mapImplementation

help

Click on a value or block to toggle highlighting of that value/block and its uses. (Values and blocks are highlighted by ID, and IDs of dead items may be reused, so not all highlights necessarily correspond to the clicked item.)

Faded out values and blocks are dead code that has not been eliminated.

Values printed in italics have a dependency cycle.

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

 
benchmark_test.go
func mapImplementation() int {
	return map[string]int{
		"amd64": 0,
		"arm":   1,
		"arm64": 2,
	}[runtime.GOARCH]
}

AST

buildssa-enter

. AS l(31)

. . NAME-benchmark.~r0 g(1) l(31) x(0) class(PPARAMOUT) esc(no) int

buildssa-body

. RETURN l(32) tc(1)

. RETURN-list

. . AS l(36) tc(1)

. . . NAME-benchmark.~r0 g(1) l(31) x(0) class(PPARAMOUT) esc(no) int

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

buildssa-exit

start

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = LocalAddr <*int> {~r0} v2 v1
v5 (?) = Const64 <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (32) = Store <mem> {int} v4 v5 v6
Ret v7 (+33)

number lines

number lines [3201 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = LocalAddr <*int> {~r0} v2 v1
v5 (?) = Const64 <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = Store <mem> {int} v4 v5 v6
Ret v7 (+33)

early phielim

early phielim [559 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = LocalAddr <*int> {~r0} v2 v1
v5 (?) = Const64 <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = Store <mem> {int} v4 v5 v6
Ret v7 (+33)

early copyelim

early copyelim [555 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = LocalAddr <*int> {~r0} v2 v1
v5 (?) = Const64 <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = Store <mem> {int} v4 v5 v6
Ret v7 (+33)

early deadcode

early deadcode [3121 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v4 (?) = LocalAddr <*int> {~r0} v2 v1
v5 (?) = Const64 <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = Store <mem> {int} v4 v5 v6
Ret v7 (+33)

short circuit

short circuit [632 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v4 (?) = LocalAddr <*int> {~r0} v2 v1
v5 (?) = Const64 <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = Store <mem> {int} v4 v5 v6
Ret v7 (+33)

decompose args

decompose args [2172 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v4 (?) = LocalAddr <*int> {~r0} v2 v1
v5 (?) = Const64 <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = Store <mem> {int} v4 v5 v6
Ret v7 (+33)

decompose user

decompose user [385 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v4 (?) = LocalAddr <*int> {~r0} v2 v1
v5 (?) = Const64 <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = Store <mem> {int} v4 v5 v6
Ret v7 (+33)

pre-opt deadcode

pre-opt deadcode [2311 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v4 (?) = LocalAddr <*int> {~r0} v2 v1
v5 (?) = Const64 <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = Store <mem> {int} v4 v5 v6
Ret v7 (+33)

opt

opt [2507 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v4 (?) = LocalAddr <*int> {~r0} v2 v1
v5 (?) = Const64 <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = Store <mem> {int} v4 v5 v6
Ret v7 (+33)

zero arg cse

zero arg cse [2720 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v4 (?) = LocalAddr <*int> {~r0} v2 v1
v5 (?) = Const64 <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = Store <mem> {int} v4 v5 v6
Ret v7 (+33)

opt deadcode

opt deadcode [1824 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v4 (?) = LocalAddr <*int> {~r0} v2 v1
v5 (?) = Const64 <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = Store <mem> {int} v4 v5 v6
Ret v7 (+33)

generic cse

generic cse [6126 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v4 (?) = LocalAddr <*int> {~r0} v2 v1
v5 (?) = Const64 <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = Store <mem> {int} v4 v5 v6
Ret v7 (+33)

phiopt

phiopt [328 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v4 (?) = LocalAddr <*int> {~r0} v2 v1
v5 (?) = Const64 <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = Store <mem> {int} v4 v5 v6
Ret v7 (+33)

gcse deadcode

gcse deadcode [1868 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v4 (?) = LocalAddr <*int> {~r0} v2 v1
v5 (?) = Const64 <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = Store <mem> {int} v4 v5 v6
Ret v7 (+33)

nilcheckelim

nilcheckelim [3293 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v4 (?) = LocalAddr <*int> {~r0} v2 v1
v5 (?) = Const64 <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = Store <mem> {int} v4 v5 v6
Ret v7 (+33)

prove

prove [4996 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v4 (?) = LocalAddr <*int> {~r0} v2 v1
v5 (?) = Const64 <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = Store <mem> {int} v4 v5 v6
v3 (?) = Const64 <int64> [0]
Ret v7 (+33)

fuse plain

fuse plain [397 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v4 (?) = LocalAddr <*int> {~r0} v2 v1
v5 (?) = Const64 <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = Store <mem> {int} v4 v5 v6
v3 (?) = Const64 <int64> [0]
Ret v7 (+33)

decompose builtin

decompose builtin [2178 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v4 (?) = LocalAddr <*int> {~r0} v2 v1
v5 (?) = Const64 <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = Store <mem> {int} v4 v5 v6
v3 (?) = Const64 <int64> [0]
Ret v7 (+33)

softfloat

softfloat [312 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v4 (?) = LocalAddr <*int> {~r0} v2 v1
v5 (?) = Const64 <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = Store <mem> {int} v4 v5 v6
v3 (?) = Const64 <int64> [0]
Ret v7 (+33)

late opt

late opt [2018 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v4 (?) = LocalAddr <*int> {~r0} v2 v1
v5 (?) = Const64 <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = Store <mem> {int} v4 v5 v6
v3 (?) = Const64 <int64> [0]
Ret v7 (+33)

dead auto elim

dead auto elim [1279 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v4 (?) = LocalAddr <*int> {~r0} v2 v1
v5 (?) = Const64 <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = Store <mem> {int} v4 v5 v6
v3 (?) = Const64 <int64> [0]
Ret v7 (+33)

generic deadcode

generic deadcode [2580 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v4 (?) = LocalAddr <*int> {~r0} v2 v1
v5 (?) = Const64 <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = Store <mem> {int} v4 v5 v6
Ret v7 (+33)

check bce

check bce [293 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v4 (?) = LocalAddr <*int> {~r0} v2 v1
v5 (?) = Const64 <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = Store <mem> {int} v4 v5 v6
Ret v7 (+33)

branchelim

branchelim [1216 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v4 (?) = LocalAddr <*int> {~r0} v2 v1
v5 (?) = Const64 <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = Store <mem> {int} v4 v5 v6
Ret v7 (+33)

fuse

fuse [408 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v4 (?) = LocalAddr <*int> {~r0} v2 v1
v5 (?) = Const64 <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = Store <mem> {int} v4 v5 v6
Ret v7 (+33)

dse

dse [2626 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v4 (?) = LocalAddr <*int> {~r0} v2 v1
v5 (?) = Const64 <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = Store <mem> {int} v4 v5 v6
Ret v7 (+33)

writebarrier

writebarrier [1894 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v4 (?) = LocalAddr <*int> {~r0} v2 v1
v5 (?) = Const64 <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = Store <mem> {int} v4 v5 v6
Ret v7 (+33)

lower

lower [5512 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v4 (?) = LEAQ <*int> {~r0} v2
v5 (?) = MOVQconst <int> [0]
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = MOVQstoreconst <mem> {~r0} [val=0,off=0] v2 v6
Ret v7 (+33)

lowered deadcode for cse

lowered deadcode for cse [2466 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = MOVQstoreconst <mem> {~r0} [val=0,off=0] v2 v6
Ret v7 (+33)

lowered cse

lowered cse [2904 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = MOVQstoreconst <mem> {~r0} [val=0,off=0] v2 v6
Ret v7 (+33)

elim unread autos

elim unread autos [729 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = MOVQstoreconst <mem> {~r0} [val=0,off=0] v2 v6
Ret v7 (+33)

lowered deadcode

lowered deadcode [1687 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = MOVQstoreconst <mem> {~r0} [val=0,off=0] v2 v6
Ret v7 (+33)

checkLower

checkLower [601 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = MOVQstoreconst <mem> {~r0} [val=0,off=0] v2 v6
Ret v7 (+33)

late phielim

late phielim [435 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = MOVQstoreconst <mem> {~r0} [val=0,off=0] v2 v6
Ret v7 (+33)

late copyelim

late copyelim [376 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = MOVQstoreconst <mem> {~r0} [val=0,off=0] v2 v6
Ret v7 (+33)

tighten

tighten [4426 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = MOVQstoreconst <mem> {~r0} [val=0,off=0] v2 v6
Ret v7 (+33)

late deadcode

late deadcode [2182 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = MOVQstoreconst <mem> {~r0} [val=0,off=0] v2 v6
Ret v7 (+33)

critical

critical [869 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = MOVQstoreconst <mem> {~r0} [val=0,off=0] v2 v6
Ret v7 (+33)

phi tighten

phi tighten [303 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = MOVQstoreconst <mem> {~r0} [val=0,off=0] v2 v6
Ret v7 (+33)

likelyadjust

likelyadjust [2027 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = MOVQstoreconst <mem> {~r0} [val=0,off=0] v2 v6
Ret v7 (+33)

layout

layout [28770 ns]

b1:
v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v6 (32) = VarDef <mem> {~r0} v1
v7 (+32) = MOVQstoreconst <mem> {~r0} [val=0,off=0] v2 v6
Ret v7 (+33)

schedule

schedule [11076 ns]

b1:
v1 (?) = InitMem <mem>
v6 (32) = VarDef <mem> {~r0} v1
v2 (?) = SP <uintptr>
v7 (+32) = MOVQstoreconst <mem> {~r0} [val=0,off=0] v2 v6
Ret v7 (+33)

late nilcheck

late nilcheck [3404 ns]

b1:
v1 (?) = InitMem <mem>
v6 (32) = VarDef <mem> {~r0} v1
v2 (?) = SP <uintptr>
v7 (+32) = MOVQstoreconst <mem> {~r0} [val=0,off=0] v2 v6
Ret v7 (+33)

flagalloc

flagalloc [3437 ns]

b1:
v1 (?) = InitMem <mem>
v6 (32) = VarDef <mem> {~r0} v1
v2 (?) = SP <uintptr>
v7 (+32) = MOVQstoreconst <mem> {~r0} [val=0,off=0] v2 v6
Ret v7 (+33)

regalloc

regalloc [31639 ns]

b1:
v1 (?) = InitMem <mem>
v6 (32) = VarDef <mem> {~r0} v1
v2 (?) = SP <uintptr> : SP
v7 (+32) = MOVQstoreconst <mem> {~r0} [val=0,off=0] v2 v6
Ret v7 (+33)

loop rotate

loop rotate [291 ns]

b1:
v1 (?) = InitMem <mem>
v6 (32) = VarDef <mem> {~r0} v1
v2 (?) = SP <uintptr> : SP
v7 (+32) = MOVQstoreconst <mem> {~r0} [val=0,off=0] v2 v6
Ret v7 (+33)

stackframe

stackframe [1937 ns]

b1:
v1 (?) = InitMem <mem>
v6 (32) = VarDef <mem> {~r0} v1
v2 (?) = SP <uintptr> : SP
v7 (+32) = MOVQstoreconst <mem> {~r0} [val=0,off=0] v2 v6
Ret v7 (+33)

trim

trim [424 ns]

b1:
v1 (?) = InitMem <mem>
v6 (32) = VarDef <mem> {~r0} v1
v2 (?) = SP <uintptr> : SP
v7 (+32) = MOVQstoreconst <mem> {~r0} [val=0,off=0] v2 v6
Ret v7 (+33)

genssa


# benchmark_test.go
00000 (31) TEXT	"".mapImplementation(SB), ABIInternal
00001 (31) PCDATA	$0, $-2
00002 (31) PCDATA	$1, $-2
00003 (31) FUNCDATA	$0, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
00004 (31) FUNCDATA	$1, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
00005 (31) FUNCDATA	$2, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
v7
00006 (+32) PCDATA	$0, $0
v7
00007 (+32) PCDATA	$1, $0
v7
00008 (+32) MOVQ	$0, "".~r0(SP)
b1
00009 (+33) RET
00010 (?) END