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

207

208

209

 
/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 a(true) g(1) l(6) x(0) class(PAUTO) tc(1) assigned used int

. AS l(6) tc(1)

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

. DCL l(6) tc(1)

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

. AS l(6) tc(1)

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

. DCL l(6) tc(1)

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

. AS l(6) tc(1)

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

. DCL l(6) tc(1)

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

. AS l(6) tc(1)

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

. AS l(8) tc(1)

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

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

. AS l(9) tc(1)

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

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

. . . NAME-main.x a(true) g(2) l(6) x(0) class(PAUTO) 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 a(true) g(2) l(6) x(0) class(PAUTO) tc(1) assigned used int

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

. IF-rlist

. . AS l(14) tc(1)

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

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

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

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

. IF-body

. . AS l(11) tc(1)

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

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

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

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

. . AS l(12) tc(1)

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

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

. AS l(16) tc(1)

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

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

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

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

. AS l(17) tc(1)

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

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

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

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

. DCL l(19)

. . NAME-fmt.format a(true) l(207) x(0) class(PAUTO) tc(1) assigned used string

. DCL l(19)

. . NAME-fmt.a a(true) l(207) x(0) class(PAUTO) tc(1) assigned used SLICE-[]interface {}

. DCL l(19)

. . NAME-fmt.n a(true) l(207) x(0) class(PAUTO) tc(1) assigned used int

. DCL l(19)

. . NAME-fmt.err a(true) l(207) x(0) class(PAUTO) tc(1) assigned used error

. BLOCK-init

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

. . . NAME-main..autotmp_13 a(true) l(19) x(0) class(PAUTO) esc(N) tc(1) assigned used UNSAFEPTR-unsafe.Pointer

. . . CALLFUNC l(19) tc(1) hascall UNSAFEPTR-unsafe.Pointer

. . . . NAME-runtime.convT64 a(true) x(0) class(PFUNC) tc(1) used FUNC-func(int) unsafe.Pointer

. . . CALLFUNC-rlist

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

. . AS l(19) tc(1)

. . . NAME-main..autotmp_12 a(true) l(19) x(0) class(PAUTO) esc(N) tc(1) assigned used INTER-interface {}

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

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

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

. . . . NAME-main..autotmp_13 a(true) l(19) x(0) class(PAUTO) esc(N) tc(1) assigned used UNSAFEPTR-unsafe.Pointer

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

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

. . . CALLFUNC l(19) tc(1) hascall UNSAFEPTR-unsafe.Pointer

. . . . NAME-runtime.convT64 a(true) x(0) class(PFUNC) tc(1) used FUNC-func(int) unsafe.Pointer

. . . CALLFUNC-rlist

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

. . AS l(19) tc(1)

. . . NAME-main..autotmp_14 a(true) l(19) x(0) class(PAUTO) esc(N) tc(1) assigned used INTER-interface {}

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

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

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

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

. BLOCK l(19) hascall

. BLOCK-list

. . AS l(19) tc(1)

. . . NAME-fmt.format a(true) l(207) x(0) class(PAUTO) tc(1) assigned used string

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

. . AS l(19) tc(1)

. . . NAME-main.~arg1 a(true) l(19) x(0) class(PAUTO) tc(1) assigned used INTER-interface {}

. . . NAME-main..autotmp_12 a(true) l(19) x(0) class(PAUTO) esc(N) tc(1) assigned used INTER-interface {}

. . AS l(19) tc(1)

. . . NAME-main.~arg2 a(true) l(19) x(0) class(PAUTO) tc(1) assigned used INTER-interface {}

. . . NAME-main..autotmp_14 a(true) l(19) x(0) class(PAUTO) esc(N) tc(1) assigned used INTER-interface {}

. EMPTY-init

. . AS l(19) tc(1)

. . . NAME-main..autotmp_18 a(true) l(19) x(0) class(PAUTO) esc(N) tc(1) addrtaken assigned used ARRAY-[2]interface {}

. . AS l(19) tc(1)

. . . NAME-main..autotmp_16 a(true) l(19) x(0) class(PAUTO) esc(N) tc(1) assigned used PTR-*[2]interface {}

. . . ADDR l(19) tc(1) PTR-*[2]interface {}

. . . . NAME-main..autotmp_18 a(true) l(19) x(0) class(PAUTO) esc(N) tc(1) addrtaken assigned used ARRAY-[2]interface {}

. . BLOCK l(19)

. . BLOCK-list

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

. . . . INDEX l(19) tc(1) assigned bounded hascall INTER-interface {}

. . . . . DEREF l(19) tc(1) implicit(true) assigned hascall ARRAY-[2]interface {}

. . . . . . NAME-main..autotmp_16 a(true) l(19) x(0) class(PAUTO) esc(N) tc(1) assigned used PTR-*[2]interface {}

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

. . . . NAME-main.~arg1 a(true) l(19) x(0) class(PAUTO) tc(1) assigned used INTER-interface {}

. . BLOCK l(19)

. . BLOCK-list

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

. . . . INDEX l(19) tc(1) assigned bounded hascall INTER-interface {}

. . . . . DEREF l(19) tc(1) implicit(true) assigned hascall ARRAY-[2]interface {}

. . . . . . NAME-main..autotmp_16 a(true) l(19) x(0) class(PAUTO) esc(N) tc(1) assigned used PTR-*[2]interface {}

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

. . . . NAME-main.~arg2 a(true) l(19) x(0) class(PAUTO) tc(1) assigned used INTER-interface {}

. . BLOCK l(19)

. . BLOCK-list

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

. . . . NAME-fmt.a a(true) l(207) x(0) class(PAUTO) tc(1) assigned used SLICE-[]interface {}

. . . . SLICEARR l(19) tc(1) hascall SLICE-[]interface {}

. . . . . NAME-main..autotmp_16 a(true) l(19) x(0) class(PAUTO) esc(N) tc(1) assigned used PTR-*[2]interface {}

. EMPTY l(19) tc(1) hascall

. . NAME-fmt.a a(true) l(207) x(0) class(PAUTO) tc(1) assigned used SLICE-[]interface {}

. AS l(19) tc(1)

. . NAME-fmt.n a(true) l(207) x(0) class(PAUTO) tc(1) assigned used int

. AS l(19) tc(1)

. . NAME-fmt.err a(true) l(207) x(0) class(PAUTO) tc(1) assigned used error

. AS l(19) tc(1)

. . NAME-main..autotmp_11 a(true) l(19) x(0) class(PAUTO) esc(N) tc(1) assigned used error

. BLOCK-init

. . CALLFUNC l(208) tc(1) isddd(true) hascall STRUCT-(int, error)

. . . NAME-fmt.Fprintf a(true) l(197) x(0) class(PFUNC) tc(1) used FUNC-func(io.Writer, string, ...interface {}) (int, error)

. . CALLFUNC-rlist

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

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

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

. . . . NAME-os.Stdout a(true) l(60) x(0) class(PEXTERN) tc(1) used PTR-*os.File

. . . NAME-fmt.format a(true) l(207) x(0) class(PAUTO) tc(1) assigned used string

. . . NAME-fmt.a a(true) l(207) x(0) class(PAUTO) tc(1) assigned used SLICE-[]interface {}

. BLOCK l(19) hascall

. BLOCK-list

. . AS l(19) tc(1)

. . . NAME-main..autotmp_10 a(true) l(19) x(0) class(PAUTO) esc(N) tc(1) used int

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

. . AS l(19) tc(1)

. . . NAME-main..autotmp_11 a(true) l(19) x(0) class(PAUTO) esc(N) tc(1) assigned used error

. . . INDREGSP-SP a(true) l(19) x(64) tc(1) addrtaken main.__ error

. BLOCK l(19)

. BLOCK-list

. . AS l(19) tc(1)

. . . NAME-fmt.n a(true) l(207) x(0) class(PAUTO) tc(1) assigned used int

. . . NAME-main..autotmp_10 a(true) l(19) x(0) class(PAUTO) esc(N) tc(1) used int

. . AS l(19) tc(1)

. . . NAME-fmt.err a(true) l(207) x(0) class(PAUTO) tc(1) assigned used error

. . . NAME-main..autotmp_11 a(true) l(19) x(0) class(PAUTO) esc(N) tc(1) assigned used error

. VARKILL l(19) tc(1)

. . NAME-main..autotmp_11 a(true) l(19) x(0) class(PAUTO) esc(N) tc(1) assigned used error

. VARKILL l(19) tc(1)

. . NAME-main..autotmp_10 a(true) l(19) x(0) class(PAUTO) esc(N) tc(1) used int

. 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] (y[int], w[int], z[int], fmt.n[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]
v49 (?) = ConstInterface <error> (fmt.err[error])
v50 (?) = OffPtr <*io.Writer> [0] v2
v51 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = Addr <**os.File> {os.Stdout} v3
v57 (?) = OffPtr <*string> [16] v2
v60 (?) = OffPtr <*[]interface {}> [32] v2
v63 (?) = OffPtr <*int> [56] v2
v65 (?) = OffPtr <*error> [64] v2
If v8 → b2 b4 (10)
b2: ← b1
v9 (11) = Copy <int> v7 (x[int])
v11 (11) = Mul64 <int> v9 v10 (w[int], y[int])
Plain → b3 (12)
b3: ← b2 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_18} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} 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) = IsSliceInBounds <bool> v4 v10
If v44 → b5 b6 (likely) (19)
b4: ← b1
v12 (14) = Copy <int> v7 (x[int])
v13 (14) = Sub64 <int> v12 v6 (y[int])
Plain → b3 (14)
b5: ← b3
v47 (19) = Sub64 <int> v10 v4
v48 (19) = SliceMake <[]interface {}> v35 v47 v47 (fmt.a[[]interface {}])
v53 (208) = Copy <mem> v42
v54 (208) = Load <*os.File> v52 v53
v55 (208) = IMake <io.Writer> v51 v54
v56 (208) = Store <mem> {io.Writer} v50 v55 v53
v58 (208) = Copy <string> v31 (fmt.format[string])
v59 (208) = Store <mem> {string} v57 v58 v56
v61 (208) = Store <mem> {[]interface {}} v60 v48 v59
v62 (208) = StaticCall <mem> {fmt.Fprintf} [80] v61
v64 (19) = Load <int> v63 v62 (fmt.n[int])
v66 (19) = Load <error> v65 v62 (fmt.err[error])
Plain → b7 (+19)
b6: ← b3
v45 (19) = Copy <mem> v42
v46 (19) = StaticCall <mem> {runtime.panicslice} v45
Exit v46 (19)
b7: ← b5
v67 (20) = Copy <mem> v62
Ret v67
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 v58 
name ~arg1[interface {}]: v25 
name ~arg2[interface {}]: v30 
name fmt.a[[]interface {}]: v48 
name fmt.n[int]: v4 v64 
name fmt.err[error]: v49 v66

number lines

number lines [26600 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = Const64 <int> [0] (x[int], z[int], fmt.n[int], w[int], y[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]
v49 (?) = ConstInterface <error> (fmt.err[error])
v50 (?) = OffPtr <*io.Writer> [0] v2
v51 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = Addr <**os.File> {os.Stdout} v3
v57 (?) = OffPtr <*string> [16] v2
v60 (?) = OffPtr <*[]interface {}> [32] v2
v63 (?) = OffPtr <*int> [56] v2
v65 (?) = OffPtr <*error> [64] v2
If v8 → b2 b4 (10)
b2: ← b1
v9 (11) = Copy <int> v7 (x[int])
v11 (+11) = Mul64 <int> v9 v10 (w[int], y[int])
Plain → b3 (+12)
b3: ← b2 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_18} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} 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) = IsSliceInBounds <bool> v4 v10
If v44 → b5 b6 (likely) (19)
b4: ← b1
v12 (14) = Copy <int> v7 (x[int])
v13 (+14) = Sub64 <int> v12 v6 (y[int])
Plain → b3 (14)
b5: ← b3
v47 (+19) = Sub64 <int> v10 v4
v48 (19) = SliceMake <[]interface {}> v35 v47 v47 (fmt.a[[]interface {}])
v53 (208) = Copy <mem> v42
v54 (+208) = Load <*os.File> v52 v53
v55 (208) = IMake <io.Writer> v51 v54
v56 (208) = Store <mem> {io.Writer} v50 v55 v53
v58 (208) = Copy <string> v31 (fmt.format[string])
v59 (208) = Store <mem> {string} v57 v58 v56
v61 (208) = Store <mem> {[]interface {}} v60 v48 v59
v62 (208) = StaticCall <mem> {fmt.Fprintf} [80] v61
v64 (+19) = Load <int> v63 v62 (fmt.n[int])
v66 (19) = Load <error> v65 v62 (fmt.err[error])
Plain → b7 (+19)
b6: ← b3
v45 (19) = Copy <mem> v42
v46 (+19) = StaticCall <mem> {runtime.panicslice} v45
Exit v46 (19)
b7: ← b5
v67 (20) = Copy <mem> v62
Ret v67
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 v58 
name ~arg1[interface {}]: v25 
name ~arg2[interface {}]: v30 
name fmt.a[[]interface {}]: v48 
name fmt.n[int]: v4 v64 
name fmt.err[error]: v49 v66

early phielim

early phielim [21200 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = Const64 <int> [0] (w[int], y[int], fmt.n[int], x[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]
v49 (?) = ConstInterface <error> (fmt.err[error])
v50 (?) = OffPtr <*io.Writer> [0] v2
v51 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = Addr <**os.File> {os.Stdout} v3
v57 (?) = OffPtr <*string> [16] v2
v60 (?) = OffPtr <*[]interface {}> [32] v2
v63 (?) = OffPtr <*int> [56] v2
v65 (?) = OffPtr <*error> [64] v2
If v8 → b2 b4 (10)
b2: ← b1
v9 (11) = Copy <int> v7 (x[int])
v11 (+11) = Mul64 <int> v7 v10 (w[int], y[int])
Plain → b3 (+12)
b3: ← b2 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_18} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} 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) = IsSliceInBounds <bool> v4 v10
If v44 → b5 b6 (likely) (19)
b4: ← b1
v12 (14) = Copy <int> v7 (x[int])
v13 (+14) = Sub64 <int> v7 v6 (y[int])
Plain → b3 (14)
b5: ← b3
v47 (+19) = Sub64 <int> v10 v4
v48 (19) = SliceMake <[]interface {}> v35 v47 v47 (fmt.a[[]interface {}])
v53 (208) = Copy <mem> v42
v54 (+208) = Load <*os.File> v52 v42
v55 (208) = IMake <io.Writer> v51 v54
v56 (208) = Store <mem> {io.Writer} v50 v55 v42
v58 (208) = Copy <string> v31 (fmt.format[string])
v59 (208) = Store <mem> {string} v57 v31 v56
v61 (208) = Store <mem> {[]interface {}} v60 v48 v59
v62 (208) = StaticCall <mem> {fmt.Fprintf} [80] v61
v64 (+19) = Load <int> v63 v62 (fmt.n[int])
v66 (19) = Load <error> v65 v62 (fmt.err[error])
Plain → b7 (+19)
b6: ← b3
v45 (19) = Copy <mem> v42
v46 (+19) = StaticCall <mem> {runtime.panicslice} v42
Exit v46 (19)
b7: ← b5
v67 (20) = Copy <mem> v62
Ret v67
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 v58 
name ~arg1[interface {}]: v25 
name ~arg2[interface {}]: v30 
name fmt.a[[]interface {}]: v48 
name fmt.n[int]: v4 v64 
name fmt.err[error]: v49 v66

early copyelim

early copyelim [21000 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = Const64 <int> [0] (w[int], y[int], x[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]
v49 (?) = ConstInterface <error> (fmt.err[error])
v50 (?) = OffPtr <*io.Writer> [0] v2
v51 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = Addr <**os.File> {os.Stdout} v3
v57 (?) = OffPtr <*string> [16] v2
v60 (?) = OffPtr <*[]interface {}> [32] v2
v63 (?) = OffPtr <*int> [56] v2
v65 (?) = OffPtr <*error> [64] v2
If v8 → b2 b4 (10)
b2: ← b1
v9 (11) = Copy <int> v7
v11 (+11) = Mul64 <int> v7 v10 (w[int], y[int])
Plain → b3 (+12)
b3: ← b2 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_18} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} 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) = IsSliceInBounds <bool> v4 v10
If v44 → b5 b6 (likely) (19)
b4: ← b1
v12 (14) = Copy <int> v7
v13 (+14) = Sub64 <int> v7 v6 (y[int])
Plain → b3 (14)
b5: ← b3
v47 (+19) = Sub64 <int> v10 v4
v48 (19) = SliceMake <[]interface {}> v35 v47 v47 (fmt.a[[]interface {}])
v53 (208) = Copy <mem> v42
v54 (+208) = Load <*os.File> v52 v42
v55 (208) = IMake <io.Writer> v51 v54
v56 (208) = Store <mem> {io.Writer} v50 v55 v42
v58 (208) = Copy <string> v31
v59 (208) = Store <mem> {string} v57 v31 v56
v61 (208) = Store <mem> {[]interface {}} v60 v48 v59
v62 (208) = StaticCall <mem> {fmt.Fprintf} [80] v61
v64 (+19) = Load <int> v63 v62 (fmt.n[int])
v66 (19) = Load <error> v65 v62 (fmt.err[error])
Plain → b7 (+19)
b6: ← b3
v45 (19) = Copy <mem> v42
v46 (+19) = StaticCall <mem> {runtime.panicslice} v42
Exit v46 (19)
b7: ← b5
v67 (20) = Copy <mem> v62
Ret v62
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 {}]: v48 
name fmt.n[int]: v4 v64 
name fmt.err[error]: v49 v66

early deadcode

early deadcode [205700 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = Const64 <int> [0] (y[int], w[int], z[int], fmt.n[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 (?) = OffPtr <*io.Writer> [0] v2
v51 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = Addr <**os.File> {os.Stdout} v3
v57 (?) = OffPtr <*string> [16] v2
v60 (?) = OffPtr <*[]interface {}> [32] v2
If v8 → b2 b4 (10)
b2: ← b1
v11 (+11) = Mul64 <int> v7 v10 (w[int], y[int])
Plain → b3 (+12)
b3: ← b2 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_18} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} 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) = IsSliceInBounds <bool> v4 v10
If v44 → b5 b6 (likely) (19)
b4: ← b1
v13 (+14) = Sub64 <int> v7 v6 (y[int])
Plain → b3 (14)
b5: ← b3
v47 (+19) = Sub64 <int> v10 v4
v48 (19) = SliceMake <[]interface {}> v35 v47 v47 (fmt.a[[]interface {}])
v54 (+208) = Load <*os.File> v52 v42
v55 (208) = IMake <io.Writer> v51 v54
v56 (208) = Store <mem> {io.Writer} v50 v55 v42
v59 (208) = Store <mem> {string} v57 v31 v56
v61 (208) = Store <mem> {[]interface {}} v60 v48 v59
v62 (208) = StaticCall <mem> {fmt.Fprintf} [80] v61
Plain → b7 (+19)
b6: ← b3
v46 (+19) = StaticCall <mem> {runtime.panicslice} v42
Exit v46 (19)
b7: ← b5
Ret v62
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 {}]: v48 
name fmt.n[int]: v4

short circuit

short circuit [29200 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = Const64 <int> [0] (w[int], y[int], x[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]
v50 (?) = OffPtr <*io.Writer> [0] v2
v51 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = Addr <**os.File> {os.Stdout} v3
v57 (?) = OffPtr <*string> [16] v2
v60 (?) = OffPtr <*[]interface {}> [32] v2
If v8 → b2 b4 (10)
b2: ← b1
v11 (+11) = Mul64 <int> v7 v10 (w[int], y[int])
Plain → b3 (+12)
b3: ← b2 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_18} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} 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) = IsSliceInBounds <bool> v4 v10
If v44 → b5 b6 (likely) (19)
b4: ← b1
v13 (+14) = Sub64 <int> v7 v6 (y[int])
Plain → b3 (14)
b5: ← b3
v47 (+19) = Sub64 <int> v10 v4
v48 (19) = SliceMake <[]interface {}> v35 v47 v47 (fmt.a[[]interface {}])
v54 (+208) = Load <*os.File> v52 v42
v55 (208) = IMake <io.Writer> v51 v54
v56 (208) = Store <mem> {io.Writer} v50 v55 v42
v59 (208) = Store <mem> {string} v57 v31 v56
v61 (208) = Store <mem> {[]interface {}} v60 v48 v59
v62 (208) = StaticCall <mem> {fmt.Fprintf} [80] v61
Plain → b7 (+19)
b6: ← b3
v46 (+19) = StaticCall <mem> {runtime.panicslice} v42
Exit v46 (19)
b7: ← b5
Ret v62
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 {}]: v48 
name fmt.n[int]: v4

decompose args

decompose args [26700 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = Const64 <int> [0] (w[int], y[int], fmt.n[int], x[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]
v50 (?) = OffPtr <*io.Writer> [0] v2
v51 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = Addr <**os.File> {os.Stdout} v3
v57 (?) = OffPtr <*string> [16] v2
v60 (?) = OffPtr <*[]interface {}> [32] v2
If v8 → b2 b4 (10)
b2: ← b1
v11 (+11) = Mul64 <int> v7 v10 (y[int], w[int])
Plain → b3 (+12)
b3: ← b2 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_18} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} 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) = IsSliceInBounds <bool> v4 v10
If v44 → b5 b6 (likely) (19)
b4: ← b1
v13 (+14) = Sub64 <int> v7 v6 (y[int])
Plain → b3 (14)
b5: ← b3
v47 (+19) = Sub64 <int> v10 v4
v48 (19) = SliceMake <[]interface {}> v35 v47 v47 (fmt.a[[]interface {}])
v54 (+208) = Load <*os.File> v52 v42
v55 (208) = IMake <io.Writer> v51 v54
v56 (208) = Store <mem> {io.Writer} v50 v55 v42
v59 (208) = Store <mem> {string} v57 v31 v56
v61 (208) = Store <mem> {[]interface {}} v60 v48 v59
v62 (208) = StaticCall <mem> {fmt.Fprintf} [80] v61
Plain → b7 (+19)
b6: ← b3
v46 (+19) = StaticCall <mem> {runtime.panicslice} v42
Exit v46 (19)
b7: ← b5
Ret v62
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 {}]: v48 
name fmt.n[int]: v4

decompose user

decompose user [185900 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = Const64 <int> [0] (z[int], fmt.n[int], x[int], y[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 (?) = OffPtr <*io.Writer> [0] v2
v51 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = Addr <**os.File> {os.Stdout} v3
v57 (?) = OffPtr <*string> [16] v2
v60 (?) = OffPtr <*[]interface {}> [32] v2
If v8 → b2 b4 (10)
b2: ← b1
v11 (+11) = Mul64 <int> v7 v10 (w[int], y[int])
Plain → b3 (+12)
b3: ← b2 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_18} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} 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) = IsSliceInBounds <bool> v4 v10
If v44 → b5 b6 (likely) (19)
b4: ← b1
v13 (+14) = Sub64 <int> v7 v6 (y[int])
Plain → b3 (14)
b5: ← b3
v47 (+19) = Sub64 <int> v10 v4
v48 (19) = SliceMake <[]interface {}> v35 v47 v47 (fmt.a[[]interface {}])
v54 (+208) = Load <*os.File> v52 v42
v55 (208) = IMake <io.Writer> v51 v54
v56 (208) = Store <mem> {io.Writer} v50 v55 v42
v59 (208) = Store <mem> {string} v57 v31 v56
v61 (208) = Store <mem> {[]interface {}} v60 v48 v59
v62 (208) = StaticCall <mem> {fmt.Fprintf} [80] v61
Plain → b7 (+19)
b6: ← b3
v46 (+19) = StaticCall <mem> {runtime.panicslice} v42
Exit v46 (19)
b7: ← b5
Ret v62
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 {}]: v48 
name fmt.n[int]: v4

opt

opt [181000 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = Const64 <int> [0] (w[int], y[int], fmt.n[int], x[int], z[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]
v50 (?) = OffPtr <*io.Writer> [0] v2
v51 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = Addr <**os.File> {os.Stdout} v3
v57 (?) = OffPtr <*string> [16] v2
v60 (?) = OffPtr <*[]interface {}> [32] v2
v45 (?) = SB <uintptr>
v66 (?) = Const64 <int> [7]
v67 (?) = Addr <*uint8> {go.string."%d, %d\n"} v45
v31 (?) = StringMake <string> v67 v66 (fmt.format[string])
First → b2 b4 (10)
b2: ← b1
v11 (+11) = Const64 <int> [4] (w[int], y[int])
Plain → b3 (+12)
b3: ← b2 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_18} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} 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
v44 (19) = ConstBool <bool> [true]
v64 (19) = Const64 <int> [0]
v58 (19) = Const64 <int> [16]
v53 (19) = Const64 <int> [16]
v12 (19) = Const64 <int> [16]
First → b5 b6 (likely) (19)
b4: ← b1
v13 (+14) = Const64 <int> [-1] (y[int])
Plain → b3 (14)
b5: ← b3
v47 (19) = Const64 <int> [2]
v48 (+19) = SliceMake <[]interface {}> v35 v47 v47 (fmt.a[[]interface {}])
v54 (+208) = Load <*os.File> v52 v42
v55 (208) = IMake <io.Writer> v51 v54
v56 (208) = Store <mem> {io.Writer} v50 v55 v42
v59 (208) = Store <mem> {string} v57 v31 v56
v61 (208) = Store <mem> {[]interface {}} v60 v48 v59
v62 (208) = StaticCall <mem> {fmt.Fprintf} [80] v61
Plain → b7 (+19)
b6: ← b3
v46 (+19) = StaticCall <mem> {runtime.panicslice} v42
Exit v46 (19)
b7: ← b5
Ret v62
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 {}]: v48 
name fmt.n[int]: v4

zero arg cse

zero arg cse [38300 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = Const64 <int> [0] (w[int], y[int], x[int], z[int], fmt.n[int])
v5 (?) = Const64 <int> [5] (x[int])
v6 (?) = Const64 <int> [3]
v7 (+9) = Const64 <int> [2] (x[int])
v8 (+10) = ConstBool <bool> [true]
v10 (?) = Const64 <int> [2]
v18 (?) = OffPtr <*int> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] v2
v24 (?) = Addr <*uint8> {type.int} v3
v29 (?) = Addr <*uint8> {type.int} v3
v40 (?) = Const64 <int> [1]
v50 (?) = OffPtr <*io.Writer> [0] v2
v51 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = Addr <**os.File> {os.Stdout} v3
v57 (?) = OffPtr <*string> [16] v2
v60 (?) = OffPtr <*[]interface {}> [32] v2
v67 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3
v45 (?) = SB <uintptr>
v66 (?) = Const64 <int> [7]
v11 (+11) = Const64 <int> [4] (y[int], w[int])
v58 (19) = Const64 <int> [16]
v13 (+14) = Const64 <int> [-1] (y[int])
v31 (?) = StringMake <string> v67 v66 (fmt.format[string])
First → b2 b4 (10)
b2: ← b1
Plain → b3 (+12)
b3: ← b2 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_18} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} 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
v44 (19) = ConstBool <bool> [true]
v64 (19) = Const64 <int> [0]
v12 (19) = Const64 <int> [16]
v53 (19) = Const64 <int> [16]
First → b5 b6 (likely) (19)
b4: ← b1
Plain → b3 (14)
b5: ← b3
v47 (19) = Const64 <int> [2]
v48 (+19) = SliceMake <[]interface {}> v35 v7 v7 (fmt.a[[]interface {}])
v54 (+208) = Load <*os.File> v52 v42
v55 (208) = IMake <io.Writer> v51 v54
v56 (208) = Store <mem> {io.Writer} v50 v55 v42
v59 (208) = Store <mem> {string} v57 v31 v56
v61 (208) = Store <mem> {[]interface {}} v60 v48 v59
v62 (208) = StaticCall <mem> {fmt.Fprintf} [80] v61
Plain → b7 (+19)
b6: ← b3
v46 (+19) = StaticCall <mem> {runtime.panicslice} v42
Exit v46 (19)
b7: ← b5
Ret v62
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 {}]: v48 
name fmt.n[int]: v4

opt deadcode

opt deadcode [51300 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
v50 (?) = OffPtr <*io.Writer> [0] v2
v51 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = Addr <**os.File> {os.Stdout} v3
v57 (?) = OffPtr <*string> [16] v2
v60 (?) = OffPtr <*[]interface {}> [32] v2
v67 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3
v66 (?) = Const64 <int> [7]
v11 (+11) = Const64 <int> [4] (w[int], y[int])
v31 (?) = StringMake <string> v67 v66 (fmt.format[string])
Plain → b2 (+10)
b2: ← b1
Plain → b3 (+12)
b3: ← b2
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_18} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} 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 → b5 (19)
b5: ← b3
v48 (+19) = SliceMake <[]interface {}> v35 v7 v7 (fmt.a[[]interface {}])
v54 (+208) = Load <*os.File> v52 v42
v55 (208) = IMake <io.Writer> v51 v54
v56 (208) = Store <mem> {io.Writer} v50 v55 v42
v59 (208) = Store <mem> {string} v57 v31 v56
v61 (208) = Store <mem> {[]interface {}} v60 v48 v59
v62 (208) = StaticCall <mem> {fmt.Fprintf} [80] v61
Plain → b7 (+19)
b7: ← b5
Ret v62
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 {}]: v48

generic cse

generic cse [51900 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
v50 (?) = OffPtr <*io.Writer> [0] v2
v51 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = Addr <**os.File> {os.Stdout} v3
v57 (?) = OffPtr <*string> [16] v2
v60 (?) = OffPtr <*[]interface {}> [32] v2
v67 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3
v66 (?) = Const64 <int> [7]
v11 (+11) = Const64 <int> [4] (w[int], y[int])
v31 (?) = StringMake <string> v67 v66 (fmt.format[string])
Plain → b2 (+10)
b2: ← b1
Plain → b3 (+12)
b3: ← b2
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_18} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} 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 → b5 (19)
b5: ← b3
v48 (+19) = SliceMake <[]interface {}> v35 v7 v7 (fmt.a[[]interface {}])
v54 (+208) = Load <*os.File> v52 v42
v55 (208) = IMake <io.Writer> v51 v54
v56 (208) = Store <mem> {io.Writer} v50 v55 v42
v59 (208) = Store <mem> {string} v57 v31 v56
v61 (208) = Store <mem> {[]interface {}} v60 v48 v59
v62 (208) = StaticCall <mem> {fmt.Fprintf} [80] v61
Plain → b7 (+19)
b7: ← b5
Ret v62
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 {}]: v48

phiopt

phiopt [20500 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
v50 (?) = OffPtr <*io.Writer> [0] v2
v51 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = Addr <**os.File> {os.Stdout} v3
v57 (?) = OffPtr <*string> [16] v2
v60 (?) = OffPtr <*[]interface {}> [32] v2
v67 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3
v66 (?) = Const64 <int> [7]
v11 (+11) = Const64 <int> [4] (w[int], y[int])
v31 (?) = StringMake <string> v67 v66 (fmt.format[string])
Plain → b2 (+10)
b2: ← b1
Plain → b3 (+12)
b3: ← b2
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_18} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} 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 → b5 (19)
b5: ← b3
v48 (+19) = SliceMake <[]interface {}> v35 v7 v7 (fmt.a[[]interface {}])
v54 (+208) = Load <*os.File> v52 v42
v55 (208) = IMake <io.Writer> v51 v54
v56 (208) = Store <mem> {io.Writer} v50 v55 v42
v59 (208) = Store <mem> {string} v57 v31 v56
v61 (208) = Store <mem> {[]interface {}} v60 v48 v59
v62 (208) = StaticCall <mem> {fmt.Fprintf} [80] v61
Plain → b7 (+19)
b7: ← b5
Ret v62
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 {}]: v48

nilcheckelim

nilcheckelim [37700 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
v50 (?) = OffPtr <*io.Writer> [0] v2
v51 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = Addr <**os.File> {os.Stdout} v3
v57 (?) = OffPtr <*string> [16] v2
v60 (?) = OffPtr <*[]interface {}> [32] v2
v67 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3
v66 (?) = Const64 <int> [7]
v11 (+11) = Const64 <int> [4] (w[int], y[int])
v31 (?) = StringMake <string> v67 v66 (fmt.format[string])
Plain → b2 (+10)
b2: ← b1
Plain → b3 (+12)
b3: ← b2
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_18} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} 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 → b5 (19)
b5: ← b3
v48 (+19) = SliceMake <[]interface {}> v35 v7 v7 (fmt.a[[]interface {}])
v54 (+208) = Load <*os.File> v52 v42
v55 (208) = IMake <io.Writer> v51 v54
v56 (208) = Store <mem> {io.Writer} v50 v55 v42
v59 (208) = Store <mem> {string} v57 v31 v56
v61 (208) = Store <mem> {[]interface {}} v60 v48 v59
v62 (208) = StaticCall <mem> {fmt.Fprintf} [80] v61
Plain → b7 (+19)
b7: ← b5
Ret v62
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 {}]: v48

prove

prove [32900 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
v50 (?) = OffPtr <*io.Writer> [0] v2
v51 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = Addr <**os.File> {os.Stdout} v3
v57 (?) = OffPtr <*string> [16] v2
v60 (?) = OffPtr <*[]interface {}> [32] v2
v67 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3
v66 (?) = Const64 <int> [7]
v11 (+11) = Const64 <int> [4] (w[int], y[int])
v31 (?) = StringMake <string> v67 v66 (fmt.format[string])
Plain → b2 (+10)
b2: ← b1
Plain → b3 (+12)
b3: ← b2
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_18} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} 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 → b5 (19)
b5: ← b3
v48 (+19) = SliceMake <[]interface {}> v35 v7 v7 (fmt.a[[]interface {}])
v54 (+208) = Load <*os.File> v52 v42
v55 (208) = IMake <io.Writer> v51 v54
v56 (208) = Store <mem> {io.Writer} v50 v55 v42
v59 (208) = Store <mem> {string} v57 v31 v56
v61 (208) = Store <mem> {[]interface {}} v60 v48 v59
v62 (208) = StaticCall <mem> {fmt.Fprintf} [80] v61
Plain → b7 (+19)
b7: ← b5
Ret v62
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 {}]: v48

fuse plain

fuse plain [21700 ns]

b1:
BlockInvalid (+10)
b2:
BlockInvalid (+12)
b3:
BlockInvalid (19)
b5:
BlockInvalid (+19)
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
v29 (?) = Addr <*uint8> {type.int} v3
v50 (?) = OffPtr <*io.Writer> [0] v2
v51 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = Addr <**os.File> {os.Stdout} v3
v57 (?) = OffPtr <*string> [16] v2
v60 (?) = OffPtr <*[]interface {}> [32] v2
v67 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3
v66 (?) = Const64 <int> [7]
v11 (+11) = Const64 <int> [4] (w[int], y[int])
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_18} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} 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
v48 (+19) = SliceMake <[]interface {}> v35 v7 v7 (fmt.a[[]interface {}])
v54 (+208) = Load <*os.File> v52 v42
v55 (208) = IMake <io.Writer> v51 v54
v56 (208) = Store <mem> {io.Writer} v50 v55 v42
v31 (?) = StringMake <string> v67 v66 (fmt.format[string])
v59 (208) = Store <mem> {string} v57 v31 v56
v61 (208) = Store <mem> {[]interface {}} v60 v48 v59
v62 (208) = StaticCall <mem> {fmt.Fprintf} [80] v61
Ret v62
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 {}]: v48

decompose builtin

decompose builtin [273800 ns]

b1:
BlockInvalid (+10)
b2:
BlockInvalid (+12)
b3:
BlockInvalid (19)
b5:
BlockInvalid (+19)
b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = Const64 <int> [2] (a.len[int], a.cap[int], x[int])
v18 (?) = OffPtr <*int> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] v2
v24 (?) = Addr <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v29 (?) = Addr <*uint8> {type.int} v3
v50 (?) = OffPtr <*io.Writer> [0] v2
v51 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = Addr <**os.File> {os.Stdout} v3
v57 (?) = OffPtr <*string> [16] v2
v60 (?) = OffPtr <*[]interface {}> [32] v2
v67 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v66 (?) = Const64 <int> [7] (format.len[int])
v11 (+11) = Const64 <int> [4] (y[int], w[int])
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_18} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v34 (a.ptr[*interface {}])
v37 (19) = OffPtr <*interface {}> [0] v35
v41 (19) = OffPtr <*interface {}> [16] v35
v48 (+19) = SliceMake <[]interface {}> v35 v7 v7
v43 (19) = OffPtr <**uint8> [8] v37
v39 (19) = Store <mem> {uintptr} v37 v24 v34
v36 (19) = OffPtr <**uint8> [8] v41
v47 (208) = OffPtr <**uint8> [8] v50
v12 (208) = OffPtr <*int> [8] v57
v44 (208) = OffPtr <*int> [16] v60
v13 (208) = OffPtr <*int> [8] v60
v31 (?) = StringMake <string> v67 v66
v38 (19) = Store <mem> {*uint8} v43 v23 v39
v46 (19) = Store <mem> {uintptr} v41 v24 v38
v42 (19) = Store <mem> {*uint8} v36 v28 v46
v54 (+208) = Load <*os.File> v52 v42
v55 (208) = IMake <io.Writer> v51 v54
v53 (208) = Store <mem> {uintptr} v50 v51 v42
v56 (208) = Store <mem> {*uint8} v47 v54 v53
v64 (208) = Store <mem> {*uint8} v57 v67 v56
v59 (208) = Store <mem> {int} v12 v66 v64
v58 (208) = Store <mem> {*uint8} v60 v35 v59
v15 (208) = Store <mem> {int} v13 v7 v58
v61 (208) = Store <mem> {int} v44 v7 v15
v62 (208) = StaticCall <mem> {fmt.Fprintf} [80] v61
Ret v62
name w[int]: v11 v16 
name x[int]: v7 
name y[int]: v11 
name z[int]: v17 
name format.ptr[*uint8]: v67 
name format.len[int]: v66 
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 [21000 ns]

b1:
BlockInvalid (+10)
b2:
BlockInvalid (+12)
b3:
BlockInvalid (19)
b5:
BlockInvalid (+19)
b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = Const64 <int> [2] (x[int], a.cap[int], a.len[int])
v18 (?) = OffPtr <*int> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] v2
v24 (?) = Addr <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v29 (?) = Addr <*uint8> {type.int} v3
v50 (?) = OffPtr <*io.Writer> [0] v2
v51 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = Addr <**os.File> {os.Stdout} v3
v57 (?) = OffPtr <*string> [16] v2
v60 (?) = OffPtr <*[]interface {}> [32] v2
v67 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v66 (?) = Const64 <int> [7] (format.len[int])
v11 (+11) = Const64 <int> [4] (w[int], y[int])
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_18} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v34 (a.ptr[*interface {}])
v37 (19) = OffPtr <*interface {}> [0] v35
v41 (19) = OffPtr <*interface {}> [16] v35
v48 (+19) = SliceMake <[]interface {}> v35 v7 v7
v43 (19) = OffPtr <**uint8> [8] v37
v39 (19) = Store <mem> {uintptr} v37 v24 v34
v36 (19) = OffPtr <**uint8> [8] v41
v47 (208) = OffPtr <**uint8> [8] v50
v12 (208) = OffPtr <*int> [8] v57
v44 (208) = OffPtr <*int> [16] v60
v13 (208) = OffPtr <*int> [8] v60
v31 (?) = StringMake <string> v67 v66
v38 (19) = Store <mem> {*uint8} v43 v23 v39
v46 (19) = Store <mem> {uintptr} v41 v24 v38
v42 (19) = Store <mem> {*uint8} v36 v28 v46
v54 (+208) = Load <*os.File> v52 v42
v55 (208) = IMake <io.Writer> v51 v54
v53 (208) = Store <mem> {uintptr} v50 v51 v42
v56 (208) = Store <mem> {*uint8} v47 v54 v53
v64 (208) = Store <mem> {*uint8} v57 v67 v56
v59 (208) = Store <mem> {int} v12 v66 v64
v58 (208) = Store <mem> {*uint8} v60 v35 v59
v15 (208) = Store <mem> {int} v13 v7 v58
v61 (208) = Store <mem> {int} v44 v7 v15
v62 (208) = StaticCall <mem> {fmt.Fprintf} [80] v61
Ret v62
name w[int]: v11 v16 
name x[int]: v7 
name y[int]: v11 
name z[int]: v17 
name format.ptr[*uint8]: v67 
name format.len[int]: v66 
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 [46700 ns]

b1:
BlockInvalid (+10)
b2:
BlockInvalid (+12)
b3:
BlockInvalid (19)
b5:
BlockInvalid (+19)
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])
v29 (?) = Addr <*uint8> {type.int} v3
v50 (?) = OffPtr <*io.Writer> [0] v2
v51 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = Addr <**os.File> {os.Stdout} v3
v57 (?) = OffPtr <*string> [16] v2
v60 (?) = OffPtr <*[]interface {}> [32] v2
v67 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v66 (?) = Const64 <int> [7] (format.len[int])
v11 (+11) = Const64 <int> [4] (w[int], y[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])
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_18} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v34 (a.ptr[*interface {}])
v37 (19) = OffPtr <*interface {}> [0] v35
v41 (19) = OffPtr <*interface {}> [16] v35
v48 (+19) = SliceMake <[]interface {}> v35 v7 v7
v43 (19) = OffPtr <**uint8> [8] v35
v39 (19) = Store <mem> {uintptr} v37 v24 v34
v36 (19) = OffPtr <**uint8> [24] v35
v47 (208) = OffPtr <**uint8> [8] v2
v12 (208) = OffPtr <*int> [24] v2
v44 (208) = OffPtr <*int> [48] v2
v13 (208) = OffPtr <*int> [40] v2
v31 (?) = StringMake <string> v67 v66
v38 (19) = Store <mem> {*uint8} v43 v23 v39
v46 (19) = Store <mem> {uintptr} v41 v24 v38
v42 (19) = Store <mem> {*uint8} v36 v28 v46
v54 (+208) = Load <*os.File> v52 v42
v55 (208) = IMake <io.Writer> v51 v54
v53 (208) = Store <mem> {uintptr} v50 v51 v42
v56 (208) = Store <mem> {*uint8} v47 v54 v53
v64 (208) = Store <mem> {*uint8} v57 v67 v56
v59 (208) = Store <mem> {int} v12 v66 v64
v58 (208) = Store <mem> {*uint8} v60 v35 v59
v15 (208) = Store <mem> {int} v13 v7 v58
v61 (208) = Store <mem> {int} v44 v7 v15
v62 (208) = StaticCall <mem> {fmt.Fprintf} [80] v61
Ret v62
name w[int]: v11 v16 
name x[int]: v7 
name y[int]: v11 
name z[int]: v17 
name format.ptr[*uint8]: v67 
name format.len[int]: v66 
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 [31700 ns]

b1:
BlockInvalid (+10)
b2:
BlockInvalid (+12)
b3:
BlockInvalid (19)
b5:
BlockInvalid (+19)
b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = Const64 <int> [2] (a.cap[int], x[int], a.len[int])
v18 (?) = OffPtr <*int> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] v2
v24 (?) = Addr <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v29 (?) = Addr <*uint8> {type.int} v3
v50 (?) = OffPtr <*io.Writer> [0] v2
v51 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = Addr <**os.File> {os.Stdout} v3
v57 (?) = OffPtr <*string> [16] v2
v60 (?) = OffPtr <*[]interface {}> [32] v2
v67 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v66 (?) = Const64 <int> [7] (format.len[int])
v11 (+11) = Const64 <int> [4] (y[int], w[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])
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_18} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v32
v34 (19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v34 (a.ptr[*interface {}])
v37 (19) = OffPtr <*interface {}> [0] v35
v41 (19) = OffPtr <*interface {}> [16] v35
v48 (+19) = SliceMake <[]interface {}> v35 v7 v7
v43 (19) = OffPtr <**uint8> [8] v35
v39 (19) = Store <mem> {uintptr} v37 v24 v34
v36 (19) = OffPtr <**uint8> [24] v35
v47 (208) = OffPtr <**uint8> [8] v2
v12 (208) = OffPtr <*int> [24] v2
v44 (208) = OffPtr <*int> [48] v2
v13 (208) = OffPtr <*int> [40] v2
v31 (?) = StringMake <string> v67 v66
v38 (19) = Store <mem> {*uint8} v43 v23 v39
v46 (19) = Store <mem> {uintptr} v41 v24 v38
v42 (19) = Store <mem> {*uint8} v36 v28 v46
v54 (+208) = Load <*os.File> v52 v42
v55 (208) = IMake <io.Writer> v51 v54
v53 (208) = Store <mem> {uintptr} v50 v51 v42
v56 (208) = Store <mem> {*uint8} v47 v54 v53
v64 (208) = Store <mem> {*uint8} v57 v67 v56
v59 (208) = Store <mem> {int} v12 v66 v64
v58 (208) = Store <mem> {*uint8} v60 v35 v59
v15 (208) = Store <mem> {int} v13 v7 v58
v61 (208) = Store <mem> {int} v44 v7 v15
v62 (208) = StaticCall <mem> {fmt.Fprintf} [80] v61
Ret v62
name w[int]: v11 v16 
name x[int]: v7 
name y[int]: v11 
name z[int]: v17 
name format.ptr[*uint8]: v67 
name format.len[int]: v66 
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 [36100 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = Const64 <int> [2] (x[int], a.cap[int], a.len[int])
v18 (?) = OffPtr <*int> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] v2
v24 (?) = Addr <*uint8> {type.int} v3 (~arg2.type[uintptr], ~arg1.type[uintptr])
v50 (?) = OffPtr <*io.Writer> [0] v2
v51 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = Addr <**os.File> {os.Stdout} v3
v57 (?) = OffPtr <*string> [16] v2
v60 (?) = OffPtr <*[]interface {}> [32] v2
v67 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v66 (?) = 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_18} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v32
v34 (+19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v34 (a.ptr[*interface {}])
v37 (19) = OffPtr <*interface {}> [0] v35
v41 (19) = OffPtr <*interface {}> [16] v35
v43 (19) = OffPtr <**uint8> [8] v35
v39 (19) = Store <mem> {uintptr} v37 v24 v34
v36 (19) = OffPtr <**uint8> [24] v35
v47 (208) = OffPtr <**uint8> [8] v2
v12 (208) = OffPtr <*int> [24] v2
v44 (208) = OffPtr <*int> [48] v2
v13 (208) = OffPtr <*int> [40] v2
v38 (19) = Store <mem> {*uint8} v43 v23 v39
v46 (19) = Store <mem> {uintptr} v41 v24 v38
v42 (19) = Store <mem> {*uint8} v36 v28 v46
v54 (+208) = Load <*os.File> v52 v42
v53 (208) = Store <mem> {uintptr} v50 v51 v42
v56 (208) = Store <mem> {*uint8} v47 v54 v53
v64 (208) = Store <mem> {*uint8} v57 v67 v56
v59 (208) = Store <mem> {int} v12 v66 v64
v58 (208) = Store <mem> {*uint8} v60 v35 v59
v15 (208) = Store <mem> {int} v13 v7 v58
v61 (208) = Store <mem> {int} v44 v7 v15
v62 (208) = StaticCall <mem> {fmt.Fprintf} [80] v61
Ret v62
name w[int]: v16 
name x[int]: v7 
name z[int]: v17 
name format.ptr[*uint8]: v67 
name format.len[int]: v66 
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 [18600 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = Const64 <int> [2] (x[int], a.cap[int], a.len[int])
v18 (?) = OffPtr <*int> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] v2
v24 (?) = Addr <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v50 (?) = OffPtr <*io.Writer> [0] v2
v51 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = Addr <**os.File> {os.Stdout} v3
v57 (?) = OffPtr <*string> [16] v2
v60 (?) = OffPtr <*[]interface {}> [32] v2
v67 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v66 (?) = 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_18} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v32
v34 (+19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v34 (a.ptr[*interface {}])
v37 (19) = OffPtr <*interface {}> [0] v35
v41 (19) = OffPtr <*interface {}> [16] v35
v43 (19) = OffPtr <**uint8> [8] v35
v39 (19) = Store <mem> {uintptr} v37 v24 v34
v36 (19) = OffPtr <**uint8> [24] v35
v47 (208) = OffPtr <**uint8> [8] v2
v12 (208) = OffPtr <*int> [24] v2
v44 (208) = OffPtr <*int> [48] v2
v13 (208) = OffPtr <*int> [40] v2
v38 (19) = Store <mem> {*uint8} v43 v23 v39
v46 (19) = Store <mem> {uintptr} v41 v24 v38
v42 (19) = Store <mem> {*uint8} v36 v28 v46
v54 (+208) = Load <*os.File> v52 v42
v53 (208) = Store <mem> {uintptr} v50 v51 v42
v56 (208) = Store <mem> {*uint8} v47 v54 v53
v64 (208) = Store <mem> {*uint8} v57 v67 v56
v59 (208) = Store <mem> {int} v12 v66 v64
v58 (208) = Store <mem> {*uint8} v60 v35 v59
v15 (208) = Store <mem> {int} v13 v7 v58
v61 (208) = Store <mem> {int} v44 v7 v15
v62 (208) = StaticCall <mem> {fmt.Fprintf} [80] v61
Ret v62
name w[int]: v16 
name x[int]: v7 
name z[int]: v17 
name format.ptr[*uint8]: v67 
name format.len[int]: v66 
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 [23300 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = Const64 <int> [2] (a.cap[int], x[int], a.len[int])
v18 (?) = OffPtr <*int> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] v2
v24 (?) = Addr <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v50 (?) = OffPtr <*io.Writer> [0] v2
v51 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = Addr <**os.File> {os.Stdout} v3
v57 (?) = OffPtr <*string> [16] v2
v60 (?) = OffPtr <*[]interface {}> [32] v2
v67 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v66 (?) = 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_18} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v32
v34 (+19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v34 (a.ptr[*interface {}])
v37 (19) = OffPtr <*interface {}> [0] v35
v41 (19) = OffPtr <*interface {}> [16] v35
v43 (19) = OffPtr <**uint8> [8] v35
v39 (19) = Store <mem> {uintptr} v37 v24 v34
v36 (19) = OffPtr <**uint8> [24] v35
v47 (208) = OffPtr <**uint8> [8] v2
v12 (208) = OffPtr <*int> [24] v2
v44 (208) = OffPtr <*int> [48] v2
v13 (208) = OffPtr <*int> [40] v2
v38 (19) = Store <mem> {*uint8} v43 v23 v39
v46 (19) = Store <mem> {uintptr} v41 v24 v38
v42 (19) = Store <mem> {*uint8} v36 v28 v46
v54 (+208) = Load <*os.File> v52 v42
v53 (208) = Store <mem> {uintptr} v50 v51 v42
v56 (208) = Store <mem> {*uint8} v47 v54 v53
v64 (208) = Store <mem> {*uint8} v57 v67 v56
v59 (208) = Store <mem> {int} v12 v66 v64
v58 (208) = Store <mem> {*uint8} v60 v35 v59
v15 (208) = Store <mem> {int} v13 v7 v58
v61 (208) = Store <mem> {int} v44 v7 v15
v62 (208) = StaticCall <mem> {fmt.Fprintf} [80] v61
Ret v62
name w[int]: v16 
name x[int]: v7 
name z[int]: v17 
name format.ptr[*uint8]: v67 
name format.len[int]: v66 
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 [20300 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = Const64 <int> [2] (a.len[int], a.cap[int], x[int])
v18 (?) = OffPtr <*int> [0] v2
v22 (?) = OffPtr <*unsafe.Pointer> [8] v2
v24 (?) = Addr <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v50 (?) = OffPtr <*io.Writer> [0] v2
v51 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = Addr <**os.File> {os.Stdout} v3
v57 (?) = OffPtr <*string> [16] v2
v60 (?) = OffPtr <*[]interface {}> [32] v2
v67 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v66 (?) = 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_18} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v32
v34 (+19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v34 (a.ptr[*interface {}])
v37 (19) = OffPtr <*interface {}> [0] v35
v41 (19) = OffPtr <*interface {}> [16] v35
v43 (19) = OffPtr <**uint8> [8] v35
v39 (19) = Store <mem> {uintptr} v37 v24 v34
v36 (19) = OffPtr <**uint8> [24] v35
v47 (208) = OffPtr <**uint8> [8] v2
v12 (208) = OffPtr <*int> [24] v2
v44 (208) = OffPtr <*int> [48] v2
v13 (208) = OffPtr <*int> [40] v2
v38 (19) = Store <mem> {*uint8} v43 v23 v39
v46 (19) = Store <mem> {uintptr} v41 v24 v38
v42 (19) = Store <mem> {*uint8} v36 v28 v46
v54 (+208) = Load <*os.File> v52 v42
v53 (208) = Store <mem> {uintptr} v50 v51 v42
v56 (208) = Store <mem> {*uint8} v47 v54 v53
v64 (208) = Store <mem> {*uint8} v57 v67 v56
v59 (208) = Store <mem> {int} v12 v66 v64
v58 (208) = Store <mem> {*uint8} v60 v35 v59
v15 (208) = Store <mem> {int} v13 v7 v58
v61 (208) = Store <mem> {int} v44 v7 v15
v62 (208) = StaticCall <mem> {fmt.Fprintf} [80] v61
Ret v62
name w[int]: v16 
name x[int]: v7 
name z[int]: v17 
name format.ptr[*uint8]: v67 
name format.len[int]: v66 
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 [28000 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 (~arg1.type[uintptr], ~arg2.type[uintptr])
v50 (?) = OffPtr <*io.Writer> [0] v2
v51 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = Addr <**os.File> {os.Stdout} v3
v57 (?) = OffPtr <*string> [16] v2
v60 (?) = OffPtr <*[]interface {}> [32] v2
v67 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v66 (?) = 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_18} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v32
v34 (+19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v34 (a.ptr[*interface {}])
v37 (19) = OffPtr <*interface {}> [0] v35
v41 (19) = OffPtr <*interface {}> [16] v35
v43 (19) = OffPtr <**uint8> [8] v35
v39 (19) = Store <mem> {uintptr} v37 v24 v34
v36 (19) = OffPtr <**uint8> [24] v35
v47 (208) = OffPtr <**uint8> [8] v2
v12 (208) = OffPtr <*int> [24] v2
v44 (208) = OffPtr <*int> [48] v2
v13 (208) = OffPtr <*int> [40] v2
v38 (19) = Store <mem> {*uint8} v43 v23 v39
v46 (19) = Store <mem> {uintptr} v41 v24 v38
v42 (19) = Store <mem> {*uint8} v36 v28 v46
v54 (+208) = Load <*os.File> v52 v42
v53 (208) = Store <mem> {uintptr} v50 v51 v42
v56 (208) = Store <mem> {*uint8} v47 v54 v53
v64 (208) = Store <mem> {*uint8} v57 v67 v56
v59 (208) = Store <mem> {int} v12 v66 v64
v58 (208) = Store <mem> {*uint8} v60 v35 v59
v15 (208) = Store <mem> {int} v13 v7 v58
v61 (208) = Store <mem> {int} v44 v7 v15
v62 (208) = StaticCall <mem> {fmt.Fprintf} [80] v61
Ret v62
name w[int]: v16 
name x[int]: v7 
name z[int]: v17 
name format.ptr[*uint8]: v67 
name format.len[int]: v66 
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 [27600 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 (~arg1.type[uintptr], ~arg2.type[uintptr])
v50 (?) = OffPtr <*io.Writer> [0] v2
v51 (?) = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = Addr <**os.File> {os.Stdout} v3
v57 (?) = OffPtr <*string> [16] v2
v60 (?) = OffPtr <*[]interface {}> [32] v2
v67 (?) = Addr <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v66 (?) = 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_18} v27
v33 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v32
v34 (+19) = Zero <mem> {[2]interface {}} [32] v33 v32
v35 (19) = LocalAddr <*[2]interface {}> {.autotmp_18} v2 v34 (a.ptr[*interface {}])
v37 (19) = OffPtr <*interface {}> [0] v35
v41 (19) = OffPtr <*interface {}> [16] v35
v43 (19) = OffPtr <**uint8> [8] v35
v39 (19) = Store <mem> {uintptr} v37 v24 v34
v36 (19) = OffPtr <**uint8> [24] v35
v47 (208) = OffPtr <**uint8> [8] v2
v12 (208) = OffPtr <*int> [24] v2
v44 (208) = OffPtr <*int> [48] v2
v13 (208) = OffPtr <*int> [40] v2
v38 (19) = Store <mem> {*uint8} v43 v23 v39
v46 (19) = Store <mem> {uintptr} v41 v24 v38
v42 (19) = Store <mem> {*uint8} v36 v28 v46
v54 (+208) = Load <*os.File> v52 v42
v53 (208) = Store <mem> {uintptr} v50 v51 v42
v56 (208) = Store <mem> {*uint8} v47 v54 v53
v64 (208) = Store <mem> {*uint8} v57 v67 v56
v59 (208) = Store <mem> {int} v12 v66 v64
v58 (208) = Store <mem> {*uint8} v60 v35 v59
v15 (208) = Store <mem> {int} v13 v7 v58
v61 (208) = Store <mem> {int} v44 v7 v15
v62 (208) = StaticCall <mem> {fmt.Fprintf} [80] v61
Ret v62
name w[int]: v16 
name x[int]: v7 
name z[int]: v17 
name format.ptr[*uint8]: v67 
name format.len[int]: v66 
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 [47500 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = MOVQconst <int> [2] (a.len[int], x[int], a.cap[int])
v22 (?) = LEAQ <*unsafe.Pointer> [8] v2
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v51 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = LEAQ <**os.File> {os.Stdout} v3
v57 (?) = LEAQ <*string> [16] v2
v60 (?) = LEAQ <*[]interface {}> [32] v2
v67 (?) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v66 (?) = 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_18} v27
v33 (19) = LEAQ <*[2]interface {}> {.autotmp_18} v2
v35 (19) = LEAQ <*[2]interface {}> {.autotmp_18} v2 (a.ptr[*interface {}])
v37 (19) = LEAQ <*interface {}> {.autotmp_18} v2
v41 (19) = LEAQ <*interface {}> {.autotmp_18} [16] v2
v43 (19) = LEAQ <**uint8> {.autotmp_18} [8] v2
v36 (19) = LEAQ <**uint8> {.autotmp_18} [24] v2
v47 (208) = LEAQ <**uint8> [8] v2
v12 (208) = LEAQ <*int> [24] v2
v44 (208) = LEAQ <*int> [48] v2
v13 (208) = LEAQ <*int> [40] v2
v55 (+19) = LEAQ <*[2]interface {}> {.autotmp_18} [16] v2
v48 (+19) = MOVOconst <int128> [0]
v25 (+19) = MOVOconst <int128> [0]
v30 (+19) = MOVOstore <mem> {.autotmp_18} v2 v25 v32
v34 (+19) = MOVOstore <mem> {.autotmp_18} [16] v2 v48 v30
v39 (19) = MOVQstore <mem> {.autotmp_18} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_18} [8] v2 v23 v39
v46 (19) = MOVQstore <mem> {.autotmp_18} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_18} [24] v2 v28 v46
v54 (+208) = MOVQload <*os.File> {os.Stdout} v3 v42
v53 (208) = MOVQstore <mem> v2 v51 v42
v56 (208) = MOVQstore <mem> [8] v2 v54 v53
v64 (208) = MOVQstore <mem> [16] v2 v67 v56
v59 (208) = MOVQstoreconst <mem> [val=7,off=24] v2 v64
v58 (208) = MOVQstore <mem> [32] v2 v35 v59
v15 (208) = MOVQstoreconst <mem> [val=2,off=40] v2 v58
v61 (208) = MOVQstoreconst <mem> [val=2,off=48] v2 v15
v62 (208) = CALLstatic <mem> {fmt.Fprintf} [80] v61
Ret v62
name w[int]: v16 
name x[int]: v7 
name z[int]: v17 
name format.ptr[*uint8]: v67 
name format.len[int]: v66 
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 cse

lowered cse [162700 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = MOVQconst <int> [2] (a.len[int], x[int], a.cap[int])
v22 (?) = LEAQ <*unsafe.Pointer> [8] v2
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v51 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = LEAQ <**os.File> {os.Stdout} v3
v57 (?) = LEAQ <*string> [16] v2
v60 (?) = LEAQ <*[]interface {}> [32] v2
v67 (?) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v66 (?) = 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_18} v27
v33 (19) = LEAQ <*[2]interface {}> {.autotmp_18} v2
v35 (19) = LEAQ <*[2]interface {}> {.autotmp_18} v2 (a.ptr[*interface {}])
v37 (19) = LEAQ <*interface {}> {.autotmp_18} v2
v41 (19) = LEAQ <*interface {}> {.autotmp_18} [16] v2
v43 (19) = LEAQ <**uint8> {.autotmp_18} [8] v2
v36 (19) = LEAQ <**uint8> {.autotmp_18} [24] v2
v47 (208) = LEAQ <**uint8> [8] v2
v12 (208) = LEAQ <*int> [24] v2
v44 (208) = LEAQ <*int> [48] v2
v13 (208) = LEAQ <*int> [40] v2
v55 (+19) = LEAQ <*[2]interface {}> {.autotmp_18} [16] v2
v48 (19) = MOVOconst <int128> [0]
v25 (+19) = MOVOconst <int128> [0]
v30 (+19) = MOVOstore <mem> {.autotmp_18} v2 v25 v32
v34 (+19) = MOVOstore <mem> {.autotmp_18} [16] v2 v25 v30
v39 (19) = MOVQstore <mem> {.autotmp_18} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_18} [8] v2 v23 v39
v46 (19) = MOVQstore <mem> {.autotmp_18} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_18} [24] v2 v28 v46
v54 (+208) = MOVQload <*os.File> {os.Stdout} v3 v42
v53 (208) = MOVQstore <mem> v2 v51 v42
v56 (208) = MOVQstore <mem> [8] v2 v54 v53
v64 (208) = MOVQstore <mem> [16] v2 v67 v56
v59 (208) = MOVQstoreconst <mem> [val=7,off=24] v2 v64
v58 (208) = MOVQstore <mem> [32] v2 v33 v59
v15 (208) = MOVQstoreconst <mem> [val=2,off=40] v2 v58
v61 (208) = MOVQstoreconst <mem> [val=2,off=48] v2 v15
v62 (208) = CALLstatic <mem> {fmt.Fprintf} [80] v61
Ret v62
name w[int]: v16 
name x[int]: v7 
name z[int]: v17 
name format.ptr[*uint8]: v67 
name format.len[int]: v66 
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

elim unread autos

elim unread autos [24200 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v7 (+9) = MOVQconst <int> [2] (a.len[int], x[int], a.cap[int])
v22 (?) = LEAQ <*unsafe.Pointer> [8] v2
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v51 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v52 (?) = LEAQ <**os.File> {os.Stdout} v3
v57 (?) = LEAQ <*string> [16] v2
v60 (?) = LEAQ <*[]interface {}> [32] v2
v67 (?) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v66 (?) = 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_18} v27
v33 (19) = LEAQ <*[2]interface {}> {.autotmp_18} v2
v35 (19) = LEAQ <*[2]interface {}> {.autotmp_18} v2 (a.ptr[*interface {}])
v37 (19) = LEAQ <*interface {}> {.autotmp_18} v2
v41 (19) = LEAQ <*interface {}> {.autotmp_18} [16] v2
v43 (19) = LEAQ <**uint8> {.autotmp_18} [8] v2
v36 (19) = LEAQ <**uint8> {.autotmp_18} [24] v2
v47 (208) = LEAQ <**uint8> [8] v2
v12 (208) = LEAQ <*int> [24] v2
v44 (208) = LEAQ <*int> [48] v2
v13 (208) = LEAQ <*int> [40] v2
v55 (+19) = LEAQ <*[2]interface {}> {.autotmp_18} [16] v2
v48 (19) = MOVOconst <int128> [0]
v25 (+19) = MOVOconst <int128> [0]
v30 (+19) = MOVOstore <mem> {.autotmp_18} v2 v25 v32
v34 (+19) = MOVOstore <mem> {.autotmp_18} [16] v2 v25 v30
v39 (19) = MOVQstore <mem> {.autotmp_18} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_18} [8] v2 v23 v39
v46 (19) = MOVQstore <mem> {.autotmp_18} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_18} [24] v2 v28 v46
v54 (+208) = MOVQload <*os.File> {os.Stdout} v3 v42
v53 (208) = MOVQstore <mem> v2 v51 v42
v56 (208) = MOVQstore <mem> [8] v2 v54 v53
v64 (208) = MOVQstore <mem> [16] v2 v67 v56
v59 (208) = MOVQstoreconst <mem> [val=7,off=24] v2 v64
v58 (208) = MOVQstore <mem> [32] v2 v33 v59
v15 (208) = MOVQstoreconst <mem> [val=2,off=40] v2 v58
v61 (208) = MOVQstoreconst <mem> [val=2,off=48] v2 v15
v62 (208) = CALLstatic <mem> {fmt.Fprintf} [80] v61
Ret v62
name w[int]: v16 
name x[int]: v7 
name z[int]: v17 
name format.ptr[*uint8]: v67 
name format.len[int]: v66 
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

lowered deadcode [38700 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v51 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v67 (?) = 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_18} v27
v33 (19) = LEAQ <*[2]interface {}> {.autotmp_18} v2
v25 (+19) = MOVOconst <int128> [0]
v30 (+19) = MOVOstore <mem> {.autotmp_18} v2 v25 v32
v34 (+19) = MOVOstore <mem> {.autotmp_18} [16] v2 v25 v30
v39 (19) = MOVQstore <mem> {.autotmp_18} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_18} [8] v2 v23 v39
v46 (19) = MOVQstore <mem> {.autotmp_18} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_18} [24] v2 v28 v46
v54 (+208) = MOVQload <*os.File> {os.Stdout} v3 v42
v53 (208) = MOVQstore <mem> v2 v51 v42
v56 (208) = MOVQstore <mem> [8] v2 v54 v53
v64 (208) = MOVQstore <mem> [16] v2 v67 v56
v59 (208) = MOVQstoreconst <mem> [val=7,off=24] v2 v64
v58 (208) = MOVQstore <mem> [32] v2 v33 v59
v15 (208) = MOVQstoreconst <mem> [val=2,off=40] v2 v58
v61 (208) = MOVQstoreconst <mem> [val=2,off=48] v2 v15
v62 (208) = CALLstatic <mem> {fmt.Fprintf} [80] v61
Ret v62
name format.ptr[*uint8]: v67 
name ~arg1.type[uintptr]: v24 
name ~arg1.data[*uint8]: v23 
name ~arg2.type[uintptr]: v24 
name ~arg2.data[*uint8]: v28

checkLower

checkLower [19500 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v51 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v67 (?) = 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_18} v27
v33 (19) = LEAQ <*[2]interface {}> {.autotmp_18} v2
v25 (+19) = MOVOconst <int128> [0]
v30 (+19) = MOVOstore <mem> {.autotmp_18} v2 v25 v32
v34 (+19) = MOVOstore <mem> {.autotmp_18} [16] v2 v25 v30
v39 (19) = MOVQstore <mem> {.autotmp_18} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_18} [8] v2 v23 v39
v46 (19) = MOVQstore <mem> {.autotmp_18} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_18} [24] v2 v28 v46
v54 (+208) = MOVQload <*os.File> {os.Stdout} v3 v42
v53 (208) = MOVQstore <mem> v2 v51 v42
v56 (208) = MOVQstore <mem> [8] v2 v54 v53
v64 (208) = MOVQstore <mem> [16] v2 v67 v56
v59 (208) = MOVQstoreconst <mem> [val=7,off=24] v2 v64
v58 (208) = MOVQstore <mem> [32] v2 v33 v59
v15 (208) = MOVQstoreconst <mem> [val=2,off=40] v2 v58
v61 (208) = MOVQstoreconst <mem> [val=2,off=48] v2 v15
v62 (208) = CALLstatic <mem> {fmt.Fprintf} [80] v61
Ret v62
name format.ptr[*uint8]: v67 
name ~arg1.type[uintptr]: v24 
name ~arg1.data[*uint8]: v23 
name ~arg2.type[uintptr]: v24 
name ~arg2.data[*uint8]: v28

late phielim

late phielim [21500 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v51 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v67 (?) = 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_18} v27
v33 (19) = LEAQ <*[2]interface {}> {.autotmp_18} v2
v25 (+19) = MOVOconst <int128> [0]
v30 (+19) = MOVOstore <mem> {.autotmp_18} v2 v25 v32
v34 (+19) = MOVOstore <mem> {.autotmp_18} [16] v2 v25 v30
v39 (19) = MOVQstore <mem> {.autotmp_18} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_18} [8] v2 v23 v39
v46 (19) = MOVQstore <mem> {.autotmp_18} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_18} [24] v2 v28 v46
v54 (+208) = MOVQload <*os.File> {os.Stdout} v3 v42
v53 (208) = MOVQstore <mem> v2 v51 v42
v56 (208) = MOVQstore <mem> [8] v2 v54 v53
v64 (208) = MOVQstore <mem> [16] v2 v67 v56
v59 (208) = MOVQstoreconst <mem> [val=7,off=24] v2 v64
v58 (208) = MOVQstore <mem> [32] v2 v33 v59
v15 (208) = MOVQstoreconst <mem> [val=2,off=40] v2 v58
v61 (208) = MOVQstoreconst <mem> [val=2,off=48] v2 v15
v62 (208) = CALLstatic <mem> {fmt.Fprintf} [80] v61
Ret v62
name format.ptr[*uint8]: v67 
name ~arg1.type[uintptr]: v24 
name ~arg1.data[*uint8]: v23 
name ~arg2.type[uintptr]: v24 
name ~arg2.data[*uint8]: v28

late copyelim

late copyelim [21100 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v51 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v67 (?) = 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_18} v27
v33 (19) = LEAQ <*[2]interface {}> {.autotmp_18} v2
v25 (+19) = MOVOconst <int128> [0]
v30 (+19) = MOVOstore <mem> {.autotmp_18} v2 v25 v32
v34 (+19) = MOVOstore <mem> {.autotmp_18} [16] v2 v25 v30
v39 (19) = MOVQstore <mem> {.autotmp_18} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_18} [8] v2 v23 v39
v46 (19) = MOVQstore <mem> {.autotmp_18} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_18} [24] v2 v28 v46
v54 (+208) = MOVQload <*os.File> {os.Stdout} v3 v42
v53 (208) = MOVQstore <mem> v2 v51 v42
v56 (208) = MOVQstore <mem> [8] v2 v54 v53
v64 (208) = MOVQstore <mem> [16] v2 v67 v56
v59 (208) = MOVQstoreconst <mem> [val=7,off=24] v2 v64
v58 (208) = MOVQstore <mem> [32] v2 v33 v59
v15 (208) = MOVQstoreconst <mem> [val=2,off=40] v2 v58
v61 (208) = MOVQstoreconst <mem> [val=2,off=48] v2 v15
v62 (208) = CALLstatic <mem> {fmt.Fprintf} [80] v61
Ret v62
name format.ptr[*uint8]: v67 
name ~arg1.type[uintptr]: v24 
name ~arg1.data[*uint8]: v23 
name ~arg2.type[uintptr]: v24 
name ~arg2.data[*uint8]: v28

tighten

tighten [31900 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v51 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v67 (?) = 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_18} v27
v33 (19) = LEAQ <*[2]interface {}> {.autotmp_18} v2
v25 (+19) = MOVOconst <int128> [0]
v30 (+19) = MOVOstore <mem> {.autotmp_18} v2 v25 v32
v34 (+19) = MOVOstore <mem> {.autotmp_18} [16] v2 v25 v30
v39 (19) = MOVQstore <mem> {.autotmp_18} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_18} [8] v2 v23 v39
v46 (19) = MOVQstore <mem> {.autotmp_18} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_18} [24] v2 v28 v46
v54 (+208) = MOVQload <*os.File> {os.Stdout} v3 v42
v53 (208) = MOVQstore <mem> v2 v51 v42
v56 (208) = MOVQstore <mem> [8] v2 v54 v53
v64 (208) = MOVQstore <mem> [16] v2 v67 v56
v59 (208) = MOVQstoreconst <mem> [val=7,off=24] v2 v64
v58 (208) = MOVQstore <mem> [32] v2 v33 v59
v15 (208) = MOVQstoreconst <mem> [val=2,off=40] v2 v58
v61 (208) = MOVQstoreconst <mem> [val=2,off=48] v2 v15
v62 (208) = CALLstatic <mem> {fmt.Fprintf} [80] v61
Ret v62
name format.ptr[*uint8]: v67 
name ~arg1.type[uintptr]: v24 
name ~arg1.data[*uint8]: v23 
name ~arg2.type[uintptr]: v24 
name ~arg2.data[*uint8]: v28

phi tighten

phi tighten [18800 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v51 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v67 (?) = 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_18} v27
v33 (19) = LEAQ <*[2]interface {}> {.autotmp_18} v2
v25 (+19) = MOVOconst <int128> [0]
v30 (+19) = MOVOstore <mem> {.autotmp_18} v2 v25 v32
v34 (+19) = MOVOstore <mem> {.autotmp_18} [16] v2 v25 v30
v39 (19) = MOVQstore <mem> {.autotmp_18} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_18} [8] v2 v23 v39
v46 (19) = MOVQstore <mem> {.autotmp_18} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_18} [24] v2 v28 v46
v54 (+208) = MOVQload <*os.File> {os.Stdout} v3 v42
v53 (208) = MOVQstore <mem> v2 v51 v42
v56 (208) = MOVQstore <mem> [8] v2 v54 v53
v64 (208) = MOVQstore <mem> [16] v2 v67 v56
v59 (208) = MOVQstoreconst <mem> [val=7,off=24] v2 v64
v58 (208) = MOVQstore <mem> [32] v2 v33 v59
v15 (208) = MOVQstoreconst <mem> [val=2,off=40] v2 v58
v61 (208) = MOVQstoreconst <mem> [val=2,off=48] v2 v15
v62 (208) = CALLstatic <mem> {fmt.Fprintf} [80] v61
Ret v62
name format.ptr[*uint8]: v67 
name ~arg1.type[uintptr]: v24 
name ~arg1.data[*uint8]: v23 
name ~arg2.type[uintptr]: v24 
name ~arg2.data[*uint8]: v28

late deadcode

late deadcode [50400 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v51 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v67 (?) = 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_18} v27
v33 (19) = LEAQ <*[2]interface {}> {.autotmp_18} v2
v25 (+19) = MOVOconst <int128> [0]
v30 (+19) = MOVOstore <mem> {.autotmp_18} v2 v25 v32
v34 (+19) = MOVOstore <mem> {.autotmp_18} [16] v2 v25 v30
v39 (19) = MOVQstore <mem> {.autotmp_18} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_18} [8] v2 v23 v39
v46 (19) = MOVQstore <mem> {.autotmp_18} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_18} [24] v2 v28 v46
v54 (+208) = MOVQload <*os.File> {os.Stdout} v3 v42
v53 (208) = MOVQstore <mem> v2 v51 v42
v56 (208) = MOVQstore <mem> [8] v2 v54 v53
v64 (208) = MOVQstore <mem> [16] v2 v67 v56
v59 (208) = MOVQstoreconst <mem> [val=7,off=24] v2 v64
v58 (208) = MOVQstore <mem> [32] v2 v33 v59
v15 (208) = MOVQstoreconst <mem> [val=2,off=40] v2 v58
v61 (208) = MOVQstoreconst <mem> [val=2,off=48] v2 v15
v62 (208) = CALLstatic <mem> {fmt.Fprintf} [80] v61
Ret v62
name format.ptr[*uint8]: v67 
name ~arg1.type[uintptr]: v24 
name ~arg1.data[*uint8]: v23 
name ~arg2.type[uintptr]: v24 
name ~arg2.data[*uint8]: v28

critical

critical [31300 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v51 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v67 (?) = 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_18} v27
v33 (19) = LEAQ <*[2]interface {}> {.autotmp_18} v2
v25 (+19) = MOVOconst <int128> [0]
v30 (+19) = MOVOstore <mem> {.autotmp_18} v2 v25 v32
v34 (+19) = MOVOstore <mem> {.autotmp_18} [16] v2 v25 v30
v39 (19) = MOVQstore <mem> {.autotmp_18} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_18} [8] v2 v23 v39
v46 (19) = MOVQstore <mem> {.autotmp_18} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_18} [24] v2 v28 v46
v54 (+208) = MOVQload <*os.File> {os.Stdout} v3 v42
v53 (208) = MOVQstore <mem> v2 v51 v42
v56 (208) = MOVQstore <mem> [8] v2 v54 v53
v64 (208) = MOVQstore <mem> [16] v2 v67 v56
v59 (208) = MOVQstoreconst <mem> [val=7,off=24] v2 v64
v58 (208) = MOVQstore <mem> [32] v2 v33 v59
v15 (208) = MOVQstoreconst <mem> [val=2,off=40] v2 v58
v61 (208) = MOVQstoreconst <mem> [val=2,off=48] v2 v15
v62 (208) = CALLstatic <mem> {fmt.Fprintf} [80] v61
Ret v62
name format.ptr[*uint8]: v67 
name ~arg1.type[uintptr]: v24 
name ~arg1.data[*uint8]: v23 
name ~arg2.type[uintptr]: v24 
name ~arg2.data[*uint8]: v28

likelyadjust

likelyadjust [21500 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v51 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v67 (?) = 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_18} v27
v33 (19) = LEAQ <*[2]interface {}> {.autotmp_18} v2
v25 (+19) = MOVOconst <int128> [0]
v30 (+19) = MOVOstore <mem> {.autotmp_18} v2 v25 v32
v34 (+19) = MOVOstore <mem> {.autotmp_18} [16] v2 v25 v30
v39 (19) = MOVQstore <mem> {.autotmp_18} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_18} [8] v2 v23 v39
v46 (19) = MOVQstore <mem> {.autotmp_18} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_18} [24] v2 v28 v46
v54 (+208) = MOVQload <*os.File> {os.Stdout} v3 v42
v53 (208) = MOVQstore <mem> v2 v51 v42
v56 (208) = MOVQstore <mem> [8] v2 v54 v53
v64 (208) = MOVQstore <mem> [16] v2 v67 v56
v59 (208) = MOVQstoreconst <mem> [val=7,off=24] v2 v64
v58 (208) = MOVQstore <mem> [32] v2 v33 v59
v15 (208) = MOVQstoreconst <mem> [val=2,off=40] v2 v58
v61 (208) = MOVQstoreconst <mem> [val=2,off=48] v2 v15
v62 (208) = CALLstatic <mem> {fmt.Fprintf} [80] v61
Ret v62
name format.ptr[*uint8]: v67 
name ~arg1.type[uintptr]: v24 
name ~arg1.data[*uint8]: v23 
name ~arg2.type[uintptr]: v24 
name ~arg2.data[*uint8]: v28

layout

layout [25500 ns]

b7:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v51 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v67 (?) = 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_18} v27
v33 (19) = LEAQ <*[2]interface {}> {.autotmp_18} v2
v25 (+19) = MOVOconst <int128> [0]
v30 (+19) = MOVOstore <mem> {.autotmp_18} v2 v25 v32
v34 (+19) = MOVOstore <mem> {.autotmp_18} [16] v2 v25 v30
v39 (19) = MOVQstore <mem> {.autotmp_18} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_18} [8] v2 v23 v39
v46 (19) = MOVQstore <mem> {.autotmp_18} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_18} [24] v2 v28 v46
v54 (+208) = MOVQload <*os.File> {os.Stdout} v3 v42
v53 (208) = MOVQstore <mem> v2 v51 v42
v56 (208) = MOVQstore <mem> [8] v2 v54 v53
v64 (208) = MOVQstore <mem> [16] v2 v67 v56
v59 (208) = MOVQstoreconst <mem> [val=7,off=24] v2 v64
v58 (208) = MOVQstore <mem> [32] v2 v33 v59
v15 (208) = MOVQstoreconst <mem> [val=2,off=40] v2 v58
v61 (208) = MOVQstoreconst <mem> [val=2,off=48] v2 v15
v62 (208) = CALLstatic <mem> {fmt.Fprintf} [80] v61
Ret v62
name format.ptr[*uint8]: v67 
name ~arg1.type[uintptr]: v24 
name ~arg1.data[*uint8]: v23 
name ~arg2.type[uintptr]: v24 
name ~arg2.data[*uint8]: v28

schedule

schedule [33700 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_18} v27
v25 (+19) = MOVOconst <int128> [0]
v30 (+19) = MOVOstore <mem> {.autotmp_18} v2 v25 v32
v34 (+19) = MOVOstore <mem> {.autotmp_18} [16] v2 v25 v30
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v39 (19) = MOVQstore <mem> {.autotmp_18} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_18} [8] v2 v23 v39
v46 (19) = MOVQstore <mem> {.autotmp_18} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_18} [24] v2 v28 v46
v51 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v54 (+208) = MOVQload <*os.File> {os.Stdout} v3 v42
v53 (208) = MOVQstore <mem> v2 v51 v42
v56 (208) = MOVQstore <mem> [8] v2 v54 v53
v67 (?) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v64 (208) = MOVQstore <mem> [16] v2 v67 v56
v59 (208) = MOVQstoreconst <mem> [val=7,off=24] v2 v64
v33 (19) = LEAQ <*[2]interface {}> {.autotmp_18} v2
v58 (208) = MOVQstore <mem> [32] v2 v33 v59
v15 (208) = MOVQstoreconst <mem> [val=2,off=40] v2 v58
v61 (208) = MOVQstoreconst <mem> [val=2,off=48] v2 v15
v62 (208) = CALLstatic <mem> {fmt.Fprintf} [80] v61
Ret v62
name format.ptr[*uint8]: v67 
name ~arg1.type[uintptr]: v24 
name ~arg1.data[*uint8]: v23 
name ~arg2.type[uintptr]: v24 
name ~arg2.data[*uint8]: v28

late nilcheck

late nilcheck [24700 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_18} v27
v25 (+19) = MOVOconst <int128> [0]
v30 (+19) = MOVOstore <mem> {.autotmp_18} v2 v25 v32
v34 (+19) = MOVOstore <mem> {.autotmp_18} [16] v2 v25 v30
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg2.type[uintptr], ~arg1.type[uintptr])
v39 (19) = MOVQstore <mem> {.autotmp_18} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_18} [8] v2 v23 v39
v46 (19) = MOVQstore <mem> {.autotmp_18} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_18} [24] v2 v28 v46
v51 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v54 (+208) = MOVQload <*os.File> {os.Stdout} v3 v42
v53 (208) = MOVQstore <mem> v2 v51 v42
v56 (208) = MOVQstore <mem> [8] v2 v54 v53
v67 (?) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v64 (208) = MOVQstore <mem> [16] v2 v67 v56
v59 (208) = MOVQstoreconst <mem> [val=7,off=24] v2 v64
v33 (19) = LEAQ <*[2]interface {}> {.autotmp_18} v2
v58 (208) = MOVQstore <mem> [32] v2 v33 v59
v15 (208) = MOVQstoreconst <mem> [val=2,off=40] v2 v58
v61 (208) = MOVQstoreconst <mem> [val=2,off=48] v2 v15
v62 (208) = CALLstatic <mem> {fmt.Fprintf} [80] v61
Ret v62
name format.ptr[*uint8]: v67 
name ~arg1.type[uintptr]: v24 
name ~arg1.data[*uint8]: v23 
name ~arg2.type[uintptr]: v24 
name ~arg2.data[*uint8]: v28

flagalloc

flagalloc [27900 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_18} v27
v25 (+19) = MOVOconst <int128> [0]
v30 (+19) = MOVOstore <mem> {.autotmp_18} v2 v25 v32
v34 (+19) = MOVOstore <mem> {.autotmp_18} [16] v2 v25 v30
v3 (?) = SB <uintptr>
v24 (?) = LEAQ <*uint8> {type.int} v3 (~arg1.type[uintptr], ~arg2.type[uintptr])
v39 (19) = MOVQstore <mem> {.autotmp_18} v2 v24 v34
v38 (19) = MOVQstore <mem> {.autotmp_18} [8] v2 v23 v39
v46 (19) = MOVQstore <mem> {.autotmp_18} [16] v2 v24 v38
v42 (19) = MOVQstore <mem> {.autotmp_18} [24] v2 v28 v46
v51 (?) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3
v54 (+208) = MOVQload <*os.File> {os.Stdout} v3 v42
v53 (208) = MOVQstore <mem> v2 v51 v42
v56 (208) = MOVQstore <mem> [8] v2 v54 v53
v67 (?) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 (format.ptr[*uint8])
v64 (208) = MOVQstore <mem> [16] v2 v67 v56
v59 (208) = MOVQstoreconst <mem> [val=7,off=24] v2 v64
v33 (19) = LEAQ <*[2]interface {}> {.autotmp_18} v2
v58 (208) = MOVQstore <mem> [32] v2 v33 v59
v15 (208) = MOVQstoreconst <mem> [val=2,off=40] v2 v58
v61 (208) = MOVQstoreconst <mem> [val=2,off=48] v2 v15
v62 (208) = CALLstatic <mem> {fmt.Fprintf} [80] v61
Ret v62
name format.ptr[*uint8]: v67 
name ~arg1.type[uintptr]: v24 
name ~arg1.data[*uint8]: v23 
name ~arg2.type[uintptr]: v24 
name ~arg2.data[*uint8]: v28

regalloc

regalloc [231600 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_28[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_18} v27
v48 (19) = MOVOconst <int128> [0] : X0
v30 (+19) = MOVOstore <mem> {.autotmp_18} v2 v48 v32
v34 (+19) = MOVOstore <mem> {.autotmp_18} [16] v2 v48 v30
v3 (?) = SB <uintptr> : SB
v55 (19) = LEAQ <*uint8> {type.int} v3 : CX
v39 (19) = MOVQstore <mem> {.autotmp_18} v2 v55 v34
v44 (19) = LoadReg <unsafe.Pointer> v13 : DX
v38 (19) = MOVQstore <mem> {.autotmp_18} [8] v2 v44 v39
v46 (19) = MOVQstore <mem> {.autotmp_18} [16] v2 v55 v38
v42 (19) = MOVQstore <mem> {.autotmp_18} [24] v2 v28 v46
v54 (+208) = MOVQload <*os.File> {os.Stdout} v3 v42 : AX
v12 (208) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3 : CX
v53 (208) = MOVQstore <mem> v2 v12 v42
v56 (208) = MOVQstore <mem> [8] v2 v54 v53
v47 (208) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 : AX
v64 (208) = MOVQstore <mem> [16] v2 v47 v56
v59 (208) = MOVQstoreconst <mem> [val=7,off=24] v2 v64
v36 (208) = LEAQ <*[2]interface {}> {.autotmp_18} v2 : AX
v58 (208) = MOVQstore <mem> [32] v2 v36 v59
v15 (208) = MOVQstoreconst <mem> [val=2,off=40] v2 v58
v61 (208) = MOVQstoreconst <mem> [val=2,off=48] v2 v15
v62 (208) = CALLstatic <mem> {fmt.Fprintf} [80] v61
Ret v62
name format.ptr[*uint8]: v67 
name ~arg1.type[uintptr]: v24 
name ~arg1.data[*uint8]: v23 
name ~arg2.type[uintptr]: v24 
name ~arg2.data[*uint8]: v28

loop rotate

loop rotate [21200 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_28[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_18} v27
v48 (19) = MOVOconst <int128> [0] : X0
v30 (+19) = MOVOstore <mem> {.autotmp_18} v2 v48 v32
v34 (+19) = MOVOstore <mem> {.autotmp_18} [16] v2 v48 v30
v3 (?) = SB <uintptr> : SB
v55 (19) = LEAQ <*uint8> {type.int} v3 : CX
v39 (19) = MOVQstore <mem> {.autotmp_18} v2 v55 v34
v44 (19) = LoadReg <unsafe.Pointer> v13 : DX
v38 (19) = MOVQstore <mem> {.autotmp_18} [8] v2 v44 v39
v46 (19) = MOVQstore <mem> {.autotmp_18} [16] v2 v55 v38
v42 (19) = MOVQstore <mem> {.autotmp_18} [24] v2 v28 v46
v54 (+208) = MOVQload <*os.File> {os.Stdout} v3 v42 : AX
v12 (208) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3 : CX
v53 (208) = MOVQstore <mem> v2 v12 v42
v56 (208) = MOVQstore <mem> [8] v2 v54 v53
v47 (208) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 : AX
v64 (208) = MOVQstore <mem> [16] v2 v47 v56
v59 (208) = MOVQstoreconst <mem> [val=7,off=24] v2 v64
v36 (208) = LEAQ <*[2]interface {}> {.autotmp_18} v2 : AX
v58 (208) = MOVQstore <mem> [32] v2 v36 v59
v15 (208) = MOVQstoreconst <mem> [val=2,off=40] v2 v58
v61 (208) = MOVQstoreconst <mem> [val=2,off=48] v2 v15
v62 (208) = CALLstatic <mem> {fmt.Fprintf} [80] v61
Ret v62
name format.ptr[*uint8]: v67 
name ~arg1.type[uintptr]: v24 
name ~arg1.data[*uint8]: v23 
name ~arg2.type[uintptr]: v24 
name ~arg2.data[*uint8]: v28

stackframe

stackframe [132800 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_28[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_18} v27
v48 (19) = MOVOconst <int128> [0] : X0
v30 (+19) = MOVOstore <mem> {.autotmp_18} v2 v48 v32
v34 (+19) = MOVOstore <mem> {.autotmp_18} [16] v2 v48 v30
v3 (?) = SB <uintptr> : SB
v55 (19) = LEAQ <*uint8> {type.int} v3 : CX
v39 (19) = MOVQstore <mem> {.autotmp_18} v2 v55 v34
v44 (19) = LoadReg <unsafe.Pointer> v13 : DX
v38 (19) = MOVQstore <mem> {.autotmp_18} [8] v2 v44 v39
v46 (19) = MOVQstore <mem> {.autotmp_18} [16] v2 v55 v38
v42 (19) = MOVQstore <mem> {.autotmp_18} [24] v2 v28 v46
v54 (+208) = MOVQload <*os.File> {os.Stdout} v3 v42 : AX
v12 (208) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3 : CX
v53 (208) = MOVQstore <mem> v2 v12 v42
v56 (208) = MOVQstore <mem> [8] v2 v54 v53
v47 (208) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 : AX
v64 (208) = MOVQstore <mem> [16] v2 v47 v56
v59 (208) = MOVQstoreconst <mem> [val=7,off=24] v2 v64
v36 (208) = LEAQ <*[2]interface {}> {.autotmp_18} v2 : AX
v58 (208) = MOVQstore <mem> [32] v2 v36 v59
v15 (208) = MOVQstoreconst <mem> [val=2,off=40] v2 v58
v61 (208) = MOVQstoreconst <mem> [val=2,off=48] v2 v15
v62 (208) = CALLstatic <mem> {fmt.Fprintf} [80] v61
Ret v62
name format.ptr[*uint8]: v67 
name ~arg1.type[uintptr]: v24 
name ~arg1.data[*uint8]: v23 
name ~arg2.type[uintptr]: v24 
name ~arg2.data[*uint8]: v28

trim

trim [22100 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_28[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_18} v27
v48 (19) = MOVOconst <int128> [0] : X0
v30 (+19) = MOVOstore <mem> {.autotmp_18} v2 v48 v32
v34 (+19) = MOVOstore <mem> {.autotmp_18} [16] v2 v48 v30
v3 (?) = SB <uintptr> : SB
v55 (19) = LEAQ <*uint8> {type.int} v3 : CX
v39 (19) = MOVQstore <mem> {.autotmp_18} v2 v55 v34
v44 (19) = LoadReg <unsafe.Pointer> v13 : DX
v38 (19) = MOVQstore <mem> {.autotmp_18} [8] v2 v44 v39
v46 (19) = MOVQstore <mem> {.autotmp_18} [16] v2 v55 v38
v42 (19) = MOVQstore <mem> {.autotmp_18} [24] v2 v28 v46
v54 (+208) = MOVQload <*os.File> {os.Stdout} v3 v42 : AX
v12 (208) = LEAQ <*uint8> {go.itab.*os.File,io.Writer} v3 : CX
v53 (208) = MOVQstore <mem> v2 v12 v42
v56 (208) = MOVQstore <mem> [8] v2 v54 v53
v47 (208) = LEAQ <*uint8> {go.string."%d, %d\n"} v3 : AX
v64 (208) = MOVQstore <mem> [16] v2 v47 v56
v59 (208) = MOVQstoreconst <mem> [val=7,off=24] v2 v64
v36 (208) = LEAQ <*[2]interface {}> {.autotmp_18} v2 : AX
v58 (208) = MOVQstore <mem> [32] v2 v36 v59
v15 (208) = MOVQstoreconst <mem> [val=2,off=40] v2 v58
v61 (208) = MOVQstoreconst <mem> [val=2,off=48] v2 v15
v62 (208) = CALLstatic <mem> {fmt.Fprintf} [80] v61
Ret v62
name format.ptr[*uint8]: v67 
name ~arg1.type[uintptr]: v24 
name ~arg1.data[*uint8]: v23 
name ~arg2.type[uintptr]: v24 
name ~arg2.data[*uint8]: v28

genssa

genssa


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