@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/runtime/asm_amd64.s

@@ -36,55 +36,22 @@ TEXT _rt0_amd64_lib(SB),NOSPLIT|NOFRAME,$0
 	MOVQ	DI, _rt0_amd64_lib_argc<>(SB)
 	MOVQ	SI, _rt0_amd64_lib_argv<>(SB)
 
-	// Synchronous initialization.
-#ifndef GOOS_windows
-	// Avoid calling it on Windows because it is not used
-	// and it would crash the application due to the autogenerated
-	// ABI wrapper trying to access a non-existent TLS slot.
-	CALL	runtime·libpreinit(SB)
-#endif
-
-	// Create a new thread to finish Go runtime initialization.
-	MOVQ	_cgo_sys_thread_create(SB), AX
-	TESTQ	AX, AX
-	JZ	nocgo
-
-	// We're calling back to C.
-	// Align stack per C ABI requirements.
-	MOVQ	SP, BX  // Callee-save in C ABI
-	ANDQ	$~15, SP
-	MOVQ	$_rt0_amd64_lib_go(SB), DI
-	MOVQ	$0, SI
-#ifdef GOOS_windows
-	// For Windows ABI
-	MOVQ	DI, CX
-	MOVQ	SI, DX
-	// Leave space for four words on the stack as required
-	// by the Windows amd64 calling convention.
-	ADJSP	$32
-#endif
-	CALL	AX
 #ifdef GOOS_windows
-	ADJSP	$-32 // just to make the assembler not complain about unbalanced stack
+	// Set up a dummy TLS value on Windows so that the autogenerated
+	// ABI wrappers don't crash when trying to load G from TLS before
+	// wintls has set up the real TLS slot in rt0_go.
+	MOVQ	$zeroTLS<>(SB), DI
+	CALL	runtime·settls(SB)
 #endif
-	MOVQ	BX, SP
-	JMP	restore
 
-nocgo:
-	ADJSP	$16
-	MOVQ	$0x800000, 0(SP)		// stacksize
-	MOVQ	$_rt0_amd64_lib_go(SB), AX
-	MOVQ	AX, 8(SP)			// fn
-	CALL	runtime·newosproc0(SB)
-	ADJSP	$-16
+	CALL	runtime·libInit(SB)
 
-restore:
 	POP_REGS_HOST_TO_ABI0()
 	RET
 
-// _rt0_amd64_lib_go initializes the Go runtime.
+// rt0_lib_go initializes the Go runtime.
 // This is started in a separate thread by _rt0_amd64_lib.
-TEXT _rt0_amd64_lib_go(SB),NOSPLIT,$0
+TEXT runtime·rt0_lib_go<ABIInternal>(SB),NOSPLIT,$0
 	MOVQ	_rt0_amd64_lib_argc<>(SB), DI
 	MOVQ	_rt0_amd64_lib_argv<>(SB), SI
 	JMP	runtime·rt0_go(SB)
@@ -510,6 +477,8 @@ goodm:
 // The frame layout needs to match systemstack
 // so that it can pretend to be systemstack_switch.
 TEXT runtime·systemstack_switch(SB), NOSPLIT, $0-0
+	// Align for consistency with offset used in gosave_systemstack_switch
+	PCALIGN	$8
 	UNDEF
 	// Make sure this function is not leaf,
 	// so the frame is saved.
@@ -885,8 +854,9 @@ TEXT ·publicationBarrier<ABIInternal>(SB),NOSPLIT,$0-0
 // Smashes R9.
 TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
 	// Take systemstack_switch PC and add 8 bytes to skip
-	// the prologue. The final location does not matter
-	// as long as we are between the prologue and the epilogue.
+	// the prologue. Keep 8 bytes offset consistent with
+	// PCALIGN $8 in systemstack_swtich, pointing start of
+	// UNDEF instruction beyond prologue.
 	MOVQ	$runtime·systemstack_switch+8(SB), R9
 	MOVQ	R9, (g_sched+gobuf_pc)(R14)
 	LEAQ	8(SP), R9
@@ -972,6 +942,11 @@ TEXT ·asmcgocall(SB),NOSPLIT,$0-20
 	JEQ	nosecret
 	CALL	·secretEraseRegisters(SB)
 
+	get_tls(CX)
+	MOVQ    g(CX), DI
+	MOVQ    g_m(DI), R8
+	MOVQ    m_g0(R8), SI
+
 nosecret:
 #endif
 	MOVQ	fn+0(FP), AX
@@ -1012,10 +987,6 @@ nosave:
 	// This code is like the above sequence but without saving/restoring g
 	// and without worrying about the stack moving out from under us
 	// (because we're on a system stack, not a goroutine stack).
-	// The above code could be used directly if already on a system stack,
-	// but then the only path through this code would be a rare case on Solaris.
-	// Using this code for all "already on system stack" calls exercises it more,
-	// which should help keep it correct.
 	MOVQ	fn+0(FP), AX
 	MOVQ	arg+8(FP), BX
 	MOVQ	SP, DX
@@ -1139,25 +1110,24 @@ havem:
 	// will seamlessly trace back into the earlier calls.
 	MOVQ	m_curg(BX), SI
 	MOVQ	SI, g(CX)
+	MOVQ	SI, R14 // set the g register, as required by ABIInternal.
+	XORPS	X15, X15 // clear X15, as required by ABIInternal.
 	MOVQ	(g_sched+gobuf_sp)(SI), DI  // prepare stack as DI
 	MOVQ	(g_sched+gobuf_pc)(SI), BX
 	MOVQ	BX, -8(DI)  // "push" return PC on the g stack
 	// Gather our arguments into registers.
-	MOVQ	fn+0(FP), BX
-	MOVQ	frame+8(FP), CX
-	MOVQ	ctxt+16(FP), DX
-	// Compute the size of the frame, including return PC and, if
-	// GOEXPERIMENT=framepointer, the saved base pointer
-	LEAQ	fn+0(FP), AX
-	SUBQ	SP, AX   // AX is our actual frame size
-	SUBQ	AX, DI   // Allocate the same frame size on the g stack
+	MOVQ	fn+0(FP), AX
+	MOVQ	frame+8(FP), BX
+	MOVQ	ctxt+16(FP), CX
+	// Compute the size of the frame, including the return PC and
+	// saved frame pointer
+	LEAQ	fn+0(FP), R8
+	SUBQ	SP, R8   // R8 is our actual frame size
+	SUBQ	R8, DI   // Allocate the same frame size on the g stack
 	MOVQ	DI, SP
 
-	MOVQ	BX, 0(SP)
-	MOVQ	CX, 8(SP)
-	MOVQ	DX, 16(SP)
-	MOVQ	$runtime·cgocallbackg(SB), AX
-	CALL	AX	// indirect call to bypass nosplit check. We're on a different stack now.
+	MOVQ	$runtime·cgocallbackg<ABIInternal>(SB), DX
+	CALL	DX	// indirect call to bypass nosplit check. We're on a different stack now.
 
 	// Compute the size of the frame again. FP and SP have
 	// completely different values here than they did above,
@@ -1278,483 +1248,6 @@ fences:
 	RDTSC
 	JMP done
 
-// func memhash(p unsafe.Pointer, h, s uintptr) uintptr
-// hash function using AES hardware instructions
-TEXT runtime·memhash<ABIInternal>(SB),NOSPLIT,$0-32
-	// AX = ptr to data
-	// BX = seed
-	// CX = size
-	CMPB	runtime·useAeshash(SB), $0
-	JEQ	noaes
-	JMP	aeshashbody<>(SB)
-noaes:
-	JMP	runtime·memhashFallback<ABIInternal>(SB)
-
-// func strhash(p unsafe.Pointer, h uintptr) uintptr
-TEXT runtime·strhash<ABIInternal>(SB),NOSPLIT,$0-24
-	// AX = ptr to string struct
-	// BX = seed
-	CMPB	runtime·useAeshash(SB), $0
-	JEQ	noaes
-	MOVQ	8(AX), CX	// length of string
-	MOVQ	(AX), AX	// string data
-	JMP	aeshashbody<>(SB)
-noaes:
-	JMP	runtime·strhashFallback<ABIInternal>(SB)
-
-// AX: data
-// BX: hash seed
-// CX: length
-// At return: AX = return value
-TEXT aeshashbody<>(SB),NOSPLIT,$0-0
-	// Fill an SSE register with our seeds.
-	MOVQ	BX, X0				// 64 bits of per-table hash seed
-	PINSRW	$4, CX, X0			// 16 bits of length
-	PSHUFHW $0, X0, X0			// repeat length 4 times total
-	MOVO	X0, X1				// save unscrambled seed
-	PXOR	runtime·aeskeysched(SB), X0	// xor in per-process seed
-	AESENC	X0, X0				// scramble seed
-
-	CMPQ	CX, $16
-	JB	aes0to15
-	JE	aes16
-	CMPQ	CX, $32
-	JBE	aes17to32
-	CMPQ	CX, $64
-	JBE	aes33to64
-	CMPQ	CX, $128
-	JBE	aes65to128
-	JMP	aes129plus
-
-aes0to15:
-	TESTQ	CX, CX
-	JE	aes0
-
-	ADDQ	$16, AX
-	TESTW	$0xff0, AX
-	JE	endofpage
-
-	// 16 bytes loaded at this address won't cross
-	// a page boundary, so we can load it directly.
-	MOVOU	-16(AX), X1
-	ADDQ	CX, CX
-	MOVQ	$masks<>(SB), AX
-	PAND	(AX)(CX*8), X1
-final1:
-	PXOR	X0, X1	// xor data with seed
-	AESENC	X1, X1	// scramble combo 3 times
-	AESENC	X1, X1
-	AESENC	X1, X1
-	MOVQ	X1, AX	// return X1
-	RET
-
-endofpage:
-	// address ends in 1111xxxx. Might be up against
-	// a page boundary, so load ending at last byte.
-	// Then shift bytes down using pshufb.
-	MOVOU	-32(AX)(CX*1), X1
-	ADDQ	CX, CX
-	MOVQ	$shifts<>(SB), AX
-	PSHUFB	(AX)(CX*8), X1
-	JMP	final1
-
-aes0:
-	// Return scrambled input seed
-	AESENC	X0, X0
-	MOVQ	X0, AX	// return X0
-	RET
-
-aes16:
-	MOVOU	(AX), X1
-	JMP	final1
-
-aes17to32:
-	// make second starting seed
-	PXOR	runtime·aeskeysched+16(SB), X1
-	AESENC	X1, X1
-
-	// load data to be hashed
-	MOVOU	(AX), X2
-	MOVOU	-16(AX)(CX*1), X3
-
-	// xor with seed
-	PXOR	X0, X2
-	PXOR	X1, X3
-
-	// scramble 3 times
-	AESENC	X2, X2
-	AESENC	X3, X3
-	AESENC	X2, X2
-	AESENC	X3, X3
-	AESENC	X2, X2
-	AESENC	X3, X3
-
-	// combine results
-	PXOR	X3, X2
-	MOVQ	X2, AX	// return X2
-	RET
-
-aes33to64:
-	// make 3 more starting seeds
-	MOVO	X1, X2
-	MOVO	X1, X3
-	PXOR	runtime·aeskeysched+16(SB), X1
-	PXOR	runtime·aeskeysched+32(SB), X2
-	PXOR	runtime·aeskeysched+48(SB), X3
-	AESENC	X1, X1
-	AESENC	X2, X2
-	AESENC	X3, X3
-
-	MOVOU	(AX), X4
-	MOVOU	16(AX), X5
-	MOVOU	-32(AX)(CX*1), X6
-	MOVOU	-16(AX)(CX*1), X7
-
-	PXOR	X0, X4
-	PXOR	X1, X5
-	PXOR	X2, X6
-	PXOR	X3, X7
-
-	AESENC	X4, X4
-	AESENC	X5, X5
-	AESENC	X6, X6
-	AESENC	X7, X7
-
-	AESENC	X4, X4
-	AESENC	X5, X5
-	AESENC	X6, X6
-	AESENC	X7, X7
-
-	AESENC	X4, X4
-	AESENC	X5, X5
-	AESENC	X6, X6
-	AESENC	X7, X7
-
-	PXOR	X6, X4
-	PXOR	X7, X5
-	PXOR	X5, X4
-	MOVQ	X4, AX	// return X4
-	RET
-
-aes65to128:
-	// make 7 more starting seeds
-	MOVO	X1, X2
-	MOVO	X1, X3
-	MOVO	X1, X4
-	MOVO	X1, X5
-	MOVO	X1, X6
-	MOVO	X1, X7
-	PXOR	runtime·aeskeysched+16(SB), X1
-	PXOR	runtime·aeskeysched+32(SB), X2
-	PXOR	runtime·aeskeysched+48(SB), X3
-	PXOR	runtime·aeskeysched+64(SB), X4
-	PXOR	runtime·aeskeysched+80(SB), X5
-	PXOR	runtime·aeskeysched+96(SB), X6
-	PXOR	runtime·aeskeysched+112(SB), X7
-	AESENC	X1, X1
-	AESENC	X2, X2
-	AESENC	X3, X3
-	AESENC	X4, X4
-	AESENC	X5, X5
-	AESENC	X6, X6
-	AESENC	X7, X7
-
-	// load data
-	MOVOU	(AX), X8
-	MOVOU	16(AX), X9
-	MOVOU	32(AX), X10
-	MOVOU	48(AX), X11
-	MOVOU	-64(AX)(CX*1), X12
-	MOVOU	-48(AX)(CX*1), X13
-	MOVOU	-32(AX)(CX*1), X14
-	MOVOU	-16(AX)(CX*1), X15
-
-	// xor with seed
-	PXOR	X0, X8
-	PXOR	X1, X9
-	PXOR	X2, X10
-	PXOR	X3, X11
-	PXOR	X4, X12
-	PXOR	X5, X13
-	PXOR	X6, X14
-	PXOR	X7, X15
-
-	// scramble 3 times
-	AESENC	X8, X8
-	AESENC	X9, X9
-	AESENC	X10, X10
-	AESENC	X11, X11
-	AESENC	X12, X12
-	AESENC	X13, X13
-	AESENC	X14, X14
-	AESENC	X15, X15
-
-	AESENC	X8, X8
-	AESENC	X9, X9
-	AESENC	X10, X10
-	AESENC	X11, X11
-	AESENC	X12, X12
-	AESENC	X13, X13
-	AESENC	X14, X14
-	AESENC	X15, X15
-
-	AESENC	X8, X8
-	AESENC	X9, X9
-	AESENC	X10, X10
-	AESENC	X11, X11
-	AESENC	X12, X12
-	AESENC	X13, X13
-	AESENC	X14, X14
-	AESENC	X15, X15
-
-	// combine results
-	PXOR	X12, X8
-	PXOR	X13, X9
-	PXOR	X14, X10
-	PXOR	X15, X11
-	PXOR	X10, X8
-	PXOR	X11, X9
-	PXOR	X9, X8
-	// X15 must be zero on return
-	PXOR	X15, X15
-	MOVQ	X8, AX	// return X8
-	RET
-
-aes129plus:
-	// make 7 more starting seeds
-	MOVO	X1, X2
-	MOVO	X1, X3
-	MOVO	X1, X4
-	MOVO	X1, X5
-	MOVO	X1, X6
-	MOVO	X1, X7
-	PXOR	runtime·aeskeysched+16(SB), X1
-	PXOR	runtime·aeskeysched+32(SB), X2
-	PXOR	runtime·aeskeysched+48(SB), X3
-	PXOR	runtime·aeskeysched+64(SB), X4
-	PXOR	runtime·aeskeysched+80(SB), X5
-	PXOR	runtime·aeskeysched+96(SB), X6
-	PXOR	runtime·aeskeysched+112(SB), X7
-	AESENC	X1, X1
-	AESENC	X2, X2
-	AESENC	X3, X3
-	AESENC	X4, X4
-	AESENC	X5, X5
-	AESENC	X6, X6
-	AESENC	X7, X7
-
-	// start with last (possibly overlapping) block
-	MOVOU	-128(AX)(CX*1), X8
-	MOVOU	-112(AX)(CX*1), X9
-	MOVOU	-96(AX)(CX*1), X10
-	MOVOU	-80(AX)(CX*1), X11
-	MOVOU	-64(AX)(CX*1), X12
-	MOVOU	-48(AX)(CX*1), X13
-	MOVOU	-32(AX)(CX*1), X14
-	MOVOU	-16(AX)(CX*1), X15
-
-	// xor in seed
-	PXOR	X0, X8
-	PXOR	X1, X9
-	PXOR	X2, X10
-	PXOR	X3, X11
-	PXOR	X4, X12
-	PXOR	X5, X13
-	PXOR	X6, X14
-	PXOR	X7, X15
-
-	// compute number of remaining 128-byte blocks
-	DECQ	CX
-	SHRQ	$7, CX
-
-	PCALIGN $16
-aesloop:
-	// scramble state
-	AESENC	X8, X8
-	AESENC	X9, X9
-	AESENC	X10, X10
-	AESENC	X11, X11
-	AESENC	X12, X12
-	AESENC	X13, X13
-	AESENC	X14, X14
-	AESENC	X15, X15
-
-	// scramble state, xor in a block
-	MOVOU	(AX), X0
-	MOVOU	16(AX), X1
-	MOVOU	32(AX), X2
-	MOVOU	48(AX), X3
-	AESENC	X0, X8
-	AESENC	X1, X9
-	AESENC	X2, X10
-	AESENC	X3, X11
-	MOVOU	64(AX), X4
-	MOVOU	80(AX), X5
-	MOVOU	96(AX), X6
-	MOVOU	112(AX), X7
-	AESENC	X4, X12
-	AESENC	X5, X13
-	AESENC	X6, X14
-	AESENC	X7, X15
-
-	ADDQ	$128, AX
-	DECQ	CX
-	JNE	aesloop
-
-	// 3 more scrambles to finish
-	AESENC	X8, X8
-	AESENC	X9, X9
-	AESENC	X10, X10
-	AESENC	X11, X11
-	AESENC	X12, X12
-	AESENC	X13, X13
-	AESENC	X14, X14
-	AESENC	X15, X15
-	AESENC	X8, X8
-	AESENC	X9, X9
-	AESENC	X10, X10
-	AESENC	X11, X11
-	AESENC	X12, X12
-	AESENC	X13, X13
-	AESENC	X14, X14
-	AESENC	X15, X15
-	AESENC	X8, X8
-	AESENC	X9, X9
-	AESENC	X10, X10
-	AESENC	X11, X11
-	AESENC	X12, X12
-	AESENC	X13, X13
-	AESENC	X14, X14
-	AESENC	X15, X15
-
-	PXOR	X12, X8
-	PXOR	X13, X9
-	PXOR	X14, X10
-	PXOR	X15, X11
-	PXOR	X10, X8
-	PXOR	X11, X9
-	PXOR	X9, X8
-	// X15 must be zero on return
-	PXOR	X15, X15
-	MOVQ	X8, AX	// return X8
-	RET
-
-// func memhash32(p unsafe.Pointer, h uintptr) uintptr
-// ABIInternal for performance.
-TEXT runtime·memhash32<ABIInternal>(SB),NOSPLIT,$0-24
-	// AX = ptr to data
-	// BX = seed
-	CMPB	runtime·useAeshash(SB), $0
-	JEQ	noaes
-	MOVQ	BX, X0	// X0 = seed
-	PINSRD	$2, (AX), X0	// data
-	AESENC	runtime·aeskeysched+0(SB), X0
-	AESENC	runtime·aeskeysched+16(SB), X0
-	AESENC	runtime·aeskeysched+32(SB), X0
-	MOVQ	X0, AX	// return X0
-	RET
-noaes:
-	JMP	runtime·memhash32Fallback<ABIInternal>(SB)
-
-// func memhash64(p unsafe.Pointer, h uintptr) uintptr
-// ABIInternal for performance.
-TEXT runtime·memhash64<ABIInternal>(SB),NOSPLIT,$0-24
-	// AX = ptr to data
-	// BX = seed
-	CMPB	runtime·useAeshash(SB), $0
-	JEQ	noaes
-	MOVQ	BX, X0	// X0 = seed
-	PINSRQ	$1, (AX), X0	// data
-	AESENC	runtime·aeskeysched+0(SB), X0
-	AESENC	runtime·aeskeysched+16(SB), X0
-	AESENC	runtime·aeskeysched+32(SB), X0
-	MOVQ	X0, AX	// return X0
-	RET
-noaes:
-	JMP	runtime·memhash64Fallback<ABIInternal>(SB)
-
-// simple mask to get rid of data in the high part of the register.
-DATA masks<>+0x00(SB)/8, $0x0000000000000000
-DATA masks<>+0x08(SB)/8, $0x0000000000000000
-DATA masks<>+0x10(SB)/8, $0x00000000000000ff
-DATA masks<>+0x18(SB)/8, $0x0000000000000000
-DATA masks<>+0x20(SB)/8, $0x000000000000ffff
-DATA masks<>+0x28(SB)/8, $0x0000000000000000
-DATA masks<>+0x30(SB)/8, $0x0000000000ffffff
-DATA masks<>+0x38(SB)/8, $0x0000000000000000
-DATA masks<>+0x40(SB)/8, $0x00000000ffffffff
-DATA masks<>+0x48(SB)/8, $0x0000000000000000
-DATA masks<>+0x50(SB)/8, $0x000000ffffffffff
-DATA masks<>+0x58(SB)/8, $0x0000000000000000
-DATA masks<>+0x60(SB)/8, $0x0000ffffffffffff
-DATA masks<>+0x68(SB)/8, $0x0000000000000000
-DATA masks<>+0x70(SB)/8, $0x00ffffffffffffff
-DATA masks<>+0x78(SB)/8, $0x0000000000000000
-DATA masks<>+0x80(SB)/8, $0xffffffffffffffff
-DATA masks<>+0x88(SB)/8, $0x0000000000000000
-DATA masks<>+0x90(SB)/8, $0xffffffffffffffff
-DATA masks<>+0x98(SB)/8, $0x00000000000000ff
-DATA masks<>+0xa0(SB)/8, $0xffffffffffffffff
-DATA masks<>+0xa8(SB)/8, $0x000000000000ffff
-DATA masks<>+0xb0(SB)/8, $0xffffffffffffffff
-DATA masks<>+0xb8(SB)/8, $0x0000000000ffffff
-DATA masks<>+0xc0(SB)/8, $0xffffffffffffffff
-DATA masks<>+0xc8(SB)/8, $0x00000000ffffffff
-DATA masks<>+0xd0(SB)/8, $0xffffffffffffffff
-DATA masks<>+0xd8(SB)/8, $0x000000ffffffffff
-DATA masks<>+0xe0(SB)/8, $0xffffffffffffffff
-DATA masks<>+0xe8(SB)/8, $0x0000ffffffffffff
-DATA masks<>+0xf0(SB)/8, $0xffffffffffffffff
-DATA masks<>+0xf8(SB)/8, $0x00ffffffffffffff
-GLOBL masks<>(SB),RODATA,$256
-
-// func checkASM() bool
-TEXT ·checkASM(SB),NOSPLIT,$0-1
-	// check that masks<>(SB) and shifts<>(SB) are aligned to 16-byte
-	MOVQ	$masks<>(SB), AX
-	MOVQ	$shifts<>(SB), BX
-	ORQ	BX, AX
-	TESTQ	$15, AX
-	SETEQ	ret+0(FP)
-	RET
-
-// these are arguments to pshufb. They move data down from
-// the high bytes of the register to the low bytes of the register.
-// index is how many bytes to move.
-DATA shifts<>+0x00(SB)/8, $0x0000000000000000
-DATA shifts<>+0x08(SB)/8, $0x0000000000000000
-DATA shifts<>+0x10(SB)/8, $0xffffffffffffff0f
-DATA shifts<>+0x18(SB)/8, $0xffffffffffffffff
-DATA shifts<>+0x20(SB)/8, $0xffffffffffff0f0e
-DATA shifts<>+0x28(SB)/8, $0xffffffffffffffff
-DATA shifts<>+0x30(SB)/8, $0xffffffffff0f0e0d
-DATA shifts<>+0x38(SB)/8, $0xffffffffffffffff
-DATA shifts<>+0x40(SB)/8, $0xffffffff0f0e0d0c
-DATA shifts<>+0x48(SB)/8, $0xffffffffffffffff
-DATA shifts<>+0x50(SB)/8, $0xffffff0f0e0d0c0b
-DATA shifts<>+0x58(SB)/8, $0xffffffffffffffff
-DATA shifts<>+0x60(SB)/8, $0xffff0f0e0d0c0b0a
-DATA shifts<>+0x68(SB)/8, $0xffffffffffffffff
-DATA shifts<>+0x70(SB)/8, $0xff0f0e0d0c0b0a09
-DATA shifts<>+0x78(SB)/8, $0xffffffffffffffff
-DATA shifts<>+0x80(SB)/8, $0x0f0e0d0c0b0a0908
-DATA shifts<>+0x88(SB)/8, $0xffffffffffffffff
-DATA shifts<>+0x90(SB)/8, $0x0e0d0c0b0a090807
-DATA shifts<>+0x98(SB)/8, $0xffffffffffffff0f
-DATA shifts<>+0xa0(SB)/8, $0x0d0c0b0a09080706
-DATA shifts<>+0xa8(SB)/8, $0xffffffffffff0f0e
-DATA shifts<>+0xb0(SB)/8, $0x0c0b0a0908070605
-DATA shifts<>+0xb8(SB)/8, $0xffffffffff0f0e0d
-DATA shifts<>+0xc0(SB)/8, $0x0b0a090807060504
-DATA shifts<>+0xc8(SB)/8, $0xffffffff0f0e0d0c
-DATA shifts<>+0xd0(SB)/8, $0x0a09080706050403
-DATA shifts<>+0xd8(SB)/8, $0xffffff0f0e0d0c0b
-DATA shifts<>+0xe0(SB)/8, $0x0908070605040302
-DATA shifts<>+0xe8(SB)/8, $0xffff0f0e0d0c0b0a
-DATA shifts<>+0xf0(SB)/8, $0x0807060504030201
-DATA shifts<>+0xf8(SB)/8, $0xff0f0e0d0c0b0a09
-GLOBL shifts<>(SB),RODATA,$256
-
 // Called from cgo wrappers, this function returns g->m->curg.stack.hi.
 // Must obey the gcc calling convention.
 TEXT _cgo_topofstack(SB),NOSPLIT,$0

package/bin/go/src/runtime/asm_arm.s

@@ -58,24 +58,8 @@ skipfpsave:
 
 	MOVW	$0, g // Initialize g.
 
-	// Synchronous initialization.
-	CALL	runtime·libpreinit(SB)
-
-	// Create a new thread to do the runtime initialization.
-	MOVW	_cgo_sys_thread_create(SB), R2
-	CMP	$0, R2
-	BEQ	nocgo
-	MOVW	$_rt0_arm_lib_go<>(SB), R0
-	MOVW	$0, R1
-	BL	(R2)
-	B	rr
-nocgo:
-	MOVW	$0x800000, R0                     // stacksize = 8192KB
-	MOVW	$_rt0_arm_lib_go<>(SB), R1  // fn
-	MOVW	R0, 4(R13)
-	MOVW	R1, 8(R13)
-	BL	runtime·newosproc0(SB)
-rr:
+	CALL	runtime·libInit(SB)
+
 	// Restore callee-save registers and return.
 	MOVB    runtime·goarmsoftfp(SB), R11
 	CMP     $0, R11
@@ -98,9 +82,9 @@ skipfprest:
 	MOVW	36(R13), R11
 	RET
 
-// _rt0_arm_lib_go initializes the Go runtime.
+// rt0_lib_go initializes the Go runtime.
 // This is started in a separate thread by _rt0_arm_lib.
-TEXT _rt0_arm_lib_go<>(SB),NOSPLIT,$8
+TEXT runtime·rt0_lib_go<ABIInternal>(SB),NOSPLIT,$8
 	MOVW	_rt0_arm_lib_argc<>(SB), R0
 	MOVW	_rt0_arm_lib_argv<>(SB), R1
 	B	runtime·rt0_go(SB)
@@ -630,10 +614,6 @@ nosave:
 	// This code is like the above sequence but without saving/restoring g
 	// and without worrying about the stack moving out from under us
 	// (because we're on a system stack, not a goroutine stack).
-	// The above code could be used directly if already on a system stack,
-	// but then the only path through this code would be a rare case on Solaris.
-	// Using this code for all "already on system stack" calls exercises it more,
-	// which should help keep it correct.
 	SUB	$24, R13
 	BIC	$0x7, R13	// alignment for gcc ABI
 	// save null g in case someone looks during debugging.
@@ -829,16 +809,6 @@ TEXT runtime·armPublicationBarrier(SB),NOSPLIT|NOFRAME,$0-0
 	DMB	MB_ST
 	RET
 
-// AES hashing not implemented for ARM
-TEXT runtime·memhash(SB),NOSPLIT|NOFRAME,$0-16
-	JMP	runtime·memhashFallback(SB)
-TEXT runtime·strhash(SB),NOSPLIT|NOFRAME,$0-12
-	JMP	runtime·strhashFallback(SB)
-TEXT runtime·memhash32(SB),NOSPLIT|NOFRAME,$0-12
-	JMP	runtime·memhash32Fallback(SB)
-TEXT runtime·memhash64(SB),NOSPLIT|NOFRAME,$0-12
-	JMP	runtime·memhash64Fallback(SB)
-
 TEXT runtime·procyieldAsm(SB),NOSPLIT|NOFRAME,$0
 	MOVW	cycles+0(FP), R1
 	MOVW	$0, R0
@@ -907,11 +877,6 @@ TEXT runtime·addmoduledata(SB),NOSPLIT,$0-0
 	MOVW	saver9-4(SP), R9
 	RET
 
-TEXT ·checkASM(SB),NOSPLIT,$0-1
-	MOVW	$1, R3
-	MOVB	R3, ret+0(FP)
-	RET
-
 // gcWriteBarrier informs the GC about heap pointer writes.
 //
 // gcWriteBarrier does NOT follow the Go ABI. It accepts the