@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/runtime/alg.go

@@ -7,8 +7,8 @@ package runtime
 import (
 	"internal/abi"
 	"internal/byteorder"
-	"internal/cpu"
 	"internal/goarch"
+	"internal/runtime/maps"
 	"internal/runtime/sys"
 	"unsafe"
 )
@@ -54,12 +54,11 @@ func memhash_varlen(p unsafe.Pointer, h uintptr) uintptr {
 	return memhash(p, h, size)
 }
 
-// runtime variable to check if the processor we're running on
-// actually supports the instructions used by the AES-based
-// hash implementation.
-var useAeshash bool
-
-// in asm_*.s
+// This is simple wrappers.
+// It's better to use maps.MemHash functions directly,
+// but we have reflection code that still calls hashing from runtime via LookupRuntime,
+// so we have to try to minimize overhead of an extra call.
+// For this add nosplit for performance
 
 // memhash should be an internal detail,
 // but widely used packages access it using linkname.
@@ -77,12 +76,21 @@ var useAeshash bool
 // Do not remove or change the type signature.
 // See go.dev/issue/67401.
 //
+//go:nosplit
 //go:linkname memhash
-func memhash(p unsafe.Pointer, h, s uintptr) uintptr
+func memhash(p unsafe.Pointer, h, s uintptr) uintptr {
+	return maps.MemHash(p, h, s)
+}
 
-func memhash32(p unsafe.Pointer, h uintptr) uintptr
+//go:nosplit
+func memhash64(p unsafe.Pointer, seed uintptr) uintptr {
+	return maps.MemHash64(readUnaligned64(p), seed)
+}
 
-func memhash64(p unsafe.Pointer, h uintptr) uintptr
+//go:nosplit
+func memhash32(p unsafe.Pointer, seed uintptr) uintptr {
+	return maps.MemHash32(readUnaligned32(p), seed)
+}
 
 // strhash should be an internal detail,
 // but widely used packages access it using linkname.
@@ -96,12 +104,10 @@ func memhash64(p unsafe.Pointer, h uintptr) uintptr
 // Do not remove or change the type signature.
 // See go.dev/issue/67401.
 //
+//go:nosplit
 //go:linkname strhash
-func strhash(p unsafe.Pointer, h uintptr) uintptr
-
-func strhashFallback(a unsafe.Pointer, h uintptr) uintptr {
-	x := (*stringStruct)(a)
-	return memhashFallback(x.str, h, uintptr(x.len))
+func strhash(p unsafe.Pointer, h uintptr) uintptr {
+	return maps.StrHash(*(*string)(p), h)
 }
 
 // NOTE: Because NaN != NaN, a map can contain any
@@ -199,8 +205,6 @@ func nilinterhash(p unsafe.Pointer, h uintptr) uintptr {
 // is slower but more general and is used for hashing interface types
 // (called from interhash or nilinterhash, above) or for hashing in
 // maps generated by reflect.MapOf (reflect_typehash, below).
-// Note: this function must match the compiler generated
-// functions exactly. See issue 37716.
 //
 // typehash should be an internal detail,
 // but widely used packages access it using linkname.
@@ -381,42 +385,6 @@ func ifaceHash(i interface {
 	return interhash(noescape(unsafe.Pointer(&i)), seed)
 }
 
-const hashRandomBytes = goarch.PtrSize / 4 * 64
-
-// used in asm_{386,amd64,arm64}.s to seed the hash function
-var aeskeysched [hashRandomBytes]byte
-
-// used in hash{32,64}.go to seed the hash function
-var hashkey [4]uintptr
-
-func alginit() {
-	// Install AES hash algorithms if the instructions needed are present.
-	if (GOARCH == "386" || GOARCH == "amd64") &&
-		cpu.X86.HasAES && // AESENC
-		cpu.X86.HasSSSE3 && // PSHUFB
-		cpu.X86.HasSSE41 { // PINSR{D,Q}
-		initAlgAES()
-		return
-	}
-	if GOARCH == "arm64" && cpu.ARM64.HasAES {
-		initAlgAES()
-		return
-	}
-	for i := range hashkey {
-		hashkey[i] = uintptr(bootstrapRand())
-	}
-}
-
-func initAlgAES() {
-	useAeshash = true
-	// Initialize with random data so hash collisions will be hard to engineer.
-	key := (*[hashRandomBytes / 8]uint64)(unsafe.Pointer(&aeskeysched))
-	for i := range key {
-		key[i] = bootstrapRand()
-	}
-}
-
-// Note: These routines perform the read with a native endianness.
 func readUnaligned32(p unsafe.Pointer) uint32 {
 	q := (*[4]byte)(p)
 	if goarch.BigEndian {

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

@@ -36,48 +36,17 @@ TEXT _rt0_386_lib(SB),NOSPLIT,$0
 	MOVL	12(BP), AX
 	MOVL	AX, _rt0_386_lib_argv<>(SB)
 
-	// Synchronous initialization.
-	CALL	runtime·libpreinit(SB)
+	CALL	runtime·libInit(SB)
 
-	SUBL	$8, SP
-
-	// Create a new thread to do the runtime initialization.
-	MOVL	_cgo_sys_thread_create(SB), AX
-	TESTL	AX, AX
-	JZ	nocgo
-
-	// Align stack to call C function.
-	// We moved SP to BP above, but BP was clobbered by the libpreinit call.
-	MOVL	SP, BP
-	ANDL	$~15, SP
-
-	MOVL	$_rt0_386_lib_go(SB), BX
-	MOVL	BX, 0(SP)
-	MOVL	$0, 4(SP)
-
-	CALL	AX
-
-	MOVL	BP, SP
-
-	JMP	restore
-
-nocgo:
-	MOVL	$0x800000, 0(SP)                    // stacksize = 8192KB
-	MOVL	$_rt0_386_lib_go(SB), AX
-	MOVL	AX, 4(SP)                           // fn
-	CALL	runtime·newosproc0(SB)
-
-restore:
-	ADDL	$8, SP
 	POPL	DI
 	POPL	SI
 	POPL	BX
 	POPL	BP
 	RET
 
-// _rt0_386_lib_go initializes the Go runtime.
+// rt0_lib_go initializes the Go runtime.
 // This is started in a separate thread by _rt0_386_lib.
-TEXT _rt0_386_lib_go(SB),NOSPLIT,$8
+TEXT runtime·rt0_lib_go<ABIInternal>(SB),NOSPLIT,$8
 	MOVL	_rt0_386_lib_argc<>(SB), AX
 	MOVL	AX, 0(SP)
 	MOVL	_rt0_386_lib_argv<>(SB), AX
@@ -665,6 +634,13 @@ TEXT ·asmcgocall(SB),NOSPLIT,$0-12
 	// We get called to create new OS threads too, and those
 	// come in on the m->g0 stack already. Or we might already
 	// be on the m->gsignal stack.
+#ifdef GOOS_windows
+	// On Windows, get_tls might return garbage if the thread
+	// has never called into Go, so check tls_g directly.
+	MOVL	runtime·tls_g(SB), CX
+	CMPL	CX, $0
+	JEQ	nosave
+#endif
 	get_tls(CX)
 	MOVL	g(CX), DI
 	CMPL	DI, $0
@@ -741,7 +717,7 @@ loadg:
 #ifdef GOOS_windows
 	MOVL	$0, BP
 	CMPL	CX, $0
-	JEQ	2(PC) // TODO
+	JEQ	needm
 #endif
 	MOVL	g(CX), BP
 	CMPL	BP, $0
@@ -947,432 +923,6 @@ TEXT ldt0setup<>(SB),NOSPLIT,$16-0
 TEXT runtime·emptyfunc(SB),0,$0-0
 	RET
 
-// hash function using AES hardware instructions
-TEXT runtime·memhash(SB),NOSPLIT,$0-16
-	CMPB	runtime·useAeshash(SB), $0
-	JEQ	noaes
-	MOVL	p+0(FP), AX	// ptr to data
-	MOVL	s+8(FP), BX	// size
-	LEAL	ret+12(FP), DX
-	JMP	aeshashbody<>(SB)
-noaes:
-	JMP	runtime·memhashFallback(SB)
-
-TEXT runtime·strhash(SB),NOSPLIT,$0-12
-	CMPB	runtime·useAeshash(SB), $0
-	JEQ	noaes
-	MOVL	p+0(FP), AX	// ptr to string object
-	MOVL	4(AX), BX	// length of string
-	MOVL	(AX), AX	// string data
-	LEAL	ret+8(FP), DX
-	JMP	aeshashbody<>(SB)
-noaes:
-	JMP	runtime·strhashFallback(SB)
-
-// AX: data
-// BX: length
-// DX: address to put return value
-TEXT aeshashbody<>(SB),NOSPLIT,$0-0
-	MOVL	h+4(FP), X0	            // 32 bits of per-table hash seed
-	PINSRW	$4, BX, X0	            // 16 bits of length
-	PSHUFHW	$0, X0, X0	            // replace size with its low 2 bytes repeated 4 times
-	MOVO	X0, X1                      // save unscrambled seed
-	PXOR	runtime·aeskeysched(SB), X0 // xor in per-process seed
-	AESENC	X0, X0                      // scramble seed
-
-	CMPL	BX, $16
-	JB	aes0to15
-	JE	aes16
-	CMPL	BX, $32
-	JBE	aes17to32
-	CMPL	BX, $64
-	JBE	aes33to64
-	JMP	aes65plus
-
-aes0to15:
-	TESTL	BX, BX
-	JE	aes0
-
-	ADDL	$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
-	ADDL	BX, BX
-	PAND	masks<>(SB)(BX*8), X1
-
-final1:
-	PXOR	X0, X1	// xor data with seed
-	AESENC	X1, X1  // scramble combo 3 times
-	AESENC	X1, X1
-	AESENC	X1, X1
-	MOVL	X1, (DX)
-	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)(BX*1), X1
-	ADDL	BX, BX
-	PSHUFB	shifts<>(SB)(BX*8), X1
-	JMP	final1
-
-aes0:
-	// Return scrambled input seed
-	AESENC	X0, X0
-	MOVL	X0, (DX)
-	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)(BX*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
-	MOVL	X2, (DX)
-	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)(BX*1), X6
-	MOVOU	-16(AX)(BX*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
-	MOVL	X4, (DX)
-	RET
-
-aes65plus:
-	// 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
-
-	// start with last (possibly overlapping) block
-	MOVOU	-64(AX)(BX*1), X4
-	MOVOU	-48(AX)(BX*1), X5
-	MOVOU	-32(AX)(BX*1), X6
-	MOVOU	-16(AX)(BX*1), X7
-
-	// scramble state once
-	AESENC	X0, X4
-	AESENC	X1, X5
-	AESENC	X2, X6
-	AESENC	X3, X7
-
-	// compute number of remaining 64-byte blocks
-	DECL	BX
-	SHRL	$6, BX
-
-aesloop:
-	// scramble state, xor in a block
-	MOVOU	(AX), X0
-	MOVOU	16(AX), X1
-	MOVOU	32(AX), X2
-	MOVOU	48(AX), X3
-	AESENC	X0, X4
-	AESENC	X1, X5
-	AESENC	X2, X6
-	AESENC	X3, X7
-
-	// scramble state
-	AESENC	X4, X4
-	AESENC	X5, X5
-	AESENC	X6, X6
-	AESENC	X7, X7
-
-	ADDL	$64, AX
-	DECL	BX
-	JNE	aesloop
-
-	// 3 more scrambles to finish
-	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
-	MOVL	X4, (DX)
-	RET
-
-TEXT runtime·memhash32(SB),NOSPLIT,$0-12
-	CMPB	runtime·useAeshash(SB), $0
-	JEQ	noaes
-	MOVL	p+0(FP), AX	// ptr to data
-	MOVL	h+4(FP), X0	// seed
-	PINSRD	$1, (AX), X0	// data
-	AESENC	runtime·aeskeysched+0(SB), X0
-	AESENC	runtime·aeskeysched+16(SB), X0
-	AESENC	runtime·aeskeysched+32(SB), X0
-	MOVL	X0, ret+8(FP)
-	RET
-noaes:
-	JMP	runtime·memhash32Fallback(SB)
-
-TEXT runtime·memhash64(SB),NOSPLIT,$0-12
-	CMPB	runtime·useAeshash(SB), $0
-	JEQ	noaes
-	MOVL	p+0(FP), AX	// ptr to data
-	MOVQ	(AX), X0	// data
-	PINSRD	$2, h+4(FP), X0	// seed
-	AESENC	runtime·aeskeysched+0(SB), X0
-	AESENC	runtime·aeskeysched+16(SB), X0
-	AESENC	runtime·aeskeysched+32(SB), X0
-	MOVL	X0, ret+8(FP)
-	RET
-noaes:
-	JMP	runtime·memhash64Fallback(SB)
-
-// simple mask to get rid of data in the high part of the register.
-DATA masks<>+0x00(SB)/4, $0x00000000
-DATA masks<>+0x04(SB)/4, $0x00000000
-DATA masks<>+0x08(SB)/4, $0x00000000
-DATA masks<>+0x0c(SB)/4, $0x00000000
-
-DATA masks<>+0x10(SB)/4, $0x000000ff
-DATA masks<>+0x14(SB)/4, $0x00000000
-DATA masks<>+0x18(SB)/4, $0x00000000
-DATA masks<>+0x1c(SB)/4, $0x00000000
-
-DATA masks<>+0x20(SB)/4, $0x0000ffff
-DATA masks<>+0x24(SB)/4, $0x00000000
-DATA masks<>+0x28(SB)/4, $0x00000000
-DATA masks<>+0x2c(SB)/4, $0x00000000
-
-DATA masks<>+0x30(SB)/4, $0x00ffffff
-DATA masks<>+0x34(SB)/4, $0x00000000
-DATA masks<>+0x38(SB)/4, $0x00000000
-DATA masks<>+0x3c(SB)/4, $0x00000000
-
-DATA masks<>+0x40(SB)/4, $0xffffffff
-DATA masks<>+0x44(SB)/4, $0x00000000
-DATA masks<>+0x48(SB)/4, $0x00000000
-DATA masks<>+0x4c(SB)/4, $0x00000000
-
-DATA masks<>+0x50(SB)/4, $0xffffffff
-DATA masks<>+0x54(SB)/4, $0x000000ff
-DATA masks<>+0x58(SB)/4, $0x00000000
-DATA masks<>+0x5c(SB)/4, $0x00000000
-
-DATA masks<>+0x60(SB)/4, $0xffffffff
-DATA masks<>+0x64(SB)/4, $0x0000ffff
-DATA masks<>+0x68(SB)/4, $0x00000000
-DATA masks<>+0x6c(SB)/4, $0x00000000
-
-DATA masks<>+0x70(SB)/4, $0xffffffff
-DATA masks<>+0x74(SB)/4, $0x00ffffff
-DATA masks<>+0x78(SB)/4, $0x00000000
-DATA masks<>+0x7c(SB)/4, $0x00000000
-
-DATA masks<>+0x80(SB)/4, $0xffffffff
-DATA masks<>+0x84(SB)/4, $0xffffffff
-DATA masks<>+0x88(SB)/4, $0x00000000
-DATA masks<>+0x8c(SB)/4, $0x00000000
-
-DATA masks<>+0x90(SB)/4, $0xffffffff
-DATA masks<>+0x94(SB)/4, $0xffffffff
-DATA masks<>+0x98(SB)/4, $0x000000ff
-DATA masks<>+0x9c(SB)/4, $0x00000000
-
-DATA masks<>+0xa0(SB)/4, $0xffffffff
-DATA masks<>+0xa4(SB)/4, $0xffffffff
-DATA masks<>+0xa8(SB)/4, $0x0000ffff
-DATA masks<>+0xac(SB)/4, $0x00000000
-
-DATA masks<>+0xb0(SB)/4, $0xffffffff
-DATA masks<>+0xb4(SB)/4, $0xffffffff
-DATA masks<>+0xb8(SB)/4, $0x00ffffff
-DATA masks<>+0xbc(SB)/4, $0x00000000
-
-DATA masks<>+0xc0(SB)/4, $0xffffffff
-DATA masks<>+0xc4(SB)/4, $0xffffffff
-DATA masks<>+0xc8(SB)/4, $0xffffffff
-DATA masks<>+0xcc(SB)/4, $0x00000000
-
-DATA masks<>+0xd0(SB)/4, $0xffffffff
-DATA masks<>+0xd4(SB)/4, $0xffffffff
-DATA masks<>+0xd8(SB)/4, $0xffffffff
-DATA masks<>+0xdc(SB)/4, $0x000000ff
-
-DATA masks<>+0xe0(SB)/4, $0xffffffff
-DATA masks<>+0xe4(SB)/4, $0xffffffff
-DATA masks<>+0xe8(SB)/4, $0xffffffff
-DATA masks<>+0xec(SB)/4, $0x0000ffff
-
-DATA masks<>+0xf0(SB)/4, $0xffffffff
-DATA masks<>+0xf4(SB)/4, $0xffffffff
-DATA masks<>+0xf8(SB)/4, $0xffffffff
-DATA masks<>+0xfc(SB)/4, $0x00ffffff
-
-GLOBL masks<>(SB),RODATA,$256
-
-// 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)/4, $0x00000000
-DATA shifts<>+0x04(SB)/4, $0x00000000
-DATA shifts<>+0x08(SB)/4, $0x00000000
-DATA shifts<>+0x0c(SB)/4, $0x00000000
-
-DATA shifts<>+0x10(SB)/4, $0xffffff0f
-DATA shifts<>+0x14(SB)/4, $0xffffffff
-DATA shifts<>+0x18(SB)/4, $0xffffffff
-DATA shifts<>+0x1c(SB)/4, $0xffffffff
-
-DATA shifts<>+0x20(SB)/4, $0xffff0f0e
-DATA shifts<>+0x24(SB)/4, $0xffffffff
-DATA shifts<>+0x28(SB)/4, $0xffffffff
-DATA shifts<>+0x2c(SB)/4, $0xffffffff
-
-DATA shifts<>+0x30(SB)/4, $0xff0f0e0d
-DATA shifts<>+0x34(SB)/4, $0xffffffff
-DATA shifts<>+0x38(SB)/4, $0xffffffff
-DATA shifts<>+0x3c(SB)/4, $0xffffffff
-
-DATA shifts<>+0x40(SB)/4, $0x0f0e0d0c
-DATA shifts<>+0x44(SB)/4, $0xffffffff
-DATA shifts<>+0x48(SB)/4, $0xffffffff
-DATA shifts<>+0x4c(SB)/4, $0xffffffff
-
-DATA shifts<>+0x50(SB)/4, $0x0e0d0c0b
-DATA shifts<>+0x54(SB)/4, $0xffffff0f
-DATA shifts<>+0x58(SB)/4, $0xffffffff
-DATA shifts<>+0x5c(SB)/4, $0xffffffff
-
-DATA shifts<>+0x60(SB)/4, $0x0d0c0b0a
-DATA shifts<>+0x64(SB)/4, $0xffff0f0e
-DATA shifts<>+0x68(SB)/4, $0xffffffff
-DATA shifts<>+0x6c(SB)/4, $0xffffffff
-
-DATA shifts<>+0x70(SB)/4, $0x0c0b0a09
-DATA shifts<>+0x74(SB)/4, $0xff0f0e0d
-DATA shifts<>+0x78(SB)/4, $0xffffffff
-DATA shifts<>+0x7c(SB)/4, $0xffffffff
-
-DATA shifts<>+0x80(SB)/4, $0x0b0a0908
-DATA shifts<>+0x84(SB)/4, $0x0f0e0d0c
-DATA shifts<>+0x88(SB)/4, $0xffffffff
-DATA shifts<>+0x8c(SB)/4, $0xffffffff
-
-DATA shifts<>+0x90(SB)/4, $0x0a090807
-DATA shifts<>+0x94(SB)/4, $0x0e0d0c0b
-DATA shifts<>+0x98(SB)/4, $0xffffff0f
-DATA shifts<>+0x9c(SB)/4, $0xffffffff
-
-DATA shifts<>+0xa0(SB)/4, $0x09080706
-DATA shifts<>+0xa4(SB)/4, $0x0d0c0b0a
-DATA shifts<>+0xa8(SB)/4, $0xffff0f0e
-DATA shifts<>+0xac(SB)/4, $0xffffffff
-
-DATA shifts<>+0xb0(SB)/4, $0x08070605
-DATA shifts<>+0xb4(SB)/4, $0x0c0b0a09
-DATA shifts<>+0xb8(SB)/4, $0xff0f0e0d
-DATA shifts<>+0xbc(SB)/4, $0xffffffff
-
-DATA shifts<>+0xc0(SB)/4, $0x07060504
-DATA shifts<>+0xc4(SB)/4, $0x0b0a0908
-DATA shifts<>+0xc8(SB)/4, $0x0f0e0d0c
-DATA shifts<>+0xcc(SB)/4, $0xffffffff
-
-DATA shifts<>+0xd0(SB)/4, $0x06050403
-DATA shifts<>+0xd4(SB)/4, $0x0a090807
-DATA shifts<>+0xd8(SB)/4, $0x0e0d0c0b
-DATA shifts<>+0xdc(SB)/4, $0xffffff0f
-
-DATA shifts<>+0xe0(SB)/4, $0x05040302
-DATA shifts<>+0xe4(SB)/4, $0x09080706
-DATA shifts<>+0xe8(SB)/4, $0x0d0c0b0a
-DATA shifts<>+0xec(SB)/4, $0xffff0f0e
-
-DATA shifts<>+0xf0(SB)/4, $0x04030201
-DATA shifts<>+0xf4(SB)/4, $0x08070605
-DATA shifts<>+0xf8(SB)/4, $0x0c0b0a09
-DATA shifts<>+0xfc(SB)/4, $0xff0f0e0d
-
-GLOBL shifts<>(SB),RODATA,$256
-
-TEXT ·checkASM(SB),NOSPLIT,$0-1
-	// check that masks<>(SB) and shifts<>(SB) are aligned to 16-byte
-	MOVL	$masks<>(SB), AX
-	MOVL	$shifts<>(SB), BX
-	ORL	BX, AX
-	TESTL	$15, AX
-	SETEQ	ret+0(FP)
-	RET
-
 // Called from cgo wrappers, this function returns g->m->curg.stack.hi.
 // Must obey the gcc calling convention.
 TEXT _cgo_topofstack(SB),NOSPLIT,$0