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.

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(56) 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(64) 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] (x[int], y[int], z[int], fmt.n[int], fmt..autotmp_4[int], w[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> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] 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> [0] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [16] v2
v62 (?) = OffPtr <*[]interface {}> [32] v2
v65 (?) = OffPtr <*int> [56] v2
v67 (?) = OffPtr <*error> [64] 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..autotmp_5[error], fmt.err[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

number lines [9899 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = Const64 <int> [0] (fmt..autotmp_4[int], x[int], y[int], z[int], fmt.n[int], w[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> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] 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> [0] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [16] v2
v62 (?) = OffPtr <*[]interface {}> [32] v2
v65 (?) = OffPtr <*int> [56] v2
v67 (?) = OffPtr <*error> [64] 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 (y[int], w[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.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 v46
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 phielim

early phielim [4650 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = Const64 <int> [0] (w[int], y[int], z[int], fmt.n[int], fmt..autotmp_4[int], x[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> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] 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> [0] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [16] v2
v62 (?) = OffPtr <*[]interface {}> [32] v2
v65 (?) = OffPtr <*int> [56] v2
v67 (?) = OffPtr <*error> [64] 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 (w[int], y[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 [4368 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = Const64 <int> [0] (fmt..autotmp_4[int], x[int], y[int], z[int], fmt.n[int], w[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> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] 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> [0] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [16] v2
v62 (?) = OffPtr <*[]interface {}> [32] v2
v65 (?) = OffPtr <*int> [56] v2
v67 (?) = OffPtr <*error> [64] 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.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 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 [23117 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = Const64 <int> [0] (fmt.n[int], fmt..autotmp_4[int], x[int], y[int], z[int], w[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> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] 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> [0] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [16] v2
v62 (?) = OffPtr <*[]interface {}> [32] 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 (w[int], y[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 [3170 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = Const64 <int> [0] (w[int], fmt.n[int], fmt..autotmp_4[int], x[int], y[int], z[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> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] 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> [0] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [16] v2
v62 (?) = OffPtr <*[]interface {}> [32] 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 args [6989 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = Const64 <int> [0] (w[int], fmt.n[int], fmt..autotmp_4[int], x[int], y[int], z[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> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] 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> [0] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [16] v2
v62 (?) = OffPtr <*[]interface {}> [32] 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 (w[int], y[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 user

decompose user [1569 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = Const64 <int> [0] (fmt.n[int], fmt..autotmp_4[int], x[int], y[int], z[int], w[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> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] 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> [0] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [16] v2
v62 (?) = OffPtr <*[]interface {}> [32] 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 (w[int], y[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

pre-opt deadcode

pre-opt deadcode [20997 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = Const64 <int> [0] (w[int], fmt..autotmp_4[int], x[int], y[int], z[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> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] 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> [0] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [16] v2
v62 (?) = OffPtr <*[]interface {}> [32] 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 [46954 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = Const64 <int> [0] (w[int], y[int], z[int], fmt.n[int], fmt..autotmp_4[int], x[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> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] v2
v24 (?) = Addr <*uint8> {type.int} v3
v29 (?) = Addr <*uint8> {type.int} v3
v40 (?) = Const64 <int> [1]
v53 (?) = OffPtr <*io.Writer> [0] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [16] v2
v62 (?) = OffPtr <*[]interface {}> [32] 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 [16857 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = Const64 <int> [0] (z[int], fmt.n[int], fmt..autotmp_4[int], x[int], y[int], w[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> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] v2
v24 (?) = Addr <*uint8> {type.int} v3
v29 (?) = Addr <*uint8> {type.int} v3
v40 (?) = Const64 <int> [1]
v53 (?) = OffPtr <*io.Writer> [0] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [16] v2
v62 (?) = OffPtr <*[]interface {}> [32] 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] (y[int], w[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 [24327 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = Const64 <int> [2] (x[int])
v18 (?) = OffPtr <*int> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] v2
v24 (?) = Addr <*uint8> {type.int} v3
v29 (?) = Addr <*uint8> {type.int} v3
v53 (?) = OffPtr <*io.Writer> [0] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [16] v2
v62 (?) = OffPtr <*[]interface {}> [32] v2
v69 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3
v68 (?) = Const64 <int> [7]
v11 (+11) = Const64 <int> [4] (w[int], y[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 [37774 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = Const64 <int> [2] (x[int])
v18 (?) = OffPtr <*int> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] v2
v24 (?) = Addr <*uint8> {type.int} v3
v29 (?) = Addr <*uint8> {type.int} v3
v53 (?) = OffPtr <*io.Writer> [0] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [16] v2
v62 (?) = OffPtr <*[]interface {}> [32] 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

phiopt [899 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = Const64 <int> [2] (x[int])
v18 (?) = OffPtr <*int> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] v2
v24 (?) = Addr <*uint8> {type.int} v3
v29 (?) = Addr <*uint8> {type.int} v3
v53 (?) = OffPtr <*io.Writer> [0] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [16] v2
v62 (?) = OffPtr <*[]interface {}> [32] 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

gcse deadcode

gcse deadcode [15087 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = Const64 <int> [2] (x[int])
v18 (?) = OffPtr <*int> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] v2
v24 (?) = Addr <*uint8> {type.int} v3
v53 (?) = OffPtr <*io.Writer> [0] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [16] v2
v62 (?) = OffPtr <*[]interface {}> [32] v2
v69 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3
v68 (?) = Const64 <int> [7]
v11 (+11) = Const64 <int> [4] (w[int], y[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 [36765 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = Const64 <int> [2] (x[int])
v18 (?) = OffPtr <*int> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] v2
v24 (?) = Addr <*uint8> {type.int} v3
v53 (?) = OffPtr <*io.Writer> [0] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [16] v2
v62 (?) = OffPtr <*[]interface {}> [32] 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 [19226 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = Const64 <int> [2] (x[int])
v18 (?) = OffPtr <*int> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] v2
v24 (?) = Addr <*uint8> {type.int} v3
v53 (?) = OffPtr <*io.Writer> [0] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [16] v2
v62 (?) = OffPtr <*[]interface {}> [32] v2
v69 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3
v68 (?) = Const64 <int> [7]
v11 (+11) = Const64 <int> [4] (w[int], y[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

fuse plain

fuse plain [3788 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> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] v2
v24 (?) = Addr <*uint8> {type.int} v3
v53 (?) = OffPtr <*io.Writer> [0] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [16] v2
v62 (?) = OffPtr <*[]interface {}> [32] 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 [39504 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.len[int], x[int], a.cap[int])
v18 (?) = OffPtr <*int> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] v2
v24 (?) = Addr <*uint8> {type.int} v3 (~arg2.type[uintptr], ~arg1.type[uintptr])
v53 (?) = OffPtr <*io.Writer> [0] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [16] v2
v62 (?) = OffPtr <*[]interface {}> [32] 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] (w[int], y[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

softfloat [630 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.len[int], x[int], a.cap[int])
v18 (?) = OffPtr <*int> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] v2
v24 (?) = Addr <*uint8> {type.int} v3 (~arg2.type[uintptr], ~arg1.type[uintptr])
v53 (?) = OffPtr <*io.Writer> [0] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [16] v2
v62 (?) = OffPtr <*[]interface {}> [32] 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] (w[int], y[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

late opt

late opt [31205 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], a.len[int], x[int])
v18 (?) = OffPtr <*int> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] v2
v24 (?) = Addr <*uint8> {type.int} v3 (~arg2.type[uintptr], ~arg1.type[uintptr])
v53 (?) = OffPtr <*io.Writer> [0] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [16] v2
v62 (?) = OffPtr <*[]interface {}> [32] 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] (w[int], y[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> [8] v2
v12 (213) = OffPtr <*int> [24] v2
v45 (213) = OffPtr <*int> [48] v2
v13 (213) = OffPtr <*int> [40] 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

dead auto elim [49892 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], a.len[int], a.cap[int])
v18 (?) = OffPtr <*int> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] v2
v24 (?) = Addr <*uint8> {type.int} v3 (~arg2.type[uintptr], ~arg1.type[uintptr])
v53 (?) = OffPtr <*io.Writer> [0] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [16] v2
v62 (?) = OffPtr <*[]interface {}> [32] 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] (w[int], y[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> [8] v2
v12 (213) = OffPtr <*int> [24] v2
v45 (213) = OffPtr <*int> [48] v2
v13 (213) = OffPtr <*int> [40] 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

generic deadcode

generic deadcode [51933 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = Const64 <int> [2] (a.len[int], x[int], a.cap[int])
v18 (?) = OffPtr <*int> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] v2
v24 (?) = Addr <*uint8> {type.int} v3 (~arg2.type[uintptr], ~arg1.type[uintptr])
v53 (?) = OffPtr <*io.Writer> [0] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [16] v2
v62 (?) = OffPtr <*[]interface {}> [32] 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> [8] v2
v12 (213) = OffPtr <*int> [24] v2
v45 (213) = OffPtr <*int> [48] v2
v13 (213) = OffPtr <*int> [40] 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

check bce [400 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = Const64 <int> [2] (a.cap[int], a.len[int], x[int])
v18 (?) = OffPtr <*int> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] v2
v24 (?) = Addr <*uint8> {type.int} v3 (~arg2.type[uintptr], ~arg1.type[uintptr])
v53 (?) = OffPtr <*io.Writer> [0] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [16] v2
v62 (?) = OffPtr <*[]interface {}> [32] 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> [8] v2
v12 (213) = OffPtr <*int> [24] v2
v45 (213) = OffPtr <*int> [48] v2
v13 (213) = OffPtr <*int> [40] 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

branchelim

branchelim [4089 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = Const64 <int> [2] (a.len[int], x[int], a.cap[int])
v18 (?) = OffPtr <*int> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] v2
v24 (?) = Addr <*uint8> {type.int} v3 (~arg2.type[uintptr], ~arg1.type[uintptr])
v53 (?) = OffPtr <*io.Writer> [0] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [16] v2
v62 (?) = OffPtr <*[]interface {}> [32] 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> [8] v2
v12 (213) = OffPtr <*int> [24] v2
v45 (213) = OffPtr <*int> [48] v2
v13 (213) = OffPtr <*int> [40] 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

fuse

fuse [830 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = Const64 <int> [2] (a.len[int], x[int], a.cap[int])
v18 (?) = OffPtr <*int> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] v2
v24 (?) = Addr <*uint8> {type.int} v3 (~arg2.type[uintptr], ~arg1.type[uintptr])
v53 (?) = OffPtr <*io.Writer> [0] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [16] v2
v62 (?) = OffPtr <*[]interface {}> [32] 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> [8] v2
v12 (213) = OffPtr <*int> [24] v2
v45 (213) = OffPtr <*int> [48] v2
v13 (213) = OffPtr <*int> [40] 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

dse

dse [29026 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = Const64 <int> [2] (x[int], a.len[int], a.cap[int])
v18 (?) = OffPtr <*int> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] v2
v24 (?) = Addr <*uint8> {type.int} v3 (~arg2.type[uintptr], ~arg1.type[uintptr])
v53 (?) = OffPtr <*io.Writer> [0] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [16] v2
v62 (?) = OffPtr <*[]interface {}> [32] 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> [8] v2
v12 (213) = OffPtr <*int> [24] v2
v45 (213) = OffPtr <*int> [48] v2
v13 (213) = OffPtr <*int> [40] 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

writebarrier

writebarrier [3960 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = Const64 <int> [2] (x[int], a.len[int], a.cap[int])
v18 (?) = OffPtr <*int> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] v2
v24 (?) = Addr <*uint8> {type.int} v3 (~arg2.type[uintptr], ~arg1.type[uintptr])
v53 (?) = OffPtr <*io.Writer> [0] v2
v54 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = Addr <**os.File> {os.Stdout} v3
v59 (?) = OffPtr <*string> [16] v2
v62 (?) = OffPtr <*[]interface {}> [32] 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> [8] v2
v12 (213) = OffPtr <*int> [24] v2
v45 (213) = OffPtr <*int> [48] v2
v13 (213) = OffPtr <*int> [40] 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

lower

lower [34865 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = MOVQconst <int> [2] (x[int], a.len[int], a.cap[int])
v22 (?) = LEAQ <*unsafe.Pointer> [8] v2
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg2.type[uintptr], ~arg1.type[uintptr])
v54 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v55 (?) = LEAQ <**os.File> {os.Stdout} v3
v59 (?) = LEAQ <*string> [16] v2
v62 (?) = LEAQ <*[]interface {}> [32] v2
v69 (?) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v68 (?) = MOVQconst <int> [7] (format.len[int])
v16 (+16) = MOVQconst <int> [-2] (w[int])
v17 (+17) = MOVQconst <int> [6] (z[int])
v20 (19) = MOVQstoreconst <mem> [val=-2,off=0] v2 v1
v21 (+19) = CALLstatic <mem> {runtime.convT64} [16] v20
v23 (19) = MOVQload <unsafe.Pointer> [8] v2 v21 (~arg1.data[*uint8])
v26 (19) = MOVQstoreconst <mem> [val=6,off=0] v2 v21
v27 (19) = CALLstatic <mem> {runtime.convT64} [16] v26
v28 (19) = MOVQload <unsafe.Pointer> [8] v2 v27 (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v33 (19) = LEAQ <*[2]interface {}> {.autotmp_20} v2
v35 (19) = LEAQ <*[2]interface {}> {.autotmp_20} v2 (a.ptr[*interface {}])
v37 (19) = LEAQ <*interface {}> {.autotmp_20} v2
v41 (19) = LEAQ <*interface {}> {.autotmp_20} [16] v2
v39 (19) = LEAQ <**uint8> {.autotmp_20} [8] v2
v29 (19) = LEAQ <**uint8> {.autotmp_20} [24] v2
v47 (213) = LEAQ <**uint8> [8] v2
v12 (213) = LEAQ <*int> [24] v2
v45 (213) = LEAQ <*int> [48] v2
v13 (213) = LEAQ <*int> [40] v2
v57 (19) = LEAQ <*[2]interface {}> {.autotmp_20} [16] v2
v49 (19) = MOVOconst <int128> [0]
v25 (19) = MOVOconst <int128> [0]
v30 (19) = MOVOstore <mem> {.autotmp_20} v2 v25 v32
v34 (19) = MOVOstore <mem> {.autotmp_20} [16] v2 v49 v30
v36 (19) = MOVQstore <mem> {.autotmp_20} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_20} [8] v2 v23 v36
v48 (19) = MOVQstore <mem> {.autotmp_20} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_20} [24] v2 v28 v48
v52 (19) = InlMark <void> [0] v42
v56 (+213) = MOVQload <*os.File> {os.Stdout} v3 v42
v51 (213) = MOVQstore <mem> v2 v54 v42
v58 (213) = MOVQstore <mem> [8] v2 v56 v51
v66 (213) = MOVQstore <mem> [16] v2 v69 v58
v61 (213) = MOVQstoreconst <mem> [val=7,off=24] v2 v66
v60 (213) = MOVQstore <mem> [32] v2 v35 v61
v15 (213) = MOVQstoreconst <mem> [val=2,off=40] v2 v60
v63 (213) = MOVQstoreconst <mem> [val=2,off=48] 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

lowered deadcode for cse

lowered deadcode for cse [17998 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg2.type[uintptr], ~arg1.type[uintptr])
v54 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v69 (?) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v20 (19) = MOVQstoreconst <mem> [val=-2,off=0] v2 v1
v21 (+19) = CALLstatic <mem> {runtime.convT64} [16] v20
v23 (19) = MOVQload <unsafe.Pointer> [8] v2 v21 (~arg1.data[*uint8])
v26 (19) = MOVQstoreconst <mem> [val=6,off=0] v2 v21
v27 (19) = CALLstatic <mem> {runtime.convT64} [16] v26
v28 (19) = MOVQload <unsafe.Pointer> [8] v2 v27 (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v35 (19) = LEAQ <*[2]interface {}> {.autotmp_20} v2 (a.ptr[*interface {}])
v49 (19) = MOVOconst <int128> [0]
v25 (19) = MOVOconst <int128> [0]
v30 (19) = MOVOstore <mem> {.autotmp_20} v2 v25 v32
v34 (19) = MOVOstore <mem> {.autotmp_20} [16] v2 v49 v30
v36 (19) = MOVQstore <mem> {.autotmp_20} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_20} [8] v2 v23 v36
v48 (19) = MOVQstore <mem> {.autotmp_20} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_20} [24] v2 v28 v48
v52 (19) = InlMark <void> [0] v42
v56 (+213) = MOVQload <*os.File> {os.Stdout} v3 v42
v51 (213) = MOVQstore <mem> v2 v54 v42
v58 (213) = MOVQstore <mem> [8] v2 v56 v51
v66 (213) = MOVQstore <mem> [16] v2 v69 v58
v61 (213) = MOVQstoreconst <mem> [val=7,off=24] v2 v66
v60 (213) = MOVQstore <mem> [32] v2 v35 v61
v15 (213) = MOVQstoreconst <mem> [val=2,off=40] v2 v60
v63 (213) = MOVQstoreconst <mem> [val=2,off=48] 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 [16278 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg2.type[uintptr], ~arg1.type[uintptr])
v54 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v69 (?) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v20 (19) = MOVQstoreconst <mem> [val=-2,off=0] v2 v1
v21 (+19) = CALLstatic <mem> {runtime.convT64} [16] v20
v23 (19) = MOVQload <unsafe.Pointer> [8] v2 v21 (~arg1.data[*uint8])
v26 (19) = MOVQstoreconst <mem> [val=6,off=0] v2 v21
v27 (19) = CALLstatic <mem> {runtime.convT64} [16] v26
v28 (19) = MOVQload <unsafe.Pointer> [8] v2 v27 (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v35 (19) = LEAQ <*[2]interface {}> {.autotmp_20} v2 (a.ptr[*interface {}])
v49 (19) = MOVOconst <int128> [0]
v25 (19) = MOVOconst <int128> [0]
v30 (19) = MOVOstore <mem> {.autotmp_20} v2 v25 v32
v34 (19) = MOVOstore <mem> {.autotmp_20} [16] v2 v25 v30
v36 (19) = MOVQstore <mem> {.autotmp_20} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_20} [8] v2 v23 v36
v48 (19) = MOVQstore <mem> {.autotmp_20} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_20} [24] v2 v28 v48
v52 (19) = InlMark <void> [0] v42
v56 (+213) = MOVQload <*os.File> {os.Stdout} v3 v42
v51 (213) = MOVQstore <mem> v2 v54 v42
v58 (213) = MOVQstore <mem> [8] v2 v56 v51
v66 (213) = MOVQstore <mem> [16] v2 v69 v58
v61 (213) = MOVQstoreconst <mem> [val=7,off=24] v2 v66
v60 (213) = MOVQstore <mem> [32] v2 v35 v61
v15 (213) = MOVQstoreconst <mem> [val=2,off=40] v2 v60
v63 (213) = MOVQstoreconst <mem> [val=2,off=48] 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

elim unread autos [4690 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg2.type[uintptr], ~arg1.type[uintptr])
v54 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v69 (?) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v20 (19) = MOVQstoreconst <mem> [val=-2,off=0] v2 v1
v21 (+19) = CALLstatic <mem> {runtime.convT64} [16] v20
v23 (19) = MOVQload <unsafe.Pointer> [8] v2 v21 (~arg1.data[*uint8])
v26 (19) = MOVQstoreconst <mem> [val=6,off=0] v2 v21
v27 (19) = CALLstatic <mem> {runtime.convT64} [16] v26
v28 (19) = MOVQload <unsafe.Pointer> [8] v2 v27 (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v35 (19) = LEAQ <*[2]interface {}> {.autotmp_20} v2 (a.ptr[*interface {}])
v49 (19) = MOVOconst <int128> [0]
v25 (19) = MOVOconst <int128> [0]
v30 (19) = MOVOstore <mem> {.autotmp_20} v2 v25 v32
v34 (19) = MOVOstore <mem> {.autotmp_20} [16] v2 v25 v30
v36 (19) = MOVQstore <mem> {.autotmp_20} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_20} [8] v2 v23 v36
v48 (19) = MOVQstore <mem> {.autotmp_20} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_20} [24] v2 v28 v48
v52 (19) = InlMark <void> [0] v42
v56 (+213) = MOVQload <*os.File> {os.Stdout} v3 v42
v51 (213) = MOVQstore <mem> v2 v54 v42
v58 (213) = MOVQstore <mem> [8] v2 v56 v51
v66 (213) = MOVQstore <mem> [16] v2 v69 v58
v61 (213) = MOVQstoreconst <mem> [val=7,off=24] v2 v66
v60 (213) = MOVQstore <mem> [32] v2 v35 v61
v15 (213) = MOVQstoreconst <mem> [val=2,off=40] v2 v60
v63 (213) = MOVQstoreconst <mem> [val=2,off=48] 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 deadcode

lowered deadcode [14328 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg2.type[uintptr], ~arg1.type[uintptr])
v54 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v69 (?) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v20 (19) = MOVQstoreconst <mem> [val=-2,off=0] v2 v1
v21 (+19) = CALLstatic <mem> {runtime.convT64} [16] v20
v23 (19) = MOVQload <unsafe.Pointer> [8] v2 v21 (~arg1.data[*uint8])
v26 (19) = MOVQstoreconst <mem> [val=6,off=0] v2 v21
v27 (19) = CALLstatic <mem> {runtime.convT64} [16] v26
v28 (19) = MOVQload <unsafe.Pointer> [8] v2 v27 (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v35 (19) = LEAQ <*[2]interface {}> {.autotmp_20} v2 (a.ptr[*interface {}])
v25 (19) = MOVOconst <int128> [0]
v30 (19) = MOVOstore <mem> {.autotmp_20} v2 v25 v32
v34 (19) = MOVOstore <mem> {.autotmp_20} [16] v2 v25 v30
v36 (19) = MOVQstore <mem> {.autotmp_20} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_20} [8] v2 v23 v36
v48 (19) = MOVQstore <mem> {.autotmp_20} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_20} [24] v2 v28 v48
v52 (19) = InlMark <void> [0] v42
v56 (+213) = MOVQload <*os.File> {os.Stdout} v3 v42
v51 (213) = MOVQstore <mem> v2 v54 v42
v58 (213) = MOVQstore <mem> [8] v2 v56 v51
v66 (213) = MOVQstore <mem> [16] v2 v69 v58
v61 (213) = MOVQstoreconst <mem> [val=7,off=24] v2 v66
v60 (213) = MOVQstore <mem> [32] v2 v35 v61
v15 (213) = MOVQstoreconst <mem> [val=2,off=40] v2 v60
v63 (213) = MOVQstoreconst <mem> [val=2,off=48] 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

checkLower

checkLower [1260 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg2.type[uintptr], ~arg1.type[uintptr])
v54 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v69 (?) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v20 (19) = MOVQstoreconst <mem> [val=-2,off=0] v2 v1
v21 (+19) = CALLstatic <mem> {runtime.convT64} [16] v20
v23 (19) = MOVQload <unsafe.Pointer> [8] v2 v21 (~arg1.data[*uint8])
v26 (19) = MOVQstoreconst <mem> [val=6,off=0] v2 v21
v27 (19) = CALLstatic <mem> {runtime.convT64} [16] v26
v28 (19) = MOVQload <unsafe.Pointer> [8] v2 v27 (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v35 (19) = LEAQ <*[2]interface {}> {.autotmp_20} v2 (a.ptr[*interface {}])
v25 (19) = MOVOconst <int128> [0]
v30 (19) = MOVOstore <mem> {.autotmp_20} v2 v25 v32
v34 (19) = MOVOstore <mem> {.autotmp_20} [16] v2 v25 v30
v36 (19) = MOVQstore <mem> {.autotmp_20} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_20} [8] v2 v23 v36
v48 (19) = MOVQstore <mem> {.autotmp_20} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_20} [24] v2 v28 v48
v52 (19) = InlMark <void> [0] v42
v56 (+213) = MOVQload <*os.File> {os.Stdout} v3 v42
v51 (213) = MOVQstore <mem> v2 v54 v42
v58 (213) = MOVQstore <mem> [8] v2 v56 v51
v66 (213) = MOVQstore <mem> [16] v2 v69 v58
v61 (213) = MOVQstoreconst <mem> [val=7,off=24] v2 v66
v60 (213) = MOVQstore <mem> [32] v2 v35 v61
v15 (213) = MOVQstoreconst <mem> [val=2,off=40] v2 v60
v63 (213) = MOVQstoreconst <mem> [val=2,off=48] 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

late phielim

late phielim [1570 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v54 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v69 (?) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v20 (19) = MOVQstoreconst <mem> [val=-2,off=0] v2 v1
v21 (+19) = CALLstatic <mem> {runtime.convT64} [16] v20
v23 (19) = MOVQload <unsafe.Pointer> [8] v2 v21 (~arg1.data[*uint8])
v26 (19) = MOVQstoreconst <mem> [val=6,off=0] v2 v21
v27 (19) = CALLstatic <mem> {runtime.convT64} [16] v26
v28 (19) = MOVQload <unsafe.Pointer> [8] v2 v27 (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v35 (19) = LEAQ <*[2]interface {}> {.autotmp_20} v2 (a.ptr[*interface {}])
v25 (19) = MOVOconst <int128> [0]
v30 (19) = MOVOstore <mem> {.autotmp_20} v2 v25 v32
v34 (19) = MOVOstore <mem> {.autotmp_20} [16] v2 v25 v30
v36 (19) = MOVQstore <mem> {.autotmp_20} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_20} [8] v2 v23 v36
v48 (19) = MOVQstore <mem> {.autotmp_20} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_20} [24] v2 v28 v48
v52 (19) = InlMark <void> [0] v42
v56 (+213) = MOVQload <*os.File> {os.Stdout} v3 v42
v51 (213) = MOVQstore <mem> v2 v54 v42
v58 (213) = MOVQstore <mem> [8] v2 v56 v51
v66 (213) = MOVQstore <mem> [16] v2 v69 v58
v61 (213) = MOVQstoreconst <mem> [val=7,off=24] v2 v66
v60 (213) = MOVQstore <mem> [32] v2 v35 v61
v15 (213) = MOVQstoreconst <mem> [val=2,off=40] v2 v60
v63 (213) = MOVQstoreconst <mem> [val=2,off=48] 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

late copyelim

late copyelim [2649 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg2.type[uintptr], ~arg1.type[uintptr])
v54 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v69 (?) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v20 (19) = MOVQstoreconst <mem> [val=-2,off=0] v2 v1
v21 (+19) = CALLstatic <mem> {runtime.convT64} [16] v20
v23 (19) = MOVQload <unsafe.Pointer> [8] v2 v21 (~arg1.data[*uint8])
v26 (19) = MOVQstoreconst <mem> [val=6,off=0] v2 v21
v27 (19) = CALLstatic <mem> {runtime.convT64} [16] v26
v28 (19) = MOVQload <unsafe.Pointer> [8] v2 v27 (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v35 (19) = LEAQ <*[2]interface {}> {.autotmp_20} v2 (a.ptr[*interface {}])
v25 (19) = MOVOconst <int128> [0]
v30 (19) = MOVOstore <mem> {.autotmp_20} v2 v25 v32
v34 (19) = MOVOstore <mem> {.autotmp_20} [16] v2 v25 v30
v36 (19) = MOVQstore <mem> {.autotmp_20} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_20} [8] v2 v23 v36
v48 (19) = MOVQstore <mem> {.autotmp_20} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_20} [24] v2 v28 v48
v52 (19) = InlMark <void> [0] v42
v56 (+213) = MOVQload <*os.File> {os.Stdout} v3 v42
v51 (213) = MOVQstore <mem> v2 v54 v42
v58 (213) = MOVQstore <mem> [8] v2 v56 v51
v66 (213) = MOVQstore <mem> [16] v2 v69 v58
v61 (213) = MOVQstoreconst <mem> [val=7,off=24] v2 v66
v60 (213) = MOVQstore <mem> [32] v2 v35 v61
v15 (213) = MOVQstoreconst <mem> [val=2,off=40] v2 v60
v63 (213) = MOVQstoreconst <mem> [val=2,off=48] 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

tighten

tighten [12098 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg2.type[uintptr], ~arg1.type[uintptr])
v54 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v69 (?) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v20 (19) = MOVQstoreconst <mem> [val=-2,off=0] v2 v1
v21 (+19) = CALLstatic <mem> {runtime.convT64} [16] v20
v23 (19) = MOVQload <unsafe.Pointer> [8] v2 v21 (~arg1.data[*uint8])
v26 (19) = MOVQstoreconst <mem> [val=6,off=0] v2 v21
v27 (19) = CALLstatic <mem> {runtime.convT64} [16] v26
v28 (19) = MOVQload <unsafe.Pointer> [8] v2 v27 (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v35 (19) = LEAQ <*[2]interface {}> {.autotmp_20} v2 (a.ptr[*interface {}])
v25 (19) = MOVOconst <int128> [0]
v30 (19) = MOVOstore <mem> {.autotmp_20} v2 v25 v32
v34 (19) = MOVOstore <mem> {.autotmp_20} [16] v2 v25 v30
v36 (19) = MOVQstore <mem> {.autotmp_20} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_20} [8] v2 v23 v36
v48 (19) = MOVQstore <mem> {.autotmp_20} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_20} [24] v2 v28 v48
v52 (19) = InlMark <void> [0] v42
v56 (+213) = MOVQload <*os.File> {os.Stdout} v3 v42
v51 (213) = MOVQstore <mem> v2 v54 v42
v58 (213) = MOVQstore <mem> [8] v2 v56 v51
v66 (213) = MOVQstore <mem> [16] v2 v69 v58
v61 (213) = MOVQstoreconst <mem> [val=7,off=24] v2 v66
v60 (213) = MOVQstore <mem> [32] v2 v35 v61
v15 (213) = MOVQstoreconst <mem> [val=2,off=40] v2 v60
v63 (213) = MOVQstoreconst <mem> [val=2,off=48] 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

late deadcode

late deadcode [12239 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg2.type[uintptr], ~arg1.type[uintptr])
v54 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v69 (?) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v20 (19) = MOVQstoreconst <mem> [val=-2,off=0] v2 v1
v21 (+19) = CALLstatic <mem> {runtime.convT64} [16] v20
v23 (19) = MOVQload <unsafe.Pointer> [8] v2 v21 (~arg1.data[*uint8])
v26 (19) = MOVQstoreconst <mem> [val=6,off=0] v2 v21
v27 (19) = CALLstatic <mem> {runtime.convT64} [16] v26
v28 (19) = MOVQload <unsafe.Pointer> [8] v2 v27 (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v35 (19) = LEAQ <*[2]interface {}> {.autotmp_20} v2 (a.ptr[*interface {}])
v25 (19) = MOVOconst <int128> [0]
v30 (19) = MOVOstore <mem> {.autotmp_20} v2 v25 v32
v34 (19) = MOVOstore <mem> {.autotmp_20} [16] v2 v25 v30
v36 (19) = MOVQstore <mem> {.autotmp_20} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_20} [8] v2 v23 v36
v48 (19) = MOVQstore <mem> {.autotmp_20} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_20} [24] v2 v28 v48
v52 (19) = InlMark <void> [0] v42
v56 (+213) = MOVQload <*os.File> {os.Stdout} v3 v42
v51 (213) = MOVQstore <mem> v2 v54 v42
v58 (213) = MOVQstore <mem> [8] v2 v56 v51
v66 (213) = MOVQstore <mem> [16] v2 v69 v58
v61 (213) = MOVQstoreconst <mem> [val=7,off=24] v2 v66
v60 (213) = MOVQstore <mem> [32] v2 v35 v61
v15 (213) = MOVQstoreconst <mem> [val=2,off=40] v2 v60
v63 (213) = MOVQstoreconst <mem> [val=2,off=48] 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

critical

critical [2219 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v54 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v69 (?) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v20 (19) = MOVQstoreconst <mem> [val=-2,off=0] v2 v1
v21 (+19) = CALLstatic <mem> {runtime.convT64} [16] v20
v23 (19) = MOVQload <unsafe.Pointer> [8] v2 v21 (~arg1.data[*uint8])
v26 (19) = MOVQstoreconst <mem> [val=6,off=0] v2 v21
v27 (19) = CALLstatic <mem> {runtime.convT64} [16] v26
v28 (19) = MOVQload <unsafe.Pointer> [8] v2 v27 (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v35 (19) = LEAQ <*[2]interface {}> {.autotmp_20} v2 (a.ptr[*interface {}])
v25 (19) = MOVOconst <int128> [0]
v30 (19) = MOVOstore <mem> {.autotmp_20} v2 v25 v32
v34 (19) = MOVOstore <mem> {.autotmp_20} [16] v2 v25 v30
v36 (19) = MOVQstore <mem> {.autotmp_20} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_20} [8] v2 v23 v36
v48 (19) = MOVQstore <mem> {.autotmp_20} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_20} [24] v2 v28 v48
v52 (19) = InlMark <void> [0] v42
v56 (+213) = MOVQload <*os.File> {os.Stdout} v3 v42
v51 (213) = MOVQstore <mem> v2 v54 v42
v58 (213) = MOVQstore <mem> [8] v2 v56 v51
v66 (213) = MOVQstore <mem> [16] v2 v69 v58
v61 (213) = MOVQstoreconst <mem> [val=7,off=24] v2 v66
v60 (213) = MOVQstore <mem> [32] v2 v35 v61
v15 (213) = MOVQstoreconst <mem> [val=2,off=40] v2 v60
v63 (213) = MOVQstoreconst <mem> [val=2,off=48] 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

phi tighten

phi tighten [690 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v54 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v69 (?) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v20 (19) = MOVQstoreconst <mem> [val=-2,off=0] v2 v1
v21 (+19) = CALLstatic <mem> {runtime.convT64} [16] v20
v23 (19) = MOVQload <unsafe.Pointer> [8] v2 v21 (~arg1.data[*uint8])
v26 (19) = MOVQstoreconst <mem> [val=6,off=0] v2 v21
v27 (19) = CALLstatic <mem> {runtime.convT64} [16] v26
v28 (19) = MOVQload <unsafe.Pointer> [8] v2 v27 (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v35 (19) = LEAQ <*[2]interface {}> {.autotmp_20} v2 (a.ptr[*interface {}])
v25 (19) = MOVOconst <int128> [0]
v30 (19) = MOVOstore <mem> {.autotmp_20} v2 v25 v32
v34 (19) = MOVOstore <mem> {.autotmp_20} [16] v2 v25 v30
v36 (19) = MOVQstore <mem> {.autotmp_20} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_20} [8] v2 v23 v36
v48 (19) = MOVQstore <mem> {.autotmp_20} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_20} [24] v2 v28 v48
v52 (19) = InlMark <void> [0] v42
v56 (+213) = MOVQload <*os.File> {os.Stdout} v3 v42
v51 (213) = MOVQstore <mem> v2 v54 v42
v58 (213) = MOVQstore <mem> [8] v2 v56 v51
v66 (213) = MOVQstore <mem> [16] v2 v69 v58
v61 (213) = MOVQstoreconst <mem> [val=7,off=24] v2 v66
v60 (213) = MOVQstore <mem> [32] v2 v35 v61
v15 (213) = MOVQstoreconst <mem> [val=2,off=40] v2 v60
v63 (213) = MOVQstoreconst <mem> [val=2,off=48] 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

likelyadjust

likelyadjust [791 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v54 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v69 (?) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v20 (19) = MOVQstoreconst <mem> [val=-2,off=0] v2 v1
v21 (+19) = CALLstatic <mem> {runtime.convT64} [16] v20
v23 (19) = MOVQload <unsafe.Pointer> [8] v2 v21 (~arg1.data[*uint8])
v26 (19) = MOVQstoreconst <mem> [val=6,off=0] v2 v21
v27 (19) = CALLstatic <mem> {runtime.convT64} [16] v26
v28 (19) = MOVQload <unsafe.Pointer> [8] v2 v27 (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v35 (19) = LEAQ <*[2]interface {}> {.autotmp_20} v2 (a.ptr[*interface {}])
v25 (19) = MOVOconst <int128> [0]
v30 (19) = MOVOstore <mem> {.autotmp_20} v2 v25 v32
v34 (19) = MOVOstore <mem> {.autotmp_20} [16] v2 v25 v30
v36 (19) = MOVQstore <mem> {.autotmp_20} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_20} [8] v2 v23 v36
v48 (19) = MOVQstore <mem> {.autotmp_20} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_20} [24] v2 v28 v48
v52 (19) = InlMark <void> [0] v42
v56 (+213) = MOVQload <*os.File> {os.Stdout} v3 v42
v51 (213) = MOVQstore <mem> v2 v54 v42
v58 (213) = MOVQstore <mem> [8] v2 v56 v51
v66 (213) = MOVQstore <mem> [16] v2 v69 v58
v61 (213) = MOVQstoreconst <mem> [val=7,off=24] v2 v66
v60 (213) = MOVQstore <mem> [32] v2 v35 v61
v15 (213) = MOVQstoreconst <mem> [val=2,off=40] v2 v60
v63 (213) = MOVQstoreconst <mem> [val=2,off=48] 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

layout

layout [3519 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v54 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v69 (?) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v20 (19) = MOVQstoreconst <mem> [val=-2,off=0] v2 v1
v21 (+19) = CALLstatic <mem> {runtime.convT64} [16] v20
v23 (19) = MOVQload <unsafe.Pointer> [8] v2 v21 (~arg1.data[*uint8])
v26 (19) = MOVQstoreconst <mem> [val=6,off=0] v2 v21
v27 (19) = CALLstatic <mem> {runtime.convT64} [16] v26
v28 (19) = MOVQload <unsafe.Pointer> [8] v2 v27 (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v35 (19) = LEAQ <*[2]interface {}> {.autotmp_20} v2 (a.ptr[*interface {}])
v25 (19) = MOVOconst <int128> [0]
v30 (19) = MOVOstore <mem> {.autotmp_20} v2 v25 v32
v34 (19) = MOVOstore <mem> {.autotmp_20} [16] v2 v25 v30
v36 (19) = MOVQstore <mem> {.autotmp_20} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_20} [8] v2 v23 v36
v48 (19) = MOVQstore <mem> {.autotmp_20} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_20} [24] v2 v28 v48
v52 (19) = InlMark <void> [0] v42
v56 (+213) = MOVQload <*os.File> {os.Stdout} v3 v42
v51 (213) = MOVQstore <mem> v2 v54 v42
v58 (213) = MOVQstore <mem> [8] v2 v56 v51
v66 (213) = MOVQstore <mem> [16] v2 v69 v58
v61 (213) = MOVQstoreconst <mem> [val=7,off=24] v2 v66
v60 (213) = MOVQstore <mem> [32] v2 v35 v61
v15 (213) = MOVQstoreconst <mem> [val=2,off=40] v2 v60
v63 (213) = MOVQstoreconst <mem> [val=2,off=48] 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

schedule

schedule [14918 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v20 (19) = MOVQstoreconst <mem> [val=-2,off=0] v2 v1
v21 (+19) = CALLstatic <mem> {runtime.convT64} [16] v20
v23 (19) = MOVQload <unsafe.Pointer> [8] v2 v21 (~arg1.data[*uint8])
v26 (19) = MOVQstoreconst <mem> [val=6,off=0] v2 v21
v27 (19) = CALLstatic <mem> {runtime.convT64} [16] v26
v28 (19) = MOVQload <unsafe.Pointer> [8] v2 v27 (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v25 (19) = MOVOconst <int128> [0]
v30 (19) = MOVOstore <mem> {.autotmp_20} v2 v25 v32
v34 (19) = MOVOstore <mem> {.autotmp_20} [16] v2 v25 v30
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v36 (19) = MOVQstore <mem> {.autotmp_20} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_20} [8] v2 v23 v36
v48 (19) = MOVQstore <mem> {.autotmp_20} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_20} [24] v2 v28 v48
v54 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (19) = InlMark <void> [0] v42
v56 (+213) = MOVQload <*os.File> {os.Stdout} v3 v42
v51 (213) = MOVQstore <mem> v2 v54 v42
v58 (213) = MOVQstore <mem> [8] v2 v56 v51
v69 (?) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v66 (213) = MOVQstore <mem> [16] v2 v69 v58
v61 (213) = MOVQstoreconst <mem> [val=7,off=24] v2 v66
v35 (19) = LEAQ <*[2]interface {}> {.autotmp_20} v2 (a.ptr[*interface {}])
v60 (213) = MOVQstore <mem> [32] v2 v35 v61
v15 (213) = MOVQstoreconst <mem> [val=2,off=40] v2 v60
v63 (213) = MOVQstoreconst <mem> [val=2,off=48] 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

late nilcheck

late nilcheck [4559 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v20 (19) = MOVQstoreconst <mem> [val=-2,off=0] v2 v1
v21 (+19) = CALLstatic <mem> {runtime.convT64} [16] v20
v23 (19) = MOVQload <unsafe.Pointer> [8] v2 v21 (~arg1.data[*uint8])
v26 (19) = MOVQstoreconst <mem> [val=6,off=0] v2 v21
v27 (19) = CALLstatic <mem> {runtime.convT64} [16] v26
v28 (19) = MOVQload <unsafe.Pointer> [8] v2 v27 (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v25 (19) = MOVOconst <int128> [0]
v30 (19) = MOVOstore <mem> {.autotmp_20} v2 v25 v32
v34 (19) = MOVOstore <mem> {.autotmp_20} [16] v2 v25 v30
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg2.type[uintptr], ~arg1.type[uintptr])
v36 (19) = MOVQstore <mem> {.autotmp_20} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_20} [8] v2 v23 v36
v48 (19) = MOVQstore <mem> {.autotmp_20} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_20} [24] v2 v28 v48
v54 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (19) = InlMark <void> [0] v42
v56 (+213) = MOVQload <*os.File> {os.Stdout} v3 v42
v51 (213) = MOVQstore <mem> v2 v54 v42
v58 (213) = MOVQstore <mem> [8] v2 v56 v51
v69 (?) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v66 (213) = MOVQstore <mem> [16] v2 v69 v58
v61 (213) = MOVQstoreconst <mem> [val=7,off=24] v2 v66
v35 (19) = LEAQ <*[2]interface {}> {.autotmp_20} v2 (a.ptr[*interface {}])
v60 (213) = MOVQstore <mem> [32] v2 v35 v61
v15 (213) = MOVQstoreconst <mem> [val=2,off=40] v2 v60
v63 (213) = MOVQstoreconst <mem> [val=2,off=48] 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

flagalloc

flagalloc [5979 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v20 (19) = MOVQstoreconst <mem> [val=-2,off=0] v2 v1
v21 (+19) = CALLstatic <mem> {runtime.convT64} [16] v20
v23 (19) = MOVQload <unsafe.Pointer> [8] v2 v21 (~arg1.data[*uint8])
v26 (19) = MOVQstoreconst <mem> [val=6,off=0] v2 v21
v27 (19) = CALLstatic <mem> {runtime.convT64} [16] v26
v28 (19) = MOVQload <unsafe.Pointer> [8] v2 v27 (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v25 (19) = MOVOconst <int128> [0]
v30 (19) = MOVOstore <mem> {.autotmp_20} v2 v25 v32
v34 (19) = MOVOstore <mem> {.autotmp_20} [16] v2 v25 v30
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg2.type[uintptr], ~arg1.type[uintptr])
v36 (19) = MOVQstore <mem> {.autotmp_20} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_20} [8] v2 v23 v36
v48 (19) = MOVQstore <mem> {.autotmp_20} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_20} [24] v2 v28 v48
v54 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (19) = InlMark <void> [0] v42
v56 (+213) = MOVQload <*os.File> {os.Stdout} v3 v42
v51 (213) = MOVQstore <mem> v2 v54 v42
v58 (213) = MOVQstore <mem> [8] v2 v56 v51
v69 (?) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v66 (213) = MOVQstore <mem> [16] v2 v69 v58
v61 (213) = MOVQstoreconst <mem> [val=7,off=24] v2 v66
v35 (19) = LEAQ <*[2]interface {}> {.autotmp_20} v2 (a.ptr[*interface {}])
v60 (213) = MOVQstore <mem> [32] v2 v35 v61
v15 (213) = MOVQstoreconst <mem> [val=2,off=40] v2 v60
v63 (213) = MOVQstoreconst <mem> [val=2,off=48] 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

regalloc

regalloc [63172 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr> : SP
v20 (19) = MOVQstoreconst <mem> [val=-2,off=0] v2 v1
v21 (+19) = CALLstatic <mem> {runtime.convT64} [16] v20
v23 (19) = MOVQload <unsafe.Pointer> [8] v2 v21 : AX (~arg1.data[*uint8])
v13 (19) = StoreReg <unsafe.Pointer> v23 : .autotmp_30[unsafe.Pointer]
v26 (19) = MOVQstoreconst <mem> [val=6,off=0] v2 v21
v27 (19) = CALLstatic <mem> {runtime.convT64} [16] v26
v28 (19) = MOVQload <unsafe.Pointer> [8] v2 v27 : AX (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v49 (19) = MOVOconst <int128> [0] : X0
v30 (19) = MOVOstore <mem> {.autotmp_20} v2 v49 v32
v34 (19) = MOVOstore <mem> {.autotmp_20} [16] v2 v49 v30
v3 (?) = SB <uintptr> : SB
v57 (19) = LEAQ <*uint8> {type.int} v3 : CX
v36 (19) = MOVQstore <mem> {.autotmp_20} v2 v57 v34
v45 (19) = LoadReg <unsafe.Pointer> v13 : DX
v38 (19) = MOVQstore <mem> {.autotmp_20} [8] v2 v45 v36
v48 (19) = MOVQstore <mem> {.autotmp_20} [16] v2 v57 v38
v42 (19) = MOVQstore <mem> {.autotmp_20} [24] v2 v28 v48
v52 (19) = InlMark <void> [0] v42
v56 (+213) = MOVQload <*os.File> {os.Stdout} v3 v42 : AX
v12 (213) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3 : CX
v51 (213) = MOVQstore <mem> v2 v12 v42
v58 (213) = MOVQstore <mem> [8] v2 v56 v51
v47 (213) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 : AX
v66 (213) = MOVQstore <mem> [16] v2 v47 v58
v61 (213) = MOVQstoreconst <mem> [val=7,off=24] v2 v66
v29 (213) = LEAQ <*[2]interface {}> {.autotmp_20} v2 : AX
v60 (213) = MOVQstore <mem> [32] v2 v29 v61
v15 (213) = MOVQstoreconst <mem> [val=2,off=40] v2 v60
v63 (213) = MOVQstoreconst <mem> [val=2,off=48] 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

loop rotate

loop rotate [880 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr> : SP
v20 (19) = MOVQstoreconst <mem> [val=-2,off=0] v2 v1
v21 (+19) = CALLstatic <mem> {runtime.convT64} [16] v20
v23 (19) = MOVQload <unsafe.Pointer> [8] v2 v21 : AX (~arg1.data[*uint8])
v13 (19) = StoreReg <unsafe.Pointer> v23 : .autotmp_30[unsafe.Pointer]
v26 (19) = MOVQstoreconst <mem> [val=6,off=0] v2 v21
v27 (19) = CALLstatic <mem> {runtime.convT64} [16] v26
v28 (19) = MOVQload <unsafe.Pointer> [8] v2 v27 : AX (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v49 (19) = MOVOconst <int128> [0] : X0
v30 (19) = MOVOstore <mem> {.autotmp_20} v2 v49 v32
v34 (19) = MOVOstore <mem> {.autotmp_20} [16] v2 v49 v30
v3 (?) = SB <uintptr> : SB
v57 (19) = LEAQ <*uint8> {type.int} v3 : CX
v36 (19) = MOVQstore <mem> {.autotmp_20} v2 v57 v34
v45 (19) = LoadReg <unsafe.Pointer> v13 : DX
v38 (19) = MOVQstore <mem> {.autotmp_20} [8] v2 v45 v36
v48 (19) = MOVQstore <mem> {.autotmp_20} [16] v2 v57 v38
v42 (19) = MOVQstore <mem> {.autotmp_20} [24] v2 v28 v48
v52 (19) = InlMark <void> [0] v42
v56 (+213) = MOVQload <*os.File> {os.Stdout} v3 v42 : AX
v12 (213) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3 : CX
v51 (213) = MOVQstore <mem> v2 v12 v42
v58 (213) = MOVQstore <mem> [8] v2 v56 v51
v47 (213) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 : AX
v66 (213) = MOVQstore <mem> [16] v2 v47 v58
v61 (213) = MOVQstoreconst <mem> [val=7,off=24] v2 v66
v29 (213) = LEAQ <*[2]interface {}> {.autotmp_20} v2 : AX
v60 (213) = MOVQstore <mem> [32] v2 v29 v61
v15 (213) = MOVQstoreconst <mem> [val=2,off=40] v2 v60
v63 (213) = MOVQstoreconst <mem> [val=2,off=48] 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

stackframe

stackframe [16449 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr> : SP
v20 (19) = MOVQstoreconst <mem> [val=-2,off=0] v2 v1
v21 (+19) = CALLstatic <mem> {runtime.convT64} [16] v20
v23 (19) = MOVQload <unsafe.Pointer> [8] v2 v21 : AX (~arg1.data[*uint8])
v13 (19) = StoreReg <unsafe.Pointer> v23 : .autotmp_30[unsafe.Pointer]
v26 (19) = MOVQstoreconst <mem> [val=6,off=0] v2 v21
v27 (19) = CALLstatic <mem> {runtime.convT64} [16] v26
v28 (19) = MOVQload <unsafe.Pointer> [8] v2 v27 : AX (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v49 (19) = MOVOconst <int128> [0] : X0
v30 (19) = MOVOstore <mem> {.autotmp_20} v2 v49 v32
v34 (19) = MOVOstore <mem> {.autotmp_20} [16] v2 v49 v30
v3 (?) = SB <uintptr> : SB
v57 (19) = LEAQ <*uint8> {type.int} v3 : CX
v36 (19) = MOVQstore <mem> {.autotmp_20} v2 v57 v34
v45 (19) = LoadReg <unsafe.Pointer> v13 : DX
v38 (19) = MOVQstore <mem> {.autotmp_20} [8] v2 v45 v36
v48 (19) = MOVQstore <mem> {.autotmp_20} [16] v2 v57 v38
v42 (19) = MOVQstore <mem> {.autotmp_20} [24] v2 v28 v48
v52 (19) = InlMark <void> [0] v42
v56 (+213) = MOVQload <*os.File> {os.Stdout} v3 v42 : AX
v12 (213) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3 : CX
v51 (213) = MOVQstore <mem> v2 v12 v42
v58 (213) = MOVQstore <mem> [8] v2 v56 v51
v47 (213) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 : AX
v66 (213) = MOVQstore <mem> [16] v2 v47 v58
v61 (213) = MOVQstoreconst <mem> [val=7,off=24] v2 v66
v29 (213) = LEAQ <*[2]interface {}> {.autotmp_20} v2 : AX
v60 (213) = MOVQstore <mem> [32] v2 v29 v61
v15 (213) = MOVQstoreconst <mem> [val=2,off=40] v2 v60
v63 (213) = MOVQstoreconst <mem> [val=2,off=48] 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

trim

trim [1020 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr> : SP
v20 (19) = MOVQstoreconst <mem> [val=-2,off=0] v2 v1
v21 (+19) = CALLstatic <mem> {runtime.convT64} [16] v20
v23 (19) = MOVQload <unsafe.Pointer> [8] v2 v21 : AX (~arg1.data[*uint8])
v13 (19) = StoreReg <unsafe.Pointer> v23 : .autotmp_30[unsafe.Pointer]
v26 (19) = MOVQstoreconst <mem> [val=6,off=0] v2 v21
v27 (19) = CALLstatic <mem> {runtime.convT64} [16] v26
v28 (19) = MOVQload <unsafe.Pointer> [8] v2 v27 : AX (~arg2.data[*uint8])
v32 (19) = VarDef <mem> {.autotmp_20} v27
v49 (19) = MOVOconst <int128> [0] : X0
v30 (19) = MOVOstore <mem> {.autotmp_20} v2 v49 v32
v34 (19) = MOVOstore <mem> {.autotmp_20} [16] v2 v49 v30
v3 (?) = SB <uintptr> : SB
v57 (19) = LEAQ <*uint8> {type.int} v3 : CX
v36 (19) = MOVQstore <mem> {.autotmp_20} v2 v57 v34
v45 (19) = LoadReg <unsafe.Pointer> v13 : DX
v38 (19) = MOVQstore <mem> {.autotmp_20} [8] v2 v45 v36
v48 (19) = MOVQstore <mem> {.autotmp_20} [16] v2 v57 v38
v42 (19) = MOVQstore <mem> {.autotmp_20} [24] v2 v28 v48
v52 (19) = InlMark <void> [0] v42
v56 (+213) = MOVQload <*os.File> {os.Stdout} v3 v42 : AX
v12 (213) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3 : CX
v51 (213) = MOVQstore <mem> v2 v12 v42
v58 (213) = MOVQstore <mem> [8] v2 v56 v51
v47 (213) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 : AX
v66 (213) = MOVQstore <mem> [16] v2 v47 v58
v61 (213) = MOVQstoreconst <mem> [val=7,off=24] v2 v66
v29 (213) = LEAQ <*[2]interface {}> {.autotmp_20} v2 : AX
v60 (213) = MOVQstore <mem> [32] v2 v29 v61
v15 (213) = MOVQstoreconst <mem> [val=2,off=40] v2 v60
v63 (213) = MOVQstoreconst <mem> [val=2,off=48] 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

genssa

genssa


# /root/main.go
00000 (5) TEXT	"".ssa(SB), ABIInternal
00001 (5) PCDATA	$0, $-2
00002 (5) PCDATA	$1, $-2
00003 (5) FUNCDATA	$0, gclocals·f6bd6b3389b872033d462029172c8612(SB)
00004 (5) FUNCDATA	$1, gclocals·306ea4dc593c4841cf74b8270a1a332d(SB)
00005 (5) FUNCDATA	$2, gclocals·f6aec3988379d2bd21c69c093370a150(SB)
00006 (5) FUNCDATA	$3, "".ssa.stkobj(SB)
v20
00007 (+19) PCDATA	$0, $0
v20
00008 (+19) PCDATA	$1, $0
v20
00009 (+19) MOVQ	$-2, (SP)
v21
00010 (19) CALL	runtime.convT64(SB)
v23
00011 (19) PCDATA	$0, $1
v23
00012 (19) MOVQ	8(SP), AX
v13
00013 (19) PCDATA	$0, $0
v13
00014 (19) PCDATA	$1, $1
v13
00015 (19) MOVQ	AX, ""..autotmp_30-40(SP)
v26
00016 (19) MOVQ	$6, (SP)
v27
00017 (19) CALL	runtime.convT64(SB)
v28
00018 (19) PCDATA	$0, $1
v28
00019 (19) MOVQ	8(SP), AX
v49
00020 (19) PCDATA	$1, $2
v49
00021 (19) XORPS	X0, X0
v30
00022 (19) MOVUPS	X0, ""..autotmp_20-32(SP)
v34
00023 (19) MOVUPS	X0, ""..autotmp_20-16(SP)
v57
00024 (19) PCDATA	$0, $2
v57
00025 (19) LEAQ	type.int(SB), CX
v36
00026 (19) MOVQ	CX, ""..autotmp_20-32(SP)
v45
00027 (19) PCDATA	$0, $3
v45
00028 (19) PCDATA	$1, $3
v45
00029 (19) MOVQ	""..autotmp_30-40(SP), DX
v38
00030 (19) PCDATA	$0, $2
v38
00031 (19) MOVQ	DX, ""..autotmp_20-24(SP)
v48
00032 (19) PCDATA	$0, $1
v48
00033 (19) MOVQ	CX, ""..autotmp_20-16(SP)
v42
00034 (19) PCDATA	$0, $0
v42
00035 (19) MOVQ	AX, ""..autotmp_20-8(SP)
v52
00036 (?) NOP
# $GOROOT/src/fmt/print.go
v56
00037 (+213) PCDATA	$0, $1
v56
00038 (+213) MOVQ	os.Stdout(SB), AX
v12
00039 (213) PCDATA	$0, $2
v12
00040 (213) LEAQ	go.itab.*os.File,io.Writer(SB), CX
v51
00041 (213) PCDATA	$0, $1
v51
00042 (213) MOVQ	CX, (SP)
v58
00043 (213) PCDATA	$0, $0
v58
00044 (213) MOVQ	AX, 8(SP)
v47
00045 (213) PCDATA	$0, $1
v47
00046 (213) LEAQ	go.string."%d, %d\n"(SB), AX
v66
00047 (213) PCDATA	$0, $0
v66
00048 (213) MOVQ	AX, 16(SP)
v61
00049 (213) MOVQ	$7, 24(SP)
v29
00050 (213) PCDATA	$0, $1
v29
00051 (213) PCDATA	$1, $0
v29
00052 (213) LEAQ	""..autotmp_20-32(SP), AX
v60
00053 (213) PCDATA	$0, $0
v60
00054 (213) MOVQ	AX, 32(SP)
v15
00055 (213) MOVQ	$2, 40(SP)
v63
00056 (213) MOVQ	$2, 48(SP)
v64
00057 (213) CALL	fmt.Fprintf(SB)
# /root/main.go
b7
00058 (+19) RET
00059 (?) END