foo

help

Click on a value or block to toggle highlighting of that value/block and its uses. (Values and blocks are highlighted by ID, and IDs of dead items may be reused, so not all highlights necessarily correspond to the clicked item.)

Faded out values and blocks are dead code that has not been eliminated.

Values printed in italics have a dependency cycle.

start

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v4 (?) = LocalAddr <*int> {r} v2 v1
    • v5 (?) = Const64 <int> [0]
    • v6 (3) = VarDef <mem> {r} v1
    • v7 (3) = LocalAddr <*int> {r} v2 v6
    • v8 (3) = Store <mem> {int} v7 v5 v6
    • v9 (?) = Const64 <int> [5]
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LocalAddr <*int> {t} v2 v10
    • v12 (4) = Store <mem> {int} v11 v9 v10
    • v13 (?) = Addr <*func(*int)> {"".foo.func1·f} v3
    • v14 (5) = LocalAddr <*int> {t} v2 v12
    • v15 (?) = OffPtr <**int> [16] v2
    • v16 (7) = Store <mem> {*int} v15 v14 v12
    • v17 (?) = Const32 <uint32> [8]
    • v18 (?) = OffPtr <*uint32> [0] v2
    • v19 (5) = Store <mem> {uint32} v18 v17 v16
    • v20 (?) = OffPtr <*uintptr> [8] v2
    • v21 (5) = Store <mem> {uintptr} v20 v13 v19
    • v22 (5) = StaticCall <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v25 (8) = Copy <mem> v22
    • v26 (8) = StaticCall <mem> {runtime.deferreturn} v25
  • Ret v26 (line +8)
  • b3: ← b1
    • v23 (5) = Copy <mem> v22
    • v24 (5) = StaticCall <mem> {runtime.deferreturn} v23
  • Ret v24 (line 5)

number lines [2707 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v4 (?) = LocalAddr <*int> {r} v2 v1
    • v5 (?) = Const64 <int> [0]
    • v6 (3) = VarDef <mem> {r} v1
    • v7 (3) = LocalAddr <*int> {r} v2 v6
    • v8 (+3) = Store <mem> {int} v7 v5 v6
    • v9 (?) = Const64 <int> [5]
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LocalAddr <*int> {t} v2 v10
    • v12 (+4) = Store <mem> {int} v11 v9 v10
    • v13 (?) = Addr <*func(*int)> {"".foo.func1·f} v3
    • v14 (+5) = LocalAddr <*int> {t} v2 v12
    • v15 (?) = OffPtr <**int> [16] v2
    • v16 (+7) = Store <mem> {*int} v15 v14 v12
    • v17 (?) = Const32 <uint32> [8]
    • v18 (?) = OffPtr <*uint32> [0] v2
    • v19 (+5) = Store <mem> {uint32} v18 v17 v16
    • v20 (?) = OffPtr <*uintptr> [8] v2
    • v21 (5) = Store <mem> {uintptr} v20 v13 v19
    • v22 (5) = StaticCall <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v25 (8) = Copy <mem> v22
    • v26 (+8) = StaticCall <mem> {runtime.deferreturn} v25
  • Ret v26 (line +8)
  • b3: ← b1
    • v23 (5) = Copy <mem> v22
    • v24 (5) = StaticCall <mem> {runtime.deferreturn} v23
  • Ret v24 (line 5)

early phielim [884 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v4 (?) = LocalAddr <*int> {r} v2 v1
    • v5 (?) = Const64 <int> [0]
    • v6 (3) = VarDef <mem> {r} v1
    • v7 (3) = LocalAddr <*int> {r} v2 v6
    • v8 (+3) = Store <mem> {int} v7 v5 v6
    • v9 (?) = Const64 <int> [5]
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LocalAddr <*int> {t} v2 v10
    • v12 (+4) = Store <mem> {int} v11 v9 v10
    • v13 (?) = Addr <*func(*int)> {"".foo.func1·f} v3
    • v14 (+5) = LocalAddr <*int> {t} v2 v12
    • v15 (?) = OffPtr <**int> [16] v2
    • v16 (+7) = Store <mem> {*int} v15 v14 v12
    • v17 (?) = Const32 <uint32> [8]
    • v18 (?) = OffPtr <*uint32> [0] v2
    • v19 (+5) = Store <mem> {uint32} v18 v17 v16
    • v20 (?) = OffPtr <*uintptr> [8] v2
    • v21 (5) = Store <mem> {uintptr} v20 v13 v19
    • v22 (5) = StaticCall <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v25 (8) = Copy <mem> v22
    • v26 (+8) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v23 (5) = Copy <mem> v22
    • v24 (5) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

early copyelim [723 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v4 (?) = LocalAddr <*int> {r} v2 v1
    • v5 (?) = Const64 <int> [0]
    • v6 (3) = VarDef <mem> {r} v1
    • v7 (3) = LocalAddr <*int> {r} v2 v6
    • v8 (+3) = Store <mem> {int} v7 v5 v6
    • v9 (?) = Const64 <int> [5]
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LocalAddr <*int> {t} v2 v10
    • v12 (+4) = Store <mem> {int} v11 v9 v10
    • v13 (?) = Addr <*func(*int)> {"".foo.func1·f} v3
    • v14 (+5) = LocalAddr <*int> {t} v2 v12
    • v15 (?) = OffPtr <**int> [16] v2
    • v16 (+7) = Store <mem> {*int} v15 v14 v12
    • v17 (?) = Const32 <uint32> [8]
    • v18 (?) = OffPtr <*uint32> [0] v2
    • v19 (+5) = Store <mem> {uint32} v18 v17 v16
    • v20 (?) = OffPtr <*uintptr> [8] v2
    • v21 (5) = Store <mem> {uintptr} v20 v13 v19
    • v22 (5) = StaticCall <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v25 (8) = Copy <mem> v22
    • v26 (+8) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v23 (5) = Copy <mem> v22
    • v24 (5) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

early deadcode [5075 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v5 (?) = Const64 <int> [0]
    • v6 (3) = VarDef <mem> {r} v1
    • v7 (3) = LocalAddr <*int> {r} v2 v6
    • v8 (+3) = Store <mem> {int} v7 v5 v6
    • v9 (?) = Const64 <int> [5]
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LocalAddr <*int> {t} v2 v10
    • v12 (+4) = Store <mem> {int} v11 v9 v10
    • v13 (?) = Addr <*func(*int)> {"".foo.func1·f} v3
    • v14 (+5) = LocalAddr <*int> {t} v2 v12
    • v15 (?) = OffPtr <**int> [16] v2
    • v16 (+7) = Store <mem> {*int} v15 v14 v12
    • v17 (?) = Const32 <uint32> [8]
    • v18 (?) = OffPtr <*uint32> [0] v2
    • v19 (+5) = Store <mem> {uint32} v18 v17 v16
    • v20 (?) = OffPtr <*uintptr> [8] v2
    • v21 (5) = Store <mem> {uintptr} v20 v13 v19
    • v22 (5) = StaticCall <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

short circuit [907 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v5 (?) = Const64 <int> [0]
    • v6 (3) = VarDef <mem> {r} v1
    • v7 (3) = LocalAddr <*int> {r} v2 v6
    • v8 (+3) = Store <mem> {int} v7 v5 v6
    • v9 (?) = Const64 <int> [5]
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LocalAddr <*int> {t} v2 v10
    • v12 (+4) = Store <mem> {int} v11 v9 v10
    • v13 (?) = Addr <*func(*int)> {"".foo.func1·f} v3
    • v14 (+5) = LocalAddr <*int> {t} v2 v12
    • v15 (?) = OffPtr <**int> [16] v2
    • v16 (+7) = Store <mem> {*int} v15 v14 v12
    • v17 (?) = Const32 <uint32> [8]
    • v18 (?) = OffPtr <*uint32> [0] v2
    • v19 (+5) = Store <mem> {uint32} v18 v17 v16
    • v20 (?) = OffPtr <*uintptr> [8] v2
    • v21 (5) = Store <mem> {uintptr} v20 v13 v19
    • v22 (5) = StaticCall <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

decompose user [540 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v5 (?) = Const64 <int> [0]
    • v6 (3) = VarDef <mem> {r} v1
    • v7 (3) = LocalAddr <*int> {r} v2 v6
    • v8 (+3) = Store <mem> {int} v7 v5 v6
    • v9 (?) = Const64 <int> [5]
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LocalAddr <*int> {t} v2 v10
    • v12 (+4) = Store <mem> {int} v11 v9 v10
    • v13 (?) = Addr <*func(*int)> {"".foo.func1·f} v3
    • v14 (+5) = LocalAddr <*int> {t} v2 v12
    • v15 (?) = OffPtr <**int> [16] v2
    • v16 (+7) = Store <mem> {*int} v15 v14 v12
    • v17 (?) = Const32 <uint32> [8]
    • v18 (?) = OffPtr <*uint32> [0] v2
    • v19 (+5) = Store <mem> {uint32} v18 v17 v16
    • v20 (?) = OffPtr <*uintptr> [8] v2
    • v21 (5) = Store <mem> {uintptr} v20 v13 v19
    • v22 (5) = StaticCall <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

opt [3013 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v5 (?) = Const64 <int> [0]
    • v6 (3) = VarDef <mem> {r} v1
    • v7 (3) = LocalAddr <*int> {r} v2 v6
    • v8 (+3) = Store <mem> {int} v7 v5 v6
    • v9 (?) = Const64 <int> [5]
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LocalAddr <*int> {t} v2 v10
    • v12 (+4) = Store <mem> {int} v11 v9 v10
    • v13 (?) = Addr <*func(*int)> {"".foo.func1·f} v3
    • v14 (+5) = LocalAddr <*int> {t} v2 v12
    • v15 (?) = OffPtr <**int> [16] v2
    • v16 (+7) = Store <mem> {*int} v15 v14 v12
    • v17 (?) = Const32 <uint32> [8]
    • v18 (?) = OffPtr <*uint32> [0] v2
    • v19 (+5) = Store <mem> {uint32} v18 v17 v16
    • v20 (?) = OffPtr <*uintptr> [8] v2
    • v21 (5) = Store <mem> {uintptr} v20 v13 v19
    • v22 (5) = StaticCall <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

zero arg cse [4432 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v5 (?) = Const64 <int> [0]
    • v6 (3) = VarDef <mem> {r} v1
    • v7 (3) = LocalAddr <*int> {r} v2 v6
    • v8 (+3) = Store <mem> {int} v7 v5 v6
    • v9 (?) = Const64 <int> [5]
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LocalAddr <*int> {t} v2 v10
    • v12 (+4) = Store <mem> {int} v11 v9 v10
    • v13 (?) = Addr <*func(*int)> {"".foo.func1·f} v3
    • v14 (+5) = LocalAddr <*int> {t} v2 v12
    • v15 (?) = OffPtr <**int> [16] v2
    • v16 (+7) = Store <mem> {*int} v15 v14 v12
    • v17 (?) = Const32 <uint32> [8]
    • v18 (?) = OffPtr <*uint32> [0] v2
    • v19 (+5) = Store <mem> {uint32} v18 v17 v16
    • v20 (?) = OffPtr <*uintptr> [8] v2
    • v21 (5) = Store <mem> {uintptr} v20 v13 v19
    • v22 (5) = StaticCall <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

opt deadcode [3280 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v5 (?) = Const64 <int> [0]
    • v6 (3) = VarDef <mem> {r} v1
    • v7 (3) = LocalAddr <*int> {r} v2 v6
    • v8 (+3) = Store <mem> {int} v7 v5 v6
    • v9 (?) = Const64 <int> [5]
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LocalAddr <*int> {t} v2 v10
    • v12 (+4) = Store <mem> {int} v11 v9 v10
    • v13 (?) = Addr <*func(*int)> {"".foo.func1·f} v3
    • v14 (+5) = LocalAddr <*int> {t} v2 v12
    • v15 (?) = OffPtr <**int> [16] v2
    • v16 (+7) = Store <mem> {*int} v15 v14 v12
    • v17 (?) = Const32 <uint32> [8]
    • v18 (?) = OffPtr <*uint32> [0] v2
    • v19 (+5) = Store <mem> {uint32} v18 v17 v16
    • v20 (?) = OffPtr <*uintptr> [8] v2
    • v21 (5) = Store <mem> {uintptr} v20 v13 v19
    • v22 (5) = StaticCall <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

generic cse [19772 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v5 (?) = Const64 <int> [0]
    • v6 (3) = VarDef <mem> {r} v1
    • v7 (3) = LocalAddr <*int> {r} v2 v6
    • v8 (+3) = Store <mem> {int} v7 v5 v6
    • v9 (?) = Const64 <int> [5]
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LocalAddr <*int> {t} v2 v10
    • v12 (+4) = Store <mem> {int} v11 v9 v10
    • v13 (?) = Addr <*func(*int)> {"".foo.func1·f} v3
    • v14 (+5) = LocalAddr <*int> {t} v2 v12
    • v15 (?) = OffPtr <**int> [16] v2
    • v16 (+7) = Store <mem> {*int} v15 v14 v12
    • v17 (?) = Const32 <uint32> [8]
    • v18 (?) = OffPtr <*uint32> [0] v2
    • v19 (+5) = Store <mem> {uint32} v18 v17 v16
    • v20 (?) = OffPtr <*uintptr> [8] v2
    • v21 (5) = Store <mem> {uintptr} v20 v13 v19
    • v22 (5) = StaticCall <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

phiopt [386 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v5 (?) = Const64 <int> [0]
    • v6 (3) = VarDef <mem> {r} v1
    • v7 (3) = LocalAddr <*int> {r} v2 v6
    • v8 (+3) = Store <mem> {int} v7 v5 v6
    • v9 (?) = Const64 <int> [5]
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LocalAddr <*int> {t} v2 v10
    • v12 (+4) = Store <mem> {int} v11 v9 v10
    • v13 (?) = Addr <*func(*int)> {"".foo.func1·f} v3
    • v14 (+5) = LocalAddr <*int> {t} v2 v12
    • v15 (?) = OffPtr <**int> [16] v2
    • v16 (+7) = Store <mem> {*int} v15 v14 v12
    • v17 (?) = Const32 <uint32> [8]
    • v18 (?) = OffPtr <*uint32> [0] v2
    • v19 (+5) = Store <mem> {uint32} v18 v17 v16
    • v20 (?) = OffPtr <*uintptr> [8] v2
    • v21 (5) = Store <mem> {uintptr} v20 v13 v19
    • v22 (5) = StaticCall <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

nilcheckelim [3645 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v5 (?) = Const64 <int> [0]
    • v6 (3) = VarDef <mem> {r} v1
    • v7 (3) = LocalAddr <*int> {r} v2 v6
    • v8 (+3) = Store <mem> {int} v7 v5 v6
    • v9 (?) = Const64 <int> [5]
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LocalAddr <*int> {t} v2 v10
    • v12 (+4) = Store <mem> {int} v11 v9 v10
    • v13 (?) = Addr <*func(*int)> {"".foo.func1·f} v3
    • v14 (+5) = LocalAddr <*int> {t} v2 v12
    • v15 (?) = OffPtr <**int> [16] v2
    • v16 (+7) = Store <mem> {*int} v15 v14 v12
    • v17 (?) = Const32 <uint32> [8]
    • v18 (?) = OffPtr <*uint32> [0] v2
    • v19 (+5) = Store <mem> {uint32} v18 v17 v16
    • v20 (?) = OffPtr <*uintptr> [8] v2
    • v21 (5) = Store <mem> {uintptr} v20 v13 v19
    • v22 (5) = StaticCall <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

prove [5575 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v5 (?) = Const64 <int> [0]
    • v6 (3) = VarDef <mem> {r} v1
    • v7 (3) = LocalAddr <*int> {r} v2 v6
    • v8 (+3) = Store <mem> {int} v7 v5 v6
    • v9 (?) = Const64 <int> [5]
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LocalAddr <*int> {t} v2 v10
    • v12 (+4) = Store <mem> {int} v11 v9 v10
    • v13 (?) = Addr <*func(*int)> {"".foo.func1·f} v3
    • v14 (+5) = LocalAddr <*int> {t} v2 v12
    • v15 (?) = OffPtr <**int> [16] v2
    • v16 (+7) = Store <mem> {*int} v15 v14 v12
    • v17 (?) = Const32 <uint32> [8]
    • v18 (?) = OffPtr <*uint32> [0] v2
    • v19 (+5) = Store <mem> {uint32} v18 v17 v16
    • v20 (?) = OffPtr <*uintptr> [8] v2
    • v21 (5) = Store <mem> {uintptr} v20 v13 v19
    • v22 (5) = StaticCall <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

decompose builtin [1922 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v5 (?) = Const64 <int> [0]
    • v6 (3) = VarDef <mem> {r} v1
    • v7 (3) = LocalAddr <*int> {r} v2 v6
    • v8 (+3) = Store <mem> {int} v7 v5 v6
    • v9 (?) = Const64 <int> [5]
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LocalAddr <*int> {t} v2 v10
    • v12 (+4) = Store <mem> {int} v11 v9 v10
    • v13 (?) = Addr <*func(*int)> {"".foo.func1·f} v3
    • v14 (+5) = LocalAddr <*int> {t} v2 v12
    • v15 (?) = OffPtr <**int> [16] v2
    • v16 (+7) = Store <mem> {*int} v15 v14 v12
    • v17 (?) = Const32 <uint32> [8]
    • v18 (?) = OffPtr <*uint32> [0] v2
    • v19 (+5) = Store <mem> {uint32} v18 v17 v16
    • v20 (?) = OffPtr <*uintptr> [8] v2
    • v21 (5) = Store <mem> {uintptr} v20 v13 v19
    • v22 (5) = StaticCall <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

softfloat [273 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v5 (?) = Const64 <int> [0]
    • v6 (3) = VarDef <mem> {r} v1
    • v7 (3) = LocalAddr <*int> {r} v2 v6
    • v8 (+3) = Store <mem> {int} v7 v5 v6
    • v9 (?) = Const64 <int> [5]
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LocalAddr <*int> {t} v2 v10
    • v12 (+4) = Store <mem> {int} v11 v9 v10
    • v13 (?) = Addr <*func(*int)> {"".foo.func1·f} v3
    • v14 (+5) = LocalAddr <*int> {t} v2 v12
    • v15 (?) = OffPtr <**int> [16] v2
    • v16 (+7) = Store <mem> {*int} v15 v14 v12
    • v17 (?) = Const32 <uint32> [8]
    • v18 (?) = OffPtr <*uint32> [0] v2
    • v19 (+5) = Store <mem> {uint32} v18 v17 v16
    • v20 (?) = OffPtr <*uintptr> [8] v2
    • v21 (5) = Store <mem> {uintptr} v20 v13 v19
    • v22 (5) = StaticCall <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

late opt [3701 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v5 (?) = Const64 <int> [0]
    • v6 (3) = VarDef <mem> {r} v1
    • v7 (3) = LocalAddr <*int> {r} v2 v6
    • v8 (+3) = Store <mem> {int} v7 v5 v6
    • v9 (?) = Const64 <int> [5]
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LocalAddr <*int> {t} v2 v10
    • v12 (+4) = Store <mem> {int} v11 v9 v10
    • v13 (?) = Addr <*func(*int)> {"".foo.func1·f} v3
    • v14 (+5) = LocalAddr <*int> {t} v2 v12
    • v15 (?) = OffPtr <**int> [16] v2
    • v16 (+7) = Store <mem> {*int} v15 v14 v12
    • v17 (?) = Const32 <uint32> [8]
    • v18 (?) = OffPtr <*uint32> [0] v2
    • v19 (+5) = Store <mem> {uint32} v18 v17 v16
    • v20 (?) = OffPtr <*uintptr> [8] v2
    • v21 (5) = Store <mem> {uintptr} v20 v13 v19
    • v22 (5) = StaticCall <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

dead auto elim [5795 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v5 (?) = Const64 <int> [0]
    • v6 (3) = VarDef <mem> {r} v1
    • v7 (3) = LocalAddr <*int> {r} v2 v6
    • v8 (+3) = Store <mem> {int} v7 v5 v6
    • v9 (?) = Const64 <int> [5]
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LocalAddr <*int> {t} v2 v10
    • v12 (+4) = Store <mem> {int} v11 v9 v10
    • v13 (?) = Addr <*func(*int)> {"".foo.func1·f} v3
    • v14 (+5) = LocalAddr <*int> {t} v2 v12
    • v15 (?) = OffPtr <**int> [16] v2
    • v16 (+7) = Store <mem> {*int} v15 v14 v12
    • v17 (?) = Const32 <uint32> [8]
    • v18 (?) = OffPtr <*uint32> [0] v2
    • v19 (+5) = Store <mem> {uint32} v18 v17 v16
    • v20 (?) = OffPtr <*uintptr> [8] v2
    • v21 (5) = Store <mem> {uintptr} v20 v13 v19
    • v22 (5) = StaticCall <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

generic deadcode [2414 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v5 (?) = Const64 <int> [0]
    • v6 (3) = VarDef <mem> {r} v1
    • v7 (3) = LocalAddr <*int> {r} v2 v6
    • v8 (+3) = Store <mem> {int} v7 v5 v6
    • v9 (?) = Const64 <int> [5]
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LocalAddr <*int> {t} v2 v10
    • v12 (+4) = Store <mem> {int} v11 v9 v10
    • v13 (?) = Addr <*func(*int)> {"".foo.func1·f} v3
    • v14 (+5) = LocalAddr <*int> {t} v2 v12
    • v15 (?) = OffPtr <**int> [16] v2
    • v16 (+7) = Store <mem> {*int} v15 v14 v12
    • v17 (?) = Const32 <uint32> [8]
    • v18 (?) = OffPtr <*uint32> [0] v2
    • v19 (+5) = Store <mem> {uint32} v18 v17 v16
    • v20 (?) = OffPtr <*uintptr> [8] v2
    • v21 (5) = Store <mem> {uintptr} v20 v13 v19
    • v22 (5) = StaticCall <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

check bce [229 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v5 (?) = Const64 <int> [0]
    • v6 (3) = VarDef <mem> {r} v1
    • v7 (3) = LocalAddr <*int> {r} v2 v6
    • v8 (+3) = Store <mem> {int} v7 v5 v6
    • v9 (?) = Const64 <int> [5]
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LocalAddr <*int> {t} v2 v10
    • v12 (+4) = Store <mem> {int} v11 v9 v10
    • v13 (?) = Addr <*func(*int)> {"".foo.func1·f} v3
    • v14 (+5) = LocalAddr <*int> {t} v2 v12
    • v15 (?) = OffPtr <**int> [16] v2
    • v16 (+7) = Store <mem> {*int} v15 v14 v12
    • v17 (?) = Const32 <uint32> [8]
    • v18 (?) = OffPtr <*uint32> [0] v2
    • v19 (+5) = Store <mem> {uint32} v18 v17 v16
    • v20 (?) = OffPtr <*uintptr> [8] v2
    • v21 (5) = Store <mem> {uintptr} v20 v13 v19
    • v22 (5) = StaticCall <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

branchelim [414 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v5 (?) = Const64 <int> [0]
    • v6 (3) = VarDef <mem> {r} v1
    • v7 (3) = LocalAddr <*int> {r} v2 v6
    • v8 (+3) = Store <mem> {int} v7 v5 v6
    • v9 (?) = Const64 <int> [5]
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LocalAddr <*int> {t} v2 v10
    • v12 (+4) = Store <mem> {int} v11 v9 v10
    • v13 (?) = Addr <*func(*int)> {"".foo.func1·f} v3
    • v14 (+5) = LocalAddr <*int> {t} v2 v12
    • v15 (?) = OffPtr <**int> [16] v2
    • v16 (+7) = Store <mem> {*int} v15 v14 v12
    • v17 (?) = Const32 <uint32> [8]
    • v18 (?) = OffPtr <*uint32> [0] v2
    • v19 (+5) = Store <mem> {uint32} v18 v17 v16
    • v20 (?) = OffPtr <*uintptr> [8] v2
    • v21 (5) = Store <mem> {uintptr} v20 v13 v19
    • v22 (5) = StaticCall <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

fuse [549 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v5 (?) = Const64 <int> [0]
    • v6 (3) = VarDef <mem> {r} v1
    • v7 (3) = LocalAddr <*int> {r} v2 v6
    • v8 (+3) = Store <mem> {int} v7 v5 v6
    • v9 (?) = Const64 <int> [5]
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LocalAddr <*int> {t} v2 v10
    • v12 (+4) = Store <mem> {int} v11 v9 v10
    • v13 (?) = Addr <*func(*int)> {"".foo.func1·f} v3
    • v14 (+5) = LocalAddr <*int> {t} v2 v12
    • v15 (?) = OffPtr <**int> [16] v2
    • v16 (+7) = Store <mem> {*int} v15 v14 v12
    • v17 (?) = Const32 <uint32> [8]
    • v18 (?) = OffPtr <*uint32> [0] v2
    • v19 (+5) = Store <mem> {uint32} v18 v17 v16
    • v20 (?) = OffPtr <*uintptr> [8] v2
    • v21 (5) = Store <mem> {uintptr} v20 v13 v19
    • v22 (5) = StaticCall <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

dse [6162 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v5 (?) = Const64 <int> [0]
    • v6 (3) = VarDef <mem> {r} v1
    • v7 (3) = LocalAddr <*int> {r} v2 v6
    • v8 (+3) = Store <mem> {int} v7 v5 v6
    • v9 (?) = Const64 <int> [5]
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LocalAddr <*int> {t} v2 v10
    • v12 (+4) = Store <mem> {int} v11 v9 v10
    • v13 (?) = Addr <*func(*int)> {"".foo.func1·f} v3
    • v14 (+5) = LocalAddr <*int> {t} v2 v12
    • v15 (?) = OffPtr <**int> [16] v2
    • v16 (+7) = Store <mem> {*int} v15 v14 v12
    • v17 (?) = Const32 <uint32> [8]
    • v18 (?) = OffPtr <*uint32> [0] v2
    • v19 (+5) = Store <mem> {uint32} v18 v17 v16
    • v20 (?) = OffPtr <*uintptr> [8] v2
    • v21 (5) = Store <mem> {uintptr} v20 v13 v19
    • v22 (5) = StaticCall <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

writebarrier [887 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v5 (?) = Const64 <int> [0]
    • v6 (3) = VarDef <mem> {r} v1
    • v7 (3) = LocalAddr <*int> {r} v2 v6
    • v8 (+3) = Store <mem> {int} v7 v5 v6
    • v9 (?) = Const64 <int> [5]
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LocalAddr <*int> {t} v2 v10
    • v12 (+4) = Store <mem> {int} v11 v9 v10
    • v13 (?) = Addr <*func(*int)> {"".foo.func1·f} v3
    • v14 (+5) = LocalAddr <*int> {t} v2 v12
    • v15 (?) = OffPtr <**int> [16] v2
    • v16 (+7) = Store <mem> {*int} v15 v14 v12
    • v17 (?) = Const32 <uint32> [8]
    • v18 (?) = OffPtr <*uint32> [0] v2
    • v19 (+5) = Store <mem> {uint32} v18 v17 v16
    • v20 (?) = OffPtr <*uintptr> [8] v2
    • v21 (5) = Store <mem> {uintptr} v20 v13 v19
    • v22 (5) = StaticCall <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = StaticCall <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

lower [18115 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v5 (?) = MOVQconst <int> [0]
    • v6 (3) = VarDef <mem> {r} v1
    • v7 (3) = LEAQ <*int> {r} v2
    • v8 (+3) = MOVQstoreconst <mem> {r} [val=0,off=0] v2 v6
    • v9 (?) = MOVQconst <int> [5]
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LEAQ <*int> {t} v2
    • v12 (+4) = MOVQstoreconst <mem> {t} [val=5,off=0] v2 v10
    • v13 (?) = LEAQ <*func(*int)> {"".foo.func1·f} v3
    • v14 (+5) = LEAQ <*int> {t} v2
    • v15 (?) = LEAQ <**int> [16] v2
    • v16 (+7) = MOVQstore <mem> [16] v2 v14 v12
    • v17 (?) = MOVLconst <uint32> [8]
    • v19 (+5) = MOVLstoreconst <mem> [val=8,off=0] v2 v16
    • v20 (?) = LEAQ <*uintptr> [8] v2
    • v21 (5) = MOVQstore <mem> [8] v2 v13 v19
    • v22 (5) = CALLstatic <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

lowered cse [10606 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v5 (?) = MOVQconst <int> [0]
    • v6 (3) = VarDef <mem> {r} v1
    • v7 (3) = LEAQ <*int> {r} v2
    • v8 (+3) = MOVQstoreconst <mem> {r} [val=0,off=0] v2 v6
    • v9 (?) = MOVQconst <int> [5]
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LEAQ <*int> {t} v2
    • v12 (+4) = MOVQstoreconst <mem> {t} [val=5,off=0] v2 v10
    • v13 (?) = LEAQ <*func(*int)> {"".foo.func1·f} v3
    • v14 (+5) = LEAQ <*int> {t} v2
    • v15 (?) = LEAQ <**int> [16] v2
    • v16 (+7) = MOVQstore <mem> [16] v2 v11 v12
    • v17 (?) = MOVLconst <uint32> [8]
    • v19 (+5) = MOVLstoreconst <mem> [val=8,off=0] v2 v16
    • v20 (?) = LEAQ <*uintptr> [8] v2
    • v21 (5) = MOVQstore <mem> [8] v2 v13 v19
    • v22 (5) = CALLstatic <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

elim unread autos [1868 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v5 (?) = MOVQconst <int> [0]
    • v6 (3) = VarDef <mem> {r} v1
    • v7 (3) = LEAQ <*int> {r} v2
    • v8 (+3) = MOVQstoreconst <mem> {r} [val=0,off=0] v2 v6
    • v9 (?) = MOVQconst <int> [5]
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LEAQ <*int> {t} v2
    • v12 (+4) = MOVQstoreconst <mem> {t} [val=5,off=0] v2 v10
    • v13 (?) = LEAQ <*func(*int)> {"".foo.func1·f} v3
    • v14 (+5) = LEAQ <*int> {t} v2
    • v15 (?) = LEAQ <**int> [16] v2
    • v16 (+7) = MOVQstore <mem> [16] v2 v11 v12
    • v17 (?) = MOVLconst <uint32> [8]
    • v19 (+5) = MOVLstoreconst <mem> [val=8,off=0] v2 v16
    • v20 (?) = LEAQ <*uintptr> [8] v2
    • v21 (5) = MOVQstore <mem> [8] v2 v13 v19
    • v22 (5) = CALLstatic <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

lowered deadcode [3836 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v6 (3) = VarDef <mem> {r} v1
    • v8 (+3) = MOVQstoreconst <mem> {r} [val=0,off=0] v2 v6
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LEAQ <*int> {t} v2
    • v12 (+4) = MOVQstoreconst <mem> {t} [val=5,off=0] v2 v10
    • v13 (?) = LEAQ <*func(*int)> {"".foo.func1·f} v3
    • v16 (+7) = MOVQstore <mem> [16] v2 v11 v12
    • v19 (+5) = MOVLstoreconst <mem> [val=8,off=0] v2 v16
    • v21 (5) = MOVQstore <mem> [8] v2 v13 v19
    • v22 (5) = CALLstatic <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

checkLower [540 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v6 (3) = VarDef <mem> {r} v1
    • v8 (+3) = MOVQstoreconst <mem> {r} [val=0,off=0] v2 v6
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LEAQ <*int> {t} v2
    • v12 (+4) = MOVQstoreconst <mem> {t} [val=5,off=0] v2 v10
    • v13 (?) = LEAQ <*func(*int)> {"".foo.func1·f} v3
    • v16 (+7) = MOVQstore <mem> [16] v2 v11 v12
    • v19 (+5) = MOVLstoreconst <mem> [val=8,off=0] v2 v16
    • v21 (5) = MOVQstore <mem> [8] v2 v13 v19
    • v22 (5) = CALLstatic <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

late phielim [525 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v6 (3) = VarDef <mem> {r} v1
    • v8 (+3) = MOVQstoreconst <mem> {r} [val=0,off=0] v2 v6
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LEAQ <*int> {t} v2
    • v12 (+4) = MOVQstoreconst <mem> {t} [val=5,off=0] v2 v10
    • v13 (?) = LEAQ <*func(*int)> {"".foo.func1·f} v3
    • v16 (+7) = MOVQstore <mem> [16] v2 v11 v12
    • v19 (+5) = MOVLstoreconst <mem> [val=8,off=0] v2 v16
    • v21 (5) = MOVQstore <mem> [8] v2 v13 v19
    • v22 (5) = CALLstatic <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

late copyelim [477 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v6 (3) = VarDef <mem> {r} v1
    • v8 (+3) = MOVQstoreconst <mem> {r} [val=0,off=0] v2 v6
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LEAQ <*int> {t} v2
    • v12 (+4) = MOVQstoreconst <mem> {t} [val=5,off=0] v2 v10
    • v13 (?) = LEAQ <*func(*int)> {"".foo.func1·f} v3
    • v16 (+7) = MOVQstore <mem> [16] v2 v11 v12
    • v19 (+5) = MOVLstoreconst <mem> [val=8,off=0] v2 v16
    • v21 (5) = MOVQstore <mem> [8] v2 v13 v19
    • v22 (5) = CALLstatic <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

tighten [5487 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v6 (3) = VarDef <mem> {r} v1
    • v8 (+3) = MOVQstoreconst <mem> {r} [val=0,off=0] v2 v6
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LEAQ <*int> {t} v2
    • v12 (+4) = MOVQstoreconst <mem> {t} [val=5,off=0] v2 v10
    • v13 (?) = LEAQ <*func(*int)> {"".foo.func1·f} v3
    • v16 (+7) = MOVQstore <mem> [16] v2 v11 v12
    • v19 (+5) = MOVLstoreconst <mem> [val=8,off=0] v2 v16
    • v21 (5) = MOVQstore <mem> [8] v2 v13 v19
    • v22 (5) = CALLstatic <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

phi tighten [293 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v6 (3) = VarDef <mem> {r} v1
    • v8 (+3) = MOVQstoreconst <mem> {r} [val=0,off=0] v2 v6
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LEAQ <*int> {t} v2
    • v12 (+4) = MOVQstoreconst <mem> {t} [val=5,off=0] v2 v10
    • v13 (?) = LEAQ <*func(*int)> {"".foo.func1·f} v3
    • v16 (+7) = MOVQstore <mem> [16] v2 v11 v12
    • v19 (+5) = MOVLstoreconst <mem> [val=8,off=0] v2 v16
    • v21 (5) = MOVQstore <mem> [8] v2 v13 v19
    • v22 (5) = CALLstatic <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

late deadcode [2266 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v6 (3) = VarDef <mem> {r} v1
    • v8 (+3) = MOVQstoreconst <mem> {r} [val=0,off=0] v2 v6
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LEAQ <*int> {t} v2
    • v12 (+4) = MOVQstoreconst <mem> {t} [val=5,off=0] v2 v10
    • v13 (?) = LEAQ <*func(*int)> {"".foo.func1·f} v3
    • v16 (+7) = MOVQstore <mem> [16] v2 v11 v12
    • v19 (+5) = MOVLstoreconst <mem> [val=8,off=0] v2 v16
    • v21 (5) = MOVQstore <mem> [8] v2 v13 v19
    • v22 (5) = CALLstatic <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

critical [526 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v6 (3) = VarDef <mem> {r} v1
    • v8 (+3) = MOVQstoreconst <mem> {r} [val=0,off=0] v2 v6
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LEAQ <*int> {t} v2
    • v12 (+4) = MOVQstoreconst <mem> {t} [val=5,off=0] v2 v10
    • v13 (?) = LEAQ <*func(*int)> {"".foo.func1·f} v3
    • v16 (+7) = MOVQstore <mem> [16] v2 v11 v12
    • v19 (+5) = MOVLstoreconst <mem> [val=8,off=0] v2 v16
    • v21 (5) = MOVQstore <mem> [8] v2 v13 v19
    • v22 (5) = CALLstatic <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

likelyadjust [447 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v6 (3) = VarDef <mem> {r} v1
    • v8 (+3) = MOVQstoreconst <mem> {r} [val=0,off=0] v2 v6
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LEAQ <*int> {t} v2
    • v12 (+4) = MOVQstoreconst <mem> {t} [val=5,off=0] v2 v10
    • v13 (?) = LEAQ <*func(*int)> {"".foo.func1·f} v3
    • v16 (+7) = MOVQstore <mem> [16] v2 v11 v12
    • v19 (+5) = MOVLstoreconst <mem> [val=8,off=0] v2 v16
    • v21 (5) = MOVQstore <mem> [8] v2 v13 v19
    • v22 (5) = CALLstatic <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

layout [1818 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v6 (3) = VarDef <mem> {r} v1
    • v8 (+3) = MOVQstoreconst <mem> {r} [val=0,off=0] v2 v6
    • v10 (4) = VarDef <mem> {t} v8
    • v11 (4) = LEAQ <*int> {t} v2
    • v12 (+4) = MOVQstoreconst <mem> {t} [val=5,off=0] v2 v10
    • v13 (?) = LEAQ <*func(*int)> {"".foo.func1·f} v3
    • v16 (+7) = MOVQstore <mem> [16] v2 v11 v12
    • v19 (+5) = MOVLstoreconst <mem> [val=8,off=0] v2 v16
    • v21 (5) = MOVQstore <mem> [8] v2 v13 v19
    • v22 (5) = CALLstatic <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

schedule [5262 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v6 (3) = VarDef <mem> {r} v1
    • v2 (?) = SP <uintptr>
    • v8 (+3) = MOVQstoreconst <mem> {r} [val=0,off=0] v2 v6
    • v10 (4) = VarDef <mem> {t} v8
    • v12 (+4) = MOVQstoreconst <mem> {t} [val=5,off=0] v2 v10
    • v11 (4) = LEAQ <*int> {t} v2
    • v16 (+7) = MOVQstore <mem> [16] v2 v11 v12
    • v19 (+5) = MOVLstoreconst <mem> [val=8,off=0] v2 v16
    • v3 (?) = SB <uintptr>
    • v13 (?) = LEAQ <*func(*int)> {"".foo.func1·f} v3
    • v21 (5) = MOVQstore <mem> [8] v2 v13 v19
    • v22 (5) = CALLstatic <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

late nilcheck [1132 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v6 (3) = VarDef <mem> {r} v1
    • v2 (?) = SP <uintptr>
    • v8 (+3) = MOVQstoreconst <mem> {r} [val=0,off=0] v2 v6
    • v10 (4) = VarDef <mem> {t} v8
    • v12 (+4) = MOVQstoreconst <mem> {t} [val=5,off=0] v2 v10
    • v11 (4) = LEAQ <*int> {t} v2
    • v16 (+7) = MOVQstore <mem> [16] v2 v11 v12
    • v19 (+5) = MOVLstoreconst <mem> [val=8,off=0] v2 v16
    • v3 (?) = SB <uintptr>
    • v13 (?) = LEAQ <*func(*int)> {"".foo.func1·f} v3
    • v21 (5) = MOVQstore <mem> [8] v2 v13 v19
    • v22 (5) = CALLstatic <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

flagalloc [3773 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v6 (3) = VarDef <mem> {r} v1
    • v2 (?) = SP <uintptr>
    • v8 (+3) = MOVQstoreconst <mem> {r} [val=0,off=0] v2 v6
    • v10 (4) = VarDef <mem> {t} v8
    • v12 (+4) = MOVQstoreconst <mem> {t} [val=5,off=0] v2 v10
    • v11 (4) = LEAQ <*int> {t} v2
    • v16 (+7) = MOVQstore <mem> [16] v2 v11 v12
    • v19 (+5) = MOVLstoreconst <mem> [val=8,off=0] v2 v16
    • v3 (?) = SB <uintptr>
    • v13 (?) = LEAQ <*func(*int)> {"".foo.func1·f} v3
    • v21 (5) = MOVQstore <mem> [8] v2 v13 v19
    • v22 (5) = CALLstatic <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

regalloc [34809 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v6 (3) = VarDef <mem> {r} v1
    • v2 (?) = SP <uintptr> : SP
    • v8 (+3) = MOVQstoreconst <mem> {r} [val=0,off=0] v2 v6
    • v10 (4) = VarDef <mem> {t} v8
    • v12 (+4) = MOVQstoreconst <mem> {t} [val=5,off=0] v2 v10
    • v20 (7) = LEAQ <*int> {t} v2 : AX
    • v16 (+7) = MOVQstore <mem> [16] v2 v20 v12
    • v19 (+5) = MOVLstoreconst <mem> [val=8,off=0] v2 v16
    • v3 (?) = SB <uintptr> : SB
    • v17 (5) = LEAQ <*func(*int)> {"".foo.func1·f} v3 : AX
    • v21 (5) = MOVQstore <mem> [8] v2 v17 v19
    • v22 (5) = CALLstatic <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

loop rotate [366 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v6 (3) = VarDef <mem> {r} v1
    • v2 (?) = SP <uintptr> : SP
    • v8 (+3) = MOVQstoreconst <mem> {r} [val=0,off=0] v2 v6
    • v10 (4) = VarDef <mem> {t} v8
    • v12 (+4) = MOVQstoreconst <mem> {t} [val=5,off=0] v2 v10
    • v20 (7) = LEAQ <*int> {t} v2 : AX
    • v16 (+7) = MOVQstore <mem> [16] v2 v20 v12
    • v19 (+5) = MOVLstoreconst <mem> [val=8,off=0] v2 v16
    • v3 (?) = SB <uintptr> : SB
    • v17 (5) = LEAQ <*func(*int)> {"".foo.func1·f} v3 : AX
    • v21 (5) = MOVQstore <mem> [8] v2 v17 v19
    • v22 (5) = CALLstatic <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

stackframe [3077 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v6 (3) = VarDef <mem> {r} v1
    • v2 (?) = SP <uintptr> : SP
    • v8 (+3) = MOVQstoreconst <mem> {r} [val=0,off=0] v2 v6
    • v10 (4) = VarDef <mem> {t} v8
    • v12 (+4) = MOVQstoreconst <mem> {t} [val=5,off=0] v2 v10
    • v20 (7) = LEAQ <*int> {t} v2 : AX
    • v16 (+7) = MOVQstore <mem> [16] v2 v20 v12
    • v19 (+5) = MOVLstoreconst <mem> [val=8,off=0] v2 v16
    • v3 (?) = SB <uintptr> : SB
    • v17 (5) = LEAQ <*func(*int)> {"".foo.func1·f} v3 : AX
    • v21 (5) = MOVQstore <mem> [8] v2 v17 v19
    • v22 (5) = CALLstatic <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

trim [512 ns]

  • b1:
    • v1 (?) = InitMem <mem>
    • v6 (3) = VarDef <mem> {r} v1
    • v2 (?) = SP <uintptr> : SP
    • v8 (+3) = MOVQstoreconst <mem> {r} [val=0,off=0] v2 v6
    • v10 (4) = VarDef <mem> {t} v8
    • v12 (+4) = MOVQstoreconst <mem> {t} [val=5,off=0] v2 v10
    • v20 (7) = LEAQ <*int> {t} v2 : AX
    • v16 (+7) = MOVQstore <mem> [16] v2 v20 v12
    • v19 (+5) = MOVLstoreconst <mem> [val=8,off=0] v2 v16
    • v3 (?) = SB <uintptr> : SB
    • v17 (5) = LEAQ <*func(*int)> {"".foo.func1·f} v3 : AX
    • v21 (5) = MOVQstore <mem> [8] v2 v17 v19
    • v22 (5) = CALLstatic <mem> {runtime.deferproc} [24] v21
  • Defer v22b2 b3 (likely) (line 5)
  • b2: ← b1
    • v26 (+8) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v26 (line +8)
  • b3: ← b1
    • v24 (5) = CALLstatic <mem> {runtime.deferreturn} v22
  • Ret v24 (line 5)

genssa

# /data/app/go/src/gosrc/practice/func/defer/asm/main.go
00000 (3) TEXT "".foo(SB)
00001 (3) FUNCDATA $0, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
00002 (3) FUNCDATA $1, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
00003 (3) FUNCDATA $3, gclocals·9fb7f0986f647f17cb53dda1484e0f7a(SB)
v8
00004 (+3) PCDATA $2, $0
v8
00005 (+3) PCDATA $0, $0
v8
00006 (+3) MOVQ $0, "".r(SP)
v12
00007 (+4) MOVQ $5, "".t-8(SP)
v20
00008 (7) PCDATA $2, $1
v20
00009 (+7) LEAQ "".t-8(SP), AX
v16
00010 (+7) PCDATA $2, $0
v16
00011 (7) MOVQ AX, 16(SP)
v19
00012 (+5) MOVL $8, (SP)
v17
00013 (5) PCDATA $2, $1
v17
00014 (5) LEAQ "".foo.func1·f(SB), AX
v21
00015 (5) PCDATA $2, $0
v21
00016 (5) MOVQ AX, 8(SP)
v22
00017 (5) CALL runtime.deferproc(SB)
b1
00018 (5) TESTL AX, AX
b1
00019 (5) JNE 23
v26
00020 (+8) XCHGL AX, AX
v26
00021 (+8) CALL runtime.deferreturn(SB)
b2
00022 (8) RET
v24
00023 (5) XCHGL AX, AX
v24
00024 (5) CALL runtime.deferreturn(SB)
b3
00025 (5) RET
00026 (?) END