Benchmark_Append

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.

Press 'w' to make the columns wider, 's' to make them skinnier.

sources

 
bench_test.go
func Benchmark_Append(b *testing.B) {
	for i := 0; i < b.N; i++ {
		buf := make([]byte, 0, n)
		buf = append(buf, data...)
 
		if bug {
			if buf == nil {
				panic("nil")
			}
		}
	}
}

AST

buildssa-enter

buildssa-body

. DCL l(16)

. . NAME-main.i a(true) g(2) l(16) x(0) class(PAUTO) tc(1) assigned used int

. AS l(16) colas(true) tc(1)

. . NAME-main.i a(true) g(2) l(16) x(0) class(PAUTO) tc(1) assigned used int

. . LITERAL-0 l(16) tc(1) int

. FOR l(16) tc(1)

. . LT l(16) tc(1) hascall bool

. . . NAME-main.i a(true) g(2) l(16) x(0) class(PAUTO) tc(1) assigned used int

. . . DOTPTR l(16) x(264) tc(1) hascall main.N int

. . . . NAME-main.b a(true) g(1) l(15) x(0) class(PPARAM) esc(no) tc(1) used PTR-*testing.B

. . BLOCK l(16)

. . BLOCK-list

. . . AS l(16) tc(1) implicit(true) int

. . . . NAME-main.i a(true) g(2) l(16) x(0) class(PAUTO) tc(1) assigned used int

. . . . ADD l(16) tc(1) int

. . . . . NAME-main.i a(true) g(2) l(16) x(0) class(PAUTO) tc(1) assigned used int

. . . . . LITERAL-1 l(16) tc(1) int

. FOR-body

. . DCL l(17)

. . . NAME-main.buf a(true) g(3) l(17) x(0) class(PAUTO) tc(1) assigned used SLICE-[]byte

. . AS-init

. . . AS l(17) tc(1)

. . . . NAME-main..autotmp_3 a(true) l(17) x(0) class(PAUTO) esc(N) tc(1) addrtaken assigned used ARRAY-[1024]byte

. . AS l(17) colas(true) tc(1) hascall

. . . NAME-main.buf a(true) g(3) l(17) x(0) class(PAUTO) tc(1) assigned used SLICE-[]byte

. . . CONVNOP l(17) tc(1) hascall SLICE-[]byte

. . . . SLICEARR l(17) tc(1) hascall SLICE-[]byte

. . . . . ADDR l(17) tc(1) implicit(true) PTR-*[1024]byte

. . . . . . NAME-main..autotmp_3 a(true) l(17) x(0) class(PAUTO) esc(N) tc(1) addrtaken assigned used ARRAY-[1024]byte

. . . . SLICEARR-list<N>

. . . . . LITERAL-0 l(17) tc(1) int

. . AS-init

. . . AS l(18) tc(1)

. . . . NAME-main..autotmp_4 a(true) l(18) x(0) class(PAUTO) esc(N) tc(1) assigned used SLICE-[]byte

. . . . NAME-main.buf a(true) g(3) l(17) x(0) class(PAUTO) tc(1) assigned used SLICE-[]byte

. . . AS l(18) tc(1)

. . . . NAME-main..autotmp_5 a(true) l(18) x(0) class(PAUTO) esc(N) tc(1) assigned used int

. . . . ADD l(18) tc(1) int

. . . . . LEN l(18) tc(1) int

. . . . . . NAME-main..autotmp_4 a(true) l(18) x(0) class(PAUTO) esc(N) tc(1) assigned used SLICE-[]byte

. . . . . LEN l(18) tc(1) int

. . . . . . NAME-main.data a(true) l(13) x(0) class(PEXTERN) tc(1) used string

. . . IF l(18) tc(1)

. . . . GT l(18) tc(1) bool

. . . . . CONV l(18) tc(1) uint

. . . . . . NAME-main..autotmp_5 a(true) l(18) x(0) class(PAUTO) esc(N) tc(1) assigned used int

. . . . . CONV l(18) tc(1) uint

. . . . . . CAP l(18) tc(1) int

. . . . . . . NAME-main..autotmp_4 a(true) l(18) x(0) class(PAUTO) esc(N) tc(1) assigned used SLICE-[]byte

. . . IF-body

. . . . AS l(18) tc(1) hascall

. . . . . NAME-main..autotmp_4 a(true) l(18) x(0) class(PAUTO) esc(N) tc(1) assigned used SLICE-[]byte

. . . . . CALLFUNC l(18) tc(1) hascall SLICE-[]byte

. . . . . . NAME-runtime.growslice a(true) x(0) class(PFUNC) tc(1) used FUNC-func(*byte, []byte, int) []byte

. . . . . CALLFUNC-list

. . . . . . AS l(18) tc(1)

. . . . . . . INDREGSP-SP a(true) l(18) x(0) tc(1) addrtaken main.__ PTR-*byte

. . . . . . . ADDR a(true) l(18) tc(1) PTR-*uint8

. . . . . . . . NAME-type.uint8 a(true) x(0) class(PEXTERN) tc(1) uint8

. . . . . . AS l(18) tc(1)

. . . . . . . INDREGSP-SP a(true) l(18) x(8) tc(1) addrtaken main.__ SLICE-[]byte

. . . . . . . NAME-main..autotmp_4 a(true) l(18) x(0) class(PAUTO) esc(N) tc(1) assigned used SLICE-[]byte

. . . . . . AS l(18) tc(1)

. . . . . . . INDREGSP-SP a(true) l(18) x(32) tc(1) addrtaken main.__ int

. . . . . . . NAME-main..autotmp_5 a(true) l(18) x(0) class(PAUTO) esc(N) tc(1) assigned used int

. . . AS l(18) tc(1) hascall

. . . . NAME-main..autotmp_4 a(true) l(18) x(0) class(PAUTO) esc(N) tc(1) assigned used SLICE-[]byte

. . . . SLICE l(18) tc(1) hascall SLICE-[]byte

. . . . . NAME-main..autotmp_4 a(true) l(18) x(0) class(PAUTO) esc(N) tc(1) assigned used SLICE-[]byte

. . . . SLICE-list<N>

. . . . . NAME-main..autotmp_5 a(true) l(18) x(0) class(PAUTO) esc(N) tc(1) assigned used int

. . . AS l(18) tc(1)

. . . . NAME-main..autotmp_6 a(true) l(18) x(0) class(PAUTO) esc(N) tc(1) assigned used uintptr

. . . . CONV l(18) tc(1) uintptr

. . . . . LEN l(18) tc(1) int

. . . . . . NAME-main.data a(true) l(13) x(0) class(PEXTERN) tc(1) used string

. . . CALLFUNC l(18) tc(1) hascall

. . . . NAME-runtime.memmove a(true) x(0) class(PFUNC) tc(1) used FUNC-func(*byte, *byte, uintptr)

. . . CALLFUNC-list

. . . . AS l(18) tc(1) hascall

. . . . . INDREGSP-SP a(true) l(18) x(0) tc(1) addrtaken main.__ PTR-*byte

. . . . . ADDR l(18) tc(1) hascall PTR-*byte

. . . . . . INDEX l(18) tc(1) addrtaken bounded hascall byte

. . . . . . . NAME-main..autotmp_4 a(true) l(18) x(0) class(PAUTO) esc(N) tc(1) assigned used SLICE-[]byte

. . . . . . . LEN l(18) tc(1) int

. . . . . . . . NAME-main.buf a(true) g(3) l(17) x(0) class(PAUTO) tc(1) assigned used SLICE-[]byte

. . . . AS l(18) tc(1)

. . . . . INDREGSP-SP a(true) l(18) x(8) tc(1) addrtaken main.__ PTR-*byte

. . . . . SPTR l(18) tc(1) PTR-*uint8

. . . . . . NAME-main.data a(true) l(13) x(0) class(PEXTERN) tc(1) used string

. . . . AS l(18) tc(1)

. . . . . INDREGSP-SP a(true) l(18) x(16) tc(1) addrtaken main.__ uintptr

. . . . . MUL l(18) tc(1) uintptr

. . . . . . NAME-main..autotmp_6 a(true) l(18) x(0) class(PAUTO) esc(N) tc(1) assigned used uintptr

. . . . . . LITERAL-1 l(18) tc(1) uintptr

. . AS l(18) tc(1) hascall

. . . NAME-main.buf a(true) g(3) l(17) x(0) class(PAUTO) tc(1) assigned used SLICE-[]byte

. . . NAME-main..autotmp_4 a(true) l(18) x(0) class(PAUTO) esc(N) tc(1) assigned used SLICE-[]byte

. . IF l(20) tc(1)

. . . LITERAL-true a(true) l(10) x(1) class(PEXTERN) tc(1) main.bug bool

. . IF-body

. . . IF l(21) tc(1)

. . . . EQ l(21) tc(1) bool

. . . . . NAME-main.buf a(true) g(3) l(17) x(0) class(PAUTO) tc(1) assigned used SLICE-[]byte

. . . . . LITERAL-nil tc(1) .nil SLICE-[]byte

. . . IF-body

. . . . CALLFUNC l(22) tc(1) hascall

. . . . . NAME-runtime.gopanic a(true) x(0) class(PFUNC) tc(1) used FUNC-func(interface {})

. . . . CALLFUNC-list

. . . . . AS l(22) tc(1)

. . . . . . INDREGSP-SP a(true) l(22) x(0) tc(1) addrtaken main.__ INTER-interface {}

. . . . . . EFACE l(22) tc(1) INTER-interface {}

. . . . . . . ADDR a(true) l(22) tc(1) PTR-*uint8

. . . . . . . . NAME-type.string a(true) x(0) class(PEXTERN) tc(1) uint8

. . . . . . . ADDR l(22) tc(1) PTR-*string

. . . . . . . . NAME-main.statictmp_0 a(true) l(22) x(0) class(PEXTERN) tc(1) addrtaken used string

buildssa-exit

start

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = LocalAddr <**testing.B> {b} v2 v1
v5 (15) = Arg <*testing.B> {b}
v6 (?) = Const64 <int> [0] (i[int])
v20 (?) = Const64 <int> [1024]
v30 (?) = Addr <*string> {"".data} v3
v39 (?) = Addr <*uint8> {type.uint8} v3
v40 (?) = OffPtr <**byte> [0] v2
v44 (?) = OffPtr <*[]byte> [8] v2
v47 (?) = OffPtr <*int> [32] v2
v50 (?) = OffPtr <*[]byte> [40] v2
v64 (?) = Addr <*string> {"".data} v3
v75 (?) = Addr <*string> {"".data} v3
v78 (?) = OffPtr <**byte> [8] v2
v80 (?) = Const64 <uintptr> [1]
v82 (?) = OffPtr <*uintptr> [16] v2
v85 (?) = ConstBool <bool> [true]
v87 (?) = ConstSlice <[]byte>
v89 (?) = Addr <*uint8> {type.string} v3
v90 (?) = Addr <*string> {"".statictmp_0} v3
v92 (?) = OffPtr <*interface {}> [0] v2
v97 (?) = Const64 <int> [1]
Plain → b2 (16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v8 (16) = Phi <*testing.B> v5 v105 (b[*testing.B])
v9 (16) = Phi <mem> v1 v104
v10 (16) = NilCheck <void> v8 v9
v11 (16) = OffPtr <*int> [264] v8
v12 (16) = Load <int> v11 v9
v13 (16) = Less64 <bool> v7 v12
If v13 → b3 b5 (likely) (16)
b3: ← b2
v14 (17) = Copy <mem> v9
v15 (17) = VarDef <mem> {.autotmp_3} v14
v16 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v15
v17 (17) = Zero <mem> {[1024]byte} [1024] v16 v15
v18 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v17
v19 (17) = NilCheck <void> v18 v17
v21 (17) = IsSliceInBounds <bool> v6 v6
If v21 → b6 b7 (likely) (17)
b4: ← b15
v96 (16) = Copy <int> v102 (i[int])
v98 (16) = Add64 <int> v96 v97 (i[int])
Plain → b2 (16)
b5: ← b2
v99 (26) = Copy <mem> v9
Ret v99
b6: ← b3
v24 (17) = IsSliceInBounds <bool> v6 v20
If v24 → b8 b7 (likely) (17)
b7: ← b3 b6
v22 (17) = Copy <mem> v17
v23 (17) = StaticCall <mem> {runtime.panicslice} v22
Exit v23 (17)
b8: ← b6
v25 (17) = Sub64 <int> v6 v6
v26 (17) = Sub64 <int> v20 v6
v27 (17) = SliceMake <[]byte> v18 v25 v26
v28 (17) = Copy <[]byte> v27 (buf[[]byte])
v29 (18) = SliceLen <int> v28
v31 (18) = Copy <mem> v17
v32 (18) = Load <string> v30 v31
v33 (18) = StringLen <int> v32
v34 (18) = Add64 <int> v29 v33
v35 (18) = Copy <uint> v34
v36 (18) = SliceCap <int> v28
v37 (18) = Copy <uint> v36
v38 (18) = Greater64U <bool> v35 v37
If v38 → b9 b10 (18)
b9: ← b8
v41 (18) = Copy <mem> v31
v42 (18) = Store <mem> {*byte} v40 v39 v41
v43 (18) = Copy <[]byte> v28
v45 (18) = Store <mem> {[]byte} v44 v43 v42
v46 (18) = Copy <int> v34
v48 (18) = Store <mem> {int} v47 v46 v45
v49 (18) = StaticCall <mem> {runtime.growslice} [64] v48
v51 (18) = Load <[]byte> v50 v49
Plain → b10 (18)
b10: ← b8 b9
v52 (18) = Phi <[]byte> v28 v51
v53 (18) = Phi <int> v34 v46
v101 (18) = Phi <mem> v31 v49
v54 (18) = SlicePtr <*byte> v52
v55 (18) = SliceLen <int> v52
v56 (18) = SliceCap <int> v52
v57 (18) = IsSliceInBounds <bool> v6 v53
v100 (18) = Copy <[]byte> v28 (buf[[]byte])
v103 (16) = Copy <int> v7 (i[int])
v106 (16) = Copy <*testing.B> v8 (b[*testing.B])
If v57 → b11 b12 (likely) (18)
b11: ← b10
v60 (18) = IsSliceInBounds <bool> v53 v56
If v60 → b13 b12 (likely) (18)
b12: ← b10 b11
v58 (18) = Copy <mem> v101
v59 (18) = StaticCall <mem> {runtime.panicslice} v58
Exit v59 (18)
b13: ← b11
v61 (18) = Sub64 <int> v53 v6
v62 (18) = Sub64 <int> v56 v6
v63 (18) = SliceMake <[]byte> v54 v61 v62 (buf[[]byte])
v65 (18) = Copy <mem> v101
v66 (18) = Load <string> v64 v65
v67 (18) = StringLen <int> v66
v68 (18) = Copy <uintptr> v67
v69 (18) = Copy <[]byte> v100 (buf[[]byte])
v70 (18) = SliceLen <int> v69
v71 (18) = SliceLen <int> v63
v72 (18) = SlicePtr <*byte> v63
v73 (18) = PtrIndex <*byte> v72 v70
v74 (18) = Store <mem> {*byte} v40 v73 v65
v76 (18) = Load <string> v75 v74
v77 (18) = StringPtr <*uint8> v76
v79 (18) = Store <mem> {*byte} v78 v77 v74
v81 (18) = Mul64 <uintptr> v68 v80
v83 (18) = Store <mem> {uintptr} v82 v81 v79
v84 (18) = StaticCall <mem> {runtime.memmove} [24] v83
If v85 → b14 b15 (20)
b14: ← b13
v86 (21) = Copy <[]byte> v63 (buf[[]byte])
v88 (21) = EqSlice <bool> v86 v87
If v88 → b16 b17 (21)
b15: ← b13 b17
v102 (16) = Copy <int> v103 (i[int])
v104 (16) = Copy <mem> v84
v105 (16) = Copy <*testing.B> v106 (b[*testing.B])
Plain → b4 (16)
b16: ← b14
v91 (22) = IMake <interface {}> v89 v90
v93 (22) = Copy <mem> v84
v94 (22) = Store <mem> {interface {}} v92 v91 v93
v95 (22) = StaticCall <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17: ← b14
Plain → b15 (16)
name i[int]: v6 v7 v96 v98 v102 v103 
name b[*testing.B]: v8 v105 v106 
name buf[[]byte]: v28 v69 v63 v86 v100

number lines

number lines [16964 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = LocalAddr <**testing.B> {b} v2 v1
v5 (15) = Arg <*testing.B> {b}
v6 (?) = Const64 <int> [0] (i[int])
v20 (?) = Const64 <int> [1024]
v30 (?) = Addr <*string> {"".data} v3
v39 (?) = Addr <*uint8> {type.uint8} v3
v40 (?) = OffPtr <**byte> [0] v2
v44 (?) = OffPtr <*[]byte> [8] v2
v47 (?) = OffPtr <*int> [32] v2
v50 (?) = OffPtr <*[]byte> [40] v2
v64 (?) = Addr <*string> {"".data} v3
v75 (?) = Addr <*string> {"".data} v3
v78 (?) = OffPtr <**byte> [8] v2
v80 (?) = Const64 <uintptr> [1]
v82 (?) = OffPtr <*uintptr> [16] v2
v85 (?) = ConstBool <bool> [true]
v87 (?) = ConstSlice <[]byte>
v89 (?) = Addr <*uint8> {type.string} v3
v90 (?) = Addr <*string> {"".statictmp_0} v3
v92 (?) = OffPtr <*interface {}> [0] v2
v97 (?) = Const64 <int> [1]
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v8 (16) = Phi <*testing.B> v5 v105 (b[*testing.B])
v9 (16) = Phi <mem> v1 v104
v10 (+16) = NilCheck <void> v8 v9
v11 (16) = OffPtr <*int> [264] v8
v12 (16) = Load <int> v11 v9
v13 (16) = Less64 <bool> v7 v12
If v13 → b3 b5 (likely) (16)
b3: ← b2
v14 (17) = Copy <mem> v9
v15 (17) = VarDef <mem> {.autotmp_3} v14
v16 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v15
v17 (+17) = Zero <mem> {[1024]byte} [1024] v16 v15
v18 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v17
v19 (17) = NilCheck <void> v18 v17
v21 (17) = IsSliceInBounds <bool> v6 v6
If v21 → b6 b7 (likely) (17)
b4: ← b15
v96 (16) = Copy <int> v102 (i[int])
v98 (+16) = Add64 <int> v96 v97 (i[int])
Plain → b2 (16)
b5: ← b2
v99 (26) = Copy <mem> v9
Ret v99
b6: ← b3
v24 (17) = IsSliceInBounds <bool> v6 v20
If v24 → b8 b7 (likely) (17)
b7: ← b3 b6
v22 (17) = Copy <mem> v17
v23 (17) = StaticCall <mem> {runtime.panicslice} v22
Exit v23 (17)
b8: ← b6
v25 (17) = Sub64 <int> v6 v6
v26 (17) = Sub64 <int> v20 v6
v27 (17) = SliceMake <[]byte> v18 v25 v26
v28 (17) = Copy <[]byte> v27 (buf[[]byte])
v29 (+18) = SliceLen <int> v28
v31 (18) = Copy <mem> v17
v32 (18) = Load <string> v30 v31
v33 (18) = StringLen <int> v32
v34 (18) = Add64 <int> v29 v33
v35 (18) = Copy <uint> v34
v36 (18) = SliceCap <int> v28
v37 (18) = Copy <uint> v36
v38 (18) = Greater64U <bool> v35 v37
If v38 → b9 b10 (18)
b9: ← b8
v41 (18) = Copy <mem> v31
v42 (18) = Store <mem> {*byte} v40 v39 v41
v43 (18) = Copy <[]byte> v28
v45 (18) = Store <mem> {[]byte} v44 v43 v42
v46 (18) = Copy <int> v34
v48 (18) = Store <mem> {int} v47 v46 v45
v49 (18) = StaticCall <mem> {runtime.growslice} [64] v48
v51 (18) = Load <[]byte> v50 v49
Plain → b10 (18)
b10: ← b8 b9
v52 (18) = Phi <[]byte> v28 v51
v53 (18) = Phi <int> v34 v46
v101 (18) = Phi <mem> v31 v49
v54 (18) = SlicePtr <*byte> v52
v55 (18) = SliceLen <int> v52
v56 (18) = SliceCap <int> v52
v57 (18) = IsSliceInBounds <bool> v6 v53
v100 (18) = Copy <[]byte> v28 (buf[[]byte])
v103 (16) = Copy <int> v7 (i[int])
v106 (16) = Copy <*testing.B> v8 (b[*testing.B])
If v57 → b11 b12 (likely) (18)
b11: ← b10
v60 (18) = IsSliceInBounds <bool> v53 v56
If v60 → b13 b12 (likely) (18)
b12: ← b10 b11
v58 (18) = Copy <mem> v101
v59 (18) = StaticCall <mem> {runtime.panicslice} v58
Exit v59 (18)
b13: ← b11
v61 (18) = Sub64 <int> v53 v6
v62 (18) = Sub64 <int> v56 v6
v63 (18) = SliceMake <[]byte> v54 v61 v62 (buf[[]byte])
v65 (18) = Copy <mem> v101
v66 (18) = Load <string> v64 v65
v67 (18) = StringLen <int> v66
v68 (18) = Copy <uintptr> v67
v69 (18) = Copy <[]byte> v100 (buf[[]byte])
v70 (18) = SliceLen <int> v69
v71 (18) = SliceLen <int> v63
v72 (18) = SlicePtr <*byte> v63
v73 (18) = PtrIndex <*byte> v72 v70
v74 (18) = Store <mem> {*byte} v40 v73 v65
v76 (18) = Load <string> v75 v74
v77 (18) = StringPtr <*uint8> v76
v79 (18) = Store <mem> {*byte} v78 v77 v74
v81 (18) = Mul64 <uintptr> v68 v80
v83 (18) = Store <mem> {uintptr} v82 v81 v79
v84 (18) = StaticCall <mem> {runtime.memmove} [24] v83
If v85 → b14 b15 (+20)
b14: ← b13
v86 (21) = Copy <[]byte> v63 (buf[[]byte])
v88 (+21) = EqSlice <bool> v86 v87
If v88 → b16 b17 (21)
b15: ← b13 b17
v102 (16) = Copy <int> v103 (i[int])
v104 (16) = Copy <mem> v84
v105 (16) = Copy <*testing.B> v106 (b[*testing.B])
Plain → b4 (16)
b16: ← b14
v91 (+22) = IMake <interface {}> v89 v90
v93 (22) = Copy <mem> v84
v94 (22) = Store <mem> {interface {}} v92 v91 v93
v95 (22) = StaticCall <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17: ← b14
Plain → b15 (16)
name i[int]: v6 v7 v96 v98 v102 v103 
name b[*testing.B]: v8 v105 v106 
name buf[[]byte]: v28 v69 v63 v86 v100

early phielim

early phielim [5544 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = LocalAddr <**testing.B> {b} v2 v1
v5 (15) = Arg <*testing.B> {b}
v6 (?) = Const64 <int> [0] (i[int])
v20 (?) = Const64 <int> [1024]
v30 (?) = Addr <*string> {"".data} v3
v39 (?) = Addr <*uint8> {type.uint8} v3
v40 (?) = OffPtr <**byte> [0] v2
v44 (?) = OffPtr <*[]byte> [8] v2
v47 (?) = OffPtr <*int> [32] v2
v50 (?) = OffPtr <*[]byte> [40] v2
v64 (?) = Addr <*string> {"".data} v3
v75 (?) = Addr <*string> {"".data} v3
v78 (?) = OffPtr <**byte> [8] v2
v80 (?) = Const64 <uintptr> [1]
v82 (?) = OffPtr <*uintptr> [16] v2
v85 (?) = ConstBool <bool> [true]
v87 (?) = ConstSlice <[]byte>
v89 (?) = Addr <*uint8> {type.string} v3
v90 (?) = Addr <*string> {"".statictmp_0} v3
v92 (?) = OffPtr <*interface {}> [0] v2
v97 (?) = Const64 <int> [1]
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v8 (16) = Copy <*testing.B> v5 (b[*testing.B])
v10 (+16) = NilCheck <void> v5 v9
v11 (16) = OffPtr <*int> [264] v5
v12 (16) = Load <int> v11 v9
v13 (16) = Less64 <bool> v7 v12
If v13 → b3 b5 (likely) (16)
b3: ← b2
v14 (17) = Copy <mem> v9
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v15
v17 (+17) = Zero <mem> {[1024]byte} [1024] v16 v15
v18 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v17
v19 (17) = NilCheck <void> v18 v17
v21 (17) = IsSliceInBounds <bool> v6 v6
If v21 → b6 b7 (likely) (17)
b4: ← b15
v96 (16) = Copy <int> v7 (i[int])
v98 (+16) = Add64 <int> v7 v97 (i[int])
Plain → b2 (16)
b5: ← b2
v99 (26) = Copy <mem> v9
Ret v99
b6: ← b3
v24 (17) = IsSliceInBounds <bool> v6 v20
If v24 → b8 b7 (likely) (17)
b7: ← b3 b6
v22 (17) = Copy <mem> v17
v23 (17) = StaticCall <mem> {runtime.panicslice} v17
Exit v23 (17)
b8: ← b6
v25 (17) = Sub64 <int> v6 v6
v26 (17) = Sub64 <int> v20 v6
v27 (17) = SliceMake <[]byte> v18 v25 v26
v28 (17) = Copy <[]byte> v27 (buf[[]byte])
v29 (+18) = SliceLen <int> v27
v31 (18) = Copy <mem> v17
v32 (18) = Load <string> v30 v17
v33 (18) = StringLen <int> v32
v34 (18) = Add64 <int> v29 v33
v35 (18) = Copy <uint> v34
v36 (18) = SliceCap <int> v27
v37 (18) = Copy <uint> v36
v38 (18) = Greater64U <bool> v34 v36
If v38 → b9 b10 (18)
b9: ← b8
v41 (18) = Copy <mem> v17
v42 (18) = Store <mem> {*byte} v40 v39 v17
v43 (18) = Copy <[]byte> v27
v45 (18) = Store <mem> {[]byte} v44 v27 v42
v46 (18) = Copy <int> v34
v48 (18) = Store <mem> {int} v47 v34 v45
v49 (18) = StaticCall <mem> {runtime.growslice} [64] v48
v51 (18) = Load <[]byte> v50 v49
Plain → b10 (18)
b10: ← b8 b9
v52 (18) = Phi <[]byte> v27 v51
v101 (18) = Phi <mem> v17 v49
v53 (18) = Copy <int> v34
v54 (18) = SlicePtr <*byte> v52
v55 (18) = SliceLen <int> v52
v56 (18) = SliceCap <int> v52
v57 (18) = IsSliceInBounds <bool> v6 v34
v100 (18) = Copy <[]byte> v27 (buf[[]byte])
v103 (16) = Copy <int> v7 (i[int])
v106 (16) = Copy <*testing.B> v5 (b[*testing.B])
If v57 → b11 b12 (likely) (18)
b11: ← b10
v60 (18) = IsSliceInBounds <bool> v34 v56
If v60 → b13 b12 (likely) (18)
b12: ← b10 b11
v58 (18) = Copy <mem> v101
v59 (18) = StaticCall <mem> {runtime.panicslice} v101
Exit v59 (18)
b13: ← b11
v61 (18) = Sub64 <int> v34 v6
v62 (18) = Sub64 <int> v56 v6
v63 (18) = SliceMake <[]byte> v54 v61 v62 (buf[[]byte])
v65 (18) = Copy <mem> v101
v66 (18) = Load <string> v64 v101
v67 (18) = StringLen <int> v66
v68 (18) = Copy <uintptr> v67
v69 (18) = Copy <[]byte> v27 (buf[[]byte])
v70 (18) = SliceLen <int> v27
v71 (18) = SliceLen <int> v63
v72 (18) = SlicePtr <*byte> v63
v73 (18) = PtrIndex <*byte> v72 v70
v74 (18) = Store <mem> {*byte} v40 v73 v101
v76 (18) = Load <string> v75 v74
v77 (18) = StringPtr <*uint8> v76
v79 (18) = Store <mem> {*byte} v78 v77 v74
v81 (18) = Mul64 <uintptr> v67 v80
v83 (18) = Store <mem> {uintptr} v82 v81 v79
v84 (18) = StaticCall <mem> {runtime.memmove} [24] v83
If v85 → b14 b15 (+20)
b14: ← b13
v86 (21) = Copy <[]byte> v63 (buf[[]byte])
v88 (+21) = EqSlice <bool> v63 v87
If v88 → b16 b17 (21)
b15: ← b13 b17
v102 (16) = Copy <int> v7 (i[int])
v104 (16) = Copy <mem> v84
v105 (16) = Copy <*testing.B> v5 (b[*testing.B])
Plain → b4 (16)
b16: ← b14
v91 (+22) = IMake <interface {}> v89 v90
v93 (22) = Copy <mem> v84
v94 (22) = Store <mem> {interface {}} v92 v91 v84
v95 (22) = StaticCall <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17: ← b14
Plain → b15 (16)
name i[int]: v6 v7 v96 v98 v102 v103 
name b[*testing.B]: v8 v105 v106 
name buf[[]byte]: v28 v69 v63 v86 v100

early copyelim

early copyelim [2698 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = LocalAddr <**testing.B> {b} v2 v1
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = Const64 <int> [0] (i[int])
v20 (?) = Const64 <int> [1024]
v30 (?) = Addr <*string> {"".data} v3
v39 (?) = Addr <*uint8> {type.uint8} v3
v40 (?) = OffPtr <**byte> [0] v2
v44 (?) = OffPtr <*[]byte> [8] v2
v47 (?) = OffPtr <*int> [32] v2
v50 (?) = OffPtr <*[]byte> [40] v2
v64 (?) = Addr <*string> {"".data} v3
v75 (?) = Addr <*string> {"".data} v3
v78 (?) = OffPtr <**byte> [8] v2
v80 (?) = Const64 <uintptr> [1]
v82 (?) = OffPtr <*uintptr> [16] v2
v85 (?) = ConstBool <bool> [true]
v87 (?) = ConstSlice <[]byte>
v89 (?) = Addr <*uint8> {type.string} v3
v90 (?) = Addr <*string> {"".statictmp_0} v3
v92 (?) = OffPtr <*interface {}> [0] v2
v97 (?) = Const64 <int> [1]
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v8 (16) = Copy <*testing.B> v5
v10 (+16) = NilCheck <void> v5 v9
v11 (16) = OffPtr <*int> [264] v5
v12 (16) = Load <int> v11 v9
v13 (16) = Less64 <bool> v7 v12
If v13 → b3 b5 (likely) (16)
b3: ← b2
v14 (17) = Copy <mem> v9
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v15
v17 (+17) = Zero <mem> {[1024]byte} [1024] v16 v15
v18 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v17
v19 (17) = NilCheck <void> v18 v17
v21 (17) = IsSliceInBounds <bool> v6 v6
If v21 → b6 b7 (likely) (17)
b4: ← b15
v96 (16) = Copy <int> v7
v98 (+16) = Add64 <int> v7 v97 (i[int])
Plain → b2 (16)
b5: ← b2
v99 (26) = Copy <mem> v9
Ret v9
b6: ← b3
v24 (17) = IsSliceInBounds <bool> v6 v20
If v24 → b8 b7 (likely) (17)
b7: ← b3 b6
v22 (17) = Copy <mem> v17
v23 (17) = StaticCall <mem> {runtime.panicslice} v17
Exit v23 (17)
b8: ← b6
v25 (17) = Sub64 <int> v6 v6
v26 (17) = Sub64 <int> v20 v6
v27 (17) = SliceMake <[]byte> v18 v25 v26 (buf[[]byte])
v28 (17) = Copy <[]byte> v27
v29 (+18) = SliceLen <int> v27
v31 (18) = Copy <mem> v17
v32 (18) = Load <string> v30 v17
v33 (18) = StringLen <int> v32
v34 (18) = Add64 <int> v29 v33
v35 (18) = Copy <uint> v34
v36 (18) = SliceCap <int> v27
v37 (18) = Copy <uint> v36
v38 (18) = Greater64U <bool> v34 v36
If v38 → b9 b10 (18)
b9: ← b8
v41 (18) = Copy <mem> v17
v42 (18) = Store <mem> {*byte} v40 v39 v17
v43 (18) = Copy <[]byte> v27
v45 (18) = Store <mem> {[]byte} v44 v27 v42
v46 (18) = Copy <int> v34
v48 (18) = Store <mem> {int} v47 v34 v45
v49 (18) = StaticCall <mem> {runtime.growslice} [64] v48
v51 (18) = Load <[]byte> v50 v49
Plain → b10 (18)
b10: ← b8 b9
v52 (18) = Phi <[]byte> v27 v51
v101 (18) = Phi <mem> v17 v49
v53 (18) = Copy <int> v34
v54 (18) = SlicePtr <*byte> v52
v55 (18) = SliceLen <int> v52
v56 (18) = SliceCap <int> v52
v57 (18) = IsSliceInBounds <bool> v6 v34
v100 (18) = Copy <[]byte> v27
v103 (16) = Copy <int> v7
v106 (16) = Copy <*testing.B> v5
If v57 → b11 b12 (likely) (18)
b11: ← b10
v60 (18) = IsSliceInBounds <bool> v34 v56
If v60 → b13 b12 (likely) (18)
b12: ← b10 b11
v58 (18) = Copy <mem> v101
v59 (18) = StaticCall <mem> {runtime.panicslice} v101
Exit v59 (18)
b13: ← b11
v61 (18) = Sub64 <int> v34 v6
v62 (18) = Sub64 <int> v56 v6
v63 (18) = SliceMake <[]byte> v54 v61 v62 (buf[[]byte])
v65 (18) = Copy <mem> v101
v66 (18) = Load <string> v64 v101
v67 (18) = StringLen <int> v66
v68 (18) = Copy <uintptr> v67
v69 (18) = Copy <[]byte> v27
v70 (18) = SliceLen <int> v27
v71 (18) = SliceLen <int> v63
v72 (18) = SlicePtr <*byte> v63
v73 (18) = PtrIndex <*byte> v72 v70
v74 (18) = Store <mem> {*byte} v40 v73 v101
v76 (18) = Load <string> v75 v74
v77 (18) = StringPtr <*uint8> v76
v79 (18) = Store <mem> {*byte} v78 v77 v74
v81 (18) = Mul64 <uintptr> v67 v80
v83 (18) = Store <mem> {uintptr} v82 v81 v79
v84 (18) = StaticCall <mem> {runtime.memmove} [24] v83
If v85 → b14 b15 (+20)
b14: ← b13
v86 (21) = Copy <[]byte> v63
v88 (+21) = EqSlice <bool> v63 v87
If v88 → b16 b17 (21)
b15: ← b13 b17
v102 (16) = Copy <int> v7
v104 (16) = Copy <mem> v84
v105 (16) = Copy <*testing.B> v5
Plain → b4 (16)
b16: ← b14
v91 (+22) = IMake <interface {}> v89 v90
v93 (22) = Copy <mem> v84
v94 (22) = Store <mem> {interface {}} v92 v91 v84
v95 (22) = StaticCall <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17: ← b14
Plain → b15 (16)
name i[int]: v6 v7 v7 v98 v7 v7 
name b[*testing.B]: v5 v5 v5 
name buf[[]byte]: v27 v27 v63 v63 v27

early deadcode

early deadcode [20996 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = Const64 <int> [0] (i[int])
v20 (?) = Const64 <int> [1024]
v30 (?) = Addr <*string> {"".data} v3
v39 (?) = Addr <*uint8> {type.uint8} v3
v40 (?) = OffPtr <**byte> [0] v2
v44 (?) = OffPtr <*[]byte> [8] v2
v47 (?) = OffPtr <*int> [32] v2
v50 (?) = OffPtr <*[]byte> [40] v2
v64 (?) = Addr <*string> {"".data} v3
v75 (?) = Addr <*string> {"".data} v3
v78 (?) = OffPtr <**byte> [8] v2
v80 (?) = Const64 <uintptr> [1]
v82 (?) = OffPtr <*uintptr> [16] v2
v85 (?) = ConstBool <bool> [true]
v87 (?) = ConstSlice <[]byte>
v89 (?) = Addr <*uint8> {type.string} v3
v90 (?) = Addr <*string> {"".statictmp_0} v3
v92 (?) = OffPtr <*interface {}> [0] v2
v97 (?) = Const64 <int> [1]
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v10 (+16) = NilCheck <void> v5 v9
v11 (16) = OffPtr <*int> [264] v5
v12 (16) = Load <int> v11 v9
v13 (16) = Less64 <bool> v7 v12
If v13 → b3 b5 (likely) (16)
b3: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v15
v17 (+17) = Zero <mem> {[1024]byte} [1024] v16 v15
v18 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v17
v19 (17) = NilCheck <void> v18 v17
v21 (17) = IsSliceInBounds <bool> v6 v6
If v21 → b6 b7 (likely) (17)
b4: ← b15
v98 (+16) = Add64 <int> v7 v97 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b6: ← b3
v24 (17) = IsSliceInBounds <bool> v6 v20
If v24 → b8 b7 (likely) (17)
b7: ← b3 b6
v23 (17) = StaticCall <mem> {runtime.panicslice} v17
Exit v23 (17)
b8: ← b6
v25 (17) = Sub64 <int> v6 v6
v26 (17) = Sub64 <int> v20 v6
v27 (17) = SliceMake <[]byte> v18 v25 v26 (buf[[]byte])
v29 (+18) = SliceLen <int> v27
v32 (18) = Load <string> v30 v17
v33 (18) = StringLen <int> v32
v34 (18) = Add64 <int> v29 v33
v36 (18) = SliceCap <int> v27
v38 (18) = Greater64U <bool> v34 v36
If v38 → b9 b10 (18)
b9: ← b8
v42 (18) = Store <mem> {*byte} v40 v39 v17
v45 (18) = Store <mem> {[]byte} v44 v27 v42
v48 (18) = Store <mem> {int} v47 v34 v45
v49 (18) = StaticCall <mem> {runtime.growslice} [64] v48
v51 (18) = Load <[]byte> v50 v49
Plain → b10 (18)
b10: ← b8 b9
v52 (18) = Phi <[]byte> v27 v51
v101 (18) = Phi <mem> v17 v49
v54 (18) = SlicePtr <*byte> v52
v56 (18) = SliceCap <int> v52
v57 (18) = IsSliceInBounds <bool> v6 v34
If v57 → b11 b12 (likely) (18)
b11: ← b10
v60 (18) = IsSliceInBounds <bool> v34 v56
If v60 → b13 b12 (likely) (18)
b12: ← b10 b11
v59 (18) = StaticCall <mem> {runtime.panicslice} v101
Exit v59 (18)
b13: ← b11
v61 (18) = Sub64 <int> v34 v6
v62 (18) = Sub64 <int> v56 v6
v63 (18) = SliceMake <[]byte> v54 v61 v62 (buf[[]byte])
v66 (18) = Load <string> v64 v101
v67 (18) = StringLen <int> v66
v70 (18) = SliceLen <int> v27
v72 (18) = SlicePtr <*byte> v63
v73 (18) = PtrIndex <*byte> v72 v70
v74 (18) = Store <mem> {*byte} v40 v73 v101
v76 (18) = Load <string> v75 v74
v77 (18) = StringPtr <*uint8> v76
v79 (18) = Store <mem> {*byte} v78 v77 v74
v81 (18) = Mul64 <uintptr> v67 v80
v83 (18) = Store <mem> {uintptr} v82 v81 v79
v84 (18) = StaticCall <mem> {runtime.memmove} [24] v83
If v85 → b14 b15 (+20)
b14: ← b13
v88 (+21) = EqSlice <bool> v63 v87
If v88 → b16 b17 (21)
b15: ← b13 b17
Plain → b4 (16)
b16: ← b14
v91 (+22) = IMake <interface {}> v89 v90
v94 (22) = Store <mem> {interface {}} v92 v91 v84
v95 (22) = StaticCall <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17: ← b14
Plain → b15 (16)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf[[]byte]: v27 v63

short circuit

short circuit [5599 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = Const64 <int> [0] (i[int])
v20 (?) = Const64 <int> [1024]
v30 (?) = Addr <*string> {"".data} v3
v39 (?) = Addr <*uint8> {type.uint8} v3
v40 (?) = OffPtr <**byte> [0] v2
v44 (?) = OffPtr <*[]byte> [8] v2
v47 (?) = OffPtr <*int> [32] v2
v50 (?) = OffPtr <*[]byte> [40] v2
v64 (?) = Addr <*string> {"".data} v3
v75 (?) = Addr <*string> {"".data} v3
v78 (?) = OffPtr <**byte> [8] v2
v80 (?) = Const64 <uintptr> [1]
v82 (?) = OffPtr <*uintptr> [16] v2
v85 (?) = ConstBool <bool> [true]
v87 (?) = ConstSlice <[]byte>
v89 (?) = Addr <*uint8> {type.string} v3
v90 (?) = Addr <*string> {"".statictmp_0} v3
v92 (?) = OffPtr <*interface {}> [0] v2
v97 (?) = Const64 <int> [1]
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v10 (+16) = NilCheck <void> v5 v9
v11 (16) = OffPtr <*int> [264] v5
v12 (16) = Load <int> v11 v9
v13 (16) = Less64 <bool> v7 v12
If v13 → b3 b5 (likely) (16)
b3: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v15
v17 (+17) = Zero <mem> {[1024]byte} [1024] v16 v15
v18 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v17
v19 (17) = NilCheck <void> v18 v17
v21 (17) = IsSliceInBounds <bool> v6 v6
If v21 → b6 b7 (likely) (17)
b4: ← b15
v98 (+16) = Add64 <int> v7 v97 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b6: ← b3
v24 (17) = IsSliceInBounds <bool> v6 v20
If v24 → b8 b7 (likely) (17)
b7: ← b3 b6
v23 (17) = StaticCall <mem> {runtime.panicslice} v17
Exit v23 (17)
b8: ← b6
v25 (17) = Sub64 <int> v6 v6
v26 (17) = Sub64 <int> v20 v6
v27 (17) = SliceMake <[]byte> v18 v25 v26 (buf[[]byte])
v29 (+18) = SliceLen <int> v27
v32 (18) = Load <string> v30 v17
v33 (18) = StringLen <int> v32
v34 (18) = Add64 <int> v29 v33
v36 (18) = SliceCap <int> v27
v38 (18) = Greater64U <bool> v34 v36
If v38 → b9 b10 (18)
b9: ← b8
v42 (18) = Store <mem> {*byte} v40 v39 v17
v45 (18) = Store <mem> {[]byte} v44 v27 v42
v48 (18) = Store <mem> {int} v47 v34 v45
v49 (18) = StaticCall <mem> {runtime.growslice} [64] v48
v51 (18) = Load <[]byte> v50 v49
Plain → b10 (18)
b10: ← b8 b9
v52 (18) = Phi <[]byte> v27 v51
v101 (18) = Phi <mem> v17 v49
v54 (18) = SlicePtr <*byte> v52
v56 (18) = SliceCap <int> v52
v57 (18) = IsSliceInBounds <bool> v6 v34
If v57 → b11 b12 (likely) (18)
b11: ← b10
v60 (18) = IsSliceInBounds <bool> v34 v56
If v60 → b13 b12 (likely) (18)
b12: ← b10 b11
v59 (18) = StaticCall <mem> {runtime.panicslice} v101
Exit v59 (18)
b13: ← b11
v61 (18) = Sub64 <int> v34 v6
v62 (18) = Sub64 <int> v56 v6
v63 (18) = SliceMake <[]byte> v54 v61 v62 (buf[[]byte])
v66 (18) = Load <string> v64 v101
v67 (18) = StringLen <int> v66
v70 (18) = SliceLen <int> v27
v72 (18) = SlicePtr <*byte> v63
v73 (18) = PtrIndex <*byte> v72 v70
v74 (18) = Store <mem> {*byte} v40 v73 v101
v76 (18) = Load <string> v75 v74
v77 (18) = StringPtr <*uint8> v76
v79 (18) = Store <mem> {*byte} v78 v77 v74
v81 (18) = Mul64 <uintptr> v67 v80
v83 (18) = Store <mem> {uintptr} v82 v81 v79
v84 (18) = StaticCall <mem> {runtime.memmove} [24] v83
If v85 → b14 b15 (+20)
b14: ← b13
v88 (+21) = EqSlice <bool> v63 v87
If v88 → b16 b17 (21)
b15: ← b13 b17
Plain → b4 (16)
b16: ← b14
v91 (+22) = IMake <interface {}> v89 v90
v94 (22) = Store <mem> {interface {}} v92 v91 v84
v95 (22) = StaticCall <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17: ← b14
Plain → b15 (16)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf[[]byte]: v27 v63

decompose user

decompose user [5699 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = Const64 <int> [0] (i[int])
v20 (?) = Const64 <int> [1024]
v30 (?) = Addr <*string> {"".data} v3
v39 (?) = Addr <*uint8> {type.uint8} v3
v40 (?) = OffPtr <**byte> [0] v2
v44 (?) = OffPtr <*[]byte> [8] v2
v47 (?) = OffPtr <*int> [32] v2
v50 (?) = OffPtr <*[]byte> [40] v2
v64 (?) = Addr <*string> {"".data} v3
v75 (?) = Addr <*string> {"".data} v3
v78 (?) = OffPtr <**byte> [8] v2
v80 (?) = Const64 <uintptr> [1]
v82 (?) = OffPtr <*uintptr> [16] v2
v85 (?) = ConstBool <bool> [true]
v87 (?) = ConstSlice <[]byte>
v89 (?) = Addr <*uint8> {type.string} v3
v90 (?) = Addr <*string> {"".statictmp_0} v3
v92 (?) = OffPtr <*interface {}> [0] v2
v97 (?) = Const64 <int> [1]
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v10 (+16) = NilCheck <void> v5 v9
v11 (16) = OffPtr <*int> [264] v5
v12 (16) = Load <int> v11 v9
v13 (16) = Less64 <bool> v7 v12
If v13 → b3 b5 (likely) (16)
b3: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v15
v17 (+17) = Zero <mem> {[1024]byte} [1024] v16 v15
v18 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v17
v19 (17) = NilCheck <void> v18 v17
v21 (17) = IsSliceInBounds <bool> v6 v6
If v21 → b6 b7 (likely) (17)
b4: ← b15
v98 (+16) = Add64 <int> v7 v97 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b6: ← b3
v24 (17) = IsSliceInBounds <bool> v6 v20
If v24 → b8 b7 (likely) (17)
b7: ← b3 b6
v23 (17) = StaticCall <mem> {runtime.panicslice} v17
Exit v23 (17)
b8: ← b6
v25 (17) = Sub64 <int> v6 v6
v26 (17) = Sub64 <int> v20 v6
v27 (17) = SliceMake <[]byte> v18 v25 v26 (buf[[]byte])
v29 (+18) = SliceLen <int> v27
v32 (18) = Load <string> v30 v17
v33 (18) = StringLen <int> v32
v34 (18) = Add64 <int> v29 v33
v36 (18) = SliceCap <int> v27
v38 (18) = Greater64U <bool> v34 v36
If v38 → b9 b10 (18)
b9: ← b8
v42 (18) = Store <mem> {*byte} v40 v39 v17
v45 (18) = Store <mem> {[]byte} v44 v27 v42
v48 (18) = Store <mem> {int} v47 v34 v45
v49 (18) = StaticCall <mem> {runtime.growslice} [64] v48
v51 (18) = Load <[]byte> v50 v49
Plain → b10 (18)
b10: ← b8 b9
v52 (18) = Phi <[]byte> v27 v51
v101 (18) = Phi <mem> v17 v49
v54 (18) = SlicePtr <*byte> v52
v56 (18) = SliceCap <int> v52
v57 (18) = IsSliceInBounds <bool> v6 v34
If v57 → b11 b12 (likely) (18)
b11: ← b10
v60 (18) = IsSliceInBounds <bool> v34 v56
If v60 → b13 b12 (likely) (18)
b12: ← b10 b11
v59 (18) = StaticCall <mem> {runtime.panicslice} v101
Exit v59 (18)
b13: ← b11
v61 (18) = Sub64 <int> v34 v6
v62 (18) = Sub64 <int> v56 v6
v63 (18) = SliceMake <[]byte> v54 v61 v62 (buf[[]byte])
v66 (18) = Load <string> v64 v101
v67 (18) = StringLen <int> v66
v70 (18) = SliceLen <int> v27
v72 (18) = SlicePtr <*byte> v63
v73 (18) = PtrIndex <*byte> v72 v70
v74 (18) = Store <mem> {*byte} v40 v73 v101
v76 (18) = Load <string> v75 v74
v77 (18) = StringPtr <*uint8> v76
v79 (18) = Store <mem> {*byte} v78 v77 v74
v81 (18) = Mul64 <uintptr> v67 v80
v83 (18) = Store <mem> {uintptr} v82 v81 v79
v84 (18) = StaticCall <mem> {runtime.memmove} [24] v83
If v85 → b14 b15 (+20)
b14: ← b13
v88 (+21) = EqSlice <bool> v63 v87
If v88 → b16 b17 (21)
b15: ← b13 b17
Plain → b4 (16)
b16: ← b14
v91 (+22) = IMake <interface {}> v89 v90
v94 (22) = Store <mem> {interface {}} v92 v91 v84
v95 (22) = StaticCall <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17: ← b14
Plain → b15 (16)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf[[]byte]: v27 v63

opt

opt [174760 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = Const64 <int> [0] (i[int])
v20 (?) = Const64 <int> [1024]
v30 (?) = Addr <*string> {"".data} v3
v39 (?) = Addr <*uint8> {type.uint8} v3
v40 (?) = OffPtr <**byte> [0] v2
v44 (?) = OffPtr <*[]byte> [8] v2
v47 (?) = OffPtr <*int> [32] v2
v50 (?) = OffPtr <*[]byte> [40] v2
v64 (?) = Addr <*string> {"".data} v3
v75 (?) = Addr <*string> {"".data} v3
v78 (?) = OffPtr <**byte> [8] v2
v80 (?) = Const64 <uintptr> [1]
v82 (?) = OffPtr <*uintptr> [16] v2
v85 (?) = ConstBool <bool> [true]
v89 (?) = Addr <*uint8> {type.string} v3
v90 (?) = Addr <*string> {"".statictmp_0} v3
v92 (?) = OffPtr <*interface {}> [0] v2
v97 (?) = Const64 <int> [1]
v93 (?) = ConstNil <*byte>
v105 (?) = Const64 <int> [0]
v104 (?) = Const64 <int> [0]
v87 (?) = SliceMake <[]byte> v93 v105 v104
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v10 (+16) = NilCheck <void> v5 v9
v11 (16) = OffPtr <*int> [264] v5
v12 (16) = Load <int> v11 v9
v13 (16) = Less64 <bool> v7 v12
If v13 → b3 b5 (likely) (16)
b3: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v15
v17 (+17) = Zero <mem> {[1024]byte} [1024] v16 v15
v18 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v17
v19 (17) = NilCheck <void> v18 v17
v21 (17) = ConstBool <bool> [true]
First → b6 b7 (likely) (17)
b4: ← b15
v98 (+16) = Add64 <int> v7 v97 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b6: ← b3
v24 (17) = ConstBool <bool> [true]
First → b8 b7 (likely) (17)
b7: ← b3 b6
v23 (17) = StaticCall <mem> {runtime.panicslice} v17
Exit v23 (17)
b8: ← b6
v25 (17) = Const64 <int> [0]
v26 (17) = Const64 <int> [1024]
v27 (17) = SliceMake <[]byte> v18 v25 v26 (buf[[]byte])
v29 (18) = Const64 <int> [0]
v32 (+18) = Load <string> v30 v17
v33 (18) = StringLen <int> v32
v36 (18) = Const64 <int> [1024]
v38 (18) = Greater64U <bool> v33 v36
If v38 → b9 b10 (18)
b9: ← b8
v42 (18) = Store <mem> {*byte} v40 v39 v17
v45 (18) = Store <mem> {[]byte} v44 v27 v42
v48 (18) = Store <mem> {int} v47 v33 v45
v49 (18) = StaticCall <mem> {runtime.growslice} [64] v48
v51 (18) = Load <[]byte> v50 v49
Plain → b10 (18)
b10: ← b8 b9
v52 (18) = Phi <[]byte> v27 v51
v101 (18) = Phi <mem> v17 v49
v54 (18) = SlicePtr <*byte> v52
v56 (18) = SliceCap <int> v52
v57 (18) = ConstBool <bool> [true]
First → b11 b12 (likely) (18)
b11: ← b10
v60 (18) = IsSliceInBounds <bool> v33 v56
If v60 → b13 b12 (likely) (18)
b12: ← b10 b11
v59 (18) = StaticCall <mem> {runtime.panicslice} v101
Exit v59 (18)
b13: ← b11
v63 (18) = SliceMake <[]byte> v54 v33 v56 (buf[[]byte])
v66 (18) = Load <string> v64 v101
v67 (18) = StringLen <int> v66
v70 (18) = Const64 <int> [0]
v72 (18) = SlicePtr <*byte> v52
v74 (18) = Store <mem> {*byte} v40 v72 v101
v76 (18) = Load <string> v75 v74
v77 (18) = StringPtr <*uint8> v76
v79 (18) = Store <mem> {*byte} v78 v77 v74
v83 (18) = Store <mem> {uintptr} v82 v67 v79
v84 (18) = StaticCall <mem> {runtime.memmove} [24] v83
v102 (18) = Const64 <int> [0]
v86 (18) = Const64 <int> [0]
v71 (18) = Const64 <int> [0]
v69 (18) = Const64 <int> [1]
First → b14 b15 (+20)
b14: ← b13
v68 (+21) = SlicePtr <*uint8> v52
v65 (+21) = SlicePtr <*uint8> v87
v88 (+21) = EqPtr <bool> v68 v65
If v88 → b16 b17 (21)
b15: ← b13 b17
Plain → b4 (16)
b16: ← b14
v91 (+22) = IMake <interface {}> v89 v90
v94 (22) = Store <mem> {interface {}} v92 v91 v84
v95 (22) = StaticCall <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17: ← b14
Plain → b15 (16)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf[[]byte]: v27 v63

zero arg cse

zero arg cse [12970 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = Const64 <int> [0] (i[int])
v20 (?) = Const64 <int> [1024]
v30 (?) = Addr <*string> {"".data} v3
v39 (?) = Addr <*uint8> {type.uint8} v3
v40 (?) = OffPtr <**byte> [0] v2
v44 (?) = OffPtr <*[]byte> [8] v2
v47 (?) = OffPtr <*int> [32] v2
v50 (?) = OffPtr <*[]byte> [40] v2
v64 (?) = Addr <*string> {"".data} v3
v75 (?) = Addr <*string> {"".data} v3
v78 (?) = OffPtr <**byte> [8] v2
v80 (?) = Const64 <uintptr> [1]
v82 (?) = OffPtr <*uintptr> [16] v2
v85 (?) = ConstBool <bool> [true]
v89 (?) = Addr <*uint8> {type.string} v3
v90 (?) = Addr <*string> {"".statictmp_0} v3
v92 (?) = OffPtr <*interface {}> [0] v2
v97 (?) = Const64 <int> [1]
v93 (?) = ConstNil <*byte>
v105 (?) = Const64 <int> [0]
v104 (?) = Const64 <int> [0]
v87 (?) = SliceMake <[]byte> v93 v6 v6
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v10 (+16) = NilCheck <void> v5 v9
v11 (16) = OffPtr <*int> [264] v5
v12 (16) = Load <int> v11 v9
v13 (16) = Less64 <bool> v7 v12
If v13 → b3 b5 (likely) (16)
b3: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v15
v17 (+17) = Zero <mem> {[1024]byte} [1024] v16 v15
v18 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v17
v19 (17) = NilCheck <void> v18 v17
v21 (17) = ConstBool <bool> [true]
First → b6 b7 (likely) (17)
b4: ← b15
v98 (+16) = Add64 <int> v7 v97 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b6: ← b3
v24 (17) = ConstBool <bool> [true]
First → b8 b7 (likely) (17)
b7: ← b3 b6
v23 (17) = StaticCall <mem> {runtime.panicslice} v17
Exit v23 (17)
b8: ← b6
v25 (17) = Const64 <int> [0]
v26 (17) = Const64 <int> [1024]
v27 (17) = SliceMake <[]byte> v18 v6 v20 (buf[[]byte])
v29 (18) = Const64 <int> [0]
v32 (+18) = Load <string> v30 v17
v33 (18) = StringLen <int> v32
v36 (18) = Const64 <int> [1024]
v38 (18) = Greater64U <bool> v33 v20
If v38 → b9 b10 (18)
b9: ← b8
v42 (18) = Store <mem> {*byte} v40 v39 v17
v45 (18) = Store <mem> {[]byte} v44 v27 v42
v48 (18) = Store <mem> {int} v47 v33 v45
v49 (18) = StaticCall <mem> {runtime.growslice} [64] v48
v51 (18) = Load <[]byte> v50 v49
Plain → b10 (18)
b10: ← b8 b9
v52 (18) = Phi <[]byte> v27 v51
v101 (18) = Phi <mem> v17 v49
v54 (18) = SlicePtr <*byte> v52
v56 (18) = SliceCap <int> v52
v57 (18) = ConstBool <bool> [true]
First → b11 b12 (likely) (18)
b11: ← b10
v60 (18) = IsSliceInBounds <bool> v33 v56
If v60 → b13 b12 (likely) (18)
b12: ← b10 b11
v59 (18) = StaticCall <mem> {runtime.panicslice} v101
Exit v59 (18)
b13: ← b11
v63 (18) = SliceMake <[]byte> v54 v33 v56 (buf[[]byte])
v66 (18) = Load <string> v64 v101
v67 (18) = StringLen <int> v66
v70 (18) = Const64 <int> [0]
v72 (18) = SlicePtr <*byte> v52
v74 (18) = Store <mem> {*byte} v40 v72 v101
v76 (18) = Load <string> v75 v74
v77 (18) = StringPtr <*uint8> v76
v79 (18) = Store <mem> {*byte} v78 v77 v74
v83 (18) = Store <mem> {uintptr} v82 v67 v79
v84 (18) = StaticCall <mem> {runtime.memmove} [24] v83
v102 (18) = Const64 <int> [0]
v86 (18) = Const64 <int> [0]
v71 (18) = Const64 <int> [0]
v69 (18) = Const64 <int> [1]
First → b14 b15 (+20)
b14: ← b13
v68 (+21) = SlicePtr <*uint8> v52
v65 (+21) = SlicePtr <*uint8> v87
v88 (+21) = EqPtr <bool> v68 v65
If v88 → b16 b17 (21)
b15: ← b13 b17
Plain → b4 (16)
b16: ← b14
v91 (+22) = IMake <interface {}> v89 v90
v94 (22) = Store <mem> {interface {}} v92 v91 v84
v95 (22) = StaticCall <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17: ← b14
Plain → b15 (16)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf[[]byte]: v27 v63

opt deadcode

opt deadcode [26344 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = Const64 <int> [0] (i[int])
v20 (?) = Const64 <int> [1024]
v30 (?) = Addr <*string> {"".data} v3
v39 (?) = Addr <*uint8> {type.uint8} v3
v40 (?) = OffPtr <**byte> [0] v2
v44 (?) = OffPtr <*[]byte> [8] v2
v47 (?) = OffPtr <*int> [32] v2
v50 (?) = OffPtr <*[]byte> [40] v2
v64 (?) = Addr <*string> {"".data} v3
v75 (?) = Addr <*string> {"".data} v3
v78 (?) = OffPtr <**byte> [8] v2
v82 (?) = OffPtr <*uintptr> [16] v2
v89 (?) = Addr <*uint8> {type.string} v3
v90 (?) = Addr <*string> {"".statictmp_0} v3
v92 (?) = OffPtr <*interface {}> [0] v2
v97 (?) = Const64 <int> [1]
v93 (?) = ConstNil <*byte>
v87 (?) = SliceMake <[]byte> v93 v6 v6
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v10 (+16) = NilCheck <void> v5 v9
v11 (16) = OffPtr <*int> [264] v5
v12 (16) = Load <int> v11 v9
v13 (16) = Less64 <bool> v7 v12
If v13 → b3 b5 (likely) (16)
b3: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v15
v17 (+17) = Zero <mem> {[1024]byte} [1024] v16 v15
v18 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v17
v19 (17) = NilCheck <void> v18 v17
Plain → b6 (17)
b4: ← b15
v98 (+16) = Add64 <int> v7 v97 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b6: ← b3
Plain → b8 (17)
b8: ← b6
v27 (17) = SliceMake <[]byte> v18 v6 v20 (buf[[]byte])
v32 (+18) = Load <string> v30 v17
v33 (18) = StringLen <int> v32
v38 (18) = Greater64U <bool> v33 v20
If v38 → b9 b10 (18)
b9: ← b8
v42 (18) = Store <mem> {*byte} v40 v39 v17
v45 (18) = Store <mem> {[]byte} v44 v27 v42
v48 (18) = Store <mem> {int} v47 v33 v45
v49 (18) = StaticCall <mem> {runtime.growslice} [64] v48
v51 (18) = Load <[]byte> v50 v49
Plain → b10 (18)
b10: ← b8 b9
v52 (18) = Phi <[]byte> v27 v51
v101 (18) = Phi <mem> v17 v49
v56 (18) = SliceCap <int> v52
Plain → b11 (18)
b11: ← b10
v60 (18) = IsSliceInBounds <bool> v33 v56
If v60 → b13 b12 (likely) (18)
b12: ← b11
v59 (18) = StaticCall <mem> {runtime.panicslice} v101
Exit v59 (18)
b13: ← b11
v66 (18) = Load <string> v64 v101
v67 (18) = StringLen <int> v66
v72 (18) = SlicePtr <*byte> v52
v74 (18) = Store <mem> {*byte} v40 v72 v101
v76 (18) = Load <string> v75 v74
v77 (18) = StringPtr <*uint8> v76
v79 (18) = Store <mem> {*byte} v78 v77 v74
v83 (18) = Store <mem> {uintptr} v82 v67 v79
v84 (18) = StaticCall <mem> {runtime.memmove} [24] v83
Plain → b14 (+20)
b14: ← b13
v68 (+21) = SlicePtr <*uint8> v52
v65 (+21) = SlicePtr <*uint8> v87
v88 (+21) = EqPtr <bool> v68 v65
If v88 → b16 b17 (21)
b15: ← b17
Plain → b4 (16)
b16: ← b14
v91 (+22) = IMake <interface {}> v89 v90
v94 (22) = Store <mem> {interface {}} v92 v91 v84
v95 (22) = StaticCall <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17: ← b14
Plain → b15 (16)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf[[]byte]: v27

generic cse

generic cse [149830 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = Const64 <int> [0] (i[int])
v20 (?) = Const64 <int> [1024]
v30 (?) = Addr <*string> {"".data} v3
v39 (?) = Addr <*uint8> {type.uint8} v3
v40 (?) = OffPtr <**byte> [0] v2
v44 (?) = OffPtr <*[]byte> [8] v2
v47 (?) = OffPtr <*int> [32] v2
v50 (?) = OffPtr <*[]byte> [40] v2
v64 (?) = Addr <*string> {"".data} v3
v75 (?) = Addr <*string> {"".data} v3
v78 (?) = OffPtr <**byte> [8] v2
v82 (?) = OffPtr <*uintptr> [16] v2
v89 (?) = Addr <*uint8> {type.string} v3
v90 (?) = Addr <*string> {"".statictmp_0} v3
v92 (?) = OffPtr <*interface {}> [0] v2
v97 (?) = Const64 <int> [1]
v93 (?) = ConstNil <*byte>
v87 (?) = SliceMake <[]byte> v93 v6 v6
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v10 (+16) = NilCheck <void> v5 v9
v11 (16) = OffPtr <*int> [264] v5
v12 (16) = Load <int> v11 v9
v13 (16) = Less64 <bool> v7 v12
If v13 → b3 b5 (likely) (16)
b3: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v15
v17 (+17) = Zero <mem> {[1024]byte} [1024] v16 v15
v18 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v17
v19 (17) = NilCheck <void> v18 v17
Plain → b6 (17)
b4: ← b15
v98 (+16) = Add64 <int> v7 v97 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b6: ← b3
Plain → b8 (17)
b8: ← b6
v27 (17) = SliceMake <[]byte> v18 v6 v20 (buf[[]byte])
v32 (+18) = Load <string> v30 v17
v33 (18) = StringLen <int> v32
v38 (18) = Greater64U <bool> v33 v20
If v38 → b9 b10 (18)
b9: ← b8
v42 (18) = Store <mem> {*byte} v40 v39 v17
v45 (18) = Store <mem> {[]byte} v44 v27 v42
v48 (18) = Store <mem> {int} v47 v33 v45
v49 (18) = StaticCall <mem> {runtime.growslice} [64] v48
v51 (18) = Load <[]byte> v50 v49
Plain → b10 (18)
b10: ← b8 b9
v52 (18) = Phi <[]byte> v27 v51
v101 (18) = Phi <mem> v17 v49
v56 (18) = SliceCap <int> v52
Plain → b11 (18)
b11: ← b10
v60 (18) = IsSliceInBounds <bool> v33 v56
If v60 → b13 b12 (likely) (18)
b12: ← b11
v59 (18) = StaticCall <mem> {runtime.panicslice} v101
Exit v59 (18)
b13: ← b11
v66 (18) = Load <string> v30 v101
v67 (18) = StringLen <int> v66
v72 (18) = SlicePtr <*byte> v52
v74 (18) = Store <mem> {*byte} v40 v72 v101
v76 (18) = Load <string> v30 v74
v77 (18) = StringPtr <*uint8> v76
v79 (18) = Store <mem> {*byte} v78 v77 v74
v83 (18) = Store <mem> {uintptr} v82 v67 v79
v84 (18) = StaticCall <mem> {runtime.memmove} [24] v83
Plain → b14 (+20)
b14: ← b13
v68 (21) = SlicePtr <*uint8> v52
v65 (+21) = SlicePtr <*uint8> v87
v88 (+21) = EqPtr <bool> v72 v65
If v88 → b16 b17 (21)
b15: ← b17
Plain → b4 (16)
b16: ← b14
v91 (+22) = IMake <interface {}> v89 v90
v94 (22) = Store <mem> {interface {}} v92 v91 v84
v95 (22) = StaticCall <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17: ← b14
Plain → b15 (16)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf[[]byte]: v27

phiopt

phiopt [1684 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = Const64 <int> [0] (i[int])
v20 (?) = Const64 <int> [1024]
v30 (?) = Addr <*string> {"".data} v3
v39 (?) = Addr <*uint8> {type.uint8} v3
v40 (?) = OffPtr <**byte> [0] v2
v44 (?) = OffPtr <*[]byte> [8] v2
v47 (?) = OffPtr <*int> [32] v2
v50 (?) = OffPtr <*[]byte> [40] v2
v64 (?) = Addr <*string> {"".data} v3
v75 (?) = Addr <*string> {"".data} v3
v78 (?) = OffPtr <**byte> [8] v2
v82 (?) = OffPtr <*uintptr> [16] v2
v89 (?) = Addr <*uint8> {type.string} v3
v90 (?) = Addr <*string> {"".statictmp_0} v3
v92 (?) = OffPtr <*interface {}> [0] v2
v97 (?) = Const64 <int> [1]
v93 (?) = ConstNil <*byte>
v87 (?) = SliceMake <[]byte> v93 v6 v6
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v10 (+16) = NilCheck <void> v5 v9
v11 (16) = OffPtr <*int> [264] v5
v12 (16) = Load <int> v11 v9
v13 (16) = Less64 <bool> v7 v12
If v13 → b3 b5 (likely) (16)
b3: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v15
v17 (+17) = Zero <mem> {[1024]byte} [1024] v16 v15
v18 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v17
v19 (17) = NilCheck <void> v18 v17
Plain → b6 (17)
b4: ← b15
v98 (+16) = Add64 <int> v7 v97 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b6: ← b3
Plain → b8 (17)
b8: ← b6
v27 (17) = SliceMake <[]byte> v18 v6 v20 (buf[[]byte])
v32 (+18) = Load <string> v30 v17
v33 (18) = StringLen <int> v32
v38 (18) = Greater64U <bool> v33 v20
If v38 → b9 b10 (18)
b9: ← b8
v42 (18) = Store <mem> {*byte} v40 v39 v17
v45 (18) = Store <mem> {[]byte} v44 v27 v42
v48 (18) = Store <mem> {int} v47 v33 v45
v49 (18) = StaticCall <mem> {runtime.growslice} [64] v48
v51 (18) = Load <[]byte> v50 v49
Plain → b10 (18)
b10: ← b8 b9
v52 (18) = Phi <[]byte> v27 v51
v101 (18) = Phi <mem> v17 v49
v56 (18) = SliceCap <int> v52
Plain → b11 (18)
b11: ← b10
v60 (18) = IsSliceInBounds <bool> v33 v56
If v60 → b13 b12 (likely) (18)
b12: ← b11
v59 (18) = StaticCall <mem> {runtime.panicslice} v101
Exit v59 (18)
b13: ← b11
v66 (18) = Load <string> v30 v101
v67 (18) = StringLen <int> v66
v72 (18) = SlicePtr <*byte> v52
v74 (18) = Store <mem> {*byte} v40 v72 v101
v76 (18) = Load <string> v30 v74
v77 (18) = StringPtr <*uint8> v76
v79 (18) = Store <mem> {*byte} v78 v77 v74
v83 (18) = Store <mem> {uintptr} v82 v67 v79
v84 (18) = StaticCall <mem> {runtime.memmove} [24] v83
Plain → b14 (+20)
b14: ← b13
v68 (21) = SlicePtr <*uint8> v52
v65 (+21) = SlicePtr <*uint8> v87
v88 (+21) = EqPtr <bool> v72 v65
If v88 → b16 b17 (21)
b15: ← b17
Plain → b4 (16)
b16: ← b14
v91 (+22) = IMake <interface {}> v89 v90
v94 (22) = Store <mem> {interface {}} v92 v91 v84
v95 (22) = StaticCall <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17: ← b14
Plain → b15 (16)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf[[]byte]: v27

nilcheckelim

nilcheckelim [38299 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = Const64 <int> [0] (i[int])
v20 (?) = Const64 <int> [1024]
v30 (?) = Addr <*string> {"".data} v3
v39 (?) = Addr <*uint8> {type.uint8} v3
v40 (?) = OffPtr <**byte> [0] v2
v44 (?) = OffPtr <*[]byte> [8] v2
v47 (?) = OffPtr <*int> [32] v2
v50 (?) = OffPtr <*[]byte> [40] v2
v64 (?) = Addr <*string> {"".data} v3
v75 (?) = Addr <*string> {"".data} v3
v78 (?) = OffPtr <**byte> [8] v2
v82 (?) = OffPtr <*uintptr> [16] v2
v89 (?) = Addr <*uint8> {type.string} v3
v90 (?) = Addr <*string> {"".statictmp_0} v3
v92 (?) = OffPtr <*interface {}> [0] v2
v97 (?) = Const64 <int> [1]
v93 (?) = ConstNil <*byte>
v87 (?) = SliceMake <[]byte> v93 v6 v6
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v11 (16) = OffPtr <*int> [264] v5
v10 (+16) = NilCheck <void> v5 v9
v12 (16) = Load <int> v11 v9
v13 (16) = Less64 <bool> v7 v12
If v13 → b3 b5 (likely) (16)
b3: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v15
v17 (+17) = Zero <mem> {[1024]byte} [1024] v16 v15
v18 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v17
Plain → b6 (17)
b4: ← b15
v98 (+16) = Add64 <int> v7 v97 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b6: ← b3
Plain → b8 (17)
b8: ← b6
v27 (17) = SliceMake <[]byte> v18 v6 v20 (buf[[]byte])
v32 (+18) = Load <string> v30 v17
v33 (18) = StringLen <int> v32
v38 (18) = Greater64U <bool> v33 v20
If v38 → b9 b10 (18)
b9: ← b8
v42 (18) = Store <mem> {*byte} v40 v39 v17
v45 (18) = Store <mem> {[]byte} v44 v27 v42
v48 (18) = Store <mem> {int} v47 v33 v45
v49 (18) = StaticCall <mem> {runtime.growslice} [64] v48
v51 (18) = Load <[]byte> v50 v49
Plain → b10 (18)
b10: ← b8 b9
v52 (18) = Phi <[]byte> v27 v51
v101 (18) = Phi <mem> v17 v49
v56 (18) = SliceCap <int> v52
Plain → b11 (18)
b11: ← b10
v60 (18) = IsSliceInBounds <bool> v33 v56
If v60 → b13 b12 (likely) (18)
b12: ← b11
v59 (18) = StaticCall <mem> {runtime.panicslice} v101
Exit v59 (18)
b13: ← b11
v66 (18) = Load <string> v30 v101
v67 (18) = StringLen <int> v66
v72 (18) = SlicePtr <*byte> v52
v74 (18) = Store <mem> {*byte} v40 v72 v101
v76 (18) = Load <string> v30 v74
v77 (18) = StringPtr <*uint8> v76
v79 (18) = Store <mem> {*byte} v78 v77 v74
v83 (18) = Store <mem> {uintptr} v82 v67 v79
v84 (18) = StaticCall <mem> {runtime.memmove} [24] v83
Plain → b14 (+20)
b14: ← b13
v68 (21) = SlicePtr <*uint8> v52
v65 (+21) = SlicePtr <*uint8> v87
v88 (+21) = EqPtr <bool> v72 v65
If v88 → b16 b17 (21)
b15: ← b17
Plain → b4 (16)
b16: ← b14
v91 (+22) = IMake <interface {}> v89 v90
v94 (22) = Store <mem> {interface {}} v92 v91 v84
v95 (22) = StaticCall <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17: ← b14
Plain → b15 (16)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf[[]byte]: v27

prove

prove [158979 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = Const64 <int> [0] (i[int])
v20 (?) = Const64 <int> [1024]
v30 (?) = Addr <*string> {"".data} v3
v39 (?) = Addr <*uint8> {type.uint8} v3
v40 (?) = OffPtr <**byte> [0] v2
v44 (?) = OffPtr <*[]byte> [8] v2
v47 (?) = OffPtr <*int> [32] v2
v50 (?) = OffPtr <*[]byte> [40] v2
v64 (?) = Addr <*string> {"".data} v3
v75 (?) = Addr <*string> {"".data} v3
v78 (?) = OffPtr <**byte> [8] v2
v82 (?) = OffPtr <*uintptr> [16] v2
v89 (?) = Addr <*uint8> {type.string} v3
v90 (?) = Addr <*string> {"".statictmp_0} v3
v92 (?) = OffPtr <*interface {}> [0] v2
v97 (?) = Const64 <int> [1]
v93 (?) = ConstNil <*byte>
v87 (?) = SliceMake <[]byte> v93 v6 v6
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v11 (16) = OffPtr <*int> [264] v5
v10 (+16) = NilCheck <void> v5 v9
v12 (16) = Load <int> v11 v9
v13 (16) = Less64 <bool> v7 v12
If v13 → b3 b5 (likely) (16)
b3: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v15
v17 (+17) = Zero <mem> {[1024]byte} [1024] v16 v15
v18 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v17
Plain → b6 (17)
b4: ← b15
v98 (+16) = Add64 <int> v7 v97 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b6: ← b3
Plain → b8 (17)
b8: ← b6
v27 (17) = SliceMake <[]byte> v18 v6 v20 (buf[[]byte])
v32 (+18) = Load <string> v30 v17
v33 (18) = StringLen <int> v32
v38 (18) = Greater64U <bool> v33 v20
If v38 → b9 b10 (18)
b9: ← b8
v42 (18) = Store <mem> {*byte} v40 v39 v17
v45 (18) = Store <mem> {[]byte} v44 v27 v42
v48 (18) = Store <mem> {int} v47 v33 v45
v49 (18) = StaticCall <mem> {runtime.growslice} [64] v48
v51 (18) = Load <[]byte> v50 v49
Plain → b10 (18)
b10: ← b8 b9
v52 (18) = Phi <[]byte> v27 v51
v101 (18) = Phi <mem> v17 v49
v56 (18) = SliceCap <int> v52
Plain → b11 (18)
b11: ← b10
v60 (18) = IsSliceInBounds <bool> v33 v56
If v60 → b13 b12 (likely) (18)
b12: ← b11
v59 (18) = StaticCall <mem> {runtime.panicslice} v101
Exit v59 (18)
b13: ← b11
v66 (18) = Load <string> v30 v101
v67 (18) = StringLen <int> v66
v72 (18) = SlicePtr <*byte> v52
v74 (18) = Store <mem> {*byte} v40 v72 v101
v76 (18) = Load <string> v30 v74
v77 (18) = StringPtr <*uint8> v76
v79 (18) = Store <mem> {*byte} v78 v77 v74
v83 (18) = Store <mem> {uintptr} v82 v67 v79
v84 (18) = StaticCall <mem> {runtime.memmove} [24] v83
Plain → b14 (+20)
b14: ← b13
v68 (21) = SlicePtr <*uint8> v52
v65 (+21) = SlicePtr <*uint8> v87
v88 (+21) = EqPtr <bool> v72 v65
If v88 → b16 b17 (21)
b15: ← b17
Plain → b4 (16)
b16: ← b14
v91 (+22) = IMake <interface {}> v89 v90
v94 (22) = Store <mem> {interface {}} v92 v91 v84
v95 (22) = StaticCall <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17: ← b14
Plain → b15 (16)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf[[]byte]: v27

decompose builtin

decompose builtin [78209 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = Const64 <int> [0] (i[int], buf.len[int])
v20 (?) = Const64 <int> [1024] (buf.cap[int])
v30 (?) = Addr <*string> {"".data} v3
v39 (?) = Addr <*uint8> {type.uint8} v3
v40 (?) = OffPtr <**byte> [0] v2
v44 (?) = OffPtr <*[]byte> [8] v2
v47 (?) = OffPtr <*int> [32] v2
v50 (?) = OffPtr <*[]byte> [40] v2
v64 (?) = Addr <*string> {"".data} v3
v75 (?) = Addr <*string> {"".data} v3
v78 (?) = OffPtr <**byte> [8] v2
v82 (?) = OffPtr <*uintptr> [16] v2
v89 (?) = Addr <*uint8> {type.string} v3
v90 (?) = Addr <*string> {"".statictmp_0} v3
v92 (?) = OffPtr <*interface {}> [0] v2
v97 (?) = Const64 <int> [1]
v93 (?) = ConstNil <*byte>
v87 (?) = SliceMake <[]byte> v93 v6 v6
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v11 (16) = OffPtr <*int> [264] v5
v10 (+16) = NilCheck <void> v5 v9
v12 (16) = Load <int> v11 v9
v13 (16) = Less64 <bool> v7 v12
If v13 → b3 b5 (likely) (16)
b3: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v15
v17 (+17) = Zero <mem> {[1024]byte} [1024] v16 v15
v18 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v17 (buf.ptr[*byte])
Plain → b6 (17)
b4: ← b15
v98 (+16) = Add64 <int> v7 v97 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b6: ← b3
Plain → b8 (17)
b8: ← b6
v27 (17) = SliceMake <[]byte> v18 v6 v20
v36 (+18) = Load <*uint8> v30 v17
v26 (+18) = OffPtr <*int> [8] v30
v29 (+18) = Load <int> v26 v17
v32 (+18) = StringMake <string> v36 v29
v38 (18) = Greater64U <bool> v29 v20
If v38 → b9 b10 (18)
b9: ← b8
v42 (18) = Store <mem> {*byte} v40 v39 v17
v25 (18) = OffPtr <*int> [16] v44
v24 (18) = OffPtr <*int> [8] v44
v21 (18) = Store <mem> {*uint8} v44 v18 v42
v85 (18) = OffPtr <*int> [8] v50
v81 (18) = OffPtr <*int> [16] v50
v23 (18) = Store <mem> {int} v24 v6 v21
v45 (18) = Store <mem> {int} v25 v20 v23
v48 (18) = Store <mem> {int} v47 v29 v45
v49 (18) = StaticCall <mem> {runtime.growslice} [64] v48
v104 (18) = Load <*byte> v50 v49
v105 (18) = Load <int> v85 v49
v80 (18) = Load <int> v81 v49
v51 (18) = SliceMake <[]byte> v104 v105 v80
Plain → b10 (18)
b10: ← b8 b9
v101 (18) = Phi <mem> v17 v49
v19 (18) = Phi <*uint8> v18 v104
v69 (18) = Phi <int> v6 v105
v71 (18) = Phi <int> v20 v80
v52 (18) = SliceMake <[]byte> v19 v69 v71
Plain → b11 (18)
b11: ← b10
v60 (18) = IsSliceInBounds <bool> v29 v71
If v60 → b13 b12 (likely) (18)
b12: ← b11
v59 (18) = StaticCall <mem> {runtime.panicslice} v101
Exit v59 (18)
b13: ← b11
v74 (18) = Store <mem> {*byte} v40 v19 v101
v73 (18) = Load <*uint8> v30 v101
v61 (18) = OffPtr <*int> [8] v30
v34 (18) = Load <*uint8> v30 v74
v106 (18) = OffPtr <*int> [8] v30
v79 (18) = Store <mem> {*byte} v78 v34 v74
v62 (18) = Load <int> v61 v101
v58 (18) = Load <int> v106 v74
v66 (18) = StringMake <string> v73 v62
v76 (18) = StringMake <string> v34 v58
v83 (18) = Store <mem> {uintptr} v82 v62 v79
v84 (18) = StaticCall <mem> {runtime.memmove} [24] v83
Plain → b14 (+20)
b14: ← b13
v88 (+21) = EqPtr <bool> v19 v93
v68 (21) = Copy <*uint8> v19
If v88 → b16 b17 (21)
b15: ← b17
Plain → b4 (16)
b16: ← b14
v91 (+22) = IMake <interface {}> v89 v90
v103 (22) = OffPtr <**uint8> [8] v92
v100 (22) = Store <mem> {uintptr} v92 v89 v84
v94 (22) = Store <mem> {*uint8} v103 v90 v100
v95 (22) = StaticCall <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17: ← b14
Plain → b15 (16)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.ptr[*byte]: v18 
name buf.len[int]: v6 
name buf.cap[int]: v20

softfloat

softfloat [492 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = Const64 <int> [0] (i[int], buf.len[int])
v20 (?) = Const64 <int> [1024] (buf.cap[int])
v30 (?) = Addr <*string> {"".data} v3
v39 (?) = Addr <*uint8> {type.uint8} v3
v40 (?) = OffPtr <**byte> [0] v2
v44 (?) = OffPtr <*[]byte> [8] v2
v47 (?) = OffPtr <*int> [32] v2
v50 (?) = OffPtr <*[]byte> [40] v2
v64 (?) = Addr <*string> {"".data} v3
v75 (?) = Addr <*string> {"".data} v3
v78 (?) = OffPtr <**byte> [8] v2
v82 (?) = OffPtr <*uintptr> [16] v2
v89 (?) = Addr <*uint8> {type.string} v3
v90 (?) = Addr <*string> {"".statictmp_0} v3
v92 (?) = OffPtr <*interface {}> [0] v2
v97 (?) = Const64 <int> [1]
v93 (?) = ConstNil <*byte>
v87 (?) = SliceMake <[]byte> v93 v6 v6
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v11 (16) = OffPtr <*int> [264] v5
v10 (+16) = NilCheck <void> v5 v9
v12 (16) = Load <int> v11 v9
v13 (16) = Less64 <bool> v7 v12
If v13 → b3 b5 (likely) (16)
b3: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v15
v17 (+17) = Zero <mem> {[1024]byte} [1024] v16 v15
v18 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v17 (buf.ptr[*byte])
Plain → b6 (17)
b4: ← b15
v98 (+16) = Add64 <int> v7 v97 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b6: ← b3
Plain → b8 (17)
b8: ← b6
v27 (17) = SliceMake <[]byte> v18 v6 v20
v36 (+18) = Load <*uint8> v30 v17
v26 (+18) = OffPtr <*int> [8] v30
v29 (+18) = Load <int> v26 v17
v32 (+18) = StringMake <string> v36 v29
v38 (18) = Greater64U <bool> v29 v20
If v38 → b9 b10 (18)
b9: ← b8
v42 (18) = Store <mem> {*byte} v40 v39 v17
v25 (18) = OffPtr <*int> [16] v44
v24 (18) = OffPtr <*int> [8] v44
v21 (18) = Store <mem> {*uint8} v44 v18 v42
v85 (18) = OffPtr <*int> [8] v50
v81 (18) = OffPtr <*int> [16] v50
v23 (18) = Store <mem> {int} v24 v6 v21
v45 (18) = Store <mem> {int} v25 v20 v23
v48 (18) = Store <mem> {int} v47 v29 v45
v49 (18) = StaticCall <mem> {runtime.growslice} [64] v48
v104 (18) = Load <*byte> v50 v49
v105 (18) = Load <int> v85 v49
v80 (18) = Load <int> v81 v49
v51 (18) = SliceMake <[]byte> v104 v105 v80
Plain → b10 (18)
b10: ← b8 b9
v101 (18) = Phi <mem> v17 v49
v19 (18) = Phi <*uint8> v18 v104
v69 (18) = Phi <int> v6 v105
v71 (18) = Phi <int> v20 v80
v52 (18) = SliceMake <[]byte> v19 v69 v71
Plain → b11 (18)
b11: ← b10
v60 (18) = IsSliceInBounds <bool> v29 v71
If v60 → b13 b12 (likely) (18)
b12: ← b11
v59 (18) = StaticCall <mem> {runtime.panicslice} v101
Exit v59 (18)
b13: ← b11
v74 (18) = Store <mem> {*byte} v40 v19 v101
v73 (18) = Load <*uint8> v30 v101
v61 (18) = OffPtr <*int> [8] v30
v34 (18) = Load <*uint8> v30 v74
v106 (18) = OffPtr <*int> [8] v30
v79 (18) = Store <mem> {*byte} v78 v34 v74
v62 (18) = Load <int> v61 v101
v58 (18) = Load <int> v106 v74
v66 (18) = StringMake <string> v73 v62
v76 (18) = StringMake <string> v34 v58
v83 (18) = Store <mem> {uintptr} v82 v62 v79
v84 (18) = StaticCall <mem> {runtime.memmove} [24] v83
Plain → b14 (+20)
b14: ← b13
v88 (+21) = EqPtr <bool> v19 v93
v68 (21) = Copy <*uint8> v19
If v88 → b16 b17 (21)
b15: ← b17
Plain → b4 (16)
b16: ← b14
v91 (+22) = IMake <interface {}> v89 v90
v103 (22) = OffPtr <**uint8> [8] v92
v100 (22) = Store <mem> {uintptr} v92 v89 v84
v94 (22) = Store <mem> {*uint8} v103 v90 v100
v95 (22) = StaticCall <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17: ← b14
Plain → b15 (16)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.ptr[*byte]: v18 
name buf.len[int]: v6 
name buf.cap[int]: v20

late opt

late opt [39604 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = Const64 <int> [0] (i[int], buf.len[int])
v20 (?) = Const64 <int> [1024] (buf.cap[int])
v30 (?) = Addr <*string> {"".data} v3
v39 (?) = Addr <*uint8> {type.uint8} v3
v40 (?) = OffPtr <**byte> [0] v2
v44 (?) = OffPtr <*[]byte> [8] v2
v47 (?) = OffPtr <*int> [32] v2
v50 (?) = OffPtr <*[]byte> [40] v2
v64 (?) = Addr <*string> {"".data} v3
v75 (?) = Addr <*string> {"".data} v3
v78 (?) = OffPtr <**byte> [8] v2
v82 (?) = OffPtr <*uintptr> [16] v2
v89 (?) = Addr <*uint8> {type.string} v3
v90 (?) = Addr <*string> {"".statictmp_0} v3
v92 (?) = OffPtr <*interface {}> [0] v2
v97 (?) = Const64 <int> [1]
v93 (?) = ConstNil <*byte>
v87 (?) = SliceMake <[]byte> v93 v6 v6
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v11 (16) = OffPtr <*int> [264] v5
v10 (+16) = NilCheck <void> v5 v9
v12 (16) = Load <int> v11 v9
v13 (16) = Less64 <bool> v7 v12
If v13 → b3 b5 (likely) (16)
b3: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v15
v17 (+17) = Zero <mem> {[1024]byte} [1024] v16 v15
v18 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v17 (buf.ptr[*byte])
Plain → b6 (17)
b4: ← b15
v98 (+16) = Add64 <int> v7 v97 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b6: ← b3
Plain → b8 (17)
b8: ← b6
v27 (17) = SliceMake <[]byte> v18 v6 v20
v36 (+18) = Load <*uint8> v30 v17
v26 (+18) = OffPtr <*int> [8] v30
v29 (+18) = Load <int> v26 v17
v32 (+18) = StringMake <string> v36 v29
v38 (18) = Greater64U <bool> v29 v20
If v38 → b9 b10 (18)
b9: ← b8
v42 (18) = Store <mem> {*byte} v40 v39 v17
v25 (18) = OffPtr <*int> [24] v2
v24 (18) = OffPtr <*int> [16] v2
v21 (18) = Store <mem> {*uint8} v44 v18 v42
v85 (18) = OffPtr <*int> [48] v2
v81 (18) = OffPtr <*int> [56] v2
v23 (18) = Store <mem> {int} v24 v6 v21
v45 (18) = Store <mem> {int} v25 v20 v23
v48 (18) = Store <mem> {int} v47 v29 v45
v49 (18) = StaticCall <mem> {runtime.growslice} [64] v48
v104 (18) = Load <*byte> v50 v49
v105 (18) = Load <int> v85 v49
v80 (18) = Load <int> v81 v49
v51 (18) = SliceMake <[]byte> v104 v105 v80
Plain → b10 (18)
b10: ← b8 b9
v101 (18) = Phi <mem> v17 v49
v19 (18) = Phi <*uint8> v18 v104
v69 (18) = Phi <int> v6 v105
v71 (18) = Phi <int> v20 v80
v52 (18) = SliceMake <[]byte> v19 v69 v71
Plain → b11 (18)
b11: ← b10
v60 (18) = IsSliceInBounds <bool> v29 v71
If v60 → b13 b12 (likely) (18)
b12: ← b11
v59 (18) = StaticCall <mem> {runtime.panicslice} v101
Exit v59 (18)
b13: ← b11
v74 (18) = Store <mem> {*byte} v40 v19 v101
v73 (18) = Load <*uint8> v30 v101
v61 (18) = OffPtr <*int> [8] v30
v34 (18) = Load <*uint8> v30 v74
v106 (18) = OffPtr <*int> [8] v30
v79 (18) = Store <mem> {*byte} v78 v34 v74
v62 (18) = Load <int> v61 v101
v58 (18) = Load <int> v106 v74
v66 (18) = StringMake <string> v73 v62
v76 (18) = StringMake <string> v34 v58
v83 (18) = Store <mem> {uintptr} v82 v62 v79
v84 (18) = StaticCall <mem> {runtime.memmove} [24] v83
Plain → b14 (+20)
b14: ← b13
v68 (21) = Copy <*uint8> v19
v65 (+21) = IsNonNil <bool> v19
v88 (+21) = Not <bool> v65
If v65 → b17 b16 (21)
b15: ← b17
Plain → b4 (16)
b16: ← b14
v91 (+22) = IMake <interface {}> v89 v90
v103 (22) = OffPtr <**uint8> [8] v2
v100 (22) = Store <mem> {uintptr} v92 v89 v84
v94 (22) = Store <mem> {*uint8} v103 v90 v100
v95 (22) = StaticCall <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17: ← b14
Plain → b15 (16)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.ptr[*byte]: v18 
name buf.len[int]: v6 
name buf.cap[int]: v20

dead auto elim

dead auto elim [29436 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = Const64 <int> [0] (i[int], buf.len[int])
v20 (?) = Const64 <int> [1024] (buf.cap[int])
v30 (?) = Addr <*string> {"".data} v3
v39 (?) = Addr <*uint8> {type.uint8} v3
v40 (?) = OffPtr <**byte> [0] v2
v44 (?) = OffPtr <*[]byte> [8] v2
v47 (?) = OffPtr <*int> [32] v2
v50 (?) = OffPtr <*[]byte> [40] v2
v64 (?) = Addr <*string> {"".data} v3
v75 (?) = Addr <*string> {"".data} v3
v78 (?) = OffPtr <**byte> [8] v2
v82 (?) = OffPtr <*uintptr> [16] v2
v89 (?) = Addr <*uint8> {type.string} v3
v90 (?) = Addr <*string> {"".statictmp_0} v3
v92 (?) = OffPtr <*interface {}> [0] v2
v97 (?) = Const64 <int> [1]
v93 (?) = ConstNil <*byte>
v87 (?) = SliceMake <[]byte> v93 v6 v6
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v11 (16) = OffPtr <*int> [264] v5
v10 (+16) = NilCheck <void> v5 v9
v12 (16) = Load <int> v11 v9
v13 (16) = Less64 <bool> v7 v12
If v13 → b3 b5 (likely) (16)
b3: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v15
v17 (+17) = Zero <mem> {[1024]byte} [1024] v16 v15
v18 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v17 (buf.ptr[*byte])
Plain → b6 (17)
b4: ← b15
v98 (+16) = Add64 <int> v7 v97 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b6: ← b3
Plain → b8 (17)
b8: ← b6
v27 (17) = SliceMake <[]byte> v18 v6 v20
v36 (+18) = Load <*uint8> v30 v17
v26 (+18) = OffPtr <*int> [8] v30
v29 (+18) = Load <int> v26 v17
v32 (+18) = StringMake <string> v36 v29
v38 (18) = Greater64U <bool> v29 v20
If v38 → b9 b10 (18)
b9: ← b8
v42 (18) = Store <mem> {*byte} v40 v39 v17
v25 (18) = OffPtr <*int> [24] v2
v24 (18) = OffPtr <*int> [16] v2
v21 (18) = Store <mem> {*uint8} v44 v18 v42
v85 (18) = OffPtr <*int> [48] v2
v81 (18) = OffPtr <*int> [56] v2
v23 (18) = Store <mem> {int} v24 v6 v21
v45 (18) = Store <mem> {int} v25 v20 v23
v48 (18) = Store <mem> {int} v47 v29 v45
v49 (18) = StaticCall <mem> {runtime.growslice} [64] v48
v104 (18) = Load <*byte> v50 v49
v105 (18) = Load <int> v85 v49
v80 (18) = Load <int> v81 v49
v51 (18) = SliceMake <[]byte> v104 v105 v80
Plain → b10 (18)
b10: ← b8 b9
v101 (18) = Phi <mem> v17 v49
v19 (18) = Phi <*uint8> v18 v104
v69 (18) = Phi <int> v6 v105
v71 (18) = Phi <int> v20 v80
v52 (18) = SliceMake <[]byte> v19 v69 v71
Plain → b11 (18)
b11: ← b10
v60 (18) = IsSliceInBounds <bool> v29 v71
If v60 → b13 b12 (likely) (18)
b12: ← b11
v59 (18) = StaticCall <mem> {runtime.panicslice} v101
Exit v59 (18)
b13: ← b11
v74 (18) = Store <mem> {*byte} v40 v19 v101
v73 (18) = Load <*uint8> v30 v101
v61 (18) = OffPtr <*int> [8] v30
v34 (18) = Load <*uint8> v30 v74
v106 (18) = OffPtr <*int> [8] v30
v79 (18) = Store <mem> {*byte} v78 v34 v74
v62 (18) = Load <int> v61 v101
v58 (18) = Load <int> v106 v74
v66 (18) = StringMake <string> v73 v62
v76 (18) = StringMake <string> v34 v58
v83 (18) = Store <mem> {uintptr} v82 v62 v79
v84 (18) = StaticCall <mem> {runtime.memmove} [24] v83
Plain → b14 (+20)
b14: ← b13
v68 (21) = Copy <*uint8> v19
v65 (+21) = IsNonNil <bool> v19
v88 (+21) = Not <bool> v65
If v65 → b17 b16 (21)
b15: ← b17
Plain → b4 (16)
b16: ← b14
v91 (+22) = IMake <interface {}> v89 v90
v103 (22) = OffPtr <**uint8> [8] v2
v100 (22) = Store <mem> {uintptr} v92 v89 v84
v94 (22) = Store <mem> {*uint8} v103 v90 v100
v95 (22) = StaticCall <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17: ← b14
Plain → b15 (16)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.ptr[*byte]: v18 
name buf.len[int]: v6 
name buf.cap[int]: v20

generic deadcode

generic deadcode [13634 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = Const64 <int> [0] (i[int], buf.len[int])
v20 (?) = Const64 <int> [1024] (buf.cap[int])
v30 (?) = Addr <*string> {"".data} v3
v39 (?) = Addr <*uint8> {type.uint8} v3
v40 (?) = OffPtr <**byte> [0] v2
v44 (?) = OffPtr <*[]byte> [8] v2
v47 (?) = OffPtr <*int> [32] v2
v50 (?) = OffPtr <*[]byte> [40] v2
v78 (?) = OffPtr <**byte> [8] v2
v82 (?) = OffPtr <*uintptr> [16] v2
v89 (?) = Addr <*uint8> {type.string} v3
v90 (?) = Addr <*string> {"".statictmp_0} v3
v92 (?) = OffPtr <*interface {}> [0] v2
v97 (?) = Const64 <int> [1]
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v11 (16) = OffPtr <*int> [264] v5
v10 (+16) = NilCheck <void> v5 v9
v12 (16) = Load <int> v11 v9
v13 (16) = Less64 <bool> v7 v12
If v13 → b3 b5 (likely) (16)
b3: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v15
v17 (+17) = Zero <mem> {[1024]byte} [1024] v16 v15
v18 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v17 (buf.ptr[*byte])
Plain → b6 (17)
b4: ← b15
v98 (+16) = Add64 <int> v7 v97 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b6: ← b3
Plain → b8 (17)
b8: ← b6
v26 (+18) = OffPtr <*int> [8] v30
v29 (+18) = Load <int> v26 v17
v38 (18) = Greater64U <bool> v29 v20
If v38 → b9 b10 (18)
b9: ← b8
v42 (18) = Store <mem> {*byte} v40 v39 v17
v25 (18) = OffPtr <*int> [24] v2
v24 (18) = OffPtr <*int> [16] v2
v21 (18) = Store <mem> {*uint8} v44 v18 v42
v81 (18) = OffPtr <*int> [56] v2
v23 (18) = Store <mem> {int} v24 v6 v21
v45 (18) = Store <mem> {int} v25 v20 v23
v48 (18) = Store <mem> {int} v47 v29 v45
v49 (18) = StaticCall <mem> {runtime.growslice} [64] v48
v104 (18) = Load <*byte> v50 v49
v80 (18) = Load <int> v81 v49
Plain → b10 (18)
b10: ← b8 b9
v101 (18) = Phi <mem> v17 v49
v19 (18) = Phi <*uint8> v18 v104
v71 (18) = Phi <int> v20 v80
Plain → b11 (18)
b11: ← b10
v60 (18) = IsSliceInBounds <bool> v29 v71
If v60 → b13 b12 (likely) (18)
b12: ← b11
v59 (18) = StaticCall <mem> {runtime.panicslice} v101
Exit v59 (18)
b13: ← b11
v74 (18) = Store <mem> {*byte} v40 v19 v101
v61 (18) = OffPtr <*int> [8] v30
v34 (18) = Load <*uint8> v30 v74
v79 (18) = Store <mem> {*byte} v78 v34 v74
v62 (18) = Load <int> v61 v101
v83 (18) = Store <mem> {uintptr} v82 v62 v79
v84 (18) = StaticCall <mem> {runtime.memmove} [24] v83
Plain → b14 (+20)
b14: ← b13
v65 (+21) = IsNonNil <bool> v19
If v65 → b17 b16 (21)
b15: ← b17
Plain → b4 (16)
b16: ← b14
v103 (22) = OffPtr <**uint8> [8] v2
v100 (+22) = Store <mem> {uintptr} v92 v89 v84
v94 (22) = Store <mem> {*uint8} v103 v90 v100
v95 (22) = StaticCall <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17: ← b14
Plain → b15 (16)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.ptr[*byte]: v18 
name buf.len[int]: v6 
name buf.cap[int]: v20

check bce

check bce [233 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = Const64 <int> [0] (buf.len[int], i[int])
v20 (?) = Const64 <int> [1024] (buf.cap[int])
v30 (?) = Addr <*string> {"".data} v3
v39 (?) = Addr <*uint8> {type.uint8} v3
v40 (?) = OffPtr <**byte> [0] v2
v44 (?) = OffPtr <*[]byte> [8] v2
v47 (?) = OffPtr <*int> [32] v2
v50 (?) = OffPtr <*[]byte> [40] v2
v78 (?) = OffPtr <**byte> [8] v2
v82 (?) = OffPtr <*uintptr> [16] v2
v89 (?) = Addr <*uint8> {type.string} v3
v90 (?) = Addr <*string> {"".statictmp_0} v3
v92 (?) = OffPtr <*interface {}> [0] v2
v97 (?) = Const64 <int> [1]
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v11 (16) = OffPtr <*int> [264] v5
v10 (+16) = NilCheck <void> v5 v9
v12 (16) = Load <int> v11 v9
v13 (16) = Less64 <bool> v7 v12
If v13 → b3 b5 (likely) (16)
b3: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v15
v17 (+17) = Zero <mem> {[1024]byte} [1024] v16 v15
v18 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v17 (buf.ptr[*byte])
Plain → b6 (17)
b4: ← b15
v98 (+16) = Add64 <int> v7 v97 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b6: ← b3
Plain → b8 (17)
b8: ← b6
v26 (+18) = OffPtr <*int> [8] v30
v29 (+18) = Load <int> v26 v17
v38 (18) = Greater64U <bool> v29 v20
If v38 → b9 b10 (18)
b9: ← b8
v42 (18) = Store <mem> {*byte} v40 v39 v17
v25 (18) = OffPtr <*int> [24] v2
v24 (18) = OffPtr <*int> [16] v2
v21 (18) = Store <mem> {*uint8} v44 v18 v42
v81 (18) = OffPtr <*int> [56] v2
v23 (18) = Store <mem> {int} v24 v6 v21
v45 (18) = Store <mem> {int} v25 v20 v23
v48 (18) = Store <mem> {int} v47 v29 v45
v49 (18) = StaticCall <mem> {runtime.growslice} [64] v48
v104 (18) = Load <*byte> v50 v49
v80 (18) = Load <int> v81 v49
Plain → b10 (18)
b10: ← b8 b9
v101 (18) = Phi <mem> v17 v49
v19 (18) = Phi <*uint8> v18 v104
v71 (18) = Phi <int> v20 v80
Plain → b11 (18)
b11: ← b10
v60 (18) = IsSliceInBounds <bool> v29 v71
If v60 → b13 b12 (likely) (18)
b12: ← b11
v59 (18) = StaticCall <mem> {runtime.panicslice} v101
Exit v59 (18)
b13: ← b11
v74 (18) = Store <mem> {*byte} v40 v19 v101
v61 (18) = OffPtr <*int> [8] v30
v34 (18) = Load <*uint8> v30 v74
v79 (18) = Store <mem> {*byte} v78 v34 v74
v62 (18) = Load <int> v61 v101
v83 (18) = Store <mem> {uintptr} v82 v62 v79
v84 (18) = StaticCall <mem> {runtime.memmove} [24] v83
Plain → b14 (+20)
b14: ← b13
v65 (+21) = IsNonNil <bool> v19
If v65 → b17 b16 (21)
b15: ← b17
Plain → b4 (16)
b16: ← b14
v103 (22) = OffPtr <**uint8> [8] v2
v100 (+22) = Store <mem> {uintptr} v92 v89 v84
v94 (22) = Store <mem> {*uint8} v103 v90 v100
v95 (22) = StaticCall <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17: ← b14
Plain → b15 (16)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.ptr[*byte]: v18 
name buf.len[int]: v6 
name buf.cap[int]: v20

branchelim

branchelim [5399 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = Const64 <int> [0] (buf.len[int], i[int])
v20 (?) = Const64 <int> [1024] (buf.cap[int])
v30 (?) = Addr <*string> {"".data} v3
v39 (?) = Addr <*uint8> {type.uint8} v3
v40 (?) = OffPtr <**byte> [0] v2
v44 (?) = OffPtr <*[]byte> [8] v2
v47 (?) = OffPtr <*int> [32] v2
v50 (?) = OffPtr <*[]byte> [40] v2
v78 (?) = OffPtr <**byte> [8] v2
v82 (?) = OffPtr <*uintptr> [16] v2
v89 (?) = Addr <*uint8> {type.string} v3
v90 (?) = Addr <*string> {"".statictmp_0} v3
v92 (?) = OffPtr <*interface {}> [0] v2
v97 (?) = Const64 <int> [1]
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v11 (16) = OffPtr <*int> [264] v5
v10 (+16) = NilCheck <void> v5 v9
v12 (16) = Load <int> v11 v9
v13 (16) = Less64 <bool> v7 v12
If v13 → b3 b5 (likely) (16)
b3: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v15
v17 (+17) = Zero <mem> {[1024]byte} [1024] v16 v15
v18 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v17 (buf.ptr[*byte])
Plain → b6 (17)
b4: ← b15
v98 (+16) = Add64 <int> v7 v97 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b6: ← b3
Plain → b8 (17)
b8: ← b6
v26 (+18) = OffPtr <*int> [8] v30
v29 (+18) = Load <int> v26 v17
v38 (18) = Greater64U <bool> v29 v20
If v38 → b9 b10 (18)
b9: ← b8
v42 (18) = Store <mem> {*byte} v40 v39 v17
v25 (18) = OffPtr <*int> [24] v2
v24 (18) = OffPtr <*int> [16] v2
v21 (18) = Store <mem> {*uint8} v44 v18 v42
v81 (18) = OffPtr <*int> [56] v2
v23 (18) = Store <mem> {int} v24 v6 v21
v45 (18) = Store <mem> {int} v25 v20 v23
v48 (18) = Store <mem> {int} v47 v29 v45
v49 (18) = StaticCall <mem> {runtime.growslice} [64] v48
v104 (18) = Load <*byte> v50 v49
v80 (18) = Load <int> v81 v49
Plain → b10 (18)
b10: ← b8 b9
v101 (18) = Phi <mem> v17 v49
v19 (18) = Phi <*uint8> v18 v104
v71 (18) = Phi <int> v20 v80
Plain → b11 (18)
b11: ← b10
v60 (18) = IsSliceInBounds <bool> v29 v71
If v60 → b13 b12 (likely) (18)
b12: ← b11
v59 (18) = StaticCall <mem> {runtime.panicslice} v101
Exit v59 (18)
b13: ← b11
v74 (18) = Store <mem> {*byte} v40 v19 v101
v61 (18) = OffPtr <*int> [8] v30
v34 (18) = Load <*uint8> v30 v74
v79 (18) = Store <mem> {*byte} v78 v34 v74
v62 (18) = Load <int> v61 v101
v83 (18) = Store <mem> {uintptr} v82 v62 v79
v84 (18) = StaticCall <mem> {runtime.memmove} [24] v83
Plain → b14 (+20)
b14: ← b13
v65 (+21) = IsNonNil <bool> v19
If v65 → b17 b16 (21)
b15: ← b17
Plain → b4 (16)
b16: ← b14
v103 (22) = OffPtr <**uint8> [8] v2
v100 (+22) = Store <mem> {uintptr} v92 v89 v84
v94 (22) = Store <mem> {*uint8} v103 v90 v100
v95 (22) = StaticCall <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17: ← b14
Plain → b15 (16)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.ptr[*byte]: v18 
name buf.len[int]: v6 
name buf.cap[int]: v20

fuse

fuse [2367 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = Const64 <int> [0] (i[int], buf.len[int])
v20 (?) = Const64 <int> [1024] (buf.cap[int])
v30 (?) = Addr <*string> {"".data} v3
v39 (?) = Addr <*uint8> {type.uint8} v3
v40 (?) = OffPtr <**byte> [0] v2
v44 (?) = OffPtr <*[]byte> [8] v2
v47 (?) = OffPtr <*int> [32] v2
v50 (?) = OffPtr <*[]byte> [40] v2
v78 (?) = OffPtr <**byte> [8] v2
v82 (?) = OffPtr <*uintptr> [16] v2
v89 (?) = Addr <*uint8> {type.string} v3
v90 (?) = Addr <*string> {"".statictmp_0} v3
v92 (?) = OffPtr <*interface {}> [0] v2
v97 (?) = Const64 <int> [1]
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v11 (16) = OffPtr <*int> [264] v5
v10 (+16) = NilCheck <void> v5 v9
v12 (16) = Load <int> v11 v9
v13 (16) = Less64 <bool> v7 v12
If v13 → b8 b5 (likely) (16)
b3:
BlockInvalid (17)
b4: ← b14
v98 (+16) = Add64 <int> v7 v97 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b6:
BlockInvalid (17)
b8: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v15
v17 (+17) = Zero <mem> {[1024]byte} [1024] v16 v15
v18 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v17 (buf.ptr[*byte])
v26 (+18) = OffPtr <*int> [8] v30
v29 (+18) = Load <int> v26 v17
v38 (18) = Greater64U <bool> v29 v20
If v38 → b9 b11 (18)
b9: ← b8
v42 (18) = Store <mem> {*byte} v40 v39 v17
v25 (18) = OffPtr <*int> [24] v2
v24 (18) = OffPtr <*int> [16] v2
v21 (18) = Store <mem> {*uint8} v44 v18 v42
v81 (18) = OffPtr <*int> [56] v2
v23 (18) = Store <mem> {int} v24 v6 v21
v45 (18) = Store <mem> {int} v25 v20 v23
v48 (18) = Store <mem> {int} v47 v29 v45
v49 (18) = StaticCall <mem> {runtime.growslice} [64] v48
v104 (18) = Load <*byte> v50 v49
v80 (18) = Load <int> v81 v49
Plain → b11 (18)
b10:
BlockInvalid (18)
b11: ← b8 b9
v101 (18) = Phi <mem> v17 v49
v19 (18) = Phi <*uint8> v18 v104
v71 (18) = Phi <int> v20 v80
v60 (18) = IsSliceInBounds <bool> v29 v71
If v60 → b14 b12 (likely) (18)
b12: ← b11
v59 (18) = StaticCall <mem> {runtime.panicslice} v101
Exit v59 (18)
b13:
BlockInvalid (+20)
b14: ← b11
v74 (18) = Store <mem> {*byte} v40 v19 v101
v61 (18) = OffPtr <*int> [8] v30
v34 (18) = Load <*uint8> v30 v74
v65 (+21) = IsNonNil <bool> v19
v79 (18) = Store <mem> {*byte} v78 v34 v74
v62 (18) = Load <int> v61 v101
v83 (18) = Store <mem> {uintptr} v82 v62 v79
v84 (18) = StaticCall <mem> {runtime.memmove} [24] v83
If v65 → b4 b16 (21)
b15:
BlockInvalid (16)
b16: ← b14
v103 (22) = OffPtr <**uint8> [8] v2
v100 (+22) = Store <mem> {uintptr} v92 v89 v84
v94 (22) = Store <mem> {*uint8} v103 v90 v100
v95 (22) = StaticCall <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17:
BlockInvalid (16)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.ptr[*byte]: v18 
name buf.len[int]: v6 
name buf.cap[int]: v20

dse

dse [8830 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = Const64 <int> [0] (i[int], buf.len[int])
v20 (?) = Const64 <int> [1024] (buf.cap[int])
v30 (?) = Addr <*string> {"".data} v3
v39 (?) = Addr <*uint8> {type.uint8} v3
v40 (?) = OffPtr <**byte> [0] v2
v44 (?) = OffPtr <*[]byte> [8] v2
v47 (?) = OffPtr <*int> [32] v2
v50 (?) = OffPtr <*[]byte> [40] v2
v78 (?) = OffPtr <**byte> [8] v2
v82 (?) = OffPtr <*uintptr> [16] v2
v89 (?) = Addr <*uint8> {type.string} v3
v90 (?) = Addr <*string> {"".statictmp_0} v3
v92 (?) = OffPtr <*interface {}> [0] v2
v97 (?) = Const64 <int> [1]
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v11 (16) = OffPtr <*int> [264] v5
v10 (+16) = NilCheck <void> v5 v9
v12 (16) = Load <int> v11 v9
v13 (16) = Less64 <bool> v7 v12
If v13 → b8 b5 (likely) (16)
b3:
BlockInvalid (17)
b4: ← b14
v98 (+16) = Add64 <int> v7 v97 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b6:
BlockInvalid (17)
b8: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v15
v17 (+17) = Zero <mem> {[1024]byte} [1024] v16 v15
v18 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v17 (buf.ptr[*byte])
v26 (+18) = OffPtr <*int> [8] v30
v29 (+18) = Load <int> v26 v17
v38 (18) = Greater64U <bool> v29 v20
If v38 → b9 b11 (18)
b9: ← b8
v42 (18) = Store <mem> {*byte} v40 v39 v17
v25 (18) = OffPtr <*int> [24] v2
v24 (18) = OffPtr <*int> [16] v2
v21 (18) = Store <mem> {*uint8} v44 v18 v42
v81 (18) = OffPtr <*int> [56] v2
v23 (18) = Store <mem> {int} v24 v6 v21
v45 (18) = Store <mem> {int} v25 v20 v23
v48 (18) = Store <mem> {int} v47 v29 v45
v49 (18) = StaticCall <mem> {runtime.growslice} [64] v48
v104 (18) = Load <*byte> v50 v49
v80 (18) = Load <int> v81 v49
Plain → b11 (18)
b10:
BlockInvalid (18)
b11: ← b8 b9
v101 (18) = Phi <mem> v17 v49
v19 (18) = Phi <*uint8> v18 v104
v71 (18) = Phi <int> v20 v80
v60 (18) = IsSliceInBounds <bool> v29 v71
If v60 → b14 b12 (likely) (18)
b12: ← b11
v59 (18) = StaticCall <mem> {runtime.panicslice} v101
Exit v59 (18)
b13:
BlockInvalid (+20)
b14: ← b11
v74 (18) = Store <mem> {*byte} v40 v19 v101
v61 (18) = OffPtr <*int> [8] v30
v34 (18) = Load <*uint8> v30 v74
v65 (+21) = IsNonNil <bool> v19
v79 (18) = Store <mem> {*byte} v78 v34 v74
v62 (18) = Load <int> v61 v101
v83 (18) = Store <mem> {uintptr} v82 v62 v79
v84 (18) = StaticCall <mem> {runtime.memmove} [24] v83
If v65 → b4 b16 (21)
b15:
BlockInvalid (16)
b16: ← b14
v103 (22) = OffPtr <**uint8> [8] v2
v100 (+22) = Store <mem> {uintptr} v92 v89 v84
v94 (22) = Store <mem> {*uint8} v103 v90 v100
v95 (22) = StaticCall <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17:
BlockInvalid (16)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.ptr[*byte]: v18 
name buf.len[int]: v6 
name buf.cap[int]: v20

writebarrier

writebarrier [5498 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = Const64 <int> [0] (i[int], buf.len[int])
v20 (?) = Const64 <int> [1024] (buf.cap[int])
v30 (?) = Addr <*string> {"".data} v3
v39 (?) = Addr <*uint8> {type.uint8} v3
v40 (?) = OffPtr <**byte> [0] v2
v44 (?) = OffPtr <*[]byte> [8] v2
v47 (?) = OffPtr <*int> [32] v2
v50 (?) = OffPtr <*[]byte> [40] v2
v78 (?) = OffPtr <**byte> [8] v2
v82 (?) = OffPtr <*uintptr> [16] v2
v89 (?) = Addr <*uint8> {type.string} v3
v90 (?) = Addr <*string> {"".statictmp_0} v3
v92 (?) = OffPtr <*interface {}> [0] v2
v97 (?) = Const64 <int> [1]
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v11 (16) = OffPtr <*int> [264] v5
v10 (+16) = NilCheck <void> v5 v9
v12 (16) = Load <int> v11 v9
v13 (16) = Less64 <bool> v7 v12
If v13 → b8 b5 (likely) (16)
b3:
BlockInvalid (17)
b4: ← b14
v98 (+16) = Add64 <int> v7 v97 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b6:
BlockInvalid (17)
b8: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v15
v17 (+17) = Zero <mem> {[1024]byte} [1024] v16 v15
v18 (17) = LocalAddr <*[1024]byte> {.autotmp_3} v2 v17 (buf.ptr[*byte])
v26 (+18) = OffPtr <*int> [8] v30
v29 (+18) = Load <int> v26 v17
v38 (18) = Greater64U <bool> v29 v20
If v38 → b9 b11 (18)
b9: ← b8
v42 (18) = Store <mem> {*byte} v40 v39 v17
v25 (18) = OffPtr <*int> [24] v2
v24 (18) = OffPtr <*int> [16] v2
v21 (18) = Store <mem> {*uint8} v44 v18 v42
v81 (18) = OffPtr <*int> [56] v2
v23 (18) = Store <mem> {int} v24 v6 v21
v45 (18) = Store <mem> {int} v25 v20 v23
v48 (18) = Store <mem> {int} v47 v29 v45
v49 (18) = StaticCall <mem> {runtime.growslice} [64] v48
v104 (18) = Load <*byte> v50 v49
v80 (18) = Load <int> v81 v49
Plain → b11 (18)
b10:
BlockInvalid (18)
b11: ← b8 b9
v101 (18) = Phi <mem> v17 v49
v19 (18) = Phi <*uint8> v18 v104
v71 (18) = Phi <int> v20 v80
v60 (18) = IsSliceInBounds <bool> v29 v71
If v60 → b14 b12 (likely) (18)
b12: ← b11
v59 (18) = StaticCall <mem> {runtime.panicslice} v101
Exit v59 (18)
b13:
BlockInvalid (+20)
b14: ← b11
v74 (18) = Store <mem> {*byte} v40 v19 v101
v61 (18) = OffPtr <*int> [8] v30
v34 (18) = Load <*uint8> v30 v74
v65 (+21) = IsNonNil <bool> v19
v79 (18) = Store <mem> {*byte} v78 v34 v74
v62 (18) = Load <int> v61 v101
v83 (18) = Store <mem> {uintptr} v82 v62 v79
v84 (18) = StaticCall <mem> {runtime.memmove} [24] v83
If v65 → b4 b16 (21)
b15:
BlockInvalid (16)
b16: ← b14
v103 (22) = OffPtr <**uint8> [8] v2
v100 (+22) = Store <mem> {uintptr} v92 v89 v84
v94 (22) = Store <mem> {*uint8} v103 v90 v100
v95 (22) = StaticCall <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17:
BlockInvalid (16)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.ptr[*byte]: v18 
name buf.len[int]: v6 
name buf.cap[int]: v20

lower

lower [122249 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = MOVQconst <int> [0] (buf.len[int], i[int])
v20 (?) = MOVQconst <int> [1024] (buf.cap[int])
v30 (?) = LEAQ <*string> {"".data} v3
v39 (?) = LEAQ <*uint8> {type.uint8} v3
v44 (?) = LEAQ <*[]byte> [8] v2
v47 (?) = LEAQ <*int> [32] v2
v50 (?) = LEAQ <*[]byte> [40] v2
v78 (?) = LEAQ <**byte> [8] v2
v82 (?) = LEAQ <*uintptr> [16] v2
v89 (?) = LEAQ <*uint8> {type.string} v3
v90 (?) = LEAQ <*string> {"".statictmp_0} v3
v97 (?) = MOVQconst <int> [1]
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v11 (16) = ADDQconst <*int> [264] v5
v10 (+16) = LoweredNilCheck <void> v5 v9
v12 (16) = MOVQload <int> [264] v5 v9
v68 (16) = CMPQ <flags> v7 v12
v13 (16) = SETL <bool> v68
v91 (16) = TESTB <flags> v13 v13
LT v68 → b8 b5 (likely) (16)
b3:
BlockInvalid (17)
b4: ← b14
v98 (+16) = ADDQconst <int> [1] v7 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b6:
BlockInvalid (17)
b8: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LEAQ <*[1024]byte> {.autotmp_3} v2
v18 (17) = LEAQ <*[1024]byte> {.autotmp_3} v2 (buf.ptr[*byte])
v26 (+18) = LEAQ <*int> {"".data} [8] v3
v106 (+17) = MOVOconst <int128> [0]
v17 (+17) = DUFFZERO <mem> [1024] v16 v106 v15
v29 (+18) = MOVQload <int> {"".data} [8] v3 v17
v58 (18) = CMPQconst <flags> [1024] v29
v38 (18) = SETA <bool> v58
v88 (18) = TESTB <flags> v38 v38
UGT v58 → b9 b11 (18)
b9: ← b8
v42 (18) = MOVQstore <mem> v2 v39 v17
v25 (18) = LEAQ <*int> [24] v2
v24 (18) = LEAQ <*int> [16] v2
v21 (18) = MOVQstore <mem> [8] v2 v18 v42
v81 (18) = LEAQ <*int> [56] v2
v23 (18) = MOVQstoreconst <mem> [val=0,off=16] v2 v21
v45 (18) = MOVQstoreconst <mem> [val=1024,off=24] v2 v23
v48 (18) = MOVQstore <mem> [32] v2 v29 v45
v49 (18) = CALLstatic <mem> {runtime.growslice} [64] v48
v104 (18) = MOVQload <*byte> [40] v2 v49
v80 (18) = MOVQload <int> [56] v2 v49
Plain → b11 (18)
b10:
BlockInvalid (18)
b11: ← b8 b9
v101 (18) = Phi <mem> v17 v49
v19 (18) = Phi <*uint8> v18 v104
v71 (18) = Phi <int> v20 v80
v76 (18) = CMPQ <flags> v29 v71
v60 (18) = SETBE <bool> v76
v73 (18) = TESTB <flags> v60 v60
ULE v76 → b14 b12 (likely) (18)
b12: ← b11
v59 (18) = CALLstatic <mem> {runtime.panicslice} v101
Exit v59 (18)
b13:
BlockInvalid (+20)
b14: ← b11
v74 (18) = MOVQstore <mem> v2 v19 v101
v62 (18) = MOVQload <int> {"".data} [8] v3 v101
v61 (18) = LEAQ <*int> {"".data} [8] v3
v34 (18) = MOVQload <*uint8> {"".data} v3 v74
v69 (+21) = TESTQ <flags> v19 v19
v79 (18) = MOVQstore <mem> [8] v2 v34 v74
v83 (18) = MOVQstore <mem> [16] v2 v62 v79
v84 (18) = CALLstatic <mem> {runtime.memmove} [24] v83
v65 (+21) = SETNE <bool> v69
v66 (+21) = TESTB <flags> v65 v65
NE v69 → b4 b16 (21)
b15:
BlockInvalid (16)
b16: ← b14
v103 (22) = LEAQ <**uint8> [8] v2
v100 (+22) = MOVQstore <mem> v2 v89 v84
v94 (22) = MOVQstore <mem> [8] v2 v90 v100
v95 (22) = CALLstatic <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17:
BlockInvalid (16)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.ptr[*byte]: v18 
name buf.len[int]: v6 
name buf.cap[int]: v20

lowered cse

lowered cse [48867 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = MOVQconst <int> [0] (buf.len[int], i[int])
v20 (?) = MOVQconst <int> [1024] (buf.cap[int])
v30 (?) = LEAQ <*string> {"".data} v3
v39 (?) = LEAQ <*uint8> {type.uint8} v3
v44 (?) = LEAQ <*[]byte> [8] v2
v47 (?) = LEAQ <*int> [32] v2
v50 (?) = LEAQ <*[]byte> [40] v2
v78 (?) = LEAQ <**byte> [8] v2
v82 (?) = LEAQ <*uintptr> [16] v2
v89 (?) = LEAQ <*uint8> {type.string} v3
v90 (?) = LEAQ <*string> {"".statictmp_0} v3
v97 (?) = MOVQconst <int> [1]
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v11 (16) = ADDQconst <*int> [264] v5
v10 (+16) = LoweredNilCheck <void> v5 v9
v12 (16) = MOVQload <int> [264] v5 v9
v68 (16) = CMPQ <flags> v7 v12
v13 (16) = SETL <bool> v68
v91 (16) = TESTB <flags> v13 v13
LT v68 → b8 b5 (likely) (16)
b3:
BlockInvalid (17)
b4: ← b14
v98 (+16) = ADDQconst <int> [1] v7 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b6:
BlockInvalid (17)
b8: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LEAQ <*[1024]byte> {.autotmp_3} v2
v18 (17) = LEAQ <*[1024]byte> {.autotmp_3} v2 (buf.ptr[*byte])
v26 (+18) = LEAQ <*int> {"".data} [8] v3
v106 (+17) = MOVOconst <int128> [0]
v17 (+17) = DUFFZERO <mem> [1024] v16 v106 v15
v29 (+18) = MOVQload <int> {"".data} [8] v3 v17
v58 (18) = CMPQconst <flags> [1024] v29
v38 (18) = SETA <bool> v58
v88 (18) = TESTB <flags> v38 v38
UGT v58 → b9 b11 (18)
b9: ← b8
v42 (18) = MOVQstore <mem> v2 v39 v17
v25 (18) = LEAQ <*int> [24] v2
v24 (18) = LEAQ <*int> [16] v2
v21 (18) = MOVQstore <mem> [8] v2 v16 v42
v81 (18) = LEAQ <*int> [56] v2
v23 (18) = MOVQstoreconst <mem> [val=0,off=16] v2 v21
v45 (18) = MOVQstoreconst <mem> [val=1024,off=24] v2 v23
v48 (18) = MOVQstore <mem> [32] v2 v29 v45
v49 (18) = CALLstatic <mem> {runtime.growslice} [64] v48
v104 (18) = MOVQload <*byte> [40] v2 v49
v80 (18) = MOVQload <int> [56] v2 v49
Plain → b11 (18)
b10:
BlockInvalid (18)
b11: ← b8 b9
v101 (18) = Phi <mem> v17 v49
v19 (18) = Phi <*uint8> v16 v104
v71 (18) = Phi <int> v20 v80
v76 (18) = CMPQ <flags> v29 v71
v60 (18) = SETBE <bool> v76
v73 (18) = TESTB <flags> v60 v60
ULE v76 → b14 b12 (likely) (18)
b12: ← b11
v59 (18) = CALLstatic <mem> {runtime.panicslice} v101
Exit v59 (18)
b13:
BlockInvalid (+20)
b14: ← b11
v74 (18) = MOVQstore <mem> v2 v19 v101
v62 (18) = MOVQload <int> {"".data} [8] v3 v101
v61 (18) = LEAQ <*int> {"".data} [8] v3
v34 (18) = MOVQload <*uint8> {"".data} v3 v74
v69 (+21) = TESTQ <flags> v19 v19
v79 (18) = MOVQstore <mem> [8] v2 v34 v74
v83 (18) = MOVQstore <mem> [16] v2 v62 v79
v84 (18) = CALLstatic <mem> {runtime.memmove} [24] v83
v65 (+21) = SETNE <bool> v69
v66 (+21) = TESTB <flags> v65 v65
NE v69 → b4 b16 (21)
b15:
BlockInvalid (16)
b16: ← b14
v103 (22) = LEAQ <**uint8> [8] v2
v100 (+22) = MOVQstore <mem> v2 v89 v84
v94 (22) = MOVQstore <mem> [8] v2 v90 v100
v95 (22) = CALLstatic <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17:
BlockInvalid (16)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.ptr[*byte]: v18 
name buf.len[int]: v6 
name buf.cap[int]: v20

elim unread autos

elim unread autos [3870 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = MOVQconst <int> [0] (i[int], buf.len[int])
v20 (?) = MOVQconst <int> [1024] (buf.cap[int])
v30 (?) = LEAQ <*string> {"".data} v3
v39 (?) = LEAQ <*uint8> {type.uint8} v3
v44 (?) = LEAQ <*[]byte> [8] v2
v47 (?) = LEAQ <*int> [32] v2
v50 (?) = LEAQ <*[]byte> [40] v2
v78 (?) = LEAQ <**byte> [8] v2
v82 (?) = LEAQ <*uintptr> [16] v2
v89 (?) = LEAQ <*uint8> {type.string} v3
v90 (?) = LEAQ <*string> {"".statictmp_0} v3
v97 (?) = MOVQconst <int> [1]
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v11 (16) = ADDQconst <*int> [264] v5
v10 (+16) = LoweredNilCheck <void> v5 v9
v12 (16) = MOVQload <int> [264] v5 v9
v68 (16) = CMPQ <flags> v7 v12
v13 (16) = SETL <bool> v68
v91 (16) = TESTB <flags> v13 v13
LT v68 → b8 b5 (likely) (16)
b3:
BlockInvalid (17)
b4: ← b14
v98 (+16) = ADDQconst <int> [1] v7 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b6:
BlockInvalid (17)
b8: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LEAQ <*[1024]byte> {.autotmp_3} v2
v18 (17) = LEAQ <*[1024]byte> {.autotmp_3} v2 (buf.ptr[*byte])
v26 (+18) = LEAQ <*int> {"".data} [8] v3
v106 (+17) = MOVOconst <int128> [0]
v17 (+17) = DUFFZERO <mem> [1024] v16 v106 v15
v29 (+18) = MOVQload <int> {"".data} [8] v3 v17
v58 (18) = CMPQconst <flags> [1024] v29
v38 (18) = SETA <bool> v58
v88 (18) = TESTB <flags> v38 v38
UGT v58 → b9 b11 (18)
b9: ← b8
v42 (18) = MOVQstore <mem> v2 v39 v17
v25 (18) = LEAQ <*int> [24] v2
v24 (18) = LEAQ <*int> [16] v2
v21 (18) = MOVQstore <mem> [8] v2 v16 v42
v81 (18) = LEAQ <*int> [56] v2
v23 (18) = MOVQstoreconst <mem> [val=0,off=16] v2 v21
v45 (18) = MOVQstoreconst <mem> [val=1024,off=24] v2 v23
v48 (18) = MOVQstore <mem> [32] v2 v29 v45
v49 (18) = CALLstatic <mem> {runtime.growslice} [64] v48
v104 (18) = MOVQload <*byte> [40] v2 v49
v80 (18) = MOVQload <int> [56] v2 v49
Plain → b11 (18)
b10:
BlockInvalid (18)
b11: ← b8 b9
v101 (18) = Phi <mem> v17 v49
v19 (18) = Phi <*uint8> v16 v104
v71 (18) = Phi <int> v20 v80
v76 (18) = CMPQ <flags> v29 v71
v60 (18) = SETBE <bool> v76
v73 (18) = TESTB <flags> v60 v60
ULE v76 → b14 b12 (likely) (18)
b12: ← b11
v59 (18) = CALLstatic <mem> {runtime.panicslice} v101
Exit v59 (18)
b13:
BlockInvalid (+20)
b14: ← b11
v74 (18) = MOVQstore <mem> v2 v19 v101
v62 (18) = MOVQload <int> {"".data} [8] v3 v101
v61 (18) = LEAQ <*int> {"".data} [8] v3
v34 (18) = MOVQload <*uint8> {"".data} v3 v74
v69 (+21) = TESTQ <flags> v19 v19
v79 (18) = MOVQstore <mem> [8] v2 v34 v74
v83 (18) = MOVQstore <mem> [16] v2 v62 v79
v84 (18) = CALLstatic <mem> {runtime.memmove} [24] v83
v65 (+21) = SETNE <bool> v69
v66 (+21) = TESTB <flags> v65 v65
NE v69 → b4 b16 (21)
b15:
BlockInvalid (16)
b16: ← b14
v103 (22) = LEAQ <**uint8> [8] v2
v100 (+22) = MOVQstore <mem> v2 v89 v84
v94 (22) = MOVQstore <mem> [8] v2 v90 v100
v95 (22) = CALLstatic <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17:
BlockInvalid (16)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.ptr[*byte]: v18 
name buf.len[int]: v6 
name buf.cap[int]: v20

lowered deadcode

lowered deadcode [51048 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = MOVQconst <int> [0] (i[int], buf.len[int])
v20 (?) = MOVQconst <int> [1024] (buf.cap[int])
v39 (?) = LEAQ <*uint8> {type.uint8} v3
v89 (?) = LEAQ <*uint8> {type.string} v3
v90 (?) = LEAQ <*string> {"".statictmp_0} v3
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v10 (+16) = LoweredNilCheck <void> v5 v9
v12 (16) = MOVQload <int> [264] v5 v9
v68 (16) = CMPQ <flags> v7 v12
LT v68 → b8 b5 (likely) (16)
b4: ← b14
v98 (+16) = ADDQconst <int> [1] v7 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b8: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LEAQ <*[1024]byte> {.autotmp_3} v2
v106 (+17) = MOVOconst <int128> [0]
v17 (+17) = DUFFZERO <mem> [1024] v16 v106 v15
v29 (+18) = MOVQload <int> {"".data} [8] v3 v17
v58 (18) = CMPQconst <flags> [1024] v29
UGT v58 → b9 b11 (18)
b9: ← b8
v42 (18) = MOVQstore <mem> v2 v39 v17
v21 (18) = MOVQstore <mem> [8] v2 v16 v42
v23 (18) = MOVQstoreconst <mem> [val=0,off=16] v2 v21
v45 (18) = MOVQstoreconst <mem> [val=1024,off=24] v2 v23
v48 (18) = MOVQstore <mem> [32] v2 v29 v45
v49 (18) = CALLstatic <mem> {runtime.growslice} [64] v48
v104 (18) = MOVQload <*byte> [40] v2 v49
v80 (18) = MOVQload <int> [56] v2 v49
Plain → b11 (18)
b11: ← b8 b9
v101 (18) = Phi <mem> v17 v49
v19 (18) = Phi <*uint8> v16 v104
v71 (18) = Phi <int> v20 v80
v76 (18) = CMPQ <flags> v29 v71
ULE v76 → b14 b12 (likely) (18)
b12: ← b11
v59 (18) = CALLstatic <mem> {runtime.panicslice} v101
Exit v59 (18)
b14: ← b11
v74 (18) = MOVQstore <mem> v2 v19 v101
v62 (18) = MOVQload <int> {"".data} [8] v3 v101
v34 (18) = MOVQload <*uint8> {"".data} v3 v74
v69 (+21) = TESTQ <flags> v19 v19
v79 (18) = MOVQstore <mem> [8] v2 v34 v74
v83 (18) = MOVQstore <mem> [16] v2 v62 v79
v84 (18) = CALLstatic <mem> {runtime.memmove} [24] v83
NE v69 → b4 b16 (21)
b16: ← b14
v100 (+22) = MOVQstore <mem> v2 v89 v84
v94 (22) = MOVQstore <mem> [8] v2 v90 v100
v95 (22) = CALLstatic <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.len[int]: v6 
name buf.cap[int]: v20

checkLower

checkLower [1478 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = MOVQconst <int> [0] (i[int], buf.len[int])
v20 (?) = MOVQconst <int> [1024] (buf.cap[int])
v39 (?) = LEAQ <*uint8> {type.uint8} v3
v89 (?) = LEAQ <*uint8> {type.string} v3
v90 (?) = LEAQ <*string> {"".statictmp_0} v3
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v10 (+16) = LoweredNilCheck <void> v5 v9
v12 (16) = MOVQload <int> [264] v5 v9
v68 (16) = CMPQ <flags> v7 v12
LT v68 → b8 b5 (likely) (16)
b4: ← b14
v98 (+16) = ADDQconst <int> [1] v7 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b8: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LEAQ <*[1024]byte> {.autotmp_3} v2
v106 (+17) = MOVOconst <int128> [0]
v17 (+17) = DUFFZERO <mem> [1024] v16 v106 v15
v29 (+18) = MOVQload <int> {"".data} [8] v3 v17
v58 (18) = CMPQconst <flags> [1024] v29
UGT v58 → b9 b11 (18)
b9: ← b8
v42 (18) = MOVQstore <mem> v2 v39 v17
v21 (18) = MOVQstore <mem> [8] v2 v16 v42
v23 (18) = MOVQstoreconst <mem> [val=0,off=16] v2 v21
v45 (18) = MOVQstoreconst <mem> [val=1024,off=24] v2 v23
v48 (18) = MOVQstore <mem> [32] v2 v29 v45
v49 (18) = CALLstatic <mem> {runtime.growslice} [64] v48
v104 (18) = MOVQload <*byte> [40] v2 v49
v80 (18) = MOVQload <int> [56] v2 v49
Plain → b11 (18)
b11: ← b8 b9
v101 (18) = Phi <mem> v17 v49
v19 (18) = Phi <*uint8> v16 v104
v71 (18) = Phi <int> v20 v80
v76 (18) = CMPQ <flags> v29 v71
ULE v76 → b14 b12 (likely) (18)
b12: ← b11
v59 (18) = CALLstatic <mem> {runtime.panicslice} v101
Exit v59 (18)
b14: ← b11
v74 (18) = MOVQstore <mem> v2 v19 v101
v62 (18) = MOVQload <int> {"".data} [8] v3 v101
v34 (18) = MOVQload <*uint8> {"".data} v3 v74
v69 (+21) = TESTQ <flags> v19 v19
v79 (18) = MOVQstore <mem> [8] v2 v34 v74
v83 (18) = MOVQstore <mem> [16] v2 v62 v79
v84 (18) = CALLstatic <mem> {runtime.memmove} [24] v83
NE v69 → b4 b16 (21)
b16: ← b14
v100 (+22) = MOVQstore <mem> v2 v89 v84
v94 (22) = MOVQstore <mem> [8] v2 v90 v100
v95 (22) = CALLstatic <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.len[int]: v6 
name buf.cap[int]: v20

late phielim

late phielim [1610 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = MOVQconst <int> [0] (buf.len[int], i[int])
v20 (?) = MOVQconst <int> [1024] (buf.cap[int])
v39 (?) = LEAQ <*uint8> {type.uint8} v3
v89 (?) = LEAQ <*uint8> {type.string} v3
v90 (?) = LEAQ <*string> {"".statictmp_0} v3
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v10 (+16) = LoweredNilCheck <void> v5 v9
v12 (16) = MOVQload <int> [264] v5 v9
v68 (16) = CMPQ <flags> v7 v12
LT v68 → b8 b5 (likely) (16)
b4: ← b14
v98 (+16) = ADDQconst <int> [1] v7 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b8: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LEAQ <*[1024]byte> {.autotmp_3} v2
v106 (+17) = MOVOconst <int128> [0]
v17 (+17) = DUFFZERO <mem> [1024] v16 v106 v15
v29 (+18) = MOVQload <int> {"".data} [8] v3 v17
v58 (18) = CMPQconst <flags> [1024] v29
UGT v58 → b9 b11 (18)
b9: ← b8
v42 (18) = MOVQstore <mem> v2 v39 v17
v21 (18) = MOVQstore <mem> [8] v2 v16 v42
v23 (18) = MOVQstoreconst <mem> [val=0,off=16] v2 v21
v45 (18) = MOVQstoreconst <mem> [val=1024,off=24] v2 v23
v48 (18) = MOVQstore <mem> [32] v2 v29 v45
v49 (18) = CALLstatic <mem> {runtime.growslice} [64] v48
v104 (18) = MOVQload <*byte> [40] v2 v49
v80 (18) = MOVQload <int> [56] v2 v49
Plain → b11 (18)
b11: ← b8 b9
v101 (18) = Phi <mem> v17 v49
v19 (18) = Phi <*uint8> v16 v104
v71 (18) = Phi <int> v20 v80
v76 (18) = CMPQ <flags> v29 v71
ULE v76 → b14 b12 (likely) (18)
b12: ← b11
v59 (18) = CALLstatic <mem> {runtime.panicslice} v101
Exit v59 (18)
b14: ← b11
v74 (18) = MOVQstore <mem> v2 v19 v101
v62 (18) = MOVQload <int> {"".data} [8] v3 v101
v34 (18) = MOVQload <*uint8> {"".data} v3 v74
v69 (+21) = TESTQ <flags> v19 v19
v79 (18) = MOVQstore <mem> [8] v2 v34 v74
v83 (18) = MOVQstore <mem> [16] v2 v62 v79
v84 (18) = CALLstatic <mem> {runtime.memmove} [24] v83
NE v69 → b4 b16 (21)
b16: ← b14
v100 (+22) = MOVQstore <mem> v2 v89 v84
v94 (22) = MOVQstore <mem> [8] v2 v90 v100
v95 (22) = CALLstatic <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.len[int]: v6 
name buf.cap[int]: v20

late copyelim

late copyelim [2673 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = MOVQconst <int> [0] (buf.len[int], i[int])
v20 (?) = MOVQconst <int> [1024] (buf.cap[int])
v39 (?) = LEAQ <*uint8> {type.uint8} v3
v89 (?) = LEAQ <*uint8> {type.string} v3
v90 (?) = LEAQ <*string> {"".statictmp_0} v3
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v10 (+16) = LoweredNilCheck <void> v5 v9
v12 (16) = MOVQload <int> [264] v5 v9
v68 (16) = CMPQ <flags> v7 v12
LT v68 → b8 b5 (likely) (16)
b4: ← b14
v98 (+16) = ADDQconst <int> [1] v7 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b8: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LEAQ <*[1024]byte> {.autotmp_3} v2
v106 (+17) = MOVOconst <int128> [0]
v17 (+17) = DUFFZERO <mem> [1024] v16 v106 v15
v29 (+18) = MOVQload <int> {"".data} [8] v3 v17
v58 (18) = CMPQconst <flags> [1024] v29
UGT v58 → b9 b11 (18)
b9: ← b8
v42 (18) = MOVQstore <mem> v2 v39 v17
v21 (18) = MOVQstore <mem> [8] v2 v16 v42
v23 (18) = MOVQstoreconst <mem> [val=0,off=16] v2 v21
v45 (18) = MOVQstoreconst <mem> [val=1024,off=24] v2 v23
v48 (18) = MOVQstore <mem> [32] v2 v29 v45
v49 (18) = CALLstatic <mem> {runtime.growslice} [64] v48
v104 (18) = MOVQload <*byte> [40] v2 v49
v80 (18) = MOVQload <int> [56] v2 v49
Plain → b11 (18)
b11: ← b8 b9
v101 (18) = Phi <mem> v17 v49
v19 (18) = Phi <*uint8> v16 v104
v71 (18) = Phi <int> v20 v80
v76 (18) = CMPQ <flags> v29 v71
ULE v76 → b14 b12 (likely) (18)
b12: ← b11
v59 (18) = CALLstatic <mem> {runtime.panicslice} v101
Exit v59 (18)
b14: ← b11
v74 (18) = MOVQstore <mem> v2 v19 v101
v62 (18) = MOVQload <int> {"".data} [8] v3 v101
v34 (18) = MOVQload <*uint8> {"".data} v3 v74
v69 (+21) = TESTQ <flags> v19 v19
v79 (18) = MOVQstore <mem> [8] v2 v34 v74
v83 (18) = MOVQstore <mem> [16] v2 v62 v79
v84 (18) = CALLstatic <mem> {runtime.memmove} [24] v83
NE v69 → b4 b16 (21)
b16: ← b14
v100 (+22) = MOVQstore <mem> v2 v89 v84
v94 (22) = MOVQstore <mem> [8] v2 v90 v100
v95 (22) = CALLstatic <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.len[int]: v6 
name buf.cap[int]: v20

tighten

tighten [59912 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = MOVQconst <int> [0] (i[int], buf.len[int])
v20 (?) = MOVQconst <int> [1024] (buf.cap[int])
v39 (?) = LEAQ <*uint8> {type.uint8} v3
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v10 (+16) = LoweredNilCheck <void> v5 v9
v12 (16) = MOVQload <int> [264] v5 v9
v68 (16) = CMPQ <flags> v7 v12
LT v68 → b8 b5 (likely) (16)
b4: ← b14
v98 (+16) = ADDQconst <int> [1] v7 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b8: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LEAQ <*[1024]byte> {.autotmp_3} v2
v106 (+17) = MOVOconst <int128> [0]
v17 (+17) = DUFFZERO <mem> [1024] v16 v106 v15
v29 (+18) = MOVQload <int> {"".data} [8] v3 v17
v58 (18) = CMPQconst <flags> [1024] v29
UGT v58 → b9 b11 (18)
b9: ← b8
v42 (18) = MOVQstore <mem> v2 v39 v17
v21 (18) = MOVQstore <mem> [8] v2 v16 v42
v23 (18) = MOVQstoreconst <mem> [val=0,off=16] v2 v21
v45 (18) = MOVQstoreconst <mem> [val=1024,off=24] v2 v23
v48 (18) = MOVQstore <mem> [32] v2 v29 v45
v49 (18) = CALLstatic <mem> {runtime.growslice} [64] v48
v104 (18) = MOVQload <*byte> [40] v2 v49
v80 (18) = MOVQload <int> [56] v2 v49
Plain → b11 (18)
b11: ← b8 b9
v101 (18) = Phi <mem> v17 v49
v19 (18) = Phi <*uint8> v16 v104
v71 (18) = Phi <int> v20 v80
v76 (18) = CMPQ <flags> v29 v71
ULE v76 → b14 b12 (likely) (18)
b12: ← b11
v59 (18) = CALLstatic <mem> {runtime.panicslice} v101
Exit v59 (18)
b14: ← b11
v74 (18) = MOVQstore <mem> v2 v19 v101
v62 (18) = MOVQload <int> {"".data} [8] v3 v101
v34 (18) = MOVQload <*uint8> {"".data} v3 v74
v69 (+21) = TESTQ <flags> v19 v19
v79 (18) = MOVQstore <mem> [8] v2 v34 v74
v83 (18) = MOVQstore <mem> [16] v2 v62 v79
v84 (18) = CALLstatic <mem> {runtime.memmove} [24] v83
NE v69 → b4 b16 (21)
b16: ← b14
v89 (?) = LEAQ <*uint8> {type.string} v3
v90 (?) = LEAQ <*string> {"".statictmp_0} v3
v100 (+22) = MOVQstore <mem> v2 v89 v84
v94 (22) = MOVQstore <mem> [8] v2 v90 v100
v95 (22) = CALLstatic <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.len[int]: v6 
name buf.cap[int]: v20

phi tighten

phi tighten [11387 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = MOVQconst <int> [0] (i[int], buf.len[int])
v20 (?) = MOVQconst <int> [1024] (buf.cap[int])
v39 (?) = LEAQ <*uint8> {type.uint8} v3
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v10 (+16) = LoweredNilCheck <void> v5 v9
v12 (16) = MOVQload <int> [264] v5 v9
v68 (16) = CMPQ <flags> v7 v12
LT v68 → b8 b5 (likely) (16)
b4: ← b14
v98 (+16) = ADDQconst <int> [1] v7 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b8: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LEAQ <*[1024]byte> {.autotmp_3} v2
v106 (+17) = MOVOconst <int128> [0]
v103 (?) = MOVQconst <int> [1024]
v17 (+17) = DUFFZERO <mem> [1024] v16 v106 v15
v29 (+18) = MOVQload <int> {"".data} [8] v3 v17
v58 (18) = CMPQconst <flags> [1024] v29
UGT v58 → b9 b11 (18)
b9: ← b8
v42 (18) = MOVQstore <mem> v2 v39 v17
v21 (18) = MOVQstore <mem> [8] v2 v16 v42
v23 (18) = MOVQstoreconst <mem> [val=0,off=16] v2 v21
v45 (18) = MOVQstoreconst <mem> [val=1024,off=24] v2 v23
v48 (18) = MOVQstore <mem> [32] v2 v29 v45
v49 (18) = CALLstatic <mem> {runtime.growslice} [64] v48
v104 (18) = MOVQload <*byte> [40] v2 v49
v80 (18) = MOVQload <int> [56] v2 v49
Plain → b11 (18)
b11: ← b8 b9
v101 (18) = Phi <mem> v17 v49
v19 (18) = Phi <*uint8> v16 v104
v71 (18) = Phi <int> v103 v80
v76 (18) = CMPQ <flags> v29 v71
ULE v76 → b14 b12 (likely) (18)
b12: ← b11
v59 (18) = CALLstatic <mem> {runtime.panicslice} v101
Exit v59 (18)
b14: ← b11
v74 (18) = MOVQstore <mem> v2 v19 v101
v62 (18) = MOVQload <int> {"".data} [8] v3 v101
v34 (18) = MOVQload <*uint8> {"".data} v3 v74
v69 (+21) = TESTQ <flags> v19 v19
v79 (18) = MOVQstore <mem> [8] v2 v34 v74
v83 (18) = MOVQstore <mem> [16] v2 v62 v79
v84 (18) = CALLstatic <mem> {runtime.memmove} [24] v83
NE v69 → b4 b16 (21)
b16: ← b14
v89 (?) = LEAQ <*uint8> {type.string} v3
v90 (?) = LEAQ <*string> {"".statictmp_0} v3
v100 (+22) = MOVQstore <mem> v2 v89 v84
v94 (22) = MOVQstore <mem> [8] v2 v90 v100
v95 (22) = CALLstatic <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.len[int]: v6 
name buf.cap[int]: v20

late deadcode

late deadcode [37584 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = MOVQconst <int> [0] (buf.len[int], i[int])
v39 (?) = LEAQ <*uint8> {type.uint8} v3
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v10 (+16) = LoweredNilCheck <void> v5 v9
v12 (16) = MOVQload <int> [264] v5 v9
v68 (16) = CMPQ <flags> v7 v12
LT v68 → b8 b5 (likely) (16)
b4: ← b14
v98 (+16) = ADDQconst <int> [1] v7 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b8: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LEAQ <*[1024]byte> {.autotmp_3} v2
v106 (+17) = MOVOconst <int128> [0]
v103 (?) = MOVQconst <int> [1024]
v17 (+17) = DUFFZERO <mem> [1024] v16 v106 v15
v29 (+18) = MOVQload <int> {"".data} [8] v3 v17
v58 (18) = CMPQconst <flags> [1024] v29
UGT v58 → b9 b11 (18)
b9: ← b8
v42 (18) = MOVQstore <mem> v2 v39 v17
v21 (18) = MOVQstore <mem> [8] v2 v16 v42
v23 (18) = MOVQstoreconst <mem> [val=0,off=16] v2 v21
v45 (18) = MOVQstoreconst <mem> [val=1024,off=24] v2 v23
v48 (18) = MOVQstore <mem> [32] v2 v29 v45
v49 (18) = CALLstatic <mem> {runtime.growslice} [64] v48
v104 (18) = MOVQload <*byte> [40] v2 v49
v80 (18) = MOVQload <int> [56] v2 v49
Plain → b11 (18)
b11: ← b8 b9
v101 (18) = Phi <mem> v17 v49
v19 (18) = Phi <*uint8> v16 v104
v71 (18) = Phi <int> v103 v80
v76 (18) = CMPQ <flags> v29 v71
ULE v76 → b14 b12 (likely) (18)
b12: ← b11
v59 (18) = CALLstatic <mem> {runtime.panicslice} v101
Exit v59 (18)
b14: ← b11
v74 (18) = MOVQstore <mem> v2 v19 v101
v62 (18) = MOVQload <int> {"".data} [8] v3 v101
v34 (18) = MOVQload <*uint8> {"".data} v3 v74
v69 (+21) = TESTQ <flags> v19 v19
v79 (18) = MOVQstore <mem> [8] v2 v34 v74
v83 (18) = MOVQstore <mem> [16] v2 v62 v79
v84 (18) = CALLstatic <mem> {runtime.memmove} [24] v83
NE v69 → b4 b16 (21)
b16: ← b14
v89 (?) = LEAQ <*uint8> {type.string} v3
v90 (?) = LEAQ <*string> {"".statictmp_0} v3
v100 (+22) = MOVQstore <mem> v2 v89 v84
v94 (22) = MOVQstore <mem> [8] v2 v90 v100
v95 (22) = CALLstatic <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.len[int]: v6

critical

critical [4905 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = MOVQconst <int> [0] (i[int], buf.len[int])
v39 (?) = LEAQ <*uint8> {type.uint8} v3
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v10 (+16) = LoweredNilCheck <void> v5 v9
v12 (16) = MOVQload <int> [264] v5 v9
v68 (16) = CMPQ <flags> v7 v12
LT v68 → b8 b5 (likely) (16)
b4: ← b14
v98 (+16) = ADDQconst <int> [1] v7 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b8: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LEAQ <*[1024]byte> {.autotmp_3} v2
v106 (+17) = MOVOconst <int128> [0]
v103 (?) = MOVQconst <int> [1024]
v17 (+17) = DUFFZERO <mem> [1024] v16 v106 v15
v29 (+18) = MOVQload <int> {"".data} [8] v3 v17
v58 (18) = CMPQconst <flags> [1024] v29
UGT v58 → b9 b17 (18)
b9: ← b8
v42 (18) = MOVQstore <mem> v2 v39 v17
v21 (18) = MOVQstore <mem> [8] v2 v16 v42
v23 (18) = MOVQstoreconst <mem> [val=0,off=16] v2 v21
v45 (18) = MOVQstoreconst <mem> [val=1024,off=24] v2 v23
v48 (18) = MOVQstore <mem> [32] v2 v29 v45
v49 (18) = CALLstatic <mem> {runtime.growslice} [64] v48
v104 (18) = MOVQload <*byte> [40] v2 v49
v80 (18) = MOVQload <int> [56] v2 v49
Plain → b11 (18)
b11: ← b17 b9
v101 (18) = Phi <mem> v17 v49
v19 (18) = Phi <*uint8> v16 v104
v71 (18) = Phi <int> v103 v80
v76 (18) = CMPQ <flags> v29 v71
ULE v76 → b14 b12 (likely) (18)
b12: ← b11
v59 (18) = CALLstatic <mem> {runtime.panicslice} v101
Exit v59 (18)
b14: ← b11
v74 (18) = MOVQstore <mem> v2 v19 v101
v62 (18) = MOVQload <int> {"".data} [8] v3 v101
v34 (18) = MOVQload <*uint8> {"".data} v3 v74
v69 (+21) = TESTQ <flags> v19 v19
v79 (18) = MOVQstore <mem> [8] v2 v34 v74
v83 (18) = MOVQstore <mem> [16] v2 v62 v79
v84 (18) = CALLstatic <mem> {runtime.memmove} [24] v83
NE v69 → b4 b16 (21)
b16: ← b14
v89 (?) = LEAQ <*uint8> {type.string} v3
v90 (?) = LEAQ <*string> {"".statictmp_0} v3
v100 (+22) = MOVQstore <mem> v2 v89 v84
v94 (22) = MOVQstore <mem> [8] v2 v90 v100
v95 (22) = CALLstatic <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17: ← b8
Plain → b11 (18)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.len[int]: v6

likelyadjust

likelyadjust [28812 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = MOVQconst <int> [0] (i[int], buf.len[int])
v39 (?) = LEAQ <*uint8> {type.uint8} v3
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v10 (+16) = LoweredNilCheck <void> v5 v9
v12 (16) = MOVQload <int> [264] v5 v9
v68 (16) = CMPQ <flags> v7 v12
LT v68 → b8 b5 (likely) (16)
b4: ← b14
v98 (+16) = ADDQconst <int> [1] v7 (i[int])
Plain → b2 (16)
b5: ← b2
Ret v9
b8: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LEAQ <*[1024]byte> {.autotmp_3} v2
v106 (+17) = MOVOconst <int128> [0]
v103 (?) = MOVQconst <int> [1024]
v17 (+17) = DUFFZERO <mem> [1024] v16 v106 v15
v29 (+18) = MOVQload <int> {"".data} [8] v3 v17
v58 (18) = CMPQconst <flags> [1024] v29
UGT v58 → b9 b17 (unlikely) (18)
b9: ← b8
v42 (18) = MOVQstore <mem> v2 v39 v17
v21 (18) = MOVQstore <mem> [8] v2 v16 v42
v23 (18) = MOVQstoreconst <mem> [val=0,off=16] v2 v21
v45 (18) = MOVQstoreconst <mem> [val=1024,off=24] v2 v23
v48 (18) = MOVQstore <mem> [32] v2 v29 v45
v49 (18) = CALLstatic <mem> {runtime.growslice} [64] v48
v104 (18) = MOVQload <*byte> [40] v2 v49
v80 (18) = MOVQload <int> [56] v2 v49
Plain → b11 (18)
b11: ← b17 b9
v101 (18) = Phi <mem> v17 v49
v19 (18) = Phi <*uint8> v16 v104
v71 (18) = Phi <int> v103 v80
v76 (18) = CMPQ <flags> v29 v71
ULE v76 → b14 b12 (likely) (18)
b12: ← b11
v59 (18) = CALLstatic <mem> {runtime.panicslice} v101
Exit v59 (18)
b14: ← b11
v74 (18) = MOVQstore <mem> v2 v19 v101
v62 (18) = MOVQload <int> {"".data} [8] v3 v101
v34 (18) = MOVQload <*uint8> {"".data} v3 v74
v69 (+21) = TESTQ <flags> v19 v19
v79 (18) = MOVQstore <mem> [8] v2 v34 v74
v83 (18) = MOVQstore <mem> [16] v2 v62 v79
v84 (18) = CALLstatic <mem> {runtime.memmove} [24] v83
NE v69 → b4 b16 (likely) (21)
b16: ← b14
v89 (?) = LEAQ <*uint8> {type.string} v3
v90 (?) = LEAQ <*string> {"".statictmp_0} v3
v100 (+22) = MOVQstore <mem> v2 v89 v84
v94 (22) = MOVQstore <mem> [8] v2 v90 v100
v95 (22) = CALLstatic <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b17: ← b8
Plain → b11 (18)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.len[int]: v6

layout

layout [13841 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
v6 (?) = MOVQconst <int> [0] (buf.len[int], i[int])
v39 (?) = LEAQ <*uint8> {type.uint8} v3
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v10 (+16) = LoweredNilCheck <void> v5 v9
v12 (16) = MOVQload <int> [264] v5 v9
v68 (16) = CMPQ <flags> v7 v12
LT v68 → b8 b5 (likely) (16)
b8: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v16 (17) = LEAQ <*[1024]byte> {.autotmp_3} v2
v106 (+17) = MOVOconst <int128> [0]
v103 (?) = MOVQconst <int> [1024]
v17 (+17) = DUFFZERO <mem> [1024] v16 v106 v15
v29 (+18) = MOVQload <int> {"".data} [8] v3 v17
v58 (18) = CMPQconst <flags> [1024] v29
UGT v58 → b9 b17 (unlikely) (18)
b17: ← b8
Plain → b11 (18)
b11: ← b17 b9
v101 (18) = Phi <mem> v17 v49
v19 (18) = Phi <*uint8> v16 v104
v71 (18) = Phi <int> v103 v80
v76 (18) = CMPQ <flags> v29 v71
ULE v76 → b14 b12 (likely) (18)
b14: ← b11
v74 (18) = MOVQstore <mem> v2 v19 v101
v62 (18) = MOVQload <int> {"".data} [8] v3 v101
v34 (18) = MOVQload <*uint8> {"".data} v3 v74
v69 (+21) = TESTQ <flags> v19 v19
v79 (18) = MOVQstore <mem> [8] v2 v34 v74
v83 (18) = MOVQstore <mem> [16] v2 v62 v79
v84 (18) = CALLstatic <mem> {runtime.memmove} [24] v83
NE v69 → b4 b16 (likely) (21)
b4: ← b14
v98 (+16) = ADDQconst <int> [1] v7 (i[int])
Plain → b2 (16)
b9: ← b8
v42 (18) = MOVQstore <mem> v2 v39 v17
v21 (18) = MOVQstore <mem> [8] v2 v16 v42
v23 (18) = MOVQstoreconst <mem> [val=0,off=16] v2 v21
v45 (18) = MOVQstoreconst <mem> [val=1024,off=24] v2 v23
v48 (18) = MOVQstore <mem> [32] v2 v29 v45
v49 (18) = CALLstatic <mem> {runtime.growslice} [64] v48
v104 (18) = MOVQload <*byte> [40] v2 v49
v80 (18) = MOVQload <int> [56] v2 v49
Plain → b11 (18)
b5: ← b2
Ret v9
b16: ← b14
v89 (?) = LEAQ <*uint8> {type.string} v3
v90 (?) = LEAQ <*string> {"".statictmp_0} v3
v100 (+22) = MOVQstore <mem> v2 v89 v84
v94 (22) = MOVQstore <mem> [8] v2 v90 v100
v95 (22) = CALLstatic <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b12: ← b11
v59 (18) = CALLstatic <mem> {runtime.panicslice} v101
Exit v59 (18)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.len[int]: v6

schedule

schedule [38952 ns]

b1:
v1 (?) = InitMem <mem>
v3 (?) = SB <uintptr>
v39 (?) = LEAQ <*uint8> {type.uint8} v3
v2 (?) = SP <uintptr>
v6 (?) = MOVQconst <int> [0] (i[int], buf.len[int])
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v10 (+16) = LoweredNilCheck <void> v5 v9
v12 (16) = MOVQload <int> [264] v5 v9
v68 (16) = CMPQ <flags> v7 v12
LT v68 → b8 b5 (likely) (16)
b8: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v106 (+17) = MOVOconst <int128> [0]
v16 (17) = LEAQ <*[1024]byte> {.autotmp_3} v2
v17 (+17) = DUFFZERO <mem> [1024] v16 v106 v15
v103 (?) = MOVQconst <int> [1024]
v29 (+18) = MOVQload <int> {"".data} [8] v3 v17
v58 (18) = CMPQconst <flags> [1024] v29
UGT v58 → b9 b17 (unlikely) (18)
b17: ← b8
Plain → b11 (18)
b11: ← b17 b9
v19 (18) = Phi <*uint8> v16 v104
v71 (18) = Phi <int> v103 v80
v101 (18) = Phi <mem> v17 v49
v76 (18) = CMPQ <flags> v29 v71
ULE v76 → b14 b12 (likely) (18)
b14: ← b11
v62 (18) = MOVQload <int> {"".data} [8] v3 v101
v74 (18) = MOVQstore <mem> v2 v19 v101
v34 (18) = MOVQload <*uint8> {"".data} v3 v74
v79 (18) = MOVQstore <mem> [8] v2 v34 v74
v83 (18) = MOVQstore <mem> [16] v2 v62 v79
v84 (18) = CALLstatic <mem> {runtime.memmove} [24] v83
v69 (+21) = TESTQ <flags> v19 v19
NE v69 → b4 b16 (likely) (21)
b4: ← b14
v98 (+16) = ADDQconst <int> [1] v7 (i[int])
Plain → b2 (16)
b9: ← b8
v42 (18) = MOVQstore <mem> v2 v39 v17
v21 (18) = MOVQstore <mem> [8] v2 v16 v42
v23 (18) = MOVQstoreconst <mem> [val=0,off=16] v2 v21
v45 (18) = MOVQstoreconst <mem> [val=1024,off=24] v2 v23
v48 (18) = MOVQstore <mem> [32] v2 v29 v45
v49 (18) = CALLstatic <mem> {runtime.growslice} [64] v48
v80 (18) = MOVQload <int> [56] v2 v49
v104 (18) = MOVQload <*byte> [40] v2 v49
Plain → b11 (18)
b5: ← b2
Ret v9
b16: ← b14
v89 (?) = LEAQ <*uint8> {type.string} v3
v100 (+22) = MOVQstore <mem> v2 v89 v84
v90 (?) = LEAQ <*string> {"".statictmp_0} v3
v94 (22) = MOVQstore <mem> [8] v2 v90 v100
v95 (22) = CALLstatic <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b12: ← b11
v59 (18) = CALLstatic <mem> {runtime.panicslice} v101
Exit v59 (18)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.len[int]: v6

late nilcheck

late nilcheck [13240 ns]

b1:
v1 (?) = InitMem <mem>
v3 (?) = SB <uintptr>
v39 (?) = LEAQ <*uint8> {type.uint8} v3
v2 (?) = SP <uintptr>
v6 (?) = MOVQconst <int> [0] (buf.len[int], i[int])
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v12 (+16) = MOVQload <int> [264] v5 v9
v68 (16) = CMPQ <flags> v7 v12
LT v68 → b8 b5 (likely) (16)
b8: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v106 (+17) = MOVOconst <int128> [0]
v16 (17) = LEAQ <*[1024]byte> {.autotmp_3} v2
v17 (+17) = DUFFZERO <mem> [1024] v16 v106 v15
v103 (?) = MOVQconst <int> [1024]
v29 (+18) = MOVQload <int> {"".data} [8] v3 v17
v58 (18) = CMPQconst <flags> [1024] v29
UGT v58 → b9 b17 (unlikely) (18)
b17: ← b8
Plain → b11 (18)
b11: ← b17 b9
v19 (18) = Phi <*uint8> v16 v104
v71 (18) = Phi <int> v103 v80
v101 (18) = Phi <mem> v17 v49
v76 (18) = CMPQ <flags> v29 v71
ULE v76 → b14 b12 (likely) (18)
b14: ← b11
v62 (18) = MOVQload <int> {"".data} [8] v3 v101
v74 (18) = MOVQstore <mem> v2 v19 v101
v34 (18) = MOVQload <*uint8> {"".data} v3 v74
v79 (18) = MOVQstore <mem> [8] v2 v34 v74
v83 (18) = MOVQstore <mem> [16] v2 v62 v79
v84 (18) = CALLstatic <mem> {runtime.memmove} [24] v83
v69 (+21) = TESTQ <flags> v19 v19
NE v69 → b4 b16 (likely) (21)
b4: ← b14
v98 (+16) = ADDQconst <int> [1] v7 (i[int])
Plain → b2 (16)
b9: ← b8
v42 (18) = MOVQstore <mem> v2 v39 v17
v21 (18) = MOVQstore <mem> [8] v2 v16 v42
v23 (18) = MOVQstoreconst <mem> [val=0,off=16] v2 v21
v45 (18) = MOVQstoreconst <mem> [val=1024,off=24] v2 v23
v48 (18) = MOVQstore <mem> [32] v2 v29 v45
v49 (18) = CALLstatic <mem> {runtime.growslice} [64] v48
v80 (18) = MOVQload <int> [56] v2 v49
v104 (18) = MOVQload <*byte> [40] v2 v49
Plain → b11 (18)
b5: ← b2
Ret v9
b16: ← b14
v89 (?) = LEAQ <*uint8> {type.string} v3
v100 (+22) = MOVQstore <mem> v2 v89 v84
v90 (?) = LEAQ <*string> {"".statictmp_0} v3
v94 (22) = MOVQstore <mem> [8] v2 v90 v100
v95 (22) = CALLstatic <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b12: ← b11
v59 (18) = CALLstatic <mem> {runtime.panicslice} v101
Exit v59 (18)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.len[int]: v6

flagalloc

flagalloc [14229 ns]

b1:
v1 (?) = InitMem <mem>
v3 (?) = SB <uintptr>
v39 (?) = LEAQ <*uint8> {type.uint8} v3
v2 (?) = SP <uintptr>
v6 (?) = MOVQconst <int> [0] (i[int], buf.len[int])
v5 (15) = Arg <*testing.B> {b} (b[*testing.B])
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v6 v98 (i[int])
v9 (16) = Phi <mem> v1 v84
v12 (+16) = MOVQload <int> [264] v5 v9
v68 (16) = CMPQ <flags> v7 v12
LT v68 → b8 b5 (likely) (16)
b8: ← b2
v15 (17) = VarDef <mem> {.autotmp_3} v9
v106 (+17) = MOVOconst <int128> [0]
v16 (17) = LEAQ <*[1024]byte> {.autotmp_3} v2
v17 (+17) = DUFFZERO <mem> [1024] v16 v106 v15
v103 (?) = MOVQconst <int> [1024]
v29 (+18) = MOVQload <int> {"".data} [8] v3 v17
v58 (18) = CMPQconst <flags> [1024] v29
UGT v58 → b9 b17 (unlikely) (18)
b17: ← b8
Plain → b11 (18)
b11: ← b17 b9
v19 (18) = Phi <*uint8> v16 v104
v71 (18) = Phi <int> v103 v80
v101 (18) = Phi <mem> v17 v49
v76 (18) = CMPQ <flags> v29 v71
ULE v76 → b14 b12 (likely) (18)
b14: ← b11
v62 (18) = MOVQload <int> {"".data} [8] v3 v101
v74 (18) = MOVQstore <mem> v2 v19 v101
v34 (18) = MOVQload <*uint8> {"".data} v3 v74
v79 (18) = MOVQstore <mem> [8] v2 v34 v74
v83 (18) = MOVQstore <mem> [16] v2 v62 v79
v84 (18) = CALLstatic <mem> {runtime.memmove} [24] v83
v69 (+21) = TESTQ <flags> v19 v19
NE v69 → b4 b16 (likely) (21)
b4: ← b14
v98 (+16) = ADDQconst <int> [1] v7 (i[int])
Plain → b2 (16)
b9: ← b8
v42 (18) = MOVQstore <mem> v2 v39 v17
v21 (18) = MOVQstore <mem> [8] v2 v16 v42
v23 (18) = MOVQstoreconst <mem> [val=0,off=16] v2 v21
v45 (18) = MOVQstoreconst <mem> [val=1024,off=24] v2 v23
v48 (18) = MOVQstore <mem> [32] v2 v29 v45
v49 (18) = CALLstatic <mem> {runtime.growslice} [64] v48
v80 (18) = MOVQload <int> [56] v2 v49
v104 (18) = MOVQload <*byte> [40] v2 v49
Plain → b11 (18)
b5: ← b2
Ret v9
b16: ← b14
v89 (?) = LEAQ <*uint8> {type.string} v3
v100 (+22) = MOVQstore <mem> v2 v89 v84
v90 (?) = LEAQ <*string> {"".statictmp_0} v3
v94 (22) = MOVQstore <mem> [8] v2 v90 v100
v95 (22) = CALLstatic <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b12: ← b11
v59 (18) = CALLstatic <mem> {runtime.panicslice} v101
Exit v59 (18)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.len[int]: v6

regalloc

regalloc [244057 ns]

b1:
v1 (?) = InitMem <mem>
v3 (?) = SB <uintptr> : SB
v2 (?) = SP <uintptr> : SP
v5 (15) = Arg <*testing.B> {b} : b[*testing.B] (b[*testing.B])
v20 (16) = LoadReg <*testing.B> v5 : AX
v91 (?) = MOVQconst <int> [0] : CX
Plain → b2 (+16)
b2: ← b1 b4
v7 (16) = Phi <int> v91 v98 : CX (i[int])
v9 (16) = Phi <mem> v1 v84
v12 (+16) = MOVQload <int> [264] v20 v9 : DX
v68 (16) = CMPQ <flags> v7 v12
LT v68 → b8 b5 (likely) (16)
b8: ← b2
v60 (16) = StoreReg <int> v7 : i[int]
v15 (17) = VarDef <mem> {.autotmp_3} v9
v66 (17) = LEAQ <*[1024]byte> {.autotmp_3} v2 : DI
v65 (17) = MOVOconst <int128> [0] : X0
v17 (+17) = DUFFZERO <mem> [1024] v66 v65 v15
v29 (+18) = MOVQload <int> {"".data} [8] v3 v17 : DX
v58 (18) = CMPQconst <flags> [1024] v29
UGT v58 → b9 b17 (unlikely) (18)
b17: ← b8
v11 (17) = LEAQ <*[1024]byte> {.autotmp_3} v2 : BX
v97 (?) = MOVQconst <int> [1024] : SI
Plain → b11 (18)
b11: ← b17 b9
v19 (18) = Phi <*uint8> v11 v104 : BX
v71 (18) = Phi <int> v97 v80 : SI
v101 (18) = Phi <mem> v17 v49
v76 (18) = CMPQ <flags> v29 v71
ULE v76 → b14 b12 (likely) (18)
b14: ← b11
v61 (18) = StoreReg <*uint8> v19 : .autotmp_10[*uint8]
v62 (18) = MOVQload <int> {"".data} [8] v3 v101 : AX
v74 (18) = MOVQstore <mem> v2 v19 v101
v34 (18) = MOVQload <*uint8> {"".data} v3 v74 : CX
v79 (18) = MOVQstore <mem> [8] v2 v34 v74
v83 (18) = MOVQstore <mem> [16] v2 v62 v79
v84 (18) = CALLstatic <mem> {runtime.memmove} [24] v83
v73 (21) = LoadReg <*uint8> v61 : AX
v69 (+21) = TESTQ <flags> v73 v73
NE v69 → b4 b16 (likely) (21)
b4: ← b14
v81 (16) = LoadReg <int> v60 : DX
v98 (+16) = ADDQconst <int> [1] v81 : CX (i[int])
v24 (16) = LoadReg <*testing.B> v5 : DX
v13 (16) = Copy <*testing.B> v24 : AX
Plain → b2 (16)
b9: ← b8
v26 (+18) = StoreReg <int> v29 : .autotmp_11[int]
v25 (18) = LEAQ <*uint8> {type.uint8} v3 : AX
v42 (18) = MOVQstore <mem> v2 v25 v17
v88 (18) = LEAQ <*[1024]byte> {.autotmp_3} v2 : CX
v21 (18) = MOVQstore <mem> [8] v2 v88 v42
v23 (18) = MOVQstoreconst <mem> [val=0,off=16] v2 v21
v45 (18) = MOVQstoreconst <mem> [val=1024,off=24] v2 v23
v48 (18) = MOVQstore <mem> [32] v2 v29 v45
v49 (18) = CALLstatic <mem> {runtime.growslice} [64] v48
v80 (18) = MOVQload <int> [56] v2 v49 : SI
v104 (18) = MOVQload <*byte> [40] v2 v49 : BX
v82 (16) = LoadReg <*testing.B> v5 : AX
v78 (16) = LoadReg <int> v60 : CX
v50 (18) = LoadReg <int> v26 : DX
Plain → b11 (18)
b5: ← b2
Ret v9
b16: ← b14
v38 (22) = LEAQ <*uint8> {type.string} v3 : AX
v100 (+22) = MOVQstore <mem> v2 v38 v84
v18 (22) = LEAQ <*string> {"".statictmp_0} v3 : AX
v94 (22) = MOVQstore <mem> [8] v2 v18 v100
v95 (22) = CALLstatic <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b12: ← b11
v59 (18) = CALLstatic <mem> {runtime.panicslice} v101
Exit v59 (18)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.len[int]: v6

loop rotate

loop rotate [6233 ns]

b1:
v1 (?) = InitMem <mem>
v3 (?) = SB <uintptr> : SB
v2 (?) = SP <uintptr> : SP
v5 (15) = Arg <*testing.B> {b} : b[*testing.B] (b[*testing.B])
v20 (16) = LoadReg <*testing.B> v5 : AX
v91 (?) = MOVQconst <int> [0] : CX
Plain → b2 (+16)
b4: ← b14
v81 (16) = LoadReg <int> v60 : DX
v98 (+16) = ADDQconst <int> [1] v81 : CX (i[int])
v24 (16) = LoadReg <*testing.B> v5 : DX
v13 (16) = Copy <*testing.B> v24 : AX
Plain → b2 (16)
b2: ← b1 b4
v7 (16) = Phi <int> v91 v98 : CX (i[int])
v9 (16) = Phi <mem> v1 v84
v12 (+16) = MOVQload <int> [264] v20 v9 : DX
v68 (16) = CMPQ <flags> v7 v12
LT v68 → b8 b5 (likely) (16)
b8: ← b2
v60 (16) = StoreReg <int> v7 : i[int]
v15 (17) = VarDef <mem> {.autotmp_3} v9
v66 (17) = LEAQ <*[1024]byte> {.autotmp_3} v2 : DI
v65 (17) = MOVOconst <int128> [0] : X0
v17 (+17) = DUFFZERO <mem> [1024] v66 v65 v15
v29 (+18) = MOVQload <int> {"".data} [8] v3 v17 : DX
v58 (18) = CMPQconst <flags> [1024] v29
UGT v58 → b9 b17 (unlikely) (18)
b17: ← b8
v11 (17) = LEAQ <*[1024]byte> {.autotmp_3} v2 : BX
v97 (?) = MOVQconst <int> [1024] : SI
Plain → b11 (18)
b11: ← b17 b9
v19 (18) = Phi <*uint8> v11 v104 : BX
v71 (18) = Phi <int> v97 v80 : SI
v101 (18) = Phi <mem> v17 v49
v76 (18) = CMPQ <flags> v29 v71
ULE v76 → b14 b12 (likely) (18)
b14: ← b11
v61 (18) = StoreReg <*uint8> v19 : .autotmp_10[*uint8]
v62 (18) = MOVQload <int> {"".data} [8] v3 v101 : AX
v74 (18) = MOVQstore <mem> v2 v19 v101
v34 (18) = MOVQload <*uint8> {"".data} v3 v74 : CX
v79 (18) = MOVQstore <mem> [8] v2 v34 v74
v83 (18) = MOVQstore <mem> [16] v2 v62 v79
v84 (18) = CALLstatic <mem> {runtime.memmove} [24] v83
v73 (21) = LoadReg <*uint8> v61 : AX
v69 (+21) = TESTQ <flags> v73 v73
NE v69 → b4 b16 (likely) (21)
b9: ← b8
v26 (+18) = StoreReg <int> v29 : .autotmp_11[int]
v25 (18) = LEAQ <*uint8> {type.uint8} v3 : AX
v42 (18) = MOVQstore <mem> v2 v25 v17
v88 (18) = LEAQ <*[1024]byte> {.autotmp_3} v2 : CX
v21 (18) = MOVQstore <mem> [8] v2 v88 v42
v23 (18) = MOVQstoreconst <mem> [val=0,off=16] v2 v21
v45 (18) = MOVQstoreconst <mem> [val=1024,off=24] v2 v23
v48 (18) = MOVQstore <mem> [32] v2 v29 v45
v49 (18) = CALLstatic <mem> {runtime.growslice} [64] v48
v80 (18) = MOVQload <int> [56] v2 v49 : SI
v104 (18) = MOVQload <*byte> [40] v2 v49 : BX
v82 (16) = LoadReg <*testing.B> v5 : AX
v78 (16) = LoadReg <int> v60 : CX
v50 (18) = LoadReg <int> v26 : DX
Plain → b11 (18)
b5: ← b2
Ret v9
b16: ← b14
v38 (22) = LEAQ <*uint8> {type.string} v3 : AX
v100 (+22) = MOVQstore <mem> v2 v38 v84
v18 (22) = LEAQ <*string> {"".statictmp_0} v3 : AX
v94 (22) = MOVQstore <mem> [8] v2 v18 v100
v95 (22) = CALLstatic <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b12: ← b11
v59 (18) = CALLstatic <mem> {runtime.panicslice} v101
Exit v59 (18)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.len[int]: v6

stackframe

stackframe [13029 ns]

b1:
v1 (?) = InitMem <mem>
v3 (?) = SB <uintptr> : SB
v2 (?) = SP <uintptr> : SP
v5 (15) = Arg <*testing.B> {b} : b[*testing.B] (b[*testing.B])
v20 (16) = LoadReg <*testing.B> v5 : AX
v91 (?) = MOVQconst <int> [0] : CX
Plain → b2 (+16)
b4: ← b14
v81 (16) = LoadReg <int> v60 : DX
v98 (+16) = ADDQconst <int> [1] v81 : CX (i[int])
v24 (16) = LoadReg <*testing.B> v5 : DX
v13 (16) = Copy <*testing.B> v24 : AX
Plain → b2 (16)
b2: ← b1 b4
v7 (16) = Phi <int> v91 v98 : CX (i[int])
v9 (16) = Phi <mem> v1 v84
v12 (+16) = MOVQload <int> [264] v20 v9 : DX
v68 (16) = CMPQ <flags> v7 v12
LT v68 → b8 b5 (likely) (16)
b8: ← b2
v60 (16) = StoreReg <int> v7 : i[int]
v15 (17) = VarDef <mem> {.autotmp_3} v9
v66 (17) = LEAQ <*[1024]byte> {.autotmp_3} v2 : DI
v65 (17) = MOVOconst <int128> [0] : X0
v17 (+17) = DUFFZERO <mem> [1024] v66 v65 v15
v29 (+18) = MOVQload <int> {"".data} [8] v3 v17 : DX
v58 (18) = CMPQconst <flags> [1024] v29
UGT v58 → b9 b17 (unlikely) (18)
b17: ← b8
v11 (17) = LEAQ <*[1024]byte> {.autotmp_3} v2 : BX
v97 (?) = MOVQconst <int> [1024] : SI
Plain → b11 (18)
b11: ← b17 b9
v19 (18) = Phi <*uint8> v11 v104 : BX
v71 (18) = Phi <int> v97 v80 : SI
v101 (18) = Phi <mem> v17 v49
v76 (18) = CMPQ <flags> v29 v71
ULE v76 → b14 b12 (likely) (18)
b14: ← b11
v61 (18) = StoreReg <*uint8> v19 : .autotmp_10[*uint8]
v62 (18) = MOVQload <int> {"".data} [8] v3 v101 : AX
v74 (18) = MOVQstore <mem> v2 v19 v101
v34 (18) = MOVQload <*uint8> {"".data} v3 v74 : CX
v79 (18) = MOVQstore <mem> [8] v2 v34 v74
v83 (18) = MOVQstore <mem> [16] v2 v62 v79
v84 (18) = CALLstatic <mem> {runtime.memmove} [24] v83
v73 (21) = LoadReg <*uint8> v61 : AX
v69 (+21) = TESTQ <flags> v73 v73
NE v69 → b4 b16 (likely) (21)
b9: ← b8
v26 (+18) = StoreReg <int> v29 : .autotmp_11[int]
v25 (18) = LEAQ <*uint8> {type.uint8} v3 : AX
v42 (18) = MOVQstore <mem> v2 v25 v17
v88 (18) = LEAQ <*[1024]byte> {.autotmp_3} v2 : CX
v21 (18) = MOVQstore <mem> [8] v2 v88 v42
v23 (18) = MOVQstoreconst <mem> [val=0,off=16] v2 v21
v45 (18) = MOVQstoreconst <mem> [val=1024,off=24] v2 v23
v48 (18) = MOVQstore <mem> [32] v2 v29 v45
v49 (18) = CALLstatic <mem> {runtime.growslice} [64] v48
v80 (18) = MOVQload <int> [56] v2 v49 : SI
v104 (18) = MOVQload <*byte> [40] v2 v49 : BX
v82 (16) = LoadReg <*testing.B> v5 : AX
v78 (16) = LoadReg <int> v60 : CX
v50 (18) = LoadReg <int> v26 : DX
Plain → b11 (18)
b5: ← b2
Ret v9
b16: ← b14
v38 (22) = LEAQ <*uint8> {type.string} v3 : AX
v100 (+22) = MOVQstore <mem> v2 v38 v84
v18 (22) = LEAQ <*string> {"".statictmp_0} v3 : AX
v94 (22) = MOVQstore <mem> [8] v2 v18 v100
v95 (22) = CALLstatic <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b12: ← b11
v59 (18) = CALLstatic <mem> {runtime.panicslice} v101
Exit v59 (18)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.len[int]: v6

trim

trim [1148 ns]

b1:
v1 (?) = InitMem <mem>
v3 (?) = SB <uintptr> : SB
v2 (?) = SP <uintptr> : SP
v5 (15) = Arg <*testing.B> {b} : b[*testing.B] (b[*testing.B])
v20 (16) = LoadReg <*testing.B> v5 : AX
v91 (?) = MOVQconst <int> [0] : CX
Plain → b2 (+16)
b4: ← b14
v81 (16) = LoadReg <int> v60 : DX
v98 (+16) = ADDQconst <int> [1] v81 : CX (i[int])
v24 (16) = LoadReg <*testing.B> v5 : DX
v13 (16) = Copy <*testing.B> v24 : AX
Plain → b2 (16)
b2: ← b1 b4
v7 (16) = Phi <int> v91 v98 : CX (i[int])
v9 (16) = Phi <mem> v1 v84
v12 (+16) = MOVQload <int> [264] v20 v9 : DX
v68 (16) = CMPQ <flags> v7 v12
LT v68 → b8 b5 (likely) (16)
b8: ← b2
v60 (16) = StoreReg <int> v7 : i[int]
v15 (17) = VarDef <mem> {.autotmp_3} v9
v66 (17) = LEAQ <*[1024]byte> {.autotmp_3} v2 : DI
v65 (17) = MOVOconst <int128> [0] : X0
v17 (+17) = DUFFZERO <mem> [1024] v66 v65 v15
v29 (+18) = MOVQload <int> {"".data} [8] v3 v17 : DX
v58 (18) = CMPQconst <flags> [1024] v29
UGT v58 → b9 b17 (unlikely) (18)
b17: ← b8
v11 (17) = LEAQ <*[1024]byte> {.autotmp_3} v2 : BX
v97 (?) = MOVQconst <int> [1024] : SI
Plain → b11 (18)
b11: ← b17 b9
v19 (18) = Phi <*uint8> v11 v104 : BX
v71 (18) = Phi <int> v97 v80 : SI
v101 (18) = Phi <mem> v17 v49
v76 (18) = CMPQ <flags> v29 v71
ULE v76 → b14 b12 (likely) (18)
b14: ← b11
v61 (18) = StoreReg <*uint8> v19 : .autotmp_10[*uint8]
v62 (18) = MOVQload <int> {"".data} [8] v3 v101 : AX
v74 (18) = MOVQstore <mem> v2 v19 v101
v34 (18) = MOVQload <*uint8> {"".data} v3 v74 : CX
v79 (18) = MOVQstore <mem> [8] v2 v34 v74
v83 (18) = MOVQstore <mem> [16] v2 v62 v79
v84 (18) = CALLstatic <mem> {runtime.memmove} [24] v83
v73 (21) = LoadReg <*uint8> v61 : AX
v69 (+21) = TESTQ <flags> v73 v73
NE v69 → b4 b16 (likely) (21)
b9: ← b8
v26 (+18) = StoreReg <int> v29 : .autotmp_11[int]
v25 (18) = LEAQ <*uint8> {type.uint8} v3 : AX
v42 (18) = MOVQstore <mem> v2 v25 v17
v88 (18) = LEAQ <*[1024]byte> {.autotmp_3} v2 : CX
v21 (18) = MOVQstore <mem> [8] v2 v88 v42
v23 (18) = MOVQstoreconst <mem> [val=0,off=16] v2 v21
v45 (18) = MOVQstoreconst <mem> [val=1024,off=24] v2 v23
v48 (18) = MOVQstore <mem> [32] v2 v29 v45
v49 (18) = CALLstatic <mem> {runtime.growslice} [64] v48
v80 (18) = MOVQload <int> [56] v2 v49 : SI
v104 (18) = MOVQload <*byte> [40] v2 v49 : BX
v82 (16) = LoadReg <*testing.B> v5 : AX
v78 (16) = LoadReg <int> v60 : CX
v50 (18) = LoadReg <int> v26 : DX
Plain → b11 (18)
b5: ← b2
Ret v9
b16: ← b14
v38 (22) = LEAQ <*uint8> {type.string} v3 : AX
v100 (+22) = MOVQstore <mem> v2 v38 v84
v18 (22) = LEAQ <*string> {"".statictmp_0} v3 : AX
v94 (22) = MOVQstore <mem> [8] v2 v18 v100
v95 (22) = CALLstatic <mem> {runtime.gopanic} [16] v94
Exit v95 (22)
b12: ← b11
v59 (18) = CALLstatic <mem> {runtime.panicslice} v101
Exit v59 (18)
name i[int]: v6 v7 v98 
name b[*testing.B]: v5 
name buf.len[int]: v6

genssa


# bench_test.go
00000 (15) TEXT	"".Benchmark_Append(SB)
00001 (15) FUNCDATA	$0, gclocals·c7c4fc7b12f6707ea74acf7400192967(SB)
00002 (15) FUNCDATA	$1, gclocals·663f8c6bfa83aa777198789ce63d9ab4(SB)
00003 (15) FUNCDATA	$3, gclocals·6f65322c5c3c84a8860d6cd73a64aa0a(SB)
v20
00004 (16) PCDATA	$2, $1
v20
00005 (16) PCDATA	$0, $0
v20
00006 (+16) MOVQ	"".b(SP), AX
v91
00007 (16) XORL	CX, CX
b1
00008 (16) JMP	16
v81
00009 (16) PCDATA	$2, $0
v81
00010 (+16) MOVQ	"".i-1048(SP), DX
v98
00011 (16) LEAQ	1(DX), CX
v24
00012 (16) PCDATA	$2, $2
v24
00013 (16) MOVQ	"".b(SP), DX
v13
00014 (16) PCDATA	$2, $1
v13
00015 (16) MOVQ	DX, AX
v12
00016 (+16) PCDATA	$2, $0
v12
00017 (+16) MOVQ	264(AX), DX
v68
00018 (16) CMPQ	CX, DX
b2
00019 (16) JGE	72
v60
00020 (16) MOVQ	CX, "".i-1048(SP)
v66
00021 (17) PCDATA	$2, $3
v66
00022 (+17) LEAQ	""..autotmp_3-1032(SP), DI
v65
00023 (17) XORPS	X0, X0
v17
00024 (+17) PCDATA	$2, $0
v17
00025 (17) DUFFZERO	$0
v29
00026 (+18) MOVQ	"".data+8(SB), DX
v58
00027 (18) CMPQ	DX, $1024
b8
00028 (18) JHI	52
v11
00029 (17) PCDATA	$2, $4
v11
00030 (17) LEAQ	""..autotmp_3-1032(SP), BX
v97
00031 (17) MOVL	$1024, SI
v76
00032 (18) CMPQ	DX, SI
b11
00033 (18) JHI	86
v61
00034 (18) PCDATA	$0, $1
v61
00035 (18) MOVQ	BX, ""..autotmp_10-8(SP)
v62
00036 (18) MOVQ	"".data+8(SB), AX
v74
00037 (18) PCDATA	$2, $0
v74
00038 (18) MOVQ	BX, (SP)
v34
00039 (18) PCDATA	$2, $5
v34
00040 (18) MOVQ	"".data(SB), CX
v79
00041 (18) PCDATA	$2, $0
v79
00042 (18) MOVQ	CX, 8(SP)
v83
00043 (18) MOVQ	AX, 16(SP)
v84
00044 (18) CALL	runtime.memmove(SB)
v73
00045 (21) PCDATA	$2, $1
v73
00046 (21) PCDATA	$0, $0
v73
00047 (+21) MOVQ	""..autotmp_10-8(SP), AX
v69
00048 (+21) PCDATA	$2, $0
v69
00049 (21) TESTQ	AX, AX
b14
00050 (21) JNE	9
b14
00051 (21) JMP	75
v26
00052 (18) MOVQ	DX, ""..autotmp_11-1040(SP)
v25
00053 (18) PCDATA	$2, $1
v25
00054 (18) LEAQ	type.uint8(SB), AX
v42
00055 (18) PCDATA	$2, $0
v42
00056 (18) MOVQ	AX, (SP)
v88
00057 (18) PCDATA	$2, $5
v88
00058 (18) LEAQ	""..autotmp_3-1032(SP), CX
v21
00059 (18) PCDATA	$2, $0
v21
00060 (18) MOVQ	CX, 8(SP)
v23
00061 (18) MOVQ	$0, 16(SP)
v45
00062 (18) MOVQ	$1024, 24(SP)
v48
00063 (18) MOVQ	DX, 32(SP)
v49
00064 (18) CALL	runtime.growslice(SB)
v80
00065 (18) MOVQ	56(SP), SI
v104
00066 (18) PCDATA	$2, $4
v104
00067 (18) MOVQ	40(SP), BX
v82
00068 (16) MOVQ	"".b(SP), AX
v78
00069 (16) MOVQ	"".i-1048(SP), CX
v50
00070 (18) MOVQ	""..autotmp_11-1040(SP), DX
b9
00071 (18) JMP	32
b5
00072 (?) PCDATA	$2, $-2
b5
00073 (?) PCDATA	$0, $-2
b5
00074 (?) RET
v38
00075 (22) PCDATA	$2, $1
v38
00076 (22) PCDATA	$0, $2
v38
00077 (+22) LEAQ	type.string(SB), AX
v100
00078 (+22) PCDATA	$2, $0
v100
00079 (22) MOVQ	AX, (SP)
v18
00080 (22) PCDATA	$2, $1
v18
00081 (22) LEAQ	"".statictmp_0(SB), AX
v94
00082 (22) PCDATA	$2, $0
v94
00083 (22) MOVQ	AX, 8(SP)
v95
00084 (22) CALL	runtime.gopanic(SB)
b16
00085 (22) UNDEF
v59
00086 (18) CALL	runtime.panicslice(SB)
b12
00087 (18) UNDEF
00088 (?) END