main

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.

start

  • b1:
    • v1 (?) = InitMem <mem>
    • v2 (?) = SP <uintptr>
    • v3 (?) = SB <uintptr>
    • v4 (111) = GetG <*g> v1 (g[*g])
    • v5 (?) = Const64 <uintptr> [0]
    • v6 (115) = NilCheck <void> v4 v1
    • v7 (115) = OffPtr <**m> [48] v4
    • v8 (115) = Load <*m> v7 v1
    • v9 (115) = NilCheck <void> v8 v1
    • v10 (115) = OffPtr <**g> [0] v8
    • v11 (115) = Load <*g> v10 v1
    • v12 (115) = NilCheck <void> v11 v1
    • v13 (115) = OffPtr <*uintptr> [304] v11
    • v14 (115) = Store <mem> {uintptr} v13 v5 v1
    • v15 (?) = ConstBool <bool> [true]
    • v16 (?) = Const64 <uintptr> [1000000000]
    • v17 (?) = Addr <*uintptr> {"".maxstacksize} v3
    • v20 (?) = Addr <*bool> {"".mainStarted} v3
    • v23 (?) = Addr <*func()> {"".main.func1·f} v3
    • v24 (?) = OffPtr <*func()> [0] v2
    • v36 (?) = Const32 <uint32> [1]
    • v44 (?) = ConstBool <bool> [false]
    • v72 (?) = Addr <*m> {"".m0} v3
    • v74 (?) = ConstString <string> {"runtime.main not on m0"}
    • v75 (?) = OffPtr <*string> [0] v2
    • v82 (?) = OffPtr <*int64> [0] v2
    • v84 (?) = Const64 <int64> [0]
    • v86 (?) = ConstString <string> {"nanotime returning zero"}
    • v94 (?) = Addr <*func(*bool)> {"".main.func2·f} v3
    • v96 (?) = OffPtr <**bool> [16] v2
    • v98 (?) = Const32 <uint32> [8]
    • v99 (?) = OffPtr <*uint32> [0] v2
    • v101 (?) = OffPtr <*uintptr> [8] v2
    • v109 (?) = Addr <*int64> {"".runtimeInitTime} v3
    • v112 (?) = Addr <*uint8> {type.chan bool} v3
    • v113 (?) = OffPtr <**byte> [0] v2
    • v115 (?) = Const64 <int> [0] (c[int])
    • v116 (?) = OffPtr <*int> [8] v2
    • v119 (?) = OffPtr <*chan bool> [16] v2
    • v121 (?) = Addr <*chan bool> {"".main_init_done} v3
    • v123 (?) = Addr <*bool> {"".iscgo} v3
    • v125 (?) = Addr <*unsafe.Pointer> {_cgo_thread_start} v3
    • v128 (?) = Const64 <unsafe.Pointer> [0]
    • v130 (?) = ConstString <string> {"_cgo_thread_start missing"}
    • v134 (?) = Addr <*unsafe.Pointer> {""._cgo_setenv} v3
    • v138 (?) = ConstString <string> {"_cgo_setenv missing"}
    • v142 (?) = Addr <*unsafe.Pointer> {""._cgo_unsetenv} v3
    • v146 (?) = ConstString <string> {"_cgo_unsetenv missing"}
    • v150 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
    • v154 (?) = ConstString <string> {"_cgo_notify_runtime_init_done missing"}
    • v160 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
    • v162 (?) = OffPtr <*unsafe.Pointer> [0] v2
    • v164 (?) = OffPtr <*unsafe.Pointer> [8] v2
    • v167 (?) = OffPtr <*int32> [16] v2
    • v168 (?) = Addr <*func()> {"".main_init·f} v3 (fn[func()])
    • v172 (?) = Addr <*chan bool> {"".main_init_done} v3
    • v174 (?) = OffPtr <*chan bool> [0] v2
    • v181 (?) = Addr <*bool> {"".isarchive} v3
    • v183 (?) = Addr <*bool> {"".islibrary} v3
    • v188 (?) = Addr <*func()> {"".main_main·f} v3 (fn[func()])
    • v192 (?) = Addr <*uint32> {"".runningPanicDefers} v3
    • v197 (?) = Const32 <uint32> [0]
    • v200 (?) = Const64 <int> [1000]
    • v202 (?) = Addr <*uint32> {"".runningPanicDefers} v3
    • v211 (?) = Const64 <int> [1]
    • v213 (?) = Addr <*uint32> {"".panicking} v3
    • v219 (?) = ConstNil <func(*g, unsafe.Pointer) bool>
    • v220 (?) = OffPtr <*func(*g, unsafe.Pointer) bool> [0] v2
    • v224 (?) = Const8 <waitReason> [8]
    • v225 (?) = OffPtr <*waitReason> [16] v2
    • v227 (?) = Const8 <byte> [16]
    • v228 (?) = OffPtr <*byte> [17] v2
    • v230 (?) = OffPtr <*int> [24] v2
    • v233 (?) = Const32 <int32> [0]
    • v234 (?) = OffPtr <*int32> [0] v2
    • v238 (?) = ConstNil <*int32> (x[*int32])
  • If v15b2 b3 (line 120)
  • b2: ← b1
    • v18 (121) = Copy <mem> v14
    • v19 (121) = Store <mem> {uintptr} v17 v16 v18
  • Plainb3 (line 121)
  • b3: ← b1 b2
    • v21 (127) = Phi <mem> v14 v19
    • v22 (127) = Store <mem> {bool} v20 v15 v21
    • v249 (143) = Copy <*g> v4 (g[*g])
  • If v15b4 b5 (line 129)
  • b4: ← b3
    • v25 (130) = Copy <mem> v22
    • v26 (130) = Store <mem> {func()} v24 v23 v25
    • v27 (130) = StaticCall <mem> {"".systemstack} [8] v26
  • Plainb5 (line 130)
  • b5: ← b3 b4
    • v28 (3614) = Phi <mem> v22 v27
    • v29 (3614) = GetG <*g> v28
    • v30 (3614) = NilCheck <void> v29 v28
    • v31 (3614) = OffPtr <**m> [48] v29
    • v32 (3614) = Load <*m> v31 v28
    • v33 (3614) = NilCheck <void> v32 v28
    • v34 (3614) = OffPtr <*uint32> [620] v32
    • v35 (3614) = Load <uint32> v34 v28
    • v37 (3614) = Add32 <uint32> v35 v36
    • v38 (3614) = NilCheck <void> v29 v28
    • v39 (3614) = OffPtr <**m> [48] v29
    • v40 (3614) = Load <*m> v39 v28
    • v41 (3614) = NilCheck <void> v40 v28
    • v42 (3614) = OffPtr <*uint32> [620] v40
    • v43 (3614) = Store <mem> {uint32} v42 v37 v28
    • v248 (143) = Copy <*g> v249 (g[*g])
  • If v44b6 b7 (line 3572)
  • b6: ← b5
  • Plainb7 (line 3575)
  • b7: ← b5 b6
    • v45 (3575) = Copy <mem> v43
    • v46 (3575) = GetG <*g> v45 (_g_[*g], g[*g])
    • v47 (3576) = NilCheck <void> v46 v45
    • v48 (3576) = OffPtr <**m> [48] v46
    • v49 (3576) = Load <*m> v48 v45
    • v50 (3576) = NilCheck <void> v49 v45
    • v51 (3576) = OffPtr <*guintptr> [352] v49 (gp[*guintptr])
    • v52 (205) = Copy <unsafe.Pointer> v46
    • v53 (205) = Convert <guintptr> v52 v45
    • v54 (205) = NilCheck <void> v51 v45
    • v55 (205) = Store <mem> {guintptr} v51 v53 v45
    • v247 (143) = Copy <*g> v248 (g[*g])
  • Plainb8 (line 3576)
  • b8: ← b7
    • v56 (3577) = Copy <*g> v46 (_g_[*g])
    • v57 (3577) = Copy <mem> v55
    • v58 (3577) = NilCheck <void> v56 v57
    • v59 (3577) = OffPtr <*muintptr> [216] v56 (mp[*muintptr])
    • v60 (3577) = NilCheck <void> v56 v57
    • v61 (3577) = OffPtr <**m> [48] v56
    • v62 (3577) = Load <*m> v61 v57 (m[*m])
    • v63 (243) = Copy <unsafe.Pointer> v62
    • v64 (243) = Convert <muintptr> v63 v57
    • v65 (243) = NilCheck <void> v59 v57
    • v66 (243) = Store <mem> {muintptr} v59 v64 v57
  • Plainb9 (line 3577)
  • b9: ← b8
  • Plainb10 (line 143)
  • b10: ← b9
  • Plainb11 (line 143)
  • b11: ← b10
    • v67 (143) = Copy <*g> v247 (g[*g])
    • v68 (143) = Copy <mem> v66
    • v69 (143) = NilCheck <void> v67 v68
    • v70 (143) = OffPtr <**m> [48] v67
    • v71 (143) = Load <*m> v70 v68
    • v73 (143) = NeqPtr <bool> v71 v72
  • If v73b12 b13 (line 143)
  • b12: ← b11
    • v76 (144) = Copy <mem> v68
    • v77 (144) = Store <mem> {string} v75 v74 v76
    • v78 (144) = StaticCall <mem> {"".throw} [16] v77
  • Exit v78 (line 144)
  • b13: ← b11
    • v79 (147) = Copy <mem> v68
    • v80 (147) = StaticCall <mem> {runtime.init} v79
    • v81 (148) = StaticCall <mem> {"".nanotime} [8] v80
    • v83 (148) = Load <int64> v82 v81
    • v85 (148) = Eq64 <bool> v83 v84
  • If v85b14 b16 (line 148)
  • b14: ← b13
    • v87 (149) = Copy <mem> v81
    • v88 (149) = Store <mem> {string} v75 v86 v87
    • v89 (149) = StaticCall <mem> {"".throw} [16] v88
  • Exit v89 (line 149)
  • b15: ← b16
    • v90 (153) = Copy <mem> v81
    • v91 (153) = VarDef <mem> {needUnlock} v90
    • v92 (153) = LocalAddr <*bool> {needUnlock} v2 v91
    • v93 (153) = Store <mem> {bool} v92 v15 v91
    • v95 (154) = LocalAddr <*bool> {needUnlock} v2 v93
    • v97 (158) = Store <mem> {*bool} v96 v95 v93
    • v100 (154) = Store <mem> {uint32} v99 v98 v97
    • v102 (154) = Store <mem> {uintptr} v101 v94 v100
    • v103 (154) = StaticCall <mem> {runtime.deferproc} [24] v102
  • Defer v103b17 b18 (likely) (line 154)
  • b16: ← b13
  • Plainb15 (line 153)
  • b17: ← b15
    • v106 (162) = Copy <mem> v103
    • v107 (162) = StaticCall <mem> {"".nanotime} [8] v106
    • v108 (162) = Load <int64> v82 v107
    • v110 (162) = Store <mem> {int64} v109 v108 v107
    • v111 (164) = StaticCall <mem> {"".gcenable} v110
    • v114 (166) = Store <mem> {*byte} v113 v112 v111
    • v117 (166) = Store <mem> {int} v116 v115 v114
    • v118 (166) = StaticCall <mem> {runtime.makechan} [24] v117
    • v120 (166) = Load <chan bool> v119 v118
    • v122 (166) = Store <mem> {chan bool} v121 v120 v118
    • v124 (167) = Load <bool> v123 v122
  • If v124b19 b20 (line 167)
  • b18: ← b15
    • v104 (154) = Copy <mem> v103
    • v105 (154) = StaticCall <mem> {runtime.deferreturn} v104
  • Ret v105 (line 154)
  • b19: ← b17
    • v126 (168) = Copy <mem> v122
    • v127 (168) = Load <unsafe.Pointer> v125 v126
    • v129 (168) = EqPtr <bool> v127 v128
  • If v129b21 b22 (line 168)
  • b20: ← b17 b30
    • v169 (189) = Phi <mem> v122 v166
    • v170 (189) = Load <uintptr> v168 v169
    • v171 (189) = ClosureCall <mem> [0] v170 v168 v169
    • v173 (190) = Load <chan bool> v172 v171
    • v175 (190) = Store <mem> {chan bool} v174 v173 v171
    • v176 (190) = StaticCall <mem> {runtime.closechan} [8] v175
    • v177 (192) = VarDef <mem> {needUnlock} v176
    • v178 (192) = LocalAddr <*bool> {needUnlock} v2 v177
    • v179 (192) = Store <mem> {bool} v178 v44 v177
    • v180 (193) = StaticCall <mem> {"".unlockOSThread} v179
    • v182 (195) = Load <bool> v181 v180
  • If v182b31 b33 (line 195)
  • b21: ← b19
    • v131 (169) = Copy <mem> v126
    • v132 (169) = Store <mem> {string} v75 v130 v131
    • v133 (169) = StaticCall <mem> {"".throw} [16] v132
  • Exit v133 (line 169)
  • b22: ← b19
  • If v15b23 b24
  • b23: ← b22
    • v135 (172) = Copy <mem> v126
    • v136 (172) = Load <unsafe.Pointer> v134 v135
    • v137 (172) = EqPtr <bool> v136 v128
  • If v137b25 b26 (line 172)
  • b24: ← b22 b28
    • v151 (179) = Phi <mem> v126 v143
    • v152 (179) = Load <unsafe.Pointer> v150 v151
    • v153 (179) = EqPtr <bool> v152 v128
  • If v153b29 b30 (line 179)
  • b25: ← b23
    • v139 (173) = Copy <mem> v135
    • v140 (173) = Store <mem> {string} v75 v138 v139
    • v141 (173) = StaticCall <mem> {"".throw} [16] v140
  • Exit v141 (line 173)
  • b26: ← b23
    • v143 (175) = Copy <mem> v135
    • v144 (175) = Load <unsafe.Pointer> v142 v143
    • v145 (175) = EqPtr <bool> v144 v128
  • If v145b27 b28 (line 175)
  • b27: ← b26
    • v147 (176) = Copy <mem> v143
    • v148 (176) = Store <mem> {string} v75 v146 v147
    • v149 (176) = StaticCall <mem> {"".throw} [16] v148
  • Exit v149 (line 176)
  • b28: ← b26
  • Plainb24 (line 179)
  • b29: ← b24
    • v155 (180) = Copy <mem> v151
    • v156 (180) = Store <mem> {string} v75 v154 v155
    • v157 (180) = StaticCall <mem> {"".throw} [16] v156
  • Exit v157 (line 180)
  • b30: ← b24
    • v158 (184) = Copy <mem> v151
    • v159 (184) = StaticCall <mem> {"".startTemplateThread} v158
    • v161 (185) = Load <unsafe.Pointer> v160 v159
    • v163 (185) = Store <mem> {unsafe.Pointer} v162 v161 v159
    • v165 (185) = Store <mem> {unsafe.Pointer} v164 v128 v163
    • v166 (185) = StaticCall <mem> {"".cgocall} [24] v165
  • Plainb20 (line 185)
  • b31: ← b20 b33
    • v186 (198) = Phi <mem> v180 v184
    • v187 (198) = StaticCall <mem> {runtime.deferreturn} v186
  • Ret v187 (line +198)
  • b32: ← b33
    • v189 (201) = Copy <mem> v184
    • v190 (201) = Load <uintptr> v188 v189
    • v191 (201) = ClosureCall <mem> [0] v190 v188 v189
  • If v44b34 b35 (line 202)
  • b33: ← b20
    • v184 (195) = Copy <mem> v180
    • v185 (195) = Load <bool> v183 v184
  • If v185b31 b32 (line 195)
  • b34: ← b32
  • Plainb35 (line 210)
  • b35: ← b32 b34
    • v193 (210) = Copy <mem> v191
    • v194 (210) = AtomicLoad32 <uint32,mem> v192 v193
    • v195 (210) = Select1 <mem> v194
    • v196 (210) = Select0 <uint32> v194
    • v198 (210) = Neq32 <bool> v196 v197
  • If v198b36 b38 (line 210)
  • b36: ← b35
  • Plainb39 (line 212)
  • b37: ← b42 b38
    • v214 (219) = Phi <mem> v246 v195
    • v215 (219) = AtomicLoad32 <uint32,mem> v213 v214
    • v216 (219) = Select1 <mem> v215
    • v217 (219) = Select0 <uint32> v215
    • v218 (219) = Neq32 <bool> v217 v197
  • If v218b46 b48 (line 219)
  • b38: ← b35
  • Plainb37 (line 219)
  • b39: ← b36 b41
    • v199 (212) = Phi <int> v115 v212 (c[int])
    • v245 (213) = Phi <mem> v195 v209
    • v201 (212) = Less64 <bool> v199 v200
  • If v201b40 b42 (likely) (line 212)
  • b40: ← b39
    • v203 (213) = Copy <mem> v245
    • v204 (213) = AtomicLoad32 <uint32,mem> v202 v203
    • v205 (213) = Select1 <mem> v204
    • v206 (213) = Select0 <uint32> v204
    • v207 (213) = Eq32 <bool> v206 v197
  • If v207b43 b45 (line 213)
  • b41: ← b44
    • v210 (212) = Copy <int> v199 (c[int])
    • v212 (212) = Add64 <int> v210 v211 (c[int])
  • Plainb39 (line 212)
  • b42: ← b39 b43
    • v246 (219) = Phi <mem> v245 v205
  • Plainb37 (line 219)
  • b43: ← b40
  • Plainb42 (line +214)
  • b44: ← b45
    • v208 (216) = Copy <mem> v205
    • v209 (216) = StaticCall <mem> {"".Gosched} v208
  • Plainb41 (line 216)
  • b45: ← b40
  • Plainb44 (line 216)
  • b46: ← b37
    • v221 (220) = Copy <mem> v216
    • v222 (220) = Store <mem> {func(*g, unsafe.Pointer) bool} v220 v219 v221
    • v223 (220) = Store <mem> {unsafe.Pointer} v164 v128 v222
    • v226 (220) = Store <mem> {waitReason} v225 v224 v223
    • v229 (220) = Store <mem> {byte} v228 v227 v226
    • v231 (220) = Store <mem> {int} v230 v211 v229
    • v232 (220) = StaticCall <mem> {"".gopark} [32] v231
  • Plainb47 (line 220)
  • b47: ← b46 b48
    • v235 (223) = Phi <mem> v232 v216
    • v236 (223) = Store <mem> {int32} v234 v233 v235
    • v237 (223) = StaticCall <mem> {"".exit} [8] v236
  • Plainb49 (line 224)
  • b48: ← b37
  • Plainb47 (line 223)
  • b49: ← b47 b51
    • v244 (226) = Phi <mem> v237 v241
  • Plainb50 (line 226)
  • b50: ← b49
    • v239 (226) = Copy <mem> v244
    • v240 (226) = NilCheck <void> v238 v239
    • v241 (226) = Store <mem> {int32} v238 v233 v239
  • Plainb51 (line 226)
  • b51: ← b50
  • Plainb49 (line 226)
  • b52:
    • v242 (228) = Unknown <mem>
    • v243 (228) = StaticCall <mem> {runtime.deferreturn} v242
  • Ret v243 (line 228)
  • name g[*g]: v4 v67 v247 v248 v249
  • name _g_[*g]: v46 v56
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v210 v212
  • name x[*int32]: v238
  • number lines [53608 ns]

    • b1:
      • v1 (?) = InitMem <mem>
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v4 (+111) = GetG <*g> v1 (g[*g])
      • v5 (?) = Const64 <uintptr> [0]
      • v6 (+115) = NilCheck <void> v4 v1
      • v7 (115) = OffPtr <**m> [48] v4
      • v8 (115) = Load <*m> v7 v1
      • v9 (115) = NilCheck <void> v8 v1
      • v10 (115) = OffPtr <**g> [0] v8
      • v11 (115) = Load <*g> v10 v1
      • v12 (115) = NilCheck <void> v11 v1
      • v13 (115) = OffPtr <*uintptr> [304] v11
      • v14 (115) = Store <mem> {uintptr} v13 v5 v1
      • v15 (?) = ConstBool <bool> [true]
      • v16 (?) = Const64 <uintptr> [1000000000]
      • v17 (?) = Addr <*uintptr> {"".maxstacksize} v3
      • v20 (?) = Addr <*bool> {"".mainStarted} v3
      • v23 (?) = Addr <*func()> {"".main.func1·f} v3
      • v24 (?) = OffPtr <*func()> [0] v2
      • v36 (?) = Const32 <uint32> [1]
      • v44 (?) = ConstBool <bool> [false]
      • v72 (?) = Addr <*m> {"".m0} v3
      • v74 (?) = ConstString <string> {"runtime.main not on m0"}
      • v75 (?) = OffPtr <*string> [0] v2
      • v82 (?) = OffPtr <*int64> [0] v2
      • v84 (?) = Const64 <int64> [0]
      • v86 (?) = ConstString <string> {"nanotime returning zero"}
      • v94 (?) = Addr <*func(*bool)> {"".main.func2·f} v3
      • v96 (?) = OffPtr <**bool> [16] v2
      • v98 (?) = Const32 <uint32> [8]
      • v99 (?) = OffPtr <*uint32> [0] v2
      • v101 (?) = OffPtr <*uintptr> [8] v2
      • v109 (?) = Addr <*int64> {"".runtimeInitTime} v3
      • v112 (?) = Addr <*uint8> {type.chan bool} v3
      • v113 (?) = OffPtr <**byte> [0] v2
      • v115 (?) = Const64 <int> [0] (c[int])
      • v116 (?) = OffPtr <*int> [8] v2
      • v119 (?) = OffPtr <*chan bool> [16] v2
      • v121 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v123 (?) = Addr <*bool> {"".iscgo} v3
      • v125 (?) = Addr <*unsafe.Pointer> {_cgo_thread_start} v3
      • v128 (?) = Const64 <unsafe.Pointer> [0]
      • v130 (?) = ConstString <string> {"_cgo_thread_start missing"}
      • v134 (?) = Addr <*unsafe.Pointer> {""._cgo_setenv} v3
      • v138 (?) = ConstString <string> {"_cgo_setenv missing"}
      • v142 (?) = Addr <*unsafe.Pointer> {""._cgo_unsetenv} v3
      • v146 (?) = ConstString <string> {"_cgo_unsetenv missing"}
      • v150 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v154 (?) = ConstString <string> {"_cgo_notify_runtime_init_done missing"}
      • v160 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v162 (?) = OffPtr <*unsafe.Pointer> [0] v2
      • v164 (?) = OffPtr <*unsafe.Pointer> [8] v2
      • v167 (?) = OffPtr <*int32> [16] v2
      • v168 (?) = Addr <*func()> {"".main_init·f} v3 (fn[func()])
      • v172 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v174 (?) = OffPtr <*chan bool> [0] v2
      • v181 (?) = Addr <*bool> {"".isarchive} v3
      • v183 (?) = Addr <*bool> {"".islibrary} v3
      • v188 (?) = Addr <*func()> {"".main_main·f} v3 (fn[func()])
      • v192 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v197 (?) = Const32 <uint32> [0]
      • v200 (?) = Const64 <int> [1000]
      • v202 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v211 (?) = Const64 <int> [1]
      • v213 (?) = Addr <*uint32> {"".panicking} v3
      • v219 (?) = ConstNil <func(*g, unsafe.Pointer) bool>
      • v220 (?) = OffPtr <*func(*g, unsafe.Pointer) bool> [0] v2
      • v224 (?) = Const8 <waitReason> [8]
      • v225 (?) = OffPtr <*waitReason> [16] v2
      • v227 (?) = Const8 <byte> [16]
      • v228 (?) = OffPtr <*byte> [17] v2
      • v230 (?) = OffPtr <*int> [24] v2
      • v233 (?) = Const32 <int32> [0]
      • v234 (?) = OffPtr <*int32> [0] v2
      • v238 (?) = ConstNil <*int32> (x[*int32])
    • If v15b2 b3 (line +120)
    • b2: ← b1
      • v18 (121) = Copy <mem> v14
      • v19 (+121) = Store <mem> {uintptr} v17 v16 v18
    • Plainb3 (line 121)
    • b3: ← b1 b2
      • v21 (127) = Phi <mem> v14 v19
      • v22 (+127) = Store <mem> {bool} v20 v15 v21
      • v249 (143) = Copy <*g> v4 (g[*g])
    • If v15b4 b5 (line +129)
    • b4: ← b3
      • v25 (130) = Copy <mem> v22
      • v26 (+130) = Store <mem> {func()} v24 v23 v25
      • v27 (130) = StaticCall <mem> {"".systemstack} [8] v26
    • Plainb5 (line 130)
    • b5: ← b3 b4
      • v28 (3614) = Phi <mem> v22 v27
      • v29 (+3614) = GetG <*g> v28
      • v30 (3614) = NilCheck <void> v29 v28
      • v31 (3614) = OffPtr <**m> [48] v29
      • v32 (3614) = Load <*m> v31 v28
      • v33 (3614) = NilCheck <void> v32 v28
      • v34 (3614) = OffPtr <*uint32> [620] v32
      • v35 (3614) = Load <uint32> v34 v28
      • v37 (3614) = Add32 <uint32> v35 v36
      • v38 (3614) = NilCheck <void> v29 v28
      • v39 (3614) = OffPtr <**m> [48] v29
      • v40 (3614) = Load <*m> v39 v28
      • v41 (3614) = NilCheck <void> v40 v28
      • v42 (3614) = OffPtr <*uint32> [620] v40
      • v43 (3614) = Store <mem> {uint32} v42 v37 v28
      • v248 (143) = Copy <*g> v249 (g[*g])
    • If v44b6 b7 (line +3572)
    • b6: ← b5
    • Plainb7 (line +3575)
    • b7: ← b5 b6
      • v45 (3575) = Copy <mem> v43
      • v46 (+3575) = GetG <*g> v45 (_g_[*g], g[*g])
      • v47 (+3576) = NilCheck <void> v46 v45
      • v48 (3576) = OffPtr <**m> [48] v46
      • v49 (3576) = Load <*m> v48 v45
      • v50 (3576) = NilCheck <void> v49 v45
      • v51 (3576) = OffPtr <*guintptr> [352] v49 (gp[*guintptr])
      • v52 (205) = Copy <unsafe.Pointer> v46
      • v53 (+205) = Convert <guintptr> v52 v45
      • v54 (205) = NilCheck <void> v51 v45
      • v55 (205) = Store <mem> {guintptr} v51 v53 v45
      • v247 (143) = Copy <*g> v248 (g[*g])
    • Plainb8 (line +3576)
    • b8: ← b7
      • v56 (3577) = Copy <*g> v46 (_g_[*g])
      • v57 (3577) = Copy <mem> v55
      • v58 (+3577) = NilCheck <void> v56 v57
      • v59 (3577) = OffPtr <*muintptr> [216] v56 (mp[*muintptr])
      • v60 (3577) = NilCheck <void> v56 v57
      • v61 (3577) = OffPtr <**m> [48] v56
      • v62 (3577) = Load <*m> v61 v57 (m[*m])
      • v63 (243) = Copy <unsafe.Pointer> v62
      • v64 (+243) = Convert <muintptr> v63 v57
      • v65 (243) = NilCheck <void> v59 v57
      • v66 (243) = Store <mem> {muintptr} v59 v64 v57
    • Plainb9 (line +3577)
    • b9: ← b8
    • Plainb10 (line 143)
    • b10: ← b9
    • Plainb11 (line 143)
    • b11: ← b10
      • v67 (143) = Copy <*g> v247 (g[*g])
      • v68 (143) = Copy <mem> v66
      • v69 (+143) = NilCheck <void> v67 v68
      • v70 (143) = OffPtr <**m> [48] v67
      • v71 (143) = Load <*m> v70 v68
      • v73 (143) = NeqPtr <bool> v71 v72
    • If v73b12 b13 (line 143)
    • b12: ← b11
      • v76 (144) = Copy <mem> v68
      • v77 (+144) = Store <mem> {string} v75 v74 v76
      • v78 (144) = StaticCall <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v79 (147) = Copy <mem> v68
      • v80 (+147) = StaticCall <mem> {runtime.init} v79
      • v81 (+148) = StaticCall <mem> {"".nanotime} [8] v80
      • v83 (148) = Load <int64> v82 v81
      • v85 (148) = Eq64 <bool> v83 v84
    • If v85b14 b16 (line 148)
    • b14: ← b13
      • v87 (149) = Copy <mem> v81
      • v88 (+149) = Store <mem> {string} v75 v86 v87
      • v89 (149) = StaticCall <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b16
      • v90 (153) = Copy <mem> v81
      • v91 (153) = VarDef <mem> {needUnlock} v90
      • v92 (153) = LocalAddr <*bool> {needUnlock} v2 v91
      • v93 (+153) = Store <mem> {bool} v92 v15 v91
      • v95 (+154) = LocalAddr <*bool> {needUnlock} v2 v93
      • v97 (+158) = Store <mem> {*bool} v96 v95 v93
      • v100 (+154) = Store <mem> {uint32} v99 v98 v97
      • v102 (154) = Store <mem> {uintptr} v101 v94 v100
      • v103 (154) = StaticCall <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b16: ← b13
    • Plainb15 (line +153)
    • b17: ← b15
      • v106 (162) = Copy <mem> v103
      • v107 (+162) = StaticCall <mem> {"".nanotime} [8] v106
      • v108 (162) = Load <int64> v82 v107
      • v110 (162) = Store <mem> {int64} v109 v108 v107
      • v111 (+164) = StaticCall <mem> {"".gcenable} v110
      • v114 (+166) = Store <mem> {*byte} v113 v112 v111
      • v117 (166) = Store <mem> {int} v116 v115 v114
      • v118 (166) = StaticCall <mem> {runtime.makechan} [24] v117
      • v120 (166) = Load <chan bool> v119 v118
      • v122 (166) = Store <mem> {chan bool} v121 v120 v118
      • v124 (+167) = Load <bool> v123 v122
    • If v124b19 b20 (line 167)
    • b18: ← b15
      • v104 (154) = Copy <mem> v103
      • v105 (154) = StaticCall <mem> {runtime.deferreturn} v104
    • Ret v105 (line 154)
    • b19: ← b17
      • v126 (168) = Copy <mem> v122
      • v127 (+168) = Load <unsafe.Pointer> v125 v126
      • v129 (168) = EqPtr <bool> v127 v128
    • If v129b21 b22 (line 168)
    • b20: ← b17 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = Load <uintptr> v168 v169
      • v171 (189) = ClosureCall <mem> [0] v170 v168 v169
      • v173 (+190) = Load <chan bool> v172 v171
      • v175 (190) = Store <mem> {chan bool} v174 v173 v171
      • v176 (190) = StaticCall <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v178 (192) = LocalAddr <*bool> {needUnlock} v2 v177
      • v179 (+192) = Store <mem> {bool} v178 v44 v177
      • v180 (+193) = StaticCall <mem> {"".unlockOSThread} v179
      • v182 (+195) = Load <bool> v181 v180
    • If v182b31 b33 (line 195)
    • b21: ← b19
      • v131 (169) = Copy <mem> v126
      • v132 (+169) = Store <mem> {string} v75 v130 v131
      • v133 (169) = StaticCall <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b22: ← b19
    • If v15b23 b24
    • b23: ← b22
      • v135 (172) = Copy <mem> v126
      • v136 (+172) = Load <unsafe.Pointer> v134 v135
      • v137 (172) = EqPtr <bool> v136 v128
    • If v137b25 b26 (line 172)
    • b24: ← b22 b28
      • v151 (179) = Phi <mem> v126 v143
      • v152 (+179) = Load <unsafe.Pointer> v150 v151
      • v153 (179) = EqPtr <bool> v152 v128
    • If v153b29 b30 (line 179)
    • b25: ← b23
      • v139 (173) = Copy <mem> v135
      • v140 (+173) = Store <mem> {string} v75 v138 v139
      • v141 (173) = StaticCall <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v143 (175) = Copy <mem> v135
      • v144 (+175) = Load <unsafe.Pointer> v142 v143
      • v145 (175) = EqPtr <bool> v144 v128
    • If v145b27 b28 (line 175)
    • b27: ← b26
      • v147 (176) = Copy <mem> v143
      • v148 (+176) = Store <mem> {string} v75 v146 v147
      • v149 (176) = StaticCall <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b28: ← b26
    • Plainb24 (line +179)
    • b29: ← b24
      • v155 (180) = Copy <mem> v151
      • v156 (+180) = Store <mem> {string} v75 v154 v155
      • v157 (180) = StaticCall <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v158 (184) = Copy <mem> v151
      • v159 (+184) = StaticCall <mem> {"".startTemplateThread} v158
      • v161 (+185) = Load <unsafe.Pointer> v160 v159
      • v163 (185) = Store <mem> {unsafe.Pointer} v162 v161 v159
      • v165 (185) = Store <mem> {unsafe.Pointer} v164 v128 v163
      • v166 (185) = StaticCall <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v186 (198) = Phi <mem> v180 v184
      • v187 (+198) = StaticCall <mem> {runtime.deferreturn} v186
    • Ret v187 (line +198)
    • b32: ← b33
      • v189 (201) = Copy <mem> v184
      • v190 (+201) = Load <uintptr> v188 v189
      • v191 (201) = ClosureCall <mem> [0] v190 v188 v189
    • If v44b34 b35 (line +202)
    • b33: ← b20
      • v184 (195) = Copy <mem> v180
      • v185 (195) = Load <bool> v183 v184
    • If v185b31 b32 (line 195)
    • b34: ← b32
    • Plainb35 (line +210)
    • b35: ← b32 b34
      • v193 (210) = Copy <mem> v191
      • v194 (+210) = AtomicLoad32 <uint32,mem> v192 v193
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v198 (210) = Neq32 <bool> v196 v197
    • If v198b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = AtomicLoad32 <uint32,mem> v213 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v218 (219) = Neq32 <bool> v217 v197
    • If v218b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v201 (+212) = Less64 <bool> v199 v200
    • If v201b40 b42 (likely) (line 212)
    • b40: ← b39
      • v203 (213) = Copy <mem> v245
      • v204 (+213) = AtomicLoad32 <uint32,mem> v202 v203
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v207 (213) = Eq32 <bool> v206 v197
    • If v207b43 b45 (line 213)
    • b41: ← b44
      • v210 (212) = Copy <int> v199 (c[int])
      • v212 (+212) = Add64 <int> v210 v211 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b44: ← b45
      • v208 (216) = Copy <mem> v205
      • v209 (+216) = StaticCall <mem> {"".Gosched} v208
    • Plainb41 (line 216)
    • b45: ← b40
    • Plainb44 (line +216)
    • b46: ← b37
      • v221 (220) = Copy <mem> v216
      • v222 (+220) = Store <mem> {func(*g, unsafe.Pointer) bool} v220 v219 v221
      • v223 (220) = Store <mem> {unsafe.Pointer} v164 v128 v222
      • v226 (220) = Store <mem> {waitReason} v225 v224 v223
      • v229 (220) = Store <mem> {byte} v228 v227 v226
      • v231 (220) = Store <mem> {int} v230 v211 v229
      • v232 (220) = StaticCall <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = Store <mem> {int32} v234 v233 v235
      • v237 (223) = StaticCall <mem> {"".exit} [8] v236
    • Plainb49 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b49: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
    • Plainb50 (line +226)
    • b50: ← b49
      • v239 (226) = Copy <mem> v244
      • v240 (+226) = NilCheck <void> v238 v239
      • v241 (226) = Store <mem> {int32} v238 v233 v239
    • Plainb51 (line 226)
    • b51: ← b50
    • Plainb49 (line +226)
    • b52:
      • v242 (228) = Unknown <mem>
      • v243 (228) = StaticCall <mem> {runtime.deferreturn} v242
    • Ret v243 (line 228)
  • name g[*g]: v4 v67 v247 v248 v249
  • name _g_[*g]: v46 v56
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v210 v212
  • name x[*int32]: v238
  • early phielim [55360 ns]

    • b1:
      • v1 (?) = InitMem <mem>
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v4 (+111) = GetG <*g> v1 (g[*g])
      • v5 (?) = Const64 <uintptr> [0]
      • v6 (+115) = NilCheck <void> v4 v1
      • v7 (115) = OffPtr <**m> [48] v4
      • v8 (115) = Load <*m> v7 v1
      • v9 (115) = NilCheck <void> v8 v1
      • v10 (115) = OffPtr <**g> [0] v8
      • v11 (115) = Load <*g> v10 v1
      • v12 (115) = NilCheck <void> v11 v1
      • v13 (115) = OffPtr <*uintptr> [304] v11
      • v14 (115) = Store <mem> {uintptr} v13 v5 v1
      • v15 (?) = ConstBool <bool> [true]
      • v16 (?) = Const64 <uintptr> [1000000000]
      • v17 (?) = Addr <*uintptr> {"".maxstacksize} v3
      • v20 (?) = Addr <*bool> {"".mainStarted} v3
      • v23 (?) = Addr <*func()> {"".main.func1·f} v3
      • v24 (?) = OffPtr <*func()> [0] v2
      • v36 (?) = Const32 <uint32> [1]
      • v44 (?) = ConstBool <bool> [false]
      • v72 (?) = Addr <*m> {"".m0} v3
      • v74 (?) = ConstString <string> {"runtime.main not on m0"}
      • v75 (?) = OffPtr <*string> [0] v2
      • v82 (?) = OffPtr <*int64> [0] v2
      • v84 (?) = Const64 <int64> [0]
      • v86 (?) = ConstString <string> {"nanotime returning zero"}
      • v94 (?) = Addr <*func(*bool)> {"".main.func2·f} v3
      • v96 (?) = OffPtr <**bool> [16] v2
      • v98 (?) = Const32 <uint32> [8]
      • v99 (?) = OffPtr <*uint32> [0] v2
      • v101 (?) = OffPtr <*uintptr> [8] v2
      • v109 (?) = Addr <*int64> {"".runtimeInitTime} v3
      • v112 (?) = Addr <*uint8> {type.chan bool} v3
      • v113 (?) = OffPtr <**byte> [0] v2
      • v115 (?) = Const64 <int> [0] (c[int])
      • v116 (?) = OffPtr <*int> [8] v2
      • v119 (?) = OffPtr <*chan bool> [16] v2
      • v121 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v123 (?) = Addr <*bool> {"".iscgo} v3
      • v125 (?) = Addr <*unsafe.Pointer> {_cgo_thread_start} v3
      • v128 (?) = Const64 <unsafe.Pointer> [0]
      • v130 (?) = ConstString <string> {"_cgo_thread_start missing"}
      • v134 (?) = Addr <*unsafe.Pointer> {""._cgo_setenv} v3
      • v138 (?) = ConstString <string> {"_cgo_setenv missing"}
      • v142 (?) = Addr <*unsafe.Pointer> {""._cgo_unsetenv} v3
      • v146 (?) = ConstString <string> {"_cgo_unsetenv missing"}
      • v150 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v154 (?) = ConstString <string> {"_cgo_notify_runtime_init_done missing"}
      • v160 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v162 (?) = OffPtr <*unsafe.Pointer> [0] v2
      • v164 (?) = OffPtr <*unsafe.Pointer> [8] v2
      • v167 (?) = OffPtr <*int32> [16] v2
      • v168 (?) = Addr <*func()> {"".main_init·f} v3 (fn[func()])
      • v172 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v174 (?) = OffPtr <*chan bool> [0] v2
      • v181 (?) = Addr <*bool> {"".isarchive} v3
      • v183 (?) = Addr <*bool> {"".islibrary} v3
      • v188 (?) = Addr <*func()> {"".main_main·f} v3 (fn[func()])
      • v192 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v197 (?) = Const32 <uint32> [0]
      • v200 (?) = Const64 <int> [1000]
      • v202 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v211 (?) = Const64 <int> [1]
      • v213 (?) = Addr <*uint32> {"".panicking} v3
      • v219 (?) = ConstNil <func(*g, unsafe.Pointer) bool>
      • v220 (?) = OffPtr <*func(*g, unsafe.Pointer) bool> [0] v2
      • v224 (?) = Const8 <waitReason> [8]
      • v225 (?) = OffPtr <*waitReason> [16] v2
      • v227 (?) = Const8 <byte> [16]
      • v228 (?) = OffPtr <*byte> [17] v2
      • v230 (?) = OffPtr <*int> [24] v2
      • v233 (?) = Const32 <int32> [0]
      • v234 (?) = OffPtr <*int32> [0] v2
      • v238 (?) = ConstNil <*int32> (x[*int32])
    • If v15b2 b3 (line +120)
    • b2: ← b1
      • v18 (121) = Copy <mem> v14
      • v19 (+121) = Store <mem> {uintptr} v17 v16 v14
    • Plainb3 (line 121)
    • b3: ← b1 b2
      • v21 (127) = Phi <mem> v14 v19
      • v22 (+127) = Store <mem> {bool} v20 v15 v21
      • v249 (143) = Copy <*g> v4 (g[*g])
    • If v15b4 b5 (line +129)
    • b4: ← b3
      • v25 (130) = Copy <mem> v22
      • v26 (+130) = Store <mem> {func()} v24 v23 v22
      • v27 (130) = StaticCall <mem> {"".systemstack} [8] v26
    • Plainb5 (line 130)
    • b5: ← b3 b4
      • v28 (3614) = Phi <mem> v22 v27
      • v29 (+3614) = GetG <*g> v28
      • v30 (3614) = NilCheck <void> v29 v28
      • v31 (3614) = OffPtr <**m> [48] v29
      • v32 (3614) = Load <*m> v31 v28
      • v33 (3614) = NilCheck <void> v32 v28
      • v34 (3614) = OffPtr <*uint32> [620] v32
      • v35 (3614) = Load <uint32> v34 v28
      • v37 (3614) = Add32 <uint32> v35 v36
      • v38 (3614) = NilCheck <void> v29 v28
      • v39 (3614) = OffPtr <**m> [48] v29
      • v40 (3614) = Load <*m> v39 v28
      • v41 (3614) = NilCheck <void> v40 v28
      • v42 (3614) = OffPtr <*uint32> [620] v40
      • v43 (3614) = Store <mem> {uint32} v42 v37 v28
      • v248 (143) = Copy <*g> v4 (g[*g])
    • If v44b6 b7 (line +3572)
    • b6: ← b5
    • Plainb7 (line +3575)
    • b7: ← b5 b6
      • v45 (3575) = Copy <mem> v43
      • v46 (+3575) = GetG <*g> v43 (_g_[*g], g[*g])
      • v47 (+3576) = NilCheck <void> v46 v43
      • v48 (3576) = OffPtr <**m> [48] v46
      • v49 (3576) = Load <*m> v48 v43
      • v50 (3576) = NilCheck <void> v49 v43
      • v51 (3576) = OffPtr <*guintptr> [352] v49 (gp[*guintptr])
      • v52 (205) = Copy <unsafe.Pointer> v46
      • v53 (+205) = Convert <guintptr> v46 v43
      • v54 (205) = NilCheck <void> v51 v43
      • v55 (205) = Store <mem> {guintptr} v51 v53 v43
      • v247 (143) = Copy <*g> v4 (g[*g])
    • Plainb8 (line +3576)
    • b8: ← b7
      • v56 (3577) = Copy <*g> v46 (_g_[*g])
      • v57 (3577) = Copy <mem> v55
      • v58 (+3577) = NilCheck <void> v46 v55
      • v59 (3577) = OffPtr <*muintptr> [216] v46 (mp[*muintptr])
      • v60 (3577) = NilCheck <void> v46 v55
      • v61 (3577) = OffPtr <**m> [48] v46
      • v62 (3577) = Load <*m> v61 v55 (m[*m])
      • v63 (243) = Copy <unsafe.Pointer> v62
      • v64 (+243) = Convert <muintptr> v62 v55
      • v65 (243) = NilCheck <void> v59 v55
      • v66 (243) = Store <mem> {muintptr} v59 v64 v55
    • Plainb9 (line +3577)
    • b9: ← b8
    • Plainb10 (line 143)
    • b10: ← b9
    • Plainb11 (line 143)
    • b11: ← b10
      • v67 (143) = Copy <*g> v4 (g[*g])
      • v68 (143) = Copy <mem> v66
      • v69 (+143) = NilCheck <void> v4 v66
      • v70 (143) = OffPtr <**m> [48] v4
      • v71 (143) = Load <*m> v70 v66
      • v73 (143) = NeqPtr <bool> v71 v72
    • If v73b12 b13 (line 143)
    • b12: ← b11
      • v76 (144) = Copy <mem> v66
      • v77 (+144) = Store <mem> {string} v75 v74 v66
      • v78 (144) = StaticCall <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v79 (147) = Copy <mem> v66
      • v80 (+147) = StaticCall <mem> {runtime.init} v66
      • v81 (+148) = StaticCall <mem> {"".nanotime} [8] v80
      • v83 (148) = Load <int64> v82 v81
      • v85 (148) = Eq64 <bool> v83 v84
    • If v85b14 b16 (line 148)
    • b14: ← b13
      • v87 (149) = Copy <mem> v81
      • v88 (+149) = Store <mem> {string} v75 v86 v81
      • v89 (149) = StaticCall <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b16
      • v90 (153) = Copy <mem> v81
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (153) = LocalAddr <*bool> {needUnlock} v2 v91
      • v93 (+153) = Store <mem> {bool} v92 v15 v91
      • v95 (+154) = LocalAddr <*bool> {needUnlock} v2 v93
      • v97 (+158) = Store <mem> {*bool} v96 v95 v93
      • v100 (+154) = Store <mem> {uint32} v99 v98 v97
      • v102 (154) = Store <mem> {uintptr} v101 v94 v100
      • v103 (154) = StaticCall <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b16: ← b13
    • Plainb15 (line +153)
    • b17: ← b15
      • v106 (162) = Copy <mem> v103
      • v107 (+162) = StaticCall <mem> {"".nanotime} [8] v103
      • v108 (162) = Load <int64> v82 v107
      • v110 (162) = Store <mem> {int64} v109 v108 v107
      • v111 (+164) = StaticCall <mem> {"".gcenable} v110
      • v114 (+166) = Store <mem> {*byte} v113 v112 v111
      • v117 (166) = Store <mem> {int} v116 v115 v114
      • v118 (166) = StaticCall <mem> {runtime.makechan} [24] v117
      • v120 (166) = Load <chan bool> v119 v118
      • v122 (166) = Store <mem> {chan bool} v121 v120 v118
      • v124 (+167) = Load <bool> v123 v122
    • If v124b19 b20 (line 167)
    • b18: ← b15
      • v104 (154) = Copy <mem> v103
      • v105 (154) = StaticCall <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b17
      • v126 (168) = Copy <mem> v122
      • v127 (+168) = Load <unsafe.Pointer> v125 v122
      • v129 (168) = EqPtr <bool> v127 v128
    • If v129b21 b22 (line 168)
    • b20: ← b17 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = Load <uintptr> v168 v169
      • v171 (189) = ClosureCall <mem> [0] v170 v168 v169
      • v173 (+190) = Load <chan bool> v172 v171
      • v175 (190) = Store <mem> {chan bool} v174 v173 v171
      • v176 (190) = StaticCall <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v178 (192) = LocalAddr <*bool> {needUnlock} v2 v177
      • v179 (+192) = Store <mem> {bool} v178 v44 v177
      • v180 (+193) = StaticCall <mem> {"".unlockOSThread} v179
      • v182 (+195) = Load <bool> v181 v180
    • If v182b31 b33 (line 195)
    • b21: ← b19
      • v131 (169) = Copy <mem> v122
      • v132 (+169) = Store <mem> {string} v75 v130 v122
      • v133 (169) = StaticCall <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b22: ← b19
    • If v15b23 b24
    • b23: ← b22
      • v135 (172) = Copy <mem> v122
      • v136 (+172) = Load <unsafe.Pointer> v134 v122
      • v137 (172) = EqPtr <bool> v136 v128
    • If v137b25 b26 (line 172)
    • b24: ← b22 b28
      • v151 (179) = Copy <mem> v122
      • v152 (+179) = Load <unsafe.Pointer> v150 v122
      • v153 (179) = EqPtr <bool> v152 v128
    • If v153b29 b30 (line 179)
    • b25: ← b23
      • v139 (173) = Copy <mem> v122
      • v140 (+173) = Store <mem> {string} v75 v138 v122
      • v141 (173) = StaticCall <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v143 (175) = Copy <mem> v122
      • v144 (+175) = Load <unsafe.Pointer> v142 v122
      • v145 (175) = EqPtr <bool> v144 v128
    • If v145b27 b28 (line 175)
    • b27: ← b26
      • v147 (176) = Copy <mem> v122
      • v148 (+176) = Store <mem> {string} v75 v146 v122
      • v149 (176) = StaticCall <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b28: ← b26
    • Plainb24 (line +179)
    • b29: ← b24
      • v155 (180) = Copy <mem> v122
      • v156 (+180) = Store <mem> {string} v75 v154 v122
      • v157 (180) = StaticCall <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v158 (184) = Copy <mem> v122
      • v159 (+184) = StaticCall <mem> {"".startTemplateThread} v122
      • v161 (+185) = Load <unsafe.Pointer> v160 v159
      • v163 (185) = Store <mem> {unsafe.Pointer} v162 v161 v159
      • v165 (185) = Store <mem> {unsafe.Pointer} v164 v128 v163
      • v166 (185) = StaticCall <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v186 (198) = Copy <mem> v180
      • v187 (+198) = StaticCall <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b32: ← b33
      • v189 (201) = Copy <mem> v180
      • v190 (+201) = Load <uintptr> v188 v180
      • v191 (201) = ClosureCall <mem> [0] v190 v188 v180
    • If v44b34 b35 (line +202)
    • b33: ← b20
      • v184 (195) = Copy <mem> v180
      • v185 (195) = Load <bool> v183 v180
    • If v185b31 b32 (line 195)
    • b34: ← b32
    • Plainb35 (line +210)
    • b35: ← b32 b34
      • v193 (210) = Copy <mem> v191
      • v194 (+210) = AtomicLoad32 <uint32,mem> v192 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v198 (210) = Neq32 <bool> v196 v197
    • If v198b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = AtomicLoad32 <uint32,mem> v213 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v218 (219) = Neq32 <bool> v217 v197
    • If v218b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v201 (+212) = Less64 <bool> v199 v200
    • If v201b40 b42 (likely) (line 212)
    • b40: ← b39
      • v203 (213) = Copy <mem> v245
      • v204 (+213) = AtomicLoad32 <uint32,mem> v202 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v207 (213) = Eq32 <bool> v206 v197
    • If v207b43 b45 (line 213)
    • b41: ← b44
      • v210 (212) = Copy <int> v199 (c[int])
      • v212 (+212) = Add64 <int> v199 v211 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b44: ← b45
      • v208 (216) = Copy <mem> v205
      • v209 (+216) = StaticCall <mem> {"".Gosched} v205
    • Plainb41 (line 216)
    • b45: ← b40
    • Plainb44 (line +216)
    • b46: ← b37
      • v221 (220) = Copy <mem> v216
      • v222 (+220) = Store <mem> {func(*g, unsafe.Pointer) bool} v220 v219 v216
      • v223 (220) = Store <mem> {unsafe.Pointer} v164 v128 v222
      • v226 (220) = Store <mem> {waitReason} v225 v224 v223
      • v229 (220) = Store <mem> {byte} v228 v227 v226
      • v231 (220) = Store <mem> {int} v230 v211 v229
      • v232 (220) = StaticCall <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = Store <mem> {int32} v234 v233 v235
      • v237 (223) = StaticCall <mem> {"".exit} [8] v236
    • Plainb49 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b49: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
    • Plainb50 (line +226)
    • b50: ← b49
      • v239 (226) = Copy <mem> v244
      • v240 (+226) = NilCheck <void> v238 v244
      • v241 (226) = Store <mem> {int32} v238 v233 v244
    • Plainb51 (line 226)
    • b51: ← b50
    • Plainb49 (line +226)
    • b52:
      • v242 (228) = Unknown <mem>
      • v243 (228) = StaticCall <mem> {runtime.deferreturn} v242
    • Ret v243 (line 228)
  • name g[*g]: v4 v67 v247 v248 v249
  • name _g_[*g]: v46 v56
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v210 v212
  • name x[*int32]: v238
  • early copyelim [19252 ns]

    • b1:
      • v1 (?) = InitMem <mem>
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v4 (+111) = GetG <*g> v1 (g[*g])
      • v5 (?) = Const64 <uintptr> [0]
      • v6 (+115) = NilCheck <void> v4 v1
      • v7 (115) = OffPtr <**m> [48] v4
      • v8 (115) = Load <*m> v7 v1
      • v9 (115) = NilCheck <void> v8 v1
      • v10 (115) = OffPtr <**g> [0] v8
      • v11 (115) = Load <*g> v10 v1
      • v12 (115) = NilCheck <void> v11 v1
      • v13 (115) = OffPtr <*uintptr> [304] v11
      • v14 (115) = Store <mem> {uintptr} v13 v5 v1
      • v15 (?) = ConstBool <bool> [true]
      • v16 (?) = Const64 <uintptr> [1000000000]
      • v17 (?) = Addr <*uintptr> {"".maxstacksize} v3
      • v20 (?) = Addr <*bool> {"".mainStarted} v3
      • v23 (?) = Addr <*func()> {"".main.func1·f} v3
      • v24 (?) = OffPtr <*func()> [0] v2
      • v36 (?) = Const32 <uint32> [1]
      • v44 (?) = ConstBool <bool> [false]
      • v72 (?) = Addr <*m> {"".m0} v3
      • v74 (?) = ConstString <string> {"runtime.main not on m0"}
      • v75 (?) = OffPtr <*string> [0] v2
      • v82 (?) = OffPtr <*int64> [0] v2
      • v84 (?) = Const64 <int64> [0]
      • v86 (?) = ConstString <string> {"nanotime returning zero"}
      • v94 (?) = Addr <*func(*bool)> {"".main.func2·f} v3
      • v96 (?) = OffPtr <**bool> [16] v2
      • v98 (?) = Const32 <uint32> [8]
      • v99 (?) = OffPtr <*uint32> [0] v2
      • v101 (?) = OffPtr <*uintptr> [8] v2
      • v109 (?) = Addr <*int64> {"".runtimeInitTime} v3
      • v112 (?) = Addr <*uint8> {type.chan bool} v3
      • v113 (?) = OffPtr <**byte> [0] v2
      • v115 (?) = Const64 <int> [0] (c[int])
      • v116 (?) = OffPtr <*int> [8] v2
      • v119 (?) = OffPtr <*chan bool> [16] v2
      • v121 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v123 (?) = Addr <*bool> {"".iscgo} v3
      • v125 (?) = Addr <*unsafe.Pointer> {_cgo_thread_start} v3
      • v128 (?) = Const64 <unsafe.Pointer> [0]
      • v130 (?) = ConstString <string> {"_cgo_thread_start missing"}
      • v134 (?) = Addr <*unsafe.Pointer> {""._cgo_setenv} v3
      • v138 (?) = ConstString <string> {"_cgo_setenv missing"}
      • v142 (?) = Addr <*unsafe.Pointer> {""._cgo_unsetenv} v3
      • v146 (?) = ConstString <string> {"_cgo_unsetenv missing"}
      • v150 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v154 (?) = ConstString <string> {"_cgo_notify_runtime_init_done missing"}
      • v160 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v162 (?) = OffPtr <*unsafe.Pointer> [0] v2
      • v164 (?) = OffPtr <*unsafe.Pointer> [8] v2
      • v167 (?) = OffPtr <*int32> [16] v2
      • v168 (?) = Addr <*func()> {"".main_init·f} v3 (fn[func()])
      • v172 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v174 (?) = OffPtr <*chan bool> [0] v2
      • v181 (?) = Addr <*bool> {"".isarchive} v3
      • v183 (?) = Addr <*bool> {"".islibrary} v3
      • v188 (?) = Addr <*func()> {"".main_main·f} v3 (fn[func()])
      • v192 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v197 (?) = Const32 <uint32> [0]
      • v200 (?) = Const64 <int> [1000]
      • v202 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v211 (?) = Const64 <int> [1]
      • v213 (?) = Addr <*uint32> {"".panicking} v3
      • v219 (?) = ConstNil <func(*g, unsafe.Pointer) bool>
      • v220 (?) = OffPtr <*func(*g, unsafe.Pointer) bool> [0] v2
      • v224 (?) = Const8 <waitReason> [8]
      • v225 (?) = OffPtr <*waitReason> [16] v2
      • v227 (?) = Const8 <byte> [16]
      • v228 (?) = OffPtr <*byte> [17] v2
      • v230 (?) = OffPtr <*int> [24] v2
      • v233 (?) = Const32 <int32> [0]
      • v234 (?) = OffPtr <*int32> [0] v2
      • v238 (?) = ConstNil <*int32> (x[*int32])
    • If v15b2 b3 (line +120)
    • b2: ← b1
      • v18 (121) = Copy <mem> v14
      • v19 (+121) = Store <mem> {uintptr} v17 v16 v14
    • Plainb3 (line 121)
    • b3: ← b1 b2
      • v21 (127) = Phi <mem> v14 v19
      • v22 (+127) = Store <mem> {bool} v20 v15 v21
      • v249 (143) = Copy <*g> v4
    • If v15b4 b5 (line +129)
    • b4: ← b3
      • v25 (130) = Copy <mem> v22
      • v26 (+130) = Store <mem> {func()} v24 v23 v22
      • v27 (130) = StaticCall <mem> {"".systemstack} [8] v26
    • Plainb5 (line 130)
    • b5: ← b3 b4
      • v28 (3614) = Phi <mem> v22 v27
      • v29 (+3614) = GetG <*g> v28
      • v30 (3614) = NilCheck <void> v29 v28
      • v31 (3614) = OffPtr <**m> [48] v29
      • v32 (3614) = Load <*m> v31 v28
      • v33 (3614) = NilCheck <void> v32 v28
      • v34 (3614) = OffPtr <*uint32> [620] v32
      • v35 (3614) = Load <uint32> v34 v28
      • v37 (3614) = Add32 <uint32> v35 v36
      • v38 (3614) = NilCheck <void> v29 v28
      • v39 (3614) = OffPtr <**m> [48] v29
      • v40 (3614) = Load <*m> v39 v28
      • v41 (3614) = NilCheck <void> v40 v28
      • v42 (3614) = OffPtr <*uint32> [620] v40
      • v43 (3614) = Store <mem> {uint32} v42 v37 v28
      • v248 (143) = Copy <*g> v4
    • If v44b6 b7 (line +3572)
    • b6: ← b5
    • Plainb7 (line +3575)
    • b7: ← b5 b6
      • v45 (3575) = Copy <mem> v43
      • v46 (+3575) = GetG <*g> v43 (_g_[*g], g[*g])
      • v47 (+3576) = NilCheck <void> v46 v43
      • v48 (3576) = OffPtr <**m> [48] v46
      • v49 (3576) = Load <*m> v48 v43
      • v50 (3576) = NilCheck <void> v49 v43
      • v51 (3576) = OffPtr <*guintptr> [352] v49 (gp[*guintptr])
      • v52 (205) = Copy <unsafe.Pointer> v46
      • v53 (+205) = Convert <guintptr> v46 v43
      • v54 (205) = NilCheck <void> v51 v43
      • v55 (205) = Store <mem> {guintptr} v51 v53 v43
      • v247 (143) = Copy <*g> v4
    • Plainb8 (line +3576)
    • b8: ← b7
      • v56 (3577) = Copy <*g> v46
      • v57 (3577) = Copy <mem> v55
      • v58 (+3577) = NilCheck <void> v46 v55
      • v59 (3577) = OffPtr <*muintptr> [216] v46 (mp[*muintptr])
      • v60 (3577) = NilCheck <void> v46 v55
      • v61 (3577) = OffPtr <**m> [48] v46
      • v62 (3577) = Load <*m> v61 v55 (m[*m])
      • v63 (243) = Copy <unsafe.Pointer> v62
      • v64 (+243) = Convert <muintptr> v62 v55
      • v65 (243) = NilCheck <void> v59 v55
      • v66 (243) = Store <mem> {muintptr} v59 v64 v55
    • Plainb9 (line +3577)
    • b9: ← b8
    • Plainb10 (line 143)
    • b10: ← b9
    • Plainb11 (line 143)
    • b11: ← b10
      • v67 (143) = Copy <*g> v4
      • v68 (143) = Copy <mem> v66
      • v69 (+143) = NilCheck <void> v4 v66
      • v70 (143) = OffPtr <**m> [48] v4
      • v71 (143) = Load <*m> v70 v66
      • v73 (143) = NeqPtr <bool> v71 v72
    • If v73b12 b13 (line 143)
    • b12: ← b11
      • v76 (144) = Copy <mem> v66
      • v77 (+144) = Store <mem> {string} v75 v74 v66
      • v78 (144) = StaticCall <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v79 (147) = Copy <mem> v66
      • v80 (+147) = StaticCall <mem> {runtime.init} v66
      • v81 (+148) = StaticCall <mem> {"".nanotime} [8] v80
      • v83 (148) = Load <int64> v82 v81
      • v85 (148) = Eq64 <bool> v83 v84
    • If v85b14 b16 (line 148)
    • b14: ← b13
      • v87 (149) = Copy <mem> v81
      • v88 (+149) = Store <mem> {string} v75 v86 v81
      • v89 (149) = StaticCall <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b16
      • v90 (153) = Copy <mem> v81
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (153) = LocalAddr <*bool> {needUnlock} v2 v91
      • v93 (+153) = Store <mem> {bool} v92 v15 v91
      • v95 (+154) = LocalAddr <*bool> {needUnlock} v2 v93
      • v97 (+158) = Store <mem> {*bool} v96 v95 v93
      • v100 (+154) = Store <mem> {uint32} v99 v98 v97
      • v102 (154) = Store <mem> {uintptr} v101 v94 v100
      • v103 (154) = StaticCall <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b16: ← b13
    • Plainb15 (line +153)
    • b17: ← b15
      • v106 (162) = Copy <mem> v103
      • v107 (+162) = StaticCall <mem> {"".nanotime} [8] v103
      • v108 (162) = Load <int64> v82 v107
      • v110 (162) = Store <mem> {int64} v109 v108 v107
      • v111 (+164) = StaticCall <mem> {"".gcenable} v110
      • v114 (+166) = Store <mem> {*byte} v113 v112 v111
      • v117 (166) = Store <mem> {int} v116 v115 v114
      • v118 (166) = StaticCall <mem> {runtime.makechan} [24] v117
      • v120 (166) = Load <chan bool> v119 v118
      • v122 (166) = Store <mem> {chan bool} v121 v120 v118
      • v124 (+167) = Load <bool> v123 v122
    • If v124b19 b20 (line 167)
    • b18: ← b15
      • v104 (154) = Copy <mem> v103
      • v105 (154) = StaticCall <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b17
      • v126 (168) = Copy <mem> v122
      • v127 (+168) = Load <unsafe.Pointer> v125 v122
      • v129 (168) = EqPtr <bool> v127 v128
    • If v129b21 b22 (line 168)
    • b20: ← b17 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = Load <uintptr> v168 v169
      • v171 (189) = ClosureCall <mem> [0] v170 v168 v169
      • v173 (+190) = Load <chan bool> v172 v171
      • v175 (190) = Store <mem> {chan bool} v174 v173 v171
      • v176 (190) = StaticCall <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v178 (192) = LocalAddr <*bool> {needUnlock} v2 v177
      • v179 (+192) = Store <mem> {bool} v178 v44 v177
      • v180 (+193) = StaticCall <mem> {"".unlockOSThread} v179
      • v182 (+195) = Load <bool> v181 v180
    • If v182b31 b33 (line 195)
    • b21: ← b19
      • v131 (169) = Copy <mem> v122
      • v132 (+169) = Store <mem> {string} v75 v130 v122
      • v133 (169) = StaticCall <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b22: ← b19
    • If v15b23 b24
    • b23: ← b22
      • v135 (172) = Copy <mem> v122
      • v136 (+172) = Load <unsafe.Pointer> v134 v122
      • v137 (172) = EqPtr <bool> v136 v128
    • If v137b25 b26 (line 172)
    • b24: ← b22 b28
      • v151 (179) = Copy <mem> v122
      • v152 (+179) = Load <unsafe.Pointer> v150 v122
      • v153 (179) = EqPtr <bool> v152 v128
    • If v153b29 b30 (line 179)
    • b25: ← b23
      • v139 (173) = Copy <mem> v122
      • v140 (+173) = Store <mem> {string} v75 v138 v122
      • v141 (173) = StaticCall <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v143 (175) = Copy <mem> v122
      • v144 (+175) = Load <unsafe.Pointer> v142 v122
      • v145 (175) = EqPtr <bool> v144 v128
    • If v145b27 b28 (line 175)
    • b27: ← b26
      • v147 (176) = Copy <mem> v122
      • v148 (+176) = Store <mem> {string} v75 v146 v122
      • v149 (176) = StaticCall <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b28: ← b26
    • Plainb24 (line +179)
    • b29: ← b24
      • v155 (180) = Copy <mem> v122
      • v156 (+180) = Store <mem> {string} v75 v154 v122
      • v157 (180) = StaticCall <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v158 (184) = Copy <mem> v122
      • v159 (+184) = StaticCall <mem> {"".startTemplateThread} v122
      • v161 (+185) = Load <unsafe.Pointer> v160 v159
      • v163 (185) = Store <mem> {unsafe.Pointer} v162 v161 v159
      • v165 (185) = Store <mem> {unsafe.Pointer} v164 v128 v163
      • v166 (185) = StaticCall <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v186 (198) = Copy <mem> v180
      • v187 (+198) = StaticCall <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b32: ← b33
      • v189 (201) = Copy <mem> v180
      • v190 (+201) = Load <uintptr> v188 v180
      • v191 (201) = ClosureCall <mem> [0] v190 v188 v180
    • If v44b34 b35 (line +202)
    • b33: ← b20
      • v184 (195) = Copy <mem> v180
      • v185 (195) = Load <bool> v183 v180
    • If v185b31 b32 (line 195)
    • b34: ← b32
    • Plainb35 (line +210)
    • b35: ← b32 b34
      • v193 (210) = Copy <mem> v191
      • v194 (+210) = AtomicLoad32 <uint32,mem> v192 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v198 (210) = Neq32 <bool> v196 v197
    • If v198b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = AtomicLoad32 <uint32,mem> v213 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v218 (219) = Neq32 <bool> v217 v197
    • If v218b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v201 (+212) = Less64 <bool> v199 v200
    • If v201b40 b42 (likely) (line 212)
    • b40: ← b39
      • v203 (213) = Copy <mem> v245
      • v204 (+213) = AtomicLoad32 <uint32,mem> v202 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v207 (213) = Eq32 <bool> v206 v197
    • If v207b43 b45 (line 213)
    • b41: ← b44
      • v210 (212) = Copy <int> v199
      • v212 (+212) = Add64 <int> v199 v211 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b44: ← b45
      • v208 (216) = Copy <mem> v205
      • v209 (+216) = StaticCall <mem> {"".Gosched} v205
    • Plainb41 (line 216)
    • b45: ← b40
    • Plainb44 (line +216)
    • b46: ← b37
      • v221 (220) = Copy <mem> v216
      • v222 (+220) = Store <mem> {func(*g, unsafe.Pointer) bool} v220 v219 v216
      • v223 (220) = Store <mem> {unsafe.Pointer} v164 v128 v222
      • v226 (220) = Store <mem> {waitReason} v225 v224 v223
      • v229 (220) = Store <mem> {byte} v228 v227 v226
      • v231 (220) = Store <mem> {int} v230 v211 v229
      • v232 (220) = StaticCall <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = Store <mem> {int32} v234 v233 v235
      • v237 (223) = StaticCall <mem> {"".exit} [8] v236
    • Plainb49 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b49: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
    • Plainb50 (line +226)
    • b50: ← b49
      • v239 (226) = Copy <mem> v244
      • v240 (+226) = NilCheck <void> v238 v244
      • v241 (226) = Store <mem> {int32} v238 v233 v244
    • Plainb51 (line 226)
    • b51: ← b50
    • Plainb49 (line +226)
    • b52:
      • v242 (228) = Unknown <mem>
      • v243 (228) = StaticCall <mem> {runtime.deferreturn} v242
    • Ret v243 (line 228)
  • name g[*g]: v4 v4 v4 v4 v4
  • name _g_[*g]: v46 v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v199 v212
  • name x[*int32]: v238
  • early deadcode [76451 ns]

    • b1:
      • v1 (?) = InitMem <mem>
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v4 (+111) = GetG <*g> v1 (g[*g])
      • v5 (?) = Const64 <uintptr> [0]
      • v6 (+115) = NilCheck <void> v4 v1
      • v7 (115) = OffPtr <**m> [48] v4
      • v8 (115) = Load <*m> v7 v1
      • v9 (115) = NilCheck <void> v8 v1
      • v10 (115) = OffPtr <**g> [0] v8
      • v11 (115) = Load <*g> v10 v1
      • v12 (115) = NilCheck <void> v11 v1
      • v13 (115) = OffPtr <*uintptr> [304] v11
      • v14 (115) = Store <mem> {uintptr} v13 v5 v1
      • v15 (?) = ConstBool <bool> [true]
      • v16 (?) = Const64 <uintptr> [1000000000]
      • v17 (?) = Addr <*uintptr> {"".maxstacksize} v3
      • v20 (?) = Addr <*bool> {"".mainStarted} v3
      • v23 (?) = Addr <*func()> {"".main.func1·f} v3
      • v24 (?) = OffPtr <*func()> [0] v2
      • v36 (?) = Const32 <uint32> [1]
      • v44 (?) = ConstBool <bool> [false]
      • v72 (?) = Addr <*m> {"".m0} v3
      • v74 (?) = ConstString <string> {"runtime.main not on m0"}
      • v75 (?) = OffPtr <*string> [0] v2
      • v82 (?) = OffPtr <*int64> [0] v2
      • v84 (?) = Const64 <int64> [0]
      • v86 (?) = ConstString <string> {"nanotime returning zero"}
      • v94 (?) = Addr <*func(*bool)> {"".main.func2·f} v3
      • v96 (?) = OffPtr <**bool> [16] v2
      • v98 (?) = Const32 <uint32> [8]
      • v99 (?) = OffPtr <*uint32> [0] v2
      • v101 (?) = OffPtr <*uintptr> [8] v2
      • v109 (?) = Addr <*int64> {"".runtimeInitTime} v3
      • v112 (?) = Addr <*uint8> {type.chan bool} v3
      • v113 (?) = OffPtr <**byte> [0] v2
      • v115 (?) = Const64 <int> [0] (c[int])
      • v116 (?) = OffPtr <*int> [8] v2
      • v119 (?) = OffPtr <*chan bool> [16] v2
      • v121 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v123 (?) = Addr <*bool> {"".iscgo} v3
      • v125 (?) = Addr <*unsafe.Pointer> {_cgo_thread_start} v3
      • v128 (?) = Const64 <unsafe.Pointer> [0]
      • v130 (?) = ConstString <string> {"_cgo_thread_start missing"}
      • v134 (?) = Addr <*unsafe.Pointer> {""._cgo_setenv} v3
      • v138 (?) = ConstString <string> {"_cgo_setenv missing"}
      • v142 (?) = Addr <*unsafe.Pointer> {""._cgo_unsetenv} v3
      • v146 (?) = ConstString <string> {"_cgo_unsetenv missing"}
      • v150 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v154 (?) = ConstString <string> {"_cgo_notify_runtime_init_done missing"}
      • v160 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v162 (?) = OffPtr <*unsafe.Pointer> [0] v2
      • v164 (?) = OffPtr <*unsafe.Pointer> [8] v2
      • v168 (?) = Addr <*func()> {"".main_init·f} v3 (fn[func()])
      • v172 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v174 (?) = OffPtr <*chan bool> [0] v2
      • v181 (?) = Addr <*bool> {"".isarchive} v3
      • v183 (?) = Addr <*bool> {"".islibrary} v3
      • v188 (?) = Addr <*func()> {"".main_main·f} v3 (fn[func()])
      • v192 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v197 (?) = Const32 <uint32> [0]
      • v200 (?) = Const64 <int> [1000]
      • v202 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v211 (?) = Const64 <int> [1]
      • v213 (?) = Addr <*uint32> {"".panicking} v3
      • v219 (?) = ConstNil <func(*g, unsafe.Pointer) bool>
      • v220 (?) = OffPtr <*func(*g, unsafe.Pointer) bool> [0] v2
      • v224 (?) = Const8 <waitReason> [8]
      • v225 (?) = OffPtr <*waitReason> [16] v2
      • v227 (?) = Const8 <byte> [16]
      • v228 (?) = OffPtr <*byte> [17] v2
      • v230 (?) = OffPtr <*int> [24] v2
      • v233 (?) = Const32 <int32> [0]
      • v234 (?) = OffPtr <*int32> [0] v2
      • v238 (?) = ConstNil <*int32> (x[*int32])
    • If v15b2 b3 (line +120)
    • b2: ← b1
      • v19 (+121) = Store <mem> {uintptr} v17 v16 v14
    • Plainb3 (line 121)
    • b3: ← b1 b2
      • v21 (127) = Phi <mem> v14 v19
      • v22 (+127) = Store <mem> {bool} v20 v15 v21
    • If v15b4 b5 (line +129)
    • b4: ← b3
      • v26 (+130) = Store <mem> {func()} v24 v23 v22
      • v27 (130) = StaticCall <mem> {"".systemstack} [8] v26
    • Plainb5 (line 130)
    • b5: ← b3 b4
      • v28 (3614) = Phi <mem> v22 v27
      • v29 (+3614) = GetG <*g> v28
      • v30 (3614) = NilCheck <void> v29 v28
      • v31 (3614) = OffPtr <**m> [48] v29
      • v32 (3614) = Load <*m> v31 v28
      • v33 (3614) = NilCheck <void> v32 v28
      • v34 (3614) = OffPtr <*uint32> [620] v32
      • v35 (3614) = Load <uint32> v34 v28
      • v37 (3614) = Add32 <uint32> v35 v36
      • v38 (3614) = NilCheck <void> v29 v28
      • v39 (3614) = OffPtr <**m> [48] v29
      • v40 (3614) = Load <*m> v39 v28
      • v41 (3614) = NilCheck <void> v40 v28
      • v42 (3614) = OffPtr <*uint32> [620] v40
      • v43 (3614) = Store <mem> {uint32} v42 v37 v28
    • If v44b6 b7 (line +3572)
    • b6: ← b5
    • Plainb7 (line +3575)
    • b7: ← b5 b6
      • v46 (+3575) = GetG <*g> v43 (_g_[*g], g[*g])
      • v47 (+3576) = NilCheck <void> v46 v43
      • v48 (3576) = OffPtr <**m> [48] v46
      • v49 (3576) = Load <*m> v48 v43
      • v50 (3576) = NilCheck <void> v49 v43
      • v51 (3576) = OffPtr <*guintptr> [352] v49 (gp[*guintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v54 (205) = NilCheck <void> v51 v43
      • v55 (205) = Store <mem> {guintptr} v51 v53 v43
    • Plainb8 (line +3576)
    • b8: ← b7
      • v58 (+3577) = NilCheck <void> v46 v55
      • v59 (3577) = OffPtr <*muintptr> [216] v46 (mp[*muintptr])
      • v60 (3577) = NilCheck <void> v46 v55
      • v61 (3577) = OffPtr <**m> [48] v46
      • v62 (3577) = Load <*m> v61 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v65 (243) = NilCheck <void> v59 v55
      • v66 (243) = Store <mem> {muintptr} v59 v64 v55
    • Plainb9 (line +3577)
    • b9: ← b8
    • Plainb10 (line 143)
    • b10: ← b9
    • Plainb11 (line 143)
    • b11: ← b10
      • v69 (+143) = NilCheck <void> v4 v66
      • v70 (143) = OffPtr <**m> [48] v4
      • v71 (143) = Load <*m> v70 v66
      • v73 (143) = NeqPtr <bool> v71 v72
    • If v73b12 b13 (line 143)
    • b12: ← b11
      • v77 (+144) = Store <mem> {string} v75 v74 v66
      • v78 (144) = StaticCall <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = StaticCall <mem> {runtime.init} v66
      • v81 (+148) = StaticCall <mem> {"".nanotime} [8] v80
      • v83 (148) = Load <int64> v82 v81
      • v85 (148) = Eq64 <bool> v83 v84
    • If v85b14 b16 (line 148)
    • b14: ← b13
      • v88 (+149) = Store <mem> {string} v75 v86 v81
      • v89 (149) = StaticCall <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b16
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (153) = LocalAddr <*bool> {needUnlock} v2 v91
      • v93 (+153) = Store <mem> {bool} v92 v15 v91
      • v95 (+154) = LocalAddr <*bool> {needUnlock} v2 v93
      • v97 (+158) = Store <mem> {*bool} v96 v95 v93
      • v100 (+154) = Store <mem> {uint32} v99 v98 v97
      • v102 (154) = Store <mem> {uintptr} v101 v94 v100
      • v103 (154) = StaticCall <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b16: ← b13
    • Plainb15 (line +153)
    • b17: ← b15
      • v107 (+162) = StaticCall <mem> {"".nanotime} [8] v103
      • v108 (162) = Load <int64> v82 v107
      • v110 (162) = Store <mem> {int64} v109 v108 v107
      • v111 (+164) = StaticCall <mem> {"".gcenable} v110
      • v114 (+166) = Store <mem> {*byte} v113 v112 v111
      • v117 (166) = Store <mem> {int} v116 v115 v114
      • v118 (166) = StaticCall <mem> {runtime.makechan} [24] v117
      • v120 (166) = Load <chan bool> v119 v118
      • v122 (166) = Store <mem> {chan bool} v121 v120 v118
      • v124 (+167) = Load <bool> v123 v122
    • If v124b19 b20 (line 167)
    • b18: ← b15
      • v105 (154) = StaticCall <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b17
      • v127 (+168) = Load <unsafe.Pointer> v125 v122
      • v129 (168) = EqPtr <bool> v127 v128
    • If v129b21 b22 (line 168)
    • b20: ← b17 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = Load <uintptr> v168 v169
      • v171 (189) = ClosureCall <mem> [0] v170 v168 v169
      • v173 (+190) = Load <chan bool> v172 v171
      • v175 (190) = Store <mem> {chan bool} v174 v173 v171
      • v176 (190) = StaticCall <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v178 (192) = LocalAddr <*bool> {needUnlock} v2 v177
      • v179 (+192) = Store <mem> {bool} v178 v44 v177
      • v180 (+193) = StaticCall <mem> {"".unlockOSThread} v179
      • v182 (+195) = Load <bool> v181 v180
    • If v182b31 b33 (line 195)
    • b21: ← b19
      • v132 (+169) = Store <mem> {string} v75 v130 v122
      • v133 (169) = StaticCall <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b22: ← b19
    • If v15b23 b24
    • b23: ← b22
      • v136 (+172) = Load <unsafe.Pointer> v134 v122
      • v137 (172) = EqPtr <bool> v136 v128
    • If v137b25 b26 (line 172)
    • b24: ← b22 b28
      • v152 (+179) = Load <unsafe.Pointer> v150 v122
      • v153 (179) = EqPtr <bool> v152 v128
    • If v153b29 b30 (line 179)
    • b25: ← b23
      • v140 (+173) = Store <mem> {string} v75 v138 v122
      • v141 (173) = StaticCall <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v144 (+175) = Load <unsafe.Pointer> v142 v122
      • v145 (175) = EqPtr <bool> v144 v128
    • If v145b27 b28 (line 175)
    • b27: ← b26
      • v148 (+176) = Store <mem> {string} v75 v146 v122
      • v149 (176) = StaticCall <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b28: ← b26
    • Plainb24 (line +179)
    • b29: ← b24
      • v156 (+180) = Store <mem> {string} v75 v154 v122
      • v157 (180) = StaticCall <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = StaticCall <mem> {"".startTemplateThread} v122
      • v161 (+185) = Load <unsafe.Pointer> v160 v159
      • v163 (185) = Store <mem> {unsafe.Pointer} v162 v161 v159
      • v165 (185) = Store <mem> {unsafe.Pointer} v164 v128 v163
      • v166 (185) = StaticCall <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = StaticCall <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b32: ← b33
      • v190 (+201) = Load <uintptr> v188 v180
      • v191 (201) = ClosureCall <mem> [0] v190 v188 v180
    • If v44b34 b35 (line +202)
    • b33: ← b20
      • v185 (195) = Load <bool> v183 v180
    • If v185b31 b32 (line 195)
    • b34: ← b32
    • Plainb35 (line +210)
    • b35: ← b32 b34
      • v194 (+210) = AtomicLoad32 <uint32,mem> v192 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v198 (210) = Neq32 <bool> v196 v197
    • If v198b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = AtomicLoad32 <uint32,mem> v213 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v218 (219) = Neq32 <bool> v217 v197
    • If v218b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v201 (+212) = Less64 <bool> v199 v200
    • If v201b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = AtomicLoad32 <uint32,mem> v202 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v207 (213) = Eq32 <bool> v206 v197
    • If v207b43 b45 (line 213)
    • b41: ← b44
      • v212 (+212) = Add64 <int> v199 v211 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b44: ← b45
      • v209 (+216) = StaticCall <mem> {"".Gosched} v205
    • Plainb41 (line 216)
    • b45: ← b40
    • Plainb44 (line +216)
    • b46: ← b37
      • v222 (+220) = Store <mem> {func(*g, unsafe.Pointer) bool} v220 v219 v216
      • v223 (220) = Store <mem> {unsafe.Pointer} v164 v128 v222
      • v226 (220) = Store <mem> {waitReason} v225 v224 v223
      • v229 (220) = Store <mem> {byte} v228 v227 v226
      • v231 (220) = Store <mem> {int} v230 v211 v229
      • v232 (220) = StaticCall <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = Store <mem> {int32} v234 v233 v235
      • v237 (223) = StaticCall <mem> {"".exit} [8] v236
    • Plainb49 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b49: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
    • Plainb50 (line +226)
    • b50: ← b49
      • v240 (+226) = NilCheck <void> v238 v244
      • v241 (226) = Store <mem> {int32} v238 v233 v244
    • Plainb51 (line 226)
    • b51: ← b50
    • Plainb49 (line +226)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • short circuit [17323 ns]

    • b1:
      • v1 (?) = InitMem <mem>
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v4 (+111) = GetG <*g> v1 (g[*g])
      • v5 (?) = Const64 <uintptr> [0]
      • v6 (+115) = NilCheck <void> v4 v1
      • v7 (115) = OffPtr <**m> [48] v4
      • v8 (115) = Load <*m> v7 v1
      • v9 (115) = NilCheck <void> v8 v1
      • v10 (115) = OffPtr <**g> [0] v8
      • v11 (115) = Load <*g> v10 v1
      • v12 (115) = NilCheck <void> v11 v1
      • v13 (115) = OffPtr <*uintptr> [304] v11
      • v14 (115) = Store <mem> {uintptr} v13 v5 v1
      • v15 (?) = ConstBool <bool> [true]
      • v16 (?) = Const64 <uintptr> [1000000000]
      • v17 (?) = Addr <*uintptr> {"".maxstacksize} v3
      • v20 (?) = Addr <*bool> {"".mainStarted} v3
      • v23 (?) = Addr <*func()> {"".main.func1·f} v3
      • v24 (?) = OffPtr <*func()> [0] v2
      • v36 (?) = Const32 <uint32> [1]
      • v44 (?) = ConstBool <bool> [false]
      • v72 (?) = Addr <*m> {"".m0} v3
      • v74 (?) = ConstString <string> {"runtime.main not on m0"}
      • v75 (?) = OffPtr <*string> [0] v2
      • v82 (?) = OffPtr <*int64> [0] v2
      • v84 (?) = Const64 <int64> [0]
      • v86 (?) = ConstString <string> {"nanotime returning zero"}
      • v94 (?) = Addr <*func(*bool)> {"".main.func2·f} v3
      • v96 (?) = OffPtr <**bool> [16] v2
      • v98 (?) = Const32 <uint32> [8]
      • v99 (?) = OffPtr <*uint32> [0] v2
      • v101 (?) = OffPtr <*uintptr> [8] v2
      • v109 (?) = Addr <*int64> {"".runtimeInitTime} v3
      • v112 (?) = Addr <*uint8> {type.chan bool} v3
      • v113 (?) = OffPtr <**byte> [0] v2
      • v115 (?) = Const64 <int> [0] (c[int])
      • v116 (?) = OffPtr <*int> [8] v2
      • v119 (?) = OffPtr <*chan bool> [16] v2
      • v121 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v123 (?) = Addr <*bool> {"".iscgo} v3
      • v125 (?) = Addr <*unsafe.Pointer> {_cgo_thread_start} v3
      • v128 (?) = Const64 <unsafe.Pointer> [0]
      • v130 (?) = ConstString <string> {"_cgo_thread_start missing"}
      • v134 (?) = Addr <*unsafe.Pointer> {""._cgo_setenv} v3
      • v138 (?) = ConstString <string> {"_cgo_setenv missing"}
      • v142 (?) = Addr <*unsafe.Pointer> {""._cgo_unsetenv} v3
      • v146 (?) = ConstString <string> {"_cgo_unsetenv missing"}
      • v150 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v154 (?) = ConstString <string> {"_cgo_notify_runtime_init_done missing"}
      • v160 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v162 (?) = OffPtr <*unsafe.Pointer> [0] v2
      • v164 (?) = OffPtr <*unsafe.Pointer> [8] v2
      • v168 (?) = Addr <*func()> {"".main_init·f} v3 (fn[func()])
      • v172 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v174 (?) = OffPtr <*chan bool> [0] v2
      • v181 (?) = Addr <*bool> {"".isarchive} v3
      • v183 (?) = Addr <*bool> {"".islibrary} v3
      • v188 (?) = Addr <*func()> {"".main_main·f} v3 (fn[func()])
      • v192 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v197 (?) = Const32 <uint32> [0]
      • v200 (?) = Const64 <int> [1000]
      • v202 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v211 (?) = Const64 <int> [1]
      • v213 (?) = Addr <*uint32> {"".panicking} v3
      • v219 (?) = ConstNil <func(*g, unsafe.Pointer) bool>
      • v220 (?) = OffPtr <*func(*g, unsafe.Pointer) bool> [0] v2
      • v224 (?) = Const8 <waitReason> [8]
      • v225 (?) = OffPtr <*waitReason> [16] v2
      • v227 (?) = Const8 <byte> [16]
      • v228 (?) = OffPtr <*byte> [17] v2
      • v230 (?) = OffPtr <*int> [24] v2
      • v233 (?) = Const32 <int32> [0]
      • v234 (?) = OffPtr <*int32> [0] v2
      • v238 (?) = ConstNil <*int32> (x[*int32])
    • If v15b2 b3 (line +120)
    • b2: ← b1
      • v19 (+121) = Store <mem> {uintptr} v17 v16 v14
    • Plainb3 (line 121)
    • b3: ← b1 b2
      • v21 (127) = Phi <mem> v14 v19
      • v22 (+127) = Store <mem> {bool} v20 v15 v21
    • If v15b4 b5 (line +129)
    • b4: ← b3
      • v26 (+130) = Store <mem> {func()} v24 v23 v22
      • v27 (130) = StaticCall <mem> {"".systemstack} [8] v26
    • Plainb5 (line 130)
    • b5: ← b3 b4
      • v28 (3614) = Phi <mem> v22 v27
      • v29 (+3614) = GetG <*g> v28
      • v30 (3614) = NilCheck <void> v29 v28
      • v31 (3614) = OffPtr <**m> [48] v29
      • v32 (3614) = Load <*m> v31 v28
      • v33 (3614) = NilCheck <void> v32 v28
      • v34 (3614) = OffPtr <*uint32> [620] v32
      • v35 (3614) = Load <uint32> v34 v28
      • v37 (3614) = Add32 <uint32> v35 v36
      • v38 (3614) = NilCheck <void> v29 v28
      • v39 (3614) = OffPtr <**m> [48] v29
      • v40 (3614) = Load <*m> v39 v28
      • v41 (3614) = NilCheck <void> v40 v28
      • v42 (3614) = OffPtr <*uint32> [620] v40
      • v43 (3614) = Store <mem> {uint32} v42 v37 v28
    • If v44b6 b7 (line +3572)
    • b6: ← b5
    • Plainb7 (line +3575)
    • b7: ← b5 b6
      • v46 (+3575) = GetG <*g> v43 (_g_[*g], g[*g])
      • v47 (+3576) = NilCheck <void> v46 v43
      • v48 (3576) = OffPtr <**m> [48] v46
      • v49 (3576) = Load <*m> v48 v43
      • v50 (3576) = NilCheck <void> v49 v43
      • v51 (3576) = OffPtr <*guintptr> [352] v49 (gp[*guintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v54 (205) = NilCheck <void> v51 v43
      • v55 (205) = Store <mem> {guintptr} v51 v53 v43
    • Plainb8 (line +3576)
    • b8: ← b7
      • v58 (+3577) = NilCheck <void> v46 v55
      • v59 (3577) = OffPtr <*muintptr> [216] v46 (mp[*muintptr])
      • v60 (3577) = NilCheck <void> v46 v55
      • v61 (3577) = OffPtr <**m> [48] v46
      • v62 (3577) = Load <*m> v61 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v65 (243) = NilCheck <void> v59 v55
      • v66 (243) = Store <mem> {muintptr} v59 v64 v55
    • Plainb9 (line +3577)
    • b9: ← b8
    • Plainb10 (line 143)
    • b10: ← b9
    • Plainb11 (line 143)
    • b11: ← b10
      • v69 (+143) = NilCheck <void> v4 v66
      • v70 (143) = OffPtr <**m> [48] v4
      • v71 (143) = Load <*m> v70 v66
      • v73 (143) = NeqPtr <bool> v71 v72
    • If v73b12 b13 (line 143)
    • b12: ← b11
      • v77 (+144) = Store <mem> {string} v75 v74 v66
      • v78 (144) = StaticCall <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = StaticCall <mem> {runtime.init} v66
      • v81 (+148) = StaticCall <mem> {"".nanotime} [8] v80
      • v83 (148) = Load <int64> v82 v81
      • v85 (148) = Eq64 <bool> v83 v84
    • If v85b14 b16 (line 148)
    • b14: ← b13
      • v88 (+149) = Store <mem> {string} v75 v86 v81
      • v89 (149) = StaticCall <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b16
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (153) = LocalAddr <*bool> {needUnlock} v2 v91
      • v93 (+153) = Store <mem> {bool} v92 v15 v91
      • v95 (+154) = LocalAddr <*bool> {needUnlock} v2 v93
      • v97 (+158) = Store <mem> {*bool} v96 v95 v93
      • v100 (+154) = Store <mem> {uint32} v99 v98 v97
      • v102 (154) = Store <mem> {uintptr} v101 v94 v100
      • v103 (154) = StaticCall <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b16: ← b13
    • Plainb15 (line +153)
    • b17: ← b15
      • v107 (+162) = StaticCall <mem> {"".nanotime} [8] v103
      • v108 (162) = Load <int64> v82 v107
      • v110 (162) = Store <mem> {int64} v109 v108 v107
      • v111 (+164) = StaticCall <mem> {"".gcenable} v110
      • v114 (+166) = Store <mem> {*byte} v113 v112 v111
      • v117 (166) = Store <mem> {int} v116 v115 v114
      • v118 (166) = StaticCall <mem> {runtime.makechan} [24] v117
      • v120 (166) = Load <chan bool> v119 v118
      • v122 (166) = Store <mem> {chan bool} v121 v120 v118
      • v124 (+167) = Load <bool> v123 v122
    • If v124b19 b20 (line 167)
    • b18: ← b15
      • v105 (154) = StaticCall <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b17
      • v127 (+168) = Load <unsafe.Pointer> v125 v122
      • v129 (168) = EqPtr <bool> v127 v128
    • If v129b21 b22 (line 168)
    • b20: ← b17 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = Load <uintptr> v168 v169
      • v171 (189) = ClosureCall <mem> [0] v170 v168 v169
      • v173 (+190) = Load <chan bool> v172 v171
      • v175 (190) = Store <mem> {chan bool} v174 v173 v171
      • v176 (190) = StaticCall <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v178 (192) = LocalAddr <*bool> {needUnlock} v2 v177
      • v179 (+192) = Store <mem> {bool} v178 v44 v177
      • v180 (+193) = StaticCall <mem> {"".unlockOSThread} v179
      • v182 (+195) = Load <bool> v181 v180
    • If v182b31 b33 (line 195)
    • b21: ← b19
      • v132 (+169) = Store <mem> {string} v75 v130 v122
      • v133 (169) = StaticCall <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b22: ← b19
    • If v15b23 b24
    • b23: ← b22
      • v136 (+172) = Load <unsafe.Pointer> v134 v122
      • v137 (172) = EqPtr <bool> v136 v128
    • If v137b25 b26 (line 172)
    • b24: ← b22 b28
      • v152 (+179) = Load <unsafe.Pointer> v150 v122
      • v153 (179) = EqPtr <bool> v152 v128
    • If v153b29 b30 (line 179)
    • b25: ← b23
      • v140 (+173) = Store <mem> {string} v75 v138 v122
      • v141 (173) = StaticCall <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v144 (+175) = Load <unsafe.Pointer> v142 v122
      • v145 (175) = EqPtr <bool> v144 v128
    • If v145b27 b28 (line 175)
    • b27: ← b26
      • v148 (+176) = Store <mem> {string} v75 v146 v122
      • v149 (176) = StaticCall <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b28: ← b26
    • Plainb24 (line +179)
    • b29: ← b24
      • v156 (+180) = Store <mem> {string} v75 v154 v122
      • v157 (180) = StaticCall <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = StaticCall <mem> {"".startTemplateThread} v122
      • v161 (+185) = Load <unsafe.Pointer> v160 v159
      • v163 (185) = Store <mem> {unsafe.Pointer} v162 v161 v159
      • v165 (185) = Store <mem> {unsafe.Pointer} v164 v128 v163
      • v166 (185) = StaticCall <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = StaticCall <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b32: ← b33
      • v190 (+201) = Load <uintptr> v188 v180
      • v191 (201) = ClosureCall <mem> [0] v190 v188 v180
    • If v44b34 b35 (line +202)
    • b33: ← b20
      • v185 (195) = Load <bool> v183 v180
    • If v185b31 b32 (line 195)
    • b34: ← b32
    • Plainb35 (line +210)
    • b35: ← b32 b34
      • v194 (+210) = AtomicLoad32 <uint32,mem> v192 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v198 (210) = Neq32 <bool> v196 v197
    • If v198b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = AtomicLoad32 <uint32,mem> v213 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v218 (219) = Neq32 <bool> v217 v197
    • If v218b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v201 (+212) = Less64 <bool> v199 v200
    • If v201b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = AtomicLoad32 <uint32,mem> v202 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v207 (213) = Eq32 <bool> v206 v197
    • If v207b43 b45 (line 213)
    • b41: ← b44
      • v212 (+212) = Add64 <int> v199 v211 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b44: ← b45
      • v209 (+216) = StaticCall <mem> {"".Gosched} v205
    • Plainb41 (line 216)
    • b45: ← b40
    • Plainb44 (line +216)
    • b46: ← b37
      • v222 (+220) = Store <mem> {func(*g, unsafe.Pointer) bool} v220 v219 v216
      • v223 (220) = Store <mem> {unsafe.Pointer} v164 v128 v222
      • v226 (220) = Store <mem> {waitReason} v225 v224 v223
      • v229 (220) = Store <mem> {byte} v228 v227 v226
      • v231 (220) = Store <mem> {int} v230 v211 v229
      • v232 (220) = StaticCall <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = Store <mem> {int32} v234 v233 v235
      • v237 (223) = StaticCall <mem> {"".exit} [8] v236
    • Plainb49 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b49: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
    • Plainb50 (line +226)
    • b50: ← b49
      • v240 (+226) = NilCheck <void> v238 v244
      • v241 (226) = Store <mem> {int32} v238 v233 v244
    • Plainb51 (line 226)
    • b51: ← b50
    • Plainb49 (line +226)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • decompose user [8451 ns]

    • b1:
      • v1 (?) = InitMem <mem>
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v4 (+111) = GetG <*g> v1 (g[*g])
      • v5 (?) = Const64 <uintptr> [0]
      • v6 (+115) = NilCheck <void> v4 v1
      • v7 (115) = OffPtr <**m> [48] v4
      • v8 (115) = Load <*m> v7 v1
      • v9 (115) = NilCheck <void> v8 v1
      • v10 (115) = OffPtr <**g> [0] v8
      • v11 (115) = Load <*g> v10 v1
      • v12 (115) = NilCheck <void> v11 v1
      • v13 (115) = OffPtr <*uintptr> [304] v11
      • v14 (115) = Store <mem> {uintptr} v13 v5 v1
      • v15 (?) = ConstBool <bool> [true]
      • v16 (?) = Const64 <uintptr> [1000000000]
      • v17 (?) = Addr <*uintptr> {"".maxstacksize} v3
      • v20 (?) = Addr <*bool> {"".mainStarted} v3
      • v23 (?) = Addr <*func()> {"".main.func1·f} v3
      • v24 (?) = OffPtr <*func()> [0] v2
      • v36 (?) = Const32 <uint32> [1]
      • v44 (?) = ConstBool <bool> [false]
      • v72 (?) = Addr <*m> {"".m0} v3
      • v74 (?) = ConstString <string> {"runtime.main not on m0"}
      • v75 (?) = OffPtr <*string> [0] v2
      • v82 (?) = OffPtr <*int64> [0] v2
      • v84 (?) = Const64 <int64> [0]
      • v86 (?) = ConstString <string> {"nanotime returning zero"}
      • v94 (?) = Addr <*func(*bool)> {"".main.func2·f} v3
      • v96 (?) = OffPtr <**bool> [16] v2
      • v98 (?) = Const32 <uint32> [8]
      • v99 (?) = OffPtr <*uint32> [0] v2
      • v101 (?) = OffPtr <*uintptr> [8] v2
      • v109 (?) = Addr <*int64> {"".runtimeInitTime} v3
      • v112 (?) = Addr <*uint8> {type.chan bool} v3
      • v113 (?) = OffPtr <**byte> [0] v2
      • v115 (?) = Const64 <int> [0] (c[int])
      • v116 (?) = OffPtr <*int> [8] v2
      • v119 (?) = OffPtr <*chan bool> [16] v2
      • v121 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v123 (?) = Addr <*bool> {"".iscgo} v3
      • v125 (?) = Addr <*unsafe.Pointer> {_cgo_thread_start} v3
      • v128 (?) = Const64 <unsafe.Pointer> [0]
      • v130 (?) = ConstString <string> {"_cgo_thread_start missing"}
      • v134 (?) = Addr <*unsafe.Pointer> {""._cgo_setenv} v3
      • v138 (?) = ConstString <string> {"_cgo_setenv missing"}
      • v142 (?) = Addr <*unsafe.Pointer> {""._cgo_unsetenv} v3
      • v146 (?) = ConstString <string> {"_cgo_unsetenv missing"}
      • v150 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v154 (?) = ConstString <string> {"_cgo_notify_runtime_init_done missing"}
      • v160 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v162 (?) = OffPtr <*unsafe.Pointer> [0] v2
      • v164 (?) = OffPtr <*unsafe.Pointer> [8] v2
      • v168 (?) = Addr <*func()> {"".main_init·f} v3 (fn[func()])
      • v172 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v174 (?) = OffPtr <*chan bool> [0] v2
      • v181 (?) = Addr <*bool> {"".isarchive} v3
      • v183 (?) = Addr <*bool> {"".islibrary} v3
      • v188 (?) = Addr <*func()> {"".main_main·f} v3 (fn[func()])
      • v192 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v197 (?) = Const32 <uint32> [0]
      • v200 (?) = Const64 <int> [1000]
      • v202 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v211 (?) = Const64 <int> [1]
      • v213 (?) = Addr <*uint32> {"".panicking} v3
      • v219 (?) = ConstNil <func(*g, unsafe.Pointer) bool>
      • v220 (?) = OffPtr <*func(*g, unsafe.Pointer) bool> [0] v2
      • v224 (?) = Const8 <waitReason> [8]
      • v225 (?) = OffPtr <*waitReason> [16] v2
      • v227 (?) = Const8 <byte> [16]
      • v228 (?) = OffPtr <*byte> [17] v2
      • v230 (?) = OffPtr <*int> [24] v2
      • v233 (?) = Const32 <int32> [0]
      • v234 (?) = OffPtr <*int32> [0] v2
      • v238 (?) = ConstNil <*int32> (x[*int32])
    • If v15b2 b3 (line +120)
    • b2: ← b1
      • v19 (+121) = Store <mem> {uintptr} v17 v16 v14
    • Plainb3 (line 121)
    • b3: ← b1 b2
      • v21 (127) = Phi <mem> v14 v19
      • v22 (+127) = Store <mem> {bool} v20 v15 v21
    • If v15b4 b5 (line +129)
    • b4: ← b3
      • v26 (+130) = Store <mem> {func()} v24 v23 v22
      • v27 (130) = StaticCall <mem> {"".systemstack} [8] v26
    • Plainb5 (line 130)
    • b5: ← b3 b4
      • v28 (3614) = Phi <mem> v22 v27
      • v29 (+3614) = GetG <*g> v28
      • v30 (3614) = NilCheck <void> v29 v28
      • v31 (3614) = OffPtr <**m> [48] v29
      • v32 (3614) = Load <*m> v31 v28
      • v33 (3614) = NilCheck <void> v32 v28
      • v34 (3614) = OffPtr <*uint32> [620] v32
      • v35 (3614) = Load <uint32> v34 v28
      • v37 (3614) = Add32 <uint32> v35 v36
      • v38 (3614) = NilCheck <void> v29 v28
      • v39 (3614) = OffPtr <**m> [48] v29
      • v40 (3614) = Load <*m> v39 v28
      • v41 (3614) = NilCheck <void> v40 v28
      • v42 (3614) = OffPtr <*uint32> [620] v40
      • v43 (3614) = Store <mem> {uint32} v42 v37 v28
    • If v44b6 b7 (line +3572)
    • b6: ← b5
    • Plainb7 (line +3575)
    • b7: ← b5 b6
      • v46 (+3575) = GetG <*g> v43 (g[*g], _g_[*g])
      • v47 (+3576) = NilCheck <void> v46 v43
      • v48 (3576) = OffPtr <**m> [48] v46
      • v49 (3576) = Load <*m> v48 v43
      • v50 (3576) = NilCheck <void> v49 v43
      • v51 (3576) = OffPtr <*guintptr> [352] v49 (gp[*guintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v54 (205) = NilCheck <void> v51 v43
      • v55 (205) = Store <mem> {guintptr} v51 v53 v43
    • Plainb8 (line +3576)
    • b8: ← b7
      • v58 (+3577) = NilCheck <void> v46 v55
      • v59 (3577) = OffPtr <*muintptr> [216] v46 (mp[*muintptr])
      • v60 (3577) = NilCheck <void> v46 v55
      • v61 (3577) = OffPtr <**m> [48] v46
      • v62 (3577) = Load <*m> v61 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v65 (243) = NilCheck <void> v59 v55
      • v66 (243) = Store <mem> {muintptr} v59 v64 v55
    • Plainb9 (line +3577)
    • b9: ← b8
    • Plainb10 (line 143)
    • b10: ← b9
    • Plainb11 (line 143)
    • b11: ← b10
      • v69 (+143) = NilCheck <void> v4 v66
      • v70 (143) = OffPtr <**m> [48] v4
      • v71 (143) = Load <*m> v70 v66
      • v73 (143) = NeqPtr <bool> v71 v72
    • If v73b12 b13 (line 143)
    • b12: ← b11
      • v77 (+144) = Store <mem> {string} v75 v74 v66
      • v78 (144) = StaticCall <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = StaticCall <mem> {runtime.init} v66
      • v81 (+148) = StaticCall <mem> {"".nanotime} [8] v80
      • v83 (148) = Load <int64> v82 v81
      • v85 (148) = Eq64 <bool> v83 v84
    • If v85b14 b16 (line 148)
    • b14: ← b13
      • v88 (+149) = Store <mem> {string} v75 v86 v81
      • v89 (149) = StaticCall <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b16
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (153) = LocalAddr <*bool> {needUnlock} v2 v91
      • v93 (+153) = Store <mem> {bool} v92 v15 v91
      • v95 (+154) = LocalAddr <*bool> {needUnlock} v2 v93
      • v97 (+158) = Store <mem> {*bool} v96 v95 v93
      • v100 (+154) = Store <mem> {uint32} v99 v98 v97
      • v102 (154) = Store <mem> {uintptr} v101 v94 v100
      • v103 (154) = StaticCall <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b16: ← b13
    • Plainb15 (line +153)
    • b17: ← b15
      • v107 (+162) = StaticCall <mem> {"".nanotime} [8] v103
      • v108 (162) = Load <int64> v82 v107
      • v110 (162) = Store <mem> {int64} v109 v108 v107
      • v111 (+164) = StaticCall <mem> {"".gcenable} v110
      • v114 (+166) = Store <mem> {*byte} v113 v112 v111
      • v117 (166) = Store <mem> {int} v116 v115 v114
      • v118 (166) = StaticCall <mem> {runtime.makechan} [24] v117
      • v120 (166) = Load <chan bool> v119 v118
      • v122 (166) = Store <mem> {chan bool} v121 v120 v118
      • v124 (+167) = Load <bool> v123 v122
    • If v124b19 b20 (line 167)
    • b18: ← b15
      • v105 (154) = StaticCall <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b17
      • v127 (+168) = Load <unsafe.Pointer> v125 v122
      • v129 (168) = EqPtr <bool> v127 v128
    • If v129b21 b22 (line 168)
    • b20: ← b17 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = Load <uintptr> v168 v169
      • v171 (189) = ClosureCall <mem> [0] v170 v168 v169
      • v173 (+190) = Load <chan bool> v172 v171
      • v175 (190) = Store <mem> {chan bool} v174 v173 v171
      • v176 (190) = StaticCall <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v178 (192) = LocalAddr <*bool> {needUnlock} v2 v177
      • v179 (+192) = Store <mem> {bool} v178 v44 v177
      • v180 (+193) = StaticCall <mem> {"".unlockOSThread} v179
      • v182 (+195) = Load <bool> v181 v180
    • If v182b31 b33 (line 195)
    • b21: ← b19
      • v132 (+169) = Store <mem> {string} v75 v130 v122
      • v133 (169) = StaticCall <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b22: ← b19
    • If v15b23 b24
    • b23: ← b22
      • v136 (+172) = Load <unsafe.Pointer> v134 v122
      • v137 (172) = EqPtr <bool> v136 v128
    • If v137b25 b26 (line 172)
    • b24: ← b22 b28
      • v152 (+179) = Load <unsafe.Pointer> v150 v122
      • v153 (179) = EqPtr <bool> v152 v128
    • If v153b29 b30 (line 179)
    • b25: ← b23
      • v140 (+173) = Store <mem> {string} v75 v138 v122
      • v141 (173) = StaticCall <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v144 (+175) = Load <unsafe.Pointer> v142 v122
      • v145 (175) = EqPtr <bool> v144 v128
    • If v145b27 b28 (line 175)
    • b27: ← b26
      • v148 (+176) = Store <mem> {string} v75 v146 v122
      • v149 (176) = StaticCall <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b28: ← b26
    • Plainb24 (line +179)
    • b29: ← b24
      • v156 (+180) = Store <mem> {string} v75 v154 v122
      • v157 (180) = StaticCall <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = StaticCall <mem> {"".startTemplateThread} v122
      • v161 (+185) = Load <unsafe.Pointer> v160 v159
      • v163 (185) = Store <mem> {unsafe.Pointer} v162 v161 v159
      • v165 (185) = Store <mem> {unsafe.Pointer} v164 v128 v163
      • v166 (185) = StaticCall <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = StaticCall <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b32: ← b33
      • v190 (+201) = Load <uintptr> v188 v180
      • v191 (201) = ClosureCall <mem> [0] v190 v188 v180
    • If v44b34 b35 (line +202)
    • b33: ← b20
      • v185 (195) = Load <bool> v183 v180
    • If v185b31 b32 (line 195)
    • b34: ← b32
    • Plainb35 (line +210)
    • b35: ← b32 b34
      • v194 (+210) = AtomicLoad32 <uint32,mem> v192 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v198 (210) = Neq32 <bool> v196 v197
    • If v198b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = AtomicLoad32 <uint32,mem> v213 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v218 (219) = Neq32 <bool> v217 v197
    • If v218b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v201 (+212) = Less64 <bool> v199 v200
    • If v201b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = AtomicLoad32 <uint32,mem> v202 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v207 (213) = Eq32 <bool> v206 v197
    • If v207b43 b45 (line 213)
    • b41: ← b44
      • v212 (+212) = Add64 <int> v199 v211 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b44: ← b45
      • v209 (+216) = StaticCall <mem> {"".Gosched} v205
    • Plainb41 (line 216)
    • b45: ← b40
    • Plainb44 (line +216)
    • b46: ← b37
      • v222 (+220) = Store <mem> {func(*g, unsafe.Pointer) bool} v220 v219 v216
      • v223 (220) = Store <mem> {unsafe.Pointer} v164 v128 v222
      • v226 (220) = Store <mem> {waitReason} v225 v224 v223
      • v229 (220) = Store <mem> {byte} v228 v227 v226
      • v231 (220) = Store <mem> {int} v230 v211 v229
      • v232 (220) = StaticCall <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = Store <mem> {int32} v234 v233 v235
      • v237 (223) = StaticCall <mem> {"".exit} [8] v236
    • Plainb49 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b49: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
    • Plainb50 (line +226)
    • b50: ← b49
      • v240 (+226) = NilCheck <void> v238 v244
      • v241 (226) = Store <mem> {int32} v238 v233 v244
    • Plainb51 (line 226)
    • b51: ← b50
    • Plainb49 (line +226)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • opt [300303 ns]

    • b1:
      • v1 (?) = InitMem <mem>
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v4 (+111) = GetG <*g> v1 (g[*g])
      • v5 (?) = Const64 <uintptr> [0]
      • v6 (+115) = Copy <mem> v1
      • v7 (115) = OffPtr <**m> [48] v4
      • v8 (115) = Load <*m> v7 v1
      • v9 (115) = NilCheck <void> v8 v1
      • v10 (115) = OffPtr <**g> [0] v8
      • v11 (115) = Load <*g> v10 v1
      • v12 (115) = NilCheck <void> v11 v1
      • v13 (115) = OffPtr <*uintptr> [304] v11
      • v14 (115) = Store <mem> {uintptr} v13 v5 v1
      • v15 (?) = ConstBool <bool> [true]
      • v16 (?) = Const64 <uintptr> [1000000000]
      • v17 (?) = Addr <*uintptr> {"".maxstacksize} v3
      • v20 (?) = Addr <*bool> {"".mainStarted} v3
      • v23 (?) = Addr <*func()> {"".main.func1·f} v3
      • v24 (?) = OffPtr <*func()> [0] v2
      • v36 (?) = Const32 <uint32> [1]
      • v44 (?) = ConstBool <bool> [false]
      • v72 (?) = Addr <*m> {"".m0} v3
      • v75 (?) = OffPtr <*string> [0] v2
      • v82 (?) = OffPtr <*int64> [0] v2
      • v84 (?) = Const64 <int64> [0]
      • v94 (?) = Addr <*func(*bool)> {"".main.func2·f} v3
      • v96 (?) = OffPtr <**bool> [16] v2
      • v98 (?) = Const32 <uint32> [8]
      • v99 (?) = OffPtr <*uint32> [0] v2
      • v101 (?) = OffPtr <*uintptr> [8] v2
      • v109 (?) = Addr <*int64> {"".runtimeInitTime} v3
      • v112 (?) = Addr <*uint8> {type.chan bool} v3
      • v113 (?) = OffPtr <**byte> [0] v2
      • v115 (?) = Const64 <int> [0] (c[int])
      • v116 (?) = OffPtr <*int> [8] v2
      • v119 (?) = OffPtr <*chan bool> [16] v2
      • v121 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v123 (?) = Addr <*bool> {"".iscgo} v3
      • v125 (?) = Addr <*unsafe.Pointer> {_cgo_thread_start} v3
      • v128 (?) = Const64 <unsafe.Pointer> [0]
      • v134 (?) = Addr <*unsafe.Pointer> {""._cgo_setenv} v3
      • v142 (?) = Addr <*unsafe.Pointer> {""._cgo_unsetenv} v3
      • v150 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v160 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v162 (?) = OffPtr <*unsafe.Pointer> [0] v2
      • v164 (?) = OffPtr <*unsafe.Pointer> [8] v2
      • v168 (?) = Addr <*func()> {"".main_init·f} v3 (fn[func()])
      • v172 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v174 (?) = OffPtr <*chan bool> [0] v2
      • v181 (?) = Addr <*bool> {"".isarchive} v3
      • v183 (?) = Addr <*bool> {"".islibrary} v3
      • v188 (?) = Addr <*func()> {"".main_main·f} v3 (fn[func()])
      • v192 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v197 (?) = Const32 <uint32> [0]
      • v200 (?) = Const64 <int> [1000]
      • v202 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v211 (?) = Const64 <int> [1]
      • v213 (?) = Addr <*uint32> {"".panicking} v3
      • v219 (?) = ConstNil <func(*g, unsafe.Pointer) bool>
      • v220 (?) = OffPtr <*func(*g, unsafe.Pointer) bool> [0] v2
      • v224 (?) = Const8 <waitReason> [8]
      • v225 (?) = OffPtr <*waitReason> [16] v2
      • v227 (?) = Const8 <byte> [16]
      • v228 (?) = OffPtr <*byte> [17] v2
      • v230 (?) = OffPtr <*int> [24] v2
      • v233 (?) = Const32 <int32> [0]
      • v234 (?) = OffPtr <*int32> [0] v2
      • v238 (?) = ConstNil <*int32> (x[*int32])
      • v242 (?) = SB <uintptr>
      • v239 (?) = Const64 <int> [22]
      • v208 (?) = SB <uintptr>
      • v210 (?) = Const64 <int> [23]
      • v193 (?) = SB <uintptr>
      • v184 (?) = Const64 <int> [25]
      • v186 (?) = SB <uintptr>
      • v158 (?) = Const64 <int> [19]
      • v147 (?) = SB <uintptr>
      • v143 (?) = Const64 <int> [21]
      • v151 (?) = SB <uintptr>
      • v135 (?) = Const64 <int> [37]
      • v243 (?) = Addr <*uint8> {go.string."runtime.main not on m0"} v242
      • v221 (?) = Addr <*uint8> {go.string."nanotime returning zero"} v208
      • v203 (?) = Addr <*uint8> {go.string."_cgo_thread_start missing"} v193
      • v189 (?) = Addr <*uint8> {go.string."_cgo_setenv missing"} v186
      • v155 (?) = Addr <*uint8> {go.string."_cgo_unsetenv missing"} v147
      • v139 (?) = Addr <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v151
      • v74 (?) = StringMake <string> v243 v239
      • v86 (?) = StringMake <string> v221 v210
      • v130 (?) = StringMake <string> v203 v184
      • v138 (?) = StringMake <string> v189 v158
      • v146 (?) = StringMake <string> v155 v143
      • v154 (?) = StringMake <string> v139 v135
    • Firstb2 b3 (line +120)
    • b2: ← b1
      • v19 (+121) = Store <mem> {uintptr} v17 v16 v14
    • Plainb3 (line 121)
    • b3: ← b1 b2
      • v21 (127) = Phi <mem> v14 v19
      • v22 (+127) = Store <mem> {bool} v20 v15 v21
    • Firstb4 b5 (line +129)
    • b4: ← b3
      • v26 (+130) = Store <mem> {func()} v24 v23 v22
      • v27 (130) = StaticCall <mem> {"".systemstack} [8] v26
    • Plainb5 (line 130)
    • b5: ← b3 b4
      • v28 (3614) = Phi <mem> v22 v27
      • v29 (+3614) = GetG <*g> v28
      • v30 (3614) = Copy <mem> v28
      • v31 (3614) = OffPtr <**m> [48] v29
      • v32 (3614) = Load <*m> v31 v28
      • v33 (3614) = NilCheck <void> v32 v28
      • v34 (3614) = OffPtr <*uint32> [620] v32
      • v35 (3614) = Load <uint32> v34 v28
      • v37 (3614) = Add32 <uint32> v35 v36
      • v38 (3614) = Copy <mem> v28
      • v39 (3614) = OffPtr <**m> [48] v29
      • v40 (3614) = Load <*m> v39 v28
      • v41 (3614) = NilCheck <void> v40 v28
      • v42 (3614) = OffPtr <*uint32> [620] v40
      • v43 (3614) = Store <mem> {uint32} v42 v37 v28
    • Firstb7 b6 (line +3572)
    • b6: ← b5
    • Plainb7 (line +3575)
    • b7: ← b5 b6
      • v46 (+3575) = GetG <*g> v43 (_g_[*g], g[*g])
      • v47 (+3576) = Copy <mem> v43
      • v48 (3576) = OffPtr <**m> [48] v46
      • v49 (3576) = Load <*m> v48 v43
      • v50 (3576) = NilCheck <void> v49 v43
      • v51 (3576) = OffPtr <*guintptr> [352] v49 (gp[*guintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v54 (205) = NilCheck <void> v51 v43
      • v55 (205) = Store <mem> {guintptr} v51 v53 v43
    • Plainb8 (line +3576)
    • b8: ← b7
      • v58 (+3577) = NilCheck <void> v46 v55
      • v59 (3577) = OffPtr <*muintptr> [216] v46 (mp[*muintptr])
      • v60 (3577) = NilCheck <void> v46 v55
      • v61 (3577) = OffPtr <**m> [48] v46
      • v62 (3577) = Load <*m> v61 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v65 (243) = NilCheck <void> v59 v55
      • v66 (243) = Store <mem> {muintptr} v59 v64 v55
    • Plainb9 (line +3577)
    • b9: ← b8
    • Plainb10 (line 143)
    • b10: ← b9
    • Plainb11 (line 143)
    • b11: ← b10
      • v69 (+143) = NilCheck <void> v4 v66
      • v70 (143) = OffPtr <**m> [48] v4
      • v71 (143) = Load <*m> v70 v66
      • v73 (143) = NeqPtr <bool> v71 v72
    • If v73b12 b13 (line 143)
    • b12: ← b11
      • v77 (+144) = Store <mem> {string} v75 v74 v66
      • v78 (144) = StaticCall <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = StaticCall <mem> {runtime.init} v66
      • v81 (+148) = StaticCall <mem> {"".nanotime} [8] v80
      • v83 (148) = Load <int64> v82 v81
      • v85 (148) = Eq64 <bool> v83 v84
    • If v85b14 b16 (line 148)
    • b14: ← b13
      • v88 (+149) = Store <mem> {string} v75 v86 v81
      • v89 (149) = StaticCall <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b16
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (153) = LocalAddr <*bool> {needUnlock} v2 v91
      • v93 (+153) = Store <mem> {bool} v92 v15 v91
      • v95 (+154) = LocalAddr <*bool> {needUnlock} v2 v93
      • v97 (+158) = Store <mem> {*bool} v96 v95 v93
      • v100 (+154) = Store <mem> {uint32} v99 v98 v97
      • v102 (154) = Store <mem> {uintptr} v101 v94 v100
      • v103 (154) = StaticCall <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b16: ← b13
    • Plainb15 (line +153)
    • b17: ← b15
      • v107 (+162) = StaticCall <mem> {"".nanotime} [8] v103
      • v108 (162) = Load <int64> v82 v107
      • v110 (162) = Store <mem> {int64} v109 v108 v107
      • v111 (+164) = StaticCall <mem> {"".gcenable} v110
      • v114 (+166) = Store <mem> {*byte} v113 v112 v111
      • v117 (166) = Store <mem> {int} v116 v115 v114
      • v118 (166) = StaticCall <mem> {runtime.makechan} [24] v117
      • v120 (166) = Load <chan bool> v119 v118
      • v122 (166) = Store <mem> {chan bool} v121 v120 v118
      • v124 (+167) = Load <bool> v123 v122
    • If v124b19 b20 (line 167)
    • b18: ← b15
      • v105 (154) = StaticCall <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b17
      • v127 (+168) = Load <unsafe.Pointer> v125 v122
      • v131 (168) = IsNonNil <bool> v127
      • v129 (168) = Not <bool> v131
    • If v131b22 b21 (line 168)
    • b20: ← b17 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = Load <uintptr> v168 v169
      • v171 (189) = ClosureCall <mem> [0] v170 v168 v169
      • v173 (+190) = Load <chan bool> v172 v171
      • v175 (190) = Store <mem> {chan bool} v174 v173 v171
      • v176 (190) = StaticCall <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v178 (192) = LocalAddr <*bool> {needUnlock} v2 v177
      • v179 (+192) = Store <mem> {bool} v178 v44 v177
      • v180 (+193) = StaticCall <mem> {"".unlockOSThread} v179
      • v182 (+195) = Load <bool> v181 v180
    • If v182b31 b33 (line 195)
    • b21: ← b19
      • v132 (+169) = Store <mem> {string} v75 v130 v122
      • v133 (169) = StaticCall <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b22: ← b19
    • Firstb23 b24
    • b23: ← b22
      • v136 (+172) = Load <unsafe.Pointer> v134 v122
      • v126 (172) = IsNonNil <bool> v136
      • v137 (172) = Not <bool> v126
    • If v126b26 b25 (line 172)
    • b24: ← b22 b28
      • v152 (+179) = Load <unsafe.Pointer> v150 v122
      • v104 (179) = IsNonNil <bool> v152
      • v153 (179) = Not <bool> v104
    • If v104b30 b29 (line 179)
    • b25: ← b23
      • v140 (+173) = Store <mem> {string} v75 v138 v122
      • v141 (173) = StaticCall <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v144 (+175) = Load <unsafe.Pointer> v142 v122
      • v106 (175) = IsNonNil <bool> v144
      • v145 (175) = Not <bool> v106
    • If v106b28 b27 (line 175)
    • b27: ← b26
      • v148 (+176) = Store <mem> {string} v75 v146 v122
      • v149 (176) = StaticCall <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b28: ← b26
    • Plainb24 (line +179)
    • b29: ← b24
      • v156 (+180) = Store <mem> {string} v75 v154 v122
      • v157 (180) = StaticCall <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = StaticCall <mem> {"".startTemplateThread} v122
      • v161 (+185) = Load <unsafe.Pointer> v160 v159
      • v163 (185) = Store <mem> {unsafe.Pointer} v162 v161 v159
      • v165 (185) = Store <mem> {unsafe.Pointer} v164 v128 v163
      • v166 (185) = StaticCall <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = StaticCall <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b32: ← b33
      • v190 (+201) = Load <uintptr> v188 v180
      • v191 (201) = ClosureCall <mem> [0] v190 v188 v180
    • Firstb35 b34 (line +202)
    • b33: ← b20
      • v185 (195) = Load <bool> v183 v180
    • If v185b31 b32 (line 195)
    • b34: ← b32
    • Plainb35 (line +210)
    • b35: ← b32 b34
      • v194 (+210) = AtomicLoad32 <uint32,mem> v192 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v198 (210) = Neq32 <bool> v196 v197
    • If v198b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = AtomicLoad32 <uint32,mem> v213 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v218 (219) = Neq32 <bool> v217 v197
    • If v218b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v201 (+212) = Less64 <bool> v199 v200
    • If v201b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = AtomicLoad32 <uint32,mem> v202 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v207 (213) = Eq32 <bool> v206 v197
    • If v207b43 b45 (line 213)
    • b41: ← b44
      • v212 (+212) = Add64 <int> v199 v211 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b44: ← b45
      • v209 (+216) = StaticCall <mem> {"".Gosched} v205
    • Plainb41 (line 216)
    • b45: ← b40
    • Plainb44 (line +216)
    • b46: ← b37
      • v222 (+220) = Store <mem> {func(*g, unsafe.Pointer) bool} v220 v219 v216
      • v223 (220) = Store <mem> {unsafe.Pointer} v164 v128 v222
      • v226 (220) = Store <mem> {waitReason} v225 v224 v223
      • v229 (220) = Store <mem> {byte} v228 v227 v226
      • v231 (220) = Store <mem> {int} v230 v211 v229
      • v232 (220) = StaticCall <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = Store <mem> {int32} v234 v233 v235
      • v237 (223) = StaticCall <mem> {"".exit} [8] v236
    • Plainb49 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b49: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
    • Plainb50 (line +226)
    • b50: ← b49
      • v240 (+226) = NilCheck <void> v238 v244
      • v241 (226) = Store <mem> {int32} v238 v233 v244
    • Plainb51 (line 226)
    • b51: ← b50
    • Plainb49 (line +226)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • zero arg cse [243178 ns]

    • b1:
      • v1 (?) = InitMem <mem>
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v4 (+111) = GetG <*g> v1 (g[*g])
      • v5 (?) = Const64 <uintptr> [0]
      • v6 (+115) = Copy <mem> v1
      • v7 (115) = OffPtr <**m> [48] v4
      • v8 (115) = Load <*m> v7 v1
      • v9 (115) = NilCheck <void> v8 v1
      • v10 (115) = OffPtr <**g> [0] v8
      • v11 (115) = Load <*g> v10 v1
      • v12 (115) = NilCheck <void> v11 v1
      • v13 (115) = OffPtr <*uintptr> [304] v11
      • v14 (115) = Store <mem> {uintptr} v13 v5 v1
      • v15 (?) = ConstBool <bool> [true]
      • v16 (?) = Const64 <uintptr> [1000000000]
      • v17 (?) = Addr <*uintptr> {"".maxstacksize} v3
      • v20 (?) = Addr <*bool> {"".mainStarted} v3
      • v23 (?) = Addr <*func()> {"".main.func1·f} v3
      • v24 (?) = OffPtr <*func()> [0] v2
      • v36 (?) = Const32 <uint32> [1]
      • v44 (?) = ConstBool <bool> [false]
      • v72 (?) = Addr <*m> {"".m0} v3
      • v75 (?) = OffPtr <*string> [0] v2
      • v82 (?) = OffPtr <*int64> [0] v2
      • v84 (?) = Const64 <int64> [0]
      • v94 (?) = Addr <*func(*bool)> {"".main.func2·f} v3
      • v96 (?) = OffPtr <**bool> [16] v2
      • v98 (?) = Const32 <uint32> [8]
      • v99 (?) = OffPtr <*uint32> [0] v2
      • v101 (?) = OffPtr <*uintptr> [8] v2
      • v109 (?) = Addr <*int64> {"".runtimeInitTime} v3
      • v112 (?) = Addr <*uint8> {type.chan bool} v3
      • v113 (?) = OffPtr <**byte> [0] v2
      • v115 (?) = Const64 <int> [0] (c[int])
      • v116 (?) = OffPtr <*int> [8] v2
      • v119 (?) = OffPtr <*chan bool> [16] v2
      • v121 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v123 (?) = Addr <*bool> {"".iscgo} v3
      • v125 (?) = Addr <*unsafe.Pointer> {_cgo_thread_start} v3
      • v128 (?) = Const64 <unsafe.Pointer> [0]
      • v134 (?) = Addr <*unsafe.Pointer> {""._cgo_setenv} v3
      • v142 (?) = Addr <*unsafe.Pointer> {""._cgo_unsetenv} v3
      • v150 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v160 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v162 (?) = OffPtr <*unsafe.Pointer> [0] v2
      • v164 (?) = OffPtr <*unsafe.Pointer> [8] v2
      • v168 (?) = Addr <*func()> {"".main_init·f} v3 (fn[func()])
      • v172 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v174 (?) = OffPtr <*chan bool> [0] v2
      • v181 (?) = Addr <*bool> {"".isarchive} v3
      • v183 (?) = Addr <*bool> {"".islibrary} v3
      • v188 (?) = Addr <*func()> {"".main_main·f} v3 (fn[func()])
      • v192 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v197 (?) = Const32 <uint32> [0]
      • v200 (?) = Const64 <int> [1000]
      • v202 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v211 (?) = Const64 <int> [1]
      • v213 (?) = Addr <*uint32> {"".panicking} v3
      • v219 (?) = ConstNil <func(*g, unsafe.Pointer) bool>
      • v220 (?) = OffPtr <*func(*g, unsafe.Pointer) bool> [0] v2
      • v224 (?) = Const8 <waitReason> [8]
      • v225 (?) = OffPtr <*waitReason> [16] v2
      • v227 (?) = Const8 <byte> [16]
      • v228 (?) = OffPtr <*byte> [17] v2
      • v230 (?) = OffPtr <*int> [24] v2
      • v233 (?) = Const32 <int32> [0]
      • v234 (?) = OffPtr <*int32> [0] v2
      • v238 (?) = ConstNil <*int32> (x[*int32])
      • v243 (?) = Addr <*uint8> {go.string."runtime.main not on m0"} v3
      • v242 (?) = SB <uintptr>
      • v239 (?) = Const64 <int> [22]
      • v221 (?) = Addr <*uint8> {go.string."nanotime returning zero"} v3
      • v208 (?) = SB <uintptr>
      • v210 (?) = Const64 <int> [23]
      • v203 (?) = Addr <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v193 (?) = SB <uintptr>
      • v184 (?) = Const64 <int> [25]
      • v189 (?) = Addr <*uint8> {go.string."_cgo_setenv missing"} v3
      • v186 (?) = SB <uintptr>
      • v158 (?) = Const64 <int> [19]
      • v155 (?) = Addr <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v147 (?) = SB <uintptr>
      • v143 (?) = Const64 <int> [21]
      • v139 (?) = Addr <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v151 (?) = SB <uintptr>
      • v135 (?) = Const64 <int> [37]
      • v74 (?) = StringMake <string> v243 v239
      • v86 (?) = StringMake <string> v221 v210
      • v130 (?) = StringMake <string> v203 v184
      • v138 (?) = StringMake <string> v189 v158
      • v146 (?) = StringMake <string> v155 v143
      • v154 (?) = StringMake <string> v139 v135
    • Firstb2 b3 (line +120)
    • b2: ← b1
      • v19 (+121) = Store <mem> {uintptr} v17 v16 v14
    • Plainb3 (line 121)
    • b3: ← b1 b2
      • v21 (127) = Phi <mem> v14 v19
      • v22 (+127) = Store <mem> {bool} v20 v15 v21
    • Firstb4 b5 (line +129)
    • b4: ← b3
      • v26 (+130) = Store <mem> {func()} v24 v23 v22
      • v27 (130) = StaticCall <mem> {"".systemstack} [8] v26
    • Plainb5 (line 130)
    • b5: ← b3 b4
      • v28 (3614) = Phi <mem> v22 v27
      • v29 (+3614) = GetG <*g> v28
      • v30 (3614) = Copy <mem> v28
      • v31 (3614) = OffPtr <**m> [48] v29
      • v32 (3614) = Load <*m> v31 v28
      • v33 (3614) = NilCheck <void> v32 v28
      • v34 (3614) = OffPtr <*uint32> [620] v32
      • v35 (3614) = Load <uint32> v34 v28
      • v37 (3614) = Add32 <uint32> v35 v36
      • v38 (3614) = Copy <mem> v28
      • v39 (3614) = OffPtr <**m> [48] v29
      • v40 (3614) = Load <*m> v39 v28
      • v41 (3614) = NilCheck <void> v40 v28
      • v42 (3614) = OffPtr <*uint32> [620] v40
      • v43 (3614) = Store <mem> {uint32} v42 v37 v28
    • Firstb7 b6 (line +3572)
    • b6: ← b5
    • Plainb7 (line +3575)
    • b7: ← b5 b6
      • v46 (+3575) = GetG <*g> v43 (_g_[*g], g[*g])
      • v47 (+3576) = Copy <mem> v43
      • v48 (3576) = OffPtr <**m> [48] v46
      • v49 (3576) = Load <*m> v48 v43
      • v50 (3576) = NilCheck <void> v49 v43
      • v51 (3576) = OffPtr <*guintptr> [352] v49 (gp[*guintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v54 (205) = NilCheck <void> v51 v43
      • v55 (205) = Store <mem> {guintptr} v51 v53 v43
    • Plainb8 (line +3576)
    • b8: ← b7
      • v58 (+3577) = NilCheck <void> v46 v55
      • v59 (3577) = OffPtr <*muintptr> [216] v46 (mp[*muintptr])
      • v60 (3577) = NilCheck <void> v46 v55
      • v61 (3577) = OffPtr <**m> [48] v46
      • v62 (3577) = Load <*m> v61 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v65 (243) = NilCheck <void> v59 v55
      • v66 (243) = Store <mem> {muintptr} v59 v64 v55
    • Plainb9 (line +3577)
    • b9: ← b8
    • Plainb10 (line 143)
    • b10: ← b9
    • Plainb11 (line 143)
    • b11: ← b10
      • v69 (+143) = NilCheck <void> v4 v66
      • v70 (143) = OffPtr <**m> [48] v4
      • v71 (143) = Load <*m> v70 v66
      • v73 (143) = NeqPtr <bool> v71 v72
    • If v73b12 b13 (line 143)
    • b12: ← b11
      • v77 (+144) = Store <mem> {string} v75 v74 v66
      • v78 (144) = StaticCall <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = StaticCall <mem> {runtime.init} v66
      • v81 (+148) = StaticCall <mem> {"".nanotime} [8] v80
      • v83 (148) = Load <int64> v82 v81
      • v85 (148) = Eq64 <bool> v83 v84
    • If v85b14 b16 (line 148)
    • b14: ← b13
      • v88 (+149) = Store <mem> {string} v75 v86 v81
      • v89 (149) = StaticCall <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b16
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (153) = LocalAddr <*bool> {needUnlock} v2 v91
      • v93 (+153) = Store <mem> {bool} v92 v15 v91
      • v95 (+154) = LocalAddr <*bool> {needUnlock} v2 v93
      • v97 (+158) = Store <mem> {*bool} v96 v95 v93
      • v100 (+154) = Store <mem> {uint32} v99 v98 v97
      • v102 (154) = Store <mem> {uintptr} v101 v94 v100
      • v103 (154) = StaticCall <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b16: ← b13
    • Plainb15 (line +153)
    • b17: ← b15
      • v107 (+162) = StaticCall <mem> {"".nanotime} [8] v103
      • v108 (162) = Load <int64> v82 v107
      • v110 (162) = Store <mem> {int64} v109 v108 v107
      • v111 (+164) = StaticCall <mem> {"".gcenable} v110
      • v114 (+166) = Store <mem> {*byte} v113 v112 v111
      • v117 (166) = Store <mem> {int} v116 v115 v114
      • v118 (166) = StaticCall <mem> {runtime.makechan} [24] v117
      • v120 (166) = Load <chan bool> v119 v118
      • v122 (166) = Store <mem> {chan bool} v121 v120 v118
      • v124 (+167) = Load <bool> v123 v122
    • If v124b19 b20 (line 167)
    • b18: ← b15
      • v105 (154) = StaticCall <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b17
      • v127 (+168) = Load <unsafe.Pointer> v125 v122
      • v131 (168) = IsNonNil <bool> v127
      • v129 (168) = Not <bool> v131
    • If v131b22 b21 (line 168)
    • b20: ← b17 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = Load <uintptr> v168 v169
      • v171 (189) = ClosureCall <mem> [0] v170 v168 v169
      • v173 (+190) = Load <chan bool> v172 v171
      • v175 (190) = Store <mem> {chan bool} v174 v173 v171
      • v176 (190) = StaticCall <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v178 (192) = LocalAddr <*bool> {needUnlock} v2 v177
      • v179 (+192) = Store <mem> {bool} v178 v44 v177
      • v180 (+193) = StaticCall <mem> {"".unlockOSThread} v179
      • v182 (+195) = Load <bool> v181 v180
    • If v182b31 b33 (line 195)
    • b21: ← b19
      • v132 (+169) = Store <mem> {string} v75 v130 v122
      • v133 (169) = StaticCall <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b22: ← b19
    • Firstb23 b24
    • b23: ← b22
      • v136 (+172) = Load <unsafe.Pointer> v134 v122
      • v126 (172) = IsNonNil <bool> v136
      • v137 (172) = Not <bool> v126
    • If v126b26 b25 (line 172)
    • b24: ← b22 b28
      • v152 (+179) = Load <unsafe.Pointer> v150 v122
      • v104 (179) = IsNonNil <bool> v152
      • v153 (179) = Not <bool> v104
    • If v104b30 b29 (line 179)
    • b25: ← b23
      • v140 (+173) = Store <mem> {string} v75 v138 v122
      • v141 (173) = StaticCall <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v144 (+175) = Load <unsafe.Pointer> v142 v122
      • v106 (175) = IsNonNil <bool> v144
      • v145 (175) = Not <bool> v106
    • If v106b28 b27 (line 175)
    • b27: ← b26
      • v148 (+176) = Store <mem> {string} v75 v146 v122
      • v149 (176) = StaticCall <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b28: ← b26
    • Plainb24 (line +179)
    • b29: ← b24
      • v156 (+180) = Store <mem> {string} v75 v154 v122
      • v157 (180) = StaticCall <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = StaticCall <mem> {"".startTemplateThread} v122
      • v161 (+185) = Load <unsafe.Pointer> v160 v159
      • v163 (185) = Store <mem> {unsafe.Pointer} v162 v161 v159
      • v165 (185) = Store <mem> {unsafe.Pointer} v164 v128 v163
      • v166 (185) = StaticCall <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = StaticCall <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b32: ← b33
      • v190 (+201) = Load <uintptr> v188 v180
      • v191 (201) = ClosureCall <mem> [0] v190 v188 v180
    • Firstb35 b34 (line +202)
    • b33: ← b20
      • v185 (195) = Load <bool> v183 v180
    • If v185b31 b32 (line 195)
    • b34: ← b32
    • Plainb35 (line +210)
    • b35: ← b32 b34
      • v194 (+210) = AtomicLoad32 <uint32,mem> v192 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v198 (210) = Neq32 <bool> v196 v197
    • If v198b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = AtomicLoad32 <uint32,mem> v213 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v218 (219) = Neq32 <bool> v217 v197
    • If v218b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v201 (+212) = Less64 <bool> v199 v200
    • If v201b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = AtomicLoad32 <uint32,mem> v202 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v207 (213) = Eq32 <bool> v206 v197
    • If v207b43 b45 (line 213)
    • b41: ← b44
      • v212 (+212) = Add64 <int> v199 v211 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b44: ← b45
      • v209 (+216) = StaticCall <mem> {"".Gosched} v205
    • Plainb41 (line 216)
    • b45: ← b40
    • Plainb44 (line +216)
    • b46: ← b37
      • v222 (+220) = Store <mem> {func(*g, unsafe.Pointer) bool} v220 v219 v216
      • v223 (220) = Store <mem> {unsafe.Pointer} v164 v128 v222
      • v226 (220) = Store <mem> {waitReason} v225 v224 v223
      • v229 (220) = Store <mem> {byte} v228 v227 v226
      • v231 (220) = Store <mem> {int} v230 v211 v229
      • v232 (220) = StaticCall <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = Store <mem> {int32} v234 v233 v235
      • v237 (223) = StaticCall <mem> {"".exit} [8] v236
    • Plainb49 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b49: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
    • Plainb50 (line +226)
    • b50: ← b49
      • v240 (+226) = NilCheck <void> v238 v244
      • v241 (226) = Store <mem> {int32} v238 v233 v244
    • Plainb51 (line 226)
    • b51: ← b50
    • Plainb49 (line +226)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • opt deadcode [115843 ns]

    • b1:
      • v1 (?) = InitMem <mem>
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v4 (+111) = GetG <*g> v1 (g[*g])
      • v5 (?) = Const64 <uintptr> [0]
      • v7 (+115) = OffPtr <**m> [48] v4
      • v8 (115) = Load <*m> v7 v1
      • v9 (115) = NilCheck <void> v8 v1
      • v10 (115) = OffPtr <**g> [0] v8
      • v11 (115) = Load <*g> v10 v1
      • v12 (115) = NilCheck <void> v11 v1
      • v13 (115) = OffPtr <*uintptr> [304] v11
      • v14 (115) = Store <mem> {uintptr} v13 v5 v1
      • v15 (?) = ConstBool <bool> [true]
      • v16 (?) = Const64 <uintptr> [1000000000]
      • v17 (?) = Addr <*uintptr> {"".maxstacksize} v3
      • v20 (?) = Addr <*bool> {"".mainStarted} v3
      • v23 (?) = Addr <*func()> {"".main.func1·f} v3
      • v24 (?) = OffPtr <*func()> [0] v2
      • v36 (?) = Const32 <uint32> [1]
      • v44 (?) = ConstBool <bool> [false]
      • v72 (?) = Addr <*m> {"".m0} v3
      • v75 (?) = OffPtr <*string> [0] v2
      • v82 (?) = OffPtr <*int64> [0] v2
      • v84 (?) = Const64 <int64> [0]
      • v94 (?) = Addr <*func(*bool)> {"".main.func2·f} v3
      • v96 (?) = OffPtr <**bool> [16] v2
      • v98 (?) = Const32 <uint32> [8]
      • v99 (?) = OffPtr <*uint32> [0] v2
      • v101 (?) = OffPtr <*uintptr> [8] v2
      • v109 (?) = Addr <*int64> {"".runtimeInitTime} v3
      • v112 (?) = Addr <*uint8> {type.chan bool} v3
      • v113 (?) = OffPtr <**byte> [0] v2
      • v115 (?) = Const64 <int> [0] (c[int])
      • v116 (?) = OffPtr <*int> [8] v2
      • v119 (?) = OffPtr <*chan bool> [16] v2
      • v121 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v123 (?) = Addr <*bool> {"".iscgo} v3
      • v125 (?) = Addr <*unsafe.Pointer> {_cgo_thread_start} v3
      • v128 (?) = Const64 <unsafe.Pointer> [0]
      • v134 (?) = Addr <*unsafe.Pointer> {""._cgo_setenv} v3
      • v142 (?) = Addr <*unsafe.Pointer> {""._cgo_unsetenv} v3
      • v150 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v160 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v162 (?) = OffPtr <*unsafe.Pointer> [0] v2
      • v164 (?) = OffPtr <*unsafe.Pointer> [8] v2
      • v168 (?) = Addr <*func()> {"".main_init·f} v3 (fn[func()])
      • v172 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v174 (?) = OffPtr <*chan bool> [0] v2
      • v181 (?) = Addr <*bool> {"".isarchive} v3
      • v183 (?) = Addr <*bool> {"".islibrary} v3
      • v188 (?) = Addr <*func()> {"".main_main·f} v3 (fn[func()])
      • v192 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v197 (?) = Const32 <uint32> [0]
      • v200 (?) = Const64 <int> [1000]
      • v202 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v211 (?) = Const64 <int> [1]
      • v213 (?) = Addr <*uint32> {"".panicking} v3
      • v219 (?) = ConstNil <func(*g, unsafe.Pointer) bool>
      • v220 (?) = OffPtr <*func(*g, unsafe.Pointer) bool> [0] v2
      • v224 (?) = Const8 <waitReason> [8]
      • v225 (?) = OffPtr <*waitReason> [16] v2
      • v227 (?) = Const8 <byte> [16]
      • v228 (?) = OffPtr <*byte> [17] v2
      • v230 (?) = OffPtr <*int> [24] v2
      • v233 (?) = Const32 <int32> [0]
      • v234 (?) = OffPtr <*int32> [0] v2
      • v238 (?) = ConstNil <*int32> (x[*int32])
      • v243 (?) = Addr <*uint8> {go.string."runtime.main not on m0"} v3
      • v239 (?) = Const64 <int> [22]
      • v221 (?) = Addr <*uint8> {go.string."nanotime returning zero"} v3
      • v210 (?) = Const64 <int> [23]
      • v203 (?) = Addr <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v184 (?) = Const64 <int> [25]
      • v189 (?) = Addr <*uint8> {go.string."_cgo_setenv missing"} v3
      • v158 (?) = Const64 <int> [19]
      • v155 (?) = Addr <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v143 (?) = Const64 <int> [21]
      • v139 (?) = Addr <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v135 (?) = Const64 <int> [37]
      • v74 (?) = StringMake <string> v243 v239
      • v86 (?) = StringMake <string> v221 v210
      • v130 (?) = StringMake <string> v203 v184
      • v138 (?) = StringMake <string> v189 v158
      • v146 (?) = StringMake <string> v155 v143
      • v154 (?) = StringMake <string> v139 v135
    • Plainb2 (line +120)
    • b2: ← b1
      • v19 (+121) = Store <mem> {uintptr} v17 v16 v14
    • Plainb3 (line 121)
    • b3: ← b2
      • v22 (+127) = Store <mem> {bool} v20 v15 v19
    • Plainb4 (line +129)
    • b4: ← b3
      • v26 (+130) = Store <mem> {func()} v24 v23 v22
      • v27 (130) = StaticCall <mem> {"".systemstack} [8] v26
    • Plainb5 (line 130)
    • b5: ← b4
      • v29 (+3614) = GetG <*g> v27
      • v31 (3614) = OffPtr <**m> [48] v29
      • v32 (3614) = Load <*m> v31 v27
      • v33 (3614) = NilCheck <void> v32 v27
      • v34 (3614) = OffPtr <*uint32> [620] v32
      • v35 (3614) = Load <uint32> v34 v27
      • v37 (3614) = Add32 <uint32> v35 v36
      • v39 (3614) = OffPtr <**m> [48] v29
      • v40 (3614) = Load <*m> v39 v27
      • v41 (3614) = NilCheck <void> v40 v27
      • v42 (3614) = OffPtr <*uint32> [620] v40
      • v43 (3614) = Store <mem> {uint32} v42 v37 v27
    • Plainb7 (line +3572)
    • b7: ← b5
      • v46 (+3575) = GetG <*g> v43 (_g_[*g], g[*g])
      • v48 (+3576) = OffPtr <**m> [48] v46
      • v49 (3576) = Load <*m> v48 v43
      • v50 (3576) = NilCheck <void> v49 v43
      • v51 (3576) = OffPtr <*guintptr> [352] v49 (gp[*guintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v54 (205) = NilCheck <void> v51 v43
      • v55 (205) = Store <mem> {guintptr} v51 v53 v43
    • Plainb8 (line +3576)
    • b8: ← b7
      • v58 (+3577) = NilCheck <void> v46 v55
      • v59 (3577) = OffPtr <*muintptr> [216] v46 (mp[*muintptr])
      • v60 (3577) = NilCheck <void> v46 v55
      • v61 (3577) = OffPtr <**m> [48] v46
      • v62 (3577) = Load <*m> v61 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v65 (243) = NilCheck <void> v59 v55
      • v66 (243) = Store <mem> {muintptr} v59 v64 v55
    • Plainb9 (line +3577)
    • b9: ← b8
    • Plainb10 (line 143)
    • b10: ← b9
    • Plainb11 (line 143)
    • b11: ← b10
      • v69 (+143) = NilCheck <void> v4 v66
      • v70 (143) = OffPtr <**m> [48] v4
      • v71 (143) = Load <*m> v70 v66
      • v73 (143) = NeqPtr <bool> v71 v72
    • If v73b12 b13 (line 143)
    • b12: ← b11
      • v77 (+144) = Store <mem> {string} v75 v74 v66
      • v78 (144) = StaticCall <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = StaticCall <mem> {runtime.init} v66
      • v81 (+148) = StaticCall <mem> {"".nanotime} [8] v80
      • v83 (148) = Load <int64> v82 v81
      • v85 (148) = Eq64 <bool> v83 v84
    • If v85b14 b16 (line 148)
    • b14: ← b13
      • v88 (+149) = Store <mem> {string} v75 v86 v81
      • v89 (149) = StaticCall <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b16
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (153) = LocalAddr <*bool> {needUnlock} v2 v91
      • v93 (+153) = Store <mem> {bool} v92 v15 v91
      • v95 (+154) = LocalAddr <*bool> {needUnlock} v2 v93
      • v97 (+158) = Store <mem> {*bool} v96 v95 v93
      • v100 (+154) = Store <mem> {uint32} v99 v98 v97
      • v102 (154) = Store <mem> {uintptr} v101 v94 v100
      • v103 (154) = StaticCall <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b16: ← b13
    • Plainb15 (line +153)
    • b17: ← b15
      • v107 (+162) = StaticCall <mem> {"".nanotime} [8] v103
      • v108 (162) = Load <int64> v82 v107
      • v110 (162) = Store <mem> {int64} v109 v108 v107
      • v111 (+164) = StaticCall <mem> {"".gcenable} v110
      • v114 (+166) = Store <mem> {*byte} v113 v112 v111
      • v117 (166) = Store <mem> {int} v116 v115 v114
      • v118 (166) = StaticCall <mem> {runtime.makechan} [24] v117
      • v120 (166) = Load <chan bool> v119 v118
      • v122 (166) = Store <mem> {chan bool} v121 v120 v118
      • v124 (+167) = Load <bool> v123 v122
    • If v124b19 b20 (line 167)
    • b18: ← b15
      • v105 (154) = StaticCall <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b17
      • v127 (+168) = Load <unsafe.Pointer> v125 v122
      • v131 (168) = IsNonNil <bool> v127
    • If v131b22 b21 (line 168)
    • b20: ← b17 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = Load <uintptr> v168 v169
      • v171 (189) = ClosureCall <mem> [0] v170 v168 v169
      • v173 (+190) = Load <chan bool> v172 v171
      • v175 (190) = Store <mem> {chan bool} v174 v173 v171
      • v176 (190) = StaticCall <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v178 (192) = LocalAddr <*bool> {needUnlock} v2 v177
      • v179 (+192) = Store <mem> {bool} v178 v44 v177
      • v180 (+193) = StaticCall <mem> {"".unlockOSThread} v179
      • v182 (+195) = Load <bool> v181 v180
    • If v182b31 b33 (line 195)
    • b21: ← b19
      • v132 (+169) = Store <mem> {string} v75 v130 v122
      • v133 (169) = StaticCall <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b22: ← b19
    • Plainb23
    • b23: ← b22
      • v136 (+172) = Load <unsafe.Pointer> v134 v122
      • v126 (172) = IsNonNil <bool> v136
    • If v126b26 b25 (line 172)
    • b24: ← b28
      • v152 (+179) = Load <unsafe.Pointer> v150 v122
      • v104 (179) = IsNonNil <bool> v152
    • If v104b30 b29 (line 179)
    • b25: ← b23
      • v140 (+173) = Store <mem> {string} v75 v138 v122
      • v141 (173) = StaticCall <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v144 (+175) = Load <unsafe.Pointer> v142 v122
      • v106 (175) = IsNonNil <bool> v144
    • If v106b28 b27 (line 175)
    • b27: ← b26
      • v148 (+176) = Store <mem> {string} v75 v146 v122
      • v149 (176) = StaticCall <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b28: ← b26
    • Plainb24 (line +179)
    • b29: ← b24
      • v156 (+180) = Store <mem> {string} v75 v154 v122
      • v157 (180) = StaticCall <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = StaticCall <mem> {"".startTemplateThread} v122
      • v161 (+185) = Load <unsafe.Pointer> v160 v159
      • v163 (185) = Store <mem> {unsafe.Pointer} v162 v161 v159
      • v165 (185) = Store <mem> {unsafe.Pointer} v164 v128 v163
      • v166 (185) = StaticCall <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = StaticCall <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b32: ← b33
      • v190 (+201) = Load <uintptr> v188 v180
      • v191 (201) = ClosureCall <mem> [0] v190 v188 v180
    • Plainb35 (line +202)
    • b33: ← b20
      • v185 (195) = Load <bool> v183 v180
    • If v185b31 b32 (line 195)
    • b35: ← b32
      • v194 (+210) = AtomicLoad32 <uint32,mem> v192 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v198 (210) = Neq32 <bool> v196 v197
    • If v198b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = AtomicLoad32 <uint32,mem> v213 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v218 (219) = Neq32 <bool> v217 v197
    • If v218b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v201 (+212) = Less64 <bool> v199 v200
    • If v201b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = AtomicLoad32 <uint32,mem> v202 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v207 (213) = Eq32 <bool> v206 v197
    • If v207b43 b45 (line 213)
    • b41: ← b44
      • v212 (+212) = Add64 <int> v199 v211 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b44: ← b45
      • v209 (+216) = StaticCall <mem> {"".Gosched} v205
    • Plainb41 (line 216)
    • b45: ← b40
    • Plainb44 (line +216)
    • b46: ← b37
      • v222 (+220) = Store <mem> {func(*g, unsafe.Pointer) bool} v220 v219 v216
      • v223 (220) = Store <mem> {unsafe.Pointer} v164 v128 v222
      • v226 (220) = Store <mem> {waitReason} v225 v224 v223
      • v229 (220) = Store <mem> {byte} v228 v227 v226
      • v231 (220) = Store <mem> {int} v230 v211 v229
      • v232 (220) = StaticCall <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = Store <mem> {int32} v234 v233 v235
      • v237 (223) = StaticCall <mem> {"".exit} [8] v236
    • Plainb49 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b49: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
    • Plainb50 (line +226)
    • b50: ← b49
      • v240 (+226) = NilCheck <void> v238 v244
      • v241 (226) = Store <mem> {int32} v238 v233 v244
    • Plainb51 (line 226)
    • b51: ← b50
    • Plainb49 (line +226)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • generic cse [239434 ns]

    • b1:
      • v1 (?) = InitMem <mem>
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v4 (+111) = GetG <*g> v1 (g[*g])
      • v5 (?) = Const64 <uintptr> [0]
      • v7 (+115) = OffPtr <**m> [48] v4
      • v8 (115) = Load <*m> v7 v1
      • v9 (115) = NilCheck <void> v8 v1
      • v10 (115) = OffPtr <**g> [0] v8
      • v11 (115) = Load <*g> v10 v1
      • v12 (115) = NilCheck <void> v11 v1
      • v13 (115) = OffPtr <*uintptr> [304] v11
      • v14 (115) = Store <mem> {uintptr} v13 v5 v1
      • v15 (?) = ConstBool <bool> [true]
      • v16 (?) = Const64 <uintptr> [1000000000]
      • v17 (?) = Addr <*uintptr> {"".maxstacksize} v3
      • v20 (?) = Addr <*bool> {"".mainStarted} v3
      • v23 (?) = Addr <*func()> {"".main.func1·f} v3
      • v24 (?) = OffPtr <*func()> [0] v2
      • v36 (?) = Const32 <uint32> [1]
      • v44 (?) = ConstBool <bool> [false]
      • v72 (?) = Addr <*m> {"".m0} v3
      • v75 (?) = OffPtr <*string> [0] v2
      • v82 (?) = OffPtr <*int64> [0] v2
      • v84 (?) = Const64 <int64> [0]
      • v94 (?) = Addr <*func(*bool)> {"".main.func2·f} v3
      • v96 (?) = OffPtr <**bool> [16] v2
      • v98 (?) = Const32 <uint32> [8]
      • v99 (?) = OffPtr <*uint32> [0] v2
      • v101 (?) = OffPtr <*uintptr> [8] v2
      • v109 (?) = Addr <*int64> {"".runtimeInitTime} v3
      • v112 (?) = Addr <*uint8> {type.chan bool} v3
      • v113 (?) = OffPtr <**byte> [0] v2
      • v115 (?) = Const64 <int> [0] (c[int])
      • v116 (?) = OffPtr <*int> [8] v2
      • v119 (?) = OffPtr <*chan bool> [16] v2
      • v121 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v123 (?) = Addr <*bool> {"".iscgo} v3
      • v125 (?) = Addr <*unsafe.Pointer> {_cgo_thread_start} v3
      • v128 (?) = Const64 <unsafe.Pointer> [0]
      • v134 (?) = Addr <*unsafe.Pointer> {""._cgo_setenv} v3
      • v142 (?) = Addr <*unsafe.Pointer> {""._cgo_unsetenv} v3
      • v150 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v160 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v162 (?) = OffPtr <*unsafe.Pointer> [0] v2
      • v164 (?) = OffPtr <*unsafe.Pointer> [8] v2
      • v168 (?) = Addr <*func()> {"".main_init·f} v3 (fn[func()])
      • v172 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v174 (?) = OffPtr <*chan bool> [0] v2
      • v181 (?) = Addr <*bool> {"".isarchive} v3
      • v183 (?) = Addr <*bool> {"".islibrary} v3
      • v188 (?) = Addr <*func()> {"".main_main·f} v3 (fn[func()])
      • v192 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v197 (?) = Const32 <uint32> [0]
      • v200 (?) = Const64 <int> [1000]
      • v202 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v211 (?) = Const64 <int> [1]
      • v213 (?) = Addr <*uint32> {"".panicking} v3
      • v219 (?) = ConstNil <func(*g, unsafe.Pointer) bool>
      • v220 (?) = OffPtr <*func(*g, unsafe.Pointer) bool> [0] v2
      • v224 (?) = Const8 <waitReason> [8]
      • v225 (?) = OffPtr <*waitReason> [16] v2
      • v227 (?) = Const8 <byte> [16]
      • v228 (?) = OffPtr <*byte> [17] v2
      • v230 (?) = OffPtr <*int> [24] v2
      • v233 (?) = Const32 <int32> [0]
      • v234 (?) = OffPtr <*int32> [0] v2
      • v238 (?) = ConstNil <*int32> (x[*int32])
      • v243 (?) = Addr <*uint8> {go.string."runtime.main not on m0"} v3
      • v239 (?) = Const64 <int> [22]
      • v221 (?) = Addr <*uint8> {go.string."nanotime returning zero"} v3
      • v210 (?) = Const64 <int> [23]
      • v203 (?) = Addr <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v184 (?) = Const64 <int> [25]
      • v189 (?) = Addr <*uint8> {go.string."_cgo_setenv missing"} v3
      • v158 (?) = Const64 <int> [19]
      • v155 (?) = Addr <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v143 (?) = Const64 <int> [21]
      • v139 (?) = Addr <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v135 (?) = Const64 <int> [37]
      • v74 (?) = StringMake <string> v243 v239
      • v86 (?) = StringMake <string> v221 v210
      • v130 (?) = StringMake <string> v203 v184
      • v138 (?) = StringMake <string> v189 v158
      • v146 (?) = StringMake <string> v155 v143
      • v154 (?) = StringMake <string> v139 v135
    • Plainb2 (line +120)
    • b2: ← b1
      • v19 (+121) = Store <mem> {uintptr} v17 v16 v14
    • Plainb3 (line 121)
    • b3: ← b2
      • v22 (+127) = Store <mem> {bool} v20 v15 v19
    • Plainb4 (line +129)
    • b4: ← b3
      • v26 (+130) = Store <mem> {func()} v24 v23 v22
      • v27 (130) = StaticCall <mem> {"".systemstack} [8] v26
    • Plainb5 (line 130)
    • b5: ← b4
      • v29 (+3614) = GetG <*g> v27
      • v31 (3614) = OffPtr <**m> [48] v29
      • v32 (3614) = Load <*m> v31 v27
      • v33 (3614) = NilCheck <void> v32 v27
      • v34 (3614) = OffPtr <*uint32> [620] v32
      • v35 (3614) = Load <uint32> v34 v27
      • v37 (3614) = Add32 <uint32> v35 v36
      • v39 (3614) = OffPtr <**m> [48] v29
      • v40 (3614) = Load <*m> v31 v27
      • v41 (3614) = NilCheck <void> v32 v27
      • v42 (3614) = OffPtr <*uint32> [620] v32
      • v43 (3614) = Store <mem> {uint32} v34 v37 v27
    • Plainb7 (line +3572)
    • b7: ← b5
      • v46 (+3575) = GetG <*g> v43 (g[*g], _g_[*g])
      • v48 (+3576) = OffPtr <**m> [48] v46
      • v49 (3576) = Load <*m> v48 v43
      • v50 (3576) = NilCheck <void> v49 v43
      • v51 (3576) = OffPtr <*guintptr> [352] v49 (gp[*guintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v54 (205) = NilCheck <void> v51 v43
      • v55 (205) = Store <mem> {guintptr} v51 v53 v43
    • Plainb8 (line +3576)
    • b8: ← b7
      • v58 (+3577) = NilCheck <void> v46 v55
      • v59 (3577) = OffPtr <*muintptr> [216] v46 (mp[*muintptr])
      • v60 (3577) = NilCheck <void> v46 v55
      • v61 (3577) = OffPtr <**m> [48] v46
      • v62 (3577) = Load <*m> v48 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v65 (243) = NilCheck <void> v59 v55
      • v66 (243) = Store <mem> {muintptr} v59 v64 v55
    • Plainb9 (line +3577)
    • b9: ← b8
    • Plainb10 (line 143)
    • b10: ← b9
    • Plainb11 (line 143)
    • b11: ← b10
      • v69 (+143) = NilCheck <void> v4 v66
      • v70 (143) = OffPtr <**m> [48] v4
      • v71 (143) = Load <*m> v7 v66
      • v73 (143) = NeqPtr <bool> v71 v72
    • If v73b12 b13 (line 143)
    • b12: ← b11
      • v77 (+144) = Store <mem> {string} v75 v74 v66
      • v78 (144) = StaticCall <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = StaticCall <mem> {runtime.init} v66
      • v81 (+148) = StaticCall <mem> {"".nanotime} [8] v80
      • v83 (148) = Load <int64> v82 v81
      • v85 (148) = Eq64 <bool> v83 v84
    • If v85b14 b16 (line 148)
    • b14: ← b13
      • v88 (+149) = Store <mem> {string} v75 v86 v81
      • v89 (149) = StaticCall <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b16
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (153) = LocalAddr <*bool> {needUnlock} v2 v91
      • v93 (+153) = Store <mem> {bool} v92 v15 v91
      • v95 (+154) = LocalAddr <*bool> {needUnlock} v2 v93
      • v97 (+158) = Store <mem> {*bool} v96 v95 v93
      • v100 (+154) = Store <mem> {uint32} v99 v98 v97
      • v102 (154) = Store <mem> {uintptr} v101 v94 v100
      • v103 (154) = StaticCall <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b16: ← b13
    • Plainb15 (line +153)
    • b17: ← b15
      • v107 (+162) = StaticCall <mem> {"".nanotime} [8] v103
      • v108 (162) = Load <int64> v82 v107
      • v110 (162) = Store <mem> {int64} v109 v108 v107
      • v111 (+164) = StaticCall <mem> {"".gcenable} v110
      • v114 (+166) = Store <mem> {*byte} v113 v112 v111
      • v117 (166) = Store <mem> {int} v116 v115 v114
      • v118 (166) = StaticCall <mem> {runtime.makechan} [24] v117
      • v120 (166) = Load <chan bool> v119 v118
      • v122 (166) = Store <mem> {chan bool} v121 v120 v118
      • v124 (+167) = Load <bool> v123 v122
    • If v124b19 b20 (line 167)
    • b18: ← b15
      • v105 (154) = StaticCall <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b17
      • v127 (+168) = Load <unsafe.Pointer> v125 v122
      • v131 (168) = IsNonNil <bool> v127
    • If v131b22 b21 (line 168)
    • b20: ← b17 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = Load <uintptr> v168 v169
      • v171 (189) = ClosureCall <mem> [0] v170 v168 v169
      • v173 (+190) = Load <chan bool> v121 v171
      • v175 (190) = Store <mem> {chan bool} v174 v173 v171
      • v176 (190) = StaticCall <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v178 (192) = LocalAddr <*bool> {needUnlock} v2 v177
      • v179 (+192) = Store <mem> {bool} v178 v44 v177
      • v180 (+193) = StaticCall <mem> {"".unlockOSThread} v179
      • v182 (+195) = Load <bool> v181 v180
    • If v182b31 b33 (line 195)
    • b21: ← b19
      • v132 (+169) = Store <mem> {string} v75 v130 v122
      • v133 (169) = StaticCall <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b22: ← b19
    • Plainb23
    • b23: ← b22
      • v136 (+172) = Load <unsafe.Pointer> v134 v122
      • v126 (172) = IsNonNil <bool> v136
    • If v126b26 b25 (line 172)
    • b24: ← b28
      • v152 (+179) = Load <unsafe.Pointer> v150 v122
      • v104 (179) = IsNonNil <bool> v152
    • If v104b30 b29 (line 179)
    • b25: ← b23
      • v140 (+173) = Store <mem> {string} v75 v138 v122
      • v141 (173) = StaticCall <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v144 (+175) = Load <unsafe.Pointer> v142 v122
      • v106 (175) = IsNonNil <bool> v144
    • If v106b28 b27 (line 175)
    • b27: ← b26
      • v148 (+176) = Store <mem> {string} v75 v146 v122
      • v149 (176) = StaticCall <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b28: ← b26
    • Plainb24 (line +179)
    • b29: ← b24
      • v156 (+180) = Store <mem> {string} v75 v154 v122
      • v157 (180) = StaticCall <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = StaticCall <mem> {"".startTemplateThread} v122
      • v161 (+185) = Load <unsafe.Pointer> v150 v159
      • v163 (185) = Store <mem> {unsafe.Pointer} v162 v161 v159
      • v165 (185) = Store <mem> {unsafe.Pointer} v164 v128 v163
      • v166 (185) = StaticCall <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = StaticCall <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b32: ← b33
      • v190 (+201) = Load <uintptr> v188 v180
      • v191 (201) = ClosureCall <mem> [0] v190 v188 v180
    • Plainb35 (line +202)
    • b33: ← b20
      • v185 (195) = Load <bool> v183 v180
    • If v185b31 b32 (line 195)
    • b35: ← b32
      • v194 (+210) = AtomicLoad32 <uint32,mem> v192 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v198 (210) = Neq32 <bool> v197 v196
    • If v198b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = AtomicLoad32 <uint32,mem> v213 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v218 (219) = Neq32 <bool> v217 v197
    • If v218b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v201 (+212) = Less64 <bool> v199 v200
    • If v201b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = AtomicLoad32 <uint32,mem> v192 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v207 (213) = Eq32 <bool> v206 v197
    • If v207b43 b45 (line 213)
    • b41: ← b44
      • v212 (+212) = Add64 <int> v199 v211 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b44: ← b45
      • v209 (+216) = StaticCall <mem> {"".Gosched} v205
    • Plainb41 (line 216)
    • b45: ← b40
    • Plainb44 (line +216)
    • b46: ← b37
      • v222 (+220) = Store <mem> {func(*g, unsafe.Pointer) bool} v220 v219 v216
      • v223 (220) = Store <mem> {unsafe.Pointer} v164 v128 v222
      • v226 (220) = Store <mem> {waitReason} v225 v224 v223
      • v229 (220) = Store <mem> {byte} v228 v227 v226
      • v231 (220) = Store <mem> {int} v230 v211 v229
      • v232 (220) = StaticCall <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = Store <mem> {int32} v234 v233 v235
      • v237 (223) = StaticCall <mem> {"".exit} [8] v236
    • Plainb49 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b49: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
    • Plainb50 (line +226)
    • b50: ← b49
      • v240 (+226) = NilCheck <void> v238 v244
      • v241 (226) = Store <mem> {int32} v238 v233 v244
    • Plainb51 (line 226)
    • b51: ← b50
    • Plainb49 (line +226)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • phiopt [3055 ns]

    • b1:
      • v1 (?) = InitMem <mem>
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v4 (+111) = GetG <*g> v1 (g[*g])
      • v5 (?) = Const64 <uintptr> [0]
      • v7 (+115) = OffPtr <**m> [48] v4
      • v8 (115) = Load <*m> v7 v1
      • v9 (115) = NilCheck <void> v8 v1
      • v10 (115) = OffPtr <**g> [0] v8
      • v11 (115) = Load <*g> v10 v1
      • v12 (115) = NilCheck <void> v11 v1
      • v13 (115) = OffPtr <*uintptr> [304] v11
      • v14 (115) = Store <mem> {uintptr} v13 v5 v1
      • v15 (?) = ConstBool <bool> [true]
      • v16 (?) = Const64 <uintptr> [1000000000]
      • v17 (?) = Addr <*uintptr> {"".maxstacksize} v3
      • v20 (?) = Addr <*bool> {"".mainStarted} v3
      • v23 (?) = Addr <*func()> {"".main.func1·f} v3
      • v24 (?) = OffPtr <*func()> [0] v2
      • v36 (?) = Const32 <uint32> [1]
      • v44 (?) = ConstBool <bool> [false]
      • v72 (?) = Addr <*m> {"".m0} v3
      • v75 (?) = OffPtr <*string> [0] v2
      • v82 (?) = OffPtr <*int64> [0] v2
      • v84 (?) = Const64 <int64> [0]
      • v94 (?) = Addr <*func(*bool)> {"".main.func2·f} v3
      • v96 (?) = OffPtr <**bool> [16] v2
      • v98 (?) = Const32 <uint32> [8]
      • v99 (?) = OffPtr <*uint32> [0] v2
      • v101 (?) = OffPtr <*uintptr> [8] v2
      • v109 (?) = Addr <*int64> {"".runtimeInitTime} v3
      • v112 (?) = Addr <*uint8> {type.chan bool} v3
      • v113 (?) = OffPtr <**byte> [0] v2
      • v115 (?) = Const64 <int> [0] (c[int])
      • v116 (?) = OffPtr <*int> [8] v2
      • v119 (?) = OffPtr <*chan bool> [16] v2
      • v121 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v123 (?) = Addr <*bool> {"".iscgo} v3
      • v125 (?) = Addr <*unsafe.Pointer> {_cgo_thread_start} v3
      • v128 (?) = Const64 <unsafe.Pointer> [0]
      • v134 (?) = Addr <*unsafe.Pointer> {""._cgo_setenv} v3
      • v142 (?) = Addr <*unsafe.Pointer> {""._cgo_unsetenv} v3
      • v150 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v160 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v162 (?) = OffPtr <*unsafe.Pointer> [0] v2
      • v164 (?) = OffPtr <*unsafe.Pointer> [8] v2
      • v168 (?) = Addr <*func()> {"".main_init·f} v3 (fn[func()])
      • v172 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v174 (?) = OffPtr <*chan bool> [0] v2
      • v181 (?) = Addr <*bool> {"".isarchive} v3
      • v183 (?) = Addr <*bool> {"".islibrary} v3
      • v188 (?) = Addr <*func()> {"".main_main·f} v3 (fn[func()])
      • v192 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v197 (?) = Const32 <uint32> [0]
      • v200 (?) = Const64 <int> [1000]
      • v202 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v211 (?) = Const64 <int> [1]
      • v213 (?) = Addr <*uint32> {"".panicking} v3
      • v219 (?) = ConstNil <func(*g, unsafe.Pointer) bool>
      • v220 (?) = OffPtr <*func(*g, unsafe.Pointer) bool> [0] v2
      • v224 (?) = Const8 <waitReason> [8]
      • v225 (?) = OffPtr <*waitReason> [16] v2
      • v227 (?) = Const8 <byte> [16]
      • v228 (?) = OffPtr <*byte> [17] v2
      • v230 (?) = OffPtr <*int> [24] v2
      • v233 (?) = Const32 <int32> [0]
      • v234 (?) = OffPtr <*int32> [0] v2
      • v238 (?) = ConstNil <*int32> (x[*int32])
      • v243 (?) = Addr <*uint8> {go.string."runtime.main not on m0"} v3
      • v239 (?) = Const64 <int> [22]
      • v221 (?) = Addr <*uint8> {go.string."nanotime returning zero"} v3
      • v210 (?) = Const64 <int> [23]
      • v203 (?) = Addr <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v184 (?) = Const64 <int> [25]
      • v189 (?) = Addr <*uint8> {go.string."_cgo_setenv missing"} v3
      • v158 (?) = Const64 <int> [19]
      • v155 (?) = Addr <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v143 (?) = Const64 <int> [21]
      • v139 (?) = Addr <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v135 (?) = Const64 <int> [37]
      • v74 (?) = StringMake <string> v243 v239
      • v86 (?) = StringMake <string> v221 v210
      • v130 (?) = StringMake <string> v203 v184
      • v138 (?) = StringMake <string> v189 v158
      • v146 (?) = StringMake <string> v155 v143
      • v154 (?) = StringMake <string> v139 v135
    • Plainb2 (line +120)
    • b2: ← b1
      • v19 (+121) = Store <mem> {uintptr} v17 v16 v14
    • Plainb3 (line 121)
    • b3: ← b2
      • v22 (+127) = Store <mem> {bool} v20 v15 v19
    • Plainb4 (line +129)
    • b4: ← b3
      • v26 (+130) = Store <mem> {func()} v24 v23 v22
      • v27 (130) = StaticCall <mem> {"".systemstack} [8] v26
    • Plainb5 (line 130)
    • b5: ← b4
      • v29 (+3614) = GetG <*g> v27
      • v31 (3614) = OffPtr <**m> [48] v29
      • v32 (3614) = Load <*m> v31 v27
      • v33 (3614) = NilCheck <void> v32 v27
      • v34 (3614) = OffPtr <*uint32> [620] v32
      • v35 (3614) = Load <uint32> v34 v27
      • v37 (3614) = Add32 <uint32> v35 v36
      • v39 (3614) = OffPtr <**m> [48] v29
      • v40 (3614) = Load <*m> v31 v27
      • v41 (3614) = NilCheck <void> v32 v27
      • v42 (3614) = OffPtr <*uint32> [620] v32
      • v43 (3614) = Store <mem> {uint32} v34 v37 v27
    • Plainb7 (line +3572)
    • b7: ← b5
      • v46 (+3575) = GetG <*g> v43 (_g_[*g], g[*g])
      • v48 (+3576) = OffPtr <**m> [48] v46
      • v49 (3576) = Load <*m> v48 v43
      • v50 (3576) = NilCheck <void> v49 v43
      • v51 (3576) = OffPtr <*guintptr> [352] v49 (gp[*guintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v54 (205) = NilCheck <void> v51 v43
      • v55 (205) = Store <mem> {guintptr} v51 v53 v43
    • Plainb8 (line +3576)
    • b8: ← b7
      • v58 (+3577) = NilCheck <void> v46 v55
      • v59 (3577) = OffPtr <*muintptr> [216] v46 (mp[*muintptr])
      • v60 (3577) = NilCheck <void> v46 v55
      • v61 (3577) = OffPtr <**m> [48] v46
      • v62 (3577) = Load <*m> v48 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v65 (243) = NilCheck <void> v59 v55
      • v66 (243) = Store <mem> {muintptr} v59 v64 v55
    • Plainb9 (line +3577)
    • b9: ← b8
    • Plainb10 (line 143)
    • b10: ← b9
    • Plainb11 (line 143)
    • b11: ← b10
      • v69 (+143) = NilCheck <void> v4 v66
      • v70 (143) = OffPtr <**m> [48] v4
      • v71 (143) = Load <*m> v7 v66
      • v73 (143) = NeqPtr <bool> v71 v72
    • If v73b12 b13 (line 143)
    • b12: ← b11
      • v77 (+144) = Store <mem> {string} v75 v74 v66
      • v78 (144) = StaticCall <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = StaticCall <mem> {runtime.init} v66
      • v81 (+148) = StaticCall <mem> {"".nanotime} [8] v80
      • v83 (148) = Load <int64> v82 v81
      • v85 (148) = Eq64 <bool> v83 v84
    • If v85b14 b16 (line 148)
    • b14: ← b13
      • v88 (+149) = Store <mem> {string} v75 v86 v81
      • v89 (149) = StaticCall <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b16
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (153) = LocalAddr <*bool> {needUnlock} v2 v91
      • v93 (+153) = Store <mem> {bool} v92 v15 v91
      • v95 (+154) = LocalAddr <*bool> {needUnlock} v2 v93
      • v97 (+158) = Store <mem> {*bool} v96 v95 v93
      • v100 (+154) = Store <mem> {uint32} v99 v98 v97
      • v102 (154) = Store <mem> {uintptr} v101 v94 v100
      • v103 (154) = StaticCall <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b16: ← b13
    • Plainb15 (line +153)
    • b17: ← b15
      • v107 (+162) = StaticCall <mem> {"".nanotime} [8] v103
      • v108 (162) = Load <int64> v82 v107
      • v110 (162) = Store <mem> {int64} v109 v108 v107
      • v111 (+164) = StaticCall <mem> {"".gcenable} v110
      • v114 (+166) = Store <mem> {*byte} v113 v112 v111
      • v117 (166) = Store <mem> {int} v116 v115 v114
      • v118 (166) = StaticCall <mem> {runtime.makechan} [24] v117
      • v120 (166) = Load <chan bool> v119 v118
      • v122 (166) = Store <mem> {chan bool} v121 v120 v118
      • v124 (+167) = Load <bool> v123 v122
    • If v124b19 b20 (line 167)
    • b18: ← b15
      • v105 (154) = StaticCall <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b17
      • v127 (+168) = Load <unsafe.Pointer> v125 v122
      • v131 (168) = IsNonNil <bool> v127
    • If v131b22 b21 (line 168)
    • b20: ← b17 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = Load <uintptr> v168 v169
      • v171 (189) = ClosureCall <mem> [0] v170 v168 v169
      • v173 (+190) = Load <chan bool> v121 v171
      • v175 (190) = Store <mem> {chan bool} v174 v173 v171
      • v176 (190) = StaticCall <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v178 (192) = LocalAddr <*bool> {needUnlock} v2 v177
      • v179 (+192) = Store <mem> {bool} v178 v44 v177
      • v180 (+193) = StaticCall <mem> {"".unlockOSThread} v179
      • v182 (+195) = Load <bool> v181 v180
    • If v182b31 b33 (line 195)
    • b21: ← b19
      • v132 (+169) = Store <mem> {string} v75 v130 v122
      • v133 (169) = StaticCall <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b22: ← b19
    • Plainb23
    • b23: ← b22
      • v136 (+172) = Load <unsafe.Pointer> v134 v122
      • v126 (172) = IsNonNil <bool> v136
    • If v126b26 b25 (line 172)
    • b24: ← b28
      • v152 (+179) = Load <unsafe.Pointer> v150 v122
      • v104 (179) = IsNonNil <bool> v152
    • If v104b30 b29 (line 179)
    • b25: ← b23
      • v140 (+173) = Store <mem> {string} v75 v138 v122
      • v141 (173) = StaticCall <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v144 (+175) = Load <unsafe.Pointer> v142 v122
      • v106 (175) = IsNonNil <bool> v144
    • If v106b28 b27 (line 175)
    • b27: ← b26
      • v148 (+176) = Store <mem> {string} v75 v146 v122
      • v149 (176) = StaticCall <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b28: ← b26
    • Plainb24 (line +179)
    • b29: ← b24
      • v156 (+180) = Store <mem> {string} v75 v154 v122
      • v157 (180) = StaticCall <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = StaticCall <mem> {"".startTemplateThread} v122
      • v161 (+185) = Load <unsafe.Pointer> v150 v159
      • v163 (185) = Store <mem> {unsafe.Pointer} v162 v161 v159
      • v165 (185) = Store <mem> {unsafe.Pointer} v164 v128 v163
      • v166 (185) = StaticCall <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = StaticCall <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b32: ← b33
      • v190 (+201) = Load <uintptr> v188 v180
      • v191 (201) = ClosureCall <mem> [0] v190 v188 v180
    • Plainb35 (line +202)
    • b33: ← b20
      • v185 (195) = Load <bool> v183 v180
    • If v185b31 b32 (line 195)
    • b35: ← b32
      • v194 (+210) = AtomicLoad32 <uint32,mem> v192 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v198 (210) = Neq32 <bool> v197 v196
    • If v198b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = AtomicLoad32 <uint32,mem> v213 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v218 (219) = Neq32 <bool> v217 v197
    • If v218b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v201 (+212) = Less64 <bool> v199 v200
    • If v201b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = AtomicLoad32 <uint32,mem> v192 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v207 (213) = Eq32 <bool> v206 v197
    • If v207b43 b45 (line 213)
    • b41: ← b44
      • v212 (+212) = Add64 <int> v199 v211 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b44: ← b45
      • v209 (+216) = StaticCall <mem> {"".Gosched} v205
    • Plainb41 (line 216)
    • b45: ← b40
    • Plainb44 (line +216)
    • b46: ← b37
      • v222 (+220) = Store <mem> {func(*g, unsafe.Pointer) bool} v220 v219 v216
      • v223 (220) = Store <mem> {unsafe.Pointer} v164 v128 v222
      • v226 (220) = Store <mem> {waitReason} v225 v224 v223
      • v229 (220) = Store <mem> {byte} v228 v227 v226
      • v231 (220) = Store <mem> {int} v230 v211 v229
      • v232 (220) = StaticCall <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = Store <mem> {int32} v234 v233 v235
      • v237 (223) = StaticCall <mem> {"".exit} [8] v236
    • Plainb49 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b49: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
    • Plainb50 (line +226)
    • b50: ← b49
      • v240 (+226) = NilCheck <void> v238 v244
      • v241 (226) = Store <mem> {int32} v238 v233 v244
    • Plainb51 (line 226)
    • b51: ← b50
    • Plainb49 (line +226)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • nilcheckelim [88825 ns]

    • b1:
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v5 (?) = Const64 <uintptr> [0]
      • v15 (?) = ConstBool <bool> [true]
      • v16 (?) = Const64 <uintptr> [1000000000]
      • v17 (?) = Addr <*uintptr> {"".maxstacksize} v3
      • v20 (?) = Addr <*bool> {"".mainStarted} v3
      • v23 (?) = Addr <*func()> {"".main.func1·f} v3
      • v24 (?) = OffPtr <*func()> [0] v2
      • v36 (?) = Const32 <uint32> [1]
      • v44 (?) = ConstBool <bool> [false]
      • v72 (?) = Addr <*m> {"".m0} v3
      • v75 (?) = OffPtr <*string> [0] v2
      • v82 (?) = OffPtr <*int64> [0] v2
      • v84 (?) = Const64 <int64> [0]
      • v94 (?) = Addr <*func(*bool)> {"".main.func2·f} v3
      • v96 (?) = OffPtr <**bool> [16] v2
      • v98 (?) = Const32 <uint32> [8]
      • v99 (?) = OffPtr <*uint32> [0] v2
      • v101 (?) = OffPtr <*uintptr> [8] v2
      • v109 (?) = Addr <*int64> {"".runtimeInitTime} v3
      • v112 (?) = Addr <*uint8> {type.chan bool} v3
      • v113 (?) = OffPtr <**byte> [0] v2
      • v115 (?) = Const64 <int> [0] (c[int])
      • v116 (?) = OffPtr <*int> [8] v2
      • v119 (?) = OffPtr <*chan bool> [16] v2
      • v121 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v123 (?) = Addr <*bool> {"".iscgo} v3
      • v125 (?) = Addr <*unsafe.Pointer> {_cgo_thread_start} v3
      • v128 (?) = Const64 <unsafe.Pointer> [0]
      • v134 (?) = Addr <*unsafe.Pointer> {""._cgo_setenv} v3
      • v142 (?) = Addr <*unsafe.Pointer> {""._cgo_unsetenv} v3
      • v150 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v160 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v162 (?) = OffPtr <*unsafe.Pointer> [0] v2
      • v164 (?) = OffPtr <*unsafe.Pointer> [8] v2
      • v168 (?) = Addr <*func()> {"".main_init·f} v3 (fn[func()])
      • v172 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v174 (?) = OffPtr <*chan bool> [0] v2
      • v181 (?) = Addr <*bool> {"".isarchive} v3
      • v183 (?) = Addr <*bool> {"".islibrary} v3
      • v188 (?) = Addr <*func()> {"".main_main·f} v3 (fn[func()])
      • v192 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v197 (?) = Const32 <uint32> [0]
      • v200 (?) = Const64 <int> [1000]
      • v202 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v211 (?) = Const64 <int> [1]
      • v213 (?) = Addr <*uint32> {"".panicking} v3
      • v219 (?) = ConstNil <func(*g, unsafe.Pointer) bool>
      • v220 (?) = OffPtr <*func(*g, unsafe.Pointer) bool> [0] v2
      • v224 (?) = Const8 <waitReason> [8]
      • v225 (?) = OffPtr <*waitReason> [16] v2
      • v227 (?) = Const8 <byte> [16]
      • v228 (?) = OffPtr <*byte> [17] v2
      • v230 (?) = OffPtr <*int> [24] v2
      • v233 (?) = Const32 <int32> [0]
      • v234 (?) = OffPtr <*int32> [0] v2
      • v238 (?) = ConstNil <*int32> (x[*int32])
      • v243 (?) = Addr <*uint8> {go.string."runtime.main not on m0"} v3
      • v239 (?) = Const64 <int> [22]
      • v221 (?) = Addr <*uint8> {go.string."nanotime returning zero"} v3
      • v210 (?) = Const64 <int> [23]
      • v203 (?) = Addr <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v184 (?) = Const64 <int> [25]
      • v189 (?) = Addr <*uint8> {go.string."_cgo_setenv missing"} v3
      • v158 (?) = Const64 <int> [19]
      • v155 (?) = Addr <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v143 (?) = Const64 <int> [21]
      • v139 (?) = Addr <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v135 (?) = Const64 <int> [37]
      • v1 (?) = InitMem <mem>
      • v4 (+111) = GetG <*g> v1 (g[*g])
      • v7 (+115) = OffPtr <**m> [48] v4
      • v8 (115) = Load <*m> v7 v1
      • v10 (115) = OffPtr <**g> [0] v8
      • v11 (115) = Load <*g> v10 v1
      • v13 (115) = OffPtr <*uintptr> [304] v11
      • v14 (115) = Store <mem> {uintptr} v13 v5 v1
      • v74 (?) = StringMake <string> v243 v239
      • v86 (?) = StringMake <string> v221 v210
      • v130 (?) = StringMake <string> v203 v184
      • v138 (?) = StringMake <string> v189 v158
      • v146 (?) = StringMake <string> v155 v143
      • v154 (?) = StringMake <string> v139 v135
      • v9 (115) = NilCheck <void> v8 v1
      • v12 (115) = NilCheck <void> v11 v1
    • Plainb2 (line +120)
    • b2: ← b1
      • v19 (+121) = Store <mem> {uintptr} v17 v16 v14
    • Plainb3 (line 121)
    • b3: ← b2
      • v22 (+127) = Store <mem> {bool} v20 v15 v19
    • Plainb4 (line +129)
    • b4: ← b3
      • v26 (+130) = Store <mem> {func()} v24 v23 v22
      • v27 (130) = StaticCall <mem> {"".systemstack} [8] v26
    • Plainb5 (line 130)
    • b5: ← b4
      • v29 (+3614) = GetG <*g> v27
      • v31 (3614) = OffPtr <**m> [48] v29
      • v32 (3614) = Load <*m> v31 v27
      • v34 (3614) = OffPtr <*uint32> [620] v32
      • v35 (3614) = Load <uint32> v34 v27
      • v37 (3614) = Add32 <uint32> v35 v36
      • v39 (3614) = OffPtr <**m> [48] v29
      • v40 (3614) = Load <*m> v31 v27
      • v42 (3614) = OffPtr <*uint32> [620] v32
      • v43 (3614) = Store <mem> {uint32} v34 v37 v27
      • v33 (3614) = NilCheck <void> v32 v27
    • Plainb7 (line +3572)
    • b7: ← b5
      • v46 (+3575) = GetG <*g> v43 (_g_[*g], g[*g])
      • v48 (+3576) = OffPtr <**m> [48] v46
      • v49 (3576) = Load <*m> v48 v43
      • v51 (3576) = OffPtr <*guintptr> [352] v49 (gp[*guintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v55 (205) = Store <mem> {guintptr} v51 v53 v43
      • v50 (3576) = NilCheck <void> v49 v43
      • v54 (205) = NilCheck <void> v51 v43
    • Plainb8 (line +3576)
    • b8: ← b7
      • v58 (+3577) = NilCheck <void> v46 v55
      • v59 (3577) = OffPtr <*muintptr> [216] v46 (mp[*muintptr])
      • v61 (3577) = OffPtr <**m> [48] v46
      • v62 (3577) = Load <*m> v48 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v66 (243) = Store <mem> {muintptr} v59 v64 v55
      • v65 (243) = NilCheck <void> v59 v55
    • Plainb9 (line +3577)
    • b9: ← b8
    • Plainb10 (line 143)
    • b10: ← b9
    • Plainb11 (line 143)
    • b11: ← b10
      • v69 (+143) = NilCheck <void> v4 v66
      • v70 (143) = OffPtr <**m> [48] v4
      • v71 (143) = Load <*m> v7 v66
      • v73 (143) = NeqPtr <bool> v71 v72
    • If v73b12 b13 (line 143)
    • b12: ← b11
      • v77 (+144) = Store <mem> {string} v75 v74 v66
      • v78 (144) = StaticCall <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = StaticCall <mem> {runtime.init} v66
      • v81 (+148) = StaticCall <mem> {"".nanotime} [8] v80
      • v83 (148) = Load <int64> v82 v81
      • v85 (148) = Eq64 <bool> v83 v84
    • If v85b14 b16 (line 148)
    • b14: ← b13
      • v88 (+149) = Store <mem> {string} v75 v86 v81
      • v89 (149) = StaticCall <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b16
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (153) = LocalAddr <*bool> {needUnlock} v2 v91
      • v93 (+153) = Store <mem> {bool} v92 v15 v91
      • v95 (+154) = LocalAddr <*bool> {needUnlock} v2 v93
      • v97 (+158) = Store <mem> {*bool} v96 v95 v93
      • v100 (+154) = Store <mem> {uint32} v99 v98 v97
      • v102 (154) = Store <mem> {uintptr} v101 v94 v100
      • v103 (154) = StaticCall <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b16: ← b13
    • Plainb15 (line +153)
    • b17: ← b15
      • v107 (+162) = StaticCall <mem> {"".nanotime} [8] v103
      • v108 (162) = Load <int64> v82 v107
      • v110 (162) = Store <mem> {int64} v109 v108 v107
      • v111 (+164) = StaticCall <mem> {"".gcenable} v110
      • v114 (+166) = Store <mem> {*byte} v113 v112 v111
      • v117 (166) = Store <mem> {int} v116 v115 v114
      • v118 (166) = StaticCall <mem> {runtime.makechan} [24] v117
      • v120 (166) = Load <chan bool> v119 v118
      • v122 (166) = Store <mem> {chan bool} v121 v120 v118
      • v124 (+167) = Load <bool> v123 v122
    • If v124b19 b20 (line 167)
    • b18: ← b15
      • v105 (154) = StaticCall <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b17
      • v127 (+168) = Load <unsafe.Pointer> v125 v122
      • v131 (168) = IsNonNil <bool> v127
    • If v131b22 b21 (line 168)
    • b20: ← b17 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = Load <uintptr> v168 v169
      • v171 (189) = ClosureCall <mem> [0] v170 v168 v169
      • v173 (+190) = Load <chan bool> v121 v171
      • v175 (190) = Store <mem> {chan bool} v174 v173 v171
      • v176 (190) = StaticCall <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v178 (192) = LocalAddr <*bool> {needUnlock} v2 v177
      • v179 (+192) = Store <mem> {bool} v178 v44 v177
      • v180 (+193) = StaticCall <mem> {"".unlockOSThread} v179
      • v182 (+195) = Load <bool> v181 v180
    • If v182b31 b33 (line 195)
    • b21: ← b19
      • v132 (+169) = Store <mem> {string} v75 v130 v122
      • v133 (169) = StaticCall <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b22: ← b19
    • Plainb23
    • b23: ← b22
      • v136 (+172) = Load <unsafe.Pointer> v134 v122
      • v126 (172) = IsNonNil <bool> v136
    • If v126b26 b25 (line 172)
    • b24: ← b28
      • v152 (+179) = Load <unsafe.Pointer> v150 v122
      • v104 (179) = IsNonNil <bool> v152
    • If v104b30 b29 (line 179)
    • b25: ← b23
      • v140 (+173) = Store <mem> {string} v75 v138 v122
      • v141 (173) = StaticCall <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v144 (+175) = Load <unsafe.Pointer> v142 v122
      • v106 (175) = IsNonNil <bool> v144
    • If v106b28 b27 (line 175)
    • b27: ← b26
      • v148 (+176) = Store <mem> {string} v75 v146 v122
      • v149 (176) = StaticCall <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b28: ← b26
    • Plainb24 (line +179)
    • b29: ← b24
      • v156 (+180) = Store <mem> {string} v75 v154 v122
      • v157 (180) = StaticCall <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = StaticCall <mem> {"".startTemplateThread} v122
      • v161 (+185) = Load <unsafe.Pointer> v150 v159
      • v163 (185) = Store <mem> {unsafe.Pointer} v162 v161 v159
      • v165 (185) = Store <mem> {unsafe.Pointer} v164 v128 v163
      • v166 (185) = StaticCall <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = StaticCall <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b32: ← b33
      • v190 (+201) = Load <uintptr> v188 v180
      • v191 (201) = ClosureCall <mem> [0] v190 v188 v180
    • Plainb35 (line +202)
    • b33: ← b20
      • v185 (195) = Load <bool> v183 v180
    • If v185b31 b32 (line 195)
    • b35: ← b32
      • v194 (+210) = AtomicLoad32 <uint32,mem> v192 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v198 (210) = Neq32 <bool> v197 v196
    • If v198b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = AtomicLoad32 <uint32,mem> v213 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v218 (219) = Neq32 <bool> v217 v197
    • If v218b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v201 (+212) = Less64 <bool> v199 v200
    • If v201b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = AtomicLoad32 <uint32,mem> v192 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v207 (213) = Eq32 <bool> v206 v197
    • If v207b43 b45 (line 213)
    • b41: ← b44
      • v212 (+212) = Add64 <int> v199 v211 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b44: ← b45
      • v209 (+216) = StaticCall <mem> {"".Gosched} v205
    • Plainb41 (line 216)
    • b45: ← b40
    • Plainb44 (line +216)
    • b46: ← b37
      • v222 (+220) = Store <mem> {func(*g, unsafe.Pointer) bool} v220 v219 v216
      • v223 (220) = Store <mem> {unsafe.Pointer} v164 v128 v222
      • v226 (220) = Store <mem> {waitReason} v225 v224 v223
      • v229 (220) = Store <mem> {byte} v228 v227 v226
      • v231 (220) = Store <mem> {int} v230 v211 v229
      • v232 (220) = StaticCall <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = Store <mem> {int32} v234 v233 v235
      • v237 (223) = StaticCall <mem> {"".exit} [8] v236
    • Plainb49 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b49: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
    • Plainb50 (line +226)
    • b50: ← b49
      • v240 (+226) = NilCheck <void> v238 v244
      • v241 (226) = Store <mem> {int32} v238 v233 v244
    • Plainb51 (line 226)
    • b51: ← b50
    • Plainb49 (line +226)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • prove [268840 ns]

    • b1:
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v5 (?) = Const64 <uintptr> [0]
      • v15 (?) = ConstBool <bool> [true]
      • v16 (?) = Const64 <uintptr> [1000000000]
      • v17 (?) = Addr <*uintptr> {"".maxstacksize} v3
      • v20 (?) = Addr <*bool> {"".mainStarted} v3
      • v23 (?) = Addr <*func()> {"".main.func1·f} v3
      • v24 (?) = OffPtr <*func()> [0] v2
      • v36 (?) = Const32 <uint32> [1]
      • v44 (?) = ConstBool <bool> [false]
      • v72 (?) = Addr <*m> {"".m0} v3
      • v75 (?) = OffPtr <*string> [0] v2
      • v82 (?) = OffPtr <*int64> [0] v2
      • v84 (?) = Const64 <int64> [0]
      • v94 (?) = Addr <*func(*bool)> {"".main.func2·f} v3
      • v96 (?) = OffPtr <**bool> [16] v2
      • v98 (?) = Const32 <uint32> [8]
      • v99 (?) = OffPtr <*uint32> [0] v2
      • v101 (?) = OffPtr <*uintptr> [8] v2
      • v109 (?) = Addr <*int64> {"".runtimeInitTime} v3
      • v112 (?) = Addr <*uint8> {type.chan bool} v3
      • v113 (?) = OffPtr <**byte> [0] v2
      • v115 (?) = Const64 <int> [0] (c[int])
      • v116 (?) = OffPtr <*int> [8] v2
      • v119 (?) = OffPtr <*chan bool> [16] v2
      • v121 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v123 (?) = Addr <*bool> {"".iscgo} v3
      • v125 (?) = Addr <*unsafe.Pointer> {_cgo_thread_start} v3
      • v128 (?) = Const64 <unsafe.Pointer> [0]
      • v134 (?) = Addr <*unsafe.Pointer> {""._cgo_setenv} v3
      • v142 (?) = Addr <*unsafe.Pointer> {""._cgo_unsetenv} v3
      • v150 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v160 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v162 (?) = OffPtr <*unsafe.Pointer> [0] v2
      • v164 (?) = OffPtr <*unsafe.Pointer> [8] v2
      • v168 (?) = Addr <*func()> {"".main_init·f} v3 (fn[func()])
      • v172 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v174 (?) = OffPtr <*chan bool> [0] v2
      • v181 (?) = Addr <*bool> {"".isarchive} v3
      • v183 (?) = Addr <*bool> {"".islibrary} v3
      • v188 (?) = Addr <*func()> {"".main_main·f} v3 (fn[func()])
      • v192 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v197 (?) = Const32 <uint32> [0]
      • v200 (?) = Const64 <int> [1000]
      • v202 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v211 (?) = Const64 <int> [1]
      • v213 (?) = Addr <*uint32> {"".panicking} v3
      • v219 (?) = ConstNil <func(*g, unsafe.Pointer) bool>
      • v220 (?) = OffPtr <*func(*g, unsafe.Pointer) bool> [0] v2
      • v224 (?) = Const8 <waitReason> [8]
      • v225 (?) = OffPtr <*waitReason> [16] v2
      • v227 (?) = Const8 <byte> [16]
      • v228 (?) = OffPtr <*byte> [17] v2
      • v230 (?) = OffPtr <*int> [24] v2
      • v233 (?) = Const32 <int32> [0]
      • v234 (?) = OffPtr <*int32> [0] v2
      • v238 (?) = ConstNil <*int32> (x[*int32])
      • v243 (?) = Addr <*uint8> {go.string."runtime.main not on m0"} v3
      • v239 (?) = Const64 <int> [22]
      • v221 (?) = Addr <*uint8> {go.string."nanotime returning zero"} v3
      • v210 (?) = Const64 <int> [23]
      • v203 (?) = Addr <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v184 (?) = Const64 <int> [25]
      • v189 (?) = Addr <*uint8> {go.string."_cgo_setenv missing"} v3
      • v158 (?) = Const64 <int> [19]
      • v155 (?) = Addr <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v143 (?) = Const64 <int> [21]
      • v139 (?) = Addr <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v135 (?) = Const64 <int> [37]
      • v1 (?) = InitMem <mem>
      • v4 (+111) = GetG <*g> v1 (g[*g])
      • v7 (+115) = OffPtr <**m> [48] v4
      • v8 (115) = Load <*m> v7 v1
      • v10 (115) = OffPtr <**g> [0] v8
      • v11 (115) = Load <*g> v10 v1
      • v13 (115) = OffPtr <*uintptr> [304] v11
      • v14 (115) = Store <mem> {uintptr} v13 v5 v1
      • v74 (?) = StringMake <string> v243 v239
      • v86 (?) = StringMake <string> v221 v210
      • v130 (?) = StringMake <string> v203 v184
      • v138 (?) = StringMake <string> v189 v158
      • v146 (?) = StringMake <string> v155 v143
      • v154 (?) = StringMake <string> v139 v135
      • v9 (115) = NilCheck <void> v8 v1
      • v12 (115) = NilCheck <void> v11 v1
    • Plainb2 (line +120)
    • b2: ← b1
      • v19 (+121) = Store <mem> {uintptr} v17 v16 v14
    • Plainb3 (line 121)
    • b3: ← b2
      • v22 (+127) = Store <mem> {bool} v20 v15 v19
    • Plainb4 (line +129)
    • b4: ← b3
      • v26 (+130) = Store <mem> {func()} v24 v23 v22
      • v27 (130) = StaticCall <mem> {"".systemstack} [8] v26
    • Plainb5 (line 130)
    • b5: ← b4
      • v29 (+3614) = GetG <*g> v27
      • v31 (3614) = OffPtr <**m> [48] v29
      • v32 (3614) = Load <*m> v31 v27
      • v34 (3614) = OffPtr <*uint32> [620] v32
      • v35 (3614) = Load <uint32> v34 v27
      • v37 (3614) = Add32 <uint32> v35 v36
      • v39 (3614) = OffPtr <**m> [48] v29
      • v40 (3614) = Load <*m> v31 v27
      • v42 (3614) = OffPtr <*uint32> [620] v32
      • v43 (3614) = Store <mem> {uint32} v34 v37 v27
      • v33 (3614) = NilCheck <void> v32 v27
    • Plainb7 (line +3572)
    • b7: ← b5
      • v46 (+3575) = GetG <*g> v43 (_g_[*g], g[*g])
      • v48 (+3576) = OffPtr <**m> [48] v46
      • v49 (3576) = Load <*m> v48 v43
      • v51 (3576) = OffPtr <*guintptr> [352] v49 (gp[*guintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v55 (205) = Store <mem> {guintptr} v51 v53 v43
      • v50 (3576) = NilCheck <void> v49 v43
      • v54 (205) = NilCheck <void> v51 v43
    • Plainb8 (line +3576)
    • b8: ← b7
      • v58 (+3577) = NilCheck <void> v46 v55
      • v59 (3577) = OffPtr <*muintptr> [216] v46 (mp[*muintptr])
      • v61 (3577) = OffPtr <**m> [48] v46
      • v62 (3577) = Load <*m> v48 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v66 (243) = Store <mem> {muintptr} v59 v64 v55
      • v65 (243) = NilCheck <void> v59 v55
    • Plainb9 (line +3577)
    • b9: ← b8
    • Plainb10 (line 143)
    • b10: ← b9
    • Plainb11 (line 143)
    • b11: ← b10
      • v69 (+143) = NilCheck <void> v4 v66
      • v70 (143) = OffPtr <**m> [48] v4
      • v71 (143) = Load <*m> v7 v66
      • v73 (143) = NeqPtr <bool> v71 v72
    • If v73b12 b13 (line 143)
    • b12: ← b11
      • v77 (+144) = Store <mem> {string} v75 v74 v66
      • v78 (144) = StaticCall <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = StaticCall <mem> {runtime.init} v66
      • v81 (+148) = StaticCall <mem> {"".nanotime} [8] v80
      • v83 (148) = Load <int64> v82 v81
      • v85 (148) = Eq64 <bool> v83 v84
    • If v85b14 b16 (line 148)
    • b14: ← b13
      • v88 (+149) = Store <mem> {string} v75 v86 v81
      • v89 (149) = StaticCall <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b16
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (153) = LocalAddr <*bool> {needUnlock} v2 v91
      • v93 (+153) = Store <mem> {bool} v92 v15 v91
      • v95 (+154) = LocalAddr <*bool> {needUnlock} v2 v93
      • v97 (+158) = Store <mem> {*bool} v96 v95 v93
      • v100 (+154) = Store <mem> {uint32} v99 v98 v97
      • v102 (154) = Store <mem> {uintptr} v101 v94 v100
      • v103 (154) = StaticCall <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b16: ← b13
    • Plainb15 (line +153)
    • b17: ← b15
      • v107 (+162) = StaticCall <mem> {"".nanotime} [8] v103
      • v108 (162) = Load <int64> v82 v107
      • v110 (162) = Store <mem> {int64} v109 v108 v107
      • v111 (+164) = StaticCall <mem> {"".gcenable} v110
      • v114 (+166) = Store <mem> {*byte} v113 v112 v111
      • v117 (166) = Store <mem> {int} v116 v115 v114
      • v118 (166) = StaticCall <mem> {runtime.makechan} [24] v117
      • v120 (166) = Load <chan bool> v119 v118
      • v122 (166) = Store <mem> {chan bool} v121 v120 v118
      • v124 (+167) = Load <bool> v123 v122
    • If v124b19 b20 (line 167)
    • b18: ← b15
      • v105 (154) = StaticCall <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b17
      • v127 (+168) = Load <unsafe.Pointer> v125 v122
      • v131 (168) = IsNonNil <bool> v127
    • If v131b22 b21 (line 168)
    • b20: ← b17 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = Load <uintptr> v168 v169
      • v171 (189) = ClosureCall <mem> [0] v170 v168 v169
      • v173 (+190) = Load <chan bool> v121 v171
      • v175 (190) = Store <mem> {chan bool} v174 v173 v171
      • v176 (190) = StaticCall <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v178 (192) = LocalAddr <*bool> {needUnlock} v2 v177
      • v179 (+192) = Store <mem> {bool} v178 v44 v177
      • v180 (+193) = StaticCall <mem> {"".unlockOSThread} v179
      • v182 (+195) = Load <bool> v181 v180
    • If v182b31 b33 (line 195)
    • b21: ← b19
      • v132 (+169) = Store <mem> {string} v75 v130 v122
      • v133 (169) = StaticCall <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b22: ← b19
    • Plainb23
    • b23: ← b22
      • v136 (+172) = Load <unsafe.Pointer> v134 v122
      • v126 (172) = IsNonNil <bool> v136
    • If v126b26 b25 (line 172)
    • b24: ← b28
      • v152 (+179) = Load <unsafe.Pointer> v150 v122
      • v104 (179) = IsNonNil <bool> v152
    • If v104b30 b29 (line 179)
    • b25: ← b23
      • v140 (+173) = Store <mem> {string} v75 v138 v122
      • v141 (173) = StaticCall <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v144 (+175) = Load <unsafe.Pointer> v142 v122
      • v106 (175) = IsNonNil <bool> v144
    • If v106b28 b27 (line 175)
    • b27: ← b26
      • v148 (+176) = Store <mem> {string} v75 v146 v122
      • v149 (176) = StaticCall <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b28: ← b26
    • Plainb24 (line +179)
    • b29: ← b24
      • v156 (+180) = Store <mem> {string} v75 v154 v122
      • v157 (180) = StaticCall <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = StaticCall <mem> {"".startTemplateThread} v122
      • v161 (+185) = Load <unsafe.Pointer> v150 v159
      • v163 (185) = Store <mem> {unsafe.Pointer} v162 v161 v159
      • v165 (185) = Store <mem> {unsafe.Pointer} v164 v128 v163
      • v166 (185) = StaticCall <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = StaticCall <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b32: ← b33
      • v190 (+201) = Load <uintptr> v188 v180
      • v191 (201) = ClosureCall <mem> [0] v190 v188 v180
    • Plainb35 (line +202)
    • b33: ← b20
      • v185 (195) = Load <bool> v183 v180
    • If v185b31 b32 (line 195)
    • b35: ← b32
      • v194 (+210) = AtomicLoad32 <uint32,mem> v192 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v198 (210) = Neq32 <bool> v197 v196
    • If v198b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = AtomicLoad32 <uint32,mem> v213 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v218 (219) = Neq32 <bool> v217 v197
    • If v218b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v201 (+212) = Less64 <bool> v199 v200
    • If v201b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = AtomicLoad32 <uint32,mem> v192 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v207 (213) = Eq32 <bool> v206 v197
    • If v207b43 b45 (line 213)
    • b41: ← b44
      • v212 (+212) = Add64 <int> v199 v211 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b44: ← b45
      • v209 (+216) = StaticCall <mem> {"".Gosched} v205
    • Plainb41 (line 216)
    • b45: ← b40
    • Plainb44 (line +216)
    • b46: ← b37
      • v222 (+220) = Store <mem> {func(*g, unsafe.Pointer) bool} v220 v219 v216
      • v223 (220) = Store <mem> {unsafe.Pointer} v164 v128 v222
      • v226 (220) = Store <mem> {waitReason} v225 v224 v223
      • v229 (220) = Store <mem> {byte} v228 v227 v226
      • v231 (220) = Store <mem> {int} v230 v211 v229
      • v232 (220) = StaticCall <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = Store <mem> {int32} v234 v233 v235
      • v237 (223) = StaticCall <mem> {"".exit} [8] v236
    • Plainb49 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b49: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
    • Plainb50 (line +226)
    • b50: ← b49
      • v240 (+226) = NilCheck <void> v238 v244
      • v241 (226) = Store <mem> {int32} v238 v233 v244
    • Plainb51 (line 226)
    • b51: ← b50
    • Plainb49 (line +226)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • decompose builtin [75807 ns]

    • b1:
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v5 (?) = Const64 <uintptr> [0]
      • v15 (?) = ConstBool <bool> [true]
      • v16 (?) = Const64 <uintptr> [1000000000]
      • v17 (?) = Addr <*uintptr> {"".maxstacksize} v3
      • v20 (?) = Addr <*bool> {"".mainStarted} v3
      • v23 (?) = Addr <*func()> {"".main.func1·f} v3
      • v24 (?) = OffPtr <*func()> [0] v2
      • v36 (?) = Const32 <uint32> [1]
      • v44 (?) = ConstBool <bool> [false]
      • v72 (?) = Addr <*m> {"".m0} v3
      • v75 (?) = OffPtr <*string> [0] v2
      • v82 (?) = OffPtr <*int64> [0] v2
      • v84 (?) = Const64 <int64> [0]
      • v94 (?) = Addr <*func(*bool)> {"".main.func2·f} v3
      • v96 (?) = OffPtr <**bool> [16] v2
      • v98 (?) = Const32 <uint32> [8]
      • v99 (?) = OffPtr <*uint32> [0] v2
      • v101 (?) = OffPtr <*uintptr> [8] v2
      • v109 (?) = Addr <*int64> {"".runtimeInitTime} v3
      • v112 (?) = Addr <*uint8> {type.chan bool} v3
      • v113 (?) = OffPtr <**byte> [0] v2
      • v115 (?) = Const64 <int> [0] (c[int])
      • v116 (?) = OffPtr <*int> [8] v2
      • v119 (?) = OffPtr <*chan bool> [16] v2
      • v121 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v123 (?) = Addr <*bool> {"".iscgo} v3
      • v125 (?) = Addr <*unsafe.Pointer> {_cgo_thread_start} v3
      • v128 (?) = Const64 <unsafe.Pointer> [0]
      • v134 (?) = Addr <*unsafe.Pointer> {""._cgo_setenv} v3
      • v142 (?) = Addr <*unsafe.Pointer> {""._cgo_unsetenv} v3
      • v150 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v160 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v162 (?) = OffPtr <*unsafe.Pointer> [0] v2
      • v164 (?) = OffPtr <*unsafe.Pointer> [8] v2
      • v168 (?) = Addr <*func()> {"".main_init·f} v3 (fn[func()])
      • v172 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v174 (?) = OffPtr <*chan bool> [0] v2
      • v181 (?) = Addr <*bool> {"".isarchive} v3
      • v183 (?) = Addr <*bool> {"".islibrary} v3
      • v188 (?) = Addr <*func()> {"".main_main·f} v3 (fn[func()])
      • v192 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v197 (?) = Const32 <uint32> [0]
      • v200 (?) = Const64 <int> [1000]
      • v202 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v211 (?) = Const64 <int> [1]
      • v213 (?) = Addr <*uint32> {"".panicking} v3
      • v219 (?) = ConstNil <func(*g, unsafe.Pointer) bool>
      • v220 (?) = OffPtr <*func(*g, unsafe.Pointer) bool> [0] v2
      • v224 (?) = Const8 <waitReason> [8]
      • v225 (?) = OffPtr <*waitReason> [16] v2
      • v227 (?) = Const8 <byte> [16]
      • v228 (?) = OffPtr <*byte> [17] v2
      • v230 (?) = OffPtr <*int> [24] v2
      • v233 (?) = Const32 <int32> [0]
      • v234 (?) = OffPtr <*int32> [0] v2
      • v238 (?) = ConstNil <*int32> (x[*int32])
      • v243 (?) = Addr <*uint8> {go.string."runtime.main not on m0"} v3
      • v239 (?) = Const64 <int> [22]
      • v221 (?) = Addr <*uint8> {go.string."nanotime returning zero"} v3
      • v210 (?) = Const64 <int> [23]
      • v203 (?) = Addr <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v184 (?) = Const64 <int> [25]
      • v189 (?) = Addr <*uint8> {go.string."_cgo_setenv missing"} v3
      • v158 (?) = Const64 <int> [19]
      • v155 (?) = Addr <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v143 (?) = Const64 <int> [21]
      • v139 (?) = Addr <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v135 (?) = Const64 <int> [37]
      • v1 (?) = InitMem <mem>
      • v4 (+111) = GetG <*g> v1 (g[*g])
      • v7 (+115) = OffPtr <**m> [48] v4
      • v8 (115) = Load <*m> v7 v1
      • v10 (115) = OffPtr <**g> [0] v8
      • v11 (115) = Load <*g> v10 v1
      • v13 (115) = OffPtr <*uintptr> [304] v11
      • v14 (115) = Store <mem> {uintptr} v13 v5 v1
      • v74 (?) = StringMake <string> v243 v239
      • v86 (?) = StringMake <string> v221 v210
      • v130 (?) = StringMake <string> v203 v184
      • v138 (?) = StringMake <string> v189 v158
      • v146 (?) = StringMake <string> v155 v143
      • v154 (?) = StringMake <string> v139 v135
      • v9 (115) = NilCheck <void> v8 v1
      • v12 (115) = NilCheck <void> v11 v1
    • Plainb2 (line +120)
    • b2: ← b1
      • v19 (+121) = Store <mem> {uintptr} v17 v16 v14
    • Plainb3 (line 121)
    • b3: ← b2
      • v22 (+127) = Store <mem> {bool} v20 v15 v19
    • Plainb4 (line +129)
    • b4: ← b3
      • v26 (+130) = Store <mem> {func()} v24 v23 v22
      • v27 (130) = StaticCall <mem> {"".systemstack} [8] v26
    • Plainb5 (line 130)
    • b5: ← b4
      • v29 (+3614) = GetG <*g> v27
      • v31 (3614) = OffPtr <**m> [48] v29
      • v32 (3614) = Load <*m> v31 v27
      • v34 (3614) = OffPtr <*uint32> [620] v32
      • v35 (3614) = Load <uint32> v34 v27
      • v37 (3614) = Add32 <uint32> v35 v36
      • v39 (3614) = OffPtr <**m> [48] v29
      • v40 (3614) = Load <*m> v31 v27
      • v42 (3614) = OffPtr <*uint32> [620] v32
      • v43 (3614) = Store <mem> {uint32} v34 v37 v27
      • v33 (3614) = NilCheck <void> v32 v27
    • Plainb7 (line +3572)
    • b7: ← b5
      • v46 (+3575) = GetG <*g> v43 (_g_[*g], g[*g])
      • v48 (+3576) = OffPtr <**m> [48] v46
      • v49 (3576) = Load <*m> v48 v43
      • v51 (3576) = OffPtr <*guintptr> [352] v49 (gp[*guintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v55 (205) = Store <mem> {guintptr} v51 v53 v43
      • v50 (3576) = NilCheck <void> v49 v43
      • v54 (205) = NilCheck <void> v51 v43
    • Plainb8 (line +3576)
    • b8: ← b7
      • v58 (+3577) = NilCheck <void> v46 v55
      • v59 (3577) = OffPtr <*muintptr> [216] v46 (mp[*muintptr])
      • v61 (3577) = OffPtr <**m> [48] v46
      • v62 (3577) = Load <*m> v48 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v66 (243) = Store <mem> {muintptr} v59 v64 v55
      • v65 (243) = NilCheck <void> v59 v55
    • Plainb9 (line +3577)
    • b9: ← b8
    • Plainb10 (line 143)
    • b10: ← b9
    • Plainb11 (line 143)
    • b11: ← b10
      • v69 (+143) = NilCheck <void> v4 v66
      • v70 (143) = OffPtr <**m> [48] v4
      • v71 (143) = Load <*m> v7 v66
      • v73 (143) = NeqPtr <bool> v71 v72
    • If v73b12 b13 (line 143)
    • b12: ← b11
      • v60 (+144) = OffPtr <*int> [8] v75
      • v41 (+144) = Store <mem> {*uint8} v75 v243 v66
      • v77 (+144) = Store <mem> {int} v60 v239 v41
      • v78 (144) = StaticCall <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = StaticCall <mem> {runtime.init} v66
      • v81 (+148) = StaticCall <mem> {"".nanotime} [8] v80
      • v83 (148) = Load <int64> v82 v81
      • v85 (148) = Eq64 <bool> v83 v84
    • If v85b14 b16 (line 148)
    • b14: ← b13
      • v145 (+149) = OffPtr <*int> [8] v75
      • v153 (+149) = Store <mem> {*uint8} v75 v221 v81
      • v88 (+149) = Store <mem> {int} v145 v210 v153
      • v89 (149) = StaticCall <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b16
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (153) = LocalAddr <*bool> {needUnlock} v2 v91
      • v93 (+153) = Store <mem> {bool} v92 v15 v91
      • v95 (+154) = LocalAddr <*bool> {needUnlock} v2 v93
      • v97 (+158) = Store <mem> {*bool} v96 v95 v93
      • v100 (+154) = Store <mem> {uint32} v99 v98 v97
      • v102 (154) = Store <mem> {uintptr} v101 v94 v100
      • v103 (154) = StaticCall <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b16: ← b13
    • Plainb15 (line +153)
    • b17: ← b15
      • v107 (+162) = StaticCall <mem> {"".nanotime} [8] v103
      • v108 (162) = Load <int64> v82 v107
      • v110 (162) = Store <mem> {int64} v109 v108 v107
      • v111 (+164) = StaticCall <mem> {"".gcenable} v110
      • v114 (+166) = Store <mem> {*byte} v113 v112 v111
      • v117 (166) = Store <mem> {int} v116 v115 v114
      • v118 (166) = StaticCall <mem> {runtime.makechan} [24] v117
      • v120 (166) = Load <chan bool> v119 v118
      • v122 (166) = Store <mem> {chan bool} v121 v120 v118
      • v124 (+167) = Load <bool> v123 v122
    • If v124b19 b20 (line 167)
    • b18: ← b15
      • v105 (154) = StaticCall <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b17
      • v127 (+168) = Load <unsafe.Pointer> v125 v122
      • v131 (168) = IsNonNil <bool> v127
    • If v131b22 b21 (line 168)
    • b20: ← b17 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = Load <uintptr> v168 v169
      • v171 (189) = ClosureCall <mem> [0] v170 v168 v169
      • v173 (+190) = Load <chan bool> v121 v171
      • v175 (190) = Store <mem> {chan bool} v174 v173 v171
      • v176 (190) = StaticCall <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v178 (192) = LocalAddr <*bool> {needUnlock} v2 v177
      • v179 (+192) = Store <mem> {bool} v178 v44 v177
      • v180 (+193) = StaticCall <mem> {"".unlockOSThread} v179
      • v182 (+195) = Load <bool> v181 v180
    • If v182b31 b33 (line 195)
    • b21: ← b19
      • v137 (+169) = OffPtr <*int> [8] v75
      • v129 (+169) = Store <mem> {*uint8} v75 v203 v122
      • v132 (+169) = Store <mem> {int} v137 v184 v129
      • v133 (169) = StaticCall <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b22: ← b19
    • Plainb23
    • b23: ← b22
      • v136 (+172) = Load <unsafe.Pointer> v134 v122
      • v126 (172) = IsNonNil <bool> v136
    • If v126b26 b25 (line 172)
    • b24: ← b28
      • v152 (+179) = Load <unsafe.Pointer> v150 v122
      • v104 (179) = IsNonNil <bool> v152
    • If v104b30 b29 (line 179)
    • b25: ← b23
      • v47 (+173) = OffPtr <*int> [8] v75
      • v38 (+173) = Store <mem> {*uint8} v75 v189 v122
      • v140 (+173) = Store <mem> {int} v47 v158 v38
      • v141 (173) = StaticCall <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v144 (+175) = Load <unsafe.Pointer> v142 v122
      • v106 (175) = IsNonNil <bool> v144
    • If v106b28 b27 (line 175)
    • b27: ← b26
      • v30 (+176) = OffPtr <*int> [8] v75
      • v28 (+176) = Store <mem> {*uint8} v75 v155 v122
      • v148 (+176) = Store <mem> {int} v30 v143 v28
      • v149 (176) = StaticCall <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b28: ← b26
    • Plainb24 (line +179)
    • b29: ← b24
      • v21 (+180) = OffPtr <*int> [8] v75
      • v151 (+180) = Store <mem> {*uint8} v75 v139 v122
      • v156 (+180) = Store <mem> {int} v21 v135 v151
      • v157 (180) = StaticCall <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = StaticCall <mem> {"".startTemplateThread} v122
      • v161 (+185) = Load <unsafe.Pointer> v150 v159
      • v163 (185) = Store <mem> {unsafe.Pointer} v162 v161 v159
      • v165 (185) = Store <mem> {unsafe.Pointer} v164 v128 v163
      • v166 (185) = StaticCall <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = StaticCall <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b32: ← b33
      • v190 (+201) = Load <uintptr> v188 v180
      • v191 (201) = ClosureCall <mem> [0] v190 v188 v180
    • Plainb35 (line +202)
    • b33: ← b20
      • v185 (195) = Load <bool> v183 v180
    • If v185b31 b32 (line 195)
    • b35: ← b32
      • v194 (+210) = AtomicLoad32 <uint32,mem> v192 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v198 (210) = Neq32 <bool> v197 v196
    • If v198b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = AtomicLoad32 <uint32,mem> v213 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v218 (219) = Neq32 <bool> v217 v197
    • If v218b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v201 (+212) = Less64 <bool> v199 v200
    • If v201b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = AtomicLoad32 <uint32,mem> v192 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v207 (213) = Eq32 <bool> v206 v197
    • If v207b43 b45 (line 213)
    • b41: ← b44
      • v212 (+212) = Add64 <int> v199 v211 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b44: ← b45
      • v209 (+216) = StaticCall <mem> {"".Gosched} v205
    • Plainb41 (line 216)
    • b45: ← b40
    • Plainb44 (line +216)
    • b46: ← b37
      • v222 (+220) = Store <mem> {func(*g, unsafe.Pointer) bool} v220 v219 v216
      • v223 (220) = Store <mem> {unsafe.Pointer} v164 v128 v222
      • v226 (220) = Store <mem> {waitReason} v225 v224 v223
      • v229 (220) = Store <mem> {byte} v228 v227 v226
      • v231 (220) = Store <mem> {int} v230 v211 v229
      • v232 (220) = StaticCall <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = Store <mem> {int32} v234 v233 v235
      • v237 (223) = StaticCall <mem> {"".exit} [8] v236
    • Plainb49 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b49: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
    • Plainb50 (line +226)
    • b50: ← b49
      • v240 (+226) = NilCheck <void> v238 v244
      • v241 (226) = Store <mem> {int32} v238 v233 v244
    • Plainb51 (line 226)
    • b51: ← b50
    • Plainb49 (line +226)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • softfloat [575 ns]

    • b1:
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v5 (?) = Const64 <uintptr> [0]
      • v15 (?) = ConstBool <bool> [true]
      • v16 (?) = Const64 <uintptr> [1000000000]
      • v17 (?) = Addr <*uintptr> {"".maxstacksize} v3
      • v20 (?) = Addr <*bool> {"".mainStarted} v3
      • v23 (?) = Addr <*func()> {"".main.func1·f} v3
      • v24 (?) = OffPtr <*func()> [0] v2
      • v36 (?) = Const32 <uint32> [1]
      • v44 (?) = ConstBool <bool> [false]
      • v72 (?) = Addr <*m> {"".m0} v3
      • v75 (?) = OffPtr <*string> [0] v2
      • v82 (?) = OffPtr <*int64> [0] v2
      • v84 (?) = Const64 <int64> [0]
      • v94 (?) = Addr <*func(*bool)> {"".main.func2·f} v3
      • v96 (?) = OffPtr <**bool> [16] v2
      • v98 (?) = Const32 <uint32> [8]
      • v99 (?) = OffPtr <*uint32> [0] v2
      • v101 (?) = OffPtr <*uintptr> [8] v2
      • v109 (?) = Addr <*int64> {"".runtimeInitTime} v3
      • v112 (?) = Addr <*uint8> {type.chan bool} v3
      • v113 (?) = OffPtr <**byte> [0] v2
      • v115 (?) = Const64 <int> [0] (c[int])
      • v116 (?) = OffPtr <*int> [8] v2
      • v119 (?) = OffPtr <*chan bool> [16] v2
      • v121 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v123 (?) = Addr <*bool> {"".iscgo} v3
      • v125 (?) = Addr <*unsafe.Pointer> {_cgo_thread_start} v3
      • v128 (?) = Const64 <unsafe.Pointer> [0]
      • v134 (?) = Addr <*unsafe.Pointer> {""._cgo_setenv} v3
      • v142 (?) = Addr <*unsafe.Pointer> {""._cgo_unsetenv} v3
      • v150 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v160 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v162 (?) = OffPtr <*unsafe.Pointer> [0] v2
      • v164 (?) = OffPtr <*unsafe.Pointer> [8] v2
      • v168 (?) = Addr <*func()> {"".main_init·f} v3 (fn[func()])
      • v172 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v174 (?) = OffPtr <*chan bool> [0] v2
      • v181 (?) = Addr <*bool> {"".isarchive} v3
      • v183 (?) = Addr <*bool> {"".islibrary} v3
      • v188 (?) = Addr <*func()> {"".main_main·f} v3 (fn[func()])
      • v192 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v197 (?) = Const32 <uint32> [0]
      • v200 (?) = Const64 <int> [1000]
      • v202 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v211 (?) = Const64 <int> [1]
      • v213 (?) = Addr <*uint32> {"".panicking} v3
      • v219 (?) = ConstNil <func(*g, unsafe.Pointer) bool>
      • v220 (?) = OffPtr <*func(*g, unsafe.Pointer) bool> [0] v2
      • v224 (?) = Const8 <waitReason> [8]
      • v225 (?) = OffPtr <*waitReason> [16] v2
      • v227 (?) = Const8 <byte> [16]
      • v228 (?) = OffPtr <*byte> [17] v2
      • v230 (?) = OffPtr <*int> [24] v2
      • v233 (?) = Const32 <int32> [0]
      • v234 (?) = OffPtr <*int32> [0] v2
      • v238 (?) = ConstNil <*int32> (x[*int32])
      • v243 (?) = Addr <*uint8> {go.string."runtime.main not on m0"} v3
      • v239 (?) = Const64 <int> [22]
      • v221 (?) = Addr <*uint8> {go.string."nanotime returning zero"} v3
      • v210 (?) = Const64 <int> [23]
      • v203 (?) = Addr <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v184 (?) = Const64 <int> [25]
      • v189 (?) = Addr <*uint8> {go.string."_cgo_setenv missing"} v3
      • v158 (?) = Const64 <int> [19]
      • v155 (?) = Addr <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v143 (?) = Const64 <int> [21]
      • v139 (?) = Addr <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v135 (?) = Const64 <int> [37]
      • v1 (?) = InitMem <mem>
      • v4 (+111) = GetG <*g> v1 (g[*g])
      • v7 (+115) = OffPtr <**m> [48] v4
      • v8 (115) = Load <*m> v7 v1
      • v10 (115) = OffPtr <**g> [0] v8
      • v11 (115) = Load <*g> v10 v1
      • v13 (115) = OffPtr <*uintptr> [304] v11
      • v14 (115) = Store <mem> {uintptr} v13 v5 v1
      • v74 (?) = StringMake <string> v243 v239
      • v86 (?) = StringMake <string> v221 v210
      • v130 (?) = StringMake <string> v203 v184
      • v138 (?) = StringMake <string> v189 v158
      • v146 (?) = StringMake <string> v155 v143
      • v154 (?) = StringMake <string> v139 v135
      • v9 (115) = NilCheck <void> v8 v1
      • v12 (115) = NilCheck <void> v11 v1
    • Plainb2 (line +120)
    • b2: ← b1
      • v19 (+121) = Store <mem> {uintptr} v17 v16 v14
    • Plainb3 (line 121)
    • b3: ← b2
      • v22 (+127) = Store <mem> {bool} v20 v15 v19
    • Plainb4 (line +129)
    • b4: ← b3
      • v26 (+130) = Store <mem> {func()} v24 v23 v22
      • v27 (130) = StaticCall <mem> {"".systemstack} [8] v26
    • Plainb5 (line 130)
    • b5: ← b4
      • v29 (+3614) = GetG <*g> v27
      • v31 (3614) = OffPtr <**m> [48] v29
      • v32 (3614) = Load <*m> v31 v27
      • v34 (3614) = OffPtr <*uint32> [620] v32
      • v35 (3614) = Load <uint32> v34 v27
      • v37 (3614) = Add32 <uint32> v35 v36
      • v39 (3614) = OffPtr <**m> [48] v29
      • v40 (3614) = Load <*m> v31 v27
      • v42 (3614) = OffPtr <*uint32> [620] v32
      • v43 (3614) = Store <mem> {uint32} v34 v37 v27
      • v33 (3614) = NilCheck <void> v32 v27
    • Plainb7 (line +3572)
    • b7: ← b5
      • v46 (+3575) = GetG <*g> v43 (_g_[*g], g[*g])
      • v48 (+3576) = OffPtr <**m> [48] v46
      • v49 (3576) = Load <*m> v48 v43
      • v51 (3576) = OffPtr <*guintptr> [352] v49 (gp[*guintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v55 (205) = Store <mem> {guintptr} v51 v53 v43
      • v50 (3576) = NilCheck <void> v49 v43
      • v54 (205) = NilCheck <void> v51 v43
    • Plainb8 (line +3576)
    • b8: ← b7
      • v58 (+3577) = NilCheck <void> v46 v55
      • v59 (3577) = OffPtr <*muintptr> [216] v46 (mp[*muintptr])
      • v61 (3577) = OffPtr <**m> [48] v46
      • v62 (3577) = Load <*m> v48 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v66 (243) = Store <mem> {muintptr} v59 v64 v55
      • v65 (243) = NilCheck <void> v59 v55
    • Plainb9 (line +3577)
    • b9: ← b8
    • Plainb10 (line 143)
    • b10: ← b9
    • Plainb11 (line 143)
    • b11: ← b10
      • v69 (+143) = NilCheck <void> v4 v66
      • v70 (143) = OffPtr <**m> [48] v4
      • v71 (143) = Load <*m> v7 v66
      • v73 (143) = NeqPtr <bool> v71 v72
    • If v73b12 b13 (line 143)
    • b12: ← b11
      • v60 (+144) = OffPtr <*int> [8] v75
      • v41 (+144) = Store <mem> {*uint8} v75 v243 v66
      • v77 (+144) = Store <mem> {int} v60 v239 v41
      • v78 (144) = StaticCall <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = StaticCall <mem> {runtime.init} v66
      • v81 (+148) = StaticCall <mem> {"".nanotime} [8] v80
      • v83 (148) = Load <int64> v82 v81
      • v85 (148) = Eq64 <bool> v83 v84
    • If v85b14 b16 (line 148)
    • b14: ← b13
      • v145 (+149) = OffPtr <*int> [8] v75
      • v153 (+149) = Store <mem> {*uint8} v75 v221 v81
      • v88 (+149) = Store <mem> {int} v145 v210 v153
      • v89 (149) = StaticCall <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b16
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (153) = LocalAddr <*bool> {needUnlock} v2 v91
      • v93 (+153) = Store <mem> {bool} v92 v15 v91
      • v95 (+154) = LocalAddr <*bool> {needUnlock} v2 v93
      • v97 (+158) = Store <mem> {*bool} v96 v95 v93
      • v100 (+154) = Store <mem> {uint32} v99 v98 v97
      • v102 (154) = Store <mem> {uintptr} v101 v94 v100
      • v103 (154) = StaticCall <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b16: ← b13
    • Plainb15 (line +153)
    • b17: ← b15
      • v107 (+162) = StaticCall <mem> {"".nanotime} [8] v103
      • v108 (162) = Load <int64> v82 v107
      • v110 (162) = Store <mem> {int64} v109 v108 v107
      • v111 (+164) = StaticCall <mem> {"".gcenable} v110
      • v114 (+166) = Store <mem> {*byte} v113 v112 v111
      • v117 (166) = Store <mem> {int} v116 v115 v114
      • v118 (166) = StaticCall <mem> {runtime.makechan} [24] v117
      • v120 (166) = Load <chan bool> v119 v118
      • v122 (166) = Store <mem> {chan bool} v121 v120 v118
      • v124 (+167) = Load <bool> v123 v122
    • If v124b19 b20 (line 167)
    • b18: ← b15
      • v105 (154) = StaticCall <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b17
      • v127 (+168) = Load <unsafe.Pointer> v125 v122
      • v131 (168) = IsNonNil <bool> v127
    • If v131b22 b21 (line 168)
    • b20: ← b17 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = Load <uintptr> v168 v169
      • v171 (189) = ClosureCall <mem> [0] v170 v168 v169
      • v173 (+190) = Load <chan bool> v121 v171
      • v175 (190) = Store <mem> {chan bool} v174 v173 v171
      • v176 (190) = StaticCall <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v178 (192) = LocalAddr <*bool> {needUnlock} v2 v177
      • v179 (+192) = Store <mem> {bool} v178 v44 v177
      • v180 (+193) = StaticCall <mem> {"".unlockOSThread} v179
      • v182 (+195) = Load <bool> v181 v180
    • If v182b31 b33 (line 195)
    • b21: ← b19
      • v137 (+169) = OffPtr <*int> [8] v75
      • v129 (+169) = Store <mem> {*uint8} v75 v203 v122
      • v132 (+169) = Store <mem> {int} v137 v184 v129
      • v133 (169) = StaticCall <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b22: ← b19
    • Plainb23
    • b23: ← b22
      • v136 (+172) = Load <unsafe.Pointer> v134 v122
      • v126 (172) = IsNonNil <bool> v136
    • If v126b26 b25 (line 172)
    • b24: ← b28
      • v152 (+179) = Load <unsafe.Pointer> v150 v122
      • v104 (179) = IsNonNil <bool> v152
    • If v104b30 b29 (line 179)
    • b25: ← b23
      • v47 (+173) = OffPtr <*int> [8] v75
      • v38 (+173) = Store <mem> {*uint8} v75 v189 v122
      • v140 (+173) = Store <mem> {int} v47 v158 v38
      • v141 (173) = StaticCall <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v144 (+175) = Load <unsafe.Pointer> v142 v122
      • v106 (175) = IsNonNil <bool> v144
    • If v106b28 b27 (line 175)
    • b27: ← b26
      • v30 (+176) = OffPtr <*int> [8] v75
      • v28 (+176) = Store <mem> {*uint8} v75 v155 v122
      • v148 (+176) = Store <mem> {int} v30 v143 v28
      • v149 (176) = StaticCall <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b28: ← b26
    • Plainb24 (line +179)
    • b29: ← b24
      • v21 (+180) = OffPtr <*int> [8] v75
      • v151 (+180) = Store <mem> {*uint8} v75 v139 v122
      • v156 (+180) = Store <mem> {int} v21 v135 v151
      • v157 (180) = StaticCall <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = StaticCall <mem> {"".startTemplateThread} v122
      • v161 (+185) = Load <unsafe.Pointer> v150 v159
      • v163 (185) = Store <mem> {unsafe.Pointer} v162 v161 v159
      • v165 (185) = Store <mem> {unsafe.Pointer} v164 v128 v163
      • v166 (185) = StaticCall <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = StaticCall <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b32: ← b33
      • v190 (+201) = Load <uintptr> v188 v180
      • v191 (201) = ClosureCall <mem> [0] v190 v188 v180
    • Plainb35 (line +202)
    • b33: ← b20
      • v185 (195) = Load <bool> v183 v180
    • If v185b31 b32 (line 195)
    • b35: ← b32
      • v194 (+210) = AtomicLoad32 <uint32,mem> v192 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v198 (210) = Neq32 <bool> v197 v196
    • If v198b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = AtomicLoad32 <uint32,mem> v213 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v218 (219) = Neq32 <bool> v217 v197
    • If v218b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v201 (+212) = Less64 <bool> v199 v200
    • If v201b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = AtomicLoad32 <uint32,mem> v192 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v207 (213) = Eq32 <bool> v206 v197
    • If v207b43 b45 (line 213)
    • b41: ← b44
      • v212 (+212) = Add64 <int> v199 v211 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b44: ← b45
      • v209 (+216) = StaticCall <mem> {"".Gosched} v205
    • Plainb41 (line 216)
    • b45: ← b40
    • Plainb44 (line +216)
    • b46: ← b37
      • v222 (+220) = Store <mem> {func(*g, unsafe.Pointer) bool} v220 v219 v216
      • v223 (220) = Store <mem> {unsafe.Pointer} v164 v128 v222
      • v226 (220) = Store <mem> {waitReason} v225 v224 v223
      • v229 (220) = Store <mem> {byte} v228 v227 v226
      • v231 (220) = Store <mem> {int} v230 v211 v229
      • v232 (220) = StaticCall <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = Store <mem> {int32} v234 v233 v235
      • v237 (223) = StaticCall <mem> {"".exit} [8] v236
    • Plainb49 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b49: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
    • Plainb50 (line +226)
    • b50: ← b49
      • v240 (+226) = NilCheck <void> v238 v244
      • v241 (226) = Store <mem> {int32} v238 v233 v244
    • Plainb51 (line 226)
    • b51: ← b50
    • Plainb49 (line +226)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • late opt [128274 ns]

    • b1:
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v5 (?) = Const64 <uintptr> [0]
      • v15 (?) = ConstBool <bool> [true]
      • v16 (?) = Const64 <uintptr> [1000000000]
      • v17 (?) = Addr <*uintptr> {"".maxstacksize} v3
      • v20 (?) = Addr <*bool> {"".mainStarted} v3
      • v23 (?) = Addr <*func()> {"".main.func1·f} v3
      • v24 (?) = OffPtr <*func()> [0] v2
      • v36 (?) = Const32 <uint32> [1]
      • v44 (?) = ConstBool <bool> [false]
      • v72 (?) = Addr <*m> {"".m0} v3
      • v75 (?) = OffPtr <*string> [0] v2
      • v82 (?) = OffPtr <*int64> [0] v2
      • v84 (?) = Const64 <int64> [0]
      • v94 (?) = Addr <*func(*bool)> {"".main.func2·f} v3
      • v96 (?) = OffPtr <**bool> [16] v2
      • v98 (?) = Const32 <uint32> [8]
      • v99 (?) = OffPtr <*uint32> [0] v2
      • v101 (?) = OffPtr <*uintptr> [8] v2
      • v109 (?) = Addr <*int64> {"".runtimeInitTime} v3
      • v112 (?) = Addr <*uint8> {type.chan bool} v3
      • v113 (?) = OffPtr <**byte> [0] v2
      • v115 (?) = Const64 <int> [0] (c[int])
      • v116 (?) = OffPtr <*int> [8] v2
      • v119 (?) = OffPtr <*chan bool> [16] v2
      • v121 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v123 (?) = Addr <*bool> {"".iscgo} v3
      • v125 (?) = Addr <*unsafe.Pointer> {_cgo_thread_start} v3
      • v128 (?) = Const64 <unsafe.Pointer> [0]
      • v134 (?) = Addr <*unsafe.Pointer> {""._cgo_setenv} v3
      • v142 (?) = Addr <*unsafe.Pointer> {""._cgo_unsetenv} v3
      • v150 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v160 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v162 (?) = OffPtr <*unsafe.Pointer> [0] v2
      • v164 (?) = OffPtr <*unsafe.Pointer> [8] v2
      • v168 (?) = Addr <*func()> {"".main_init·f} v3 (fn[func()])
      • v172 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v174 (?) = OffPtr <*chan bool> [0] v2
      • v181 (?) = Addr <*bool> {"".isarchive} v3
      • v183 (?) = Addr <*bool> {"".islibrary} v3
      • v188 (?) = Addr <*func()> {"".main_main·f} v3 (fn[func()])
      • v192 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v197 (?) = Const32 <uint32> [0]
      • v200 (?) = Const64 <int> [1000]
      • v202 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v211 (?) = Const64 <int> [1]
      • v213 (?) = Addr <*uint32> {"".panicking} v3
      • v219 (?) = ConstNil <func(*g, unsafe.Pointer) bool>
      • v220 (?) = OffPtr <*func(*g, unsafe.Pointer) bool> [0] v2
      • v224 (?) = Const8 <waitReason> [8]
      • v225 (?) = OffPtr <*waitReason> [16] v2
      • v227 (?) = Const8 <byte> [16]
      • v228 (?) = OffPtr <*byte> [17] v2
      • v230 (?) = OffPtr <*int> [24] v2
      • v233 (?) = Const32 <int32> [0]
      • v234 (?) = OffPtr <*int32> [0] v2
      • v238 (?) = ConstNil <*int32> (x[*int32])
      • v243 (?) = Addr <*uint8> {go.string."runtime.main not on m0"} v3
      • v239 (?) = Const64 <int> [22]
      • v221 (?) = Addr <*uint8> {go.string."nanotime returning zero"} v3
      • v210 (?) = Const64 <int> [23]
      • v203 (?) = Addr <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v184 (?) = Const64 <int> [25]
      • v189 (?) = Addr <*uint8> {go.string."_cgo_setenv missing"} v3
      • v158 (?) = Const64 <int> [19]
      • v155 (?) = Addr <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v143 (?) = Const64 <int> [21]
      • v139 (?) = Addr <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v135 (?) = Const64 <int> [37]
      • v1 (?) = InitMem <mem>
      • v4 (+111) = GetG <*g> v1 (g[*g])
      • v7 (+115) = OffPtr <**m> [48] v4
      • v8 (115) = Load <*m> v7 v1
      • v10 (115) = OffPtr <**g> [0] v8
      • v11 (115) = Load <*g> v10 v1
      • v13 (115) = OffPtr <*uintptr> [304] v11
      • v14 (115) = Store <mem> {uintptr} v13 v5 v1
      • v74 (?) = StringMake <string> v243 v239
      • v86 (?) = StringMake <string> v221 v210
      • v130 (?) = StringMake <string> v203 v184
      • v138 (?) = StringMake <string> v189 v158
      • v146 (?) = StringMake <string> v155 v143
      • v154 (?) = StringMake <string> v139 v135
      • v9 (115) = NilCheck <void> v8 v1
      • v12 (115) = NilCheck <void> v11 v1
    • Plainb2 (line +120)
    • b2: ← b1
      • v19 (+121) = Store <mem> {uintptr} v17 v16 v14
    • Plainb3 (line 121)
    • b3: ← b2
      • v22 (+127) = Store <mem> {bool} v20 v15 v19
    • Plainb4 (line +129)
    • b4: ← b3
      • v26 (+130) = Store <mem> {func()} v24 v23 v22
      • v27 (130) = StaticCall <mem> {"".systemstack} [8] v26
    • Plainb5 (line 130)
    • b5: ← b4
      • v29 (+3614) = GetG <*g> v27
      • v31 (3614) = OffPtr <**m> [48] v29
      • v32 (3614) = Load <*m> v31 v27
      • v34 (3614) = OffPtr <*uint32> [620] v32
      • v35 (3614) = Load <uint32> v34 v27
      • v37 (3614) = Add32 <uint32> v35 v36
      • v39 (3614) = OffPtr <**m> [48] v29
      • v40 (3614) = Load <*m> v31 v27
      • v42 (3614) = OffPtr <*uint32> [620] v32
      • v43 (3614) = Store <mem> {uint32} v34 v37 v27
      • v33 (3614) = NilCheck <void> v32 v27
    • Plainb7 (line +3572)
    • b7: ← b5
      • v46 (+3575) = GetG <*g> v43 (_g_[*g], g[*g])
      • v48 (+3576) = OffPtr <**m> [48] v46
      • v49 (3576) = Load <*m> v48 v43
      • v51 (3576) = OffPtr <*guintptr> [352] v49 (gp[*guintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v55 (205) = Store <mem> {guintptr} v51 v53 v43
      • v50 (3576) = NilCheck <void> v49 v43
      • v54 (205) = NilCheck <void> v51 v43
    • Plainb8 (line +3576)
    • b8: ← b7
      • v58 (+3577) = NilCheck <void> v46 v55
      • v59 (3577) = OffPtr <*muintptr> [216] v46 (mp[*muintptr])
      • v61 (3577) = OffPtr <**m> [48] v46
      • v62 (3577) = Load <*m> v48 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v66 (243) = Store <mem> {muintptr} v59 v64 v55
      • v65 (243) = NilCheck <void> v59 v55
    • Plainb9 (line +3577)
    • b9: ← b8
    • Plainb10 (line 143)
    • b10: ← b9
    • Plainb11 (line 143)
    • b11: ← b10
      • v69 (+143) = NilCheck <void> v4 v66
      • v70 (143) = OffPtr <**m> [48] v4
      • v71 (143) = Load <*m> v7 v66
      • v73 (143) = NeqPtr <bool> v71 v72
    • If v73b12 b13 (line 143)
    • b12: ← b11
      • v60 (144) = OffPtr <*int> [8] v2
      • v41 (+144) = Store <mem> {*uint8} v75 v243 v66
      • v77 (+144) = Store <mem> {int} v60 v239 v41
      • v78 (144) = StaticCall <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = StaticCall <mem> {runtime.init} v66
      • v81 (+148) = StaticCall <mem> {"".nanotime} [8] v80
      • v83 (148) = Load <int64> v82 v81
      • v85 (148) = Eq64 <bool> v83 v84
    • If v85b14 b16 (line 148)
    • b14: ← b13
      • v145 (149) = OffPtr <*int> [8] v2
      • v153 (+149) = Store <mem> {*uint8} v75 v221 v81
      • v88 (+149) = Store <mem> {int} v145 v210 v153
      • v89 (149) = StaticCall <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b16
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (153) = LocalAddr <*bool> {needUnlock} v2 v91
      • v93 (+153) = Store <mem> {bool} v92 v15 v91
      • v95 (+154) = LocalAddr <*bool> {needUnlock} v2 v93
      • v97 (+158) = Store <mem> {*bool} v96 v95 v93
      • v100 (+154) = Store <mem> {uint32} v99 v98 v97
      • v102 (154) = Store <mem> {uintptr} v101 v94 v100
      • v103 (154) = StaticCall <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b16: ← b13
    • Plainb15 (line +153)
    • b17: ← b15
      • v107 (+162) = StaticCall <mem> {"".nanotime} [8] v103
      • v108 (162) = Load <int64> v82 v107
      • v110 (162) = Store <mem> {int64} v109 v108 v107
      • v111 (+164) = StaticCall <mem> {"".gcenable} v110
      • v114 (+166) = Store <mem> {*byte} v113 v112 v111
      • v117 (166) = Store <mem> {int} v116 v115 v114
      • v118 (166) = StaticCall <mem> {runtime.makechan} [24] v117
      • v120 (166) = Load <chan bool> v119 v118
      • v122 (166) = Store <mem> {chan bool} v121 v120 v118
      • v124 (+167) = Load <bool> v123 v122
    • If v124b19 b20 (line 167)
    • b18: ← b15
      • v105 (154) = StaticCall <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b17
      • v127 (+168) = Load <unsafe.Pointer> v125 v122
      • v131 (168) = IsNonNil <bool> v127
    • If v131b22 b21 (line 168)
    • b20: ← b17 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = Load <uintptr> v168 v169
      • v171 (189) = ClosureCall <mem> [0] v170 v168 v169
      • v173 (+190) = Load <chan bool> v121 v171
      • v175 (190) = Store <mem> {chan bool} v174 v173 v171
      • v176 (190) = StaticCall <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v178 (192) = LocalAddr <*bool> {needUnlock} v2 v177
      • v179 (+192) = Store <mem> {bool} v178 v44 v177
      • v180 (+193) = StaticCall <mem> {"".unlockOSThread} v179
      • v182 (+195) = Load <bool> v181 v180
    • If v182b31 b33 (line 195)
    • b21: ← b19
      • v137 (169) = OffPtr <*int> [8] v2
      • v129 (+169) = Store <mem> {*uint8} v75 v203 v122
      • v132 (+169) = Store <mem> {int} v137 v184 v129
      • v133 (169) = StaticCall <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b22: ← b19
    • Plainb23
    • b23: ← b22
      • v136 (+172) = Load <unsafe.Pointer> v134 v122
      • v126 (172) = IsNonNil <bool> v136
    • If v126b26 b25 (line 172)
    • b24: ← b28
      • v152 (+179) = Load <unsafe.Pointer> v150 v122
      • v104 (179) = IsNonNil <bool> v152
    • If v104b30 b29 (line 179)
    • b25: ← b23
      • v47 (173) = OffPtr <*int> [8] v2
      • v38 (+173) = Store <mem> {*uint8} v75 v189 v122
      • v140 (+173) = Store <mem> {int} v47 v158 v38
      • v141 (173) = StaticCall <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v144 (+175) = Load <unsafe.Pointer> v142 v122
      • v106 (175) = IsNonNil <bool> v144
    • If v106b28 b27 (line 175)
    • b27: ← b26
      • v30 (176) = OffPtr <*int> [8] v2
      • v28 (+176) = Store <mem> {*uint8} v75 v155 v122
      • v148 (+176) = Store <mem> {int} v30 v143 v28
      • v149 (176) = StaticCall <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b28: ← b26
    • Plainb24 (line +179)
    • b29: ← b24
      • v21 (180) = OffPtr <*int> [8] v2
      • v151 (+180) = Store <mem> {*uint8} v75 v139 v122
      • v156 (+180) = Store <mem> {int} v21 v135 v151
      • v157 (180) = StaticCall <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = StaticCall <mem> {"".startTemplateThread} v122
      • v161 (+185) = Load <unsafe.Pointer> v150 v159
      • v163 (185) = Store <mem> {unsafe.Pointer} v162 v161 v159
      • v165 (185) = Store <mem> {unsafe.Pointer} v164 v128 v163
      • v166 (185) = StaticCall <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = StaticCall <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b32: ← b33
      • v190 (+201) = Load <uintptr> v188 v180
      • v191 (201) = ClosureCall <mem> [0] v190 v188 v180
    • Plainb35 (line +202)
    • b33: ← b20
      • v185 (195) = Load <bool> v183 v180
    • If v185b31 b32 (line 195)
    • b35: ← b32
      • v194 (+210) = AtomicLoad32 <uint32,mem> v192 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v198 (210) = Neq32 <bool> v197 v196
    • If v198b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = AtomicLoad32 <uint32,mem> v213 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v218 (219) = Neq32 <bool> v217 v197
    • If v218b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v201 (+212) = Less64 <bool> v199 v200
    • If v201b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = AtomicLoad32 <uint32,mem> v192 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v207 (213) = Eq32 <bool> v206 v197
    • If v207b43 b45 (line 213)
    • b41: ← b44
      • v212 (+212) = Add64 <int> v199 v211 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b44: ← b45
      • v209 (+216) = StaticCall <mem> {"".Gosched} v205
    • Plainb41 (line 216)
    • b45: ← b40
    • Plainb44 (line +216)
    • b46: ← b37
      • v222 (+220) = Store <mem> {func(*g, unsafe.Pointer) bool} v220 v219 v216
      • v223 (220) = Store <mem> {unsafe.Pointer} v164 v128 v222
      • v226 (220) = Store <mem> {waitReason} v225 v224 v223
      • v229 (220) = Store <mem> {byte} v228 v227 v226
      • v231 (220) = Store <mem> {int} v230 v211 v229
      • v232 (220) = StaticCall <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = Store <mem> {int32} v234 v233 v235
      • v237 (223) = StaticCall <mem> {"".exit} [8] v236
    • Plainb49 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b49: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
    • Plainb50 (line +226)
    • b50: ← b49
      • v240 (+226) = NilCheck <void> v238 v244
      • v241 (226) = Store <mem> {int32} v238 v233 v244
    • Plainb51 (line 226)
    • b51: ← b50
    • Plainb49 (line +226)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • dead auto elim [110920 ns]

    • b1:
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v5 (?) = Const64 <uintptr> [0]
      • v15 (?) = ConstBool <bool> [true]
      • v16 (?) = Const64 <uintptr> [1000000000]
      • v17 (?) = Addr <*uintptr> {"".maxstacksize} v3
      • v20 (?) = Addr <*bool> {"".mainStarted} v3
      • v23 (?) = Addr <*func()> {"".main.func1·f} v3
      • v24 (?) = OffPtr <*func()> [0] v2
      • v36 (?) = Const32 <uint32> [1]
      • v44 (?) = ConstBool <bool> [false]
      • v72 (?) = Addr <*m> {"".m0} v3
      • v75 (?) = OffPtr <*string> [0] v2
      • v82 (?) = OffPtr <*int64> [0] v2
      • v84 (?) = Const64 <int64> [0]
      • v94 (?) = Addr <*func(*bool)> {"".main.func2·f} v3
      • v96 (?) = OffPtr <**bool> [16] v2
      • v98 (?) = Const32 <uint32> [8]
      • v99 (?) = OffPtr <*uint32> [0] v2
      • v101 (?) = OffPtr <*uintptr> [8] v2
      • v109 (?) = Addr <*int64> {"".runtimeInitTime} v3
      • v112 (?) = Addr <*uint8> {type.chan bool} v3
      • v113 (?) = OffPtr <**byte> [0] v2
      • v115 (?) = Const64 <int> [0] (c[int])
      • v116 (?) = OffPtr <*int> [8] v2
      • v119 (?) = OffPtr <*chan bool> [16] v2
      • v121 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v123 (?) = Addr <*bool> {"".iscgo} v3
      • v125 (?) = Addr <*unsafe.Pointer> {_cgo_thread_start} v3
      • v128 (?) = Const64 <unsafe.Pointer> [0]
      • v134 (?) = Addr <*unsafe.Pointer> {""._cgo_setenv} v3
      • v142 (?) = Addr <*unsafe.Pointer> {""._cgo_unsetenv} v3
      • v150 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v160 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v162 (?) = OffPtr <*unsafe.Pointer> [0] v2
      • v164 (?) = OffPtr <*unsafe.Pointer> [8] v2
      • v168 (?) = Addr <*func()> {"".main_init·f} v3 (fn[func()])
      • v172 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v174 (?) = OffPtr <*chan bool> [0] v2
      • v181 (?) = Addr <*bool> {"".isarchive} v3
      • v183 (?) = Addr <*bool> {"".islibrary} v3
      • v188 (?) = Addr <*func()> {"".main_main·f} v3 (fn[func()])
      • v192 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v197 (?) = Const32 <uint32> [0]
      • v200 (?) = Const64 <int> [1000]
      • v202 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v211 (?) = Const64 <int> [1]
      • v213 (?) = Addr <*uint32> {"".panicking} v3
      • v219 (?) = ConstNil <func(*g, unsafe.Pointer) bool>
      • v220 (?) = OffPtr <*func(*g, unsafe.Pointer) bool> [0] v2
      • v224 (?) = Const8 <waitReason> [8]
      • v225 (?) = OffPtr <*waitReason> [16] v2
      • v227 (?) = Const8 <byte> [16]
      • v228 (?) = OffPtr <*byte> [17] v2
      • v230 (?) = OffPtr <*int> [24] v2
      • v233 (?) = Const32 <int32> [0]
      • v234 (?) = OffPtr <*int32> [0] v2
      • v238 (?) = ConstNil <*int32> (x[*int32])
      • v243 (?) = Addr <*uint8> {go.string."runtime.main not on m0"} v3
      • v239 (?) = Const64 <int> [22]
      • v221 (?) = Addr <*uint8> {go.string."nanotime returning zero"} v3
      • v210 (?) = Const64 <int> [23]
      • v203 (?) = Addr <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v184 (?) = Const64 <int> [25]
      • v189 (?) = Addr <*uint8> {go.string."_cgo_setenv missing"} v3
      • v158 (?) = Const64 <int> [19]
      • v155 (?) = Addr <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v143 (?) = Const64 <int> [21]
      • v139 (?) = Addr <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v135 (?) = Const64 <int> [37]
      • v1 (?) = InitMem <mem>
      • v4 (+111) = GetG <*g> v1 (g[*g])
      • v7 (+115) = OffPtr <**m> [48] v4
      • v8 (115) = Load <*m> v7 v1
      • v10 (115) = OffPtr <**g> [0] v8
      • v11 (115) = Load <*g> v10 v1
      • v13 (115) = OffPtr <*uintptr> [304] v11
      • v14 (115) = Store <mem> {uintptr} v13 v5 v1
      • v74 (?) = StringMake <string> v243 v239
      • v86 (?) = StringMake <string> v221 v210
      • v130 (?) = StringMake <string> v203 v184
      • v138 (?) = StringMake <string> v189 v158
      • v146 (?) = StringMake <string> v155 v143
      • v154 (?) = StringMake <string> v139 v135
      • v9 (115) = NilCheck <void> v8 v1
      • v12 (115) = NilCheck <void> v11 v1
    • Plainb2 (line +120)
    • b2: ← b1
      • v19 (+121) = Store <mem> {uintptr} v17 v16 v14
    • Plainb3 (line 121)
    • b3: ← b2
      • v22 (+127) = Store <mem> {bool} v20 v15 v19
    • Plainb4 (line +129)
    • b4: ← b3
      • v26 (+130) = Store <mem> {func()} v24 v23 v22
      • v27 (130) = StaticCall <mem> {"".systemstack} [8] v26
    • Plainb5 (line 130)
    • b5: ← b4
      • v29 (+3614) = GetG <*g> v27
      • v31 (3614) = OffPtr <**m> [48] v29
      • v32 (3614) = Load <*m> v31 v27
      • v34 (3614) = OffPtr <*uint32> [620] v32
      • v35 (3614) = Load <uint32> v34 v27
      • v37 (3614) = Add32 <uint32> v35 v36
      • v39 (3614) = OffPtr <**m> [48] v29
      • v40 (3614) = Load <*m> v31 v27
      • v42 (3614) = OffPtr <*uint32> [620] v32
      • v43 (3614) = Store <mem> {uint32} v34 v37 v27
      • v33 (3614) = NilCheck <void> v32 v27
    • Plainb7 (line +3572)
    • b7: ← b5
      • v46 (+3575) = GetG <*g> v43 (_g_[*g], g[*g])
      • v48 (+3576) = OffPtr <**m> [48] v46
      • v49 (3576) = Load <*m> v48 v43
      • v51 (3576) = OffPtr <*guintptr> [352] v49 (gp[*guintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v55 (205) = Store <mem> {guintptr} v51 v53 v43
      • v50 (3576) = NilCheck <void> v49 v43
      • v54 (205) = NilCheck <void> v51 v43
    • Plainb8 (line +3576)
    • b8: ← b7
      • v58 (+3577) = NilCheck <void> v46 v55
      • v59 (3577) = OffPtr <*muintptr> [216] v46 (mp[*muintptr])
      • v61 (3577) = OffPtr <**m> [48] v46
      • v62 (3577) = Load <*m> v48 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v66 (243) = Store <mem> {muintptr} v59 v64 v55
      • v65 (243) = NilCheck <void> v59 v55
    • Plainb9 (line +3577)
    • b9: ← b8
    • Plainb10 (line 143)
    • b10: ← b9
    • Plainb11 (line 143)
    • b11: ← b10
      • v69 (+143) = NilCheck <void> v4 v66
      • v70 (143) = OffPtr <**m> [48] v4
      • v71 (143) = Load <*m> v7 v66
      • v73 (143) = NeqPtr <bool> v71 v72
    • If v73b12 b13 (line 143)
    • b12: ← b11
      • v60 (144) = OffPtr <*int> [8] v2
      • v41 (+144) = Store <mem> {*uint8} v75 v243 v66
      • v77 (+144) = Store <mem> {int} v60 v239 v41
      • v78 (144) = StaticCall <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = StaticCall <mem> {runtime.init} v66
      • v81 (+148) = StaticCall <mem> {"".nanotime} [8] v80
      • v83 (148) = Load <int64> v82 v81
      • v85 (148) = Eq64 <bool> v83 v84
    • If v85b14 b16 (line 148)
    • b14: ← b13
      • v145 (149) = OffPtr <*int> [8] v2
      • v153 (+149) = Store <mem> {*uint8} v75 v221 v81
      • v88 (+149) = Store <mem> {int} v145 v210 v153
      • v89 (149) = StaticCall <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b16
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (153) = LocalAddr <*bool> {needUnlock} v2 v91
      • v93 (+153) = Store <mem> {bool} v92 v15 v91
      • v95 (+154) = LocalAddr <*bool> {needUnlock} v2 v93
      • v97 (+158) = Store <mem> {*bool} v96 v95 v93
      • v100 (+154) = Store <mem> {uint32} v99 v98 v97
      • v102 (154) = Store <mem> {uintptr} v101 v94 v100
      • v103 (154) = StaticCall <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b16: ← b13
    • Plainb15 (line +153)
    • b17: ← b15
      • v107 (+162) = StaticCall <mem> {"".nanotime} [8] v103
      • v108 (162) = Load <int64> v82 v107
      • v110 (162) = Store <mem> {int64} v109 v108 v107
      • v111 (+164) = StaticCall <mem> {"".gcenable} v110
      • v114 (+166) = Store <mem> {*byte} v113 v112 v111
      • v117 (166) = Store <mem> {int} v116 v115 v114
      • v118 (166) = StaticCall <mem> {runtime.makechan} [24] v117
      • v120 (166) = Load <chan bool> v119 v118
      • v122 (166) = Store <mem> {chan bool} v121 v120 v118
      • v124 (+167) = Load <bool> v123 v122
    • If v124b19 b20 (line 167)
    • b18: ← b15
      • v105 (154) = StaticCall <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b17
      • v127 (+168) = Load <unsafe.Pointer> v125 v122
      • v131 (168) = IsNonNil <bool> v127
    • If v131b22 b21 (line 168)
    • b20: ← b17 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = Load <uintptr> v168 v169
      • v171 (189) = ClosureCall <mem> [0] v170 v168 v169
      • v173 (+190) = Load <chan bool> v121 v171
      • v175 (190) = Store <mem> {chan bool} v174 v173 v171
      • v176 (190) = StaticCall <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v178 (192) = LocalAddr <*bool> {needUnlock} v2 v177
      • v179 (+192) = Store <mem> {bool} v178 v44 v177
      • v180 (+193) = StaticCall <mem> {"".unlockOSThread} v179
      • v182 (+195) = Load <bool> v181 v180
    • If v182b31 b33 (line 195)
    • b21: ← b19
      • v137 (169) = OffPtr <*int> [8] v2
      • v129 (+169) = Store <mem> {*uint8} v75 v203 v122
      • v132 (+169) = Store <mem> {int} v137 v184 v129
      • v133 (169) = StaticCall <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b22: ← b19
    • Plainb23
    • b23: ← b22
      • v136 (+172) = Load <unsafe.Pointer> v134 v122
      • v126 (172) = IsNonNil <bool> v136
    • If v126b26 b25 (line 172)
    • b24: ← b28
      • v152 (+179) = Load <unsafe.Pointer> v150 v122
      • v104 (179) = IsNonNil <bool> v152
    • If v104b30 b29 (line 179)
    • b25: ← b23
      • v47 (173) = OffPtr <*int> [8] v2
      • v38 (+173) = Store <mem> {*uint8} v75 v189 v122
      • v140 (+173) = Store <mem> {int} v47 v158 v38
      • v141 (173) = StaticCall <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v144 (+175) = Load <unsafe.Pointer> v142 v122
      • v106 (175) = IsNonNil <bool> v144
    • If v106b28 b27 (line 175)
    • b27: ← b26
      • v30 (176) = OffPtr <*int> [8] v2
      • v28 (+176) = Store <mem> {*uint8} v75 v155 v122
      • v148 (+176) = Store <mem> {int} v30 v143 v28
      • v149 (176) = StaticCall <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b28: ← b26
    • Plainb24 (line +179)
    • b29: ← b24
      • v21 (180) = OffPtr <*int> [8] v2
      • v151 (+180) = Store <mem> {*uint8} v75 v139 v122
      • v156 (+180) = Store <mem> {int} v21 v135 v151
      • v157 (180) = StaticCall <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = StaticCall <mem> {"".startTemplateThread} v122
      • v161 (+185) = Load <unsafe.Pointer> v150 v159
      • v163 (185) = Store <mem> {unsafe.Pointer} v162 v161 v159
      • v165 (185) = Store <mem> {unsafe.Pointer} v164 v128 v163
      • v166 (185) = StaticCall <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = StaticCall <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b32: ← b33
      • v190 (+201) = Load <uintptr> v188 v180
      • v191 (201) = ClosureCall <mem> [0] v190 v188 v180
    • Plainb35 (line +202)
    • b33: ← b20
      • v185 (195) = Load <bool> v183 v180
    • If v185b31 b32 (line 195)
    • b35: ← b32
      • v194 (+210) = AtomicLoad32 <uint32,mem> v192 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v198 (210) = Neq32 <bool> v197 v196
    • If v198b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = AtomicLoad32 <uint32,mem> v213 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v218 (219) = Neq32 <bool> v217 v197
    • If v218b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v201 (+212) = Less64 <bool> v199 v200
    • If v201b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = AtomicLoad32 <uint32,mem> v192 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v207 (213) = Eq32 <bool> v206 v197
    • If v207b43 b45 (line 213)
    • b41: ← b44
      • v212 (+212) = Add64 <int> v199 v211 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b44: ← b45
      • v209 (+216) = StaticCall <mem> {"".Gosched} v205
    • Plainb41 (line 216)
    • b45: ← b40
    • Plainb44 (line +216)
    • b46: ← b37
      • v222 (+220) = Store <mem> {func(*g, unsafe.Pointer) bool} v220 v219 v216
      • v223 (220) = Store <mem> {unsafe.Pointer} v164 v128 v222
      • v226 (220) = Store <mem> {waitReason} v225 v224 v223
      • v229 (220) = Store <mem> {byte} v228 v227 v226
      • v231 (220) = Store <mem> {int} v230 v211 v229
      • v232 (220) = StaticCall <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = Store <mem> {int32} v234 v233 v235
      • v237 (223) = StaticCall <mem> {"".exit} [8] v236
    • Plainb49 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b49: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
    • Plainb50 (line +226)
    • b50: ← b49
      • v240 (+226) = NilCheck <void> v238 v244
      • v241 (226) = Store <mem> {int32} v238 v233 v244
    • Plainb51 (line 226)
    • b51: ← b50
    • Plainb49 (line +226)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • generic deadcode [81217 ns]

    • b1:
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v5 (?) = Const64 <uintptr> [0]
      • v15 (?) = ConstBool <bool> [true]
      • v16 (?) = Const64 <uintptr> [1000000000]
      • v17 (?) = Addr <*uintptr> {"".maxstacksize} v3
      • v20 (?) = Addr <*bool> {"".mainStarted} v3
      • v23 (?) = Addr <*func()> {"".main.func1·f} v3
      • v24 (?) = OffPtr <*func()> [0] v2
      • v36 (?) = Const32 <uint32> [1]
      • v44 (?) = ConstBool <bool> [false]
      • v72 (?) = Addr <*m> {"".m0} v3
      • v75 (?) = OffPtr <*string> [0] v2
      • v82 (?) = OffPtr <*int64> [0] v2
      • v84 (?) = Const64 <int64> [0]
      • v94 (?) = Addr <*func(*bool)> {"".main.func2·f} v3
      • v96 (?) = OffPtr <**bool> [16] v2
      • v98 (?) = Const32 <uint32> [8]
      • v99 (?) = OffPtr <*uint32> [0] v2
      • v101 (?) = OffPtr <*uintptr> [8] v2
      • v109 (?) = Addr <*int64> {"".runtimeInitTime} v3
      • v112 (?) = Addr <*uint8> {type.chan bool} v3
      • v113 (?) = OffPtr <**byte> [0] v2
      • v115 (?) = Const64 <int> [0] (c[int])
      • v116 (?) = OffPtr <*int> [8] v2
      • v119 (?) = OffPtr <*chan bool> [16] v2
      • v121 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v123 (?) = Addr <*bool> {"".iscgo} v3
      • v125 (?) = Addr <*unsafe.Pointer> {_cgo_thread_start} v3
      • v128 (?) = Const64 <unsafe.Pointer> [0]
      • v134 (?) = Addr <*unsafe.Pointer> {""._cgo_setenv} v3
      • v142 (?) = Addr <*unsafe.Pointer> {""._cgo_unsetenv} v3
      • v150 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v162 (?) = OffPtr <*unsafe.Pointer> [0] v2
      • v164 (?) = OffPtr <*unsafe.Pointer> [8] v2
      • v168 (?) = Addr <*func()> {"".main_init·f} v3 (fn[func()])
      • v174 (?) = OffPtr <*chan bool> [0] v2
      • v181 (?) = Addr <*bool> {"".isarchive} v3
      • v183 (?) = Addr <*bool> {"".islibrary} v3
      • v188 (?) = Addr <*func()> {"".main_main·f} v3 (fn[func()])
      • v192 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v197 (?) = Const32 <uint32> [0]
      • v200 (?) = Const64 <int> [1000]
      • v211 (?) = Const64 <int> [1]
      • v213 (?) = Addr <*uint32> {"".panicking} v3
      • v219 (?) = ConstNil <func(*g, unsafe.Pointer) bool>
      • v220 (?) = OffPtr <*func(*g, unsafe.Pointer) bool> [0] v2
      • v224 (?) = Const8 <waitReason> [8]
      • v225 (?) = OffPtr <*waitReason> [16] v2
      • v227 (?) = Const8 <byte> [16]
      • v228 (?) = OffPtr <*byte> [17] v2
      • v230 (?) = OffPtr <*int> [24] v2
      • v233 (?) = Const32 <int32> [0]
      • v234 (?) = OffPtr <*int32> [0] v2
      • v238 (?) = ConstNil <*int32> (x[*int32])
      • v243 (?) = Addr <*uint8> {go.string."runtime.main not on m0"} v3
      • v239 (?) = Const64 <int> [22]
      • v221 (?) = Addr <*uint8> {go.string."nanotime returning zero"} v3
      • v210 (?) = Const64 <int> [23]
      • v203 (?) = Addr <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v184 (?) = Const64 <int> [25]
      • v189 (?) = Addr <*uint8> {go.string."_cgo_setenv missing"} v3
      • v158 (?) = Const64 <int> [19]
      • v155 (?) = Addr <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v143 (?) = Const64 <int> [21]
      • v139 (?) = Addr <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v135 (?) = Const64 <int> [37]
      • v1 (?) = InitMem <mem>
      • v4 (+111) = GetG <*g> v1 (g[*g])
      • v7 (+115) = OffPtr <**m> [48] v4
      • v8 (115) = Load <*m> v7 v1
      • v10 (115) = OffPtr <**g> [0] v8
      • v11 (115) = Load <*g> v10 v1
      • v13 (115) = OffPtr <*uintptr> [304] v11
      • v14 (115) = Store <mem> {uintptr} v13 v5 v1
      • v9 (115) = NilCheck <void> v8 v1
      • v12 (115) = NilCheck <void> v11 v1
    • Plainb2 (line +120)
    • b2: ← b1
      • v19 (+121) = Store <mem> {uintptr} v17 v16 v14
    • Plainb3 (line 121)
    • b3: ← b2
      • v22 (+127) = Store <mem> {bool} v20 v15 v19
    • Plainb4 (line +129)
    • b4: ← b3
      • v26 (+130) = Store <mem> {func()} v24 v23 v22
      • v27 (130) = StaticCall <mem> {"".systemstack} [8] v26
    • Plainb5 (line 130)
    • b5: ← b4
      • v29 (+3614) = GetG <*g> v27
      • v31 (3614) = OffPtr <**m> [48] v29
      • v32 (3614) = Load <*m> v31 v27
      • v34 (3614) = OffPtr <*uint32> [620] v32
      • v35 (3614) = Load <uint32> v34 v27
      • v37 (3614) = Add32 <uint32> v35 v36
      • v43 (3614) = Store <mem> {uint32} v34 v37 v27
      • v33 (3614) = NilCheck <void> v32 v27
    • Plainb7 (line +3572)
    • b7: ← b5
      • v46 (+3575) = GetG <*g> v43 (g[*g], _g_[*g])
      • v48 (+3576) = OffPtr <**m> [48] v46
      • v49 (3576) = Load <*m> v48 v43
      • v51 (3576) = OffPtr <*guintptr> [352] v49 (gp[*guintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v55 (205) = Store <mem> {guintptr} v51 v53 v43
      • v50 (3576) = NilCheck <void> v49 v43
      • v54 (205) = NilCheck <void> v51 v43
    • Plainb8 (line +3576)
    • b8: ← b7
      • v58 (+3577) = NilCheck <void> v46 v55
      • v59 (3577) = OffPtr <*muintptr> [216] v46 (mp[*muintptr])
      • v62 (3577) = Load <*m> v48 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v66 (243) = Store <mem> {muintptr} v59 v64 v55
      • v65 (243) = NilCheck <void> v59 v55
    • Plainb9 (line +3577)
    • b9: ← b8
    • Plainb10 (line 143)
    • b10: ← b9
    • Plainb11 (line 143)
    • b11: ← b10
      • v69 (+143) = NilCheck <void> v4 v66
      • v71 (143) = Load <*m> v7 v66
      • v73 (143) = NeqPtr <bool> v71 v72
    • If v73b12 b13 (line 143)
    • b12: ← b11
      • v60 (144) = OffPtr <*int> [8] v2
      • v41 (+144) = Store <mem> {*uint8} v75 v243 v66
      • v77 (+144) = Store <mem> {int} v60 v239 v41
      • v78 (144) = StaticCall <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = StaticCall <mem> {runtime.init} v66
      • v81 (+148) = StaticCall <mem> {"".nanotime} [8] v80
      • v83 (148) = Load <int64> v82 v81
      • v85 (148) = Eq64 <bool> v83 v84
    • If v85b14 b16 (line 148)
    • b14: ← b13
      • v145 (149) = OffPtr <*int> [8] v2
      • v153 (+149) = Store <mem> {*uint8} v75 v221 v81
      • v88 (+149) = Store <mem> {int} v145 v210 v153
      • v89 (149) = StaticCall <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b16
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (153) = LocalAddr <*bool> {needUnlock} v2 v91
      • v93 (+153) = Store <mem> {bool} v92 v15 v91
      • v95 (+154) = LocalAddr <*bool> {needUnlock} v2 v93
      • v97 (+158) = Store <mem> {*bool} v96 v95 v93
      • v100 (+154) = Store <mem> {uint32} v99 v98 v97
      • v102 (154) = Store <mem> {uintptr} v101 v94 v100
      • v103 (154) = StaticCall <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b16: ← b13
    • Plainb15 (line +153)
    • b17: ← b15
      • v107 (+162) = StaticCall <mem> {"".nanotime} [8] v103
      • v108 (162) = Load <int64> v82 v107
      • v110 (162) = Store <mem> {int64} v109 v108 v107
      • v111 (+164) = StaticCall <mem> {"".gcenable} v110
      • v114 (+166) = Store <mem> {*byte} v113 v112 v111
      • v117 (166) = Store <mem> {int} v116 v115 v114
      • v118 (166) = StaticCall <mem> {runtime.makechan} [24] v117
      • v120 (166) = Load <chan bool> v119 v118
      • v122 (166) = Store <mem> {chan bool} v121 v120 v118
      • v124 (+167) = Load <bool> v123 v122
    • If v124b19 b20 (line 167)
    • b18: ← b15
      • v105 (154) = StaticCall <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b17
      • v127 (+168) = Load <unsafe.Pointer> v125 v122
      • v131 (168) = IsNonNil <bool> v127
    • If v131b22 b21 (line 168)
    • b20: ← b17 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = Load <uintptr> v168 v169
      • v171 (189) = ClosureCall <mem> [0] v170 v168 v169
      • v173 (+190) = Load <chan bool> v121 v171
      • v175 (190) = Store <mem> {chan bool} v174 v173 v171
      • v176 (190) = StaticCall <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v178 (192) = LocalAddr <*bool> {needUnlock} v2 v177
      • v179 (+192) = Store <mem> {bool} v178 v44 v177
      • v180 (+193) = StaticCall <mem> {"".unlockOSThread} v179
      • v182 (+195) = Load <bool> v181 v180
    • If v182b31 b33 (line 195)
    • b21: ← b19
      • v137 (169) = OffPtr <*int> [8] v2
      • v129 (+169) = Store <mem> {*uint8} v75 v203 v122
      • v132 (+169) = Store <mem> {int} v137 v184 v129
      • v133 (169) = StaticCall <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b22: ← b19
    • Plainb23
    • b23: ← b22
      • v136 (+172) = Load <unsafe.Pointer> v134 v122
      • v126 (172) = IsNonNil <bool> v136
    • If v126b26 b25 (line 172)
    • b24: ← b28
      • v152 (+179) = Load <unsafe.Pointer> v150 v122
      • v104 (179) = IsNonNil <bool> v152
    • If v104b30 b29 (line 179)
    • b25: ← b23
      • v47 (173) = OffPtr <*int> [8] v2
      • v38 (+173) = Store <mem> {*uint8} v75 v189 v122
      • v140 (+173) = Store <mem> {int} v47 v158 v38
      • v141 (173) = StaticCall <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v144 (+175) = Load <unsafe.Pointer> v142 v122
      • v106 (175) = IsNonNil <bool> v144
    • If v106b28 b27 (line 175)
    • b27: ← b26
      • v30 (176) = OffPtr <*int> [8] v2
      • v28 (+176) = Store <mem> {*uint8} v75 v155 v122
      • v148 (+176) = Store <mem> {int} v30 v143 v28
      • v149 (176) = StaticCall <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b28: ← b26
    • Plainb24 (line +179)
    • b29: ← b24
      • v21 (180) = OffPtr <*int> [8] v2
      • v151 (+180) = Store <mem> {*uint8} v75 v139 v122
      • v156 (+180) = Store <mem> {int} v21 v135 v151
      • v157 (180) = StaticCall <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = StaticCall <mem> {"".startTemplateThread} v122
      • v161 (+185) = Load <unsafe.Pointer> v150 v159
      • v163 (185) = Store <mem> {unsafe.Pointer} v162 v161 v159
      • v165 (185) = Store <mem> {unsafe.Pointer} v164 v128 v163
      • v166 (185) = StaticCall <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = StaticCall <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b32: ← b33
      • v190 (+201) = Load <uintptr> v188 v180
      • v191 (201) = ClosureCall <mem> [0] v190 v188 v180
    • Plainb35 (line +202)
    • b33: ← b20
      • v185 (195) = Load <bool> v183 v180
    • If v185b31 b32 (line 195)
    • b35: ← b32
      • v194 (+210) = AtomicLoad32 <uint32,mem> v192 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v198 (210) = Neq32 <bool> v197 v196
    • If v198b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = AtomicLoad32 <uint32,mem> v213 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v218 (219) = Neq32 <bool> v217 v197
    • If v218b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v201 (+212) = Less64 <bool> v199 v200
    • If v201b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = AtomicLoad32 <uint32,mem> v192 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v207 (213) = Eq32 <bool> v206 v197
    • If v207b43 b45 (line 213)
    • b41: ← b44
      • v212 (+212) = Add64 <int> v199 v211 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b44: ← b45
      • v209 (+216) = StaticCall <mem> {"".Gosched} v205
    • Plainb41 (line 216)
    • b45: ← b40
    • Plainb44 (line +216)
    • b46: ← b37
      • v222 (+220) = Store <mem> {func(*g, unsafe.Pointer) bool} v220 v219 v216
      • v223 (220) = Store <mem> {unsafe.Pointer} v164 v128 v222
      • v226 (220) = Store <mem> {waitReason} v225 v224 v223
      • v229 (220) = Store <mem> {byte} v228 v227 v226
      • v231 (220) = Store <mem> {int} v230 v211 v229
      • v232 (220) = StaticCall <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = Store <mem> {int32} v234 v233 v235
      • v237 (223) = StaticCall <mem> {"".exit} [8] v236
    • Plainb49 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b49: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
    • Plainb50 (line +226)
    • b50: ← b49
      • v240 (+226) = NilCheck <void> v238 v244
      • v241 (226) = Store <mem> {int32} v238 v233 v244
    • Plainb51 (line 226)
    • b51: ← b50
    • Plainb49 (line +226)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • check bce [358 ns]

    • b1:
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v5 (?) = Const64 <uintptr> [0]
      • v15 (?) = ConstBool <bool> [true]
      • v16 (?) = Const64 <uintptr> [1000000000]
      • v17 (?) = Addr <*uintptr> {"".maxstacksize} v3
      • v20 (?) = Addr <*bool> {"".mainStarted} v3
      • v23 (?) = Addr <*func()> {"".main.func1·f} v3
      • v24 (?) = OffPtr <*func()> [0] v2
      • v36 (?) = Const32 <uint32> [1]
      • v44 (?) = ConstBool <bool> [false]
      • v72 (?) = Addr <*m> {"".m0} v3
      • v75 (?) = OffPtr <*string> [0] v2
      • v82 (?) = OffPtr <*int64> [0] v2
      • v84 (?) = Const64 <int64> [0]
      • v94 (?) = Addr <*func(*bool)> {"".main.func2·f} v3
      • v96 (?) = OffPtr <**bool> [16] v2
      • v98 (?) = Const32 <uint32> [8]
      • v99 (?) = OffPtr <*uint32> [0] v2
      • v101 (?) = OffPtr <*uintptr> [8] v2
      • v109 (?) = Addr <*int64> {"".runtimeInitTime} v3
      • v112 (?) = Addr <*uint8> {type.chan bool} v3
      • v113 (?) = OffPtr <**byte> [0] v2
      • v115 (?) = Const64 <int> [0] (c[int])
      • v116 (?) = OffPtr <*int> [8] v2
      • v119 (?) = OffPtr <*chan bool> [16] v2
      • v121 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v123 (?) = Addr <*bool> {"".iscgo} v3
      • v125 (?) = Addr <*unsafe.Pointer> {_cgo_thread_start} v3
      • v128 (?) = Const64 <unsafe.Pointer> [0]
      • v134 (?) = Addr <*unsafe.Pointer> {""._cgo_setenv} v3
      • v142 (?) = Addr <*unsafe.Pointer> {""._cgo_unsetenv} v3
      • v150 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v162 (?) = OffPtr <*unsafe.Pointer> [0] v2
      • v164 (?) = OffPtr <*unsafe.Pointer> [8] v2
      • v168 (?) = Addr <*func()> {"".main_init·f} v3 (fn[func()])
      • v174 (?) = OffPtr <*chan bool> [0] v2
      • v181 (?) = Addr <*bool> {"".isarchive} v3
      • v183 (?) = Addr <*bool> {"".islibrary} v3
      • v188 (?) = Addr <*func()> {"".main_main·f} v3 (fn[func()])
      • v192 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v197 (?) = Const32 <uint32> [0]
      • v200 (?) = Const64 <int> [1000]
      • v211 (?) = Const64 <int> [1]
      • v213 (?) = Addr <*uint32> {"".panicking} v3
      • v219 (?) = ConstNil <func(*g, unsafe.Pointer) bool>
      • v220 (?) = OffPtr <*func(*g, unsafe.Pointer) bool> [0] v2
      • v224 (?) = Const8 <waitReason> [8]
      • v225 (?) = OffPtr <*waitReason> [16] v2
      • v227 (?) = Const8 <byte> [16]
      • v228 (?) = OffPtr <*byte> [17] v2
      • v230 (?) = OffPtr <*int> [24] v2
      • v233 (?) = Const32 <int32> [0]
      • v234 (?) = OffPtr <*int32> [0] v2
      • v238 (?) = ConstNil <*int32> (x[*int32])
      • v243 (?) = Addr <*uint8> {go.string."runtime.main not on m0"} v3
      • v239 (?) = Const64 <int> [22]
      • v221 (?) = Addr <*uint8> {go.string."nanotime returning zero"} v3
      • v210 (?) = Const64 <int> [23]
      • v203 (?) = Addr <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v184 (?) = Const64 <int> [25]
      • v189 (?) = Addr <*uint8> {go.string."_cgo_setenv missing"} v3
      • v158 (?) = Const64 <int> [19]
      • v155 (?) = Addr <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v143 (?) = Const64 <int> [21]
      • v139 (?) = Addr <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v135 (?) = Const64 <int> [37]
      • v1 (?) = InitMem <mem>
      • v4 (+111) = GetG <*g> v1 (g[*g])
      • v7 (+115) = OffPtr <**m> [48] v4
      • v8 (115) = Load <*m> v7 v1
      • v10 (115) = OffPtr <**g> [0] v8
      • v11 (115) = Load <*g> v10 v1
      • v13 (115) = OffPtr <*uintptr> [304] v11
      • v14 (115) = Store <mem> {uintptr} v13 v5 v1
      • v9 (115) = NilCheck <void> v8 v1
      • v12 (115) = NilCheck <void> v11 v1
    • Plainb2 (line +120)
    • b2: ← b1
      • v19 (+121) = Store <mem> {uintptr} v17 v16 v14
    • Plainb3 (line 121)
    • b3: ← b2
      • v22 (+127) = Store <mem> {bool} v20 v15 v19
    • Plainb4 (line +129)
    • b4: ← b3
      • v26 (+130) = Store <mem> {func()} v24 v23 v22
      • v27 (130) = StaticCall <mem> {"".systemstack} [8] v26
    • Plainb5 (line 130)
    • b5: ← b4
      • v29 (+3614) = GetG <*g> v27
      • v31 (3614) = OffPtr <**m> [48] v29
      • v32 (3614) = Load <*m> v31 v27
      • v34 (3614) = OffPtr <*uint32> [620] v32
      • v35 (3614) = Load <uint32> v34 v27
      • v37 (3614) = Add32 <uint32> v35 v36
      • v43 (3614) = Store <mem> {uint32} v34 v37 v27
      • v33 (3614) = NilCheck <void> v32 v27
    • Plainb7 (line +3572)
    • b7: ← b5
      • v46 (+3575) = GetG <*g> v43 (_g_[*g], g[*g])
      • v48 (+3576) = OffPtr <**m> [48] v46
      • v49 (3576) = Load <*m> v48 v43
      • v51 (3576) = OffPtr <*guintptr> [352] v49 (gp[*guintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v55 (205) = Store <mem> {guintptr} v51 v53 v43
      • v50 (3576) = NilCheck <void> v49 v43
      • v54 (205) = NilCheck <void> v51 v43
    • Plainb8 (line +3576)
    • b8: ← b7
      • v58 (+3577) = NilCheck <void> v46 v55
      • v59 (3577) = OffPtr <*muintptr> [216] v46 (mp[*muintptr])
      • v62 (3577) = Load <*m> v48 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v66 (243) = Store <mem> {muintptr} v59 v64 v55
      • v65 (243) = NilCheck <void> v59 v55
    • Plainb9 (line +3577)
    • b9: ← b8
    • Plainb10 (line 143)
    • b10: ← b9
    • Plainb11 (line 143)
    • b11: ← b10
      • v69 (+143) = NilCheck <void> v4 v66
      • v71 (143) = Load <*m> v7 v66
      • v73 (143) = NeqPtr <bool> v71 v72
    • If v73b12 b13 (line 143)
    • b12: ← b11
      • v60 (144) = OffPtr <*int> [8] v2
      • v41 (+144) = Store <mem> {*uint8} v75 v243 v66
      • v77 (+144) = Store <mem> {int} v60 v239 v41
      • v78 (144) = StaticCall <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = StaticCall <mem> {runtime.init} v66
      • v81 (+148) = StaticCall <mem> {"".nanotime} [8] v80
      • v83 (148) = Load <int64> v82 v81
      • v85 (148) = Eq64 <bool> v83 v84
    • If v85b14 b16 (line 148)
    • b14: ← b13
      • v145 (149) = OffPtr <*int> [8] v2
      • v153 (+149) = Store <mem> {*uint8} v75 v221 v81
      • v88 (+149) = Store <mem> {int} v145 v210 v153
      • v89 (149) = StaticCall <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b16
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (153) = LocalAddr <*bool> {needUnlock} v2 v91
      • v93 (+153) = Store <mem> {bool} v92 v15 v91
      • v95 (+154) = LocalAddr <*bool> {needUnlock} v2 v93
      • v97 (+158) = Store <mem> {*bool} v96 v95 v93
      • v100 (+154) = Store <mem> {uint32} v99 v98 v97
      • v102 (154) = Store <mem> {uintptr} v101 v94 v100
      • v103 (154) = StaticCall <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b16: ← b13
    • Plainb15 (line +153)
    • b17: ← b15
      • v107 (+162) = StaticCall <mem> {"".nanotime} [8] v103
      • v108 (162) = Load <int64> v82 v107
      • v110 (162) = Store <mem> {int64} v109 v108 v107
      • v111 (+164) = StaticCall <mem> {"".gcenable} v110
      • v114 (+166) = Store <mem> {*byte} v113 v112 v111
      • v117 (166) = Store <mem> {int} v116 v115 v114
      • v118 (166) = StaticCall <mem> {runtime.makechan} [24] v117
      • v120 (166) = Load <chan bool> v119 v118
      • v122 (166) = Store <mem> {chan bool} v121 v120 v118
      • v124 (+167) = Load <bool> v123 v122
    • If v124b19 b20 (line 167)
    • b18: ← b15
      • v105 (154) = StaticCall <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b17
      • v127 (+168) = Load <unsafe.Pointer> v125 v122
      • v131 (168) = IsNonNil <bool> v127
    • If v131b22 b21 (line 168)
    • b20: ← b17 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = Load <uintptr> v168 v169
      • v171 (189) = ClosureCall <mem> [0] v170 v168 v169
      • v173 (+190) = Load <chan bool> v121 v171
      • v175 (190) = Store <mem> {chan bool} v174 v173 v171
      • v176 (190) = StaticCall <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v178 (192) = LocalAddr <*bool> {needUnlock} v2 v177
      • v179 (+192) = Store <mem> {bool} v178 v44 v177
      • v180 (+193) = StaticCall <mem> {"".unlockOSThread} v179
      • v182 (+195) = Load <bool> v181 v180
    • If v182b31 b33 (line 195)
    • b21: ← b19
      • v137 (169) = OffPtr <*int> [8] v2
      • v129 (+169) = Store <mem> {*uint8} v75 v203 v122
      • v132 (+169) = Store <mem> {int} v137 v184 v129
      • v133 (169) = StaticCall <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b22: ← b19
    • Plainb23
    • b23: ← b22
      • v136 (+172) = Load <unsafe.Pointer> v134 v122
      • v126 (172) = IsNonNil <bool> v136
    • If v126b26 b25 (line 172)
    • b24: ← b28
      • v152 (+179) = Load <unsafe.Pointer> v150 v122
      • v104 (179) = IsNonNil <bool> v152
    • If v104b30 b29 (line 179)
    • b25: ← b23
      • v47 (173) = OffPtr <*int> [8] v2
      • v38 (+173) = Store <mem> {*uint8} v75 v189 v122
      • v140 (+173) = Store <mem> {int} v47 v158 v38
      • v141 (173) = StaticCall <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v144 (+175) = Load <unsafe.Pointer> v142 v122
      • v106 (175) = IsNonNil <bool> v144
    • If v106b28 b27 (line 175)
    • b27: ← b26
      • v30 (176) = OffPtr <*int> [8] v2
      • v28 (+176) = Store <mem> {*uint8} v75 v155 v122
      • v148 (+176) = Store <mem> {int} v30 v143 v28
      • v149 (176) = StaticCall <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b28: ← b26
    • Plainb24 (line +179)
    • b29: ← b24
      • v21 (180) = OffPtr <*int> [8] v2
      • v151 (+180) = Store <mem> {*uint8} v75 v139 v122
      • v156 (+180) = Store <mem> {int} v21 v135 v151
      • v157 (180) = StaticCall <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = StaticCall <mem> {"".startTemplateThread} v122
      • v161 (+185) = Load <unsafe.Pointer> v150 v159
      • v163 (185) = Store <mem> {unsafe.Pointer} v162 v161 v159
      • v165 (185) = Store <mem> {unsafe.Pointer} v164 v128 v163
      • v166 (185) = StaticCall <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = StaticCall <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b32: ← b33
      • v190 (+201) = Load <uintptr> v188 v180
      • v191 (201) = ClosureCall <mem> [0] v190 v188 v180
    • Plainb35 (line +202)
    • b33: ← b20
      • v185 (195) = Load <bool> v183 v180
    • If v185b31 b32 (line 195)
    • b35: ← b32
      • v194 (+210) = AtomicLoad32 <uint32,mem> v192 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v198 (210) = Neq32 <bool> v197 v196
    • If v198b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = AtomicLoad32 <uint32,mem> v213 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v218 (219) = Neq32 <bool> v217 v197
    • If v218b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v201 (+212) = Less64 <bool> v199 v200
    • If v201b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = AtomicLoad32 <uint32,mem> v192 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v207 (213) = Eq32 <bool> v206 v197
    • If v207b43 b45 (line 213)
    • b41: ← b44
      • v212 (+212) = Add64 <int> v199 v211 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b44: ← b45
      • v209 (+216) = StaticCall <mem> {"".Gosched} v205
    • Plainb41 (line 216)
    • b45: ← b40
    • Plainb44 (line +216)
    • b46: ← b37
      • v222 (+220) = Store <mem> {func(*g, unsafe.Pointer) bool} v220 v219 v216
      • v223 (220) = Store <mem> {unsafe.Pointer} v164 v128 v222
      • v226 (220) = Store <mem> {waitReason} v225 v224 v223
      • v229 (220) = Store <mem> {byte} v228 v227 v226
      • v231 (220) = Store <mem> {int} v230 v211 v229
      • v232 (220) = StaticCall <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = Store <mem> {int32} v234 v233 v235
      • v237 (223) = StaticCall <mem> {"".exit} [8] v236
    • Plainb49 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b49: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
    • Plainb50 (line +226)
    • b50: ← b49
      • v240 (+226) = NilCheck <void> v238 v244
      • v241 (226) = Store <mem> {int32} v238 v233 v244
    • Plainb51 (line 226)
    • b51: ← b50
    • Plainb49 (line +226)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • branchelim [5456 ns]

    • b1:
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v5 (?) = Const64 <uintptr> [0]
      • v15 (?) = ConstBool <bool> [true]
      • v16 (?) = Const64 <uintptr> [1000000000]
      • v17 (?) = Addr <*uintptr> {"".maxstacksize} v3
      • v20 (?) = Addr <*bool> {"".mainStarted} v3
      • v23 (?) = Addr <*func()> {"".main.func1·f} v3
      • v24 (?) = OffPtr <*func()> [0] v2
      • v36 (?) = Const32 <uint32> [1]
      • v44 (?) = ConstBool <bool> [false]
      • v72 (?) = Addr <*m> {"".m0} v3
      • v75 (?) = OffPtr <*string> [0] v2
      • v82 (?) = OffPtr <*int64> [0] v2
      • v84 (?) = Const64 <int64> [0]
      • v94 (?) = Addr <*func(*bool)> {"".main.func2·f} v3
      • v96 (?) = OffPtr <**bool> [16] v2
      • v98 (?) = Const32 <uint32> [8]
      • v99 (?) = OffPtr <*uint32> [0] v2
      • v101 (?) = OffPtr <*uintptr> [8] v2
      • v109 (?) = Addr <*int64> {"".runtimeInitTime} v3
      • v112 (?) = Addr <*uint8> {type.chan bool} v3
      • v113 (?) = OffPtr <**byte> [0] v2
      • v115 (?) = Const64 <int> [0] (c[int])
      • v116 (?) = OffPtr <*int> [8] v2
      • v119 (?) = OffPtr <*chan bool> [16] v2
      • v121 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v123 (?) = Addr <*bool> {"".iscgo} v3
      • v125 (?) = Addr <*unsafe.Pointer> {_cgo_thread_start} v3
      • v128 (?) = Const64 <unsafe.Pointer> [0]
      • v134 (?) = Addr <*unsafe.Pointer> {""._cgo_setenv} v3
      • v142 (?) = Addr <*unsafe.Pointer> {""._cgo_unsetenv} v3
      • v150 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v162 (?) = OffPtr <*unsafe.Pointer> [0] v2
      • v164 (?) = OffPtr <*unsafe.Pointer> [8] v2
      • v168 (?) = Addr <*func()> {"".main_init·f} v3 (fn[func()])
      • v174 (?) = OffPtr <*chan bool> [0] v2
      • v181 (?) = Addr <*bool> {"".isarchive} v3
      • v183 (?) = Addr <*bool> {"".islibrary} v3
      • v188 (?) = Addr <*func()> {"".main_main·f} v3 (fn[func()])
      • v192 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v197 (?) = Const32 <uint32> [0]
      • v200 (?) = Const64 <int> [1000]
      • v211 (?) = Const64 <int> [1]
      • v213 (?) = Addr <*uint32> {"".panicking} v3
      • v219 (?) = ConstNil <func(*g, unsafe.Pointer) bool>
      • v220 (?) = OffPtr <*func(*g, unsafe.Pointer) bool> [0] v2
      • v224 (?) = Const8 <waitReason> [8]
      • v225 (?) = OffPtr <*waitReason> [16] v2
      • v227 (?) = Const8 <byte> [16]
      • v228 (?) = OffPtr <*byte> [17] v2
      • v230 (?) = OffPtr <*int> [24] v2
      • v233 (?) = Const32 <int32> [0]
      • v234 (?) = OffPtr <*int32> [0] v2
      • v238 (?) = ConstNil <*int32> (x[*int32])
      • v243 (?) = Addr <*uint8> {go.string."runtime.main not on m0"} v3
      • v239 (?) = Const64 <int> [22]
      • v221 (?) = Addr <*uint8> {go.string."nanotime returning zero"} v3
      • v210 (?) = Const64 <int> [23]
      • v203 (?) = Addr <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v184 (?) = Const64 <int> [25]
      • v189 (?) = Addr <*uint8> {go.string."_cgo_setenv missing"} v3
      • v158 (?) = Const64 <int> [19]
      • v155 (?) = Addr <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v143 (?) = Const64 <int> [21]
      • v139 (?) = Addr <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v135 (?) = Const64 <int> [37]
      • v1 (?) = InitMem <mem>
      • v4 (+111) = GetG <*g> v1 (g[*g])
      • v7 (+115) = OffPtr <**m> [48] v4
      • v8 (115) = Load <*m> v7 v1
      • v10 (115) = OffPtr <**g> [0] v8
      • v11 (115) = Load <*g> v10 v1
      • v13 (115) = OffPtr <*uintptr> [304] v11
      • v14 (115) = Store <mem> {uintptr} v13 v5 v1
      • v9 (115) = NilCheck <void> v8 v1
      • v12 (115) = NilCheck <void> v11 v1
    • Plainb2 (line +120)
    • b2: ← b1
      • v19 (+121) = Store <mem> {uintptr} v17 v16 v14
    • Plainb3 (line 121)
    • b3: ← b2
      • v22 (+127) = Store <mem> {bool} v20 v15 v19
    • Plainb4 (line +129)
    • b4: ← b3
      • v26 (+130) = Store <mem> {func()} v24 v23 v22
      • v27 (130) = StaticCall <mem> {"".systemstack} [8] v26
    • Plainb5 (line 130)
    • b5: ← b4
      • v29 (+3614) = GetG <*g> v27
      • v31 (3614) = OffPtr <**m> [48] v29
      • v32 (3614) = Load <*m> v31 v27
      • v34 (3614) = OffPtr <*uint32> [620] v32
      • v35 (3614) = Load <uint32> v34 v27
      • v37 (3614) = Add32 <uint32> v35 v36
      • v43 (3614) = Store <mem> {uint32} v34 v37 v27
      • v33 (3614) = NilCheck <void> v32 v27
    • Plainb7 (line +3572)
    • b7: ← b5
      • v46 (+3575) = GetG <*g> v43 (_g_[*g], g[*g])
      • v48 (+3576) = OffPtr <**m> [48] v46
      • v49 (3576) = Load <*m> v48 v43
      • v51 (3576) = OffPtr <*guintptr> [352] v49 (gp[*guintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v55 (205) = Store <mem> {guintptr} v51 v53 v43
      • v50 (3576) = NilCheck <void> v49 v43
      • v54 (205) = NilCheck <void> v51 v43
    • Plainb8 (line +3576)
    • b8: ← b7
      • v58 (+3577) = NilCheck <void> v46 v55
      • v59 (3577) = OffPtr <*muintptr> [216] v46 (mp[*muintptr])
      • v62 (3577) = Load <*m> v48 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v66 (243) = Store <mem> {muintptr} v59 v64 v55
      • v65 (243) = NilCheck <void> v59 v55
    • Plainb9 (line +3577)
    • b9: ← b8
    • Plainb10 (line 143)
    • b10: ← b9
    • Plainb11 (line 143)
    • b11: ← b10
      • v69 (+143) = NilCheck <void> v4 v66
      • v71 (143) = Load <*m> v7 v66
      • v73 (143) = NeqPtr <bool> v71 v72
    • If v73b12 b13 (line 143)
    • b12: ← b11
      • v60 (144) = OffPtr <*int> [8] v2
      • v41 (+144) = Store <mem> {*uint8} v75 v243 v66
      • v77 (+144) = Store <mem> {int} v60 v239 v41
      • v78 (144) = StaticCall <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = StaticCall <mem> {runtime.init} v66
      • v81 (+148) = StaticCall <mem> {"".nanotime} [8] v80
      • v83 (148) = Load <int64> v82 v81
      • v85 (148) = Eq64 <bool> v83 v84
    • If v85b14 b16 (line 148)
    • b14: ← b13
      • v145 (149) = OffPtr <*int> [8] v2
      • v153 (+149) = Store <mem> {*uint8} v75 v221 v81
      • v88 (+149) = Store <mem> {int} v145 v210 v153
      • v89 (149) = StaticCall <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b16
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (153) = LocalAddr <*bool> {needUnlock} v2 v91
      • v93 (+153) = Store <mem> {bool} v92 v15 v91
      • v95 (+154) = LocalAddr <*bool> {needUnlock} v2 v93
      • v97 (+158) = Store <mem> {*bool} v96 v95 v93
      • v100 (+154) = Store <mem> {uint32} v99 v98 v97
      • v102 (154) = Store <mem> {uintptr} v101 v94 v100
      • v103 (154) = StaticCall <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b16: ← b13
    • Plainb15 (line +153)
    • b17: ← b15
      • v107 (+162) = StaticCall <mem> {"".nanotime} [8] v103
      • v108 (162) = Load <int64> v82 v107
      • v110 (162) = Store <mem> {int64} v109 v108 v107
      • v111 (+164) = StaticCall <mem> {"".gcenable} v110
      • v114 (+166) = Store <mem> {*byte} v113 v112 v111
      • v117 (166) = Store <mem> {int} v116 v115 v114
      • v118 (166) = StaticCall <mem> {runtime.makechan} [24] v117
      • v120 (166) = Load <chan bool> v119 v118
      • v122 (166) = Store <mem> {chan bool} v121 v120 v118
      • v124 (+167) = Load <bool> v123 v122
    • If v124b19 b20 (line 167)
    • b18: ← b15
      • v105 (154) = StaticCall <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b17
      • v127 (+168) = Load <unsafe.Pointer> v125 v122
      • v131 (168) = IsNonNil <bool> v127
    • If v131b22 b21 (line 168)
    • b20: ← b17 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = Load <uintptr> v168 v169
      • v171 (189) = ClosureCall <mem> [0] v170 v168 v169
      • v173 (+190) = Load <chan bool> v121 v171
      • v175 (190) = Store <mem> {chan bool} v174 v173 v171
      • v176 (190) = StaticCall <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v178 (192) = LocalAddr <*bool> {needUnlock} v2 v177
      • v179 (+192) = Store <mem> {bool} v178 v44 v177
      • v180 (+193) = StaticCall <mem> {"".unlockOSThread} v179
      • v182 (+195) = Load <bool> v181 v180
    • If v182b31 b33 (line 195)
    • b21: ← b19
      • v137 (169) = OffPtr <*int> [8] v2
      • v129 (+169) = Store <mem> {*uint8} v75 v203 v122
      • v132 (+169) = Store <mem> {int} v137 v184 v129
      • v133 (169) = StaticCall <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b22: ← b19
    • Plainb23
    • b23: ← b22
      • v136 (+172) = Load <unsafe.Pointer> v134 v122
      • v126 (172) = IsNonNil <bool> v136
    • If v126b26 b25 (line 172)
    • b24: ← b28
      • v152 (+179) = Load <unsafe.Pointer> v150 v122
      • v104 (179) = IsNonNil <bool> v152
    • If v104b30 b29 (line 179)
    • b25: ← b23
      • v47 (173) = OffPtr <*int> [8] v2
      • v38 (+173) = Store <mem> {*uint8} v75 v189 v122
      • v140 (+173) = Store <mem> {int} v47 v158 v38
      • v141 (173) = StaticCall <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v144 (+175) = Load <unsafe.Pointer> v142 v122
      • v106 (175) = IsNonNil <bool> v144
    • If v106b28 b27 (line 175)
    • b27: ← b26
      • v30 (176) = OffPtr <*int> [8] v2
      • v28 (+176) = Store <mem> {*uint8} v75 v155 v122
      • v148 (+176) = Store <mem> {int} v30 v143 v28
      • v149 (176) = StaticCall <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b28: ← b26
    • Plainb24 (line +179)
    • b29: ← b24
      • v21 (180) = OffPtr <*int> [8] v2
      • v151 (+180) = Store <mem> {*uint8} v75 v139 v122
      • v156 (+180) = Store <mem> {int} v21 v135 v151
      • v157 (180) = StaticCall <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = StaticCall <mem> {"".startTemplateThread} v122
      • v161 (+185) = Load <unsafe.Pointer> v150 v159
      • v163 (185) = Store <mem> {unsafe.Pointer} v162 v161 v159
      • v165 (185) = Store <mem> {unsafe.Pointer} v164 v128 v163
      • v166 (185) = StaticCall <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = StaticCall <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b32: ← b33
      • v190 (+201) = Load <uintptr> v188 v180
      • v191 (201) = ClosureCall <mem> [0] v190 v188 v180
    • Plainb35 (line +202)
    • b33: ← b20
      • v185 (195) = Load <bool> v183 v180
    • If v185b31 b32 (line 195)
    • b35: ← b32
      • v194 (+210) = AtomicLoad32 <uint32,mem> v192 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v198 (210) = Neq32 <bool> v197 v196
    • If v198b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = AtomicLoad32 <uint32,mem> v213 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v218 (219) = Neq32 <bool> v217 v197
    • If v218b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v201 (+212) = Less64 <bool> v199 v200
    • If v201b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = AtomicLoad32 <uint32,mem> v192 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v207 (213) = Eq32 <bool> v206 v197
    • If v207b43 b45 (line 213)
    • b41: ← b44
      • v212 (+212) = Add64 <int> v199 v211 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b44: ← b45
      • v209 (+216) = StaticCall <mem> {"".Gosched} v205
    • Plainb41 (line 216)
    • b45: ← b40
    • Plainb44 (line +216)
    • b46: ← b37
      • v222 (+220) = Store <mem> {func(*g, unsafe.Pointer) bool} v220 v219 v216
      • v223 (220) = Store <mem> {unsafe.Pointer} v164 v128 v222
      • v226 (220) = Store <mem> {waitReason} v225 v224 v223
      • v229 (220) = Store <mem> {byte} v228 v227 v226
      • v231 (220) = Store <mem> {int} v230 v211 v229
      • v232 (220) = StaticCall <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = Store <mem> {int32} v234 v233 v235
      • v237 (223) = StaticCall <mem> {"".exit} [8] v236
    • Plainb49 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b49: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
    • Plainb50 (line +226)
    • b50: ← b49
      • v240 (+226) = NilCheck <void> v238 v244
      • v241 (226) = Store <mem> {int32} v238 v233 v244
    • Plainb51 (line 226)
    • b51: ← b50
    • Plainb49 (line +226)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • fuse [79707 ns]

    • b1:
    • BlockInvalid (line +120)
    • b2:
    • BlockInvalid (line 121)
    • b3:
    • BlockInvalid (line +129)
    • b4:
    • BlockInvalid (line 130)
    • b5:
    • BlockInvalid (line +3572)
    • b7:
    • BlockInvalid (line +3576)
    • b8:
    • BlockInvalid (line +3577)
    • b9:
    • BlockInvalid (line 143)
    • b10:
    • BlockInvalid (line 143)
    • b11:
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v5 (?) = Const64 <uintptr> [0]
      • v15 (?) = ConstBool <bool> [true]
      • v16 (?) = Const64 <uintptr> [1000000000]
      • v17 (?) = Addr <*uintptr> {"".maxstacksize} v3
      • v20 (?) = Addr <*bool> {"".mainStarted} v3
      • v23 (?) = Addr <*func()> {"".main.func1·f} v3
      • v24 (?) = OffPtr <*func()> [0] v2
      • v36 (?) = Const32 <uint32> [1]
      • v44 (?) = ConstBool <bool> [false]
      • v72 (?) = Addr <*m> {"".m0} v3
      • v75 (?) = OffPtr <*string> [0] v2
      • v82 (?) = OffPtr <*int64> [0] v2
      • v84 (?) = Const64 <int64> [0]
      • v94 (?) = Addr <*func(*bool)> {"".main.func2·f} v3
      • v96 (?) = OffPtr <**bool> [16] v2
      • v98 (?) = Const32 <uint32> [8]
      • v99 (?) = OffPtr <*uint32> [0] v2
      • v101 (?) = OffPtr <*uintptr> [8] v2
      • v109 (?) = Addr <*int64> {"".runtimeInitTime} v3
      • v112 (?) = Addr <*uint8> {type.chan bool} v3
      • v113 (?) = OffPtr <**byte> [0] v2
      • v115 (?) = Const64 <int> [0] (c[int])
      • v116 (?) = OffPtr <*int> [8] v2
      • v119 (?) = OffPtr <*chan bool> [16] v2
      • v121 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v123 (?) = Addr <*bool> {"".iscgo} v3
      • v125 (?) = Addr <*unsafe.Pointer> {_cgo_thread_start} v3
      • v128 (?) = Const64 <unsafe.Pointer> [0]
      • v134 (?) = Addr <*unsafe.Pointer> {""._cgo_setenv} v3
      • v142 (?) = Addr <*unsafe.Pointer> {""._cgo_unsetenv} v3
      • v150 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v162 (?) = OffPtr <*unsafe.Pointer> [0] v2
      • v164 (?) = OffPtr <*unsafe.Pointer> [8] v2
      • v168 (?) = Addr <*func()> {"".main_init·f} v3 (fn[func()])
      • v174 (?) = OffPtr <*chan bool> [0] v2
      • v181 (?) = Addr <*bool> {"".isarchive} v3
      • v183 (?) = Addr <*bool> {"".islibrary} v3
      • v188 (?) = Addr <*func()> {"".main_main·f} v3 (fn[func()])
      • v192 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v197 (?) = Const32 <uint32> [0]
      • v200 (?) = Const64 <int> [1000]
      • v211 (?) = Const64 <int> [1]
      • v213 (?) = Addr <*uint32> {"".panicking} v3
      • v219 (?) = ConstNil <func(*g, unsafe.Pointer) bool>
      • v220 (?) = OffPtr <*func(*g, unsafe.Pointer) bool> [0] v2
      • v224 (?) = Const8 <waitReason> [8]
      • v225 (?) = OffPtr <*waitReason> [16] v2
      • v227 (?) = Const8 <byte> [16]
      • v228 (?) = OffPtr <*byte> [17] v2
      • v230 (?) = OffPtr <*int> [24] v2
      • v233 (?) = Const32 <int32> [0]
      • v234 (?) = OffPtr <*int32> [0] v2
      • v238 (?) = ConstNil <*int32> (x[*int32])
      • v243 (?) = Addr <*uint8> {go.string."runtime.main not on m0"} v3
      • v239 (?) = Const64 <int> [22]
      • v221 (?) = Addr <*uint8> {go.string."nanotime returning zero"} v3
      • v210 (?) = Const64 <int> [23]
      • v203 (?) = Addr <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v184 (?) = Const64 <int> [25]
      • v189 (?) = Addr <*uint8> {go.string."_cgo_setenv missing"} v3
      • v158 (?) = Const64 <int> [19]
      • v155 (?) = Addr <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v143 (?) = Const64 <int> [21]
      • v139 (?) = Addr <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v135 (?) = Const64 <int> [37]
      • v1 (?) = InitMem <mem>
      • v4 (+111) = GetG <*g> v1 (g[*g])
      • v7 (+115) = OffPtr <**m> [48] v4
      • v8 (115) = Load <*m> v7 v1
      • v10 (115) = OffPtr <**g> [0] v8
      • v11 (115) = Load <*g> v10 v1
      • v13 (115) = OffPtr <*uintptr> [304] v11
      • v14 (115) = Store <mem> {uintptr} v13 v5 v1
      • v19 (+121) = Store <mem> {uintptr} v17 v16 v14
      • v22 (+127) = Store <mem> {bool} v20 v15 v19
      • v26 (+130) = Store <mem> {func()} v24 v23 v22
      • v27 (130) = StaticCall <mem> {"".systemstack} [8] v26
      • v29 (+3614) = GetG <*g> v27
      • v31 (3614) = OffPtr <**m> [48] v29
      • v32 (3614) = Load <*m> v31 v27
      • v34 (3614) = OffPtr <*uint32> [620] v32
      • v35 (3614) = Load <uint32> v34 v27
      • v37 (3614) = Add32 <uint32> v35 v36
      • v43 (3614) = Store <mem> {uint32} v34 v37 v27
      • v46 (+3575) = GetG <*g> v43 (_g_[*g], g[*g])
      • v48 (+3576) = OffPtr <**m> [48] v46
      • v49 (3576) = Load <*m> v48 v43
      • v51 (3576) = OffPtr <*guintptr> [352] v49 (gp[*guintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v55 (205) = Store <mem> {guintptr} v51 v53 v43
      • v58 (+3577) = NilCheck <void> v46 v55
      • v59 (3577) = OffPtr <*muintptr> [216] v46 (mp[*muintptr])
      • v62 (3577) = Load <*m> v48 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v66 (243) = Store <mem> {muintptr} v59 v64 v55
      • v69 (+143) = NilCheck <void> v4 v66
      • v71 (143) = Load <*m> v7 v66
      • v73 (143) = NeqPtr <bool> v71 v72
      • v9 (115) = NilCheck <void> v8 v1
      • v12 (115) = NilCheck <void> v11 v1
      • v33 (3614) = NilCheck <void> v32 v27
      • v50 (3576) = NilCheck <void> v49 v43
      • v54 (205) = NilCheck <void> v51 v43
      • v65 (243) = NilCheck <void> v59 v55
    • If v73b12 b13 (line 143)
    • b12: ← b11
      • v60 (144) = OffPtr <*int> [8] v2
      • v41 (+144) = Store <mem> {*uint8} v75 v243 v66
      • v77 (+144) = Store <mem> {int} v60 v239 v41
      • v78 (144) = StaticCall <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = StaticCall <mem> {runtime.init} v66
      • v81 (+148) = StaticCall <mem> {"".nanotime} [8] v80
      • v83 (148) = Load <int64> v82 v81
      • v85 (148) = Eq64 <bool> v83 v84
    • If v85b14 b15 (line 148)
    • b14: ← b13
      • v145 (149) = OffPtr <*int> [8] v2
      • v153 (+149) = Store <mem> {*uint8} v75 v221 v81
      • v88 (+149) = Store <mem> {int} v145 v210 v153
      • v89 (149) = StaticCall <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b13
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (+153) = LocalAddr <*bool> {needUnlock} v2 v91
      • v93 (+153) = Store <mem> {bool} v92 v15 v91
      • v95 (+154) = LocalAddr <*bool> {needUnlock} v2 v93
      • v97 (+158) = Store <mem> {*bool} v96 v95 v93
      • v100 (+154) = Store <mem> {uint32} v99 v98 v97
      • v102 (154) = Store <mem> {uintptr} v101 v94 v100
      • v103 (154) = StaticCall <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b16:
    • BlockInvalid (line +153)
    • b17: ← b15
      • v107 (+162) = StaticCall <mem> {"".nanotime} [8] v103
      • v108 (162) = Load <int64> v82 v107
      • v110 (162) = Store <mem> {int64} v109 v108 v107
      • v111 (+164) = StaticCall <mem> {"".gcenable} v110
      • v114 (+166) = Store <mem> {*byte} v113 v112 v111
      • v117 (166) = Store <mem> {int} v116 v115 v114
      • v118 (166) = StaticCall <mem> {runtime.makechan} [24] v117
      • v120 (166) = Load <chan bool> v119 v118
      • v122 (166) = Store <mem> {chan bool} v121 v120 v118
      • v124 (+167) = Load <bool> v123 v122
    • If v124b19 b20 (line 167)
    • b18: ← b15
      • v105 (154) = StaticCall <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b17
      • v127 (+168) = Load <unsafe.Pointer> v125 v122
      • v131 (168) = IsNonNil <bool> v127
    • If v131b23 b21 (line 168)
    • b20: ← b17 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = Load <uintptr> v168 v169
      • v171 (189) = ClosureCall <mem> [0] v170 v168 v169
      • v173 (+190) = Load <chan bool> v121 v171
      • v175 (190) = Store <mem> {chan bool} v174 v173 v171
      • v176 (190) = StaticCall <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v178 (192) = LocalAddr <*bool> {needUnlock} v2 v177
      • v179 (+192) = Store <mem> {bool} v178 v44 v177
      • v180 (+193) = StaticCall <mem> {"".unlockOSThread} v179
      • v182 (+195) = Load <bool> v181 v180
    • If v182b31 b33 (line 195)
    • b21: ← b19
      • v137 (169) = OffPtr <*int> [8] v2
      • v129 (+169) = Store <mem> {*uint8} v75 v203 v122
      • v132 (+169) = Store <mem> {int} v137 v184 v129
      • v133 (169) = StaticCall <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b22:
    • BlockInvalid
    • b23: ← b19
      • v136 (+172) = Load <unsafe.Pointer> v134 v122
      • v126 (172) = IsNonNil <bool> v136
    • If v126b26 b25 (line 172)
    • b24: ← b26
      • v152 (+179) = Load <unsafe.Pointer> v150 v122
      • v104 (179) = IsNonNil <bool> v152
    • If v104b30 b29 (line 179)
    • b25: ← b23
      • v47 (173) = OffPtr <*int> [8] v2
      • v38 (+173) = Store <mem> {*uint8} v75 v189 v122
      • v140 (+173) = Store <mem> {int} v47 v158 v38
      • v141 (173) = StaticCall <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v144 (+175) = Load <unsafe.Pointer> v142 v122
      • v106 (175) = IsNonNil <bool> v144
    • If v106b24 b27 (line 175)
    • b27: ← b26
      • v30 (176) = OffPtr <*int> [8] v2
      • v28 (+176) = Store <mem> {*uint8} v75 v155 v122
      • v148 (+176) = Store <mem> {int} v30 v143 v28
      • v149 (176) = StaticCall <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b28:
    • BlockInvalid (line +179)
    • b29: ← b24
      • v21 (180) = OffPtr <*int> [8] v2
      • v151 (+180) = Store <mem> {*uint8} v75 v139 v122
      • v156 (+180) = Store <mem> {int} v21 v135 v151
      • v157 (180) = StaticCall <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = StaticCall <mem> {"".startTemplateThread} v122
      • v161 (+185) = Load <unsafe.Pointer> v150 v159
      • v163 (185) = Store <mem> {unsafe.Pointer} v162 v161 v159
      • v165 (185) = Store <mem> {unsafe.Pointer} v164 v128 v163
      • v166 (185) = StaticCall <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = StaticCall <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b32:
    • BlockInvalid (line +202)
    • b33: ← b20
      • v185 (195) = Load <bool> v183 v180
    • If v185b31 b35 (line 195)
    • b35: ← b33
      • v190 (+201) = Load <uintptr> v188 v180
      • v191 (201) = ClosureCall <mem> [0] v190 v188 v180
      • v194 (+210) = AtomicLoad32 <uint32,mem> v192 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v198 (210) = Neq32 <bool> v197 v196
    • If v198b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = AtomicLoad32 <uint32,mem> v213 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v218 (219) = Neq32 <bool> v217 v197
    • If v218b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v201 (+212) = Less64 <bool> v199 v200
    • If v201b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = AtomicLoad32 <uint32,mem> v192 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v207 (213) = Eq32 <bool> v206 v197
    • If v207b43 b41 (line 213)
    • b41: ← b40
      • v209 (+216) = StaticCall <mem> {"".Gosched} v205
      • v212 (+212) = Add64 <int> v199 v211 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b44:
    • BlockInvalid (line 216)
    • b45:
    • BlockInvalid (line +216)
    • b46: ← b37
      • v222 (+220) = Store <mem> {func(*g, unsafe.Pointer) bool} v220 v219 v216
      • v223 (220) = Store <mem> {unsafe.Pointer} v164 v128 v222
      • v226 (220) = Store <mem> {waitReason} v225 v224 v223
      • v229 (220) = Store <mem> {byte} v228 v227 v226
      • v231 (220) = Store <mem> {int} v230 v211 v229
      • v232 (220) = StaticCall <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = Store <mem> {int32} v234 v233 v235
      • v237 (223) = StaticCall <mem> {"".exit} [8] v236
    • Plainb51 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b49:
    • BlockInvalid (line +226)
    • b50:
    • BlockInvalid (line 226)
    • b51: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
      • v240 (+226) = NilCheck <void> v238 v244
      • v241 (226) = Store <mem> {int32} v238 v233 v244
    • Plainb51 (line +226)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • dse [99804 ns]

    • b1:
    • BlockInvalid (line +120)
    • b2:
    • BlockInvalid (line 121)
    • b3:
    • BlockInvalid (line +129)
    • b4:
    • BlockInvalid (line 130)
    • b5:
    • BlockInvalid (line +3572)
    • b7:
    • BlockInvalid (line +3576)
    • b8:
    • BlockInvalid (line +3577)
    • b9:
    • BlockInvalid (line 143)
    • b10:
    • BlockInvalid (line 143)
    • b11:
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v5 (?) = Const64 <uintptr> [0]
      • v15 (?) = ConstBool <bool> [true]
      • v16 (?) = Const64 <uintptr> [1000000000]
      • v17 (?) = Addr <*uintptr> {"".maxstacksize} v3
      • v20 (?) = Addr <*bool> {"".mainStarted} v3
      • v23 (?) = Addr <*func()> {"".main.func1·f} v3
      • v24 (?) = OffPtr <*func()> [0] v2
      • v36 (?) = Const32 <uint32> [1]
      • v44 (?) = ConstBool <bool> [false]
      • v72 (?) = Addr <*m> {"".m0} v3
      • v75 (?) = OffPtr <*string> [0] v2
      • v82 (?) = OffPtr <*int64> [0] v2
      • v84 (?) = Const64 <int64> [0]
      • v94 (?) = Addr <*func(*bool)> {"".main.func2·f} v3
      • v96 (?) = OffPtr <**bool> [16] v2
      • v98 (?) = Const32 <uint32> [8]
      • v99 (?) = OffPtr <*uint32> [0] v2
      • v101 (?) = OffPtr <*uintptr> [8] v2
      • v109 (?) = Addr <*int64> {"".runtimeInitTime} v3
      • v112 (?) = Addr <*uint8> {type.chan bool} v3
      • v113 (?) = OffPtr <**byte> [0] v2
      • v115 (?) = Const64 <int> [0] (c[int])
      • v116 (?) = OffPtr <*int> [8] v2
      • v119 (?) = OffPtr <*chan bool> [16] v2
      • v121 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v123 (?) = Addr <*bool> {"".iscgo} v3
      • v125 (?) = Addr <*unsafe.Pointer> {_cgo_thread_start} v3
      • v128 (?) = Const64 <unsafe.Pointer> [0]
      • v134 (?) = Addr <*unsafe.Pointer> {""._cgo_setenv} v3
      • v142 (?) = Addr <*unsafe.Pointer> {""._cgo_unsetenv} v3
      • v150 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v162 (?) = OffPtr <*unsafe.Pointer> [0] v2
      • v164 (?) = OffPtr <*unsafe.Pointer> [8] v2
      • v168 (?) = Addr <*func()> {"".main_init·f} v3 (fn[func()])
      • v174 (?) = OffPtr <*chan bool> [0] v2
      • v181 (?) = Addr <*bool> {"".isarchive} v3
      • v183 (?) = Addr <*bool> {"".islibrary} v3
      • v188 (?) = Addr <*func()> {"".main_main·f} v3 (fn[func()])
      • v192 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v197 (?) = Const32 <uint32> [0]
      • v200 (?) = Const64 <int> [1000]
      • v211 (?) = Const64 <int> [1]
      • v213 (?) = Addr <*uint32> {"".panicking} v3
      • v219 (?) = ConstNil <func(*g, unsafe.Pointer) bool>
      • v220 (?) = OffPtr <*func(*g, unsafe.Pointer) bool> [0] v2
      • v224 (?) = Const8 <waitReason> [8]
      • v225 (?) = OffPtr <*waitReason> [16] v2
      • v227 (?) = Const8 <byte> [16]
      • v228 (?) = OffPtr <*byte> [17] v2
      • v230 (?) = OffPtr <*int> [24] v2
      • v233 (?) = Const32 <int32> [0]
      • v234 (?) = OffPtr <*int32> [0] v2
      • v238 (?) = ConstNil <*int32> (x[*int32])
      • v243 (?) = Addr <*uint8> {go.string."runtime.main not on m0"} v3
      • v239 (?) = Const64 <int> [22]
      • v221 (?) = Addr <*uint8> {go.string."nanotime returning zero"} v3
      • v210 (?) = Const64 <int> [23]
      • v203 (?) = Addr <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v184 (?) = Const64 <int> [25]
      • v189 (?) = Addr <*uint8> {go.string."_cgo_setenv missing"} v3
      • v158 (?) = Const64 <int> [19]
      • v155 (?) = Addr <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v143 (?) = Const64 <int> [21]
      • v139 (?) = Addr <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v135 (?) = Const64 <int> [37]
      • v1 (?) = InitMem <mem>
      • v4 (+111) = GetG <*g> v1 (g[*g])
      • v7 (+115) = OffPtr <**m> [48] v4
      • v8 (115) = Load <*m> v7 v1
      • v10 (115) = OffPtr <**g> [0] v8
      • v11 (115) = Load <*g> v10 v1
      • v13 (115) = OffPtr <*uintptr> [304] v11
      • v14 (115) = Store <mem> {uintptr} v13 v5 v1
      • v19 (+121) = Store <mem> {uintptr} v17 v16 v14
      • v22 (+127) = Store <mem> {bool} v20 v15 v19
      • v26 (+130) = Store <mem> {func()} v24 v23 v22
      • v27 (130) = StaticCall <mem> {"".systemstack} [8] v26
      • v29 (+3614) = GetG <*g> v27
      • v31 (3614) = OffPtr <**m> [48] v29
      • v32 (3614) = Load <*m> v31 v27
      • v34 (3614) = OffPtr <*uint32> [620] v32
      • v35 (3614) = Load <uint32> v34 v27
      • v37 (3614) = Add32 <uint32> v35 v36
      • v43 (3614) = Store <mem> {uint32} v34 v37 v27
      • v46 (+3575) = GetG <*g> v43 (_g_[*g], g[*g])
      • v48 (+3576) = OffPtr <**m> [48] v46
      • v49 (3576) = Load <*m> v48 v43
      • v51 (3576) = OffPtr <*guintptr> [352] v49 (gp[*guintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v55 (205) = Store <mem> {guintptr} v51 v53 v43
      • v58 (+3577) = NilCheck <void> v46 v55
      • v59 (3577) = OffPtr <*muintptr> [216] v46 (mp[*muintptr])
      • v62 (3577) = Load <*m> v48 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v66 (243) = Store <mem> {muintptr} v59 v64 v55
      • v69 (+143) = NilCheck <void> v4 v66
      • v71 (143) = Load <*m> v7 v66
      • v73 (143) = NeqPtr <bool> v71 v72
      • v9 (115) = NilCheck <void> v8 v1
      • v12 (115) = NilCheck <void> v11 v1
      • v33 (3614) = NilCheck <void> v32 v27
      • v50 (3576) = NilCheck <void> v49 v43
      • v54 (205) = NilCheck <void> v51 v43
      • v65 (243) = NilCheck <void> v59 v55
    • If v73b12 b13 (line 143)
    • b12: ← b11
      • v60 (144) = OffPtr <*int> [8] v2
      • v41 (+144) = Store <mem> {*uint8} v75 v243 v66
      • v77 (+144) = Store <mem> {int} v60 v239 v41
      • v78 (144) = StaticCall <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = StaticCall <mem> {runtime.init} v66
      • v81 (+148) = StaticCall <mem> {"".nanotime} [8] v80
      • v83 (148) = Load <int64> v82 v81
      • v85 (148) = Eq64 <bool> v83 v84
    • If v85b14 b15 (line 148)
    • b14: ← b13
      • v145 (149) = OffPtr <*int> [8] v2
      • v153 (+149) = Store <mem> {*uint8} v75 v221 v81
      • v88 (+149) = Store <mem> {int} v145 v210 v153
      • v89 (149) = StaticCall <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b13
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (+153) = LocalAddr <*bool> {needUnlock} v2 v91
      • v93 (+153) = Store <mem> {bool} v92 v15 v91
      • v95 (+154) = LocalAddr <*bool> {needUnlock} v2 v93
      • v97 (+158) = Store <mem> {*bool} v96 v95 v93
      • v100 (+154) = Store <mem> {uint32} v99 v98 v97
      • v102 (154) = Store <mem> {uintptr} v101 v94 v100
      • v103 (154) = StaticCall <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b16:
    • BlockInvalid (line +153)
    • b17: ← b15
      • v107 (+162) = StaticCall <mem> {"".nanotime} [8] v103
      • v108 (162) = Load <int64> v82 v107
      • v110 (162) = Store <mem> {int64} v109 v108 v107
      • v111 (+164) = StaticCall <mem> {"".gcenable} v110
      • v114 (+166) = Store <mem> {*byte} v113 v112 v111
      • v117 (166) = Store <mem> {int} v116 v115 v114
      • v118 (166) = StaticCall <mem> {runtime.makechan} [24] v117
      • v120 (166) = Load <chan bool> v119 v118
      • v122 (166) = Store <mem> {chan bool} v121 v120 v118
      • v124 (+167) = Load <bool> v123 v122
    • If v124b19 b20 (line 167)
    • b18: ← b15
      • v105 (154) = StaticCall <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b17
      • v127 (+168) = Load <unsafe.Pointer> v125 v122
      • v131 (168) = IsNonNil <bool> v127
    • If v131b23 b21 (line 168)
    • b20: ← b17 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = Load <uintptr> v168 v169
      • v171 (189) = ClosureCall <mem> [0] v170 v168 v169
      • v173 (+190) = Load <chan bool> v121 v171
      • v175 (190) = Store <mem> {chan bool} v174 v173 v171
      • v176 (190) = StaticCall <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v178 (192) = LocalAddr <*bool> {needUnlock} v2 v177
      • v179 (+192) = Store <mem> {bool} v178 v44 v177
      • v180 (+193) = StaticCall <mem> {"".unlockOSThread} v179
      • v182 (+195) = Load <bool> v181 v180
    • If v182b31 b33 (line 195)
    • b21: ← b19
      • v137 (169) = OffPtr <*int> [8] v2
      • v129 (+169) = Store <mem> {*uint8} v75 v203 v122
      • v132 (+169) = Store <mem> {int} v137 v184 v129
      • v133 (169) = StaticCall <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b22:
    • BlockInvalid
    • b23: ← b19
      • v136 (+172) = Load <unsafe.Pointer> v134 v122
      • v126 (172) = IsNonNil <bool> v136
    • If v126b26 b25 (line 172)
    • b24: ← b26
      • v152 (+179) = Load <unsafe.Pointer> v150 v122
      • v104 (179) = IsNonNil <bool> v152
    • If v104b30 b29 (line 179)
    • b25: ← b23
      • v47 (173) = OffPtr <*int> [8] v2
      • v38 (+173) = Store <mem> {*uint8} v75 v189 v122
      • v140 (+173) = Store <mem> {int} v47 v158 v38
      • v141 (173) = StaticCall <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v144 (+175) = Load <unsafe.Pointer> v142 v122
      • v106 (175) = IsNonNil <bool> v144
    • If v106b24 b27 (line 175)
    • b27: ← b26
      • v30 (176) = OffPtr <*int> [8] v2
      • v28 (+176) = Store <mem> {*uint8} v75 v155 v122
      • v148 (+176) = Store <mem> {int} v30 v143 v28
      • v149 (176) = StaticCall <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b28:
    • BlockInvalid (line +179)
    • b29: ← b24
      • v21 (180) = OffPtr <*int> [8] v2
      • v151 (+180) = Store <mem> {*uint8} v75 v139 v122
      • v156 (+180) = Store <mem> {int} v21 v135 v151
      • v157 (180) = StaticCall <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = StaticCall <mem> {"".startTemplateThread} v122
      • v161 (+185) = Load <unsafe.Pointer> v150 v159
      • v163 (185) = Store <mem> {unsafe.Pointer} v162 v161 v159
      • v165 (185) = Store <mem> {unsafe.Pointer} v164 v128 v163
      • v166 (185) = StaticCall <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = StaticCall <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b32:
    • BlockInvalid (line +202)
    • b33: ← b20
      • v185 (195) = Load <bool> v183 v180
    • If v185b31 b35 (line 195)
    • b35: ← b33
      • v190 (+201) = Load <uintptr> v188 v180
      • v191 (201) = ClosureCall <mem> [0] v190 v188 v180
      • v194 (+210) = AtomicLoad32 <uint32,mem> v192 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v198 (210) = Neq32 <bool> v197 v196
    • If v198b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = AtomicLoad32 <uint32,mem> v213 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v218 (219) = Neq32 <bool> v217 v197
    • If v218b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v201 (+212) = Less64 <bool> v199 v200
    • If v201b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = AtomicLoad32 <uint32,mem> v192 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v207 (213) = Eq32 <bool> v206 v197
    • If v207b43 b41 (line 213)
    • b41: ← b40
      • v209 (+216) = StaticCall <mem> {"".Gosched} v205
      • v212 (+212) = Add64 <int> v199 v211 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b44:
    • BlockInvalid (line 216)
    • b45:
    • BlockInvalid (line +216)
    • b46: ← b37
      • v222 (+220) = Store <mem> {func(*g, unsafe.Pointer) bool} v220 v219 v216
      • v223 (220) = Store <mem> {unsafe.Pointer} v164 v128 v222
      • v226 (220) = Store <mem> {waitReason} v225 v224 v223
      • v229 (220) = Store <mem> {byte} v228 v227 v226
      • v231 (220) = Store <mem> {int} v230 v211 v229
      • v232 (220) = StaticCall <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = Store <mem> {int32} v234 v233 v235
      • v237 (223) = StaticCall <mem> {"".exit} [8] v236
    • Plainb51 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b49:
    • BlockInvalid (line +226)
    • b50:
    • BlockInvalid (line 226)
    • b51: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
      • v240 (+226) = NilCheck <void> v238 v244
      • v241 (226) = Store <mem> {int32} v238 v233 v244
    • Plainb51 (line +226)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • writebarrier [50785 ns]

    • b1:
    • BlockInvalid (line +120)
    • b2:
    • BlockInvalid (line 121)
    • b3:
    • BlockInvalid (line +129)
    • b4:
    • BlockInvalid (line 130)
    • b5:
    • BlockInvalid (line +3572)
    • b7:
    • BlockInvalid (line +3576)
    • b8:
    • BlockInvalid (line +3577)
    • b9:
    • BlockInvalid (line 143)
    • b10:
    • BlockInvalid (line 143)
    • b11:
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v5 (?) = Const64 <uintptr> [0]
      • v15 (?) = ConstBool <bool> [true]
      • v16 (?) = Const64 <uintptr> [1000000000]
      • v17 (?) = Addr <*uintptr> {"".maxstacksize} v3
      • v20 (?) = Addr <*bool> {"".mainStarted} v3
      • v23 (?) = Addr <*func()> {"".main.func1·f} v3
      • v24 (?) = OffPtr <*func()> [0] v2
      • v36 (?) = Const32 <uint32> [1]
      • v44 (?) = ConstBool <bool> [false]
      • v72 (?) = Addr <*m> {"".m0} v3
      • v75 (?) = OffPtr <*string> [0] v2
      • v82 (?) = OffPtr <*int64> [0] v2
      • v84 (?) = Const64 <int64> [0]
      • v94 (?) = Addr <*func(*bool)> {"".main.func2·f} v3
      • v96 (?) = OffPtr <**bool> [16] v2
      • v98 (?) = Const32 <uint32> [8]
      • v99 (?) = OffPtr <*uint32> [0] v2
      • v101 (?) = OffPtr <*uintptr> [8] v2
      • v109 (?) = Addr <*int64> {"".runtimeInitTime} v3
      • v112 (?) = Addr <*uint8> {type.chan bool} v3
      • v113 (?) = OffPtr <**byte> [0] v2
      • v115 (?) = Const64 <int> [0] (c[int])
      • v116 (?) = OffPtr <*int> [8] v2
      • v119 (?) = OffPtr <*chan bool> [16] v2
      • v121 (?) = Addr <*chan bool> {"".main_init_done} v3
      • v123 (?) = Addr <*bool> {"".iscgo} v3
      • v125 (?) = Addr <*unsafe.Pointer> {_cgo_thread_start} v3
      • v128 (?) = Const64 <unsafe.Pointer> [0]
      • v134 (?) = Addr <*unsafe.Pointer> {""._cgo_setenv} v3
      • v142 (?) = Addr <*unsafe.Pointer> {""._cgo_unsetenv} v3
      • v150 (?) = Addr <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v162 (?) = OffPtr <*unsafe.Pointer> [0] v2
      • v164 (?) = OffPtr <*unsafe.Pointer> [8] v2
      • v168 (?) = Addr <*func()> {"".main_init·f} v3 (fn[func()])
      • v174 (?) = OffPtr <*chan bool> [0] v2
      • v181 (?) = Addr <*bool> {"".isarchive} v3
      • v183 (?) = Addr <*bool> {"".islibrary} v3
      • v188 (?) = Addr <*func()> {"".main_main·f} v3 (fn[func()])
      • v192 (?) = Addr <*uint32> {"".runningPanicDefers} v3
      • v197 (?) = Const32 <uint32> [0]
      • v200 (?) = Const64 <int> [1000]
      • v211 (?) = Const64 <int> [1]
      • v213 (?) = Addr <*uint32> {"".panicking} v3
      • v219 (?) = ConstNil <func(*g, unsafe.Pointer) bool>
      • v220 (?) = OffPtr <*func(*g, unsafe.Pointer) bool> [0] v2
      • v224 (?) = Const8 <waitReason> [8]
      • v225 (?) = OffPtr <*waitReason> [16] v2
      • v227 (?) = Const8 <byte> [16]
      • v228 (?) = OffPtr <*byte> [17] v2
      • v230 (?) = OffPtr <*int> [24] v2
      • v233 (?) = Const32 <int32> [0]
      • v234 (?) = OffPtr <*int32> [0] v2
      • v238 (?) = ConstNil <*int32> (x[*int32])
      • v243 (?) = Addr <*uint8> {go.string."runtime.main not on m0"} v3
      • v239 (?) = Const64 <int> [22]
      • v221 (?) = Addr <*uint8> {go.string."nanotime returning zero"} v3
      • v210 (?) = Const64 <int> [23]
      • v203 (?) = Addr <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v184 (?) = Const64 <int> [25]
      • v189 (?) = Addr <*uint8> {go.string."_cgo_setenv missing"} v3
      • v158 (?) = Const64 <int> [19]
      • v155 (?) = Addr <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v143 (?) = Const64 <int> [21]
      • v139 (?) = Addr <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v135 (?) = Const64 <int> [37]
      • v1 (?) = InitMem <mem>
      • v4 (+111) = GetG <*g> v1 (g[*g])
      • v7 (+115) = OffPtr <**m> [48] v4
      • v8 (115) = Load <*m> v7 v1
      • v10 (115) = OffPtr <**g> [0] v8
      • v11 (115) = Load <*g> v10 v1
      • v13 (115) = OffPtr <*uintptr> [304] v11
      • v14 (115) = Store <mem> {uintptr} v13 v5 v1
      • v19 (+121) = Store <mem> {uintptr} v17 v16 v14
      • v22 (+127) = Store <mem> {bool} v20 v15 v19
      • v26 (+130) = Store <mem> {func()} v24 v23 v22
      • v27 (130) = StaticCall <mem> {"".systemstack} [8] v26
      • v29 (+3614) = GetG <*g> v27
      • v31 (3614) = OffPtr <**m> [48] v29
      • v32 (3614) = Load <*m> v31 v27
      • v34 (3614) = OffPtr <*uint32> [620] v32
      • v35 (3614) = Load <uint32> v34 v27
      • v37 (3614) = Add32 <uint32> v35 v36
      • v43 (3614) = Store <mem> {uint32} v34 v37 v27
      • v46 (+3575) = GetG <*g> v43 (_g_[*g], g[*g])
      • v48 (+3576) = OffPtr <**m> [48] v46
      • v49 (3576) = Load <*m> v48 v43
      • v51 (3576) = OffPtr <*guintptr> [352] v49 (gp[*guintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v55 (205) = Store <mem> {guintptr} v51 v53 v43
      • v58 (+3577) = NilCheck <void> v46 v55
      • v59 (3577) = OffPtr <*muintptr> [216] v46 (mp[*muintptr])
      • v62 (3577) = Load <*m> v48 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v66 (243) = Store <mem> {muintptr} v59 v64 v55
      • v69 (+143) = NilCheck <void> v4 v66
      • v71 (143) = Load <*m> v7 v66
      • v73 (143) = NeqPtr <bool> v71 v72
      • v70 (143) = Addr <*uint32> {runtime.writeBarrier} v3
      • v9 (115) = NilCheck <void> v8 v1
      • v12 (115) = NilCheck <void> v11 v1
      • v33 (3614) = NilCheck <void> v32 v27
      • v50 (3576) = NilCheck <void> v49 v43
      • v54 (205) = NilCheck <void> v51 v43
      • v65 (243) = NilCheck <void> v59 v55
    • If v73b12 b13 (line 143)
    • b12: ← b11
      • v60 (144) = OffPtr <*int> [8] v2
      • v41 (+144) = Store <mem> {*uint8} v75 v243 v66
      • v77 (+144) = Store <mem> {int} v60 v239 v41
      • v78 (144) = StaticCall <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = StaticCall <mem> {runtime.init} v66
      • v81 (+148) = StaticCall <mem> {"".nanotime} [8] v80
      • v83 (148) = Load <int64> v82 v81
      • v85 (148) = Eq64 <bool> v83 v84
    • If v85b14 b15 (line 148)
    • b14: ← b13
      • v145 (149) = OffPtr <*int> [8] v2
      • v153 (+149) = Store <mem> {*uint8} v75 v221 v81
      • v88 (+149) = Store <mem> {int} v145 v210 v153
      • v89 (149) = StaticCall <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b13
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (+153) = LocalAddr <*bool> {needUnlock} v2 v91
      • v93 (+153) = Store <mem> {bool} v92 v15 v91
      • v95 (+154) = LocalAddr <*bool> {needUnlock} v2 v93
      • v97 (+158) = Store <mem> {*bool} v96 v95 v93
      • v100 (+154) = Store <mem> {uint32} v99 v98 v97
      • v102 (154) = Store <mem> {uintptr} v101 v94 v100
      • v103 (154) = StaticCall <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b16:
    • BlockInvalid (line +153)
    • b17: ← b15
      • v107 (+162) = StaticCall <mem> {"".nanotime} [8] v103
      • v108 (162) = Load <int64> v82 v107
      • v110 (162) = Store <mem> {int64} v109 v108 v107
      • v111 (+164) = StaticCall <mem> {"".gcenable} v110
      • v114 (+166) = Store <mem> {*byte} v113 v112 v111
      • v117 (166) = Store <mem> {int} v116 v115 v114
      • v118 (166) = StaticCall <mem> {runtime.makechan} [24] v117
      • v120 (166) = Load <chan bool> v119 v118
      • v61 (166) = Load <uint32> v70 v118
      • v42 (166) = Neq32 <bool> v61 v197
    • If v42b34 b6 (unlikely) (line 166)
    • b18: ← b15
      • v105 (154) = StaticCall <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b52
      • v127 (+168) = Load <unsafe.Pointer> v125 v122
      • v131 (168) = IsNonNil <bool> v127
    • If v131b23 b21 (line 168)
    • b20: ← b52 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = Load <uintptr> v168 v169
      • v171 (189) = ClosureCall <mem> [0] v170 v168 v169
      • v173 (+190) = Load <chan bool> v121 v171
      • v175 (190) = Store <mem> {chan bool} v174 v173 v171
      • v176 (190) = StaticCall <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v178 (192) = LocalAddr <*bool> {needUnlock} v2 v177
      • v179 (+192) = Store <mem> {bool} v178 v44 v177
      • v180 (+193) = StaticCall <mem> {"".unlockOSThread} v179
      • v182 (+195) = Load <bool> v181 v180
    • If v182b31 b33 (line 195)
    • b21: ← b19
      • v137 (169) = OffPtr <*int> [8] v2
      • v129 (+169) = Store <mem> {*uint8} v75 v203 v122
      • v132 (+169) = Store <mem> {int} v137 v184 v129
      • v133 (169) = StaticCall <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b22:
    • BlockInvalid
    • b23: ← b19
      • v136 (+172) = Load <unsafe.Pointer> v134 v122
      • v126 (172) = IsNonNil <bool> v136
    • If v126b26 b25 (line 172)
    • b24: ← b26
      • v152 (+179) = Load <unsafe.Pointer> v150 v122
      • v104 (179) = IsNonNil <bool> v152
    • If v104b30 b29 (line 179)
    • b25: ← b23
      • v47 (173) = OffPtr <*int> [8] v2
      • v38 (+173) = Store <mem> {*uint8} v75 v189 v122
      • v140 (+173) = Store <mem> {int} v47 v158 v38
      • v141 (173) = StaticCall <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v144 (+175) = Load <unsafe.Pointer> v142 v122
      • v106 (175) = IsNonNil <bool> v144
    • If v106b24 b27 (line 175)
    • b27: ← b26
      • v30 (176) = OffPtr <*int> [8] v2
      • v28 (+176) = Store <mem> {*uint8} v75 v155 v122
      • v148 (+176) = Store <mem> {int} v30 v143 v28
      • v149 (176) = StaticCall <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b28:
    • BlockInvalid (line +179)
    • b29: ← b24
      • v21 (180) = OffPtr <*int> [8] v2
      • v151 (+180) = Store <mem> {*uint8} v75 v139 v122
      • v156 (+180) = Store <mem> {int} v21 v135 v151
      • v157 (180) = StaticCall <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = StaticCall <mem> {"".startTemplateThread} v122
      • v161 (+185) = Load <unsafe.Pointer> v150 v159
      • v163 (185) = Store <mem> {unsafe.Pointer} v162 v161 v159
      • v165 (185) = Store <mem> {unsafe.Pointer} v164 v128 v163
      • v166 (185) = StaticCall <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = StaticCall <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b32:
    • BlockInvalid (line +202)
    • b33: ← b20
      • v185 (195) = Load <bool> v183 v180
    • If v185b31 b35 (line 195)
    • b35: ← b33
      • v190 (+201) = Load <uintptr> v188 v180
      • v191 (201) = ClosureCall <mem> [0] v190 v188 v180
      • v194 (+210) = AtomicLoad32 <uint32,mem> v192 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v198 (210) = Neq32 <bool> v197 v196
    • If v198b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = AtomicLoad32 <uint32,mem> v213 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v218 (219) = Neq32 <bool> v217 v197
    • If v218b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v201 (+212) = Less64 <bool> v199 v200
    • If v201b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = AtomicLoad32 <uint32,mem> v192 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v207 (213) = Eq32 <bool> v206 v197
    • If v207b43 b41 (line 213)
    • b41: ← b40
      • v209 (+216) = StaticCall <mem> {"".Gosched} v205
      • v212 (+212) = Add64 <int> v199 v211 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b44:
    • BlockInvalid (line 216)
    • b45:
    • BlockInvalid (line +216)
    • b46: ← b37
      • v222 (+220) = Store <mem> {func(*g, unsafe.Pointer) bool} v220 v219 v216
      • v223 (220) = Store <mem> {unsafe.Pointer} v164 v128 v222
      • v226 (220) = Store <mem> {waitReason} v225 v224 v223
      • v229 (220) = Store <mem> {byte} v228 v227 v226
      • v231 (220) = Store <mem> {int} v230 v211 v229
      • v232 (220) = StaticCall <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = Store <mem> {int32} v234 v233 v235
      • v237 (223) = StaticCall <mem> {"".exit} [8] v236
    • Plainb51 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b49:
    • BlockInvalid (line +226)
    • b50:
    • BlockInvalid (line 226)
    • b51: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
      • v240 (+226) = NilCheck <void> v238 v244
      • v241 (226) = Store <mem> {int32} v238 v233 v244
    • Plainb51 (line +226)
    • b34: ← b17
      • v40 (166) = WB <mem> {runtime.gcWriteBarrier} v121 v120 v118
    • Plainb52 (line 166)
    • b6: ← b17
      • v39 (166) = Store <mem> {chan bool} v121 v120 v118
    • Plainb52 (line 166)
    • b52: ← b34 b6
      • v122 (166) = Phi <mem> v40 v39
      • v124 (+167) = Load <bool> v123 v122
    • If v124b19 b20 (line 167)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • lower [670505 ns]

    • b1:
    • BlockInvalid (line +120)
    • b2:
    • BlockInvalid (line 121)
    • b3:
    • BlockInvalid (line +129)
    • b4:
    • BlockInvalid (line 130)
    • b5:
    • BlockInvalid (line +3572)
    • b7:
    • BlockInvalid (line +3576)
    • b8:
    • BlockInvalid (line +3577)
    • b9:
    • BlockInvalid (line 143)
    • b10:
    • BlockInvalid (line 143)
    • b11:
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v5 (?) = MOVQconst <uintptr> [0]
      • v15 (?) = MOVLconst <bool> [1]
      • v16 (?) = MOVQconst <uintptr> [1000000000]
      • v17 (?) = LEAQ <*uintptr> {"".maxstacksize} v3
      • v20 (?) = LEAQ <*bool> {"".mainStarted} v3
      • v23 (?) = LEAQ <*func()> {"".main.func1·f} v3
      • v36 (?) = MOVLconst <uint32> [1]
      • v44 (?) = MOVLconst <bool> [0]
      • v72 (?) = LEAQ <*m> {"".m0} v3
      • v84 (?) = MOVQconst <int64> [0]
      • v94 (?) = LEAQ <*func(*bool)> {"".main.func2·f} v3
      • v96 (?) = LEAQ <**bool> [16] v2
      • v98 (?) = MOVLconst <uint32> [8]
      • v101 (?) = LEAQ <*uintptr> [8] v2
      • v109 (?) = LEAQ <*int64> {"".runtimeInitTime} v3
      • v112 (?) = LEAQ <*uint8> {type.chan bool} v3
      • v115 (?) = MOVQconst <int> [0] (c[int])
      • v116 (?) = LEAQ <*int> [8] v2
      • v119 (?) = LEAQ <*chan bool> [16] v2
      • v121 (?) = LEAQ <*chan bool> {"".main_init_done} v3
      • v123 (?) = LEAQ <*bool> {"".iscgo} v3
      • v125 (?) = LEAQ <*unsafe.Pointer> {_cgo_thread_start} v3
      • v128 (?) = MOVQconst <unsafe.Pointer> [0]
      • v134 (?) = LEAQ <*unsafe.Pointer> {""._cgo_setenv} v3
      • v142 (?) = LEAQ <*unsafe.Pointer> {""._cgo_unsetenv} v3
      • v150 (?) = LEAQ <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v164 (?) = LEAQ <*unsafe.Pointer> [8] v2
      • v168 (?) = LEAQ <*func()> {"".main_init·f} v3 (fn[func()])
      • v181 (?) = LEAQ <*bool> {"".isarchive} v3
      • v183 (?) = LEAQ <*bool> {"".islibrary} v3
      • v188 (?) = LEAQ <*func()> {"".main_main·f} v3 (fn[func()])
      • v192 (?) = LEAQ <*uint32> {"".runningPanicDefers} v3
      • v197 (?) = MOVLconst <uint32> [0]
      • v200 (?) = MOVQconst <int> [1000]
      • v211 (?) = MOVQconst <int> [1]
      • v213 (?) = LEAQ <*uint32> {"".panicking} v3
      • v219 (?) = MOVQconst <func(*g, unsafe.Pointer) bool> [0]
      • v224 (?) = MOVLconst <waitReason> [8]
      • v225 (?) = LEAQ <*waitReason> [16] v2
      • v227 (?) = MOVLconst <byte> [16]
      • v228 (?) = LEAQ <*byte> [17] v2
      • v230 (?) = LEAQ <*int> [24] v2
      • v233 (?) = MOVLconst <int32> [0]
      • v238 (?) = MOVQconst <*int32> [0] (x[*int32])
      • v243 (?) = LEAQ <*uint8> {go.string."runtime.main not on m0"} v3
      • v239 (?) = MOVQconst <int> [22]
      • v221 (?) = LEAQ <*uint8> {go.string."nanotime returning zero"} v3
      • v210 (?) = MOVQconst <int> [23]
      • v203 (?) = LEAQ <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v184 (?) = MOVQconst <int> [25]
      • v189 (?) = LEAQ <*uint8> {go.string."_cgo_setenv missing"} v3
      • v158 (?) = MOVQconst <int> [19]
      • v155 (?) = LEAQ <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v143 (?) = MOVQconst <int> [21]
      • v139 (?) = LEAQ <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v135 (?) = MOVQconst <int> [37]
      • v1 (?) = InitMem <mem>
      • v4 (+111) = LoweredGetG <*g> v1 (g[*g])
      • v7 (+115) = ADDQconst <**m> [48] v4
      • v8 (115) = MOVQload <*m> [48] v4 v1
      • v11 (115) = MOVQload <*g> v8 v1
      • v13 (115) = ADDQconst <*uintptr> [304] v11
      • v14 (115) = MOVQstoreconst <mem> [val=0,off=304] v11 v1
      • v19 (+121) = MOVQstoreconst <mem> {"".maxstacksize} [val=1000000000,off=0] v3 v14
      • v22 (+127) = MOVBstoreconst <mem> {"".mainStarted} [val=1,off=0] v3 v19
      • v26 (+130) = MOVQstore <mem> v2 v23 v22
      • v27 (130) = CALLstatic <mem> {"".systemstack} [8] v26
      • v29 (+3614) = LoweredGetG <*g> v27
      • v31 (3614) = ADDQconst <**m> [48] v29
      • v32 (3614) = MOVQload <*m> [48] v29 v27
      • v34 (3614) = ADDQconst <*uint32> [620] v32
      • v35 (3614) = MOVLload <uint32> [620] v32 v27
      • v37 (3614) = ADDLconst <uint32> [1] v35
      • v43 (3614) = ADDLconstmodify <mem> [val=1,off=620] v32 v27
      • v46 (+3575) = LoweredGetG <*g> v43 (g[*g], _g_[*g])
      • v48 (+3576) = ADDQconst <**m> [48] v46
      • v49 (3576) = MOVQload <*m> [48] v46 v43
      • v51 (3576) = ADDQconst <*guintptr> [352] v49 (gp[*guintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v55 (205) = MOVQstore <mem> [352] v49 v53 v43
      • v58 (+3577) = LoweredNilCheck <void> v46 v55
      • v59 (3577) = ADDQconst <*muintptr> [216] v46 (mp[*muintptr])
      • v62 (3577) = MOVQload <*m> [48] v46 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v66 (243) = MOVQstore <mem> [216] v46 v64 v55
      • v69 (+143) = LoweredNilCheck <void> v4 v66
      • v70 (143) = LEAQ <*uint32> {runtime.writeBarrier} v3
      • v172 (143) = CMPQload <flags> [48] v4 v72 v66
      • v9 (115) = LoweredNilCheck <void> v8 v1
      • v12 (115) = LoweredNilCheck <void> v11 v1
      • v33 (3614) = LoweredNilCheck <void> v32 v27
      • v50 (3576) = LoweredNilCheck <void> v49 v43
      • v54 (205) = LoweredNilCheck <void> v51 v43
      • v65 (243) = LoweredNilCheck <void> v59 v55
      • v73 (143) = SETNE <bool> v172
      • v202 (143) = TESTB <flags> v73 v73
    • NE v172b12 b13 (line 143)
    • b12: ← b11
      • v60 (144) = LEAQ <*int> [8] v2
      • v41 (+144) = MOVQstore <mem> v2 v243 v66
      • v77 (+144) = MOVQstoreconst <mem> [val=22,off=8] v2 v41
      • v78 (144) = CALLstatic <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = CALLstatic <mem> {runtime.init} v66
      • v81 (+148) = CALLstatic <mem> {"".nanotime} [8] v80
      • v251 (148) = CMPQconstload <flags> [val=0,off=0] v2 v81
      • v85 (148) = SETEQ <bool> v251
      • v160 (148) = TESTB <flags> v85 v85
    • EQ v251b14 b15 (line 148)
    • b14: ← b13
      • v145 (149) = LEAQ <*int> [8] v2
      • v153 (+149) = MOVQstore <mem> v2 v221 v81
      • v88 (+149) = MOVQstoreconst <mem> [val=23,off=8] v2 v153
      • v89 (149) = CALLstatic <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b13
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (+153) = LEAQ <*bool> {needUnlock} v2
      • v93 (+153) = MOVBstoreconst <mem> {needUnlock} [val=1,off=0] v2 v91
      • v95 (+154) = LEAQ <*bool> {needUnlock} v2
      • v97 (+158) = MOVQstore <mem> [16] v2 v95 v93
      • v100 (+154) = MOVLstoreconst <mem> [val=8,off=0] v2 v97
      • v102 (154) = MOVQstore <mem> [8] v2 v94 v100
      • v103 (154) = CALLstatic <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b16:
    • BlockInvalid (line +153)
    • b17: ← b15
      • v107 (+162) = CALLstatic <mem> {"".nanotime} [8] v103
      • v108 (162) = MOVQload <int64> v2 v107
      • v110 (162) = MOVQstore <mem> {"".runtimeInitTime} v3 v108 v107
      • v111 (+164) = CALLstatic <mem> {"".gcenable} v110
      • v114 (+166) = MOVQstore <mem> v2 v112 v111
      • v117 (166) = MOVQstoreconst <mem> [val=0,off=8] v2 v114
      • v118 (166) = CALLstatic <mem> {runtime.makechan} [24] v117
      • v120 (166) = MOVQload <chan bool> [16] v2 v118
      • v252 (166) = CMPLconstload <flags> {runtime.writeBarrier} [val=0,off=0] v3 v118
      • v42 (166) = SETNE <bool> v252
      • v146 (166) = TESTB <flags> v42 v42
    • NE v252b34 b6 (unlikely) (line 166)
    • b18: ← b15
      • v105 (154) = CALLstatic <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b52
      • v25 (168) = CMPQconstload <flags> {_cgo_thread_start} [val=0,off=0] v3 v122
      • v131 (+168) = SETNE <bool> v25
      • v130 (168) = TESTB <flags> v131 v131
    • NE v25b23 b21 (line 168)
    • b20: ← b52 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = MOVQload <uintptr> {"".main_init·f} v3 v169
      • v171 (189) = CALLclosure <mem> [0] v170 v168 v169
      • v173 (+190) = MOVQload <chan bool> {"".main_init_done} v3 v171
      • v175 (190) = MOVQstore <mem> v2 v173 v171
      • v176 (190) = CALLstatic <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v178 (192) = LEAQ <*bool> {needUnlock} v2
      • v179 (+192) = MOVBstoreconst <mem> {needUnlock} [val=0,off=0] v2 v177
      • v180 (+193) = CALLstatic <mem> {"".unlockOSThread} v179
      • v147 (+195) = CMPBconstload <flags> [val=0,off=0] v181 v180
      • v74 (+195) = Copy <flags> v147
    • NE v147b31 b33 (line 195)
    • b21: ← b19
      • v137 (169) = LEAQ <*int> [8] v2
      • v129 (+169) = MOVQstore <mem> v2 v203 v122
      • v132 (+169) = MOVQstoreconst <mem> [val=25,off=8] v2 v129
      • v133 (169) = CALLstatic <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b22:
    • BlockInvalid
    • b23: ← b19
      • v249 (172) = CMPQconstload <flags> {""._cgo_setenv} [val=0,off=0] v3 v122
      • v126 (+172) = SETNE <bool> v249
      • v186 (172) = TESTB <flags> v126 v126
    • NE v249b26 b25 (line 172)
    • b24: ← b26
      • v18 (179) = CMPQconstload <flags> {_cgo_notify_runtime_init_done} [val=0,off=0] v3 v122
      • v104 (+179) = SETNE <bool> v18
      • v208 (179) = TESTB <flags> v104 v104
    • NE v18b30 b29 (line 179)
    • b25: ← b23
      • v47 (173) = LEAQ <*int> [8] v2
      • v38 (+173) = MOVQstore <mem> v2 v189 v122
      • v140 (+173) = MOVQstoreconst <mem> [val=19,off=8] v2 v38
      • v141 (173) = CALLstatic <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v167 (175) = CMPQconstload <flags> {""._cgo_unsetenv} [val=0,off=0] v3 v122
      • v106 (+175) = SETNE <bool> v167
      • v6 (175) = TESTB <flags> v106 v106
    • NE v167b24 b27 (line 175)
    • b27: ← b26
      • v30 (176) = LEAQ <*int> [8] v2
      • v28 (+176) = MOVQstore <mem> v2 v155 v122
      • v148 (+176) = MOVQstoreconst <mem> [val=21,off=8] v2 v28
      • v149 (176) = CALLstatic <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b28:
    • BlockInvalid (line +179)
    • b29: ← b24
      • v21 (180) = LEAQ <*int> [8] v2
      • v151 (+180) = MOVQstore <mem> v2 v139 v122
      • v156 (+180) = MOVQstoreconst <mem> [val=37,off=8] v2 v151
      • v157 (180) = CALLstatic <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = CALLstatic <mem> {"".startTemplateThread} v122
      • v161 (+185) = MOVQload <unsafe.Pointer> {_cgo_notify_runtime_init_done} v3 v159
      • v163 (185) = MOVQstore <mem> v2 v161 v159
      • v165 (185) = MOVQstoreconst <mem> [val=0,off=8] v2 v163
      • v166 (185) = CALLstatic <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = CALLstatic <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b32:
    • BlockInvalid (line +202)
    • b33: ← b20
      • v79 (195) = CMPBconstload <flags> [val=0,off=0] v183 v180
      • v87 (195) = Copy <flags> v79
    • NE v79b31 b35 (line 195)
    • b35: ← b33
      • v190 (+201) = MOVQload <uintptr> {"".main_main·f} v3 v180
      • v191 (201) = CALLclosure <mem> [0] v190 v188 v180
      • v194 (+210) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v250 (210) = TESTL <flags> v196 v196
      • v198 (210) = SETNE <bool> v250
      • v76 (210) = TESTB <flags> v198 v198
      • v68 (210) = InvertFlags <flags> v250
    • NE v250b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = MOVLatomicload <uint32,mem> {"".panicking} v3 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v63 (219) = TESTL <flags> v217 v217
      • v218 (219) = SETNE <bool> v63
      • v67 (219) = TESTB <flags> v218 v218
    • NE v63b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v56 (+212) = CMPQconst <flags> [1000] v199
      • v201 (+212) = SETL <bool> v56
      • v57 (+212) = TESTB <flags> v201 v201
    • LT v56b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v52 (213) = TESTL <flags> v206 v206
      • v207 (213) = SETEQ <bool> v52
      • v247 (213) = TESTB <flags> v207 v207
    • EQ v52b43 b41 (line 213)
    • b41: ← b40
      • v209 (+216) = CALLstatic <mem> {"".Gosched} v205
      • v212 (+212) = ADDQconst <int> [1] v199 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b44:
    • BlockInvalid (line 216)
    • b45:
    • BlockInvalid (line +216)
    • b46: ← b37
      • v253 (220) = MOVOconst <int128> [0]
      • v223 (+220) = MOVOstore <mem> v2 v253 v216
      • v229 (220) = MOVWstoreconst <mem> [val=4104,off=16] v2 v223
      • v231 (220) = MOVQstoreconst <mem> [val=1,off=24] v2 v229
      • v232 (220) = CALLstatic <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = MOVLstoreconst <mem> [val=0,off=0] v2 v235
      • v237 (223) = CALLstatic <mem> {"".exit} [8] v236
    • Plainb51 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b49:
    • BlockInvalid (line +226)
    • b50:
    • BlockInvalid (line 226)
    • b51: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
      • v240 (+226) = LoweredNilCheck <void> v238 v244
      • v241 (226) = MOVLstoreconst <mem> [val=0,off=0] v238 v244
    • Plainb51 (line +226)
    • b34: ← b17
      • v40 (166) = LoweredWB <mem> {runtime.gcWriteBarrier} v121 v120 v118
    • Plainb52 (line 166)
    • b6: ← b17
      • v39 (166) = MOVQstore <mem> {"".main_init_done} v3 v120 v118
    • Plainb52 (line 166)
    • b52: ← b34 b6
      • v122 (166) = Phi <mem> v40 v39
      • v248 (+167) = CMPBconstload <flags> [val=0,off=0] v123 v122
      • v45 (+167) = Copy <flags> v248
    • NE v248b19 b20 (line 167)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • lowered cse [345576 ns]

    • b1:
    • BlockInvalid (line +120)
    • b2:
    • BlockInvalid (line 121)
    • b3:
    • BlockInvalid (line +129)
    • b4:
    • BlockInvalid (line 130)
    • b5:
    • BlockInvalid (line +3572)
    • b7:
    • BlockInvalid (line +3576)
    • b8:
    • BlockInvalid (line +3577)
    • b9:
    • BlockInvalid (line 143)
    • b10:
    • BlockInvalid (line 143)
    • b11:
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v5 (?) = MOVQconst <uintptr> [0]
      • v15 (?) = MOVLconst <bool> [1]
      • v16 (?) = MOVQconst <uintptr> [1000000000]
      • v17 (?) = LEAQ <*uintptr> {"".maxstacksize} v3
      • v20 (?) = LEAQ <*bool> {"".mainStarted} v3
      • v23 (?) = LEAQ <*func()> {"".main.func1·f} v3
      • v36 (?) = MOVLconst <uint32> [1]
      • v44 (?) = MOVLconst <bool> [0]
      • v72 (?) = LEAQ <*m> {"".m0} v3
      • v84 (?) = MOVQconst <int64> [0]
      • v94 (?) = LEAQ <*func(*bool)> {"".main.func2·f} v3
      • v96 (?) = LEAQ <**bool> [16] v2
      • v98 (?) = MOVLconst <uint32> [8]
      • v101 (?) = LEAQ <*uintptr> [8] v2
      • v109 (?) = LEAQ <*int64> {"".runtimeInitTime} v3
      • v112 (?) = LEAQ <*uint8> {type.chan bool} v3
      • v115 (?) = MOVQconst <int> [0] (c[int])
      • v116 (?) = LEAQ <*int> [8] v2
      • v119 (?) = LEAQ <*chan bool> [16] v2
      • v121 (?) = LEAQ <*chan bool> {"".main_init_done} v3
      • v123 (?) = LEAQ <*bool> {"".iscgo} v3
      • v125 (?) = LEAQ <*unsafe.Pointer> {_cgo_thread_start} v3
      • v128 (?) = MOVQconst <unsafe.Pointer> [0]
      • v134 (?) = LEAQ <*unsafe.Pointer> {""._cgo_setenv} v3
      • v142 (?) = LEAQ <*unsafe.Pointer> {""._cgo_unsetenv} v3
      • v150 (?) = LEAQ <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v164 (?) = LEAQ <*unsafe.Pointer> [8] v2
      • v168 (?) = LEAQ <*func()> {"".main_init·f} v3 (fn[func()])
      • v181 (?) = LEAQ <*bool> {"".isarchive} v3
      • v183 (?) = LEAQ <*bool> {"".islibrary} v3
      • v188 (?) = LEAQ <*func()> {"".main_main·f} v3 (fn[func()])
      • v192 (?) = LEAQ <*uint32> {"".runningPanicDefers} v3
      • v197 (?) = MOVLconst <uint32> [0]
      • v200 (?) = MOVQconst <int> [1000]
      • v211 (?) = MOVQconst <int> [1]
      • v213 (?) = LEAQ <*uint32> {"".panicking} v3
      • v219 (?) = MOVQconst <func(*g, unsafe.Pointer) bool> [0]
      • v224 (?) = MOVLconst <waitReason> [8]
      • v225 (?) = LEAQ <*waitReason> [16] v2
      • v227 (?) = MOVLconst <byte> [16]
      • v228 (?) = LEAQ <*byte> [17] v2
      • v230 (?) = LEAQ <*int> [24] v2
      • v233 (?) = MOVLconst <int32> [0]
      • v238 (?) = MOVQconst <*int32> [0] (x[*int32])
      • v243 (?) = LEAQ <*uint8> {go.string."runtime.main not on m0"} v3
      • v239 (?) = MOVQconst <int> [22]
      • v221 (?) = LEAQ <*uint8> {go.string."nanotime returning zero"} v3
      • v210 (?) = MOVQconst <int> [23]
      • v203 (?) = LEAQ <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v184 (?) = MOVQconst <int> [25]
      • v189 (?) = LEAQ <*uint8> {go.string."_cgo_setenv missing"} v3
      • v158 (?) = MOVQconst <int> [19]
      • v155 (?) = LEAQ <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v143 (?) = MOVQconst <int> [21]
      • v139 (?) = LEAQ <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v135 (?) = MOVQconst <int> [37]
      • v1 (?) = InitMem <mem>
      • v4 (+111) = LoweredGetG <*g> v1 (g[*g])
      • v7 (+115) = ADDQconst <**m> [48] v4
      • v8 (115) = MOVQload <*m> [48] v4 v1
      • v11 (115) = MOVQload <*g> v8 v1
      • v13 (115) = ADDQconst <*uintptr> [304] v11
      • v14 (115) = MOVQstoreconst <mem> [val=0,off=304] v11 v1
      • v19 (+121) = MOVQstoreconst <mem> {"".maxstacksize} [val=1000000000,off=0] v3 v14
      • v22 (+127) = MOVBstoreconst <mem> {"".mainStarted} [val=1,off=0] v3 v19
      • v26 (+130) = MOVQstore <mem> v2 v23 v22
      • v27 (130) = CALLstatic <mem> {"".systemstack} [8] v26
      • v29 (+3614) = LoweredGetG <*g> v27
      • v31 (3614) = ADDQconst <**m> [48] v29
      • v32 (3614) = MOVQload <*m> [48] v29 v27
      • v34 (3614) = ADDQconst <*uint32> [620] v32
      • v35 (3614) = MOVLload <uint32> [620] v32 v27
      • v37 (3614) = ADDLconst <uint32> [1] v35
      • v43 (3614) = ADDLconstmodify <mem> [val=1,off=620] v32 v27
      • v46 (+3575) = LoweredGetG <*g> v43 (_g_[*g], g[*g])
      • v48 (+3576) = ADDQconst <**m> [48] v46
      • v49 (3576) = MOVQload <*m> [48] v46 v43
      • v51 (3576) = ADDQconst <*guintptr> [352] v49 (gp[*guintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v55 (205) = MOVQstore <mem> [352] v49 v53 v43
      • v58 (+3577) = LoweredNilCheck <void> v46 v55
      • v59 (3577) = ADDQconst <*muintptr> [216] v46 (mp[*muintptr])
      • v62 (3577) = MOVQload <*m> [48] v46 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v66 (243) = MOVQstore <mem> [216] v46 v64 v55
      • v69 (+143) = LoweredNilCheck <void> v4 v66
      • v70 (143) = LEAQ <*uint32> {runtime.writeBarrier} v3
      • v172 (143) = CMPQload <flags> [48] v4 v72 v66
      • v9 (115) = LoweredNilCheck <void> v8 v1
      • v12 (115) = LoweredNilCheck <void> v11 v1
      • v33 (3614) = LoweredNilCheck <void> v32 v27
      • v50 (3576) = LoweredNilCheck <void> v49 v43
      • v54 (205) = LoweredNilCheck <void> v51 v43
      • v65 (243) = LoweredNilCheck <void> v59 v55
      • v73 (143) = SETNE <bool> v172
      • v202 (143) = TESTB <flags> v73 v73
    • NE v172b12 b13 (line 143)
    • b12: ← b11
      • v60 (144) = LEAQ <*int> [8] v2
      • v41 (+144) = MOVQstore <mem> v2 v243 v66
      • v77 (+144) = MOVQstoreconst <mem> [val=22,off=8] v2 v41
      • v78 (144) = CALLstatic <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = CALLstatic <mem> {runtime.init} v66
      • v81 (+148) = CALLstatic <mem> {"".nanotime} [8] v80
      • v251 (148) = CMPQconstload <flags> [val=0,off=0] v2 v81
      • v85 (148) = SETEQ <bool> v251
      • v160 (148) = TESTB <flags> v85 v85
    • EQ v251b14 b15 (line 148)
    • b14: ← b13
      • v145 (149) = LEAQ <*int> [8] v2
      • v153 (+149) = MOVQstore <mem> v2 v221 v81
      • v88 (+149) = MOVQstoreconst <mem> [val=23,off=8] v2 v153
      • v89 (149) = CALLstatic <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b13
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (+153) = LEAQ <*bool> {needUnlock} v2
      • v93 (+153) = MOVBstoreconst <mem> {needUnlock} [val=1,off=0] v2 v91
      • v95 (+154) = LEAQ <*bool> {needUnlock} v2
      • v97 (+158) = MOVQstore <mem> [16] v2 v92 v93
      • v100 (+154) = MOVLstoreconst <mem> [val=8,off=0] v2 v97
      • v102 (154) = MOVQstore <mem> [8] v2 v94 v100
      • v103 (154) = CALLstatic <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b16:
    • BlockInvalid (line +153)
    • b17: ← b15
      • v107 (+162) = CALLstatic <mem> {"".nanotime} [8] v103
      • v108 (162) = MOVQload <int64> v2 v107
      • v110 (162) = MOVQstore <mem> {"".runtimeInitTime} v3 v108 v107
      • v111 (+164) = CALLstatic <mem> {"".gcenable} v110
      • v114 (+166) = MOVQstore <mem> v2 v112 v111
      • v117 (166) = MOVQstoreconst <mem> [val=0,off=8] v2 v114
      • v118 (166) = CALLstatic <mem> {runtime.makechan} [24] v117
      • v120 (166) = MOVQload <chan bool> [16] v2 v118
      • v252 (166) = CMPLconstload <flags> {runtime.writeBarrier} [val=0,off=0] v3 v118
      • v42 (166) = SETNE <bool> v252
      • v146 (166) = TESTB <flags> v42 v42
    • NE v252b34 b6 (unlikely) (line 166)
    • b18: ← b15
      • v105 (154) = CALLstatic <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b52
      • v25 (168) = CMPQconstload <flags> {_cgo_thread_start} [val=0,off=0] v3 v122
      • v131 (+168) = SETNE <bool> v25
      • v130 (168) = TESTB <flags> v131 v131
    • NE v25b23 b21 (line 168)
    • b20: ← b52 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = MOVQload <uintptr> {"".main_init·f} v3 v169
      • v171 (189) = CALLclosure <mem> [0] v170 v168 v169
      • v173 (+190) = MOVQload <chan bool> {"".main_init_done} v3 v171
      • v175 (190) = MOVQstore <mem> v2 v173 v171
      • v176 (190) = CALLstatic <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v178 (192) = LEAQ <*bool> {needUnlock} v2
      • v179 (+192) = MOVBstoreconst <mem> {needUnlock} [val=0,off=0] v2 v177
      • v180 (+193) = CALLstatic <mem> {"".unlockOSThread} v179
      • v147 (+195) = CMPBconstload <flags> [val=0,off=0] v181 v180
      • v74 (+195) = Copy <flags> v147
    • NE v147b31 b33 (line 195)
    • b21: ← b19
      • v137 (169) = LEAQ <*int> [8] v2
      • v129 (+169) = MOVQstore <mem> v2 v203 v122
      • v132 (+169) = MOVQstoreconst <mem> [val=25,off=8] v2 v129
      • v133 (169) = CALLstatic <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b22:
    • BlockInvalid
    • b23: ← b19
      • v249 (172) = CMPQconstload <flags> {""._cgo_setenv} [val=0,off=0] v3 v122
      • v126 (+172) = SETNE <bool> v249
      • v186 (172) = TESTB <flags> v126 v126
    • NE v249b26 b25 (line 172)
    • b24: ← b26
      • v18 (179) = CMPQconstload <flags> {_cgo_notify_runtime_init_done} [val=0,off=0] v3 v122
      • v104 (+179) = SETNE <bool> v18
      • v208 (179) = TESTB <flags> v104 v104
    • NE v18b30 b29 (line 179)
    • b25: ← b23
      • v47 (173) = LEAQ <*int> [8] v2
      • v38 (+173) = MOVQstore <mem> v2 v189 v122
      • v140 (+173) = MOVQstoreconst <mem> [val=19,off=8] v2 v38
      • v141 (173) = CALLstatic <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v167 (175) = CMPQconstload <flags> {""._cgo_unsetenv} [val=0,off=0] v3 v122
      • v106 (+175) = SETNE <bool> v167
      • v6 (175) = TESTB <flags> v106 v106
    • NE v167b24 b27 (line 175)
    • b27: ← b26
      • v30 (176) = LEAQ <*int> [8] v2
      • v28 (+176) = MOVQstore <mem> v2 v155 v122
      • v148 (+176) = MOVQstoreconst <mem> [val=21,off=8] v2 v28
      • v149 (176) = CALLstatic <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b28:
    • BlockInvalid (line +179)
    • b29: ← b24
      • v21 (180) = LEAQ <*int> [8] v2
      • v151 (+180) = MOVQstore <mem> v2 v139 v122
      • v156 (+180) = MOVQstoreconst <mem> [val=37,off=8] v2 v151
      • v157 (180) = CALLstatic <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = CALLstatic <mem> {"".startTemplateThread} v122
      • v161 (+185) = MOVQload <unsafe.Pointer> {_cgo_notify_runtime_init_done} v3 v159
      • v163 (185) = MOVQstore <mem> v2 v161 v159
      • v165 (185) = MOVQstoreconst <mem> [val=0,off=8] v2 v163
      • v166 (185) = CALLstatic <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = CALLstatic <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b32:
    • BlockInvalid (line +202)
    • b33: ← b20
      • v79 (195) = CMPBconstload <flags> [val=0,off=0] v183 v180
      • v87 (195) = Copy <flags> v79
    • NE v79b31 b35 (line 195)
    • b35: ← b33
      • v190 (+201) = MOVQload <uintptr> {"".main_main·f} v3 v180
      • v191 (201) = CALLclosure <mem> [0] v190 v188 v180
      • v194 (+210) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v250 (210) = TESTL <flags> v196 v196
      • v198 (210) = SETNE <bool> v250
      • v76 (210) = TESTB <flags> v198 v198
      • v68 (210) = InvertFlags <flags> v250
    • NE v250b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = MOVLatomicload <uint32,mem> {"".panicking} v3 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v63 (219) = TESTL <flags> v217 v217
      • v218 (219) = SETNE <bool> v63
      • v67 (219) = TESTB <flags> v218 v218
    • NE v63b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v56 (+212) = CMPQconst <flags> [1000] v199
      • v201 (+212) = SETL <bool> v56
      • v57 (+212) = TESTB <flags> v201 v201
    • LT v56b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v52 (213) = TESTL <flags> v206 v206
      • v207 (213) = SETEQ <bool> v52
      • v247 (213) = TESTB <flags> v207 v207
    • EQ v52b43 b41 (line 213)
    • b41: ← b40
      • v209 (+216) = CALLstatic <mem> {"".Gosched} v205
      • v212 (+212) = ADDQconst <int> [1] v199 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b44:
    • BlockInvalid (line 216)
    • b45:
    • BlockInvalid (line +216)
    • b46: ← b37
      • v253 (220) = MOVOconst <int128> [0]
      • v223 (+220) = MOVOstore <mem> v2 v253 v216
      • v229 (220) = MOVWstoreconst <mem> [val=4104,off=16] v2 v223
      • v231 (220) = MOVQstoreconst <mem> [val=1,off=24] v2 v229
      • v232 (220) = CALLstatic <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = MOVLstoreconst <mem> [val=0,off=0] v2 v235
      • v237 (223) = CALLstatic <mem> {"".exit} [8] v236
    • Plainb51 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b49:
    • BlockInvalid (line +226)
    • b50:
    • BlockInvalid (line 226)
    • b51: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
      • v240 (+226) = LoweredNilCheck <void> v238 v244
      • v241 (226) = MOVLstoreconst <mem> [val=0,off=0] v238 v244
    • Plainb51 (line +226)
    • b34: ← b17
      • v40 (166) = LoweredWB <mem> {runtime.gcWriteBarrier} v121 v120 v118
    • Plainb52 (line 166)
    • b6: ← b17
      • v39 (166) = MOVQstore <mem> {"".main_init_done} v3 v120 v118
    • Plainb52 (line 166)
    • b52: ← b34 b6
      • v122 (166) = Phi <mem> v40 v39
      • v248 (+167) = CMPBconstload <flags> [val=0,off=0] v123 v122
      • v45 (+167) = Copy <flags> v248
    • NE v248b19 b20 (line 167)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • elim unread autos [20154 ns]

    • b1:
    • BlockInvalid (line +120)
    • b2:
    • BlockInvalid (line 121)
    • b3:
    • BlockInvalid (line +129)
    • b4:
    • BlockInvalid (line 130)
    • b5:
    • BlockInvalid (line +3572)
    • b7:
    • BlockInvalid (line +3576)
    • b8:
    • BlockInvalid (line +3577)
    • b9:
    • BlockInvalid (line 143)
    • b10:
    • BlockInvalid (line 143)
    • b11:
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v5 (?) = MOVQconst <uintptr> [0]
      • v15 (?) = MOVLconst <bool> [1]
      • v16 (?) = MOVQconst <uintptr> [1000000000]
      • v17 (?) = LEAQ <*uintptr> {"".maxstacksize} v3
      • v20 (?) = LEAQ <*bool> {"".mainStarted} v3
      • v23 (?) = LEAQ <*func()> {"".main.func1·f} v3
      • v36 (?) = MOVLconst <uint32> [1]
      • v44 (?) = MOVLconst <bool> [0]
      • v72 (?) = LEAQ <*m> {"".m0} v3
      • v84 (?) = MOVQconst <int64> [0]
      • v94 (?) = LEAQ <*func(*bool)> {"".main.func2·f} v3
      • v96 (?) = LEAQ <**bool> [16] v2
      • v98 (?) = MOVLconst <uint32> [8]
      • v101 (?) = LEAQ <*uintptr> [8] v2
      • v109 (?) = LEAQ <*int64> {"".runtimeInitTime} v3
      • v112 (?) = LEAQ <*uint8> {type.chan bool} v3
      • v115 (?) = MOVQconst <int> [0] (c[int])
      • v116 (?) = LEAQ <*int> [8] v2
      • v119 (?) = LEAQ <*chan bool> [16] v2
      • v121 (?) = LEAQ <*chan bool> {"".main_init_done} v3
      • v123 (?) = LEAQ <*bool> {"".iscgo} v3
      • v125 (?) = LEAQ <*unsafe.Pointer> {_cgo_thread_start} v3
      • v128 (?) = MOVQconst <unsafe.Pointer> [0]
      • v134 (?) = LEAQ <*unsafe.Pointer> {""._cgo_setenv} v3
      • v142 (?) = LEAQ <*unsafe.Pointer> {""._cgo_unsetenv} v3
      • v150 (?) = LEAQ <*unsafe.Pointer> {_cgo_notify_runtime_init_done} v3
      • v164 (?) = LEAQ <*unsafe.Pointer> [8] v2
      • v168 (?) = LEAQ <*func()> {"".main_init·f} v3 (fn[func()])
      • v181 (?) = LEAQ <*bool> {"".isarchive} v3
      • v183 (?) = LEAQ <*bool> {"".islibrary} v3
      • v188 (?) = LEAQ <*func()> {"".main_main·f} v3 (fn[func()])
      • v192 (?) = LEAQ <*uint32> {"".runningPanicDefers} v3
      • v197 (?) = MOVLconst <uint32> [0]
      • v200 (?) = MOVQconst <int> [1000]
      • v211 (?) = MOVQconst <int> [1]
      • v213 (?) = LEAQ <*uint32> {"".panicking} v3
      • v219 (?) = MOVQconst <func(*g, unsafe.Pointer) bool> [0]
      • v224 (?) = MOVLconst <waitReason> [8]
      • v225 (?) = LEAQ <*waitReason> [16] v2
      • v227 (?) = MOVLconst <byte> [16]
      • v228 (?) = LEAQ <*byte> [17] v2
      • v230 (?) = LEAQ <*int> [24] v2
      • v233 (?) = MOVLconst <int32> [0]
      • v238 (?) = MOVQconst <*int32> [0] (x[*int32])
      • v243 (?) = LEAQ <*uint8> {go.string."runtime.main not on m0"} v3
      • v239 (?) = MOVQconst <int> [22]
      • v221 (?) = LEAQ <*uint8> {go.string."nanotime returning zero"} v3
      • v210 (?) = MOVQconst <int> [23]
      • v203 (?) = LEAQ <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v184 (?) = MOVQconst <int> [25]
      • v189 (?) = LEAQ <*uint8> {go.string."_cgo_setenv missing"} v3
      • v158 (?) = MOVQconst <int> [19]
      • v155 (?) = LEAQ <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v143 (?) = MOVQconst <int> [21]
      • v139 (?) = LEAQ <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v135 (?) = MOVQconst <int> [37]
      • v1 (?) = InitMem <mem>
      • v4 (+111) = LoweredGetG <*g> v1 (g[*g])
      • v7 (+115) = ADDQconst <**m> [48] v4
      • v8 (115) = MOVQload <*m> [48] v4 v1
      • v11 (115) = MOVQload <*g> v8 v1
      • v13 (115) = ADDQconst <*uintptr> [304] v11
      • v14 (115) = MOVQstoreconst <mem> [val=0,off=304] v11 v1
      • v19 (+121) = MOVQstoreconst <mem> {"".maxstacksize} [val=1000000000,off=0] v3 v14
      • v22 (+127) = MOVBstoreconst <mem> {"".mainStarted} [val=1,off=0] v3 v19
      • v26 (+130) = MOVQstore <mem> v2 v23 v22
      • v27 (130) = CALLstatic <mem> {"".systemstack} [8] v26
      • v29 (+3614) = LoweredGetG <*g> v27
      • v31 (3614) = ADDQconst <**m> [48] v29
      • v32 (3614) = MOVQload <*m> [48] v29 v27
      • v34 (3614) = ADDQconst <*uint32> [620] v32
      • v35 (3614) = MOVLload <uint32> [620] v32 v27
      • v37 (3614) = ADDLconst <uint32> [1] v35
      • v43 (3614) = ADDLconstmodify <mem> [val=1,off=620] v32 v27
      • v46 (+3575) = LoweredGetG <*g> v43 (_g_[*g], g[*g])
      • v48 (+3576) = ADDQconst <**m> [48] v46
      • v49 (3576) = MOVQload <*m> [48] v46 v43
      • v51 (3576) = ADDQconst <*guintptr> [352] v49 (gp[*guintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v55 (205) = MOVQstore <mem> [352] v49 v53 v43
      • v58 (+3577) = LoweredNilCheck <void> v46 v55
      • v59 (3577) = ADDQconst <*muintptr> [216] v46 (mp[*muintptr])
      • v62 (3577) = MOVQload <*m> [48] v46 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v66 (243) = MOVQstore <mem> [216] v46 v64 v55
      • v69 (+143) = LoweredNilCheck <void> v4 v66
      • v70 (143) = LEAQ <*uint32> {runtime.writeBarrier} v3
      • v172 (143) = CMPQload <flags> [48] v4 v72 v66
      • v9 (115) = LoweredNilCheck <void> v8 v1
      • v12 (115) = LoweredNilCheck <void> v11 v1
      • v33 (3614) = LoweredNilCheck <void> v32 v27
      • v50 (3576) = LoweredNilCheck <void> v49 v43
      • v54 (205) = LoweredNilCheck <void> v51 v43
      • v65 (243) = LoweredNilCheck <void> v59 v55
      • v73 (143) = SETNE <bool> v172
      • v202 (143) = TESTB <flags> v73 v73
    • NE v172b12 b13 (line 143)
    • b12: ← b11
      • v60 (144) = LEAQ <*int> [8] v2
      • v41 (+144) = MOVQstore <mem> v2 v243 v66
      • v77 (+144) = MOVQstoreconst <mem> [val=22,off=8] v2 v41
      • v78 (144) = CALLstatic <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = CALLstatic <mem> {runtime.init} v66
      • v81 (+148) = CALLstatic <mem> {"".nanotime} [8] v80
      • v251 (148) = CMPQconstload <flags> [val=0,off=0] v2 v81
      • v85 (148) = SETEQ <bool> v251
      • v160 (148) = TESTB <flags> v85 v85
    • EQ v251b14 b15 (line 148)
    • b14: ← b13
      • v145 (149) = LEAQ <*int> [8] v2
      • v153 (+149) = MOVQstore <mem> v2 v221 v81
      • v88 (+149) = MOVQstoreconst <mem> [val=23,off=8] v2 v153
      • v89 (149) = CALLstatic <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b13
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (+153) = LEAQ <*bool> {needUnlock} v2
      • v93 (+153) = MOVBstoreconst <mem> {needUnlock} [val=1,off=0] v2 v91
      • v95 (+154) = LEAQ <*bool> {needUnlock} v2
      • v97 (+158) = MOVQstore <mem> [16] v2 v92 v93
      • v100 (+154) = MOVLstoreconst <mem> [val=8,off=0] v2 v97
      • v102 (154) = MOVQstore <mem> [8] v2 v94 v100
      • v103 (154) = CALLstatic <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b16:
    • BlockInvalid (line +153)
    • b17: ← b15
      • v107 (+162) = CALLstatic <mem> {"".nanotime} [8] v103
      • v108 (162) = MOVQload <int64> v2 v107
      • v110 (162) = MOVQstore <mem> {"".runtimeInitTime} v3 v108 v107
      • v111 (+164) = CALLstatic <mem> {"".gcenable} v110
      • v114 (+166) = MOVQstore <mem> v2 v112 v111
      • v117 (166) = MOVQstoreconst <mem> [val=0,off=8] v2 v114
      • v118 (166) = CALLstatic <mem> {runtime.makechan} [24] v117
      • v120 (166) = MOVQload <chan bool> [16] v2 v118
      • v252 (166) = CMPLconstload <flags> {runtime.writeBarrier} [val=0,off=0] v3 v118
      • v42 (166) = SETNE <bool> v252
      • v146 (166) = TESTB <flags> v42 v42
    • NE v252b34 b6 (unlikely) (line 166)
    • b18: ← b15
      • v105 (154) = CALLstatic <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b52
      • v25 (168) = CMPQconstload <flags> {_cgo_thread_start} [val=0,off=0] v3 v122
      • v131 (+168) = SETNE <bool> v25
      • v130 (168) = TESTB <flags> v131 v131
    • NE v25b23 b21 (line 168)
    • b20: ← b52 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = MOVQload <uintptr> {"".main_init·f} v3 v169
      • v171 (189) = CALLclosure <mem> [0] v170 v168 v169
      • v173 (+190) = MOVQload <chan bool> {"".main_init_done} v3 v171
      • v175 (190) = MOVQstore <mem> v2 v173 v171
      • v176 (190) = CALLstatic <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v178 (192) = LEAQ <*bool> {needUnlock} v2
      • v179 (+192) = MOVBstoreconst <mem> {needUnlock} [val=0,off=0] v2 v177
      • v180 (+193) = CALLstatic <mem> {"".unlockOSThread} v179
      • v147 (+195) = CMPBconstload <flags> [val=0,off=0] v181 v180
      • v74 (+195) = Copy <flags> v147
    • NE v147b31 b33 (line 195)
    • b21: ← b19
      • v137 (169) = LEAQ <*int> [8] v2
      • v129 (+169) = MOVQstore <mem> v2 v203 v122
      • v132 (+169) = MOVQstoreconst <mem> [val=25,off=8] v2 v129
      • v133 (169) = CALLstatic <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b22:
    • BlockInvalid
    • b23: ← b19
      • v249 (172) = CMPQconstload <flags> {""._cgo_setenv} [val=0,off=0] v3 v122
      • v126 (+172) = SETNE <bool> v249
      • v186 (172) = TESTB <flags> v126 v126
    • NE v249b26 b25 (line 172)
    • b24: ← b26
      • v18 (179) = CMPQconstload <flags> {_cgo_notify_runtime_init_done} [val=0,off=0] v3 v122
      • v104 (+179) = SETNE <bool> v18
      • v208 (179) = TESTB <flags> v104 v104
    • NE v18b30 b29 (line 179)
    • b25: ← b23
      • v47 (173) = LEAQ <*int> [8] v2
      • v38 (+173) = MOVQstore <mem> v2 v189 v122
      • v140 (+173) = MOVQstoreconst <mem> [val=19,off=8] v2 v38
      • v141 (173) = CALLstatic <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v167 (175) = CMPQconstload <flags> {""._cgo_unsetenv} [val=0,off=0] v3 v122
      • v106 (+175) = SETNE <bool> v167
      • v6 (175) = TESTB <flags> v106 v106
    • NE v167b24 b27 (line 175)
    • b27: ← b26
      • v30 (176) = LEAQ <*int> [8] v2
      • v28 (+176) = MOVQstore <mem> v2 v155 v122
      • v148 (+176) = MOVQstoreconst <mem> [val=21,off=8] v2 v28
      • v149 (176) = CALLstatic <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b28:
    • BlockInvalid (line +179)
    • b29: ← b24
      • v21 (180) = LEAQ <*int> [8] v2
      • v151 (+180) = MOVQstore <mem> v2 v139 v122
      • v156 (+180) = MOVQstoreconst <mem> [val=37,off=8] v2 v151
      • v157 (180) = CALLstatic <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = CALLstatic <mem> {"".startTemplateThread} v122
      • v161 (+185) = MOVQload <unsafe.Pointer> {_cgo_notify_runtime_init_done} v3 v159
      • v163 (185) = MOVQstore <mem> v2 v161 v159
      • v165 (185) = MOVQstoreconst <mem> [val=0,off=8] v2 v163
      • v166 (185) = CALLstatic <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = CALLstatic <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b32:
    • BlockInvalid (line +202)
    • b33: ← b20
      • v79 (195) = CMPBconstload <flags> [val=0,off=0] v183 v180
      • v87 (195) = Copy <flags> v79
    • NE v79b31 b35 (line 195)
    • b35: ← b33
      • v190 (+201) = MOVQload <uintptr> {"".main_main·f} v3 v180
      • v191 (201) = CALLclosure <mem> [0] v190 v188 v180
      • v194 (+210) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v250 (210) = TESTL <flags> v196 v196
      • v198 (210) = SETNE <bool> v250
      • v76 (210) = TESTB <flags> v198 v198
      • v68 (210) = InvertFlags <flags> v250
    • NE v250b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = MOVLatomicload <uint32,mem> {"".panicking} v3 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v63 (219) = TESTL <flags> v217 v217
      • v218 (219) = SETNE <bool> v63
      • v67 (219) = TESTB <flags> v218 v218
    • NE v63b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v56 (+212) = CMPQconst <flags> [1000] v199
      • v201 (+212) = SETL <bool> v56
      • v57 (+212) = TESTB <flags> v201 v201
    • LT v56b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v52 (213) = TESTL <flags> v206 v206
      • v207 (213) = SETEQ <bool> v52
      • v247 (213) = TESTB <flags> v207 v207
    • EQ v52b43 b41 (line 213)
    • b41: ← b40
      • v209 (+216) = CALLstatic <mem> {"".Gosched} v205
      • v212 (+212) = ADDQconst <int> [1] v199 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b44:
    • BlockInvalid (line 216)
    • b45:
    • BlockInvalid (line +216)
    • b46: ← b37
      • v253 (220) = MOVOconst <int128> [0]
      • v223 (+220) = MOVOstore <mem> v2 v253 v216
      • v229 (220) = MOVWstoreconst <mem> [val=4104,off=16] v2 v223
      • v231 (220) = MOVQstoreconst <mem> [val=1,off=24] v2 v229
      • v232 (220) = CALLstatic <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = MOVLstoreconst <mem> [val=0,off=0] v2 v235
      • v237 (223) = CALLstatic <mem> {"".exit} [8] v236
    • Plainb51 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b49:
    • BlockInvalid (line +226)
    • b50:
    • BlockInvalid (line 226)
    • b51: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
      • v240 (+226) = LoweredNilCheck <void> v238 v244
      • v241 (226) = MOVLstoreconst <mem> [val=0,off=0] v238 v244
    • Plainb51 (line +226)
    • b34: ← b17
      • v40 (166) = LoweredWB <mem> {runtime.gcWriteBarrier} v121 v120 v118
    • Plainb52 (line 166)
    • b6: ← b17
      • v39 (166) = MOVQstore <mem> {"".main_init_done} v3 v120 v118
    • Plainb52 (line 166)
    • b52: ← b34 b6
      • v122 (166) = Phi <mem> v40 v39
      • v248 (+167) = CMPBconstload <flags> [val=0,off=0] v123 v122
      • v45 (+167) = Copy <flags> v248
    • NE v248b19 b20 (line 167)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • lowered deadcode [102332 ns]

    • b11:
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v23 (?) = LEAQ <*func()> {"".main.func1·f} v3
      • v72 (?) = LEAQ <*m> {"".m0} v3
      • v94 (?) = LEAQ <*func(*bool)> {"".main.func2·f} v3
      • v112 (?) = LEAQ <*uint8> {type.chan bool} v3
      • v115 (?) = MOVQconst <int> [0] (c[int])
      • v121 (?) = LEAQ <*chan bool> {"".main_init_done} v3
      • v123 (?) = LEAQ <*bool> {"".iscgo} v3
      • v168 (?) = LEAQ <*func()> {"".main_init·f} v3 (fn[func()])
      • v181 (?) = LEAQ <*bool> {"".isarchive} v3
      • v183 (?) = LEAQ <*bool> {"".islibrary} v3
      • v188 (?) = LEAQ <*func()> {"".main_main·f} v3 (fn[func()])
      • v238 (?) = MOVQconst <*int32> [0] (x[*int32])
      • v243 (?) = LEAQ <*uint8> {go.string."runtime.main not on m0"} v3
      • v221 (?) = LEAQ <*uint8> {go.string."nanotime returning zero"} v3
      • v203 (?) = LEAQ <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v189 (?) = LEAQ <*uint8> {go.string."_cgo_setenv missing"} v3
      • v155 (?) = LEAQ <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v139 (?) = LEAQ <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v1 (?) = InitMem <mem>
      • v4 (+111) = LoweredGetG <*g> v1 (g[*g])
      • v8 (+115) = MOVQload <*m> [48] v4 v1
      • v11 (115) = MOVQload <*g> v8 v1
      • v14 (115) = MOVQstoreconst <mem> [val=0,off=304] v11 v1
      • v19 (+121) = MOVQstoreconst <mem> {"".maxstacksize} [val=1000000000,off=0] v3 v14
      • v22 (+127) = MOVBstoreconst <mem> {"".mainStarted} [val=1,off=0] v3 v19
      • v26 (+130) = MOVQstore <mem> v2 v23 v22
      • v27 (130) = CALLstatic <mem> {"".systemstack} [8] v26
      • v29 (+3614) = LoweredGetG <*g> v27
      • v32 (3614) = MOVQload <*m> [48] v29 v27
      • v43 (3614) = ADDLconstmodify <mem> [val=1,off=620] v32 v27
      • v46 (+3575) = LoweredGetG <*g> v43 (_g_[*g], g[*g])
      • v49 (3576) = MOVQload <*m> [48] v46 v43
      • v51 (+3576) = ADDQconst <*guintptr> [352] v49 (gp[*guintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v55 (205) = MOVQstore <mem> [352] v49 v53 v43
      • v58 (+3577) = LoweredNilCheck <void> v46 v55
      • v59 (3577) = ADDQconst <*muintptr> [216] v46 (mp[*muintptr])
      • v62 (3577) = MOVQload <*m> [48] v46 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v66 (243) = MOVQstore <mem> [216] v46 v64 v55
      • v69 (+143) = LoweredNilCheck <void> v4 v66
      • v172 (143) = CMPQload <flags> [48] v4 v72 v66
      • v9 (115) = LoweredNilCheck <void> v8 v1
      • v12 (115) = LoweredNilCheck <void> v11 v1
      • v33 (3614) = LoweredNilCheck <void> v32 v27
      • v50 (3576) = LoweredNilCheck <void> v49 v43
      • v54 (205) = LoweredNilCheck <void> v51 v43
      • v65 (243) = LoweredNilCheck <void> v59 v55
    • NE v172b12 b13 (line 143)
    • b12: ← b11
      • v41 (+144) = MOVQstore <mem> v2 v243 v66
      • v77 (+144) = MOVQstoreconst <mem> [val=22,off=8] v2 v41
      • v78 (144) = CALLstatic <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = CALLstatic <mem> {runtime.init} v66
      • v81 (+148) = CALLstatic <mem> {"".nanotime} [8] v80
      • v251 (148) = CMPQconstload <flags> [val=0,off=0] v2 v81
    • EQ v251b14 b15 (line 148)
    • b14: ← b13
      • v153 (+149) = MOVQstore <mem> v2 v221 v81
      • v88 (+149) = MOVQstoreconst <mem> [val=23,off=8] v2 v153
      • v89 (149) = CALLstatic <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b13
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (+153) = LEAQ <*bool> {needUnlock} v2
      • v93 (+153) = MOVBstoreconst <mem> {needUnlock} [val=1,off=0] v2 v91
      • v97 (+158) = MOVQstore <mem> [16] v2 v92 v93
      • v100 (+154) = MOVLstoreconst <mem> [val=8,off=0] v2 v97
      • v102 (154) = MOVQstore <mem> [8] v2 v94 v100
      • v103 (154) = CALLstatic <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b17: ← b15
      • v107 (+162) = CALLstatic <mem> {"".nanotime} [8] v103
      • v108 (162) = MOVQload <int64> v2 v107
      • v110 (162) = MOVQstore <mem> {"".runtimeInitTime} v3 v108 v107
      • v111 (+164) = CALLstatic <mem> {"".gcenable} v110
      • v114 (+166) = MOVQstore <mem> v2 v112 v111
      • v117 (166) = MOVQstoreconst <mem> [val=0,off=8] v2 v114
      • v118 (166) = CALLstatic <mem> {runtime.makechan} [24] v117
      • v120 (166) = MOVQload <chan bool> [16] v2 v118
      • v252 (166) = CMPLconstload <flags> {runtime.writeBarrier} [val=0,off=0] v3 v118
    • NE v252b34 b6 (unlikely) (line 166)
    • b18: ← b15
      • v105 (154) = CALLstatic <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b52
      • v25 (+168) = CMPQconstload <flags> {_cgo_thread_start} [val=0,off=0] v3 v122
    • NE v25b23 b21 (line 168)
    • b20: ← b52 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = MOVQload <uintptr> {"".main_init·f} v3 v169
      • v171 (189) = CALLclosure <mem> [0] v170 v168 v169
      • v173 (+190) = MOVQload <chan bool> {"".main_init_done} v3 v171
      • v175 (190) = MOVQstore <mem> v2 v173 v171
      • v176 (190) = CALLstatic <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v179 (+192) = MOVBstoreconst <mem> {needUnlock} [val=0,off=0] v2 v177
      • v180 (+193) = CALLstatic <mem> {"".unlockOSThread} v179
      • v147 (+195) = CMPBconstload <flags> [val=0,off=0] v181 v180
    • NE v147b31 b33 (line 195)
    • b21: ← b19
      • v129 (+169) = MOVQstore <mem> v2 v203 v122
      • v132 (+169) = MOVQstoreconst <mem> [val=25,off=8] v2 v129
      • v133 (169) = CALLstatic <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b23: ← b19
      • v249 (+172) = CMPQconstload <flags> {""._cgo_setenv} [val=0,off=0] v3 v122
    • NE v249b26 b25 (line 172)
    • b24: ← b26
      • v18 (+179) = CMPQconstload <flags> {_cgo_notify_runtime_init_done} [val=0,off=0] v3 v122
    • NE v18b30 b29 (line 179)
    • b25: ← b23
      • v38 (+173) = MOVQstore <mem> v2 v189 v122
      • v140 (+173) = MOVQstoreconst <mem> [val=19,off=8] v2 v38
      • v141 (173) = CALLstatic <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v167 (+175) = CMPQconstload <flags> {""._cgo_unsetenv} [val=0,off=0] v3 v122
    • NE v167b24 b27 (line 175)
    • b27: ← b26
      • v28 (+176) = MOVQstore <mem> v2 v155 v122
      • v148 (+176) = MOVQstoreconst <mem> [val=21,off=8] v2 v28
      • v149 (176) = CALLstatic <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b29: ← b24
      • v151 (+180) = MOVQstore <mem> v2 v139 v122
      • v156 (+180) = MOVQstoreconst <mem> [val=37,off=8] v2 v151
      • v157 (180) = CALLstatic <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = CALLstatic <mem> {"".startTemplateThread} v122
      • v161 (+185) = MOVQload <unsafe.Pointer> {_cgo_notify_runtime_init_done} v3 v159
      • v163 (185) = MOVQstore <mem> v2 v161 v159
      • v165 (185) = MOVQstoreconst <mem> [val=0,off=8] v2 v163
      • v166 (185) = CALLstatic <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = CALLstatic <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b33: ← b20
      • v79 (195) = CMPBconstload <flags> [val=0,off=0] v183 v180
    • NE v79b31 b35 (line 195)
    • b35: ← b33
      • v190 (+201) = MOVQload <uintptr> {"".main_main·f} v3 v180
      • v191 (201) = CALLclosure <mem> [0] v190 v188 v180
      • v194 (+210) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v250 (210) = TESTL <flags> v196 v196
    • NE v250b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = MOVLatomicload <uint32,mem> {"".panicking} v3 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v63 (219) = TESTL <flags> v217 v217
    • NE v63b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v56 (+212) = CMPQconst <flags> [1000] v199
    • LT v56b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v52 (213) = TESTL <flags> v206 v206
    • EQ v52b43 b41 (line 213)
    • b41: ← b40
      • v209 (+216) = CALLstatic <mem> {"".Gosched} v205
      • v212 (+212) = ADDQconst <int> [1] v199 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b46: ← b37
      • v253 (220) = MOVOconst <int128> [0]
      • v223 (+220) = MOVOstore <mem> v2 v253 v216
      • v229 (220) = MOVWstoreconst <mem> [val=4104,off=16] v2 v223
      • v231 (220) = MOVQstoreconst <mem> [val=1,off=24] v2 v229
      • v232 (220) = CALLstatic <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = MOVLstoreconst <mem> [val=0,off=0] v2 v235
      • v237 (223) = CALLstatic <mem> {"".exit} [8] v236
    • Plainb51 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b51: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
      • v240 (+226) = LoweredNilCheck <void> v238 v244
      • v241 (226) = MOVLstoreconst <mem> [val=0,off=0] v238 v244
    • Plainb51 (line +226)
    • b34: ← b17
      • v40 (166) = LoweredWB <mem> {runtime.gcWriteBarrier} v121 v120 v118
    • Plainb52 (line 166)
    • b6: ← b17
      • v39 (166) = MOVQstore <mem> {"".main_init_done} v3 v120 v118
    • Plainb52 (line 166)
    • b52: ← b34 b6
      • v122 (166) = Phi <mem> v40 v39
      • v248 (+167) = CMPBconstload <flags> [val=0,off=0] v123 v122
    • NE v248b19 b20 (line 167)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • checkLower [20653 ns]

    • b11:
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v23 (?) = LEAQ <*func()> {"".main.func1·f} v3
      • v72 (?) = LEAQ <*m> {"".m0} v3
      • v94 (?) = LEAQ <*func(*bool)> {"".main.func2·f} v3
      • v112 (?) = LEAQ <*uint8> {type.chan bool} v3
      • v115 (?) = MOVQconst <int> [0] (c[int])
      • v121 (?) = LEAQ <*chan bool> {"".main_init_done} v3
      • v123 (?) = LEAQ <*bool> {"".iscgo} v3
      • v168 (?) = LEAQ <*func()> {"".main_init·f} v3 (fn[func()])
      • v181 (?) = LEAQ <*bool> {"".isarchive} v3
      • v183 (?) = LEAQ <*bool> {"".islibrary} v3
      • v188 (?) = LEAQ <*func()> {"".main_main·f} v3 (fn[func()])
      • v238 (?) = MOVQconst <*int32> [0] (x[*int32])
      • v243 (?) = LEAQ <*uint8> {go.string."runtime.main not on m0"} v3
      • v221 (?) = LEAQ <*uint8> {go.string."nanotime returning zero"} v3
      • v203 (?) = LEAQ <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v189 (?) = LEAQ <*uint8> {go.string."_cgo_setenv missing"} v3
      • v155 (?) = LEAQ <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v139 (?) = LEAQ <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v1 (?) = InitMem <mem>
      • v4 (+111) = LoweredGetG <*g> v1 (g[*g])
      • v8 (+115) = MOVQload <*m> [48] v4 v1
      • v11 (115) = MOVQload <*g> v8 v1
      • v14 (115) = MOVQstoreconst <mem> [val=0,off=304] v11 v1
      • v19 (+121) = MOVQstoreconst <mem> {"".maxstacksize} [val=1000000000,off=0] v3 v14
      • v22 (+127) = MOVBstoreconst <mem> {"".mainStarted} [val=1,off=0] v3 v19
      • v26 (+130) = MOVQstore <mem> v2 v23 v22
      • v27 (130) = CALLstatic <mem> {"".systemstack} [8] v26
      • v29 (+3614) = LoweredGetG <*g> v27
      • v32 (3614) = MOVQload <*m> [48] v29 v27
      • v43 (3614) = ADDLconstmodify <mem> [val=1,off=620] v32 v27
      • v46 (+3575) = LoweredGetG <*g> v43 (_g_[*g], g[*g])
      • v49 (3576) = MOVQload <*m> [48] v46 v43
      • v51 (+3576) = ADDQconst <*guintptr> [352] v49 (gp[*guintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v55 (205) = MOVQstore <mem> [352] v49 v53 v43
      • v58 (+3577) = LoweredNilCheck <void> v46 v55
      • v59 (3577) = ADDQconst <*muintptr> [216] v46 (mp[*muintptr])
      • v62 (3577) = MOVQload <*m> [48] v46 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v66 (243) = MOVQstore <mem> [216] v46 v64 v55
      • v69 (+143) = LoweredNilCheck <void> v4 v66
      • v172 (143) = CMPQload <flags> [48] v4 v72 v66
      • v9 (115) = LoweredNilCheck <void> v8 v1
      • v12 (115) = LoweredNilCheck <void> v11 v1
      • v33 (3614) = LoweredNilCheck <void> v32 v27
      • v50 (3576) = LoweredNilCheck <void> v49 v43
      • v54 (205) = LoweredNilCheck <void> v51 v43
      • v65 (243) = LoweredNilCheck <void> v59 v55
    • NE v172b12 b13 (line 143)
    • b12: ← b11
      • v41 (+144) = MOVQstore <mem> v2 v243 v66
      • v77 (+144) = MOVQstoreconst <mem> [val=22,off=8] v2 v41
      • v78 (144) = CALLstatic <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = CALLstatic <mem> {runtime.init} v66
      • v81 (+148) = CALLstatic <mem> {"".nanotime} [8] v80
      • v251 (148) = CMPQconstload <flags> [val=0,off=0] v2 v81
    • EQ v251b14 b15 (line 148)
    • b14: ← b13
      • v153 (+149) = MOVQstore <mem> v2 v221 v81
      • v88 (+149) = MOVQstoreconst <mem> [val=23,off=8] v2 v153
      • v89 (149) = CALLstatic <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b13
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (+153) = LEAQ <*bool> {needUnlock} v2
      • v93 (+153) = MOVBstoreconst <mem> {needUnlock} [val=1,off=0] v2 v91
      • v97 (+158) = MOVQstore <mem> [16] v2 v92 v93
      • v100 (+154) = MOVLstoreconst <mem> [val=8,off=0] v2 v97
      • v102 (154) = MOVQstore <mem> [8] v2 v94 v100
      • v103 (154) = CALLstatic <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b17: ← b15
      • v107 (+162) = CALLstatic <mem> {"".nanotime} [8] v103
      • v108 (162) = MOVQload <int64> v2 v107
      • v110 (162) = MOVQstore <mem> {"".runtimeInitTime} v3 v108 v107
      • v111 (+164) = CALLstatic <mem> {"".gcenable} v110
      • v114 (+166) = MOVQstore <mem> v2 v112 v111
      • v117 (166) = MOVQstoreconst <mem> [val=0,off=8] v2 v114
      • v118 (166) = CALLstatic <mem> {runtime.makechan} [24] v117
      • v120 (166) = MOVQload <chan bool> [16] v2 v118
      • v252 (166) = CMPLconstload <flags> {runtime.writeBarrier} [val=0,off=0] v3 v118
    • NE v252b34 b6 (unlikely) (line 166)
    • b18: ← b15
      • v105 (154) = CALLstatic <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b52
      • v25 (+168) = CMPQconstload <flags> {_cgo_thread_start} [val=0,off=0] v3 v122
    • NE v25b23 b21 (line 168)
    • b20: ← b52 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = MOVQload <uintptr> {"".main_init·f} v3 v169
      • v171 (189) = CALLclosure <mem> [0] v170 v168 v169
      • v173 (+190) = MOVQload <chan bool> {"".main_init_done} v3 v171
      • v175 (190) = MOVQstore <mem> v2 v173 v171
      • v176 (190) = CALLstatic <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v179 (+192) = MOVBstoreconst <mem> {needUnlock} [val=0,off=0] v2 v177
      • v180 (+193) = CALLstatic <mem> {"".unlockOSThread} v179
      • v147 (+195) = CMPBconstload <flags> [val=0,off=0] v181 v180
    • NE v147b31 b33 (line 195)
    • b21: ← b19
      • v129 (+169) = MOVQstore <mem> v2 v203 v122
      • v132 (+169) = MOVQstoreconst <mem> [val=25,off=8] v2 v129
      • v133 (169) = CALLstatic <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b23: ← b19
      • v249 (+172) = CMPQconstload <flags> {""._cgo_setenv} [val=0,off=0] v3 v122
    • NE v249b26 b25 (line 172)
    • b24: ← b26
      • v18 (+179) = CMPQconstload <flags> {_cgo_notify_runtime_init_done} [val=0,off=0] v3 v122
    • NE v18b30 b29 (line 179)
    • b25: ← b23
      • v38 (+173) = MOVQstore <mem> v2 v189 v122
      • v140 (+173) = MOVQstoreconst <mem> [val=19,off=8] v2 v38
      • v141 (173) = CALLstatic <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v167 (+175) = CMPQconstload <flags> {""._cgo_unsetenv} [val=0,off=0] v3 v122
    • NE v167b24 b27 (line 175)
    • b27: ← b26
      • v28 (+176) = MOVQstore <mem> v2 v155 v122
      • v148 (+176) = MOVQstoreconst <mem> [val=21,off=8] v2 v28
      • v149 (176) = CALLstatic <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b29: ← b24
      • v151 (+180) = MOVQstore <mem> v2 v139 v122
      • v156 (+180) = MOVQstoreconst <mem> [val=37,off=8] v2 v151
      • v157 (180) = CALLstatic <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = CALLstatic <mem> {"".startTemplateThread} v122
      • v161 (+185) = MOVQload <unsafe.Pointer> {_cgo_notify_runtime_init_done} v3 v159
      • v163 (185) = MOVQstore <mem> v2 v161 v159
      • v165 (185) = MOVQstoreconst <mem> [val=0,off=8] v2 v163
      • v166 (185) = CALLstatic <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = CALLstatic <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b33: ← b20
      • v79 (195) = CMPBconstload <flags> [val=0,off=0] v183 v180
    • NE v79b31 b35 (line 195)
    • b35: ← b33
      • v190 (+201) = MOVQload <uintptr> {"".main_main·f} v3 v180
      • v191 (201) = CALLclosure <mem> [0] v190 v188 v180
      • v194 (+210) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v250 (210) = TESTL <flags> v196 v196
    • NE v250b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = MOVLatomicload <uint32,mem> {"".panicking} v3 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v63 (219) = TESTL <flags> v217 v217
    • NE v63b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v56 (+212) = CMPQconst <flags> [1000] v199
    • LT v56b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v52 (213) = TESTL <flags> v206 v206
    • EQ v52b43 b41 (line 213)
    • b41: ← b40
      • v209 (+216) = CALLstatic <mem> {"".Gosched} v205
      • v212 (+212) = ADDQconst <int> [1] v199 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b46: ← b37
      • v253 (220) = MOVOconst <int128> [0]
      • v223 (+220) = MOVOstore <mem> v2 v253 v216
      • v229 (220) = MOVWstoreconst <mem> [val=4104,off=16] v2 v223
      • v231 (220) = MOVQstoreconst <mem> [val=1,off=24] v2 v229
      • v232 (220) = CALLstatic <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = MOVLstoreconst <mem> [val=0,off=0] v2 v235
      • v237 (223) = CALLstatic <mem> {"".exit} [8] v236
    • Plainb51 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b51: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
      • v240 (+226) = LoweredNilCheck <void> v238 v244
      • v241 (226) = MOVLstoreconst <mem> [val=0,off=0] v238 v244
    • Plainb51 (line +226)
    • b34: ← b17
      • v40 (166) = LoweredWB <mem> {runtime.gcWriteBarrier} v121 v120 v118
    • Plainb52 (line 166)
    • b6: ← b17
      • v39 (166) = MOVQstore <mem> {"".main_init_done} v3 v120 v118
    • Plainb52 (line 166)
    • b52: ← b34 b6
      • v122 (166) = Phi <mem> v40 v39
      • v248 (+167) = CMPBconstload <flags> [val=0,off=0] v123 v122
    • NE v248b19 b20 (line 167)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • late phielim [11314 ns]

    • b11:
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v23 (?) = LEAQ <*func()> {"".main.func1·f} v3
      • v72 (?) = LEAQ <*m> {"".m0} v3
      • v94 (?) = LEAQ <*func(*bool)> {"".main.func2·f} v3
      • v112 (?) = LEAQ <*uint8> {type.chan bool} v3
      • v115 (?) = MOVQconst <int> [0] (c[int])
      • v121 (?) = LEAQ <*chan bool> {"".main_init_done} v3
      • v123 (?) = LEAQ <*bool> {"".iscgo} v3
      • v168 (?) = LEAQ <*func()> {"".main_init·f} v3 (fn[func()])
      • v181 (?) = LEAQ <*bool> {"".isarchive} v3
      • v183 (?) = LEAQ <*bool> {"".islibrary} v3
      • v188 (?) = LEAQ <*func()> {"".main_main·f} v3 (fn[func()])
      • v238 (?) = MOVQconst <*int32> [0] (x[*int32])
      • v243 (?) = LEAQ <*uint8> {go.string."runtime.main not on m0"} v3
      • v221 (?) = LEAQ <*uint8> {go.string."nanotime returning zero"} v3
      • v203 (?) = LEAQ <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v189 (?) = LEAQ <*uint8> {go.string."_cgo_setenv missing"} v3
      • v155 (?) = LEAQ <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v139 (?) = LEAQ <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v1 (?) = InitMem <mem>
      • v4 (+111) = LoweredGetG <*g> v1 (g[*g])
      • v8 (+115) = MOVQload <*m> [48] v4 v1
      • v11 (115) = MOVQload <*g> v8 v1
      • v14 (115) = MOVQstoreconst <mem> [val=0,off=304] v11 v1
      • v19 (+121) = MOVQstoreconst <mem> {"".maxstacksize} [val=1000000000,off=0] v3 v14
      • v22 (+127) = MOVBstoreconst <mem> {"".mainStarted} [val=1,off=0] v3 v19
      • v26 (+130) = MOVQstore <mem> v2 v23 v22
      • v27 (130) = CALLstatic <mem> {"".systemstack} [8] v26
      • v29 (+3614) = LoweredGetG <*g> v27
      • v32 (3614) = MOVQload <*m> [48] v29 v27
      • v43 (3614) = ADDLconstmodify <mem> [val=1,off=620] v32 v27
      • v46 (+3575) = LoweredGetG <*g> v43 (_g_[*g], g[*g])
      • v49 (3576) = MOVQload <*m> [48] v46 v43
      • v51 (+3576) = ADDQconst <*guintptr> [352] v49 (gp[*guintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v55 (205) = MOVQstore <mem> [352] v49 v53 v43
      • v58 (+3577) = LoweredNilCheck <void> v46 v55
      • v59 (3577) = ADDQconst <*muintptr> [216] v46 (mp[*muintptr])
      • v62 (3577) = MOVQload <*m> [48] v46 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v66 (243) = MOVQstore <mem> [216] v46 v64 v55
      • v69 (+143) = LoweredNilCheck <void> v4 v66
      • v172 (143) = CMPQload <flags> [48] v4 v72 v66
      • v9 (115) = LoweredNilCheck <void> v8 v1
      • v12 (115) = LoweredNilCheck <void> v11 v1
      • v33 (3614) = LoweredNilCheck <void> v32 v27
      • v50 (3576) = LoweredNilCheck <void> v49 v43
      • v54 (205) = LoweredNilCheck <void> v51 v43
      • v65 (243) = LoweredNilCheck <void> v59 v55
    • NE v172b12 b13 (line 143)
    • b12: ← b11
      • v41 (+144) = MOVQstore <mem> v2 v243 v66
      • v77 (+144) = MOVQstoreconst <mem> [val=22,off=8] v2 v41
      • v78 (144) = CALLstatic <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = CALLstatic <mem> {runtime.init} v66
      • v81 (+148) = CALLstatic <mem> {"".nanotime} [8] v80
      • v251 (148) = CMPQconstload <flags> [val=0,off=0] v2 v81
    • EQ v251b14 b15 (line 148)
    • b14: ← b13
      • v153 (+149) = MOVQstore <mem> v2 v221 v81
      • v88 (+149) = MOVQstoreconst <mem> [val=23,off=8] v2 v153
      • v89 (149) = CALLstatic <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b13
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (+153) = LEAQ <*bool> {needUnlock} v2
      • v93 (+153) = MOVBstoreconst <mem> {needUnlock} [val=1,off=0] v2 v91
      • v97 (+158) = MOVQstore <mem> [16] v2 v92 v93
      • v100 (+154) = MOVLstoreconst <mem> [val=8,off=0] v2 v97
      • v102 (154) = MOVQstore <mem> [8] v2 v94 v100
      • v103 (154) = CALLstatic <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b17: ← b15
      • v107 (+162) = CALLstatic <mem> {"".nanotime} [8] v103
      • v108 (162) = MOVQload <int64> v2 v107
      • v110 (162) = MOVQstore <mem> {"".runtimeInitTime} v3 v108 v107
      • v111 (+164) = CALLstatic <mem> {"".gcenable} v110
      • v114 (+166) = MOVQstore <mem> v2 v112 v111
      • v117 (166) = MOVQstoreconst <mem> [val=0,off=8] v2 v114
      • v118 (166) = CALLstatic <mem> {runtime.makechan} [24] v117
      • v120 (166) = MOVQload <chan bool> [16] v2 v118
      • v252 (166) = CMPLconstload <flags> {runtime.writeBarrier} [val=0,off=0] v3 v118
    • NE v252b34 b6 (unlikely) (line 166)
    • b18: ← b15
      • v105 (154) = CALLstatic <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b52
      • v25 (+168) = CMPQconstload <flags> {_cgo_thread_start} [val=0,off=0] v3 v122
    • NE v25b23 b21 (line 168)
    • b20: ← b52 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = MOVQload <uintptr> {"".main_init·f} v3 v169
      • v171 (189) = CALLclosure <mem> [0] v170 v168 v169
      • v173 (+190) = MOVQload <chan bool> {"".main_init_done} v3 v171
      • v175 (190) = MOVQstore <mem> v2 v173 v171
      • v176 (190) = CALLstatic <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v179 (+192) = MOVBstoreconst <mem> {needUnlock} [val=0,off=0] v2 v177
      • v180 (+193) = CALLstatic <mem> {"".unlockOSThread} v179
      • v147 (+195) = CMPBconstload <flags> [val=0,off=0] v181 v180
    • NE v147b31 b33 (line 195)
    • b21: ← b19
      • v129 (+169) = MOVQstore <mem> v2 v203 v122
      • v132 (+169) = MOVQstoreconst <mem> [val=25,off=8] v2 v129
      • v133 (169) = CALLstatic <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b23: ← b19
      • v249 (+172) = CMPQconstload <flags> {""._cgo_setenv} [val=0,off=0] v3 v122
    • NE v249b26 b25 (line 172)
    • b24: ← b26
      • v18 (+179) = CMPQconstload <flags> {_cgo_notify_runtime_init_done} [val=0,off=0] v3 v122
    • NE v18b30 b29 (line 179)
    • b25: ← b23
      • v38 (+173) = MOVQstore <mem> v2 v189 v122
      • v140 (+173) = MOVQstoreconst <mem> [val=19,off=8] v2 v38
      • v141 (173) = CALLstatic <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v167 (+175) = CMPQconstload <flags> {""._cgo_unsetenv} [val=0,off=0] v3 v122
    • NE v167b24 b27 (line 175)
    • b27: ← b26
      • v28 (+176) = MOVQstore <mem> v2 v155 v122
      • v148 (+176) = MOVQstoreconst <mem> [val=21,off=8] v2 v28
      • v149 (176) = CALLstatic <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b29: ← b24
      • v151 (+180) = MOVQstore <mem> v2 v139 v122
      • v156 (+180) = MOVQstoreconst <mem> [val=37,off=8] v2 v151
      • v157 (180) = CALLstatic <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = CALLstatic <mem> {"".startTemplateThread} v122
      • v161 (+185) = MOVQload <unsafe.Pointer> {_cgo_notify_runtime_init_done} v3 v159
      • v163 (185) = MOVQstore <mem> v2 v161 v159
      • v165 (185) = MOVQstoreconst <mem> [val=0,off=8] v2 v163
      • v166 (185) = CALLstatic <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = CALLstatic <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b33: ← b20
      • v79 (195) = CMPBconstload <flags> [val=0,off=0] v183 v180
    • NE v79b31 b35 (line 195)
    • b35: ← b33
      • v190 (+201) = MOVQload <uintptr> {"".main_main·f} v3 v180
      • v191 (201) = CALLclosure <mem> [0] v190 v188 v180
      • v194 (+210) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v250 (210) = TESTL <flags> v196 v196
    • NE v250b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = MOVLatomicload <uint32,mem> {"".panicking} v3 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v63 (219) = TESTL <flags> v217 v217
    • NE v63b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v56 (+212) = CMPQconst <flags> [1000] v199
    • LT v56b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v52 (213) = TESTL <flags> v206 v206
    • EQ v52b43 b41 (line 213)
    • b41: ← b40
      • v209 (+216) = CALLstatic <mem> {"".Gosched} v205
      • v212 (+212) = ADDQconst <int> [1] v199 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b46: ← b37
      • v253 (220) = MOVOconst <int128> [0]
      • v223 (+220) = MOVOstore <mem> v2 v253 v216
      • v229 (220) = MOVWstoreconst <mem> [val=4104,off=16] v2 v223
      • v231 (220) = MOVQstoreconst <mem> [val=1,off=24] v2 v229
      • v232 (220) = CALLstatic <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = MOVLstoreconst <mem> [val=0,off=0] v2 v235
      • v237 (223) = CALLstatic <mem> {"".exit} [8] v236
    • Plainb51 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b51: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
      • v240 (+226) = LoweredNilCheck <void> v238 v244
      • v241 (226) = MOVLstoreconst <mem> [val=0,off=0] v238 v244
    • Plainb51 (line +226)
    • b34: ← b17
      • v40 (166) = LoweredWB <mem> {runtime.gcWriteBarrier} v121 v120 v118
    • Plainb52 (line 166)
    • b6: ← b17
      • v39 (166) = MOVQstore <mem> {"".main_init_done} v3 v120 v118
    • Plainb52 (line 166)
    • b52: ← b34 b6
      • v122 (166) = Phi <mem> v40 v39
      • v248 (+167) = CMPBconstload <flags> [val=0,off=0] v123 v122
    • NE v248b19 b20 (line 167)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • late copyelim [14627 ns]

    • b11:
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v23 (?) = LEAQ <*func()> {"".main.func1·f} v3
      • v72 (?) = LEAQ <*m> {"".m0} v3
      • v94 (?) = LEAQ <*func(*bool)> {"".main.func2·f} v3
      • v112 (?) = LEAQ <*uint8> {type.chan bool} v3
      • v115 (?) = MOVQconst <int> [0] (c[int])
      • v121 (?) = LEAQ <*chan bool> {"".main_init_done} v3
      • v123 (?) = LEAQ <*bool> {"".iscgo} v3
      • v168 (?) = LEAQ <*func()> {"".main_init·f} v3 (fn[func()])
      • v181 (?) = LEAQ <*bool> {"".isarchive} v3
      • v183 (?) = LEAQ <*bool> {"".islibrary} v3
      • v188 (?) = LEAQ <*func()> {"".main_main·f} v3 (fn[func()])
      • v238 (?) = MOVQconst <*int32> [0] (x[*int32])
      • v243 (?) = LEAQ <*uint8> {go.string."runtime.main not on m0"} v3
      • v221 (?) = LEAQ <*uint8> {go.string."nanotime returning zero"} v3
      • v203 (?) = LEAQ <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v189 (?) = LEAQ <*uint8> {go.string."_cgo_setenv missing"} v3
      • v155 (?) = LEAQ <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v139 (?) = LEAQ <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v1 (?) = InitMem <mem>
      • v4 (+111) = LoweredGetG <*g> v1 (g[*g])
      • v8 (+115) = MOVQload <*m> [48] v4 v1
      • v11 (115) = MOVQload <*g> v8 v1
      • v14 (115) = MOVQstoreconst <mem> [val=0,off=304] v11 v1
      • v19 (+121) = MOVQstoreconst <mem> {"".maxstacksize} [val=1000000000,off=0] v3 v14
      • v22 (+127) = MOVBstoreconst <mem> {"".mainStarted} [val=1,off=0] v3 v19
      • v26 (+130) = MOVQstore <mem> v2 v23 v22
      • v27 (130) = CALLstatic <mem> {"".systemstack} [8] v26
      • v29 (+3614) = LoweredGetG <*g> v27
      • v32 (3614) = MOVQload <*m> [48] v29 v27
      • v43 (3614) = ADDLconstmodify <mem> [val=1,off=620] v32 v27
      • v46 (+3575) = LoweredGetG <*g> v43 (g[*g], _g_[*g])
      • v49 (3576) = MOVQload <*m> [48] v46 v43
      • v51 (+3576) = ADDQconst <*guintptr> [352] v49 (gp[*guintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v55 (205) = MOVQstore <mem> [352] v49 v53 v43
      • v58 (+3577) = LoweredNilCheck <void> v46 v55
      • v59 (3577) = ADDQconst <*muintptr> [216] v46 (mp[*muintptr])
      • v62 (3577) = MOVQload <*m> [48] v46 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v66 (243) = MOVQstore <mem> [216] v46 v64 v55
      • v69 (+143) = LoweredNilCheck <void> v4 v66
      • v172 (143) = CMPQload <flags> [48] v4 v72 v66
      • v9 (115) = LoweredNilCheck <void> v8 v1
      • v12 (115) = LoweredNilCheck <void> v11 v1
      • v33 (3614) = LoweredNilCheck <void> v32 v27
      • v50 (3576) = LoweredNilCheck <void> v49 v43
      • v54 (205) = LoweredNilCheck <void> v51 v43
      • v65 (243) = LoweredNilCheck <void> v59 v55
    • NE v172b12 b13 (line 143)
    • b12: ← b11
      • v41 (+144) = MOVQstore <mem> v2 v243 v66
      • v77 (+144) = MOVQstoreconst <mem> [val=22,off=8] v2 v41
      • v78 (144) = CALLstatic <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = CALLstatic <mem> {runtime.init} v66
      • v81 (+148) = CALLstatic <mem> {"".nanotime} [8] v80
      • v251 (148) = CMPQconstload <flags> [val=0,off=0] v2 v81
    • EQ v251b14 b15 (line 148)
    • b14: ← b13
      • v153 (+149) = MOVQstore <mem> v2 v221 v81
      • v88 (+149) = MOVQstoreconst <mem> [val=23,off=8] v2 v153
      • v89 (149) = CALLstatic <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b13
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (+153) = LEAQ <*bool> {needUnlock} v2
      • v93 (+153) = MOVBstoreconst <mem> {needUnlock} [val=1,off=0] v2 v91
      • v97 (+158) = MOVQstore <mem> [16] v2 v92 v93
      • v100 (+154) = MOVLstoreconst <mem> [val=8,off=0] v2 v97
      • v102 (154) = MOVQstore <mem> [8] v2 v94 v100
      • v103 (154) = CALLstatic <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b17: ← b15
      • v107 (+162) = CALLstatic <mem> {"".nanotime} [8] v103
      • v108 (162) = MOVQload <int64> v2 v107
      • v110 (162) = MOVQstore <mem> {"".runtimeInitTime} v3 v108 v107
      • v111 (+164) = CALLstatic <mem> {"".gcenable} v110
      • v114 (+166) = MOVQstore <mem> v2 v112 v111
      • v117 (166) = MOVQstoreconst <mem> [val=0,off=8] v2 v114
      • v118 (166) = CALLstatic <mem> {runtime.makechan} [24] v117
      • v120 (166) = MOVQload <chan bool> [16] v2 v118
      • v252 (166) = CMPLconstload <flags> {runtime.writeBarrier} [val=0,off=0] v3 v118
    • NE v252b34 b6 (unlikely) (line 166)
    • b18: ← b15
      • v105 (154) = CALLstatic <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b52
      • v25 (+168) = CMPQconstload <flags> {_cgo_thread_start} [val=0,off=0] v3 v122
    • NE v25b23 b21 (line 168)
    • b20: ← b52 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = MOVQload <uintptr> {"".main_init·f} v3 v169
      • v171 (189) = CALLclosure <mem> [0] v170 v168 v169
      • v173 (+190) = MOVQload <chan bool> {"".main_init_done} v3 v171
      • v175 (190) = MOVQstore <mem> v2 v173 v171
      • v176 (190) = CALLstatic <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v179 (+192) = MOVBstoreconst <mem> {needUnlock} [val=0,off=0] v2 v177
      • v180 (+193) = CALLstatic <mem> {"".unlockOSThread} v179
      • v147 (+195) = CMPBconstload <flags> [val=0,off=0] v181 v180
    • NE v147b31 b33 (line 195)
    • b21: ← b19
      • v129 (+169) = MOVQstore <mem> v2 v203 v122
      • v132 (+169) = MOVQstoreconst <mem> [val=25,off=8] v2 v129
      • v133 (169) = CALLstatic <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b23: ← b19
      • v249 (+172) = CMPQconstload <flags> {""._cgo_setenv} [val=0,off=0] v3 v122
    • NE v249b26 b25 (line 172)
    • b24: ← b26
      • v18 (+179) = CMPQconstload <flags> {_cgo_notify_runtime_init_done} [val=0,off=0] v3 v122
    • NE v18b30 b29 (line 179)
    • b25: ← b23
      • v38 (+173) = MOVQstore <mem> v2 v189 v122
      • v140 (+173) = MOVQstoreconst <mem> [val=19,off=8] v2 v38
      • v141 (173) = CALLstatic <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v167 (+175) = CMPQconstload <flags> {""._cgo_unsetenv} [val=0,off=0] v3 v122
    • NE v167b24 b27 (line 175)
    • b27: ← b26
      • v28 (+176) = MOVQstore <mem> v2 v155 v122
      • v148 (+176) = MOVQstoreconst <mem> [val=21,off=8] v2 v28
      • v149 (176) = CALLstatic <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b29: ← b24
      • v151 (+180) = MOVQstore <mem> v2 v139 v122
      • v156 (+180) = MOVQstoreconst <mem> [val=37,off=8] v2 v151
      • v157 (180) = CALLstatic <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = CALLstatic <mem> {"".startTemplateThread} v122
      • v161 (+185) = MOVQload <unsafe.Pointer> {_cgo_notify_runtime_init_done} v3 v159
      • v163 (185) = MOVQstore <mem> v2 v161 v159
      • v165 (185) = MOVQstoreconst <mem> [val=0,off=8] v2 v163
      • v166 (185) = CALLstatic <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = CALLstatic <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b33: ← b20
      • v79 (195) = CMPBconstload <flags> [val=0,off=0] v183 v180
    • NE v79b31 b35 (line 195)
    • b35: ← b33
      • v190 (+201) = MOVQload <uintptr> {"".main_main·f} v3 v180
      • v191 (201) = CALLclosure <mem> [0] v190 v188 v180
      • v194 (+210) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v250 (210) = TESTL <flags> v196 v196
    • NE v250b36 b38 (line 210)
    • b36: ← b35
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = MOVLatomicload <uint32,mem> {"".panicking} v3 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v63 (219) = TESTL <flags> v217 v217
    • NE v63b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v56 (+212) = CMPQconst <flags> [1000] v199
    • LT v56b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v52 (213) = TESTL <flags> v206 v206
    • EQ v52b43 b41 (line 213)
    • b41: ← b40
      • v209 (+216) = CALLstatic <mem> {"".Gosched} v205
      • v212 (+212) = ADDQconst <int> [1] v199 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b46: ← b37
      • v253 (220) = MOVOconst <int128> [0]
      • v223 (+220) = MOVOstore <mem> v2 v253 v216
      • v229 (220) = MOVWstoreconst <mem> [val=4104,off=16] v2 v223
      • v231 (220) = MOVQstoreconst <mem> [val=1,off=24] v2 v229
      • v232 (220) = CALLstatic <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = MOVLstoreconst <mem> [val=0,off=0] v2 v235
      • v237 (223) = CALLstatic <mem> {"".exit} [8] v236
    • Plainb51 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b51: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
      • v240 (+226) = LoweredNilCheck <void> v238 v244
      • v241 (226) = MOVLstoreconst <mem> [val=0,off=0] v238 v244
    • Plainb51 (line +226)
    • b34: ← b17
      • v40 (166) = LoweredWB <mem> {runtime.gcWriteBarrier} v121 v120 v118
    • Plainb52 (line 166)
    • b6: ← b17
      • v39 (166) = MOVQstore <mem> {"".main_init_done} v3 v120 v118
    • Plainb52 (line 166)
    • b52: ← b34 b6
      • v122 (166) = Phi <mem> v40 v39
      • v248 (+167) = CMPBconstload <flags> [val=0,off=0] v123 v122
    • NE v248b19 b20 (line 167)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • tighten [93455 ns]

    • b11:
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v23 (?) = LEAQ <*func()> {"".main.func1·f} v3
      • v72 (?) = LEAQ <*m> {"".m0} v3
      • v1 (?) = InitMem <mem>
      • v4 (+111) = LoweredGetG <*g> v1 (g[*g])
      • v8 (+115) = MOVQload <*m> [48] v4 v1
      • v11 (115) = MOVQload <*g> v8 v1
      • v14 (115) = MOVQstoreconst <mem> [val=0,off=304] v11 v1
      • v19 (+121) = MOVQstoreconst <mem> {"".maxstacksize} [val=1000000000,off=0] v3 v14
      • v22 (+127) = MOVBstoreconst <mem> {"".mainStarted} [val=1,off=0] v3 v19
      • v26 (+130) = MOVQstore <mem> v2 v23 v22
      • v27 (130) = CALLstatic <mem> {"".systemstack} [8] v26
      • v29 (+3614) = LoweredGetG <*g> v27
      • v32 (3614) = MOVQload <*m> [48] v29 v27
      • v43 (3614) = ADDLconstmodify <mem> [val=1,off=620] v32 v27
      • v9 (115) = LoweredNilCheck <void> v8 v1
      • v12 (115) = LoweredNilCheck <void> v11 v1
      • v33 (3614) = LoweredNilCheck <void> v32 v27
      • v46 (+3575) = LoweredGetG <*g> v43 (_g_[*g], g[*g])
      • v59 (3577) = ADDQconst <*muintptr> [216] v46 (mp[*muintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v49 (3576) = MOVQload <*m> [48] v46 v43
      • v50 (3576) = LoweredNilCheck <void> v49 v43
      • v55 (205) = MOVQstore <mem> [352] v49 v53 v43
      • v51 (+3576) = ADDQconst <*guintptr> [352] v49 (gp[*guintptr])
      • v54 (205) = LoweredNilCheck <void> v51 v43
      • v62 (3577) = MOVQload <*m> [48] v46 v55 (m[*m])
      • v65 (243) = LoweredNilCheck <void> v59 v55
      • v58 (+3577) = LoweredNilCheck <void> v46 v55
      • v64 (+243) = Convert <muintptr> v62 v55
      • v66 (243) = MOVQstore <mem> [216] v46 v64 v55
      • v172 (143) = CMPQload <flags> [48] v4 v72 v66
      • v69 (+143) = LoweredNilCheck <void> v4 v66
    • NE v172b12 b13 (line 143)
    • b12: ← b11
      • v243 (?) = LEAQ <*uint8> {go.string."runtime.main not on m0"} v3
      • v41 (+144) = MOVQstore <mem> v2 v243 v66
      • v77 (+144) = MOVQstoreconst <mem> [val=22,off=8] v2 v41
      • v78 (144) = CALLstatic <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = CALLstatic <mem> {runtime.init} v66
      • v81 (+148) = CALLstatic <mem> {"".nanotime} [8] v80
      • v251 (148) = CMPQconstload <flags> [val=0,off=0] v2 v81
    • EQ v251b14 b15 (line 148)
    • b14: ← b13
      • v221 (?) = LEAQ <*uint8> {go.string."nanotime returning zero"} v3
      • v153 (+149) = MOVQstore <mem> v2 v221 v81
      • v88 (+149) = MOVQstoreconst <mem> [val=23,off=8] v2 v153
      • v89 (149) = CALLstatic <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b13
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (+153) = LEAQ <*bool> {needUnlock} v2
      • v93 (+153) = MOVBstoreconst <mem> {needUnlock} [val=1,off=0] v2 v91
      • v97 (+158) = MOVQstore <mem> [16] v2 v92 v93
      • v100 (+154) = MOVLstoreconst <mem> [val=8,off=0] v2 v97
      • v94 (?) = LEAQ <*func(*bool)> {"".main.func2·f} v3
      • v102 (154) = MOVQstore <mem> [8] v2 v94 v100
      • v103 (154) = CALLstatic <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b17: ← b15
      • v107 (+162) = CALLstatic <mem> {"".nanotime} [8] v103
      • v108 (162) = MOVQload <int64> v2 v107
      • v110 (162) = MOVQstore <mem> {"".runtimeInitTime} v3 v108 v107
      • v111 (+164) = CALLstatic <mem> {"".gcenable} v110
      • v112 (?) = LEAQ <*uint8> {type.chan bool} v3
      • v114 (+166) = MOVQstore <mem> v2 v112 v111
      • v117 (166) = MOVQstoreconst <mem> [val=0,off=8] v2 v114
      • v118 (166) = CALLstatic <mem> {runtime.makechan} [24] v117
      • v120 (166) = MOVQload <chan bool> [16] v2 v118
      • v252 (166) = CMPLconstload <flags> {runtime.writeBarrier} [val=0,off=0] v3 v118
    • NE v252b34 b6 (unlikely) (line 166)
    • b18: ← b15
      • v105 (154) = CALLstatic <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b52
      • v25 (+168) = CMPQconstload <flags> {_cgo_thread_start} [val=0,off=0] v3 v122
    • NE v25b23 b21 (line 168)
    • b20: ← b52 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = MOVQload <uintptr> {"".main_init·f} v3 v169
      • v168 (?) = LEAQ <*func()> {"".main_init·f} v3 (fn[func()])
      • v181 (?) = LEAQ <*bool> {"".isarchive} v3
      • v171 (189) = CALLclosure <mem> [0] v170 v168 v169
      • v173 (+190) = MOVQload <chan bool> {"".main_init_done} v3 v171
      • v175 (190) = MOVQstore <mem> v2 v173 v171
      • v176 (190) = CALLstatic <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v179 (+192) = MOVBstoreconst <mem> {needUnlock} [val=0,off=0] v2 v177
      • v180 (+193) = CALLstatic <mem> {"".unlockOSThread} v179
      • v147 (+195) = CMPBconstload <flags> [val=0,off=0] v181 v180
    • NE v147b31 b33 (line 195)
    • b21: ← b19
      • v203 (?) = LEAQ <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v129 (+169) = MOVQstore <mem> v2 v203 v122
      • v132 (+169) = MOVQstoreconst <mem> [val=25,off=8] v2 v129
      • v133 (169) = CALLstatic <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b23: ← b19
      • v249 (+172) = CMPQconstload <flags> {""._cgo_setenv} [val=0,off=0] v3 v122
    • NE v249b26 b25 (line 172)
    • b24: ← b26
      • v18 (+179) = CMPQconstload <flags> {_cgo_notify_runtime_init_done} [val=0,off=0] v3 v122
    • NE v18b30 b29 (line 179)
    • b25: ← b23
      • v189 (?) = LEAQ <*uint8> {go.string."_cgo_setenv missing"} v3
      • v38 (+173) = MOVQstore <mem> v2 v189 v122
      • v140 (+173) = MOVQstoreconst <mem> [val=19,off=8] v2 v38
      • v141 (173) = CALLstatic <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v167 (+175) = CMPQconstload <flags> {""._cgo_unsetenv} [val=0,off=0] v3 v122
    • NE v167b24 b27 (line 175)
    • b27: ← b26
      • v155 (?) = LEAQ <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v28 (+176) = MOVQstore <mem> v2 v155 v122
      • v148 (+176) = MOVQstoreconst <mem> [val=21,off=8] v2 v28
      • v149 (176) = CALLstatic <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b29: ← b24
      • v139 (?) = LEAQ <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v151 (+180) = MOVQstore <mem> v2 v139 v122
      • v156 (+180) = MOVQstoreconst <mem> [val=37,off=8] v2 v151
      • v157 (180) = CALLstatic <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = CALLstatic <mem> {"".startTemplateThread} v122
      • v161 (+185) = MOVQload <unsafe.Pointer> {_cgo_notify_runtime_init_done} v3 v159
      • v163 (185) = MOVQstore <mem> v2 v161 v159
      • v165 (185) = MOVQstoreconst <mem> [val=0,off=8] v2 v163
      • v166 (185) = CALLstatic <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = CALLstatic <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b33: ← b20
      • v183 (?) = LEAQ <*bool> {"".islibrary} v3
      • v79 (195) = CMPBconstload <flags> [val=0,off=0] v183 v180
    • NE v79b31 b35 (line 195)
    • b35: ← b33
      • v190 (+201) = MOVQload <uintptr> {"".main_main·f} v3 v180
      • v188 (?) = LEAQ <*func()> {"".main_main·f} v3 (fn[func()])
      • v191 (201) = CALLclosure <mem> [0] v190 v188 v180
      • v194 (+210) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v250 (210) = TESTL <flags> v196 v196
    • NE v250b36 b38 (line 210)
    • b36: ← b35
      • v115 (?) = MOVQconst <int> [0] (c[int])
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = MOVLatomicload <uint32,mem> {"".panicking} v3 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v63 (219) = TESTL <flags> v217 v217
    • NE v63b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v56 (+212) = CMPQconst <flags> [1000] v199
    • LT v56b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v52 (213) = TESTL <flags> v206 v206
    • EQ v52b43 b41 (line 213)
    • b41: ← b40
      • v209 (+216) = CALLstatic <mem> {"".Gosched} v205
      • v212 (+212) = ADDQconst <int> [1] v199 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b46: ← b37
      • v253 (220) = MOVOconst <int128> [0]
      • v223 (+220) = MOVOstore <mem> v2 v253 v216
      • v229 (220) = MOVWstoreconst <mem> [val=4104,off=16] v2 v223
      • v231 (220) = MOVQstoreconst <mem> [val=1,off=24] v2 v229
      • v232 (220) = CALLstatic <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = MOVLstoreconst <mem> [val=0,off=0] v2 v235
      • v237 (223) = CALLstatic <mem> {"".exit} [8] v236
      • v238 (?) = MOVQconst <*int32> [0] (x[*int32])
    • Plainb51 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b51: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
      • v240 (+226) = LoweredNilCheck <void> v238 v244
      • v241 (226) = MOVLstoreconst <mem> [val=0,off=0] v238 v244
    • Plainb51 (line +226)
    • b34: ← b17
      • v121 (?) = LEAQ <*chan bool> {"".main_init_done} v3
      • v40 (166) = LoweredWB <mem> {runtime.gcWriteBarrier} v121 v120 v118
    • Plainb52 (line 166)
    • b6: ← b17
      • v39 (166) = MOVQstore <mem> {"".main_init_done} v3 v120 v118
    • Plainb52 (line 166)
    • b52: ← b34 b6
      • v122 (166) = Phi <mem> v40 v39
      • v123 (?) = LEAQ <*bool> {"".iscgo} v3
      • v248 (+167) = CMPBconstload <flags> [val=0,off=0] v123 v122
    • NE v248b19 b20 (line 167)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • phi tighten [5608 ns]

    • b11:
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v23 (?) = LEAQ <*func()> {"".main.func1·f} v3
      • v72 (?) = LEAQ <*m> {"".m0} v3
      • v1 (?) = InitMem <mem>
      • v4 (+111) = LoweredGetG <*g> v1 (g[*g])
      • v8 (+115) = MOVQload <*m> [48] v4 v1
      • v11 (115) = MOVQload <*g> v8 v1
      • v14 (115) = MOVQstoreconst <mem> [val=0,off=304] v11 v1
      • v19 (+121) = MOVQstoreconst <mem> {"".maxstacksize} [val=1000000000,off=0] v3 v14
      • v22 (+127) = MOVBstoreconst <mem> {"".mainStarted} [val=1,off=0] v3 v19
      • v26 (+130) = MOVQstore <mem> v2 v23 v22
      • v27 (130) = CALLstatic <mem> {"".systemstack} [8] v26
      • v29 (+3614) = LoweredGetG <*g> v27
      • v32 (3614) = MOVQload <*m> [48] v29 v27
      • v43 (3614) = ADDLconstmodify <mem> [val=1,off=620] v32 v27
      • v9 (115) = LoweredNilCheck <void> v8 v1
      • v12 (115) = LoweredNilCheck <void> v11 v1
      • v33 (3614) = LoweredNilCheck <void> v32 v27
      • v46 (+3575) = LoweredGetG <*g> v43 (_g_[*g], g[*g])
      • v59 (3577) = ADDQconst <*muintptr> [216] v46 (mp[*muintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v49 (3576) = MOVQload <*m> [48] v46 v43
      • v50 (3576) = LoweredNilCheck <void> v49 v43
      • v55 (205) = MOVQstore <mem> [352] v49 v53 v43
      • v51 (+3576) = ADDQconst <*guintptr> [352] v49 (gp[*guintptr])
      • v54 (205) = LoweredNilCheck <void> v51 v43
      • v62 (3577) = MOVQload <*m> [48] v46 v55 (m[*m])
      • v65 (243) = LoweredNilCheck <void> v59 v55
      • v58 (+3577) = LoweredNilCheck <void> v46 v55
      • v64 (+243) = Convert <muintptr> v62 v55
      • v66 (243) = MOVQstore <mem> [216] v46 v64 v55
      • v172 (143) = CMPQload <flags> [48] v4 v72 v66
      • v69 (+143) = LoweredNilCheck <void> v4 v66
    • NE v172b12 b13 (line 143)
    • b12: ← b11
      • v243 (?) = LEAQ <*uint8> {go.string."runtime.main not on m0"} v3
      • v41 (+144) = MOVQstore <mem> v2 v243 v66
      • v77 (+144) = MOVQstoreconst <mem> [val=22,off=8] v2 v41
      • v78 (144) = CALLstatic <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = CALLstatic <mem> {runtime.init} v66
      • v81 (+148) = CALLstatic <mem> {"".nanotime} [8] v80
      • v251 (148) = CMPQconstload <flags> [val=0,off=0] v2 v81
    • EQ v251b14 b15 (line 148)
    • b14: ← b13
      • v221 (?) = LEAQ <*uint8> {go.string."nanotime returning zero"} v3
      • v153 (+149) = MOVQstore <mem> v2 v221 v81
      • v88 (+149) = MOVQstoreconst <mem> [val=23,off=8] v2 v153
      • v89 (149) = CALLstatic <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b13
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (+153) = LEAQ <*bool> {needUnlock} v2
      • v93 (+153) = MOVBstoreconst <mem> {needUnlock} [val=1,off=0] v2 v91
      • v97 (+158) = MOVQstore <mem> [16] v2 v92 v93
      • v100 (+154) = MOVLstoreconst <mem> [val=8,off=0] v2 v97
      • v94 (?) = LEAQ <*func(*bool)> {"".main.func2·f} v3
      • v102 (154) = MOVQstore <mem> [8] v2 v94 v100
      • v103 (154) = CALLstatic <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b17: ← b15
      • v107 (+162) = CALLstatic <mem> {"".nanotime} [8] v103
      • v108 (162) = MOVQload <int64> v2 v107
      • v110 (162) = MOVQstore <mem> {"".runtimeInitTime} v3 v108 v107
      • v111 (+164) = CALLstatic <mem> {"".gcenable} v110
      • v112 (?) = LEAQ <*uint8> {type.chan bool} v3
      • v114 (+166) = MOVQstore <mem> v2 v112 v111
      • v117 (166) = MOVQstoreconst <mem> [val=0,off=8] v2 v114
      • v118 (166) = CALLstatic <mem> {runtime.makechan} [24] v117
      • v120 (166) = MOVQload <chan bool> [16] v2 v118
      • v252 (166) = CMPLconstload <flags> {runtime.writeBarrier} [val=0,off=0] v3 v118
    • NE v252b34 b6 (unlikely) (line 166)
    • b18: ← b15
      • v105 (154) = CALLstatic <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b52
      • v25 (+168) = CMPQconstload <flags> {_cgo_thread_start} [val=0,off=0] v3 v122
    • NE v25b23 b21 (line 168)
    • b20: ← b52 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = MOVQload <uintptr> {"".main_init·f} v3 v169
      • v168 (?) = LEAQ <*func()> {"".main_init·f} v3 (fn[func()])
      • v181 (?) = LEAQ <*bool> {"".isarchive} v3
      • v171 (189) = CALLclosure <mem> [0] v170 v168 v169
      • v173 (+190) = MOVQload <chan bool> {"".main_init_done} v3 v171
      • v175 (190) = MOVQstore <mem> v2 v173 v171
      • v176 (190) = CALLstatic <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v179 (+192) = MOVBstoreconst <mem> {needUnlock} [val=0,off=0] v2 v177
      • v180 (+193) = CALLstatic <mem> {"".unlockOSThread} v179
      • v147 (+195) = CMPBconstload <flags> [val=0,off=0] v181 v180
    • NE v147b31 b33 (line 195)
    • b21: ← b19
      • v203 (?) = LEAQ <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v129 (+169) = MOVQstore <mem> v2 v203 v122
      • v132 (+169) = MOVQstoreconst <mem> [val=25,off=8] v2 v129
      • v133 (169) = CALLstatic <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b23: ← b19
      • v249 (+172) = CMPQconstload <flags> {""._cgo_setenv} [val=0,off=0] v3 v122
    • NE v249b26 b25 (line 172)
    • b24: ← b26
      • v18 (+179) = CMPQconstload <flags> {_cgo_notify_runtime_init_done} [val=0,off=0] v3 v122
    • NE v18b30 b29 (line 179)
    • b25: ← b23
      • v189 (?) = LEAQ <*uint8> {go.string."_cgo_setenv missing"} v3
      • v38 (+173) = MOVQstore <mem> v2 v189 v122
      • v140 (+173) = MOVQstoreconst <mem> [val=19,off=8] v2 v38
      • v141 (173) = CALLstatic <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v167 (+175) = CMPQconstload <flags> {""._cgo_unsetenv} [val=0,off=0] v3 v122
    • NE v167b24 b27 (line 175)
    • b27: ← b26
      • v155 (?) = LEAQ <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v28 (+176) = MOVQstore <mem> v2 v155 v122
      • v148 (+176) = MOVQstoreconst <mem> [val=21,off=8] v2 v28
      • v149 (176) = CALLstatic <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b29: ← b24
      • v139 (?) = LEAQ <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v151 (+180) = MOVQstore <mem> v2 v139 v122
      • v156 (+180) = MOVQstoreconst <mem> [val=37,off=8] v2 v151
      • v157 (180) = CALLstatic <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = CALLstatic <mem> {"".startTemplateThread} v122
      • v161 (+185) = MOVQload <unsafe.Pointer> {_cgo_notify_runtime_init_done} v3 v159
      • v163 (185) = MOVQstore <mem> v2 v161 v159
      • v165 (185) = MOVQstoreconst <mem> [val=0,off=8] v2 v163
      • v166 (185) = CALLstatic <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = CALLstatic <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b33: ← b20
      • v183 (?) = LEAQ <*bool> {"".islibrary} v3
      • v79 (195) = CMPBconstload <flags> [val=0,off=0] v183 v180
    • NE v79b31 b35 (line 195)
    • b35: ← b33
      • v190 (+201) = MOVQload <uintptr> {"".main_main·f} v3 v180
      • v188 (?) = LEAQ <*func()> {"".main_main·f} v3 (fn[func()])
      • v191 (201) = CALLclosure <mem> [0] v190 v188 v180
      • v194 (+210) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v250 (210) = TESTL <flags> v196 v196
    • NE v250b36 b38 (line 210)
    • b36: ← b35
      • v115 (?) = MOVQconst <int> [0] (c[int])
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = MOVLatomicload <uint32,mem> {"".panicking} v3 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v63 (219) = TESTL <flags> v217 v217
    • NE v63b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v56 (+212) = CMPQconst <flags> [1000] v199
    • LT v56b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v52 (213) = TESTL <flags> v206 v206
    • EQ v52b43 b41 (line 213)
    • b41: ← b40
      • v209 (+216) = CALLstatic <mem> {"".Gosched} v205
      • v212 (+212) = ADDQconst <int> [1] v199 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b46: ← b37
      • v253 (220) = MOVOconst <int128> [0]
      • v223 (+220) = MOVOstore <mem> v2 v253 v216
      • v229 (220) = MOVWstoreconst <mem> [val=4104,off=16] v2 v223
      • v231 (220) = MOVQstoreconst <mem> [val=1,off=24] v2 v229
      • v232 (220) = CALLstatic <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = MOVLstoreconst <mem> [val=0,off=0] v2 v235
      • v237 (223) = CALLstatic <mem> {"".exit} [8] v236
      • v238 (?) = MOVQconst <*int32> [0] (x[*int32])
    • Plainb51 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b51: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
      • v240 (+226) = LoweredNilCheck <void> v238 v244
      • v241 (226) = MOVLstoreconst <mem> [val=0,off=0] v238 v244
    • Plainb51 (line +226)
    • b34: ← b17
      • v121 (?) = LEAQ <*chan bool> {"".main_init_done} v3
      • v40 (166) = LoweredWB <mem> {runtime.gcWriteBarrier} v121 v120 v118
    • Plainb52 (line 166)
    • b6: ← b17
      • v39 (166) = MOVQstore <mem> {"".main_init_done} v3 v120 v118
    • Plainb52 (line 166)
    • b52: ← b34 b6
      • v122 (166) = Phi <mem> v40 v39
      • v123 (?) = LEAQ <*bool> {"".iscgo} v3
      • v248 (+167) = CMPBconstload <flags> [val=0,off=0] v123 v122
    • NE v248b19 b20 (line 167)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • late deadcode [75527 ns]

    • b11:
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v23 (?) = LEAQ <*func()> {"".main.func1·f} v3
      • v72 (?) = LEAQ <*m> {"".m0} v3
      • v1 (?) = InitMem <mem>
      • v4 (+111) = LoweredGetG <*g> v1 (g[*g])
      • v8 (+115) = MOVQload <*m> [48] v4 v1
      • v11 (115) = MOVQload <*g> v8 v1
      • v14 (115) = MOVQstoreconst <mem> [val=0,off=304] v11 v1
      • v19 (+121) = MOVQstoreconst <mem> {"".maxstacksize} [val=1000000000,off=0] v3 v14
      • v22 (+127) = MOVBstoreconst <mem> {"".mainStarted} [val=1,off=0] v3 v19
      • v26 (+130) = MOVQstore <mem> v2 v23 v22
      • v27 (130) = CALLstatic <mem> {"".systemstack} [8] v26
      • v29 (+3614) = LoweredGetG <*g> v27
      • v32 (3614) = MOVQload <*m> [48] v29 v27
      • v43 (3614) = ADDLconstmodify <mem> [val=1,off=620] v32 v27
      • v9 (115) = LoweredNilCheck <void> v8 v1
      • v12 (115) = LoweredNilCheck <void> v11 v1
      • v33 (3614) = LoweredNilCheck <void> v32 v27
      • v46 (+3575) = LoweredGetG <*g> v43 (_g_[*g], g[*g])
      • v59 (3577) = ADDQconst <*muintptr> [216] v46 (mp[*muintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v49 (3576) = MOVQload <*m> [48] v46 v43
      • v50 (3576) = LoweredNilCheck <void> v49 v43
      • v55 (205) = MOVQstore <mem> [352] v49 v53 v43
      • v51 (+3576) = ADDQconst <*guintptr> [352] v49 (gp[*guintptr])
      • v54 (205) = LoweredNilCheck <void> v51 v43
      • v62 (3577) = MOVQload <*m> [48] v46 v55 (m[*m])
      • v65 (243) = LoweredNilCheck <void> v59 v55
      • v58 (+3577) = LoweredNilCheck <void> v46 v55
      • v64 (+243) = Convert <muintptr> v62 v55
      • v66 (243) = MOVQstore <mem> [216] v46 v64 v55
      • v172 (143) = CMPQload <flags> [48] v4 v72 v66
      • v69 (+143) = LoweredNilCheck <void> v4 v66
    • NE v172b12 b13 (line 143)
    • b12: ← b11
      • v243 (?) = LEAQ <*uint8> {go.string."runtime.main not on m0"} v3
      • v41 (+144) = MOVQstore <mem> v2 v243 v66
      • v77 (+144) = MOVQstoreconst <mem> [val=22,off=8] v2 v41
      • v78 (144) = CALLstatic <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = CALLstatic <mem> {runtime.init} v66
      • v81 (+148) = CALLstatic <mem> {"".nanotime} [8] v80
      • v251 (148) = CMPQconstload <flags> [val=0,off=0] v2 v81
    • EQ v251b14 b15 (line 148)
    • b14: ← b13
      • v221 (?) = LEAQ <*uint8> {go.string."nanotime returning zero"} v3
      • v153 (+149) = MOVQstore <mem> v2 v221 v81
      • v88 (+149) = MOVQstoreconst <mem> [val=23,off=8] v2 v153
      • v89 (149) = CALLstatic <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b13
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (+153) = LEAQ <*bool> {needUnlock} v2
      • v93 (+153) = MOVBstoreconst <mem> {needUnlock} [val=1,off=0] v2 v91
      • v97 (+158) = MOVQstore <mem> [16] v2 v92 v93
      • v100 (+154) = MOVLstoreconst <mem> [val=8,off=0] v2 v97
      • v94 (?) = LEAQ <*func(*bool)> {"".main.func2·f} v3
      • v102 (154) = MOVQstore <mem> [8] v2 v94 v100
      • v103 (154) = CALLstatic <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b17: ← b15
      • v107 (+162) = CALLstatic <mem> {"".nanotime} [8] v103
      • v108 (162) = MOVQload <int64> v2 v107
      • v110 (162) = MOVQstore <mem> {"".runtimeInitTime} v3 v108 v107
      • v111 (+164) = CALLstatic <mem> {"".gcenable} v110
      • v112 (?) = LEAQ <*uint8> {type.chan bool} v3
      • v114 (+166) = MOVQstore <mem> v2 v112 v111
      • v117 (166) = MOVQstoreconst <mem> [val=0,off=8] v2 v114
      • v118 (166) = CALLstatic <mem> {runtime.makechan} [24] v117
      • v120 (166) = MOVQload <chan bool> [16] v2 v118
      • v252 (166) = CMPLconstload <flags> {runtime.writeBarrier} [val=0,off=0] v3 v118
    • NE v252b34 b6 (unlikely) (line 166)
    • b18: ← b15
      • v105 (154) = CALLstatic <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b52
      • v25 (+168) = CMPQconstload <flags> {_cgo_thread_start} [val=0,off=0] v3 v122
    • NE v25b23 b21 (line 168)
    • b20: ← b52 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = MOVQload <uintptr> {"".main_init·f} v3 v169
      • v168 (?) = LEAQ <*func()> {"".main_init·f} v3 (fn[func()])
      • v181 (?) = LEAQ <*bool> {"".isarchive} v3
      • v171 (189) = CALLclosure <mem> [0] v170 v168 v169
      • v173 (+190) = MOVQload <chan bool> {"".main_init_done} v3 v171
      • v175 (190) = MOVQstore <mem> v2 v173 v171
      • v176 (190) = CALLstatic <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v179 (+192) = MOVBstoreconst <mem> {needUnlock} [val=0,off=0] v2 v177
      • v180 (+193) = CALLstatic <mem> {"".unlockOSThread} v179
      • v147 (+195) = CMPBconstload <flags> [val=0,off=0] v181 v180
    • NE v147b31 b33 (line 195)
    • b21: ← b19
      • v203 (?) = LEAQ <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v129 (+169) = MOVQstore <mem> v2 v203 v122
      • v132 (+169) = MOVQstoreconst <mem> [val=25,off=8] v2 v129
      • v133 (169) = CALLstatic <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b23: ← b19
      • v249 (+172) = CMPQconstload <flags> {""._cgo_setenv} [val=0,off=0] v3 v122
    • NE v249b26 b25 (line 172)
    • b24: ← b26
      • v18 (+179) = CMPQconstload <flags> {_cgo_notify_runtime_init_done} [val=0,off=0] v3 v122
    • NE v18b30 b29 (line 179)
    • b25: ← b23
      • v189 (?) = LEAQ <*uint8> {go.string."_cgo_setenv missing"} v3
      • v38 (+173) = MOVQstore <mem> v2 v189 v122
      • v140 (+173) = MOVQstoreconst <mem> [val=19,off=8] v2 v38
      • v141 (173) = CALLstatic <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v167 (+175) = CMPQconstload <flags> {""._cgo_unsetenv} [val=0,off=0] v3 v122
    • NE v167b24 b27 (line 175)
    • b27: ← b26
      • v155 (?) = LEAQ <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v28 (+176) = MOVQstore <mem> v2 v155 v122
      • v148 (+176) = MOVQstoreconst <mem> [val=21,off=8] v2 v28
      • v149 (176) = CALLstatic <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b29: ← b24
      • v139 (?) = LEAQ <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v151 (+180) = MOVQstore <mem> v2 v139 v122
      • v156 (+180) = MOVQstoreconst <mem> [val=37,off=8] v2 v151
      • v157 (180) = CALLstatic <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = CALLstatic <mem> {"".startTemplateThread} v122
      • v161 (+185) = MOVQload <unsafe.Pointer> {_cgo_notify_runtime_init_done} v3 v159
      • v163 (185) = MOVQstore <mem> v2 v161 v159
      • v165 (185) = MOVQstoreconst <mem> [val=0,off=8] v2 v163
      • v166 (185) = CALLstatic <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b20 b33
      • v187 (+198) = CALLstatic <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b33: ← b20
      • v183 (?) = LEAQ <*bool> {"".islibrary} v3
      • v79 (195) = CMPBconstload <flags> [val=0,off=0] v183 v180
    • NE v79b31 b35 (line 195)
    • b35: ← b33
      • v190 (+201) = MOVQload <uintptr> {"".main_main·f} v3 v180
      • v188 (?) = LEAQ <*func()> {"".main_main·f} v3 (fn[func()])
      • v191 (201) = CALLclosure <mem> [0] v190 v188 v180
      • v194 (+210) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v250 (210) = TESTL <flags> v196 v196
    • NE v250b36 b38 (line 210)
    • b36: ← b35
      • v115 (?) = MOVQconst <int> [0] (c[int])
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = MOVLatomicload <uint32,mem> {"".panicking} v3 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v63 (219) = TESTL <flags> v217 v217
    • NE v63b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v56 (+212) = CMPQconst <flags> [1000] v199
    • LT v56b40 b42 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v52 (213) = TESTL <flags> v206 v206
    • EQ v52b43 b41 (line 213)
    • b41: ← b40
      • v209 (+216) = CALLstatic <mem> {"".Gosched} v205
      • v212 (+212) = ADDQconst <int> [1] v199 (c[int])
    • Plainb39 (line 212)
    • b42: ← b39 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b46: ← b37
      • v253 (220) = MOVOconst <int128> [0]
      • v223 (+220) = MOVOstore <mem> v2 v253 v216
      • v229 (220) = MOVWstoreconst <mem> [val=4104,off=16] v2 v223
      • v231 (220) = MOVQstoreconst <mem> [val=1,off=24] v2 v229
      • v232 (220) = CALLstatic <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = MOVLstoreconst <mem> [val=0,off=0] v2 v235
      • v237 (223) = CALLstatic <mem> {"".exit} [8] v236
      • v238 (?) = MOVQconst <*int32> [0] (x[*int32])
    • Plainb51 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b51: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
      • v240 (+226) = LoweredNilCheck <void> v238 v244
      • v241 (226) = MOVLstoreconst <mem> [val=0,off=0] v238 v244
    • Plainb51 (line +226)
    • b34: ← b17
      • v121 (?) = LEAQ <*chan bool> {"".main_init_done} v3
      • v40 (166) = LoweredWB <mem> {runtime.gcWriteBarrier} v121 v120 v118
    • Plainb52 (line 166)
    • b6: ← b17
      • v39 (166) = MOVQstore <mem> {"".main_init_done} v3 v120 v118
    • Plainb52 (line 166)
    • b52: ← b34 b6
      • v122 (166) = Phi <mem> v40 v39
      • v123 (?) = LEAQ <*bool> {"".iscgo} v3
      • v248 (+167) = CMPBconstload <flags> [val=0,off=0] v123 v122
    • NE v248b19 b20 (line 167)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • critical [6138 ns]

    • b11:
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v23 (?) = LEAQ <*func()> {"".main.func1·f} v3
      • v72 (?) = LEAQ <*m> {"".m0} v3
      • v1 (?) = InitMem <mem>
      • v4 (+111) = LoweredGetG <*g> v1 (g[*g])
      • v8 (+115) = MOVQload <*m> [48] v4 v1
      • v11 (115) = MOVQload <*g> v8 v1
      • v14 (115) = MOVQstoreconst <mem> [val=0,off=304] v11 v1
      • v19 (+121) = MOVQstoreconst <mem> {"".maxstacksize} [val=1000000000,off=0] v3 v14
      • v22 (+127) = MOVBstoreconst <mem> {"".mainStarted} [val=1,off=0] v3 v19
      • v26 (+130) = MOVQstore <mem> v2 v23 v22
      • v27 (130) = CALLstatic <mem> {"".systemstack} [8] v26
      • v29 (+3614) = LoweredGetG <*g> v27
      • v32 (3614) = MOVQload <*m> [48] v29 v27
      • v43 (3614) = ADDLconstmodify <mem> [val=1,off=620] v32 v27
      • v9 (115) = LoweredNilCheck <void> v8 v1
      • v12 (115) = LoweredNilCheck <void> v11 v1
      • v33 (3614) = LoweredNilCheck <void> v32 v27
      • v46 (+3575) = LoweredGetG <*g> v43 (_g_[*g], g[*g])
      • v59 (3577) = ADDQconst <*muintptr> [216] v46 (mp[*muintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v49 (3576) = MOVQload <*m> [48] v46 v43
      • v50 (3576) = LoweredNilCheck <void> v49 v43
      • v55 (205) = MOVQstore <mem> [352] v49 v53 v43
      • v51 (+3576) = ADDQconst <*guintptr> [352] v49 (gp[*guintptr])
      • v54 (205) = LoweredNilCheck <void> v51 v43
      • v62 (3577) = MOVQload <*m> [48] v46 v55 (m[*m])
      • v65 (243) = LoweredNilCheck <void> v59 v55
      • v58 (+3577) = LoweredNilCheck <void> v46 v55
      • v64 (+243) = Convert <muintptr> v62 v55
      • v66 (243) = MOVQstore <mem> [216] v46 v64 v55
      • v172 (143) = CMPQload <flags> [48] v4 v72 v66
      • v69 (+143) = LoweredNilCheck <void> v4 v66
    • NE v172b12 b13 (line 143)
    • b12: ← b11
      • v243 (?) = LEAQ <*uint8> {go.string."runtime.main not on m0"} v3
      • v41 (+144) = MOVQstore <mem> v2 v243 v66
      • v77 (+144) = MOVQstoreconst <mem> [val=22,off=8] v2 v41
      • v78 (144) = CALLstatic <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = CALLstatic <mem> {runtime.init} v66
      • v81 (+148) = CALLstatic <mem> {"".nanotime} [8] v80
      • v251 (148) = CMPQconstload <flags> [val=0,off=0] v2 v81
    • EQ v251b14 b15 (line 148)
    • b14: ← b13
      • v221 (?) = LEAQ <*uint8> {go.string."nanotime returning zero"} v3
      • v153 (+149) = MOVQstore <mem> v2 v221 v81
      • v88 (+149) = MOVQstoreconst <mem> [val=23,off=8] v2 v153
      • v89 (149) = CALLstatic <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b13
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (+153) = LEAQ <*bool> {needUnlock} v2
      • v93 (+153) = MOVBstoreconst <mem> {needUnlock} [val=1,off=0] v2 v91
      • v97 (+158) = MOVQstore <mem> [16] v2 v92 v93
      • v100 (+154) = MOVLstoreconst <mem> [val=8,off=0] v2 v97
      • v94 (?) = LEAQ <*func(*bool)> {"".main.func2·f} v3
      • v102 (154) = MOVQstore <mem> [8] v2 v94 v100
      • v103 (154) = CALLstatic <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b17: ← b15
      • v107 (+162) = CALLstatic <mem> {"".nanotime} [8] v103
      • v108 (162) = MOVQload <int64> v2 v107
      • v110 (162) = MOVQstore <mem> {"".runtimeInitTime} v3 v108 v107
      • v111 (+164) = CALLstatic <mem> {"".gcenable} v110
      • v112 (?) = LEAQ <*uint8> {type.chan bool} v3
      • v114 (+166) = MOVQstore <mem> v2 v112 v111
      • v117 (166) = MOVQstoreconst <mem> [val=0,off=8] v2 v114
      • v118 (166) = CALLstatic <mem> {runtime.makechan} [24] v117
      • v120 (166) = MOVQload <chan bool> [16] v2 v118
      • v252 (166) = CMPLconstload <flags> {runtime.writeBarrier} [val=0,off=0] v3 v118
    • NE v252b34 b6 (unlikely) (line 166)
    • b18: ← b15
      • v105 (154) = CALLstatic <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b52
      • v25 (+168) = CMPQconstload <flags> {_cgo_thread_start} [val=0,off=0] v3 v122
    • NE v25b23 b21 (line 168)
    • b20: ← b50 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = MOVQload <uintptr> {"".main_init·f} v3 v169
      • v168 (?) = LEAQ <*func()> {"".main_init·f} v3 (fn[func()])
      • v181 (?) = LEAQ <*bool> {"".isarchive} v3
      • v171 (189) = CALLclosure <mem> [0] v170 v168 v169
      • v173 (+190) = MOVQload <chan bool> {"".main_init_done} v3 v171
      • v175 (190) = MOVQstore <mem> v2 v173 v171
      • v176 (190) = CALLstatic <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v179 (+192) = MOVBstoreconst <mem> {needUnlock} [val=0,off=0] v2 v177
      • v180 (+193) = CALLstatic <mem> {"".unlockOSThread} v179
      • v147 (+195) = CMPBconstload <flags> [val=0,off=0] v181 v180
    • NE v147b49 b33 (line 195)
    • b21: ← b19
      • v203 (?) = LEAQ <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v129 (+169) = MOVQstore <mem> v2 v203 v122
      • v132 (+169) = MOVQstoreconst <mem> [val=25,off=8] v2 v129
      • v133 (169) = CALLstatic <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b23: ← b19
      • v249 (+172) = CMPQconstload <flags> {""._cgo_setenv} [val=0,off=0] v3 v122
    • NE v249b26 b25 (line 172)
    • b24: ← b26
      • v18 (+179) = CMPQconstload <flags> {_cgo_notify_runtime_init_done} [val=0,off=0] v3 v122
    • NE v18b30 b29 (line 179)
    • b25: ← b23
      • v189 (?) = LEAQ <*uint8> {go.string."_cgo_setenv missing"} v3
      • v38 (+173) = MOVQstore <mem> v2 v189 v122
      • v140 (+173) = MOVQstoreconst <mem> [val=19,off=8] v2 v38
      • v141 (173) = CALLstatic <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v167 (+175) = CMPQconstload <flags> {""._cgo_unsetenv} [val=0,off=0] v3 v122
    • NE v167b24 b27 (line 175)
    • b27: ← b26
      • v155 (?) = LEAQ <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v28 (+176) = MOVQstore <mem> v2 v155 v122
      • v148 (+176) = MOVQstoreconst <mem> [val=21,off=8] v2 v28
      • v149 (176) = CALLstatic <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b29: ← b24
      • v139 (?) = LEAQ <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v151 (+180) = MOVQstore <mem> v2 v139 v122
      • v156 (+180) = MOVQstoreconst <mem> [val=37,off=8] v2 v151
      • v157 (180) = CALLstatic <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = CALLstatic <mem> {"".startTemplateThread} v122
      • v161 (+185) = MOVQload <unsafe.Pointer> {_cgo_notify_runtime_init_done} v3 v159
      • v163 (185) = MOVQstore <mem> v2 v161 v159
      • v165 (185) = MOVQstoreconst <mem> [val=0,off=8] v2 v163
      • v166 (185) = CALLstatic <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b49 b45
      • v187 (+198) = CALLstatic <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b33: ← b20
      • v183 (?) = LEAQ <*bool> {"".islibrary} v3
      • v79 (195) = CMPBconstload <flags> [val=0,off=0] v183 v180
    • NE v79b45 b35 (line 195)
    • b35: ← b33
      • v190 (+201) = MOVQload <uintptr> {"".main_main·f} v3 v180
      • v188 (?) = LEAQ <*func()> {"".main_main·f} v3 (fn[func()])
      • v191 (201) = CALLclosure <mem> [0] v190 v188 v180
      • v194 (+210) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v250 (210) = TESTL <flags> v196 v196
    • NE v250b36 b38 (line 210)
    • b36: ← b35
      • v115 (?) = MOVQconst <int> [0] (c[int])
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = MOVLatomicload <uint32,mem> {"".panicking} v3 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v63 (219) = TESTL <flags> v217 v217
    • NE v63b46 b48 (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v56 (+212) = CMPQconst <flags> [1000] v199
    • LT v56b40 b44 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v52 (213) = TESTL <flags> v206 v206
    • EQ v52b43 b41 (line 213)
    • b41: ← b40
      • v209 (+216) = CALLstatic <mem> {"".Gosched} v205
      • v212 (+212) = ADDQconst <int> [1] v199 (c[int])
    • Plainb39 (line 212)
    • b42: ← b44 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b46: ← b37
      • v253 (220) = MOVOconst <int128> [0]
      • v223 (+220) = MOVOstore <mem> v2 v253 v216
      • v229 (220) = MOVWstoreconst <mem> [val=4104,off=16] v2 v223
      • v231 (220) = MOVQstoreconst <mem> [val=1,off=24] v2 v229
      • v232 (220) = CALLstatic <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = MOVLstoreconst <mem> [val=0,off=0] v2 v235
      • v237 (223) = CALLstatic <mem> {"".exit} [8] v236
      • v238 (?) = MOVQconst <*int32> [0] (x[*int32])
    • Plainb51 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b51: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
      • v240 (+226) = LoweredNilCheck <void> v238 v244
      • v241 (226) = MOVLstoreconst <mem> [val=0,off=0] v238 v244
    • Plainb51 (line +226)
    • b34: ← b17
      • v121 (?) = LEAQ <*chan bool> {"".main_init_done} v3
      • v40 (166) = LoweredWB <mem> {runtime.gcWriteBarrier} v121 v120 v118
    • Plainb52 (line 166)
    • b6: ← b17
      • v39 (166) = MOVQstore <mem> {"".main_init_done} v3 v120 v118
    • Plainb52 (line 166)
    • b52: ← b34 b6
      • v122 (166) = Phi <mem> v40 v39
      • v123 (?) = LEAQ <*bool> {"".iscgo} v3
      • v248 (+167) = CMPBconstload <flags> [val=0,off=0] v123 v122
    • NE v248b19 b50 (line 167)
    • b50: ← b52
    • Plainb20 (line 167)
    • b49: ← b20
    • Plainb31 (line 195)
    • b45: ← b33
    • Plainb31 (line 195)
    • b44: ← b39
    • Plainb42 (line 212)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • likelyadjust [72032 ns]

    • b11:
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v23 (?) = LEAQ <*func()> {"".main.func1·f} v3
      • v72 (?) = LEAQ <*m> {"".m0} v3
      • v1 (?) = InitMem <mem>
      • v4 (+111) = LoweredGetG <*g> v1 (g[*g])
      • v8 (+115) = MOVQload <*m> [48] v4 v1
      • v11 (115) = MOVQload <*g> v8 v1
      • v14 (115) = MOVQstoreconst <mem> [val=0,off=304] v11 v1
      • v19 (+121) = MOVQstoreconst <mem> {"".maxstacksize} [val=1000000000,off=0] v3 v14
      • v22 (+127) = MOVBstoreconst <mem> {"".mainStarted} [val=1,off=0] v3 v19
      • v26 (+130) = MOVQstore <mem> v2 v23 v22
      • v27 (130) = CALLstatic <mem> {"".systemstack} [8] v26
      • v29 (+3614) = LoweredGetG <*g> v27
      • v32 (3614) = MOVQload <*m> [48] v29 v27
      • v43 (3614) = ADDLconstmodify <mem> [val=1,off=620] v32 v27
      • v9 (115) = LoweredNilCheck <void> v8 v1
      • v12 (115) = LoweredNilCheck <void> v11 v1
      • v33 (3614) = LoweredNilCheck <void> v32 v27
      • v46 (+3575) = LoweredGetG <*g> v43 (_g_[*g], g[*g])
      • v59 (3577) = ADDQconst <*muintptr> [216] v46 (mp[*muintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v49 (3576) = MOVQload <*m> [48] v46 v43
      • v50 (3576) = LoweredNilCheck <void> v49 v43
      • v55 (205) = MOVQstore <mem> [352] v49 v53 v43
      • v51 (+3576) = ADDQconst <*guintptr> [352] v49 (gp[*guintptr])
      • v54 (205) = LoweredNilCheck <void> v51 v43
      • v62 (3577) = MOVQload <*m> [48] v46 v55 (m[*m])
      • v65 (243) = LoweredNilCheck <void> v59 v55
      • v58 (+3577) = LoweredNilCheck <void> v46 v55
      • v64 (+243) = Convert <muintptr> v62 v55
      • v66 (243) = MOVQstore <mem> [216] v46 v64 v55
      • v172 (143) = CMPQload <flags> [48] v4 v72 v66
      • v69 (+143) = LoweredNilCheck <void> v4 v66
    • NE v172b12 b13 (unlikely) (line 143)
    • b12: ← b11
      • v243 (?) = LEAQ <*uint8> {go.string."runtime.main not on m0"} v3
      • v41 (+144) = MOVQstore <mem> v2 v243 v66
      • v77 (+144) = MOVQstoreconst <mem> [val=22,off=8] v2 v41
      • v78 (144) = CALLstatic <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
    • b13: ← b11
      • v80 (+147) = CALLstatic <mem> {runtime.init} v66
      • v81 (+148) = CALLstatic <mem> {"".nanotime} [8] v80
      • v251 (148) = CMPQconstload <flags> [val=0,off=0] v2 v81
    • EQ v251b14 b15 (unlikely) (line 148)
    • b14: ← b13
      • v221 (?) = LEAQ <*uint8> {go.string."nanotime returning zero"} v3
      • v153 (+149) = MOVQstore <mem> v2 v221 v81
      • v88 (+149) = MOVQstoreconst <mem> [val=23,off=8] v2 v153
      • v89 (149) = CALLstatic <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b15: ← b13
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (+153) = LEAQ <*bool> {needUnlock} v2
      • v93 (+153) = MOVBstoreconst <mem> {needUnlock} [val=1,off=0] v2 v91
      • v97 (+158) = MOVQstore <mem> [16] v2 v92 v93
      • v100 (+154) = MOVLstoreconst <mem> [val=8,off=0] v2 v97
      • v94 (?) = LEAQ <*func(*bool)> {"".main.func2·f} v3
      • v102 (154) = MOVQstore <mem> [8] v2 v94 v100
      • v103 (154) = CALLstatic <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b17: ← b15
      • v107 (+162) = CALLstatic <mem> {"".nanotime} [8] v103
      • v108 (162) = MOVQload <int64> v2 v107
      • v110 (162) = MOVQstore <mem> {"".runtimeInitTime} v3 v108 v107
      • v111 (+164) = CALLstatic <mem> {"".gcenable} v110
      • v112 (?) = LEAQ <*uint8> {type.chan bool} v3
      • v114 (+166) = MOVQstore <mem> v2 v112 v111
      • v117 (166) = MOVQstoreconst <mem> [val=0,off=8] v2 v114
      • v118 (166) = CALLstatic <mem> {runtime.makechan} [24] v117
      • v120 (166) = MOVQload <chan bool> [16] v2 v118
      • v252 (166) = CMPLconstload <flags> {runtime.writeBarrier} [val=0,off=0] v3 v118
    • NE v252b34 b6 (unlikely) (line 166)
    • b18: ← b15
      • v105 (154) = CALLstatic <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b19: ← b52
      • v25 (+168) = CMPQconstload <flags> {_cgo_thread_start} [val=0,off=0] v3 v122
    • NE v25b23 b21 (likely) (line 168)
    • b20: ← b50 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = MOVQload <uintptr> {"".main_init·f} v3 v169
      • v168 (?) = LEAQ <*func()> {"".main_init·f} v3 (fn[func()])
      • v181 (?) = LEAQ <*bool> {"".isarchive} v3
      • v171 (189) = CALLclosure <mem> [0] v170 v168 v169
      • v173 (+190) = MOVQload <chan bool> {"".main_init_done} v3 v171
      • v175 (190) = MOVQstore <mem> v2 v173 v171
      • v176 (190) = CALLstatic <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v179 (+192) = MOVBstoreconst <mem> {needUnlock} [val=0,off=0] v2 v177
      • v180 (+193) = CALLstatic <mem> {"".unlockOSThread} v179
      • v147 (+195) = CMPBconstload <flags> [val=0,off=0] v181 v180
    • NE v147b49 b33 (unlikely) (line 195)
    • b21: ← b19
      • v203 (?) = LEAQ <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v129 (+169) = MOVQstore <mem> v2 v203 v122
      • v132 (+169) = MOVQstoreconst <mem> [val=25,off=8] v2 v129
      • v133 (169) = CALLstatic <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b23: ← b19
      • v249 (+172) = CMPQconstload <flags> {""._cgo_setenv} [val=0,off=0] v3 v122
    • NE v249b26 b25 (likely) (line 172)
    • b24: ← b26
      • v18 (+179) = CMPQconstload <flags> {_cgo_notify_runtime_init_done} [val=0,off=0] v3 v122
    • NE v18b30 b29 (likely) (line 179)
    • b25: ← b23
      • v189 (?) = LEAQ <*uint8> {go.string."_cgo_setenv missing"} v3
      • v38 (+173) = MOVQstore <mem> v2 v189 v122
      • v140 (+173) = MOVQstoreconst <mem> [val=19,off=8] v2 v38
      • v141 (173) = CALLstatic <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b26: ← b23
      • v167 (+175) = CMPQconstload <flags> {""._cgo_unsetenv} [val=0,off=0] v3 v122
    • NE v167b24 b27 (likely) (line 175)
    • b27: ← b26
      • v155 (?) = LEAQ <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v28 (+176) = MOVQstore <mem> v2 v155 v122
      • v148 (+176) = MOVQstoreconst <mem> [val=21,off=8] v2 v28
      • v149 (176) = CALLstatic <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b29: ← b24
      • v139 (?) = LEAQ <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v151 (+180) = MOVQstore <mem> v2 v139 v122
      • v156 (+180) = MOVQstoreconst <mem> [val=37,off=8] v2 v151
      • v157 (180) = CALLstatic <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b30: ← b24
      • v159 (+184) = CALLstatic <mem> {"".startTemplateThread} v122
      • v161 (+185) = MOVQload <unsafe.Pointer> {_cgo_notify_runtime_init_done} v3 v159
      • v163 (185) = MOVQstore <mem> v2 v161 v159
      • v165 (185) = MOVQstoreconst <mem> [val=0,off=8] v2 v163
      • v166 (185) = CALLstatic <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b31: ← b49 b45
      • v187 (+198) = CALLstatic <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b33: ← b20
      • v183 (?) = LEAQ <*bool> {"".islibrary} v3
      • v79 (195) = CMPBconstload <flags> [val=0,off=0] v183 v180
    • NE v79b45 b35 (unlikely) (line 195)
    • b35: ← b33
      • v190 (+201) = MOVQload <uintptr> {"".main_main·f} v3 v180
      • v188 (?) = LEAQ <*func()> {"".main_main·f} v3 (fn[func()])
      • v191 (201) = CALLclosure <mem> [0] v190 v188 v180
      • v194 (+210) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v250 (210) = TESTL <flags> v196 v196
    • NE v250b36 b38 (line 210)
    • b36: ← b35
      • v115 (?) = MOVQconst <int> [0] (c[int])
    • Plainb39 (line 212)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = MOVLatomicload <uint32,mem> {"".panicking} v3 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v63 (219) = TESTL <flags> v217 v217
    • NE v63b46 b48 (unlikely) (line 219)
    • b38: ← b35
    • Plainb37 (line +219)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v56 (+212) = CMPQconst <flags> [1000] v199
    • LT v56b40 b44 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v52 (213) = TESTL <flags> v206 v206
    • EQ v52b43 b41 (unlikely) (line 213)
    • b41: ← b40
      • v209 (+216) = CALLstatic <mem> {"".Gosched} v205
      • v212 (+212) = ADDQconst <int> [1] v199 (c[int])
    • Plainb39 (line 212)
    • b42: ← b44 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b43: ← b40
    • Plainb42 (line +214)
    • b46: ← b37
      • v253 (220) = MOVOconst <int128> [0]
      • v223 (+220) = MOVOstore <mem> v2 v253 v216
      • v229 (220) = MOVWstoreconst <mem> [val=4104,off=16] v2 v223
      • v231 (220) = MOVQstoreconst <mem> [val=1,off=24] v2 v229
      • v232 (220) = CALLstatic <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = MOVLstoreconst <mem> [val=0,off=0] v2 v235
      • v237 (223) = CALLstatic <mem> {"".exit} [8] v236
      • v238 (?) = MOVQconst <*int32> [0] (x[*int32])
    • Plainb51 (line +224)
    • b48: ← b37
    • Plainb47 (line +223)
    • b51: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
      • v240 (+226) = LoweredNilCheck <void> v238 v244
      • v241 (226) = MOVLstoreconst <mem> [val=0,off=0] v238 v244
    • Plainb51 (line +226)
    • b34: ← b17
      • v121 (?) = LEAQ <*chan bool> {"".main_init_done} v3
      • v40 (166) = LoweredWB <mem> {runtime.gcWriteBarrier} v121 v120 v118
    • Plainb52 (line 166)
    • b6: ← b17
      • v39 (166) = MOVQstore <mem> {"".main_init_done} v3 v120 v118
    • Plainb52 (line 166)
    • b52: ← b34 b6
      • v122 (166) = Phi <mem> v40 v39
      • v123 (?) = LEAQ <*bool> {"".iscgo} v3
      • v248 (+167) = CMPBconstload <flags> [val=0,off=0] v123 v122
    • NE v248b19 b50 (line 167)
    • b50: ← b52
    • Plainb20 (line 167)
    • b49: ← b20
    • Plainb31 (line 195)
    • b45: ← b33
    • Plainb31 (line 195)
    • b44: ← b39
    • Plainb42 (line 212)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • layout [13173 ns]

    • b11:
      • v2 (?) = SP <uintptr>
      • v3 (?) = SB <uintptr>
      • v23 (?) = LEAQ <*func()> {"".main.func1·f} v3
      • v72 (?) = LEAQ <*m> {"".m0} v3
      • v1 (?) = InitMem <mem>
      • v4 (+111) = LoweredGetG <*g> v1 (g[*g])
      • v8 (+115) = MOVQload <*m> [48] v4 v1
      • v11 (115) = MOVQload <*g> v8 v1
      • v14 (115) = MOVQstoreconst <mem> [val=0,off=304] v11 v1
      • v19 (+121) = MOVQstoreconst <mem> {"".maxstacksize} [val=1000000000,off=0] v3 v14
      • v22 (+127) = MOVBstoreconst <mem> {"".mainStarted} [val=1,off=0] v3 v19
      • v26 (+130) = MOVQstore <mem> v2 v23 v22
      • v27 (130) = CALLstatic <mem> {"".systemstack} [8] v26
      • v29 (+3614) = LoweredGetG <*g> v27
      • v32 (3614) = MOVQload <*m> [48] v29 v27
      • v43 (3614) = ADDLconstmodify <mem> [val=1,off=620] v32 v27
      • v9 (115) = LoweredNilCheck <void> v8 v1
      • v12 (115) = LoweredNilCheck <void> v11 v1
      • v33 (3614) = LoweredNilCheck <void> v32 v27
      • v46 (+3575) = LoweredGetG <*g> v43 (_g_[*g], g[*g])
      • v59 (3577) = ADDQconst <*muintptr> [216] v46 (mp[*muintptr])
      • v53 (+205) = Convert <guintptr> v46 v43
      • v49 (3576) = MOVQload <*m> [48] v46 v43
      • v50 (3576) = LoweredNilCheck <void> v49 v43
      • v55 (205) = MOVQstore <mem> [352] v49 v53 v43
      • v51 (+3576) = ADDQconst <*guintptr> [352] v49 (gp[*guintptr])
      • v54 (205) = LoweredNilCheck <void> v51 v43
      • v62 (3577) = MOVQload <*m> [48] v46 v55 (m[*m])
      • v65 (243) = LoweredNilCheck <void> v59 v55
      • v58 (+3577) = LoweredNilCheck <void> v46 v55
      • v64 (+243) = Convert <muintptr> v62 v55
      • v66 (243) = MOVQstore <mem> [216] v46 v64 v55
      • v172 (143) = CMPQload <flags> [48] v4 v72 v66
      • v69 (+143) = LoweredNilCheck <void> v4 v66
    • NE v172b12 b13 (unlikely) (line 143)
    • b13: ← b11
      • v80 (+147) = CALLstatic <mem> {runtime.init} v66
      • v81 (+148) = CALLstatic <mem> {"".nanotime} [8] v80
      • v251 (148) = CMPQconstload <flags> [val=0,off=0] v2 v81
    • EQ v251b14 b15 (unlikely) (line 148)
    • b15: ← b13
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v92 (+153) = LEAQ <*bool> {needUnlock} v2
      • v93 (+153) = MOVBstoreconst <mem> {needUnlock} [val=1,off=0] v2 v91
      • v97 (+158) = MOVQstore <mem> [16] v2 v92 v93
      • v100 (+154) = MOVLstoreconst <mem> [val=8,off=0] v2 v97
      • v94 (?) = LEAQ <*func(*bool)> {"".main.func2·f} v3
      • v102 (154) = MOVQstore <mem> [8] v2 v94 v100
      • v103 (154) = CALLstatic <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b17: ← b15
      • v107 (+162) = CALLstatic <mem> {"".nanotime} [8] v103
      • v108 (162) = MOVQload <int64> v2 v107
      • v110 (162) = MOVQstore <mem> {"".runtimeInitTime} v3 v108 v107
      • v111 (+164) = CALLstatic <mem> {"".gcenable} v110
      • v112 (?) = LEAQ <*uint8> {type.chan bool} v3
      • v114 (+166) = MOVQstore <mem> v2 v112 v111
      • v117 (166) = MOVQstoreconst <mem> [val=0,off=8] v2 v114
      • v118 (166) = CALLstatic <mem> {runtime.makechan} [24] v117
      • v120 (166) = MOVQload <chan bool> [16] v2 v118
      • v252 (166) = CMPLconstload <flags> {runtime.writeBarrier} [val=0,off=0] v3 v118
    • NE v252b34 b6 (unlikely) (line 166)
    • b6: ← b17
      • v39 (166) = MOVQstore <mem> {"".main_init_done} v3 v120 v118
    • Plainb52 (line 166)
    • b52: ← b34 b6
      • v122 (166) = Phi <mem> v40 v39
      • v123 (?) = LEAQ <*bool> {"".iscgo} v3
      • v248 (+167) = CMPBconstload <flags> [val=0,off=0] v123 v122
    • NE v248b19 b50 (line 167)
    • b19: ← b52
      • v25 (+168) = CMPQconstload <flags> {_cgo_thread_start} [val=0,off=0] v3 v122
    • NE v25b23 b21 (likely) (line 168)
    • b23: ← b19
      • v249 (+172) = CMPQconstload <flags> {""._cgo_setenv} [val=0,off=0] v3 v122
    • NE v249b26 b25 (likely) (line 172)
    • b26: ← b23
      • v167 (+175) = CMPQconstload <flags> {""._cgo_unsetenv} [val=0,off=0] v3 v122
    • NE v167b24 b27 (likely) (line 175)
    • b24: ← b26
      • v18 (+179) = CMPQconstload <flags> {_cgo_notify_runtime_init_done} [val=0,off=0] v3 v122
    • NE v18b30 b29 (likely) (line 179)
    • b30: ← b24
      • v159 (+184) = CALLstatic <mem> {"".startTemplateThread} v122
      • v161 (+185) = MOVQload <unsafe.Pointer> {_cgo_notify_runtime_init_done} v3 v159
      • v163 (185) = MOVQstore <mem> v2 v161 v159
      • v165 (185) = MOVQstoreconst <mem> [val=0,off=8] v2 v163
      • v166 (185) = CALLstatic <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b20: ← b50 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = MOVQload <uintptr> {"".main_init·f} v3 v169
      • v168 (?) = LEAQ <*func()> {"".main_init·f} v3 (fn[func()])
      • v181 (?) = LEAQ <*bool> {"".isarchive} v3
      • v171 (189) = CALLclosure <mem> [0] v170 v168 v169
      • v173 (+190) = MOVQload <chan bool> {"".main_init_done} v3 v171
      • v175 (190) = MOVQstore <mem> v2 v173 v171
      • v176 (190) = CALLstatic <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v179 (+192) = MOVBstoreconst <mem> {needUnlock} [val=0,off=0] v2 v177
      • v180 (+193) = CALLstatic <mem> {"".unlockOSThread} v179
      • v147 (+195) = CMPBconstload <flags> [val=0,off=0] v181 v180
    • NE v147b49 b33 (unlikely) (line 195)
    • b33: ← b20
      • v183 (?) = LEAQ <*bool> {"".islibrary} v3
      • v79 (195) = CMPBconstload <flags> [val=0,off=0] v183 v180
    • NE v79b45 b35 (unlikely) (line 195)
    • b35: ← b33
      • v190 (+201) = MOVQload <uintptr> {"".main_main·f} v3 v180
      • v188 (?) = LEAQ <*func()> {"".main_main·f} v3 (fn[func()])
      • v191 (201) = CALLclosure <mem> [0] v190 v188 v180
      • v194 (+210) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v191
      • v195 (210) = Select1 <mem> v194
      • v196 (210) = Select0 <uint32> v194
      • v250 (210) = TESTL <flags> v196 v196
    • NE v250b36 b38 (line 210)
    • b36: ← b35
      • v115 (?) = MOVQconst <int> [0] (c[int])
    • Plainb39 (line 212)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v56 (+212) = CMPQconst <flags> [1000] v199
    • LT v56b40 b44 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v245
      • v205 (213) = Select1 <mem> v204
      • v206 (213) = Select0 <uint32> v204
      • v52 (213) = TESTL <flags> v206 v206
    • EQ v52b43 b41 (unlikely) (line 213)
    • b41: ← b40
      • v209 (+216) = CALLstatic <mem> {"".Gosched} v205
      • v212 (+212) = ADDQconst <int> [1] v199 (c[int])
    • Plainb39 (line 212)
    • b43: ← b40
    • Plainb42 (line +214)
    • b42: ← b44 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = MOVLatomicload <uint32,mem> {"".panicking} v3 v214
      • v216 (219) = Select1 <mem> v215
      • v217 (219) = Select0 <uint32> v215
      • v63 (219) = TESTL <flags> v217 v217
    • NE v63b46 b48 (unlikely) (line 219)
    • b48: ← b37
    • Plainb47 (line +223)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = MOVLstoreconst <mem> [val=0,off=0] v2 v235
      • v237 (223) = CALLstatic <mem> {"".exit} [8] v236
      • v238 (?) = MOVQconst <*int32> [0] (x[*int32])
    • Plainb51 (line +224)
    • b51: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
      • v240 (+226) = LoweredNilCheck <void> v238 v244
      • v241 (226) = MOVLstoreconst <mem> [val=0,off=0] v238 v244
    • Plainb51 (line +226)
    • b46: ← b37
      • v253 (220) = MOVOconst <int128> [0]
      • v223 (+220) = MOVOstore <mem> v2 v253 v216
      • v229 (220) = MOVWstoreconst <mem> [val=4104,off=16] v2 v223
      • v231 (220) = MOVQstoreconst <mem> [val=1,off=24] v2 v229
      • v232 (220) = CALLstatic <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b44: ← b39
    • Plainb42 (line 212)
    • b38: ← b35
    • Plainb37 (line +219)
    • b45: ← b33
    • Plainb31 (line 195)
    • b31: ← b49 b45
      • v187 (+198) = CALLstatic <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b49: ← b20
    • Plainb31 (line 195)
    • b50: ← b52
    • Plainb20 (line 167)
    • b34: ← b17
      • v121 (?) = LEAQ <*chan bool> {"".main_init_done} v3
      • v40 (166) = LoweredWB <mem> {runtime.gcWriteBarrier} v121 v120 v118
    • Plainb52 (line 166)
    • b18: ← b15
      • v105 (154) = CALLstatic <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b29: ← b24
      • v139 (?) = LEAQ <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v151 (+180) = MOVQstore <mem> v2 v139 v122
      • v156 (+180) = MOVQstoreconst <mem> [val=37,off=8] v2 v151
      • v157 (180) = CALLstatic <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b27: ← b26
      • v155 (?) = LEAQ <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v28 (+176) = MOVQstore <mem> v2 v155 v122
      • v148 (+176) = MOVQstoreconst <mem> [val=21,off=8] v2 v28
      • v149 (176) = CALLstatic <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b25: ← b23
      • v189 (?) = LEAQ <*uint8> {go.string."_cgo_setenv missing"} v3
      • v38 (+173) = MOVQstore <mem> v2 v189 v122
      • v140 (+173) = MOVQstoreconst <mem> [val=19,off=8] v2 v38
      • v141 (173) = CALLstatic <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b21: ← b19
      • v203 (?) = LEAQ <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v129 (+169) = MOVQstore <mem> v2 v203 v122
      • v132 (+169) = MOVQstoreconst <mem> [val=25,off=8] v2 v129
      • v133 (169) = CALLstatic <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b14: ← b13
      • v221 (?) = LEAQ <*uint8> {go.string."nanotime returning zero"} v3
      • v153 (+149) = MOVQstore <mem> v2 v221 v81
      • v88 (+149) = MOVQstoreconst <mem> [val=23,off=8] v2 v153
      • v89 (149) = CALLstatic <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b12: ← b11
      • v243 (?) = LEAQ <*uint8> {go.string."runtime.main not on m0"} v3
      • v41 (+144) = MOVQstore <mem> v2 v243 v66
      • v77 (+144) = MOVQstoreconst <mem> [val=22,off=8] v2 v41
      • v78 (144) = CALLstatic <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • schedule [93864 ns]

    • b11:
      • v1 (?) = InitMem <mem>
      • v4 (+111) = LoweredGetG <*g> v1 (g[*g])
      • v8 (+115) = MOVQload <*m> [48] v4 v1
      • v9 (115) = LoweredNilCheck <void> v8 v1
      • v11 (115) = MOVQload <*g> v8 v1
      • v12 (115) = LoweredNilCheck <void> v11 v1
      • v14 (115) = MOVQstoreconst <mem> [val=0,off=304] v11 v1
      • v3 (?) = SB <uintptr>
      • v19 (+121) = MOVQstoreconst <mem> {"".maxstacksize} [val=1000000000,off=0] v3 v14
      • v22 (+127) = MOVBstoreconst <mem> {"".mainStarted} [val=1,off=0] v3 v19
      • v23 (?) = LEAQ <*func()> {"".main.func1·f} v3
      • v2 (?) = SP <uintptr>
      • v26 (+130) = MOVQstore <mem> v2 v23 v22
      • v27 (130) = CALLstatic <mem> {"".systemstack} [8] v26
      • v29 (+3614) = LoweredGetG <*g> v27
      • v32 (3614) = MOVQload <*m> [48] v29 v27
      • v33 (3614) = LoweredNilCheck <void> v32 v27
      • v43 (3614) = ADDLconstmodify <mem> [val=1,off=620] v32 v27
      • v46 (+3575) = LoweredGetG <*g> v43 (_g_[*g], g[*g])
      • v49 (3576) = MOVQload <*m> [48] v46 v43
      • v50 (3576) = LoweredNilCheck <void> v49 v43
      • v51 (+3576) = ADDQconst <*guintptr> [352] v49 (gp[*guintptr])
      • v54 (205) = LoweredNilCheck <void> v51 v43
      • v53 (+205) = Convert <guintptr> v46 v43
      • v55 (205) = MOVQstore <mem> [352] v49 v53 v43
      • v58 (+3577) = LoweredNilCheck <void> v46 v55
      • v59 (3577) = ADDQconst <*muintptr> [216] v46 (mp[*muintptr])
      • v65 (243) = LoweredNilCheck <void> v59 v55
      • v62 (3577) = MOVQload <*m> [48] v46 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v66 (243) = MOVQstore <mem> [216] v46 v64 v55
      • v69 (+143) = LoweredNilCheck <void> v4 v66
      • v72 (?) = LEAQ <*m> {"".m0} v3
      • v172 (143) = CMPQload <flags> [48] v4 v72 v66
    • NE v172b12 b13 (unlikely) (line 143)
    • b13: ← b11
      • v80 (+147) = CALLstatic <mem> {runtime.init} v66
      • v81 (+148) = CALLstatic <mem> {"".nanotime} [8] v80
      • v251 (148) = CMPQconstload <flags> [val=0,off=0] v2 v81
    • EQ v251b14 b15 (unlikely) (line 148)
    • b15: ← b13
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v93 (+153) = MOVBstoreconst <mem> {needUnlock} [val=1,off=0] v2 v91
      • v92 (+153) = LEAQ <*bool> {needUnlock} v2
      • v97 (+158) = MOVQstore <mem> [16] v2 v92 v93
      • v100 (+154) = MOVLstoreconst <mem> [val=8,off=0] v2 v97
      • v94 (?) = LEAQ <*func(*bool)> {"".main.func2·f} v3
      • v102 (154) = MOVQstore <mem> [8] v2 v94 v100
      • v103 (154) = CALLstatic <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b17: ← b15
      • v107 (+162) = CALLstatic <mem> {"".nanotime} [8] v103
      • v108 (162) = MOVQload <int64> v2 v107
      • v110 (162) = MOVQstore <mem> {"".runtimeInitTime} v3 v108 v107
      • v111 (+164) = CALLstatic <mem> {"".gcenable} v110
      • v112 (?) = LEAQ <*uint8> {type.chan bool} v3
      • v114 (+166) = MOVQstore <mem> v2 v112 v111
      • v117 (166) = MOVQstoreconst <mem> [val=0,off=8] v2 v114
      • v118 (166) = CALLstatic <mem> {runtime.makechan} [24] v117
      • v120 (166) = MOVQload <chan bool> [16] v2 v118
      • v252 (166) = CMPLconstload <flags> {runtime.writeBarrier} [val=0,off=0] v3 v118
    • NE v252b34 b6 (unlikely) (line 166)
    • b6: ← b17
      • v39 (166) = MOVQstore <mem> {"".main_init_done} v3 v120 v118
    • Plainb52 (line 166)
    • b52: ← b34 b6
      • v122 (166) = Phi <mem> v40 v39
      • v123 (?) = LEAQ <*bool> {"".iscgo} v3
      • v248 (+167) = CMPBconstload <flags> [val=0,off=0] v123 v122
    • NE v248b19 b50 (line 167)
    • b19: ← b52
      • v25 (+168) = CMPQconstload <flags> {_cgo_thread_start} [val=0,off=0] v3 v122
    • NE v25b23 b21 (likely) (line 168)
    • b23: ← b19
      • v249 (+172) = CMPQconstload <flags> {""._cgo_setenv} [val=0,off=0] v3 v122
    • NE v249b26 b25 (likely) (line 172)
    • b26: ← b23
      • v167 (+175) = CMPQconstload <flags> {""._cgo_unsetenv} [val=0,off=0] v3 v122
    • NE v167b24 b27 (likely) (line 175)
    • b24: ← b26
      • v18 (+179) = CMPQconstload <flags> {_cgo_notify_runtime_init_done} [val=0,off=0] v3 v122
    • NE v18b30 b29 (likely) (line 179)
    • b30: ← b24
      • v159 (+184) = CALLstatic <mem> {"".startTemplateThread} v122
      • v161 (+185) = MOVQload <unsafe.Pointer> {_cgo_notify_runtime_init_done} v3 v159
      • v163 (185) = MOVQstore <mem> v2 v161 v159
      • v165 (185) = MOVQstoreconst <mem> [val=0,off=8] v2 v163
      • v166 (185) = CALLstatic <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b20: ← b50 b30
      • v169 (189) = Phi <mem> v122 v166
      • v168 (?) = LEAQ <*func()> {"".main_init·f} v3 (fn[func()])
      • v170 (+189) = MOVQload <uintptr> {"".main_init·f} v3 v169
      • v171 (189) = CALLclosure <mem> [0] v170 v168 v169
      • v173 (+190) = MOVQload <chan bool> {"".main_init_done} v3 v171
      • v175 (190) = MOVQstore <mem> v2 v173 v171
      • v176 (190) = CALLstatic <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v179 (+192) = MOVBstoreconst <mem> {needUnlock} [val=0,off=0] v2 v177
      • v180 (+193) = CALLstatic <mem> {"".unlockOSThread} v179
      • v181 (?) = LEAQ <*bool> {"".isarchive} v3
      • v147 (+195) = CMPBconstload <flags> [val=0,off=0] v181 v180
    • NE v147b49 b33 (unlikely) (line 195)
    • b33: ← b20
      • v183 (?) = LEAQ <*bool> {"".islibrary} v3
      • v79 (195) = CMPBconstload <flags> [val=0,off=0] v183 v180
    • NE v79b45 b35 (unlikely) (line 195)
    • b35: ← b33
      • v188 (?) = LEAQ <*func()> {"".main_main·f} v3 (fn[func()])
      • v190 (+201) = MOVQload <uintptr> {"".main_main·f} v3 v180
      • v191 (201) = CALLclosure <mem> [0] v190 v188 v180
      • v194 (+210) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v191
      • v196 (210) = Select0 <uint32> v194
      • v195 (210) = Select1 <mem> v194
      • v250 (210) = TESTL <flags> v196 v196
    • NE v250b36 b38 (line 210)
    • b36: ← b35
      • v115 (?) = MOVQconst <int> [0] (c[int])
    • Plainb39 (line 212)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v56 (+212) = CMPQconst <flags> [1000] v199
    • LT v56b40 b44 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v245
      • v206 (213) = Select0 <uint32> v204
      • v205 (213) = Select1 <mem> v204
      • v52 (213) = TESTL <flags> v206 v206
    • EQ v52b43 b41 (unlikely) (line 213)
    • b41: ← b40
      • v209 (+216) = CALLstatic <mem> {"".Gosched} v205
      • v212 (+212) = ADDQconst <int> [1] v199 (c[int])
    • Plainb39 (line 212)
    • b43: ← b40
    • Plainb42 (line +214)
    • b42: ← b44 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = MOVLatomicload <uint32,mem> {"".panicking} v3 v214
      • v217 (219) = Select0 <uint32> v215
      • v216 (219) = Select1 <mem> v215
      • v63 (219) = TESTL <flags> v217 v217
    • NE v63b46 b48 (unlikely) (line 219)
    • b48: ← b37
    • Plainb47 (line +223)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = MOVLstoreconst <mem> [val=0,off=0] v2 v235
      • v237 (223) = CALLstatic <mem> {"".exit} [8] v236
      • v238 (?) = MOVQconst <*int32> [0] (x[*int32])
    • Plainb51 (line +224)
    • b51: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
      • v240 (+226) = LoweredNilCheck <void> v238 v244
      • v241 (226) = MOVLstoreconst <mem> [val=0,off=0] v238 v244
    • Plainb51 (line +226)
    • b46: ← b37
      • v253 (220) = MOVOconst <int128> [0]
      • v223 (+220) = MOVOstore <mem> v2 v253 v216
      • v229 (220) = MOVWstoreconst <mem> [val=4104,off=16] v2 v223
      • v231 (220) = MOVQstoreconst <mem> [val=1,off=24] v2 v229
      • v232 (220) = CALLstatic <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b44: ← b39
    • Plainb42 (line 212)
    • b38: ← b35
    • Plainb37 (line +219)
    • b45: ← b33
    • Plainb31 (line 195)
    • b31: ← b49 b45
      • v187 (+198) = CALLstatic <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b49: ← b20
    • Plainb31 (line 195)
    • b50: ← b52
    • Plainb20 (line 167)
    • b34: ← b17
      • v121 (?) = LEAQ <*chan bool> {"".main_init_done} v3
      • v40 (166) = LoweredWB <mem> {runtime.gcWriteBarrier} v121 v120 v118
    • Plainb52 (line 166)
    • b18: ← b15
      • v105 (154) = CALLstatic <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b29: ← b24
      • v139 (?) = LEAQ <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v151 (+180) = MOVQstore <mem> v2 v139 v122
      • v156 (+180) = MOVQstoreconst <mem> [val=37,off=8] v2 v151
      • v157 (180) = CALLstatic <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b27: ← b26
      • v155 (?) = LEAQ <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v28 (+176) = MOVQstore <mem> v2 v155 v122
      • v148 (+176) = MOVQstoreconst <mem> [val=21,off=8] v2 v28
      • v149 (176) = CALLstatic <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b25: ← b23
      • v189 (?) = LEAQ <*uint8> {go.string."_cgo_setenv missing"} v3
      • v38 (+173) = MOVQstore <mem> v2 v189 v122
      • v140 (+173) = MOVQstoreconst <mem> [val=19,off=8] v2 v38
      • v141 (173) = CALLstatic <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b21: ← b19
      • v203 (?) = LEAQ <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v129 (+169) = MOVQstore <mem> v2 v203 v122
      • v132 (+169) = MOVQstoreconst <mem> [val=25,off=8] v2 v129
      • v133 (169) = CALLstatic <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b14: ← b13
      • v221 (?) = LEAQ <*uint8> {go.string."nanotime returning zero"} v3
      • v153 (+149) = MOVQstore <mem> v2 v221 v81
      • v88 (+149) = MOVQstoreconst <mem> [val=23,off=8] v2 v153
      • v89 (149) = CALLstatic <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b12: ← b11
      • v243 (?) = LEAQ <*uint8> {go.string."runtime.main not on m0"} v3
      • v41 (+144) = MOVQstore <mem> v2 v243 v66
      • v77 (+144) = MOVQstoreconst <mem> [val=22,off=8] v2 v41
      • v78 (144) = CALLstatic <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • late nilcheck [30406 ns]

    • b11:
      • v1 (?) = InitMem <mem>
      • v4 (+111) = LoweredGetG <*g> v1 (g[*g])
      • v8 (+115) = MOVQload <*m> [48] v4 v1
      • v11 (115) = MOVQload <*g> v8 v1
      • v14 (115) = MOVQstoreconst <mem> [val=0,off=304] v11 v1
      • v3 (?) = SB <uintptr>
      • v19 (+121) = MOVQstoreconst <mem> {"".maxstacksize} [val=1000000000,off=0] v3 v14
      • v22 (+127) = MOVBstoreconst <mem> {"".mainStarted} [val=1,off=0] v3 v19
      • v23 (?) = LEAQ <*func()> {"".main.func1·f} v3
      • v2 (?) = SP <uintptr>
      • v26 (+130) = MOVQstore <mem> v2 v23 v22
      • v27 (130) = CALLstatic <mem> {"".systemstack} [8] v26
      • v29 (+3614) = LoweredGetG <*g> v27
      • v32 (3614) = MOVQload <*m> [48] v29 v27
      • v43 (3614) = ADDLconstmodify <mem> [val=1,off=620] v32 v27
      • v46 (+3575) = LoweredGetG <*g> v43 (_g_[*g], g[*g])
      • v49 (3576) = MOVQload <*m> [48] v46 v43
      • v51 (+3576) = ADDQconst <*guintptr> [352] v49 (gp[*guintptr])
      • v54 (205) = LoweredNilCheck <void> v51 v43
      • v53 (+205) = Convert <guintptr> v46 v43
      • v55 (205) = MOVQstore <mem> [352] v49 v53 v43
      • v59 (+3577) = ADDQconst <*muintptr> [216] v46 (mp[*muintptr])
      • v65 (243) = LoweredNilCheck <void> v59 v55
      • v62 (3577) = MOVQload <*m> [48] v46 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v66 (243) = MOVQstore <mem> [216] v46 v64 v55
      • v72 (?) = LEAQ <*m> {"".m0} v3
      • v172 (+143) = CMPQload <flags> [48] v4 v72 v66
    • NE v172b12 b13 (unlikely) (line 143)
    • b13: ← b11
      • v80 (+147) = CALLstatic <mem> {runtime.init} v66
      • v81 (+148) = CALLstatic <mem> {"".nanotime} [8] v80
      • v251 (148) = CMPQconstload <flags> [val=0,off=0] v2 v81
    • EQ v251b14 b15 (unlikely) (line 148)
    • b15: ← b13
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v93 (+153) = MOVBstoreconst <mem> {needUnlock} [val=1,off=0] v2 v91
      • v92 (+153) = LEAQ <*bool> {needUnlock} v2
      • v97 (+158) = MOVQstore <mem> [16] v2 v92 v93
      • v100 (+154) = MOVLstoreconst <mem> [val=8,off=0] v2 v97
      • v94 (?) = LEAQ <*func(*bool)> {"".main.func2·f} v3
      • v102 (154) = MOVQstore <mem> [8] v2 v94 v100
      • v103 (154) = CALLstatic <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b17: ← b15
      • v107 (+162) = CALLstatic <mem> {"".nanotime} [8] v103
      • v108 (162) = MOVQload <int64> v2 v107
      • v110 (162) = MOVQstore <mem> {"".runtimeInitTime} v3 v108 v107
      • v111 (+164) = CALLstatic <mem> {"".gcenable} v110
      • v112 (?) = LEAQ <*uint8> {type.chan bool} v3
      • v114 (+166) = MOVQstore <mem> v2 v112 v111
      • v117 (166) = MOVQstoreconst <mem> [val=0,off=8] v2 v114
      • v118 (166) = CALLstatic <mem> {runtime.makechan} [24] v117
      • v120 (166) = MOVQload <chan bool> [16] v2 v118
      • v252 (166) = CMPLconstload <flags> {runtime.writeBarrier} [val=0,off=0] v3 v118
    • NE v252b34 b6 (unlikely) (line 166)
    • b6: ← b17
      • v39 (166) = MOVQstore <mem> {"".main_init_done} v3 v120 v118
    • Plainb52 (line 166)
    • b52: ← b34 b6
      • v122 (166) = Phi <mem> v40 v39
      • v123 (?) = LEAQ <*bool> {"".iscgo} v3
      • v248 (+167) = CMPBconstload <flags> [val=0,off=0] v123 v122
    • NE v248b19 b50 (line 167)
    • b19: ← b52
      • v25 (+168) = CMPQconstload <flags> {_cgo_thread_start} [val=0,off=0] v3 v122
    • NE v25b23 b21 (likely) (line 168)
    • b23: ← b19
      • v249 (+172) = CMPQconstload <flags> {""._cgo_setenv} [val=0,off=0] v3 v122
    • NE v249b26 b25 (likely) (line 172)
    • b26: ← b23
      • v167 (+175) = CMPQconstload <flags> {""._cgo_unsetenv} [val=0,off=0] v3 v122
    • NE v167b24 b27 (likely) (line 175)
    • b24: ← b26
      • v18 (+179) = CMPQconstload <flags> {_cgo_notify_runtime_init_done} [val=0,off=0] v3 v122
    • NE v18b30 b29 (likely) (line 179)
    • b30: ← b24
      • v159 (+184) = CALLstatic <mem> {"".startTemplateThread} v122
      • v161 (+185) = MOVQload <unsafe.Pointer> {_cgo_notify_runtime_init_done} v3 v159
      • v163 (185) = MOVQstore <mem> v2 v161 v159
      • v165 (185) = MOVQstoreconst <mem> [val=0,off=8] v2 v163
      • v166 (185) = CALLstatic <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b20: ← b50 b30
      • v169 (189) = Phi <mem> v122 v166
      • v168 (?) = LEAQ <*func()> {"".main_init·f} v3 (fn[func()])
      • v170 (+189) = MOVQload <uintptr> {"".main_init·f} v3 v169
      • v171 (189) = CALLclosure <mem> [0] v170 v168 v169
      • v173 (+190) = MOVQload <chan bool> {"".main_init_done} v3 v171
      • v175 (190) = MOVQstore <mem> v2 v173 v171
      • v176 (190) = CALLstatic <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v179 (+192) = MOVBstoreconst <mem> {needUnlock} [val=0,off=0] v2 v177
      • v180 (+193) = CALLstatic <mem> {"".unlockOSThread} v179
      • v181 (?) = LEAQ <*bool> {"".isarchive} v3
      • v147 (+195) = CMPBconstload <flags> [val=0,off=0] v181 v180
    • NE v147b49 b33 (unlikely) (line 195)
    • b33: ← b20
      • v183 (?) = LEAQ <*bool> {"".islibrary} v3
      • v79 (195) = CMPBconstload <flags> [val=0,off=0] v183 v180
    • NE v79b45 b35 (unlikely) (line 195)
    • b35: ← b33
      • v188 (?) = LEAQ <*func()> {"".main_main·f} v3 (fn[func()])
      • v190 (+201) = MOVQload <uintptr> {"".main_main·f} v3 v180
      • v191 (201) = CALLclosure <mem> [0] v190 v188 v180
      • v194 (+210) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v191
      • v196 (210) = Select0 <uint32> v194
      • v195 (210) = Select1 <mem> v194
      • v250 (210) = TESTL <flags> v196 v196
    • NE v250b36 b38 (line 210)
    • b36: ← b35
      • v115 (?) = MOVQconst <int> [0] (c[int])
    • Plainb39 (line 212)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v56 (+212) = CMPQconst <flags> [1000] v199
    • LT v56b40 b44 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v245
      • v206 (213) = Select0 <uint32> v204
      • v205 (213) = Select1 <mem> v204
      • v52 (213) = TESTL <flags> v206 v206
    • EQ v52b43 b41 (unlikely) (line 213)
    • b41: ← b40
      • v209 (+216) = CALLstatic <mem> {"".Gosched} v205
      • v212 (+212) = ADDQconst <int> [1] v199 (c[int])
    • Plainb39 (line 212)
    • b43: ← b40
    • Plainb42 (line +214)
    • b42: ← b44 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = MOVLatomicload <uint32,mem> {"".panicking} v3 v214
      • v217 (219) = Select0 <uint32> v215
      • v216 (219) = Select1 <mem> v215
      • v63 (219) = TESTL <flags> v217 v217
    • NE v63b46 b48 (unlikely) (line 219)
    • b48: ← b37
    • Plainb47 (line +223)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = MOVLstoreconst <mem> [val=0,off=0] v2 v235
      • v237 (223) = CALLstatic <mem> {"".exit} [8] v236
      • v238 (?) = MOVQconst <*int32> [0] (x[*int32])
    • Plainb51 (line +224)
    • b51: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
      • v241 (+226) = MOVLstoreconst <mem> [val=0,off=0] v238 v244
    • Plainb51 (line +226)
    • b46: ← b37
      • v253 (220) = MOVOconst <int128> [0]
      • v223 (+220) = MOVOstore <mem> v2 v253 v216
      • v229 (220) = MOVWstoreconst <mem> [val=4104,off=16] v2 v223
      • v231 (220) = MOVQstoreconst <mem> [val=1,off=24] v2 v229
      • v232 (220) = CALLstatic <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b44: ← b39
    • Plainb42 (line 212)
    • b38: ← b35
    • Plainb37 (line +219)
    • b45: ← b33
    • Plainb31 (line 195)
    • b31: ← b49 b45
      • v187 (+198) = CALLstatic <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b49: ← b20
    • Plainb31 (line 195)
    • b50: ← b52
    • Plainb20 (line 167)
    • b34: ← b17
      • v121 (?) = LEAQ <*chan bool> {"".main_init_done} v3
      • v40 (166) = LoweredWB <mem> {runtime.gcWriteBarrier} v121 v120 v118
    • Plainb52 (line 166)
    • b18: ← b15
      • v105 (154) = CALLstatic <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b29: ← b24
      • v139 (?) = LEAQ <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v151 (+180) = MOVQstore <mem> v2 v139 v122
      • v156 (+180) = MOVQstoreconst <mem> [val=37,off=8] v2 v151
      • v157 (180) = CALLstatic <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b27: ← b26
      • v155 (?) = LEAQ <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v28 (+176) = MOVQstore <mem> v2 v155 v122
      • v148 (+176) = MOVQstoreconst <mem> [val=21,off=8] v2 v28
      • v149 (176) = CALLstatic <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b25: ← b23
      • v189 (?) = LEAQ <*uint8> {go.string."_cgo_setenv missing"} v3
      • v38 (+173) = MOVQstore <mem> v2 v189 v122
      • v140 (+173) = MOVQstoreconst <mem> [val=19,off=8] v2 v38
      • v141 (173) = CALLstatic <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b21: ← b19
      • v203 (?) = LEAQ <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v129 (+169) = MOVQstore <mem> v2 v203 v122
      • v132 (+169) = MOVQstoreconst <mem> [val=25,off=8] v2 v129
      • v133 (169) = CALLstatic <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b14: ← b13
      • v221 (?) = LEAQ <*uint8> {go.string."nanotime returning zero"} v3
      • v153 (+149) = MOVQstore <mem> v2 v221 v81
      • v88 (+149) = MOVQstoreconst <mem> [val=23,off=8] v2 v153
      • v89 (149) = CALLstatic <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b12: ← b11
      • v243 (?) = LEAQ <*uint8> {go.string."runtime.main not on m0"} v3
      • v41 (+144) = MOVQstore <mem> v2 v243 v66
      • v77 (+144) = MOVQstoreconst <mem> [val=22,off=8] v2 v41
      • v78 (144) = CALLstatic <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • flagalloc [55368 ns]

    • b11:
      • v1 (?) = InitMem <mem>
      • v4 (+111) = LoweredGetG <*g> v1 (g[*g])
      • v8 (+115) = MOVQload <*m> [48] v4 v1
      • v11 (115) = MOVQload <*g> v8 v1
      • v14 (115) = MOVQstoreconst <mem> [val=0,off=304] v11 v1
      • v3 (?) = SB <uintptr>
      • v19 (+121) = MOVQstoreconst <mem> {"".maxstacksize} [val=1000000000,off=0] v3 v14
      • v22 (+127) = MOVBstoreconst <mem> {"".mainStarted} [val=1,off=0] v3 v19
      • v23 (?) = LEAQ <*func()> {"".main.func1·f} v3
      • v2 (?) = SP <uintptr>
      • v26 (+130) = MOVQstore <mem> v2 v23 v22
      • v27 (130) = CALLstatic <mem> {"".systemstack} [8] v26
      • v29 (+3614) = LoweredGetG <*g> v27
      • v32 (3614) = MOVQload <*m> [48] v29 v27
      • v43 (3614) = ADDLconstmodify <mem> [val=1,off=620] v32 v27
      • v46 (+3575) = LoweredGetG <*g> v43 (_g_[*g], g[*g])
      • v49 (3576) = MOVQload <*m> [48] v46 v43
      • v51 (+3576) = ADDQconst <*guintptr> [352] v49 (gp[*guintptr])
      • v54 (205) = LoweredNilCheck <void> v51 v43
      • v53 (+205) = Convert <guintptr> v46 v43
      • v55 (205) = MOVQstore <mem> [352] v49 v53 v43
      • v59 (+3577) = ADDQconst <*muintptr> [216] v46 (mp[*muintptr])
      • v65 (243) = LoweredNilCheck <void> v59 v55
      • v62 (3577) = MOVQload <*m> [48] v46 v55 (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55
      • v66 (243) = MOVQstore <mem> [216] v46 v64 v55
      • v72 (?) = LEAQ <*m> {"".m0} v3
      • v172 (+143) = CMPQload <flags> [48] v4 v72 v66
    • NE v172b12 b13 (unlikely) (line 143)
    • b13: ← b11
      • v80 (+147) = CALLstatic <mem> {runtime.init} v66
      • v81 (+148) = CALLstatic <mem> {"".nanotime} [8] v80
      • v251 (148) = CMPQconstload <flags> [val=0,off=0] v2 v81
    • EQ v251b14 b15 (unlikely) (line 148)
    • b15: ← b13
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v93 (+153) = MOVBstoreconst <mem> {needUnlock} [val=1,off=0] v2 v91
      • v92 (+153) = LEAQ <*bool> {needUnlock} v2
      • v97 (+158) = MOVQstore <mem> [16] v2 v92 v93
      • v100 (+154) = MOVLstoreconst <mem> [val=8,off=0] v2 v97
      • v94 (?) = LEAQ <*func(*bool)> {"".main.func2·f} v3
      • v102 (154) = MOVQstore <mem> [8] v2 v94 v100
      • v103 (154) = CALLstatic <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b17: ← b15
      • v107 (+162) = CALLstatic <mem> {"".nanotime} [8] v103
      • v108 (162) = MOVQload <int64> v2 v107
      • v110 (162) = MOVQstore <mem> {"".runtimeInitTime} v3 v108 v107
      • v111 (+164) = CALLstatic <mem> {"".gcenable} v110
      • v112 (?) = LEAQ <*uint8> {type.chan bool} v3
      • v114 (+166) = MOVQstore <mem> v2 v112 v111
      • v117 (166) = MOVQstoreconst <mem> [val=0,off=8] v2 v114
      • v118 (166) = CALLstatic <mem> {runtime.makechan} [24] v117
      • v120 (166) = MOVQload <chan bool> [16] v2 v118
      • v252 (166) = CMPLconstload <flags> {runtime.writeBarrier} [val=0,off=0] v3 v118
    • NE v252b34 b6 (unlikely) (line 166)
    • b6: ← b17
      • v39 (166) = MOVQstore <mem> {"".main_init_done} v3 v120 v118
    • Plainb52 (line 166)
    • b52: ← b34 b6
      • v122 (166) = Phi <mem> v40 v39
      • v123 (?) = LEAQ <*bool> {"".iscgo} v3
      • v248 (+167) = CMPBconstload <flags> [val=0,off=0] v123 v122
    • NE v248b19 b50 (line 167)
    • b19: ← b52
      • v25 (+168) = CMPQconstload <flags> {_cgo_thread_start} [val=0,off=0] v3 v122
    • NE v25b23 b21 (likely) (line 168)
    • b23: ← b19
      • v249 (+172) = CMPQconstload <flags> {""._cgo_setenv} [val=0,off=0] v3 v122
    • NE v249b26 b25 (likely) (line 172)
    • b26: ← b23
      • v167 (+175) = CMPQconstload <flags> {""._cgo_unsetenv} [val=0,off=0] v3 v122
    • NE v167b24 b27 (likely) (line 175)
    • b24: ← b26
      • v18 (+179) = CMPQconstload <flags> {_cgo_notify_runtime_init_done} [val=0,off=0] v3 v122
    • NE v18b30 b29 (likely) (line 179)
    • b30: ← b24
      • v159 (+184) = CALLstatic <mem> {"".startTemplateThread} v122
      • v161 (+185) = MOVQload <unsafe.Pointer> {_cgo_notify_runtime_init_done} v3 v159
      • v163 (185) = MOVQstore <mem> v2 v161 v159
      • v165 (185) = MOVQstoreconst <mem> [val=0,off=8] v2 v163
      • v166 (185) = CALLstatic <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b20: ← b50 b30
      • v169 (189) = Phi <mem> v122 v166
      • v168 (?) = LEAQ <*func()> {"".main_init·f} v3 (fn[func()])
      • v170 (+189) = MOVQload <uintptr> {"".main_init·f} v3 v169
      • v171 (189) = CALLclosure <mem> [0] v170 v168 v169
      • v173 (+190) = MOVQload <chan bool> {"".main_init_done} v3 v171
      • v175 (190) = MOVQstore <mem> v2 v173 v171
      • v176 (190) = CALLstatic <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v179 (+192) = MOVBstoreconst <mem> {needUnlock} [val=0,off=0] v2 v177
      • v180 (+193) = CALLstatic <mem> {"".unlockOSThread} v179
      • v181 (?) = LEAQ <*bool> {"".isarchive} v3
      • v147 (+195) = CMPBconstload <flags> [val=0,off=0] v181 v180
    • NE v147b49 b33 (unlikely) (line 195)
    • b33: ← b20
      • v183 (?) = LEAQ <*bool> {"".islibrary} v3
      • v79 (195) = CMPBconstload <flags> [val=0,off=0] v183 v180
    • NE v79b45 b35 (unlikely) (line 195)
    • b35: ← b33
      • v188 (?) = LEAQ <*func()> {"".main_main·f} v3 (fn[func()])
      • v190 (+201) = MOVQload <uintptr> {"".main_main·f} v3 v180
      • v191 (201) = CALLclosure <mem> [0] v190 v188 v180
      • v194 (+210) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v191
      • v196 (210) = Select0 <uint32> v194
      • v195 (210) = Select1 <mem> v194
      • v250 (210) = TESTL <flags> v196 v196
    • NE v250b36 b38 (line 210)
    • b36: ← b35
      • v115 (?) = MOVQconst <int> [0] (c[int])
    • Plainb39 (line 212)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v115 v212 (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v56 (+212) = CMPQconst <flags> [1000] v199
    • LT v56b40 b44 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v245
      • v206 (213) = Select0 <uint32> v204
      • v205 (213) = Select1 <mem> v204
      • v52 (213) = TESTL <flags> v206 v206
    • EQ v52b43 b41 (unlikely) (line 213)
    • b41: ← b40
      • v209 (+216) = CALLstatic <mem> {"".Gosched} v205
      • v212 (+212) = ADDQconst <int> [1] v199 (c[int])
    • Plainb39 (line 212)
    • b43: ← b40
    • Plainb42 (line +214)
    • b42: ← b44 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = MOVLatomicload <uint32,mem> {"".panicking} v3 v214
      • v217 (219) = Select0 <uint32> v215
      • v216 (219) = Select1 <mem> v215
      • v63 (219) = TESTL <flags> v217 v217
    • NE v63b46 b48 (unlikely) (line 219)
    • b48: ← b37
    • Plainb47 (line +223)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = MOVLstoreconst <mem> [val=0,off=0] v2 v235
      • v237 (223) = CALLstatic <mem> {"".exit} [8] v236
      • v238 (?) = MOVQconst <*int32> [0] (x[*int32])
    • Plainb51 (line +224)
    • b51: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
      • v241 (+226) = MOVLstoreconst <mem> [val=0,off=0] v238 v244
    • Plainb51 (line +226)
    • b46: ← b37
      • v253 (220) = MOVOconst <int128> [0]
      • v223 (+220) = MOVOstore <mem> v2 v253 v216
      • v229 (220) = MOVWstoreconst <mem> [val=4104,off=16] v2 v223
      • v231 (220) = MOVQstoreconst <mem> [val=1,off=24] v2 v229
      • v232 (220) = CALLstatic <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b44: ← b39
    • Plainb42 (line 212)
    • b38: ← b35
    • Plainb37 (line +219)
    • b45: ← b33
    • Plainb31 (line 195)
    • b31: ← b49 b45
      • v187 (+198) = CALLstatic <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b49: ← b20
    • Plainb31 (line 195)
    • b50: ← b52
    • Plainb20 (line 167)
    • b34: ← b17
      • v121 (?) = LEAQ <*chan bool> {"".main_init_done} v3
      • v40 (166) = LoweredWB <mem> {runtime.gcWriteBarrier} v121 v120 v118
    • Plainb52 (line 166)
    • b18: ← b15
      • v105 (154) = CALLstatic <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b29: ← b24
      • v139 (?) = LEAQ <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3
      • v151 (+180) = MOVQstore <mem> v2 v139 v122
      • v156 (+180) = MOVQstoreconst <mem> [val=37,off=8] v2 v151
      • v157 (180) = CALLstatic <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b27: ← b26
      • v155 (?) = LEAQ <*uint8> {go.string."_cgo_unsetenv missing"} v3
      • v28 (+176) = MOVQstore <mem> v2 v155 v122
      • v148 (+176) = MOVQstoreconst <mem> [val=21,off=8] v2 v28
      • v149 (176) = CALLstatic <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b25: ← b23
      • v189 (?) = LEAQ <*uint8> {go.string."_cgo_setenv missing"} v3
      • v38 (+173) = MOVQstore <mem> v2 v189 v122
      • v140 (+173) = MOVQstoreconst <mem> [val=19,off=8] v2 v38
      • v141 (173) = CALLstatic <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b21: ← b19
      • v203 (?) = LEAQ <*uint8> {go.string."_cgo_thread_start missing"} v3
      • v129 (+169) = MOVQstore <mem> v2 v203 v122
      • v132 (+169) = MOVQstoreconst <mem> [val=25,off=8] v2 v129
      • v133 (169) = CALLstatic <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b14: ← b13
      • v221 (?) = LEAQ <*uint8> {go.string."nanotime returning zero"} v3
      • v153 (+149) = MOVQstore <mem> v2 v221 v81
      • v88 (+149) = MOVQstoreconst <mem> [val=23,off=8] v2 v153
      • v89 (149) = CALLstatic <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b12: ← b11
      • v243 (?) = LEAQ <*uint8> {go.string."runtime.main not on m0"} v3
      • v41 (+144) = MOVQstore <mem> v2 v243 v66
      • v77 (+144) = MOVQstoreconst <mem> [val=22,off=8] v2 v41
      • v78 (144) = CALLstatic <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • regalloc [598089 ns]

    • b11:
      • v1 (?) = InitMem <mem>
      • v4 (+111) = LoweredGetG <*g> v1 : AX (g[*g])
      • v57 (+111) = StoreReg <*g> v4 : g[*g]
      • v8 (+115) = MOVQload <*m> [48] v4 v1 : CX
      • v11 (115) = MOVQload <*g> v8 v1 : CX
      • v14 (115) = MOVQstoreconst <mem> [val=0,off=304] v11 v1
      • v3 (?) = SB <uintptr> : SB
      • v19 (+121) = MOVQstoreconst <mem> {"".maxstacksize} [val=1000000000,off=0] v3 v14
      • v22 (+127) = MOVBstoreconst <mem> {"".mainStarted} [val=1,off=0] v3 v19
      • v2 (?) = SP <uintptr> : SP
      • v45 (130) = LEAQ <*func()> {"".main.func1·f} v3 : CX
      • v26 (+130) = MOVQstore <mem> v2 v45 v22
      • v27 (130) = CALLstatic <mem> {"".systemstack} [8] v26
      • v29 (+3614) = LoweredGetG <*g> v27 : AX
      • v32 (3614) = MOVQload <*m> [48] v29 v27 : AX
      • v43 (3614) = ADDLconstmodify <mem> [val=1,off=620] v32 v27
      • v46 (+3575) = LoweredGetG <*g> v43 : AX (_g_[*g], g[*g])
      • v49 (3576) = MOVQload <*m> [48] v46 v43 : CX
      • v51 (+3576) = ADDQconst <*guintptr> [352] v49 : DX (gp[*guintptr])
      • v54 (205) = LoweredNilCheck <void> v51 v43
      • v247 (205) = Copy <*g> v46 : DX
      • v53 (+205) = Convert <guintptr> v46 v43 : AX
      • v55 (205) = MOVQstore <mem> [352] v49 v53 v43
      • v59 (+3577) = ADDQconst <*muintptr> [216] v247 : AX (mp[*muintptr])
      • v65 (243) = LoweredNilCheck <void> v59 v55
      • v62 (3577) = MOVQload <*m> [48] v247 v55 : AX (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55 : AX
      • v66 (243) = MOVQstore <mem> [216] v247 v64 v55
      • v207 (143) = LEAQ <*m> {"".m0} v3 : AX
      • v201 (143) = LoadReg <*g> v57 : CX
      • v172 (+143) = CMPQload <flags> [48] v201 v207 v66
    • NE v172b12 b13 (unlikely) (line 143)
    • b13: ← b11
      • v80 (+147) = CALLstatic <mem> {runtime.init} v66
      • v81 (+148) = CALLstatic <mem> {"".nanotime} [8] v80
      • v251 (148) = CMPQconstload <flags> [val=0,off=0] v2 v81
    • EQ v251b14 b15 (unlikely) (line 148)
    • b15: ← b13
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v93 (+153) = MOVBstoreconst <mem> {needUnlock} [val=1,off=0] v2 v91
      • v67 (158) = LEAQ <*bool> {needUnlock} v2 : AX
      • v97 (+158) = MOVQstore <mem> [16] v2 v67 v93
      • v100 (+154) = MOVLstoreconst <mem> [val=8,off=0] v2 v97
      • v218 (154) = LEAQ <*func(*bool)> {"".main.func2·f} v3 : AX
      • v102 (154) = MOVQstore <mem> [8] v2 v218 v100
      • v103 (154) = CALLstatic <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b17: ← b15
      • v107 (+162) = CALLstatic <mem> {"".nanotime} [8] v103
      • v108 (162) = MOVQload <int64> v2 v107 : AX
      • v110 (162) = MOVQstore <mem> {"".runtimeInitTime} v3 v108 v107
      • v111 (+164) = CALLstatic <mem> {"".gcenable} v110
      • v68 (166) = LEAQ <*uint8> {type.chan bool} v3 : AX
      • v114 (+166) = MOVQstore <mem> v2 v68 v111
      • v117 (166) = MOVQstoreconst <mem> [val=0,off=8] v2 v114
      • v118 (166) = CALLstatic <mem> {runtime.makechan} [24] v117
      • v120 (166) = MOVQload <chan bool> [16] v2 v118 : AX
      • v252 (166) = CMPLconstload <flags> {runtime.writeBarrier} [val=0,off=0] v3 v118
    • NE v252b34 b6 (unlikely) (line 166)
    • b6: ← b17
      • v39 (166) = MOVQstore <mem> {"".main_init_done} v3 v120 v118
    • Plainb52 (line 166)
    • b52: ← b34 b6
      • v122 (166) = Phi <mem> v40 v39
      • v76 (167) = LEAQ <*bool> {"".iscgo} v3 : AX
      • v248 (+167) = CMPBconstload <flags> [val=0,off=0] v76 v122
    • NE v248b19 b50 (line 167)
    • b19: ← b52
      • v25 (+168) = CMPQconstload <flags> {_cgo_thread_start} [val=0,off=0] v3 v122
    • NE v25b23 b21 (likely) (line 168)
    • b23: ← b19
      • v249 (+172) = CMPQconstload <flags> {""._cgo_setenv} [val=0,off=0] v3 v122
    • NE v249b26 b25 (likely) (line 172)
    • b26: ← b23
      • v167 (+175) = CMPQconstload <flags> {""._cgo_unsetenv} [val=0,off=0] v3 v122
    • NE v167b24 b27 (likely) (line 175)
    • b24: ← b26
      • v18 (+179) = CMPQconstload <flags> {_cgo_notify_runtime_init_done} [val=0,off=0] v3 v122
    • NE v18b30 b29 (likely) (line 179)
    • b30: ← b24
      • v159 (+184) = CALLstatic <mem> {"".startTemplateThread} v122
      • v161 (+185) = MOVQload <unsafe.Pointer> {_cgo_notify_runtime_init_done} v3 v159 : AX
      • v163 (185) = MOVQstore <mem> v2 v161 v159
      • v165 (185) = MOVQstoreconst <mem> [val=0,off=8] v2 v163
      • v166 (185) = CALLstatic <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b20: ← b50 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = MOVQload <uintptr> {"".main_init·f} v3 v169 : AX
      • v198 (189) = LEAQ <*func()> {"".main_init·f} v3 : DX
      • v171 (189) = CALLclosure <mem> [0] v170 v198 v169
      • v173 (+190) = MOVQload <chan bool> {"".main_init_done} v3 v171 : AX
      • v175 (190) = MOVQstore <mem> v2 v173 v171
      • v176 (190) = CALLstatic <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v179 (+192) = MOVBstoreconst <mem> {needUnlock} [val=0,off=0] v2 v177
      • v180 (+193) = CALLstatic <mem> {"".unlockOSThread} v179
      • v87 (195) = LEAQ <*bool> {"".isarchive} v3 : AX
      • v147 (+195) = CMPBconstload <flags> [val=0,off=0] v87 v180
    • NE v147b49 b33 (unlikely) (line 195)
    • b33: ← b20
      • v21 (195) = LEAQ <*bool> {"".islibrary} v3 : AX
      • v79 (195) = CMPBconstload <flags> [val=0,off=0] v21 v180
    • NE v79b45 b35 (unlikely) (line 195)
    • b35: ← b33
      • v190 (+201) = MOVQload <uintptr> {"".main_main·f} v3 v180 : AX
      • v30 (201) = LEAQ <*func()> {"".main_main·f} v3 : DX
      • v191 (201) = CALLclosure <mem> [0] v190 v30 v180
      • v194 (+210) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v191 : <AX,nil>
      • v196 (210) = Select0 <uint32> v194 : AX
      • v195 (210) = Select1 <mem> v194
      • v250 (210) = TESTL <flags> v196 v196
    • NE v250b36 b38 (line 210)
    • b36: ← b35
      • v131 (?) = MOVQconst <int> [0] : AX
    • Plainb39 (line 212)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v131 v212 : AX (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v56 (+212) = CMPQconst <flags> [1000] v199
    • LT v56b40 b44 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v245 : <CX,nil>
      • v206 (213) = Select0 <uint32> v204 : CX
      • v205 (213) = Select1 <mem> v204
      • v52 (213) = TESTL <flags> v206 v206
    • EQ v52b43 b41 (unlikely) (line 213)
    • b41: ← b40
      • v6 (212) = StoreReg <int> v199 : c[int]
      • v209 (+216) = CALLstatic <mem> {"".Gosched} v205
      • v106 (212) = LoadReg <int> v6 : AX
      • v212 (+212) = ADDQconst <int> [1] v106 : AX (c[int])
    • Plainb39 (line 212)
    • b43: ← b40
    • Plainb42 (line +214)
    • b42: ← b44 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = MOVLatomicload <uint32,mem> {"".panicking} v3 v214 : <AX,nil>
      • v217 (219) = Select0 <uint32> v215 : AX
      • v216 (219) = Select1 <mem> v215
      • v63 (219) = TESTL <flags> v217 v217
    • NE v63b46 b48 (unlikely) (line 219)
    • b48: ← b37
    • Plainb47 (line +223)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = MOVLstoreconst <mem> [val=0,off=0] v2 v235
      • v237 (223) = CALLstatic <mem> {"".exit} [8] v236
    • Plainb51 (line +224)
    • b51: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
      • v47 (226) = MOVQconst <*int32> [0] : AX
      • v241 (+226) = MOVLstoreconst <mem> [val=0,off=0] v47 v244
    • Plainb51 (line +226)
    • b46: ← b37
      • v208 (220) = MOVOconst <int128> [0] : X0
      • v223 (+220) = MOVOstore <mem> v2 v208 v216
      • v229 (220) = MOVWstoreconst <mem> [val=4104,off=16] v2 v223
      • v231 (220) = MOVQstoreconst <mem> [val=1,off=24] v2 v229
      • v232 (220) = CALLstatic <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b44: ← b39
    • Plainb42 (line 212)
    • b38: ← b35
    • Plainb37 (line +219)
    • b45: ← b33
    • Plainb31 (line 195)
    • b31: ← b49 b45
      • v187 (+198) = CALLstatic <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b49: ← b20
    • Plainb31 (line 195)
    • b50: ← b52
    • Plainb20 (line 167)
    • b34: ← b17
      • v104 (166) = LEAQ <*chan bool> {"".main_init_done} v3 : DI
      • v40 (166) = LoweredWB <mem> {runtime.gcWriteBarrier} v104 v120 v118
    • Plainb52 (line 166)
    • b18: ← b15
      • v105 (154) = CALLstatic <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b29: ← b24
      • v130 (180) = LEAQ <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3 : AX
      • v151 (+180) = MOVQstore <mem> v2 v130 v122
      • v156 (+180) = MOVQstoreconst <mem> [val=37,off=8] v2 v151
      • v157 (180) = CALLstatic <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b27: ← b26
      • v178 (176) = LEAQ <*uint8> {go.string."_cgo_unsetenv missing"} v3 : AX
      • v28 (+176) = MOVQstore <mem> v2 v178 v122
      • v148 (+176) = MOVQstoreconst <mem> [val=21,off=8] v2 v28
      • v149 (176) = CALLstatic <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b25: ← b23
      • v74 (173) = LEAQ <*uint8> {go.string."_cgo_setenv missing"} v3 : AX
      • v38 (+173) = MOVQstore <mem> v2 v74 v122
      • v140 (+173) = MOVQstoreconst <mem> [val=19,off=8] v2 v38
      • v141 (173) = CALLstatic <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b21: ← b19
      • v137 (169) = LEAQ <*uint8> {go.string."_cgo_thread_start missing"} v3 : AX
      • v129 (+169) = MOVQstore <mem> v2 v137 v122
      • v132 (+169) = MOVQstoreconst <mem> [val=25,off=8] v2 v129
      • v133 (169) = CALLstatic <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b14: ← b13
      • v126 (149) = LEAQ <*uint8> {go.string."nanotime returning zero"} v3 : AX
      • v153 (+149) = MOVQstore <mem> v2 v126 v81
      • v88 (+149) = MOVQstoreconst <mem> [val=23,off=8] v2 v153
      • v89 (149) = CALLstatic <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b12: ← b11
      • v186 (144) = LEAQ <*uint8> {go.string."runtime.main not on m0"} v3 : AX
      • v41 (+144) = MOVQstore <mem> v2 v186 v66
      • v77 (+144) = MOVQstoreconst <mem> [val=22,off=8] v2 v41
      • v78 (144) = CALLstatic <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • loop rotate [10326 ns]

    • b11:
      • v1 (?) = InitMem <mem>
      • v4 (+111) = LoweredGetG <*g> v1 : AX (g[*g])
      • v57 (+111) = StoreReg <*g> v4 : g[*g]
      • v8 (+115) = MOVQload <*m> [48] v4 v1 : CX
      • v11 (115) = MOVQload <*g> v8 v1 : CX
      • v14 (115) = MOVQstoreconst <mem> [val=0,off=304] v11 v1
      • v3 (?) = SB <uintptr> : SB
      • v19 (+121) = MOVQstoreconst <mem> {"".maxstacksize} [val=1000000000,off=0] v3 v14
      • v22 (+127) = MOVBstoreconst <mem> {"".mainStarted} [val=1,off=0] v3 v19
      • v2 (?) = SP <uintptr> : SP
      • v45 (130) = LEAQ <*func()> {"".main.func1·f} v3 : CX
      • v26 (+130) = MOVQstore <mem> v2 v45 v22
      • v27 (130) = CALLstatic <mem> {"".systemstack} [8] v26
      • v29 (+3614) = LoweredGetG <*g> v27 : AX
      • v32 (3614) = MOVQload <*m> [48] v29 v27 : AX
      • v43 (3614) = ADDLconstmodify <mem> [val=1,off=620] v32 v27
      • v46 (+3575) = LoweredGetG <*g> v43 : AX (_g_[*g], g[*g])
      • v49 (3576) = MOVQload <*m> [48] v46 v43 : CX
      • v51 (+3576) = ADDQconst <*guintptr> [352] v49 : DX (gp[*guintptr])
      • v54 (205) = LoweredNilCheck <void> v51 v43
      • v247 (205) = Copy <*g> v46 : DX
      • v53 (+205) = Convert <guintptr> v46 v43 : AX
      • v55 (205) = MOVQstore <mem> [352] v49 v53 v43
      • v59 (+3577) = ADDQconst <*muintptr> [216] v247 : AX (mp[*muintptr])
      • v65 (243) = LoweredNilCheck <void> v59 v55
      • v62 (3577) = MOVQload <*m> [48] v247 v55 : AX (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55 : AX
      • v66 (243) = MOVQstore <mem> [216] v247 v64 v55
      • v207 (143) = LEAQ <*m> {"".m0} v3 : AX
      • v201 (143) = LoadReg <*g> v57 : CX
      • v172 (+143) = CMPQload <flags> [48] v201 v207 v66
    • NE v172b12 b13 (unlikely) (line 143)
    • b13: ← b11
      • v80 (+147) = CALLstatic <mem> {runtime.init} v66
      • v81 (+148) = CALLstatic <mem> {"".nanotime} [8] v80
      • v251 (148) = CMPQconstload <flags> [val=0,off=0] v2 v81
    • EQ v251b14 b15 (unlikely) (line 148)
    • b15: ← b13
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v93 (+153) = MOVBstoreconst <mem> {needUnlock} [val=1,off=0] v2 v91
      • v67 (158) = LEAQ <*bool> {needUnlock} v2 : AX
      • v97 (+158) = MOVQstore <mem> [16] v2 v67 v93
      • v100 (+154) = MOVLstoreconst <mem> [val=8,off=0] v2 v97
      • v218 (154) = LEAQ <*func(*bool)> {"".main.func2·f} v3 : AX
      • v102 (154) = MOVQstore <mem> [8] v2 v218 v100
      • v103 (154) = CALLstatic <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b17: ← b15
      • v107 (+162) = CALLstatic <mem> {"".nanotime} [8] v103
      • v108 (162) = MOVQload <int64> v2 v107 : AX
      • v110 (162) = MOVQstore <mem> {"".runtimeInitTime} v3 v108 v107
      • v111 (+164) = CALLstatic <mem> {"".gcenable} v110
      • v68 (166) = LEAQ <*uint8> {type.chan bool} v3 : AX
      • v114 (+166) = MOVQstore <mem> v2 v68 v111
      • v117 (166) = MOVQstoreconst <mem> [val=0,off=8] v2 v114
      • v118 (166) = CALLstatic <mem> {runtime.makechan} [24] v117
      • v120 (166) = MOVQload <chan bool> [16] v2 v118 : AX
      • v252 (166) = CMPLconstload <flags> {runtime.writeBarrier} [val=0,off=0] v3 v118
    • NE v252b34 b6 (unlikely) (line 166)
    • b6: ← b17
      • v39 (166) = MOVQstore <mem> {"".main_init_done} v3 v120 v118
    • Plainb52 (line 166)
    • b52: ← b34 b6
      • v122 (166) = Phi <mem> v40 v39
      • v76 (167) = LEAQ <*bool> {"".iscgo} v3 : AX
      • v248 (+167) = CMPBconstload <flags> [val=0,off=0] v76 v122
    • NE v248b19 b50 (line 167)
    • b19: ← b52
      • v25 (+168) = CMPQconstload <flags> {_cgo_thread_start} [val=0,off=0] v3 v122
    • NE v25b23 b21 (likely) (line 168)
    • b23: ← b19
      • v249 (+172) = CMPQconstload <flags> {""._cgo_setenv} [val=0,off=0] v3 v122
    • NE v249b26 b25 (likely) (line 172)
    • b26: ← b23
      • v167 (+175) = CMPQconstload <flags> {""._cgo_unsetenv} [val=0,off=0] v3 v122
    • NE v167b24 b27 (likely) (line 175)
    • b24: ← b26
      • v18 (+179) = CMPQconstload <flags> {_cgo_notify_runtime_init_done} [val=0,off=0] v3 v122
    • NE v18b30 b29 (likely) (line 179)
    • b30: ← b24
      • v159 (+184) = CALLstatic <mem> {"".startTemplateThread} v122
      • v161 (+185) = MOVQload <unsafe.Pointer> {_cgo_notify_runtime_init_done} v3 v159 : AX
      • v163 (185) = MOVQstore <mem> v2 v161 v159
      • v165 (185) = MOVQstoreconst <mem> [val=0,off=8] v2 v163
      • v166 (185) = CALLstatic <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b20: ← b50 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = MOVQload <uintptr> {"".main_init·f} v3 v169 : AX
      • v198 (189) = LEAQ <*func()> {"".main_init·f} v3 : DX
      • v171 (189) = CALLclosure <mem> [0] v170 v198 v169
      • v173 (+190) = MOVQload <chan bool> {"".main_init_done} v3 v171 : AX
      • v175 (190) = MOVQstore <mem> v2 v173 v171
      • v176 (190) = CALLstatic <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v179 (+192) = MOVBstoreconst <mem> {needUnlock} [val=0,off=0] v2 v177
      • v180 (+193) = CALLstatic <mem> {"".unlockOSThread} v179
      • v87 (195) = LEAQ <*bool> {"".isarchive} v3 : AX
      • v147 (+195) = CMPBconstload <flags> [val=0,off=0] v87 v180
    • NE v147b49 b33 (unlikely) (line 195)
    • b33: ← b20
      • v21 (195) = LEAQ <*bool> {"".islibrary} v3 : AX
      • v79 (195) = CMPBconstload <flags> [val=0,off=0] v21 v180
    • NE v79b45 b35 (unlikely) (line 195)
    • b35: ← b33
      • v190 (+201) = MOVQload <uintptr> {"".main_main·f} v3 v180 : AX
      • v30 (201) = LEAQ <*func()> {"".main_main·f} v3 : DX
      • v191 (201) = CALLclosure <mem> [0] v190 v30 v180
      • v194 (+210) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v191 : <AX,nil>
      • v196 (210) = Select0 <uint32> v194 : AX
      • v195 (210) = Select1 <mem> v194
      • v250 (210) = TESTL <flags> v196 v196
    • NE v250b36 b38 (line 210)
    • b36: ← b35
      • v131 (?) = MOVQconst <int> [0] : AX
    • Plainb39 (line 212)
    • b41: ← b40
      • v6 (212) = StoreReg <int> v199 : c[int]
      • v209 (+216) = CALLstatic <mem> {"".Gosched} v205
      • v106 (212) = LoadReg <int> v6 : AX
      • v212 (+212) = ADDQconst <int> [1] v106 : AX (c[int])
    • Plainb39 (line 212)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v131 v212 : AX (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v56 (+212) = CMPQconst <flags> [1000] v199
    • LT v56b40 b44 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v245 : <CX,nil>
      • v206 (213) = Select0 <uint32> v204 : CX
      • v205 (213) = Select1 <mem> v204
      • v52 (213) = TESTL <flags> v206 v206
    • EQ v52b43 b41 (unlikely) (line 213)
    • b43: ← b40
    • Plainb42 (line +214)
    • b42: ← b44 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = MOVLatomicload <uint32,mem> {"".panicking} v3 v214 : <AX,nil>
      • v217 (219) = Select0 <uint32> v215 : AX
      • v216 (219) = Select1 <mem> v215
      • v63 (219) = TESTL <flags> v217 v217
    • NE v63b46 b48 (unlikely) (line 219)
    • b48: ← b37
    • Plainb47 (line +223)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = MOVLstoreconst <mem> [val=0,off=0] v2 v235
      • v237 (223) = CALLstatic <mem> {"".exit} [8] v236
    • Plainb51 (line +224)
    • b51: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
      • v47 (226) = MOVQconst <*int32> [0] : AX
      • v241 (+226) = MOVLstoreconst <mem> [val=0,off=0] v47 v244
    • Plainb51 (line +226)
    • b46: ← b37
      • v208 (220) = MOVOconst <int128> [0] : X0
      • v223 (+220) = MOVOstore <mem> v2 v208 v216
      • v229 (220) = MOVWstoreconst <mem> [val=4104,off=16] v2 v223
      • v231 (220) = MOVQstoreconst <mem> [val=1,off=24] v2 v229
      • v232 (220) = CALLstatic <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b44: ← b39
    • Plainb42 (line 212)
    • b38: ← b35
    • Plainb37 (line +219)
    • b45: ← b33
    • Plainb31 (line 195)
    • b31: ← b49 b45
      • v187 (+198) = CALLstatic <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b49: ← b20
    • Plainb31 (line 195)
    • b50: ← b52
    • Plainb20 (line 167)
    • b34: ← b17
      • v104 (166) = LEAQ <*chan bool> {"".main_init_done} v3 : DI
      • v40 (166) = LoweredWB <mem> {runtime.gcWriteBarrier} v104 v120 v118
    • Plainb52 (line 166)
    • b18: ← b15
      • v105 (154) = CALLstatic <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b29: ← b24
      • v130 (180) = LEAQ <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3 : AX
      • v151 (+180) = MOVQstore <mem> v2 v130 v122
      • v156 (+180) = MOVQstoreconst <mem> [val=37,off=8] v2 v151
      • v157 (180) = CALLstatic <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b27: ← b26
      • v178 (176) = LEAQ <*uint8> {go.string."_cgo_unsetenv missing"} v3 : AX
      • v28 (+176) = MOVQstore <mem> v2 v178 v122
      • v148 (+176) = MOVQstoreconst <mem> [val=21,off=8] v2 v28
      • v149 (176) = CALLstatic <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b25: ← b23
      • v74 (173) = LEAQ <*uint8> {go.string."_cgo_setenv missing"} v3 : AX
      • v38 (+173) = MOVQstore <mem> v2 v74 v122
      • v140 (+173) = MOVQstoreconst <mem> [val=19,off=8] v2 v38
      • v141 (173) = CALLstatic <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b21: ← b19
      • v137 (169) = LEAQ <*uint8> {go.string."_cgo_thread_start missing"} v3 : AX
      • v129 (+169) = MOVQstore <mem> v2 v137 v122
      • v132 (+169) = MOVQstoreconst <mem> [val=25,off=8] v2 v129
      • v133 (169) = CALLstatic <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b14: ← b13
      • v126 (149) = LEAQ <*uint8> {go.string."nanotime returning zero"} v3 : AX
      • v153 (+149) = MOVQstore <mem> v2 v126 v81
      • v88 (+149) = MOVQstoreconst <mem> [val=23,off=8] v2 v153
      • v89 (149) = CALLstatic <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b12: ← b11
      • v186 (144) = LEAQ <*uint8> {go.string."runtime.main not on m0"} v3 : AX
      • v41 (+144) = MOVQstore <mem> v2 v186 v66
      • v77 (+144) = MOVQstoreconst <mem> [val=22,off=8] v2 v41
      • v78 (144) = CALLstatic <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • stackframe [26111 ns]

    • b11:
      • v1 (?) = InitMem <mem>
      • v4 (+111) = LoweredGetG <*g> v1 : AX (g[*g])
      • v57 (+111) = StoreReg <*g> v4 : g[*g]
      • v8 (+115) = MOVQload <*m> [48] v4 v1 : CX
      • v11 (115) = MOVQload <*g> v8 v1 : CX
      • v14 (115) = MOVQstoreconst <mem> [val=0,off=304] v11 v1
      • v3 (?) = SB <uintptr> : SB
      • v19 (+121) = MOVQstoreconst <mem> {"".maxstacksize} [val=1000000000,off=0] v3 v14
      • v22 (+127) = MOVBstoreconst <mem> {"".mainStarted} [val=1,off=0] v3 v19
      • v2 (?) = SP <uintptr> : SP
      • v45 (130) = LEAQ <*func()> {"".main.func1·f} v3 : CX
      • v26 (+130) = MOVQstore <mem> v2 v45 v22
      • v27 (130) = CALLstatic <mem> {"".systemstack} [8] v26
      • v29 (+3614) = LoweredGetG <*g> v27 : AX
      • v32 (3614) = MOVQload <*m> [48] v29 v27 : AX
      • v43 (3614) = ADDLconstmodify <mem> [val=1,off=620] v32 v27
      • v46 (+3575) = LoweredGetG <*g> v43 : AX (_g_[*g], g[*g])
      • v49 (3576) = MOVQload <*m> [48] v46 v43 : CX
      • v51 (+3576) = ADDQconst <*guintptr> [352] v49 : DX (gp[*guintptr])
      • v54 (205) = LoweredNilCheck <void> v51 v43
      • v247 (205) = Copy <*g> v46 : DX
      • v53 (+205) = Convert <guintptr> v46 v43 : AX
      • v55 (205) = MOVQstore <mem> [352] v49 v53 v43
      • v59 (+3577) = ADDQconst <*muintptr> [216] v247 : AX (mp[*muintptr])
      • v65 (243) = LoweredNilCheck <void> v59 v55
      • v62 (3577) = MOVQload <*m> [48] v247 v55 : AX (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55 : AX
      • v66 (243) = MOVQstore <mem> [216] v247 v64 v55
      • v207 (143) = LEAQ <*m> {"".m0} v3 : AX
      • v201 (143) = LoadReg <*g> v57 : CX
      • v172 (+143) = CMPQload <flags> [48] v201 v207 v66
    • NE v172b12 b13 (unlikely) (line 143)
    • b13: ← b11
      • v80 (+147) = CALLstatic <mem> {runtime.init} v66
      • v81 (+148) = CALLstatic <mem> {"".nanotime} [8] v80
      • v251 (148) = CMPQconstload <flags> [val=0,off=0] v2 v81
    • EQ v251b14 b15 (unlikely) (line 148)
    • b15: ← b13
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v93 (+153) = MOVBstoreconst <mem> {needUnlock} [val=1,off=0] v2 v91
      • v67 (158) = LEAQ <*bool> {needUnlock} v2 : AX
      • v97 (+158) = MOVQstore <mem> [16] v2 v67 v93
      • v100 (+154) = MOVLstoreconst <mem> [val=8,off=0] v2 v97
      • v218 (154) = LEAQ <*func(*bool)> {"".main.func2·f} v3 : AX
      • v102 (154) = MOVQstore <mem> [8] v2 v218 v100
      • v103 (154) = CALLstatic <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b17: ← b15
      • v107 (+162) = CALLstatic <mem> {"".nanotime} [8] v103
      • v108 (162) = MOVQload <int64> v2 v107 : AX
      • v110 (162) = MOVQstore <mem> {"".runtimeInitTime} v3 v108 v107
      • v111 (+164) = CALLstatic <mem> {"".gcenable} v110
      • v68 (166) = LEAQ <*uint8> {type.chan bool} v3 : AX
      • v114 (+166) = MOVQstore <mem> v2 v68 v111
      • v117 (166) = MOVQstoreconst <mem> [val=0,off=8] v2 v114
      • v118 (166) = CALLstatic <mem> {runtime.makechan} [24] v117
      • v120 (166) = MOVQload <chan bool> [16] v2 v118 : AX
      • v252 (166) = CMPLconstload <flags> {runtime.writeBarrier} [val=0,off=0] v3 v118
    • NE v252b34 b6 (unlikely) (line 166)
    • b6: ← b17
      • v39 (166) = MOVQstore <mem> {"".main_init_done} v3 v120 v118
    • Plainb52 (line 166)
    • b52: ← b34 b6
      • v122 (166) = Phi <mem> v40 v39
      • v76 (167) = LEAQ <*bool> {"".iscgo} v3 : AX
      • v248 (+167) = CMPBconstload <flags> [val=0,off=0] v76 v122
    • NE v248b19 b50 (line 167)
    • b19: ← b52
      • v25 (+168) = CMPQconstload <flags> {_cgo_thread_start} [val=0,off=0] v3 v122
    • NE v25b23 b21 (likely) (line 168)
    • b23: ← b19
      • v249 (+172) = CMPQconstload <flags> {""._cgo_setenv} [val=0,off=0] v3 v122
    • NE v249b26 b25 (likely) (line 172)
    • b26: ← b23
      • v167 (+175) = CMPQconstload <flags> {""._cgo_unsetenv} [val=0,off=0] v3 v122
    • NE v167b24 b27 (likely) (line 175)
    • b24: ← b26
      • v18 (+179) = CMPQconstload <flags> {_cgo_notify_runtime_init_done} [val=0,off=0] v3 v122
    • NE v18b30 b29 (likely) (line 179)
    • b30: ← b24
      • v159 (+184) = CALLstatic <mem> {"".startTemplateThread} v122
      • v161 (+185) = MOVQload <unsafe.Pointer> {_cgo_notify_runtime_init_done} v3 v159 : AX
      • v163 (185) = MOVQstore <mem> v2 v161 v159
      • v165 (185) = MOVQstoreconst <mem> [val=0,off=8] v2 v163
      • v166 (185) = CALLstatic <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b20: ← b50 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = MOVQload <uintptr> {"".main_init·f} v3 v169 : AX
      • v198 (189) = LEAQ <*func()> {"".main_init·f} v3 : DX
      • v171 (189) = CALLclosure <mem> [0] v170 v198 v169
      • v173 (+190) = MOVQload <chan bool> {"".main_init_done} v3 v171 : AX
      • v175 (190) = MOVQstore <mem> v2 v173 v171
      • v176 (190) = CALLstatic <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v179 (+192) = MOVBstoreconst <mem> {needUnlock} [val=0,off=0] v2 v177
      • v180 (+193) = CALLstatic <mem> {"".unlockOSThread} v179
      • v87 (195) = LEAQ <*bool> {"".isarchive} v3 : AX
      • v147 (+195) = CMPBconstload <flags> [val=0,off=0] v87 v180
    • NE v147b49 b33 (unlikely) (line 195)
    • b33: ← b20
      • v21 (195) = LEAQ <*bool> {"".islibrary} v3 : AX
      • v79 (195) = CMPBconstload <flags> [val=0,off=0] v21 v180
    • NE v79b45 b35 (unlikely) (line 195)
    • b35: ← b33
      • v190 (+201) = MOVQload <uintptr> {"".main_main·f} v3 v180 : AX
      • v30 (201) = LEAQ <*func()> {"".main_main·f} v3 : DX
      • v191 (201) = CALLclosure <mem> [0] v190 v30 v180
      • v194 (+210) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v191 : <AX,nil>
      • v196 (210) = Select0 <uint32> v194 : AX
      • v195 (210) = Select1 <mem> v194
      • v250 (210) = TESTL <flags> v196 v196
    • NE v250b36 b38 (line 210)
    • b36: ← b35
      • v131 (?) = MOVQconst <int> [0] : AX
    • Plainb39 (line 212)
    • b41: ← b40
      • v6 (212) = StoreReg <int> v199 : c[int]
      • v209 (+216) = CALLstatic <mem> {"".Gosched} v205
      • v106 (212) = LoadReg <int> v6 : AX
      • v212 (+212) = ADDQconst <int> [1] v106 : AX (c[int])
    • Plainb39 (line 212)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v131 v212 : AX (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v56 (+212) = CMPQconst <flags> [1000] v199
    • LT v56b40 b44 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v245 : <CX,nil>
      • v206 (213) = Select0 <uint32> v204 : CX
      • v205 (213) = Select1 <mem> v204
      • v52 (213) = TESTL <flags> v206 v206
    • EQ v52b43 b41 (unlikely) (line 213)
    • b43: ← b40
    • Plainb42 (line +214)
    • b42: ← b44 b43
      • v246 (219) = Phi <mem> v245 v205
    • Plainb37 (line +219)
    • b37: ← b42 b38
      • v214 (219) = Phi <mem> v246 v195
      • v215 (+219) = MOVLatomicload <uint32,mem> {"".panicking} v3 v214 : <AX,nil>
      • v217 (219) = Select0 <uint32> v215 : AX
      • v216 (219) = Select1 <mem> v215
      • v63 (219) = TESTL <flags> v217 v217
    • NE v63b46 b48 (unlikely) (line 219)
    • b48: ← b37
    • Plainb47 (line +223)
    • b47: ← b46 b48
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = MOVLstoreconst <mem> [val=0,off=0] v2 v235
      • v237 (223) = CALLstatic <mem> {"".exit} [8] v236
    • Plainb51 (line +224)
    • b51: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
      • v47 (226) = MOVQconst <*int32> [0] : AX
      • v241 (+226) = MOVLstoreconst <mem> [val=0,off=0] v47 v244
    • Plainb51 (line +226)
    • b46: ← b37
      • v208 (220) = MOVOconst <int128> [0] : X0
      • v223 (+220) = MOVOstore <mem> v2 v208 v216
      • v229 (220) = MOVWstoreconst <mem> [val=4104,off=16] v2 v223
      • v231 (220) = MOVQstoreconst <mem> [val=1,off=24] v2 v229
      • v232 (220) = CALLstatic <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b44: ← b39
    • Plainb42 (line 212)
    • b38: ← b35
    • Plainb37 (line +219)
    • b45: ← b33
    • Plainb31 (line 195)
    • b31: ← b49 b45
      • v187 (+198) = CALLstatic <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b49: ← b20
    • Plainb31 (line 195)
    • b50: ← b52
    • Plainb20 (line 167)
    • b34: ← b17
      • v104 (166) = LEAQ <*chan bool> {"".main_init_done} v3 : DI
      • v40 (166) = LoweredWB <mem> {runtime.gcWriteBarrier} v104 v120 v118
    • Plainb52 (line 166)
    • b18: ← b15
      • v105 (154) = CALLstatic <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b29: ← b24
      • v130 (180) = LEAQ <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3 : AX
      • v151 (+180) = MOVQstore <mem> v2 v130 v122
      • v156 (+180) = MOVQstoreconst <mem> [val=37,off=8] v2 v151
      • v157 (180) = CALLstatic <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b27: ← b26
      • v178 (176) = LEAQ <*uint8> {go.string."_cgo_unsetenv missing"} v3 : AX
      • v28 (+176) = MOVQstore <mem> v2 v178 v122
      • v148 (+176) = MOVQstoreconst <mem> [val=21,off=8] v2 v28
      • v149 (176) = CALLstatic <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b25: ← b23
      • v74 (173) = LEAQ <*uint8> {go.string."_cgo_setenv missing"} v3 : AX
      • v38 (+173) = MOVQstore <mem> v2 v74 v122
      • v140 (+173) = MOVQstoreconst <mem> [val=19,off=8] v2 v38
      • v141 (173) = CALLstatic <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b21: ← b19
      • v137 (169) = LEAQ <*uint8> {go.string."_cgo_thread_start missing"} v3 : AX
      • v129 (+169) = MOVQstore <mem> v2 v137 v122
      • v132 (+169) = MOVQstoreconst <mem> [val=25,off=8] v2 v129
      • v133 (169) = CALLstatic <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b14: ← b13
      • v126 (149) = LEAQ <*uint8> {go.string."nanotime returning zero"} v3 : AX
      • v153 (+149) = MOVQstore <mem> v2 v126 v81
      • v88 (+149) = MOVQstoreconst <mem> [val=23,off=8] v2 v153
      • v89 (149) = CALLstatic <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b12: ← b11
      • v186 (144) = LEAQ <*uint8> {go.string."runtime.main not on m0"} v3 : AX
      • v41 (+144) = MOVQstore <mem> v2 v186 v66
      • v77 (+144) = MOVQstoreconst <mem> [val=22,off=8] v2 v41
      • v78 (144) = CALLstatic <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • trim [7080 ns]

    • b11:
      • v1 (?) = InitMem <mem>
      • v4 (+111) = LoweredGetG <*g> v1 : AX (g[*g])
      • v57 (+111) = StoreReg <*g> v4 : g[*g]
      • v8 (+115) = MOVQload <*m> [48] v4 v1 : CX
      • v11 (115) = MOVQload <*g> v8 v1 : CX
      • v14 (115) = MOVQstoreconst <mem> [val=0,off=304] v11 v1
      • v3 (?) = SB <uintptr> : SB
      • v19 (+121) = MOVQstoreconst <mem> {"".maxstacksize} [val=1000000000,off=0] v3 v14
      • v22 (+127) = MOVBstoreconst <mem> {"".mainStarted} [val=1,off=0] v3 v19
      • v2 (?) = SP <uintptr> : SP
      • v45 (130) = LEAQ <*func()> {"".main.func1·f} v3 : CX
      • v26 (+130) = MOVQstore <mem> v2 v45 v22
      • v27 (130) = CALLstatic <mem> {"".systemstack} [8] v26
      • v29 (+3614) = LoweredGetG <*g> v27 : AX
      • v32 (3614) = MOVQload <*m> [48] v29 v27 : AX
      • v43 (3614) = ADDLconstmodify <mem> [val=1,off=620] v32 v27
      • v46 (+3575) = LoweredGetG <*g> v43 : AX (_g_[*g], g[*g])
      • v49 (3576) = MOVQload <*m> [48] v46 v43 : CX
      • v51 (+3576) = ADDQconst <*guintptr> [352] v49 : DX (gp[*guintptr])
      • v54 (205) = LoweredNilCheck <void> v51 v43
      • v247 (205) = Copy <*g> v46 : DX
      • v53 (+205) = Convert <guintptr> v46 v43 : AX
      • v55 (205) = MOVQstore <mem> [352] v49 v53 v43
      • v59 (+3577) = ADDQconst <*muintptr> [216] v247 : AX (mp[*muintptr])
      • v65 (243) = LoweredNilCheck <void> v59 v55
      • v62 (3577) = MOVQload <*m> [48] v247 v55 : AX (m[*m])
      • v64 (+243) = Convert <muintptr> v62 v55 : AX
      • v66 (243) = MOVQstore <mem> [216] v247 v64 v55
      • v207 (143) = LEAQ <*m> {"".m0} v3 : AX
      • v201 (143) = LoadReg <*g> v57 : CX
      • v172 (+143) = CMPQload <flags> [48] v201 v207 v66
    • NE v172b12 b13 (unlikely) (line 143)
    • b13: ← b11
      • v80 (+147) = CALLstatic <mem> {runtime.init} v66
      • v81 (+148) = CALLstatic <mem> {"".nanotime} [8] v80
      • v251 (148) = CMPQconstload <flags> [val=0,off=0] v2 v81
    • EQ v251b14 b15 (unlikely) (line 148)
    • b15: ← b13
      • v91 (153) = VarDef <mem> {needUnlock} v81
      • v93 (+153) = MOVBstoreconst <mem> {needUnlock} [val=1,off=0] v2 v91
      • v67 (158) = LEAQ <*bool> {needUnlock} v2 : AX
      • v97 (+158) = MOVQstore <mem> [16] v2 v67 v93
      • v100 (+154) = MOVLstoreconst <mem> [val=8,off=0] v2 v97
      • v218 (154) = LEAQ <*func(*bool)> {"".main.func2·f} v3 : AX
      • v102 (154) = MOVQstore <mem> [8] v2 v218 v100
      • v103 (154) = CALLstatic <mem> {runtime.deferproc} [24] v102
    • Defer v103b17 b18 (likely) (line 154)
    • b17: ← b15
      • v107 (+162) = CALLstatic <mem> {"".nanotime} [8] v103
      • v108 (162) = MOVQload <int64> v2 v107 : AX
      • v110 (162) = MOVQstore <mem> {"".runtimeInitTime} v3 v108 v107
      • v111 (+164) = CALLstatic <mem> {"".gcenable} v110
      • v68 (166) = LEAQ <*uint8> {type.chan bool} v3 : AX
      • v114 (+166) = MOVQstore <mem> v2 v68 v111
      • v117 (166) = MOVQstoreconst <mem> [val=0,off=8] v2 v114
      • v118 (166) = CALLstatic <mem> {runtime.makechan} [24] v117
      • v120 (166) = MOVQload <chan bool> [16] v2 v118 : AX
      • v252 (166) = CMPLconstload <flags> {runtime.writeBarrier} [val=0,off=0] v3 v118
    • NE v252b34 b6 (unlikely) (line 166)
    • b6: ← b17
      • v39 (166) = MOVQstore <mem> {"".main_init_done} v3 v120 v118
    • Plainb52 (line 166)
    • b52: ← b34 b6
      • v122 (166) = Phi <mem> v40 v39
      • v76 (167) = LEAQ <*bool> {"".iscgo} v3 : AX
      • v248 (+167) = CMPBconstload <flags> [val=0,off=0] v76 v122
    • NE v248b19 b20 (line 167)
    • b19: ← b52
      • v25 (+168) = CMPQconstload <flags> {_cgo_thread_start} [val=0,off=0] v3 v122
    • NE v25b23 b21 (likely) (line 168)
    • b23: ← b19
      • v249 (+172) = CMPQconstload <flags> {""._cgo_setenv} [val=0,off=0] v3 v122
    • NE v249b26 b25 (likely) (line 172)
    • b26: ← b23
      • v167 (+175) = CMPQconstload <flags> {""._cgo_unsetenv} [val=0,off=0] v3 v122
    • NE v167b24 b27 (likely) (line 175)
    • b24: ← b26
      • v18 (+179) = CMPQconstload <flags> {_cgo_notify_runtime_init_done} [val=0,off=0] v3 v122
    • NE v18b30 b29 (likely) (line 179)
    • b30: ← b24
      • v159 (+184) = CALLstatic <mem> {"".startTemplateThread} v122
      • v161 (+185) = MOVQload <unsafe.Pointer> {_cgo_notify_runtime_init_done} v3 v159 : AX
      • v163 (185) = MOVQstore <mem> v2 v161 v159
      • v165 (185) = MOVQstoreconst <mem> [val=0,off=8] v2 v163
      • v166 (185) = CALLstatic <mem> {"".cgocall} [24] v165
    • Plainb20 (line 185)
    • b20: ← b52 b30
      • v169 (189) = Phi <mem> v122 v166
      • v170 (+189) = MOVQload <uintptr> {"".main_init·f} v3 v169 : AX
      • v198 (189) = LEAQ <*func()> {"".main_init·f} v3 : DX
      • v171 (189) = CALLclosure <mem> [0] v170 v198 v169
      • v173 (+190) = MOVQload <chan bool> {"".main_init_done} v3 v171 : AX
      • v175 (190) = MOVQstore <mem> v2 v173 v171
      • v176 (190) = CALLstatic <mem> {runtime.closechan} [8] v175
      • v177 (192) = VarDef <mem> {needUnlock} v176
      • v179 (+192) = MOVBstoreconst <mem> {needUnlock} [val=0,off=0] v2 v177
      • v180 (+193) = CALLstatic <mem> {"".unlockOSThread} v179
      • v87 (195) = LEAQ <*bool> {"".isarchive} v3 : AX
      • v147 (+195) = CMPBconstload <flags> [val=0,off=0] v87 v180
    • NE v147b31 b33 (unlikely) (line 195)
    • b33: ← b20
      • v21 (195) = LEAQ <*bool> {"".islibrary} v3 : AX
      • v79 (195) = CMPBconstload <flags> [val=0,off=0] v21 v180
    • NE v79b31 b35 (unlikely) (line 195)
    • b35: ← b33
      • v190 (+201) = MOVQload <uintptr> {"".main_main·f} v3 v180 : AX
      • v30 (201) = LEAQ <*func()> {"".main_main·f} v3 : DX
      • v191 (201) = CALLclosure <mem> [0] v190 v30 v180
      • v194 (+210) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v191 : <AX,nil>
      • v196 (210) = Select0 <uint32> v194 : AX
      • v195 (210) = Select1 <mem> v194
      • v250 (210) = TESTL <flags> v196 v196
    • NE v250b36 b37 (line 210)
    • b36: ← b35
      • v131 (?) = MOVQconst <int> [0] : AX
    • Plainb39 (line 212)
    • b41: ← b40
      • v6 (212) = StoreReg <int> v199 : c[int]
      • v209 (+216) = CALLstatic <mem> {"".Gosched} v205
      • v106 (212) = LoadReg <int> v6 : AX
      • v212 (+212) = ADDQconst <int> [1] v106 : AX (c[int])
    • Plainb39 (line 212)
    • b39: ← b36 b41
      • v199 (212) = Phi <int> v131 v212 : AX (c[int])
      • v245 (213) = Phi <mem> v195 v209
      • v56 (+212) = CMPQconst <flags> [1000] v199
    • LT v56b40 b37 (likely) (line 212)
    • b40: ← b39
      • v204 (+213) = MOVLatomicload <uint32,mem> {"".runningPanicDefers} v3 v245 : <CX,nil>
      • v206 (213) = Select0 <uint32> v204 : CX
      • v205 (213) = Select1 <mem> v204
      • v52 (213) = TESTL <flags> v206 v206
    • EQ v52b37 b41 (unlikely) (line 213)
    • b37: ← b39 b35 b40
      • v214 (219) = Phi <mem> v245 v195 v205
      • v215 (+219) = MOVLatomicload <uint32,mem> {"".panicking} v3 v214 : <AX,nil>
      • v217 (219) = Select0 <uint32> v215 : AX
      • v216 (219) = Select1 <mem> v215
      • v63 (219) = TESTL <flags> v217 v217
    • NE v63b46 b47 (unlikely) (line 219)
    • b47: ← b46 b37
      • v235 (223) = Phi <mem> v232 v216
      • v236 (+223) = MOVLstoreconst <mem> [val=0,off=0] v2 v235
      • v237 (223) = CALLstatic <mem> {"".exit} [8] v236
    • Plainb51 (line +224)
    • b51: ← b47 b51
      • v244 (226) = Phi <mem> v237 v241
      • v47 (226) = MOVQconst <*int32> [0] : AX
      • v241 (+226) = MOVLstoreconst <mem> [val=0,off=0] v47 v244
    • Plainb51 (line +226)
    • b46: ← b37
      • v208 (220) = MOVOconst <int128> [0] : X0
      • v223 (+220) = MOVOstore <mem> v2 v208 v216
      • v229 (220) = MOVWstoreconst <mem> [val=4104,off=16] v2 v223
      • v231 (220) = MOVQstoreconst <mem> [val=1,off=24] v2 v229
      • v232 (220) = CALLstatic <mem> {"".gopark} [32] v231
    • Plainb47 (line 220)
    • b31: ← b20 b33
      • v187 (+198) = CALLstatic <mem> {runtime.deferreturn} v180
    • Ret v187 (line +198)
    • b34: ← b17
      • v104 (166) = LEAQ <*chan bool> {"".main_init_done} v3 : DI
      • v40 (166) = LoweredWB <mem> {runtime.gcWriteBarrier} v104 v120 v118
    • Plainb52 (line 166)
    • b18: ← b15
      • v105 (154) = CALLstatic <mem> {runtime.deferreturn} v103
    • Ret v105 (line 154)
    • b29: ← b24
      • v130 (180) = LEAQ <*uint8> {go.string."_cgo_notify_runtime_init_done missing"} v3 : AX
      • v151 (+180) = MOVQstore <mem> v2 v130 v122
      • v156 (+180) = MOVQstoreconst <mem> [val=37,off=8] v2 v151
      • v157 (180) = CALLstatic <mem> {"".throw} [16] v156
    • Exit v157 (line 180)
    • b27: ← b26
      • v178 (176) = LEAQ <*uint8> {go.string."_cgo_unsetenv missing"} v3 : AX
      • v28 (+176) = MOVQstore <mem> v2 v178 v122
      • v148 (+176) = MOVQstoreconst <mem> [val=21,off=8] v2 v28
      • v149 (176) = CALLstatic <mem> {"".throw} [16] v148
    • Exit v149 (line 176)
    • b25: ← b23
      • v74 (173) = LEAQ <*uint8> {go.string."_cgo_setenv missing"} v3 : AX
      • v38 (+173) = MOVQstore <mem> v2 v74 v122
      • v140 (+173) = MOVQstoreconst <mem> [val=19,off=8] v2 v38
      • v141 (173) = CALLstatic <mem> {"".throw} [16] v140
    • Exit v141 (line 173)
    • b21: ← b19
      • v137 (169) = LEAQ <*uint8> {go.string."_cgo_thread_start missing"} v3 : AX
      • v129 (+169) = MOVQstore <mem> v2 v137 v122
      • v132 (+169) = MOVQstoreconst <mem> [val=25,off=8] v2 v129
      • v133 (169) = CALLstatic <mem> {"".throw} [16] v132
    • Exit v133 (line 169)
    • b14: ← b13
      • v126 (149) = LEAQ <*uint8> {go.string."nanotime returning zero"} v3 : AX
      • v153 (+149) = MOVQstore <mem> v2 v126 v81
      • v88 (+149) = MOVQstoreconst <mem> [val=23,off=8] v2 v153
      • v89 (149) = CALLstatic <mem> {"".throw} [16] v88
    • Exit v89 (line 149)
    • b12: ← b11
      • v186 (144) = LEAQ <*uint8> {go.string."runtime.main not on m0"} v3 : AX
      • v41 (+144) = MOVQstore <mem> v2 v186 v66
      • v77 (+144) = MOVQstoreconst <mem> [val=22,off=8] v2 v41
      • v78 (144) = CALLstatic <mem> {"".throw} [16] v77
    • Exit v78 (line 144)
  • name g[*g]: v4
  • name _g_[*g]: v46
  • name gp[*guintptr]: v51
  • name g[*g]: v46
  • name mp[*muintptr]: v59
  • name m[*m]: v62
  • name fn[func()]: v168 v188
  • name c[int]: v115 v199 v212
  • name x[*int32]: v238
  • genssa

    # /data/app/go/src/gosrc/go/src/runtime/proc.go
    00000 (110) TEXT "".main(SB)
    00001 (110) FUNCDATA $0, gclocals·69c1753bd5f81501d95132d08af04464(SB)
    00002 (110) FUNCDATA $1, gclocals·9fb7f0986f647f17cb53dda1484e0f7a(SB)
    00003 (110) FUNCDATA $3, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
    v4
    00004 (+111) MOVQ (TLS), AX
    v57
    00005 (111) MOVQ AX, "".g-8(SP)
    v8
    00006 (+115) MOVQ 48(AX), CX
    v11
    00007 (115) MOVQ (CX), CX
    v14
    00008 (115) MOVQ $0, 304(CX)
    v19
    00009 (+121) MOVQ $1000000000, "".maxstacksize(SB)
    v22
    00010 (+127) MOVB $1, "".mainStarted(SB)
    v45
    00011 (+130) LEAQ "".main.func1·f(SB), CX
    v26
    00012 (130) MOVQ CX, (SP)
    v27
    00013 (130) PCDATA $2, $0
    v27
    00014 (130) PCDATA $0, $1
    v27
    00015 (130) CALL "".systemstack(SB)
    v29
    00016 (+3614) PCDATA $2, $-2
    v29
    00017 (+3614) PCDATA $0, $-2
    v29
    00018 (+3614) MOVQ (TLS), AX
    v32
    00019 (3614) MOVQ 48(AX), AX
    v43
    00020 (3614) INCL 620(AX)
    v46
    00021 (+3575) MOVQ (TLS), AX
    v49
    00022 (+3576) MOVQ 48(AX), CX
    v51
    00023 (3576) LEAQ 352(CX), DX
    # /data/app/go/src/gosrc/go/src/runtime/runtime2.go
    v54
    00024 (205) TESTB AX, (DX)
    v247
    00025 (205) MOVQ AX, DX
    v55
    00026 (205) MOVQ AX, 352(CX)
    # /data/app/go/src/gosrc/go/src/runtime/proc.go
    v59
    00027 (+3577) LEAQ 216(DX), AX
    # /data/app/go/src/gosrc/go/src/runtime/runtime2.go
    v65
    00028 (243) TESTB AX, (AX)
    # /data/app/go/src/gosrc/go/src/runtime/proc.go
    v62
    00029 (3577) MOVQ 48(DX), AX
    # /data/app/go/src/gosrc/go/src/runtime/runtime2.go
    v66
    00030 (243) MOVQ AX, 216(DX)
    # /data/app/go/src/gosrc/go/src/runtime/proc.go
    v207
    00031 (+143) LEAQ "".m0(SB), AX
    v201
    00032 (143) MOVQ "".g-8(SP), CX
    v172
    00033 (143) CMPQ 48(CX), AX
    b11
    00034 (143) JNE 229
    v80
    00035 (+147) PCDATA $2, $0
    v80
    00036 (+147) PCDATA $0, $0
    v80
    00037 (+147) CALL runtime.init(SB)
    v81
    00038 (+148) CALL "".nanotime(SB)
    v251
    00039 (148) PCDATA $2, $-2
    v251
    00040 (148) PCDATA $0, $-2
    v251
    00041 (148) CMPQ (SP), $0
    b13
    00042 (148) JEQ 220
    v93
    00043 (+153) MOVB $1, "".needUnlock-17(SP)
    v67
    00044 (+158) LEAQ "".needUnlock-17(SP), AX
    v97
    00045 (158) MOVQ AX, 16(SP)
    v100
    00046 (+154) MOVL $8, (SP)
    v218
    00047 (154) LEAQ "".main.func2·f(SB), AX
    v102
    00048 (154) MOVQ AX, 8(SP)
    v103
    00049 (154) PCDATA $2, $0
    v103
    00050 (154) PCDATA $0, $0
    v103
    00051 (154) CALL runtime.deferproc(SB)
    b15
    00052 (154) TESTL AX, AX
    b15
    00053 (154) JNE 179
    v107
    00054 (+162) CALL "".nanotime(SB)
    v108
    00055 (162) PCDATA $2, $-2
    v108
    00056 (162) PCDATA $0, $-2
    v108
    00057 (162) MOVQ (SP), AX
    v110
    00058 (162) MOVQ AX, "".runtimeInitTime(SB)
    v111
    00059 (+164) PCDATA $2, $0
    v111
    00060 (+164) PCDATA $0, $0
    v111
    00061 (+164) CALL "".gcenable(SB)
    v68
    00062 (166) PCDATA $2, $-2
    v68
    00063 (166) PCDATA $0, $-2
    v68
    00064 (+166) LEAQ type.chan bool(SB), AX
    v114
    00065 (166) MOVQ AX, (SP)
    v117
    00066 (166) MOVQ $0, 8(SP)
    v118
    00067 (166) PCDATA $2, $0
    v118
    00068 (166) PCDATA $0, $0
    v118
    00069 (166) CALL runtime.makechan(SB)
    v120
    00070 (166) PCDATA $2, $-2
    v120
    00071 (166) PCDATA $0, $-2
    v120
    00072 (166) MOVQ 16(SP), AX
    v252
    00073 (166) CMPL runtime.writeBarrier(SB), $0
    b17
    00074 (166) JNE 174
    v39
    00075 (166) MOVQ AX, "".main_init_done(SB)
    v76
    00076 (+167) LEAQ "".iscgo(SB), AX
    v248
    00077 (167) CMPB (AX), $0
    b52
    00078 (167) JEQ 98
    v25
    00079 (+168) CMPQ _cgo_thread_start(SB), $0
    b19
    00080 (168) JEQ 211
    v249
    00081 (+172) CMPQ ""._cgo_setenv(SB), $0
    b23
    00082 (172) JEQ 202
    v167
    00083 (+175) CMPQ ""._cgo_unsetenv(SB), $0
    b26
    00084 (175) JEQ 193
    v18
    00085 (+179) CMPQ _cgo_notify_runtime_init_done(SB), $0
    b24
    00086 (179) JEQ 184
    v159
    00087 (+184) PCDATA $2, $0
    v159
    00088 (+184) PCDATA $0, $0
    v159
    00089 (+184) CALL "".startTemplateThread(SB)
    v161
    00090 (+185) PCDATA $2, $-2
    v161
    00091 (+185) PCDATA $0, $-2
    v161
    00092 (+185) MOVQ _cgo_notify_runtime_init_done(SB), AX
    v163
    00093 (185) MOVQ AX, (SP)
    v165
    00094 (185) MOVQ $0, 8(SP)
    v166
    00095 (185) PCDATA $2, $0
    v166
    00096 (185) PCDATA $0, $0
    v166
    00097 (185) CALL "".cgocall(SB)
    v170
    00098 (+189) PCDATA $2, $-2
    v170
    00099 (+189) PCDATA $0, $-2
    v170
    00100 (+189) MOVQ "".main_init·f(SB), AX
    v198
    00101 (189) LEAQ "".main_init·f(SB), DX
    v171
    00102 (189) PCDATA $2, $0
    v171
    00103 (189) PCDATA $0, $0
    v171
    00104 (189) CALL AX
    v173
    00105 (+190) PCDATA $2, $-2
    v173
    00106 (+190) PCDATA $0, $-2
    v173
    00107 (+190) MOVQ "".main_init_done(SB), AX
    v175
    00108 (190) MOVQ AX, (SP)
    v176
    00109 (190) PCDATA $2, $0
    v176
    00110 (190) PCDATA $0, $0
    v176
    00111 (190) CALL runtime.closechan(SB)
    v179
    00112 (+192) PCDATA $2, $-2
    v179
    00113 (+192) PCDATA $0, $-2
    v179
    00114 (+192) MOVB $0, "".needUnlock-17(SP)
    v180
    00115 (+193) PCDATA $2, $0
    v180
    00116 (+193) PCDATA $0, $0
    v180
    00117 (+193) CALL "".unlockOSThread(SB)
    v87
    00118 (195) PCDATA $2, $-2
    v87
    00119 (195) PCDATA $0, $-2
    v87
    00120 (+195) LEAQ "".isarchive(SB), AX
    v147
    00121 (195) CMPB (AX), $0
    b20
    00122 (195) JNE 171
    v21
    00123 (195) LEAQ "".islibrary(SB), AX
    v79
    00124 (195) CMPB (AX), $0
    b33
    00125 (195) JNE 171
    v190
    00126 (+201) MOVQ "".main_main·f(SB), AX
    v30
    00127 (201) LEAQ "".main_main·f(SB), DX
    v191
    00128 (201) PCDATA $2, $0
    v191
    00129 (201) PCDATA $0, $0
    v191
    00130 (201) CALL AX
    v194
    00131 (+210) PCDATA $2, $-2
    v194
    00132 (+210) PCDATA $0, $-2
    v194
    00133 (+210) MOVL "".runningPanicDefers(SB), AX
    v250
    00134 (210) TESTL AX, AX
    b35
    00135 (210) JEQ 151
    v131
    00136 (210) XORL AX, AX
    b36
    00137 (212) JMP 146
    v6
    00138 (212) MOVQ AX, "".c-16(SP)
    v209
    00139 (+216) PCDATA $2, $0
    v209
    00140 (+216) PCDATA $0, $0
    v209
    00141 (+216) CALL "".Gosched(SB)
    v106
    00142 (212) PCDATA $2, $-2
    v106
    00143 (212) PCDATA $0, $-2
    v106
    00144 (+212) MOVQ "".c-16(SP), AX
    v212
    00145 (212) INCQ AX
    v56
    00146 (+212) CMPQ AX, $1000
    b39
    00147 (212) JGE 151
    v204
    00148 (+213) MOVL "".runningPanicDefers(SB), CX
    v52
    00149 (213) TESTL CX, CX
    b40
    00150 (213) JNE 138
    v215
    00151 (+219) MOVL "".panicking(SB), AX
    v63
    00152 (219) TESTL AX, AX
    b37
    00153 (219) JNE 163
    v236
    00154 (+223) MOVL $0, (SP)
    v237
    00155 (223) PCDATA $2, $0
    v237
    00156 (223) PCDATA $0, $0
    v237
    00157 (223) CALL "".exit(SB)
    v47
    00158 (226) PCDATA $2, $-2
    v47
    00159 (226) PCDATA $0, $-2
    v47
    00160 (+226) XORL AX, AX
    v241
    00161 (226) MOVL $0, (AX)
    b51
    00162 (226) JMP 158
    v208
    00163 (+220) XORPS X0, X0
    v223
    00164 (220) MOVUPS X0, (SP)
    v229
    00165 (220) MOVW $4104, 16(SP)
    v231
    00166 (220) MOVQ $1, 24(SP)
    v232
    00167 (220) PCDATA $2, $0
    v232
    00168 (220) PCDATA $0, $0
    v232
    00169 (220) CALL "".gopark(SB)
    b46
    00170 (220) JMP 154
    v187
    00171 (+198) XCHGL AX, AX
    v187
    00172 (+198) CALL runtime.deferreturn(SB)
    b31
    00173 (198) RET
    v104
    00174 (166) PCDATA $2, $-2
    v104
    00175 (166) PCDATA $0, $-2
    v104
    00176 (166) LEAQ "".main_init_done(SB), DI
    v40
    00177 (166) CALL runtime.gcWriteBarrier(SB)
    b34
    00178 (166) JMP 76
    v105
    00179 (154) PCDATA $2, $0
    v105
    00180 (154) PCDATA $0, $0
    v105
    00181 (154) XCHGL AX, AX
    v105
    00182 (154) CALL runtime.deferreturn(SB)
    b18
    00183 (154) RET
    v130
    00184 (180) PCDATA $2, $-2
    v130
    00185 (180) PCDATA $0, $-2
    v130
    00186 (+180) LEAQ go.string."_cgo_notify_runtime_init_done missing"(SB), AX
    v151
    00187 (180) MOVQ AX, (SP)
    v156
    00188 (180) MOVQ $37, 8(SP)
    v157
    00189 (180) PCDATA $2, $0
    v157
    00190 (180) PCDATA $0, $0
    v157
    00191 (180) CALL "".throw(SB)
    b29
    00192 (180) UNDEF
    v178
    00193 (176) PCDATA $2, $-2
    v178
    00194 (176) PCDATA $0, $-2
    v178
    00195 (+176) LEAQ go.string."_cgo_unsetenv missing"(SB), AX
    v28
    00196 (176) MOVQ AX, (SP)
    v148
    00197 (176) MOVQ $21, 8(SP)
    v149
    00198 (176) PCDATA $2, $0
    v149
    00199 (176) PCDATA $0, $0
    v149
    00200 (176) CALL "".throw(SB)
    b27
    00201 (176) UNDEF
    v74
    00202 (173) PCDATA $2, $-2
    v74
    00203 (173) PCDATA $0, $-2
    v74
    00204 (+173) LEAQ go.string."_cgo_setenv missing"(SB), AX
    v38
    00205 (173) MOVQ AX, (SP)
    v140
    00206 (173) MOVQ $19, 8(SP)
    v141
    00207 (173) PCDATA $2, $0
    v141
    00208 (173) PCDATA $0, $0
    v141
    00209 (173) CALL "".throw(SB)
    b25
    00210 (173) UNDEF
    v137
    00211 (169) PCDATA $2, $-2
    v137
    00212 (169) PCDATA $0, $-2
    v137
    00213 (+169) LEAQ go.string."_cgo_thread_start missing"(SB), AX
    v129
    00214 (169) MOVQ AX, (SP)
    v132
    00215 (169) MOVQ $25, 8(SP)
    v133
    00216 (169) PCDATA $2, $0
    v133
    00217 (169) PCDATA $0, $0
    v133
    00218 (169) CALL "".throw(SB)
    b21
    00219 (169) UNDEF
    v126
    00220 (149) PCDATA $2, $-2
    v126
    00221 (149) PCDATA $0, $-2
    v126
    00222 (+149) LEAQ go.string."nanotime returning zero"(SB), AX
    v153
    00223 (149) MOVQ AX, (SP)
    v88
    00224 (149) MOVQ $23, 8(SP)
    v89
    00225 (149) PCDATA $2, $0
    v89
    00226 (149) PCDATA $0, $0
    v89
    00227 (149) CALL "".throw(SB)
    b14
    00228 (149) UNDEF
    v186
    00229 (144) PCDATA $2, $-2
    v186
    00230 (144) PCDATA $0, $-2
    v186
    00231 (+144) LEAQ go.string."runtime.main not on m0"(SB), AX
    v41
    00232 (144) MOVQ AX, (SP)
    v77
    00233 (144) MOVQ $22, 8(SP)
    v78
    00234 (144) PCDATA $2, $0
    v78
    00235 (144) PCDATA $0, $0
    v78
    00236 (144) CALL "".throw(SB)
    b12
    00237 (144) UNDEF
    00238 (?) END