ssa

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.

CFG: Dashed edge is for unlikely branches. Blue color is for backward edges. Edge with a dot means that this edge follows the order in which blocks were laidout.

darkmode

sources

sources

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

212

213

214

 
/root/main.go
func ssa() {
	var w, x, y, z int
 
	x = 5
	x = x - 3
	if x < 3 {
		y = x * 2
		w = y
	} else {
		y = x - 3
	}
	w = x - y
	z = x + y
 
	fmt.Printf("%d, %d\n", w, z)
}
 
$GOROOT/src/fmt/print.go
func Printf(format string, a ...interface{}) (n int, err error) {
	return Fprintf(os.Stdout, format, a...)
}

AST

AST

buildssa-enter

buildssa-body

. DCL l(6) tc(1)

. . NAME-main.w g(1) l(6) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. AS l(6) tc(1)

. . NAME-main.w g(1) l(6) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. DCL l(6) tc(1)

. . NAME-main.x g(2) l(6) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. AS l(6) tc(1)

. . NAME-main.x g(2) l(6) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. DCL l(6) tc(1)

. . NAME-main.y g(3) l(6) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. AS l(6) tc(1)

. . NAME-main.y g(3) l(6) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. DCL l(6) tc(1)

. . NAME-main.z g(4) l(6) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. AS l(6) tc(1)

. . NAME-main.z g(4) l(6) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. AS l(8) tc(1)

. . NAME-main.x g(2) l(6) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. . LITERAL-5 l(8) tc(1) int

. AS l(9) tc(1)

. . NAME-main.x g(2) l(6) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. . SUB l(9) tc(1) int

. . . NAME-main.x g(2) l(6) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. . . LITERAL-3 l(9) tc(1) int

. IF l(10) tc(1)

. . LT l(10) tc(1) bool

. . . NAME-main.x g(2) l(6) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. . . LITERAL-3 l(10) tc(1) int

. IF-rlist

. . AS l(14) tc(1)

. . . NAME-main.y g(3) l(6) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. . . SUB l(14) tc(1) int

. . . . NAME-main.x g(2) l(6) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. . . . LITERAL-3 l(14) tc(1) int

. IF-body

. . AS l(11) tc(1)

. . . NAME-main.y g(3) l(6) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. . . MUL l(11) tc(1) int

. . . . NAME-main.x g(2) l(6) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. . . . LITERAL-2 l(11) tc(1) int

. . AS l(12) tc(1)

. . . NAME-main.w g(1) l(6) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. . . NAME-main.y g(3) l(6) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. AS l(16) tc(1)

. . NAME-main.w g(1) l(6) x(0) class(PAUTO) esc(no) tc(1) assigned used int

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

. . . NAME-main.x g(2) l(6) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. . . NAME-main.y g(3) l(6) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. AS l(17) tc(1)

. . NAME-main.z g(4) l(6) x(0) class(PAUTO) esc(no) tc(1) assigned used int

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

. . . NAME-main.x g(2) l(6) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. . . NAME-main.y g(3) l(6) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. DCL l(19)

. . NAME-fmt.format l(212) x(0) class(PAUTO) esc(no) tc(1) assigned used string

. DCL l(19)

. . NAME-fmt.a l(212) x(0) class(PAUTO) esc(no) tc(1) assigned used SLICE-@0

. DCL l(19)

. . NAME-fmt.n l(212) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. DCL l(19)

. . NAME-fmt.err l(212) x(0) class(PAUTO) esc(no) tc(1) assigned used error

. BLOCK-init

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

. . . NAME-main..autotmp_15 l(19) x(0) class(PAUTO) esc(N) tc(1) assigned used UNSAFEPTR-@0

. . . CALLFUNC l(19) tc(1) hascall UNSAFEPTR-@0

. . . . NAME-runtime.convT64 x(0) class(PFUNC) tc(1) used FUNC-@0

. . . CALLFUNC-rlist

. . . . NAME-main.w g(1) l(6) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. . AS l(19) tc(1)

. . . NAME-main..autotmp_14 l(19) x(0) class(PAUTO) esc(N) tc(1) assigned used INTER-@0

. . . EFACE l(19) tc(1) INTER-@0

. . . . ADDR l(19) tc(1) PTR-@0

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

. . . . NAME-main..autotmp_15 l(19) x(0) class(PAUTO) esc(N) tc(1) assigned used UNSAFEPTR-@0

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

. . . NAME-main..autotmp_17 l(19) x(0) class(PAUTO) esc(N) tc(1) assigned used UNSAFEPTR-@0

. . . CALLFUNC l(19) tc(1) hascall UNSAFEPTR-@0

. . . . NAME-runtime.convT64 x(0) class(PFUNC) tc(1) used FUNC-@0

. . . CALLFUNC-rlist

. . . . NAME-main.z g(4) l(6) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. . AS l(19) tc(1)

. . . NAME-main..autotmp_16 l(19) x(0) class(PAUTO) esc(N) tc(1) assigned used INTER-@0

. . . EFACE l(19) tc(1) INTER-@0

. . . . ADDR l(19) tc(1) PTR-@0

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

. . . . NAME-main..autotmp_17 l(19) x(0) class(PAUTO) esc(N) tc(1) assigned used UNSAFEPTR-@0

. BLOCK l(19) hascall

. BLOCK-list

. . AS l(19) tc(1)

. . . NAME-fmt.format l(212) x(0) class(PAUTO) esc(no) tc(1) assigned used string

. . . LITERAL-"%d, %d\n" l(19) tc(1) string

. . AS l(19) tc(1)

. . . NAME-main.~arg1 l(19) x(0) class(PAUTO) esc(no) tc(1) assigned used INTER-@0

. . . NAME-main..autotmp_14 l(19) x(0) class(PAUTO) esc(N) tc(1) assigned used INTER-@0

. . AS l(19) tc(1)

. . . NAME-main.~arg2 l(19) x(0) class(PAUTO) esc(no) tc(1) assigned used INTER-@0

. . . NAME-main..autotmp_16 l(19) x(0) class(PAUTO) esc(N) tc(1) assigned used INTER-@0

. EMPTY-init

. . AS l(19) tc(1)

. . . NAME-main..autotmp_20 l(19) x(0) class(PAUTO) esc(N) tc(1) addrtaken assigned used ARRAY-@0

. . AS l(19) tc(1)

. . . NAME-main..autotmp_18 l(19) x(0) class(PAUTO) esc(N) tc(1) assigned used PTR-@0

. . . ADDR l(19) tc(1) PTR-@0

. . . . NAME-main..autotmp_20 l(19) x(0) class(PAUTO) esc(N) tc(1) addrtaken assigned used ARRAY-@0

. . BLOCK l(19)

. . BLOCK-list

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

. . . . INDEX l(19) tc(1) bounded hascall INTER-@0

. . . . . DEREF l(19) tc(1) implicit(true) hascall ARRAY-@0

. . . . . . NAME-main..autotmp_18 l(19) x(0) class(PAUTO) esc(N) tc(1) assigned used PTR-@0

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

. . . . NAME-main.~arg1 l(19) x(0) class(PAUTO) esc(no) tc(1) assigned used INTER-@0

. . BLOCK l(19)

. . BLOCK-list

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

. . . . INDEX l(19) tc(1) bounded hascall INTER-@0

. . . . . DEREF l(19) tc(1) implicit(true) hascall ARRAY-@0

. . . . . . NAME-main..autotmp_18 l(19) x(0) class(PAUTO) esc(N) tc(1) assigned used PTR-@0

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

. . . . NAME-main.~arg2 l(19) x(0) class(PAUTO) esc(no) tc(1) assigned used INTER-@0

. . BLOCK l(19)

. . BLOCK-list

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

. . . . NAME-fmt.a l(212) x(0) class(PAUTO) esc(no) tc(1) assigned used SLICE-@0

. . . . SLICEARR l(19) tc(1) hascall SLICE-@0

. . . . . NAME-main..autotmp_18 l(19) x(0) class(PAUTO) esc(N) tc(1) assigned used PTR-@0

. EMPTY l(19) tc(1) hascall

. . NAME-fmt.a l(212) x(0) class(PAUTO) esc(no) tc(1) assigned used SLICE-@0

. AS l(19) tc(1)

. . NAME-fmt.n l(212) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. AS l(19) tc(1)

. . NAME-fmt.err l(212) x(0) class(PAUTO) esc(no) tc(1) assigned used error

. INLMARK l(+19) x(0)

. DCL l(19) tc(1)

. . NAME-fmt..autotmp_4 l(213) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. AS l(19) tc(1)

. . NAME-fmt..autotmp_4 l(213) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. DCL l(19) tc(1)

. . NAME-fmt..autotmp_5 l(213) x(0) class(PAUTO) esc(no) tc(1) assigned used error

. AS l(19) tc(1)

. . NAME-fmt..autotmp_5 l(213) x(0) class(PAUTO) esc(no) tc(1) assigned used error

. AS l(213) tc(1)

. . NAME-main..autotmp_13 l(213) x(0) class(PAUTO) esc(N) tc(1) assigned used error

. BLOCK-init

. . CALLFUNC l(213) tc(1) isddd(true) hascall STRUCT-@0

. . . NAME-fmt.Fprintf l(202) x(0) class(PFUNC) tc(1) used FUNC-@0

. . CALLFUNC-rlist

. . . EFACE l(213) tc(1) io.Writer

. . . . ADDR l(213) tc(1) PTR-@0

. . . . . NAME-go.itab.*os.File,io.Writer l(213) x(0) class(PEXTERN) tc(1) uint8

. . . . NAME-os.Stdout l(64) x(0) class(PEXTERN) tc(1) used PTR-@0

. . . NAME-fmt.format l(212) x(0) class(PAUTO) esc(no) tc(1) assigned used string

. . . NAME-fmt.a l(212) x(0) class(PAUTO) esc(no) tc(1) assigned used SLICE-@0

. BLOCK l(213) hascall

. BLOCK-list

. . AS l(213) tc(1)

. . . NAME-main..autotmp_12 l(213) x(0) class(PAUTO) esc(N) tc(1) used int

. . . RESULT l(213) x(64) tc(1) int

. . AS l(213) tc(1)

. . . NAME-main..autotmp_13 l(213) x(0) class(PAUTO) esc(N) tc(1) assigned used error

. . . RESULT l(213) x(72) tc(1) error

. BLOCK l(213)

. BLOCK-list

. . AS l(213) tc(1)

. . . NAME-fmt..autotmp_4 l(213) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. . . NAME-main..autotmp_12 l(213) x(0) class(PAUTO) esc(N) tc(1) used int

. . AS l(213) tc(1)

. . . NAME-fmt..autotmp_5 l(213) x(0) class(PAUTO) esc(no) tc(1) assigned used error

. . . NAME-main..autotmp_13 l(213) x(0) class(PAUTO) esc(N) tc(1) assigned used error

. VARKILL l(213) tc(1)

. . NAME-main..autotmp_13 l(213) x(0) class(PAUTO) esc(N) tc(1) assigned used error

. VARKILL l(213) tc(1)

. . NAME-main..autotmp_12 l(213) x(0) class(PAUTO) esc(N) tc(1) used int

. BLOCK l(19)

. BLOCK-list

. . AS l(19) tc(1)

. . . NAME-fmt.n l(212) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. . . NAME-fmt..autotmp_4 l(213) x(0) class(PAUTO) esc(no) tc(1) assigned used int

. . AS l(19) tc(1)

. . . NAME-fmt.err l(212) x(0) class(PAUTO) esc(no) tc(1) assigned used error

. . . NAME-fmt..autotmp_5 l(213) x(0) class(PAUTO) esc(no) tc(1) assigned used error

. GOTO l(19) tc(1) main..i0

. LABEL l(19) tc(1) main..i0

buildssa-exit

start

start

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = Const64 <int> [0] (w[int], x[int], fmt.n[int], y[int], z[int], fmt..autotmp_4[int])
v5 (?) = Const64 <int> [5] (x[int])
v6 (?) = Const64 <int> [3]
v7 (9) = Sub64 <int> v5 v6 (x[int])
v8 (10) = Less64 <bool> v7 v6
v10 (?) = Const64 <int> [2]
v18 (?) = OffPtr <*int> [8] v2
v22 (?) = OffPtr <*unsafe.Pointer> [16] v2
v24 (?) = Addr <*uint8> {type.int} v3
v29 (?) = Addr <*uint8> {type.int} v3
v31 (?) = ConstString <string> {"%d, %d\n"} (fmt.format[string])
v40 (?) = Const64 <int> [1]
v50 (?) = ConstInterface <error> (fmt..autotmp_5[error], fmt.err[error])
v53 (?) = OffPtr <*io.Writer> [8] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [24] v2
v62 (?) = OffPtr <*[]interface {}> [40] v2
v65 (?) = OffPtr <*int> [64] v2
v67 (?) = OffPtr <*error> [72] v2
If v8 → b3 b4 (10)
b2: ← b3 b4
v14 (16) = Phi <int> v9 v12 (x[int])
v15 (16) = Phi <int> v11 v13 (y[int])
v16 (16) = Sub64 <int> v14 v15 (w[int])
v17 (17) = Add64 <int> v14 v15 (z[int])
v19 (19) = Copy <mem> v1
v20 (19) = Store <mem> {int} v18 v16 v19
v21 (19) = StaticCall <mem> {runtime.convT64} [16] v20
v23 (19) = Load <unsafe.Pointer> v22 v21
v25 (19) = IMake <interface {}> v24 v23 (~arg1[interface {}])
v26 (19) = Store <mem> {int} v18 v17 v21
v27 (19) = StaticCall <mem> {runtime.convT64} [16] v26
v28 (19) = Load <unsafe.Pointer> v22 v27
v30 (19) = IMake <interface {}> v29 v28 (~arg2[interface {}])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v34
v36 (19) = NilCheck <void> v35 v34
v37 (19) = PtrIndex <*interface {}> v35 v4
v38 (19) = Store <mem> {interface {}} v37 v25 v34
v39 (19) = NilCheck <void> v35 v38
v41 (19) = PtrIndex <*interface {}> v35 v40
v42 (19) = Store <mem> {interface {}} v41 v30 v38
v43 (19) = NilCheck <void> v35 v42
v44 (19) = Copy <*interface {}> v35
v45 (19) = IsSliceInBounds <bool> v4 v10
If v45 → b5 b6 (likely) (19)
b3: ← b1
v9 (11) = Copy <int> v7 (x[int])
v11 (11) = Mul64 <int> v9 v10 (w[int], y[int])
Plain → b2 (12)
b4: ← b1
v12 (14) = Copy <int> v7 (x[int])
v13 (14) = Sub64 <int> v12 v6 (y[int])
Plain → b2 (14)
b5: ← b2
v48 (19) = Sub64 <int> v10 v4
v49 (19) = SliceMake <[]interface {}> v44 v48 v48 (fmt.a[[]interface {}])
v51 (19) = Copy <mem> v42
v52 (+19) = InlMark <void> [0] v51
v56 (213) = Load <*os.File> v55 v51
v57 (213) = IMake <io.Writer> v54 v56
v58 (213) = Store <mem> {io.Writer} v53 v57 v51
v60 (213) = Copy <string> v31 (fmt.format[string])
v61 (213) = Store <mem> {string} v59 v60 v58
v63 (213) = Store <mem> {[]interface {}} v62 v49 v61
v64 (213) = StaticCall <mem> {fmt.Fprintf} [80] v63
v66 (213) = Load <int> v65 v64 (fmt..autotmp_4[int], fmt.n[int])
v68 (213) = Load <error> v67 v64 (fmt.err[error], fmt..autotmp_5[error])
Plain → b7 (+19)
b6: ← b2
v46 (19) = Copy <mem> v42
v47 (19) = PanicBounds <mem> [6] v4 v10 v46
Exit v47 (19)
b7: ← b5
v69 (20) = Copy <mem> v64
Ret v69
name w[int]: v4 v11 v16 
name x[int]: v4 v5 v7 v9 v12 v14 
name y[int]: v4 v11 v13 v15 
name z[int]: v4 v17 
name fmt.format[string]: v31 v60 
name ~arg1[interface {}]: v25 
name ~arg2[interface {}]: v30 
name fmt.a[[]interface {}]: v49 
name fmt.n[int]: v4 v66 
name fmt.err[error]: v50 v68 
name fmt..autotmp_4[int]: v4 v66 
name fmt..autotmp_5[error]: v50 v68

number lines + early phielim

number lines [111400 ns]

early phielim [40000 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = Const64 <int> [0] (w[int], x[int], fmt.n[int], y[int], z[int], fmt..autotmp_4[int])
v5 (?) = Const64 <int> [5] (x[int])
v6 (?) = Const64 <int> [3]
v7 (+9) = Sub64 <int> v5 v6 (x[int])
v8 (+10) = Less64 <bool> v7 v6
v10 (?) = Const64 <int> [2]
v18 (?) = OffPtr <*int> [8] v2
v22 (?) = OffPtr <*unsafe.Pointer> [16] v2
v24 (?) = Addr <*uint8> {type.int} v3
v29 (?) = Addr <*uint8> {type.int} v3
v31 (?) = ConstString <string> {"%d, %d\n"} (fmt.format[string])
v40 (?) = Const64 <int> [1]
v50 (?) = ConstInterface <error> (fmt.err[error], fmt..autotmp_5[error])
v53 (?) = OffPtr <*io.Writer> [8] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [24] v2
v62 (?) = OffPtr <*[]interface {}> [40] v2
v65 (?) = OffPtr <*int> [64] v2
v67 (?) = OffPtr <*error> [72] v2
If v8 → b3 b4 (10)
b2: ← b3 b4
v15 (16) = Phi <int> v11 v13 (y[int])
v14 (16) = Copy <int> v7 (x[int])
v16 (+16) = Sub64 <int> v7 v15 (w[int])
v17 (+17) = Add64 <int> v7 v15 (z[int])
v19 (19) = Copy <mem> v1
v20 (19) = Store <mem> {int} v18 v16 v1
v21 (+19) = StaticCall <mem> {runtime.convT64} [16] v20
v23 (19) = Load <unsafe.Pointer> v22 v21
v25 (19) = IMake <interface {}> v24 v23 (~arg1[interface {}])
v26 (19) = Store <mem> {int} v18 v17 v21
v27 (19) = StaticCall <mem> {runtime.convT64} [16] v26
v28 (19) = Load <unsafe.Pointer> v22 v27
v30 (19) = IMake <interface {}> v29 v28 (~arg2[interface {}])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v34
v36 (19) = NilCheck <void> v35 v34
v37 (19) = PtrIndex <*interface {}> v35 v4
v38 (19) = Store <mem> {interface {}} v37 v25 v34
v39 (19) = NilCheck <void> v35 v38
v41 (19) = PtrIndex <*interface {}> v35 v40
v42 (19) = Store <mem> {interface {}} v41 v30 v38
v43 (19) = NilCheck <void> v35 v42
v44 (19) = Copy <*interface {}> v35
v45 (19) = IsSliceInBounds <bool> v4 v10
If v45 → b5 b6 (likely) (19)
b3: ← b1
v9 (11) = Copy <int> v7 (x[int])
v11 (+11) = Mul64 <int> v7 v10 (y[int], w[int])
Plain → b2 (+12)
b4: ← b1
v12 (14) = Copy <int> v7 (x[int])
v13 (+14) = Sub64 <int> v7 v6 (y[int])
Plain → b2 (14)
b5: ← b2
v48 (19) = Sub64 <int> v10 v4
v49 (19) = SliceMake <[]interface {}> v35 v48 v48 (fmt.a[[]interface {}])
v51 (19) = Copy <mem> v42
v52 (19) = InlMark <void> [0] v42
v56 (+213) = Load <*os.File> v55 v42
v57 (213) = IMake <io.Writer> v54 v56
v58 (213) = Store <mem> {io.Writer} v53 v57 v42
v60 (213) = Copy <string> v31 (fmt.format[string])
v61 (213) = Store <mem> {string} v59 v31 v58
v63 (213) = Store <mem> {[]interface {}} v62 v49 v61
v64 (213) = StaticCall <mem> {fmt.Fprintf} [80] v63
v66 (213) = Load <int> v65 v64 (fmt.n[int], fmt..autotmp_4[int])
v68 (213) = Load <error> v67 v64 (fmt.err[error], fmt..autotmp_5[error])
Plain → b7 (+19)
b6: ← b2
v46 (19) = Copy <mem> v42
v47 (19) = PanicBounds <mem> [6] v4 v10 v42
Exit v47 (19)
b7: ← b5
v69 (20) = Copy <mem> v64
Ret v69 (+19)
name w[int]: v4 v11 v16 
name x[int]: v4 v5 v7 v9 v12 v14 
name y[int]: v4 v11 v13 v15 
name z[int]: v4 v17 
name fmt.format[string]: v31 v60 
name ~arg1[interface {}]: v25 
name ~arg2[interface {}]: v30 
name fmt.a[[]interface {}]: v49 
name fmt.n[int]: v4 v66 
name fmt.err[error]: v50 v68 
name fmt..autotmp_4[int]: v4 v66 
name fmt..autotmp_5[error]: v50 v68

early copyelim

early copyelim [22100 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = Const64 <int> [0] (fmt.n[int], w[int], x[int], y[int], z[int], fmt..autotmp_4[int])
v5 (?) = Const64 <int> [5] (x[int])
v6 (?) = Const64 <int> [3]
v7 (+9) = Sub64 <int> v5 v6 (x[int])
v8 (+10) = Less64 <bool> v7 v6
v10 (?) = Const64 <int> [2]
v18 (?) = OffPtr <*int> [8] v2
v22 (?) = OffPtr <*unsafe.Pointer> [16] v2
v24 (?) = Addr <*uint8> {type.int} v3
v29 (?) = Addr <*uint8> {type.int} v3
v31 (?) = ConstString <string> {"%d, %d\n"} (fmt.format[string])
v40 (?) = Const64 <int> [1]
v50 (?) = ConstInterface <error> (fmt.err[error], fmt..autotmp_5[error])
v53 (?) = OffPtr <*io.Writer> [8] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [24] v2
v62 (?) = OffPtr <*[]interface {}> [40] v2
v65 (?) = OffPtr <*int> [64] v2
v67 (?) = OffPtr <*error> [72] v2
If v8 → b3 b4 (10)
b2: ← b3 b4
v15 (16) = Phi <int> v11 v13 (y[int])
v14 (16) = Copy <int> v7
v16 (+16) = Sub64 <int> v7 v15 (w[int])
v17 (+17) = Add64 <int> v7 v15 (z[int])
v19 (19) = Copy <mem> v1
v20 (19) = Store <mem> {int} v18 v16 v1
v21 (+19) = StaticCall <mem> {runtime.convT64} [16] v20
v23 (19) = Load <unsafe.Pointer> v22 v21
v25 (19) = IMake <interface {}> v24 v23 (~arg1[interface {}])
v26 (19) = Store <mem> {int} v18 v17 v21
v27 (19) = StaticCall <mem> {runtime.convT64} [16] v26
v28 (19) = Load <unsafe.Pointer> v22 v27
v30 (19) = IMake <interface {}> v29 v28 (~arg2[interface {}])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v34
v36 (19) = NilCheck <void> v35 v34
v37 (19) = PtrIndex <*interface {}> v35 v4
v38 (19) = Store <mem> {interface {}} v37 v25 v34
v39 (19) = NilCheck <void> v35 v38
v41 (19) = PtrIndex <*interface {}> v35 v40
v42 (19) = Store <mem> {interface {}} v41 v30 v38
v43 (19) = NilCheck <void> v35 v42
v44 (19) = Copy <*interface {}> v35
v45 (19) = IsSliceInBounds <bool> v4 v10
If v45 → b5 b6 (likely) (19)
b3: ← b1
v9 (11) = Copy <int> v7
v11 (+11) = Mul64 <int> v7 v10 (w[int], y[int])
Plain → b2 (+12)
b4: ← b1
v12 (14) = Copy <int> v7
v13 (+14) = Sub64 <int> v7 v6 (y[int])
Plain → b2 (14)
b5: ← b2
v48 (19) = Sub64 <int> v10 v4
v49 (19) = SliceMake <[]interface {}> v35 v48 v48 (fmt.a[[]interface {}])
v51 (19) = Copy <mem> v42
v52 (19) = InlMark <void> [0] v42
v56 (+213) = Load <*os.File> v55 v42
v57 (213) = IMake <io.Writer> v54 v56
v58 (213) = Store <mem> {io.Writer} v53 v57 v42
v60 (213) = Copy <string> v31
v61 (213) = Store <mem> {string} v59 v31 v58
v63 (213) = Store <mem> {[]interface {}} v62 v49 v61
v64 (213) = StaticCall <mem> {fmt.Fprintf} [80] v63
v66 (213) = Load <int> v65 v64 (fmt..autotmp_4[int], fmt.n[int])
v68 (213) = Load <error> v67 v64 (fmt.err[error], fmt..autotmp_5[error])
Plain → b7 (+19)
b6: ← b2
v46 (19) = Copy <mem> v42
v47 (19) = PanicBounds <mem> [6] v4 v10 v42
Exit v47 (19)
b7: ← b5
v69 (20) = Copy <mem> v64
Ret v64 (+19)
name w[int]: v4 v11 v16 
name x[int]: v4 v5 v7 v7 v7 v7 
name y[int]: v4 v11 v13 v15 
name z[int]: v4 v17 
name fmt.format[string]: v31 v31 
name ~arg1[interface {}]: v25 
name ~arg2[interface {}]: v30 
name fmt.a[[]interface {}]: v49 
name fmt.n[int]: v4 v66 
name fmt.err[error]: v50 v68 
name fmt..autotmp_4[int]: v4 v66 
name fmt..autotmp_5[error]: v50 v68

early deadcode

early deadcode [208800 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = Const64 <int> [0] (y[int], z[int], fmt..autotmp_4[int], w[int], x[int], fmt.n[int])
v5 (?) = Const64 <int> [5] (x[int])
v6 (?) = Const64 <int> [3]
v7 (+9) = Sub64 <int> v5 v6 (x[int])
v8 (+10) = Less64 <bool> v7 v6
v10 (?) = Const64 <int> [2]
v18 (?) = OffPtr <*int> [8] v2
v22 (?) = OffPtr <*unsafe.Pointer> [16] v2
v24 (?) = Addr <*uint8> {type.int} v3
v29 (?) = Addr <*uint8> {type.int} v3
v31 (?) = ConstString <string> {"%d, %d\n"} (fmt.format[string])
v40 (?) = Const64 <int> [1]
v53 (?) = OffPtr <*io.Writer> [8] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [24] v2
v62 (?) = OffPtr <*[]interface {}> [40] v2
If v8 → b3 b4 (10)
b2: ← b3 b4
v15 (16) = Phi <int> v11 v13 (y[int])
v16 (+16) = Sub64 <int> v7 v15 (w[int])
v17 (+17) = Add64 <int> v7 v15 (z[int])
v20 (19) = Store <mem> {int} v18 v16 v1
v21 (+19) = StaticCall <mem> {runtime.convT64} [16] v20
v23 (19) = Load <unsafe.Pointer> v22 v21
v25 (19) = IMake <interface {}> v24 v23 (~arg1[interface {}])
v26 (19) = Store <mem> {int} v18 v17 v21
v27 (19) = StaticCall <mem> {runtime.convT64} [16] v26
v28 (19) = Load <unsafe.Pointer> v22 v27
v30 (19) = IMake <interface {}> v29 v28 (~arg2[interface {}])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v34
v36 (19) = NilCheck <void> v35 v34
v37 (19) = PtrIndex <*interface {}> v35 v4
v38 (19) = Store <mem> {interface {}} v37 v25 v34
v39 (19) = NilCheck <void> v35 v38
v41 (19) = PtrIndex <*interface {}> v35 v40
v42 (19) = Store <mem> {interface {}} v41 v30 v38
v43 (19) = NilCheck <void> v35 v42
v45 (19) = IsSliceInBounds <bool> v4 v10
If v45 → b5 b6 (likely) (19)
b3: ← b1
v11 (+11) = Mul64 <int> v7 v10 (y[int], w[int])
Plain → b2 (+12)
b4: ← b1
v13 (+14) = Sub64 <int> v7 v6 (y[int])
Plain → b2 (14)
b5: ← b2
v48 (19) = Sub64 <int> v10 v4
v49 (19) = SliceMake <[]interface {}> v35 v48 v48 (fmt.a[[]interface {}])
v52 (19) = InlMark <void> [0] v42
v56 (+213) = Load <*os.File> v55 v42
v57 (213) = IMake <io.Writer> v54 v56
v58 (213) = Store <mem> {io.Writer} v53 v57 v42
v61 (213) = Store <mem> {string} v59 v31 v58
v63 (213) = Store <mem> {[]interface {}} v62 v49 v61
v64 (213) = StaticCall <mem> {fmt.Fprintf} [80] v63
Plain → b7 (+19)
b6: ← b2
v47 (19) = PanicBounds <mem> [6] v4 v10 v42
Exit v47 (19)
b7: ← b5
Ret v64 (+19)
name w[int]: v4 v11 v16 
name x[int]: v4 v5 v7 
name y[int]: v4 v11 v13 v15 
name z[int]: v4 v17 
name fmt.format[string]: v31 
name ~arg1[interface {}]: v25 
name ~arg2[interface {}]: v30 
name fmt.a[[]interface {}]: v49 
name fmt.n[int]: v4 
name fmt..autotmp_4[int]: v4

short circuit

short circuit [24500 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = Const64 <int> [0] (y[int], z[int], fmt..autotmp_4[int], w[int], x[int], fmt.n[int])
v5 (?) = Const64 <int> [5] (x[int])
v6 (?) = Const64 <int> [3]
v7 (+9) = Sub64 <int> v5 v6 (x[int])
v8 (+10) = Less64 <bool> v7 v6
v10 (?) = Const64 <int> [2]
v18 (?) = OffPtr <*int> [8] v2
v22 (?) = OffPtr <*unsafe.Pointer> [16] v2
v24 (?) = Addr <*uint8> {type.int} v3
v29 (?) = Addr <*uint8> {type.int} v3
v31 (?) = ConstString <string> {"%d, %d\n"} (fmt.format[string])
v40 (?) = Const64 <int> [1]
v53 (?) = OffPtr <*io.Writer> [8] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [24] v2
v62 (?) = OffPtr <*[]interface {}> [40] v2
If v8 → b3 b4 (10)
b2: ← b3 b4
v15 (16) = Phi <int> v11 v13 (y[int])
v16 (+16) = Sub64 <int> v7 v15 (w[int])
v17 (+17) = Add64 <int> v7 v15 (z[int])
v20 (19) = Store <mem> {int} v18 v16 v1
v21 (+19) = StaticCall <mem> {runtime.convT64} [16] v20
v23 (19) = Load <unsafe.Pointer> v22 v21
v25 (19) = IMake <interface {}> v24 v23 (~arg1[interface {}])
v26 (19) = Store <mem> {int} v18 v17 v21
v27 (19) = StaticCall <mem> {runtime.convT64} [16] v26
v28 (19) = Load <unsafe.Pointer> v22 v27
v30 (19) = IMake <interface {}> v29 v28 (~arg2[interface {}])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v34
v36 (19) = NilCheck <void> v35 v34
v37 (19) = PtrIndex <*interface {}> v35 v4
v38 (19) = Store <mem> {interface {}} v37 v25 v34
v39 (19) = NilCheck <void> v35 v38
v41 (19) = PtrIndex <*interface {}> v35 v40
v42 (19) = Store <mem> {interface {}} v41 v30 v38
v43 (19) = NilCheck <void> v35 v42
v45 (19) = IsSliceInBounds <bool> v4 v10
If v45 → b7 b6 (likely) (19)
b3: ← b1
v11 (+11) = Mul64 <int> v7 v10 (y[int], w[int])
Plain → b2 (+12)
b4: ← b1
v13 (+14) = Sub64 <int> v7 v6 (y[int])
Plain → b2 (14)
b5:
BlockInvalid (+19)
b6: ← b2
v47 (19) = PanicBounds <mem> [6] v4 v10 v42
Exit v47 (19)
b7: ← b2
v48 (19) = Sub64 <int> v10 v4
v49 (19) = SliceMake <[]interface {}> v35 v48 v48 (fmt.a[[]interface {}])
v52 (19) = InlMark <void> [0] v42
v56 (+213) = Load <*os.File> v55 v42
v57 (213) = IMake <io.Writer> v54 v56
v58 (213) = Store <mem> {io.Writer} v53 v57 v42
v61 (213) = Store <mem> {string} v59 v31 v58
v63 (213) = Store <mem> {[]interface {}} v62 v49 v61
v64 (213) = StaticCall <mem> {fmt.Fprintf} [80] v63
Ret v64 (+19)
name w[int]: v4 v11 v16 
name x[int]: v4 v5 v7 
name y[int]: v4 v11 v13 v15 
name z[int]: v4 v17 
name fmt.format[string]: v31 
name ~arg1[interface {}]: v25 
name ~arg2[interface {}]: v30 
name fmt.a[[]interface {}]: v49 
name fmt.n[int]: v4 
name fmt..autotmp_4[int]: v4

decompose args + decompose user + pre-opt deadcode

decompose args [25600 ns]

decompose user [20300 ns]

pre-opt deadcode [46300 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = Const64 <int> [0] (y[int], z[int], fmt..autotmp_4[int], w[int], x[int], fmt.n[int])
v5 (?) = Const64 <int> [5] (x[int])
v6 (?) = Const64 <int> [3]
v7 (+9) = Sub64 <int> v5 v6 (x[int])
v8 (+10) = Less64 <bool> v7 v6
v10 (?) = Const64 <int> [2]
v18 (?) = OffPtr <*int> [8] v2
v22 (?) = OffPtr <*unsafe.Pointer> [16] v2
v24 (?) = Addr <*uint8> {type.int} v3
v29 (?) = Addr <*uint8> {type.int} v3
v31 (?) = ConstString <string> {"%d, %d\n"} (fmt.format[string])
v40 (?) = Const64 <int> [1]
v53 (?) = OffPtr <*io.Writer> [8] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [24] v2
v62 (?) = OffPtr <*[]interface {}> [40] v2
If v8 → b3 b4 (10)
b2: ← b3 b4
v15 (16) = Phi <int> v11 v13 (y[int])
v16 (+16) = Sub64 <int> v7 v15 (w[int])
v17 (+17) = Add64 <int> v7 v15 (z[int])
v20 (19) = Store <mem> {int} v18 v16 v1
v21 (+19) = StaticCall <mem> {runtime.convT64} [16] v20
v23 (19) = Load <unsafe.Pointer> v22 v21
v25 (19) = IMake <interface {}> v24 v23 (~arg1[interface {}])
v26 (19) = Store <mem> {int} v18 v17 v21
v27 (19) = StaticCall <mem> {runtime.convT64} [16] v26
v28 (19) = Load <unsafe.Pointer> v22 v27
v30 (19) = IMake <interface {}> v29 v28 (~arg2[interface {}])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v34
v36 (19) = NilCheck <void> v35 v34
v37 (19) = PtrIndex <*interface {}> v35 v4
v38 (19) = Store <mem> {interface {}} v37 v25 v34
v39 (19) = NilCheck <void> v35 v38
v41 (19) = PtrIndex <*interface {}> v35 v40
v42 (19) = Store <mem> {interface {}} v41 v30 v38
v43 (19) = NilCheck <void> v35 v42
v45 (19) = IsSliceInBounds <bool> v4 v10
If v45 → b7 b6 (likely) (19)
b3: ← b1
v11 (+11) = Mul64 <int> v7 v10 (y[int], w[int])
Plain → b2 (+12)
b4: ← b1
v13 (+14) = Sub64 <int> v7 v6 (y[int])
Plain → b2 (14)
b6: ← b2
v47 (19) = PanicBounds <mem> [6] v4 v10 v42
Exit v47 (19)
b7: ← b2
v48 (19) = Sub64 <int> v10 v4
v49 (19) = SliceMake <[]interface {}> v35 v48 v48 (fmt.a[[]interface {}])
v52 (19) = InlMark <void> [0] v42
v56 (+213) = Load <*os.File> v55 v42
v57 (213) = IMake <io.Writer> v54 v56
v58 (213) = Store <mem> {io.Writer} v53 v57 v42
v61 (213) = Store <mem> {string} v59 v31 v58
v63 (213) = Store <mem> {[]interface {}} v62 v49 v61
v64 (213) = StaticCall <mem> {fmt.Fprintf} [80] v63
Ret v64 (+19)
name w[int]: v4 v11 v16 
name x[int]: v4 v5 v7 
name y[int]: v4 v11 v13 v15 
name z[int]: v4 v17 
name fmt.format[string]: v31 
name ~arg1[interface {}]: v25 
name ~arg2[interface {}]: v30 
name fmt.a[[]interface {}]: v49 
name fmt.n[int]: v4 
name fmt..autotmp_4[int]: v4

opt

opt [58800 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = Const64 <int> [0] (y[int], z[int], fmt..autotmp_4[int], w[int], x[int], fmt.n[int])
v5 (?) = Const64 <int> [5] (x[int])
v6 (?) = Const64 <int> [3]
v7 (+9) = Const64 <int> [2] (x[int])
v8 (+10) = ConstBool <bool> [true]
v10 (?) = Const64 <int> [2]
v18 (?) = OffPtr <*int> [8] v2
v22 (?) = OffPtr <*unsafe.Pointer> [16] v2
v24 (?) = Addr <*uint8> {type.int} v3
v29 (?) = Addr <*uint8> {type.int} v3
v40 (?) = Const64 <int> [1]
v53 (?) = OffPtr <*io.Writer> [8] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [24] v2
v62 (?) = OffPtr <*[]interface {}> [40] v2
v46 (?) = SB <uintptr>
v68 (?) = Const64 <int> [7]
v69 (?) = Addr <*uint8> {go.string."%d, %d\n"} v46
v31 (?) = StringMake <string> v69 v68 (fmt.format[string])
First → b3 b4 (10)
b2: ← b3 b4
v15 (16) = Phi <int> v11 v13 (y[int])
v16 (+16) = Sub64 <int> v7 v15 (w[int])
v17 (+17) = Add64 <int> v7 v15 (z[int])
v20 (19) = Store <mem> {int} v18 v16 v1
v21 (+19) = StaticCall <mem> {runtime.convT64} [16] v20
v23 (19) = Load <unsafe.Pointer> v22 v21
v25 (19) = IMake <interface {}> v24 v23 (~arg1[interface {}])
v26 (19) = Store <mem> {int} v18 v17 v21
v27 (19) = StaticCall <mem> {runtime.convT64} [16] v26
v28 (19) = Load <unsafe.Pointer> v22 v27
v30 (19) = IMake <interface {}> v29 v28 (~arg2[interface {}])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v34
v36 (19) = NilCheck <void> v35 v34
v37 (19) = OffPtr <*interface {}> [0] v35
v38 (19) = Store <mem> {interface {}} v37 v25 v34
v39 (19) = NilCheck <void> v35 v38
v41 (19) = OffPtr <*interface {}> [16] v35
v42 (19) = Store <mem> {interface {}} v41 v30 v38
v43 (19) = NilCheck <void> v35 v42
v45 (19) = ConstBool <bool> [true]
v66 (19) = Const64 <int> [0]
v60 (19) = Const64 <int> [16]
v51 (19) = Const64 <int> [16]
v12 (19) = Const64 <int> [16]
First → b7 b6 (likely) (19)
b3: ← b1
v11 (+11) = Const64 <int> [4] (y[int], w[int])
Plain → b2 (+12)
b4: ← b1
v13 (+14) = Const64 <int> [-1] (y[int])
Plain → b2 (14)
b6: ← b2
v47 (19) = PanicBounds <mem> [6] v4 v10 v42
Exit v47 (19)
b7: ← b2
v48 (19) = Const64 <int> [2]
v49 (19) = SliceMake <[]interface {}> v35 v48 v48 (fmt.a[[]interface {}])
v52 (19) = InlMark <void> [0] v42
v56 (+213) = Load <*os.File> v55 v42
v57 (213) = IMake <io.Writer> v54 v56
v58 (213) = Store <mem> {io.Writer} v53 v57 v42
v61 (213) = Store <mem> {string} v59 v31 v58
v63 (213) = Store <mem> {[]interface {}} v62 v49 v61
v64 (213) = StaticCall <mem> {fmt.Fprintf} [80] v63
Ret v64 (+19)
name w[int]: v4 v11 v16 
name x[int]: v4 v5 v7 
name y[int]: v4 v11 v13 v15 
name z[int]: v4 v17 
name fmt.format[string]: v31 
name ~arg1[interface {}]: v25 
name ~arg2[interface {}]: v30 
name fmt.a[[]interface {}]: v49 
name fmt.n[int]: v4 
name fmt..autotmp_4[int]: v4

zero arg cse

zero arg cse [34200 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = Const64 <int> [0] (y[int], z[int], fmt..autotmp_4[int], w[int], x[int], fmt.n[int])
v5 (?) = Const64 <int> [5] (x[int])
v6 (?) = Const64 <int> [3]
v7 (+9) = Const64 <int> [2] (x[int])
v8 (+10) = ConstBool <bool> [true]
v10 (?) = Const64 <int> [2]
v18 (?) = OffPtr <*int> [8] v2
v22 (?) = OffPtr <*unsafe.Pointer> [16] v2
v24 (?) = Addr <*uint8> {type.int} v3
v29 (?) = Addr <*uint8> {type.int} v3
v40 (?) = Const64 <int> [1]
v53 (?) = OffPtr <*io.Writer> [8] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [24] v2
v62 (?) = OffPtr <*[]interface {}> [40] v2
v69 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3
v46 (?) = SB <uintptr>
v68 (?) = Const64 <int> [7]
v60 (19) = Const64 <int> [16]
v11 (+11) = Const64 <int> [4] (w[int], y[int])
v13 (+14) = Const64 <int> [-1] (y[int])
v31 (?) = StringMake <string> v69 v68 (fmt.format[string])
First → b3 b4 (10)
b2: ← b3 b4
v15 (16) = Phi <int> v11 v13 (y[int])
v16 (+16) = Sub64 <int> v7 v15 (w[int])
v17 (+17) = Add64 <int> v7 v15 (z[int])
v20 (19) = Store <mem> {int} v18 v16 v1
v21 (+19) = StaticCall <mem> {runtime.convT64} [16] v20
v23 (19) = Load <unsafe.Pointer> v22 v21
v25 (19) = IMake <interface {}> v24 v23 (~arg1[interface {}])
v26 (19) = Store <mem> {int} v18 v17 v21
v27 (19) = StaticCall <mem> {runtime.convT64} [16] v26
v28 (19) = Load <unsafe.Pointer> v22 v27
v30 (19) = IMake <interface {}> v29 v28 (~arg2[interface {}])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v34
v36 (19) = NilCheck <void> v35 v34
v37 (19) = OffPtr <*interface {}> [0] v35
v38 (19) = Store <mem> {interface {}} v37 v25 v34
v39 (19) = NilCheck <void> v35 v38
v41 (19) = OffPtr <*interface {}> [16] v35
v42 (19) = Store <mem> {interface {}} v41 v30 v38
v43 (19) = NilCheck <void> v35 v42
v45 (19) = ConstBool <bool> [true]
v66 (19) = Const64 <int> [0]
v12 (19) = Const64 <int> [16]
v51 (19) = Const64 <int> [16]
First → b7 b6 (likely) (19)
b3: ← b1
Plain → b2 (+12)
b4: ← b1
Plain → b2 (14)
b6: ← b2
v47 (19) = PanicBounds <mem> [6] v4 v7 v42
Exit v47 (19)
b7: ← b2
v48 (19) = Const64 <int> [2]
v49 (19) = SliceMake <[]interface {}> v35 v7 v7 (fmt.a[[]interface {}])
v52 (19) = InlMark <void> [0] v42
v56 (+213) = Load <*os.File> v55 v42
v57 (213) = IMake <io.Writer> v54 v56
v58 (213) = Store <mem> {io.Writer} v53 v57 v42
v61 (213) = Store <mem> {string} v59 v31 v58
v63 (213) = Store <mem> {[]interface {}} v62 v49 v61
v64 (213) = StaticCall <mem> {fmt.Fprintf} [80] v63
Ret v64 (+19)
name w[int]: v4 v11 v16 
name x[int]: v4 v5 v7 
name y[int]: v4 v11 v13 v15 
name z[int]: v4 v17 
name fmt.format[string]: v31 
name ~arg1[interface {}]: v25 
name ~arg2[interface {}]: v30 
name fmt.a[[]interface {}]: v49 
name fmt.n[int]: v4 
name fmt..autotmp_4[int]: v4

opt deadcode

opt deadcode [71600 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = Const64 <int> [2] (x[int])
v18 (?) = OffPtr <*int> [8] v2
v22 (?) = OffPtr <*unsafe.Pointer> [16] v2
v24 (?) = Addr <*uint8> {type.int} v3
v29 (?) = Addr <*uint8> {type.int} v3
v53 (?) = OffPtr <*io.Writer> [8] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [24] v2
v62 (?) = OffPtr <*[]interface {}> [40] v2
v69 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3
v68 (?) = Const64 <int> [7]
v11 (+11) = Const64 <int> [4] (y[int], w[int])
v31 (?) = StringMake <string> v69 v68 (fmt.format[string])
Plain → b3 (+10)
b2: ← b3
v16 (+16) = Sub64 <int> v7 v11 (w[int])
v17 (+17) = Add64 <int> v7 v11 (z[int])
v20 (19) = Store <mem> {int} v18 v16 v1
v21 (+19) = StaticCall <mem> {runtime.convT64} [16] v20
v23 (19) = Load <unsafe.Pointer> v22 v21
v25 (19) = IMake <interface {}> v24 v23 (~arg1[interface {}])
v26 (19) = Store <mem> {int} v18 v17 v21
v27 (19) = StaticCall <mem> {runtime.convT64} [16] v26
v28 (19) = Load <unsafe.Pointer> v22 v27
v30 (19) = IMake <interface {}> v29 v28 (~arg2[interface {}])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v34
v36 (19) = NilCheck <void> v35 v34
v37 (19) = OffPtr <*interface {}> [0] v35
v38 (19) = Store <mem> {interface {}} v37 v25 v34
v39 (19) = NilCheck <void> v35 v38
v41 (19) = OffPtr <*interface {}> [16] v35
v42 (19) = Store <mem> {interface {}} v41 v30 v38
v43 (19) = NilCheck <void> v35 v42
Plain → b7 (19)
b3: ← b1
Plain → b2 (+12)
b7: ← b2
v49 (19) = SliceMake <[]interface {}> v35 v7 v7 (fmt.a[[]interface {}])
v52 (19) = InlMark <void> [0] v42
v56 (+213) = Load <*os.File> v55 v42
v57 (213) = IMake <io.Writer> v54 v56
v58 (213) = Store <mem> {io.Writer} v53 v57 v42
v61 (213) = Store <mem> {string} v59 v31 v58
v63 (213) = Store <mem> {[]interface {}} v62 v49 v61
v64 (213) = StaticCall <mem> {fmt.Fprintf} [80] v63
Ret v64 (+19)
name w[int]: v11 v16 
name x[int]: v7 
name y[int]: v11 
name z[int]: v17 
name fmt.format[string]: v31 
name ~arg1[interface {}]: v25 
name ~arg2[interface {}]: v30 
name fmt.a[[]interface {}]: v49

generic cse

generic cse [48700 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = Const64 <int> [2] (x[int])
v18 (?) = OffPtr <*int> [8] v2
v22 (?) = OffPtr <*unsafe.Pointer> [16] v2
v24 (?) = Addr <*uint8> {type.int} v3
v29 (?) = Addr <*uint8> {type.int} v3
v53 (?) = OffPtr <*io.Writer> [8] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [24] v2
v62 (?) = OffPtr <*[]interface {}> [40] v2
v69 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3
v68 (?) = Const64 <int> [7]
v11 (+11) = Const64 <int> [4] (y[int], w[int])
v31 (?) = StringMake <string> v69 v68 (fmt.format[string])
Plain → b3 (+10)
b2: ← b3
v16 (+16) = Sub64 <int> v7 v11 (w[int])
v17 (+17) = Add64 <int> v7 v11 (z[int])
v20 (19) = Store <mem> {int} v18 v16 v1
v21 (+19) = StaticCall <mem> {runtime.convT64} [16] v20
v23 (19) = Load <unsafe.Pointer> v22 v21
v25 (19) = IMake <interface {}> v24 v23 (~arg1[interface {}])
v26 (19) = Store <mem> {int} v18 v17 v21
v27 (19) = StaticCall <mem> {runtime.convT64} [16] v26
v28 (19) = Load <unsafe.Pointer> v22 v27
v30 (19) = IMake <interface {}> v24 v28 (~arg2[interface {}])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v34
v36 (19) = NilCheck <void> v35 v34
v37 (19) = OffPtr <*interface {}> [0] v35
v38 (19) = Store <mem> {interface {}} v37 v25 v34
v39 (19) = NilCheck <void> v35 v38
v41 (19) = OffPtr <*interface {}> [16] v35
v42 (19) = Store <mem> {interface {}} v41 v30 v38
v43 (19) = NilCheck <void> v35 v42
Plain → b7 (19)
b3: ← b1
Plain → b2 (+12)
b7: ← b2
v49 (19) = SliceMake <[]interface {}> v35 v7 v7 (fmt.a[[]interface {}])
v52 (19) = InlMark <void> [0] v42
v56 (+213) = Load <*os.File> v55 v42
v57 (213) = IMake <io.Writer> v54 v56
v58 (213) = Store <mem> {io.Writer} v53 v57 v42
v61 (213) = Store <mem> {string} v59 v31 v58
v63 (213) = Store <mem> {[]interface {}} v62 v49 v61
v64 (213) = StaticCall <mem> {fmt.Fprintf} [80] v63
Ret v64 (+19)
name w[int]: v11 v16 
name x[int]: v7 
name y[int]: v11 
name z[int]: v17 
name fmt.format[string]: v31 
name ~arg1[interface {}]: v25 
name ~arg2[interface {}]: v30 
name fmt.a[[]interface {}]: v49

phiopt + gcse deadcode

phiopt [20200 ns]

gcse deadcode [32100 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = Const64 <int> [2] (x[int])
v18 (?) = OffPtr <*int> [8] v2
v22 (?) = OffPtr <*unsafe.Pointer> [16] v2
v24 (?) = Addr <*uint8> {type.int} v3
v53 (?) = OffPtr <*io.Writer> [8] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [24] v2
v62 (?) = OffPtr <*[]interface {}> [40] v2
v69 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3
v68 (?) = Const64 <int> [7]
v11 (+11) = Const64 <int> [4] (y[int], w[int])
v31 (?) = StringMake <string> v69 v68 (fmt.format[string])
Plain → b3 (+10)
b2: ← b3
v16 (+16) = Sub64 <int> v7 v11 (w[int])
v17 (+17) = Add64 <int> v7 v11 (z[int])
v20 (19) = Store <mem> {int} v18 v16 v1
v21 (+19) = StaticCall <mem> {runtime.convT64} [16] v20
v23 (19) = Load <unsafe.Pointer> v22 v21
v25 (19) = IMake <interface {}> v24 v23 (~arg1[interface {}])
v26 (19) = Store <mem> {int} v18 v17 v21
v27 (19) = StaticCall <mem> {runtime.convT64} [16] v26
v28 (19) = Load <unsafe.Pointer> v22 v27
v30 (19) = IMake <interface {}> v24 v28 (~arg2[interface {}])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v34
v36 (19) = NilCheck <void> v35 v34
v37 (19) = OffPtr <*interface {}> [0] v35
v38 (19) = Store <mem> {interface {}} v37 v25 v34
v39 (19) = NilCheck <void> v35 v38
v41 (19) = OffPtr <*interface {}> [16] v35
v42 (19) = Store <mem> {interface {}} v41 v30 v38
v43 (19) = NilCheck <void> v35 v42
Plain → b7 (19)
b3: ← b1
Plain → b2 (+12)
b7: ← b2
v49 (19) = SliceMake <[]interface {}> v35 v7 v7 (fmt.a[[]interface {}])
v52 (19) = InlMark <void> [0] v42
v56 (+213) = Load <*os.File> v55 v42
v57 (213) = IMake <io.Writer> v54 v56
v58 (213) = Store <mem> {io.Writer} v53 v57 v42
v61 (213) = Store <mem> {string} v59 v31 v58
v63 (213) = Store <mem> {[]interface {}} v62 v49 v61
v64 (213) = StaticCall <mem> {fmt.Fprintf} [80] v63
Ret v64 (+19)
name w[int]: v11 v16 
name x[int]: v7 
name y[int]: v11 
name z[int]: v17 
name fmt.format[string]: v31 
name ~arg1[interface {}]: v25 
name ~arg2[interface {}]: v30 
name fmt.a[[]interface {}]: v49

nilcheckelim

nilcheckelim [33500 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = Const64 <int> [2] (x[int])
v18 (?) = OffPtr <*int> [8] v2
v22 (?) = OffPtr <*unsafe.Pointer> [16] v2
v24 (?) = Addr <*uint8> {type.int} v3
v53 (?) = OffPtr <*io.Writer> [8] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [24] v2
v62 (?) = OffPtr <*[]interface {}> [40] v2
v69 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3
v68 (?) = Const64 <int> [7]
v11 (+11) = Const64 <int> [4] (y[int], w[int])
v31 (?) = StringMake <string> v69 v68 (fmt.format[string])
Plain → b3 (+10)
b2: ← b3
v16 (+16) = Sub64 <int> v7 v11 (w[int])
v17 (+17) = Add64 <int> v7 v11 (z[int])
v20 (19) = Store <mem> {int} v18 v16 v1
v21 (+19) = StaticCall <mem> {runtime.convT64} [16] v20
v23 (19) = Load <unsafe.Pointer> v22 v21
v25 (19) = IMake <interface {}> v24 v23 (~arg1[interface {}])
v26 (19) = Store <mem> {int} v18 v17 v21
v27 (19) = StaticCall <mem> {runtime.convT64} [16] v26
v28 (19) = Load <unsafe.Pointer> v22 v27
v30 (19) = IMake <interface {}> v24 v28 (~arg2[interface {}])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v34
v37 (19) = OffPtr <*interface {}> [0] v35
v41 (19) = OffPtr <*interface {}> [16] v35
v38 (19) = Store <mem> {interface {}} v37 v25 v34
v42 (19) = Store <mem> {interface {}} v41 v30 v38
Plain → b7 (19)
b3: ← b1
Plain → b2 (+12)
b7: ← b2
v49 (19) = SliceMake <[]interface {}> v35 v7 v7 (fmt.a[[]interface {}])
v52 (19) = InlMark <void> [0] v42
v56 (+213) = Load <*os.File> v55 v42
v57 (213) = IMake <io.Writer> v54 v56
v58 (213) = Store <mem> {io.Writer} v53 v57 v42
v61 (213) = Store <mem> {string} v59 v31 v58
v63 (213) = Store <mem> {[]interface {}} v62 v49 v61
v64 (213) = StaticCall <mem> {fmt.Fprintf} [80] v63
Ret v64 (+19)
name w[int]: v11 v16 
name x[int]: v7 
name y[int]: v11 
name z[int]: v17 
name fmt.format[string]: v31 
name ~arg1[interface {}]: v25 
name ~arg2[interface {}]: v30 
name fmt.a[[]interface {}]: v49

prove

prove [51000 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = Const64 <int> [2] (x[int])
v18 (?) = OffPtr <*int> [8] v2
v22 (?) = OffPtr <*unsafe.Pointer> [16] v2
v24 (?) = Addr <*uint8> {type.int} v3
v53 (?) = OffPtr <*io.Writer> [8] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [24] v2
v62 (?) = OffPtr <*[]interface {}> [40] v2
v69 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3
v68 (?) = Const64 <int> [7]
v11 (+11) = Const64 <int> [4] (y[int], w[int])
v43 (?) = Const64 <int64> [0]
v31 (?) = StringMake <string> v69 v68 (fmt.format[string])
Plain → b3 (+10)
b2: ← b3
v16 (+16) = Sub64 <int> v7 v11 (w[int])
v17 (+17) = Add64 <int> v7 v11 (z[int])
v20 (19) = Store <mem> {int} v18 v16 v1
v21 (+19) = StaticCall <mem> {runtime.convT64} [16] v20
v23 (19) = Load <unsafe.Pointer> v22 v21
v25 (19) = IMake <interface {}> v24 v23 (~arg1[interface {}])
v26 (19) = Store <mem> {int} v18 v17 v21
v27 (19) = StaticCall <mem> {runtime.convT64} [16] v26
v28 (19) = Load <unsafe.Pointer> v22 v27
v30 (19) = IMake <interface {}> v24 v28 (~arg2[interface {}])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v34
v37 (19) = OffPtr <*interface {}> [0] v35
v41 (19) = OffPtr <*interface {}> [16] v35
v38 (19) = Store <mem> {interface {}} v37 v25 v34
v42 (19) = Store <mem> {interface {}} v41 v30 v38
Plain → b7 (19)
b3: ← b1
Plain → b2 (+12)
b7: ← b2
v49 (19) = SliceMake <[]interface {}> v35 v7 v7 (fmt.a[[]interface {}])
v52 (19) = InlMark <void> [0] v42
v56 (+213) = Load <*os.File> v55 v42
v57 (213) = IMake <io.Writer> v54 v56
v58 (213) = Store <mem> {io.Writer} v53 v57 v42
v61 (213) = Store <mem> {string} v59 v31 v58
v63 (213) = Store <mem> {[]interface {}} v62 v49 v61
v64 (213) = StaticCall <mem> {fmt.Fprintf} [80] v63
Ret v64 (+19)
name w[int]: v11 v16 
name x[int]: v7 
name y[int]: v11 
name z[int]: v17 
name fmt.format[string]: v31 
name ~arg1[interface {}]: v25 
name ~arg2[interface {}]: v30 
name fmt.a[[]interface {}]: v49

early fuse

early fuse [24700 ns]

b1:
BlockInvalid (+10)
b2:
BlockInvalid (19)
b3:
BlockInvalid (+12)
b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = Const64 <int> [2] (x[int])
v18 (?) = OffPtr <*int> [8] v2
v22 (?) = OffPtr <*unsafe.Pointer> [16] v2
v24 (?) = Addr <*uint8> {type.int} v3
v53 (?) = OffPtr <*io.Writer> [8] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [24] v2
v62 (?) = OffPtr <*[]interface {}> [40] v2
v69 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3
v68 (?) = Const64 <int> [7]
v11 (+11) = Const64 <int> [4] (y[int], w[int])
v43 (?) = Const64 <int64> [0]
v16 (+16) = Sub64 <int> v7 v11 (w[int])
v17 (+17) = Add64 <int> v7 v11 (z[int])
v20 (19) = Store <mem> {int} v18 v16 v1
v21 (+19) = StaticCall <mem> {runtime.convT64} [16] v20
v23 (19) = Load <unsafe.Pointer> v22 v21
v25 (19) = IMake <interface {}> v24 v23 (~arg1[interface {}])
v26 (19) = Store <mem> {int} v18 v17 v21
v27 (19) = StaticCall <mem> {runtime.convT64} [16] v26
v28 (19) = Load <unsafe.Pointer> v22 v27
v30 (19) = IMake <interface {}> v24 v28 (~arg2[interface {}])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v34
v37 (19) = OffPtr <*interface {}> [0] v35
v41 (19) = OffPtr <*interface {}> [16] v35
v38 (19) = Store <mem> {interface {}} v37 v25 v34
v42 (19) = Store <mem> {interface {}} v41 v30 v38
v49 (19) = SliceMake <[]interface {}> v35 v7 v7 (fmt.a[[]interface {}])
v52 (19) = InlMark <void> [0] v42
v56 (+213) = Load <*os.File> v55 v42
v57 (213) = IMake <io.Writer> v54 v56
v58 (213) = Store <mem> {io.Writer} v53 v57 v42
v31 (?) = StringMake <string> v69 v68 (fmt.format[string])
v61 (213) = Store <mem> {string} v59 v31 v58
v63 (213) = Store <mem> {[]interface {}} v62 v49 v61
v64 (213) = StaticCall <mem> {fmt.Fprintf} [80] v63
Ret v64 (+19)
name w[int]: v11 v16 
name x[int]: v7 
name y[int]: v11 
name z[int]: v17 
name fmt.format[string]: v31 
name ~arg1[interface {}]: v25 
name ~arg2[interface {}]: v30 
name fmt.a[[]interface {}]: v49

decompose builtin

decompose builtin [92800 ns]

b1:
BlockInvalid (+10)
b2:
BlockInvalid (19)
b3:
BlockInvalid (+12)
b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = Const64 <int> [2] (a.cap[int], x[int], a.len[int])
v18 (?) = OffPtr <*int> [8] v2
v22 (?) = OffPtr <*unsafe.Pointer> [16] v2
v24 (?) = Addr <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v53 (?) = OffPtr <*io.Writer> [8] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [24] v2
v62 (?) = OffPtr <*[]interface {}> [40] v2
v69 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v68 (?) = Const64 <int> [7] (format.len[int])
v11 (+11) = Const64 <int> [4] (y[int], w[int])
v43 (?) = Const64 <int64> [0]
v16 (+16) = Sub64 <int> v7 v11 (w[int])
v17 (+17) = Add64 <int> v7 v11 (z[int])
v20 (19) = Store <mem> {int} v18 v16 v1
v21 (+19) = StaticCall <mem> {runtime.convT64} [16] v20
v23 (19) = Load <unsafe.Pointer> v22 v21 (~arg1.data[*uint8])
v25 (19) = IMake <interface {}> v24 v23
v26 (19) = Store <mem> {int} v18 v17 v21
v27 (19) = StaticCall <mem> {runtime.convT64} [16] v26
v28 (19) = Load <unsafe.Pointer> v22 v27 (~arg2.data[*uint8])
v30 (19) = IMake <interface {}> v24 v28
v32 (19) = VarDef <mem> {.autotmp_20} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v34 (a.ptr[*interface {}])
v37 (19) = OffPtr <*interface {}> [0] v35
v41 (19) = OffPtr <*interface {}> [16] v35
v49 (19) = SliceMake <[]interface {}> v35 v7 v7
v39 (19) = OffPtr <**uint8> [8] v37
v36 (19) = Store <mem> {uintptr} v37 v24 v34
v29 (19) = OffPtr <**uint8> [8] v41
v47 (213) = OffPtr <**uint8> [8] v53
v12 (213) = OffPtr <*int> [8] v59
v45 (213) = OffPtr <*int> [16] v62
v13 (213) = OffPtr <*int> [8] v62
v31 (?) = StringMake <string> v69 v68
v38 (19) = Store <mem> {*uint8} v39 v23 v36
v48 (19) = Store <mem> {uintptr} v41 v24 v38
v42 (19) = Store <mem> {*uint8} v29 v28 v48
v52 (19) = InlMark <void> [0] v42
v56 (+213) = Load <*os.File> v55 v42
v57 (213) = IMake <io.Writer> v54 v56
v51 (213) = Store <mem> {uintptr} v53 v54 v42
v58 (213) = Store <mem> {*uint8} v47 v56 v51
v66 (213) = Store <mem> {*uint8} v59 v69 v58
v61 (213) = Store <mem> {int} v12 v68 v66
v60 (213) = Store <mem> {*uint8} v62 v35 v61
v15 (213) = Store <mem> {int} v13 v7 v60
v63 (213) = Store <mem> {int} v45 v7 v15
v64 (213) = StaticCall <mem> {fmt.Fprintf} [80] v63
Ret v64 (+19)
name w[int]: v11 v16 
name x[int]: v7 
name y[int]: v11 
name z[int]: v17 
name format.ptr[*uint8]: v69 
name format.len[int]: v68 
name ~arg1.type[uintptr]: v24 
name ~arg1.data[*uint8]: v23 
name ~arg2.type[uintptr]: v24 
name ~arg2.data[*uint8]: v28 
name a.ptr[*interface {}]: v35 
name a.len[int]: v7 
name a.cap[int]: v7

softfloat + late opt

softfloat [20100 ns]

late opt [54100 ns]

b1:
BlockInvalid (+10)
b2:
BlockInvalid (19)
b3:
BlockInvalid (+12)
b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = Const64 <int> [2] (a.cap[int], x[int], a.len[int])
v18 (?) = OffPtr <*int> [8] v2
v22 (?) = OffPtr <*unsafe.Pointer> [16] v2
v24 (?) = Addr <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v53 (?) = OffPtr <*io.Writer> [8] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [24] v2
v62 (?) = OffPtr <*[]interface {}> [40] v2
v69 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v68 (?) = Const64 <int> [7] (format.len[int])
v11 (+11) = Const64 <int> [4] (y[int], w[int])
v43 (?) = Const64 <int64> [0]
v16 (+16) = Const64 <int> [-2] (w[int])
v17 (+17) = Const64 <int> [6] (z[int])
v20 (19) = Store <mem> {int} v18 v16 v1
v21 (+19) = StaticCall <mem> {runtime.convT64} [16] v20
v23 (19) = Load <unsafe.Pointer> v22 v21 (~arg1.data[*uint8])
v25 (19) = IMake <interface {}> v24 v23
v26 (19) = Store <mem> {int} v18 v17 v21
v27 (19) = StaticCall <mem> {runtime.convT64} [16] v26
v28 (19) = Load <unsafe.Pointer> v22 v27 (~arg2.data[*uint8])
v30 (19) = IMake <interface {}> v24 v28
v32 (19) = VarDef <mem> {.autotmp_20} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v34 (a.ptr[*interface {}])
v37 (19) = OffPtr <*interface {}> [0] v35
v41 (19) = OffPtr <*interface {}> [16] v35
v49 (19) = SliceMake <[]interface {}> v35 v7 v7
v39 (19) = OffPtr <**uint8> [8] v35
v36 (19) = Store <mem> {uintptr} v37 v24 v34
v29 (19) = OffPtr <**uint8> [24] v35
v47 (213) = OffPtr <**uint8> [16] v2
v12 (213) = OffPtr <*int> [32] v2
v45 (213) = OffPtr <*int> [56] v2
v13 (213) = OffPtr <*int> [48] v2
v31 (?) = StringMake <string> v69 v68
v38 (19) = Store <mem> {*uint8} v39 v23 v36
v48 (19) = Store <mem> {uintptr} v41 v24 v38
v42 (19) = Store <mem> {*uint8} v29 v28 v48
v52 (19) = InlMark <void> [0] v42
v56 (+213) = Load <*os.File> v55 v42
v57 (213) = IMake <io.Writer> v54 v56
v51 (213) = Store <mem> {uintptr} v53 v54 v42
v58 (213) = Store <mem> {*uint8} v47 v56 v51
v66 (213) = Store <mem> {*uint8} v59 v69 v58
v61 (213) = Store <mem> {int} v12 v68 v66
v60 (213) = Store <mem> {*uint8} v62 v35 v61
v15 (213) = Store <mem> {int} v13 v7 v60
v63 (213) = Store <mem> {int} v45 v7 v15
v64 (213) = StaticCall <mem> {fmt.Fprintf} [80] v63
Ret v64 (+19)
name w[int]: v11 v16 
name x[int]: v7 
name y[int]: v11 
name z[int]: v17 
name format.ptr[*uint8]: v69 
name format.len[int]: v68 
name ~arg1.type[uintptr]: v24 
name ~arg1.data[*uint8]: v23 
name ~arg2.type[uintptr]: v24 
name ~arg2.data[*uint8]: v28 
name a.ptr[*interface {}]: v35 
name a.len[int]: v7 
name a.cap[int]: v7

dead auto elim + generic deadcode

dead auto elim [32500 ns]

generic deadcode [35300 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = Const64 <int> [2] (a.cap[int], x[int], a.len[int])
v18 (?) = OffPtr <*int> [8] v2
v22 (?) = OffPtr <*unsafe.Pointer> [16] v2
v24 (?) = Addr <*uint8> {type.int} v3 (~arg2.type[uintptr], ~arg1.type[uintptr])
v53 (?) = OffPtr <*io.Writer> [8] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [24] v2
v62 (?) = OffPtr <*[]interface {}> [40] v2
v69 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v68 (?) = Const64 <int> [7] (format.len[int])
v16 (+16) = Const64 <int> [-2] (w[int])
v17 (+17) = Const64 <int> [6] (z[int])
v20 (19) = Store <mem> {int} v18 v16 v1
v21 (+19) = StaticCall <mem> {runtime.convT64} [16] v20
v23 (19) = Load <unsafe.Pointer> v22 v21 (~arg1.data[*uint8])
v26 (19) = Store <mem> {int} v18 v17 v21
v27 (19) = StaticCall <mem> {runtime.convT64} [16] v26
v28 (19) = Load <unsafe.Pointer> v22 v27 (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_20} v2 v34 (a.ptr[*interface {}])
v37 (19) = OffPtr <*interface {}> [0] v35
v41 (19) = OffPtr <*interface {}> [16] v35
v39 (19) = OffPtr <**uint8> [8] v35
v36 (19) = Store <mem> {uintptr} v37 v24 v34
v29 (19) = OffPtr <**uint8> [24] v35
v47 (213) = OffPtr <**uint8> [16] v2
v12 (213) = OffPtr <*int> [32] v2
v45 (213) = OffPtr <*int> [56] v2
v13 (213) = OffPtr <*int> [48] v2
v38 (19) = Store <mem> {*uint8} v39 v23 v36
v48 (19) = Store <mem> {uintptr} v41 v24 v38
v42 (19) = Store <mem> {*uint8} v29 v28 v48
v52 (19) = InlMark <void> [0] v42
v56 (+213) = Load <*os.File> v55 v42
v51 (213) = Store <mem> {uintptr} v53 v54 v42
v58 (213) = Store <mem> {*uint8} v47 v56 v51
v66 (213) = Store <mem> {*uint8} v59 v69 v58
v61 (213) = Store <mem> {int} v12 v68 v66
v60 (213) = Store <mem> {*uint8} v62 v35 v61
v15 (213) = Store <mem> {int} v13 v7 v60
v63 (213) = Store <mem> {int} v45 v7 v15
v64 (213) = StaticCall <mem> {fmt.Fprintf} [80] v63
Ret v64 (+19)
name w[int]: v16 
name x[int]: v7 
name z[int]: v17 
name format.ptr[*uint8]: v69 
name format.len[int]: v68 
name ~arg1.type[uintptr]: v24 
name ~arg1.data[*uint8]: v23 
name ~arg2.type[uintptr]: v24 
name ~arg2.data[*uint8]: v28 
name a.ptr[*interface {}]: v35 
name a.len[int]: v7 
name a.cap[int]: v7

check bce + branchelim + late fuse + dse + writebarrier + lower

check bce [22300 ns]

branchelim [21700 ns]

late fuse [18900 ns]

dse [26700 ns]

writebarrier [22000 ns]

lower [43500 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = MOVDconst <int> [2] (a.cap[int], x[int], a.len[int])
v18 (?) = MOVDaddr <*int> [8] v2
v22 (?) = MOVDaddr <*unsafe.Pointer> [16] v2
v24 (?) = MOVDaddr <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v53 (?) = MOVDaddr <*io.Writer> [8] v2
v54 (?) = MOVDaddr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = MOVDaddr <**os.File> {os.Stdout} v3
v59 (?) = MOVDaddr <*string> [24] v2
v62 (?) = MOVDaddr <*[]interface {}> [40] v2
v69 (?) = MOVDaddr <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v68 (?) = MOVDconst <int> [7] (format.len[int])
v16 (+16) = MOVDconst <int> [-2] (w[int])
v17 (+17) = MOVDconst <int> [6] (z[int])
v20 (19) = MOVDstoreconst <mem> [val=-2,off=8] v2 v1
v21 (+19) = CALLstatic <mem> {runtime.convT64} [16] v20
v23 (19) = MOVDload <unsafe.Pointer> [16] v2 v21 (~arg1.data[*uint8])
v26 (19) = MOVDstoreconst <mem> [val=6,off=8] v2 v21
v27 (19) = CALLstatic <mem> {runtime.convT64} [16] v26
v28 (19) = MOVDload <unsafe.Pointer> [16] v2 v27 (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v33 (19) = MOVDaddr <*[2]interface {}> {.autotmp_20} v2
v34 (19) = CLEAR <mem> [val=32,off=0] v33 v32
v35 (19) = MOVDaddr <*[2]interface {}> {.autotmp_20} v2 (a.ptr[*interface {}])
v37 (19) = MOVDaddr <*interface {}> {.autotmp_20} v2
v41 (19) = MOVDaddr <*interface {}> {.autotmp_20} [16] v2
v39 (19) = MOVDaddr <**uint8> {.autotmp_20} [8] v2
v36 (19) = MOVDstore <mem> {.autotmp_20} v2 v24 v34
v29 (19) = MOVDaddr <**uint8> {.autotmp_20} [24] v2
v47 (213) = MOVDaddr <**uint8> [16] v2
v12 (213) = MOVDaddr <*int> [32] v2
v45 (213) = MOVDaddr <*int> [56] v2
v13 (213) = MOVDaddr <*int> [48] v2
v42 (19) = STMG3 <mem> {.autotmp_20} [8] v2 v23 v24 v28 v36
v52 (19) = InlMark <void> [0] v42
v56 (+213) = MOVDload <*os.File> {os.Stdout} v3 v42
v66 (213) = STMG3 <mem> [8] v2 v54 v56 v69 v42
v61 (213) = MOVDstoreconst <mem> [val=7,off=32] v2 v66
v60 (213) = MOVDstore <mem> [40] v2 v35 v61
v15 (213) = MOVDstoreconst <mem> [val=2,off=48] v2 v60
v63 (213) = MOVDstoreconst <mem> [val=2,off=56] v2 v15
v64 (213) = CALLstatic <mem> {fmt.Fprintf} [80] v63
Ret v64 (+19)
name w[int]: v16 
name x[int]: v7 
name z[int]: v17 
name format.ptr[*uint8]: v69 
name format.len[int]: v68 
name ~arg1.type[uintptr]: v24 
name ~arg1.data[*uint8]: v23 
name ~arg2.type[uintptr]: v24 
name ~arg2.data[*uint8]: v28 
name a.ptr[*interface {}]: v35 
name a.len[int]: v7 
name a.cap[int]: v7

addressing modes + lowered deadcode for cse

addressing modes [24500 ns]

lowered deadcode for cse [50100 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v24 (?) = MOVDaddr <*uint8> {type.int} v3 (~arg2.type[uintptr], ~arg1.type[uintptr])
v54 (?) = MOVDaddr <*uint8> {go.itab.*os.File,io.Writer} v3
v69 (?) = MOVDaddr <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v20 (19) = MOVDstoreconst <mem> [val=-2,off=8] v2 v1
v21 (+19) = CALLstatic <mem> {runtime.convT64} [16] v20
v23 (19) = MOVDload <unsafe.Pointer> [16] v2 v21 (~arg1.data[*uint8])
v26 (19) = MOVDstoreconst <mem> [val=6,off=8] v2 v21
v27 (19) = CALLstatic <mem> {runtime.convT64} [16] v26
v28 (19) = MOVDload <unsafe.Pointer> [16] v2 v27 (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v33 (19) = MOVDaddr <*[2]interface {}> {.autotmp_20} v2
v34 (19) = CLEAR <mem> [val=32,off=0] v33 v32
v35 (19) = MOVDaddr <*[2]interface {}> {.autotmp_20} v2 (a.ptr[*interface {}])
v36 (19) = MOVDstore <mem> {.autotmp_20} v2 v24 v34
v42 (19) = STMG3 <mem> {.autotmp_20} [8] v2 v23 v24 v28 v36
v52 (19) = InlMark <void> [0] v42
v56 (+213) = MOVDload <*os.File> {os.Stdout} v3 v42
v66 (213) = STMG3 <mem> [8] v2 v54 v56 v69 v42
v61 (213) = MOVDstoreconst <mem> [val=7,off=32] v2 v66
v60 (213) = MOVDstore <mem> [40] v2 v35 v61
v15 (213) = MOVDstoreconst <mem> [val=2,off=48] v2 v60
v63 (213) = MOVDstoreconst <mem> [val=2,off=56] v2 v15
v64 (213) = CALLstatic <mem> {fmt.Fprintf} [80] v63
Ret v64 (+19)
name format.ptr[*uint8]: v69 
name ~arg1.type[uintptr]: v24 
name ~arg1.data[*uint8]: v23 
name ~arg2.type[uintptr]: v24 
name ~arg2.data[*uint8]: v28 
name a.ptr[*interface {}]: v35

lowered cse

lowered cse [38800 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v24 (?) = MOVDaddr <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v54 (?) = MOVDaddr <*uint8> {go.itab.*os.File,io.Writer} v3
v69 (?) = MOVDaddr <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v20 (19) = MOVDstoreconst <mem> [val=-2,off=8] v2 v1
v21 (+19) = CALLstatic <mem> {runtime.convT64} [16] v20
v23 (19) = MOVDload <unsafe.Pointer> [16] v2 v21 (~arg1.data[*uint8])
v26 (19) = MOVDstoreconst <mem> [val=6,off=8] v2 v21
v27 (19) = CALLstatic <mem> {runtime.convT64} [16] v26
v28 (19) = MOVDload <unsafe.Pointer> [16] v2 v27 (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v33 (19) = MOVDaddr <*[2]interface {}> {.autotmp_20} v2
v34 (19) = CLEAR <mem> [val=32,off=0] v33 v32
v35 (19) = MOVDaddr <*[2]interface {}> {.autotmp_20} v2 (a.ptr[*interface {}])
v36 (19) = MOVDstore <mem> {.autotmp_20} v2 v24 v34
v42 (19) = STMG3 <mem> {.autotmp_20} [8] v2 v23 v24 v28 v36
v52 (19) = InlMark <void> [0] v42
v56 (+213) = MOVDload <*os.File> {os.Stdout} v3 v42
v66 (213) = STMG3 <mem> [8] v2 v54 v56 v69 v42
v61 (213) = MOVDstoreconst <mem> [val=7,off=32] v2 v66
v60 (213) = MOVDstore <mem> [40] v2 v33 v61
v15 (213) = MOVDstoreconst <mem> [val=2,off=48] v2 v60
v63 (213) = MOVDstoreconst <mem> [val=2,off=56] v2 v15
v64 (213) = CALLstatic <mem> {fmt.Fprintf} [80] v63
Ret v64 (+19)
name format.ptr[*uint8]: v69 
name ~arg1.type[uintptr]: v24 
name ~arg1.data[*uint8]: v23 
name ~arg2.type[uintptr]: v24 
name ~arg2.data[*uint8]: v28 
name a.ptr[*interface {}]: v35

elim unread autos + tighten tuple selectors + lowered deadcode

elim unread autos [21900 ns]

tighten tuple selectors [19000 ns]

lowered deadcode [44300 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v24 (?) = MOVDaddr <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v54 (?) = MOVDaddr <*uint8> {go.itab.*os.File,io.Writer} v3
v69 (?) = MOVDaddr <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v20 (19) = MOVDstoreconst <mem> [val=-2,off=8] v2 v1
v21 (+19) = CALLstatic <mem> {runtime.convT64} [16] v20
v23 (19) = MOVDload <unsafe.Pointer> [16] v2 v21 (~arg1.data[*uint8])
v26 (19) = MOVDstoreconst <mem> [val=6,off=8] v2 v21
v27 (19) = CALLstatic <mem> {runtime.convT64} [16] v26
v28 (19) = MOVDload <unsafe.Pointer> [16] v2 v27 (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v33 (19) = MOVDaddr <*[2]interface {}> {.autotmp_20} v2
v34 (19) = CLEAR <mem> [val=32,off=0] v33 v32
v36 (19) = MOVDstore <mem> {.autotmp_20} v2 v24 v34
v42 (19) = STMG3 <mem> {.autotmp_20} [8] v2 v23 v24 v28 v36
v52 (19) = InlMark <void> [0] v42
v56 (+213) = MOVDload <*os.File> {os.Stdout} v3 v42
v66 (213) = STMG3 <mem> [8] v2 v54 v56 v69 v42
v61 (213) = MOVDstoreconst <mem> [val=7,off=32] v2 v66
v60 (213) = MOVDstore <mem> [40] v2 v33 v61
v15 (213) = MOVDstoreconst <mem> [val=2,off=48] v2 v60
v63 (213) = MOVDstoreconst <mem> [val=2,off=56] v2 v15
v64 (213) = CALLstatic <mem> {fmt.Fprintf} [80] v63
Ret v64 (+19)
name format.ptr[*uint8]: v69 
name ~arg1.type[uintptr]: v24 
name ~arg1.data[*uint8]: v23 
name ~arg2.type[uintptr]: v24 
name ~arg2.data[*uint8]: v28

checkLower + late phielim + late copyelim + tighten + late deadcode + critical + phi tighten + likelyadjust + layout + schedule

checkLower [23300 ns]

late phielim [23400 ns]

late copyelim [24000 ns]

tighten [33800 ns]

late deadcode [32900 ns]

critical [18900 ns]

phi tighten [18300 ns]

likelyadjust [18900 ns]

layout [20700 ns]

schedule [30100 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v20 (19) = MOVDstoreconst <mem> [val=-2,off=8] v2 v1
v21 (+19) = CALLstatic <mem> {runtime.convT64} [16] v20
v23 (19) = MOVDload <unsafe.Pointer> [16] v2 v21 (~arg1.data[*uint8])
v26 (19) = MOVDstoreconst <mem> [val=6,off=8] v2 v21
v27 (19) = CALLstatic <mem> {runtime.convT64} [16] v26
v28 (19) = MOVDload <unsafe.Pointer> [16] v2 v27 (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v33 (19) = MOVDaddr <*[2]interface {}> {.autotmp_20} v2
v34 (19) = CLEAR <mem> [val=32,off=0] v33 v32
v3 (?) = SB <uintptr>
v24 (?) = MOVDaddr <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v36 (19) = MOVDstore <mem> {.autotmp_20} v2 v24 v34
v42 (19) = STMG3 <mem> {.autotmp_20} [8] v2 v23 v24 v28 v36
v54 (?) = MOVDaddr <*uint8> {go.itab.*os.File,io.Writer} v3
v69 (?) = MOVDaddr <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v52 (19) = InlMark <void> [0] v42
v56 (+213) = MOVDload <*os.File> {os.Stdout} v3 v42
v66 (213) = STMG3 <mem> [8] v2 v54 v56 v69 v42
v61 (213) = MOVDstoreconst <mem> [val=7,off=32] v2 v66
v60 (213) = MOVDstore <mem> [40] v2 v33 v61
v15 (213) = MOVDstoreconst <mem> [val=2,off=48] v2 v60
v63 (213) = MOVDstoreconst <mem> [val=2,off=56] v2 v15
v64 (213) = CALLstatic <mem> {fmt.Fprintf} [80] v63
Ret v64 (+19)
name format.ptr[*uint8]: v69 
name ~arg1.type[uintptr]: v24 
name ~arg1.data[*uint8]: v23 
name ~arg2.type[uintptr]: v24 
name ~arg2.data[*uint8]: v28

late nilcheck + flagalloc + regalloc

late nilcheck [23300 ns]

flagalloc [23600 ns]

regalloc [106600 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr> : SP
v20 (19) = MOVDstoreconst <mem> [val=-2,off=8] v2 v1
v21 (+19) = CALLstatic <mem> {runtime.convT64} [16] v20
v23 (19) = MOVDload <unsafe.Pointer> [16] v2 v21 : R0 (~arg1.data[*uint8])
v45 (19) = StoreReg <unsafe.Pointer> v23 : .autotmp_30[unsafe.Pointer]
v26 (19) = MOVDstoreconst <mem> [val=6,off=8] v2 v21
v27 (19) = CALLstatic <mem> {runtime.convT64} [16] v26
v28 (19) = MOVDload <unsafe.Pointer> [16] v2 v27 : R3 (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v35 (19) = MOVDaddr <*[2]interface {}> {.autotmp_20} v2 : R1
v34 (19) = CLEAR <mem> [val=32,off=0] v35 v32
v3 (?) = SB <uintptr> : SB
v13 (19) = MOVDaddr <*uint8> {type.int} v3 : R2
v36 (19) = MOVDstore <mem> {.autotmp_20} v2 v13 v34
v12 (19) = LoadReg <unsafe.Pointer> v45 : R1
v42 (19) = STMG3 <mem> {.autotmp_20} [8] v2 v12 v13 v28 v36
v52 (19) = InlMark <void> [0] v42
v56 (+213) = MOVDload <*os.File> {os.Stdout} v3 v42 : R2
v47 (213) = MOVDaddr <*uint8> {go.itab.*os.File,io.Writer} v3 : R1
v29 (213) = MOVDaddr <*uint8> {go.string."%d, %d\n"} v3 : R3
v66 (213) = STMG3 <mem> [8] v2 v47 v56 v29 v42
v61 (213) = MOVDstoreconst <mem> [val=7,off=32] v2 v66
v39 (213) = MOVDaddr <*[2]interface {}> {.autotmp_20} v2 : R0
v60 (213) = MOVDstore <mem> [40] v2 v39 v61
v15 (213) = MOVDstoreconst <mem> [val=2,off=48] v2 v60
v63 (213) = MOVDstoreconst <mem> [val=2,off=56] v2 v15
v64 (213) = CALLstatic <mem> {fmt.Fprintf} [80] v63
Ret v64 (+19)
name format.ptr[*uint8]: v69 
name ~arg1.type[uintptr]: v24 
name ~arg1.data[*uint8]: v23 
name ~arg2.type[uintptr]: v24 
name ~arg2.data[*uint8]: v28

loop rotate + stackframe + trim

loop rotate [25200 ns]

stackframe [42000 ns]

trim [24700 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr> : SP
v20 (19) = MOVDstoreconst <mem> [val=-2,off=8] v2 v1
v21 (+19) = CALLstatic <mem> {runtime.convT64} [16] v20
v23 (19) = MOVDload <unsafe.Pointer> [16] v2 v21 : R0 (~arg1.data[*uint8])
v45 (19) = StoreReg <unsafe.Pointer> v23 : .autotmp_30[unsafe.Pointer]
v26 (19) = MOVDstoreconst <mem> [val=6,off=8] v2 v21
v27 (19) = CALLstatic <mem> {runtime.convT64} [16] v26
v28 (19) = MOVDload <unsafe.Pointer> [16] v2 v27 : R3 (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v35 (19) = MOVDaddr <*[2]interface {}> {.autotmp_20} v2 : R1
v34 (19) = CLEAR <mem> [val=32,off=0] v35 v32
v3 (?) = SB <uintptr> : SB
v13 (19) = MOVDaddr <*uint8> {type.int} v3 : R2
v36 (19) = MOVDstore <mem> {.autotmp_20} v2 v13 v34
v12 (19) = LoadReg <unsafe.Pointer> v45 : R1
v42 (19) = STMG3 <mem> {.autotmp_20} [8] v2 v12 v13 v28 v36
v52 (19) = InlMark <void> [0] v42
v56 (+213) = MOVDload <*os.File> {os.Stdout} v3 v42 : R2
v47 (213) = MOVDaddr <*uint8> {go.itab.*os.File,io.Writer} v3 : R1
v29 (213) = MOVDaddr <*uint8> {go.string."%d, %d\n"} v3 : R3
v66 (213) = STMG3 <mem> [8] v2 v47 v56 v29 v42
v61 (213) = MOVDstoreconst <mem> [val=7,off=32] v2 v66
v39 (213) = MOVDaddr <*[2]interface {}> {.autotmp_20} v2 : R0
v60 (213) = MOVDstore <mem> [40] v2 v39 v61
v15 (213) = MOVDstoreconst <mem> [val=2,off=48] v2 v60
v63 (213) = MOVDstoreconst <mem> [val=2,off=56] v2 v15
v64 (213) = CALLstatic <mem> {fmt.Fprintf} [80] v63
Ret v64 (+19)
name format.ptr[*uint8]: v69 
name ~arg1.type[uintptr]: v24 
name ~arg1.data[*uint8]: v23 
name ~arg2.type[uintptr]: v24 
name ~arg2.data[*uint8]: v28

genssa

genssa


# /root/main.go
00000 (5) TEXT	"".ssa(SB), ABIInternal
00001 (5) FUNCDATA	$0, gclocals·7434ac78ed715a61a5258eadde9d1323(SB)
00002 (5) FUNCDATA	$1, gclocals·098b7d6a888b077fd6537e1a0ddbfb7f(SB)
00003 (5) FUNCDATA	$3, "".ssa.stkobj(SB)
v20
00004 (+19) MOVD	$-2, 8(R15)
v21
00005 (19) PCDATA	$1, $0
v21
00006 (19) CALL	runtime.convT64(SB)
v23
00007 (19) MOVD	16(R15), R0
v45
00008 (19) MOVD	R0, ""..autotmp_30-40(R15)
v26
00009 (19) MOVD	$6, 8(R15)
v27
00010 (19) PCDATA	$1, $1
v27
00011 (19) CALL	runtime.convT64(SB)
v28
00012 (19) MOVD	16(R15), R3
v35
00013 (19) MOVD	$""..autotmp_20-32(R15), R1
v34
00014 (19) CLEAR	$32, (R1)
v13
00015 (19) MOVD	$type.int(SB), R2
v36
00016 (19) MOVD	R2, ""..autotmp_20-32(R15)
v12
00017 (19) MOVD	""..autotmp_30-40(R15), R1
v42
00018 (19) STMG	R1, R3, ""..autotmp_20-24(R15)
v52
00019 (?) NOP
# $GOROOT/src/fmt/print.go
v56
00020 (+213) MOVD	os.Stdout(SB), R2
v47
00021 (213) MOVD	$go.itab.*os.File,io.Writer(SB), R1
v29
00022 (213) MOVD	$go.string."%d, %d\n"(SB), R3
v66
00023 (213) STMG	R1, R3, 8(R15)
v61
00024 (213) MOVD	$7, 32(R15)
v39
00025 (213) MOVD	$""..autotmp_20-32(R15), R0
v60
00026 (213) MOVD	R0, 40(R15)
v15
00027 (213) MOVD	$2, 48(R15)
v63
00028 (213) MOVD	$2, 56(R15)
v64
00029 (213) PCDATA	$1, $0
v64
00030 (213) CALL	fmt.Fprintf(SB)
# /root/main.go
b7
00031 (+19) RET
00032 (?) END