start | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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 v22 → b2 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 | 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
|