@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/runtime/stubs_arm.go

@@ -14,12 +14,21 @@ func _mod()
 func _modu()
 
 // Called from assembly only; declared for go vet.
-func usplitR0()
+//
+// load_g is also called from runtime/cgo.
+//
+// load_g should be an internal detail,
+// but widely used packages access it using linkname.
+// Notable members of the hall of shame include:
+//   - github.com/ebitengine/purego
+//
+//go:linkname load_g
 func load_g()
 func save_g()
 func emptyfunc()
 func _initcgo()
 func read_tls_fallback()
+func usplitR0()
 
 //go:noescape
 func asmcgocall_no_g(fn, arg unsafe.Pointer)

package/bin/go/src/runtime/stubs_arm64.go

@@ -7,6 +7,15 @@ package runtime
 import "unsafe"
 
 // Called from assembly only; declared for go vet.
+//
+// load_g is also called from runtime/cgo.
+//
+// load_g should be an internal detail,
+// but widely used packages access it using linkname.
+// Notable members of the hall of shame include:
+//   - github.com/ebitengine/purego
+//
+//go:linkname load_g
 func load_g()
 func save_g()
 
@@ -19,7 +28,11 @@ func emptyfunc()
 //
 // Spills/loads arguments in registers to/from an internal/abi.RegArgs
 // respectively. Does not follow the Go ABI.
+//
+//go:linknamestd spillArgs
 func spillArgs()
+
+//go:linknamestd unspillArgs
 func unspillArgs()
 
 // getfp returns the frame pointer register of its caller or 0 if not implemented.

package/bin/go/src/runtime/stubs_loong64.go

@@ -6,15 +6,33 @@
 
 package runtime
 
+import "unsafe"
+
 // Called from assembly only; declared for go vet.
+//
+// load_g is also called from runtime/cgo.
+//
+// load_g should be an internal detail,
+// but widely used packages access it using linkname.
+// Notable members of the hall of shame include:
+//   - github.com/ebitengine/purego
+//
+//go:linkname load_g
 func load_g()
 func save_g()
 
+//go:noescape
+func asmcgocall_no_g(fn, arg unsafe.Pointer)
+
 // Used by reflectcall and the reflect package.
 //
 // Spills/loads arguments in registers to/from an internal/abi.RegArgs
 // respectively. Does not follow the Go ABI.
+//
+//go:linknamestd spillArgs
 func spillArgs()
+
+//go:linknamestd unspillArgs
 func unspillArgs()
 
 // getfp returns the frame pointer register of its caller or 0 if not implemented.

package/bin/go/src/runtime/stubs_mips64x.go

@@ -9,6 +9,15 @@ package runtime
 import "unsafe"
 
 // Called from assembly only; declared for go vet.
+//
+// load_g is also called from runtime/cgo.
+//
+// load_g should be an internal detail,
+// but widely used packages access it using linkname.
+// Notable members of the hall of shame include:
+//   - github.com/ebitengine/purego
+//
+//go:linkname load_g
 func load_g()
 func save_g()
 

package/bin/go/src/runtime/stubs_mipsx.go

@@ -6,7 +6,18 @@
 
 package runtime
 
+import _ "unsafe" // for linkname
+
 // Called from assembly only; declared for go vet.
+//
+// load_g is also called from runtime/cgo.
+//
+// load_g should be an internal detail,
+// but widely used packages access it using linkname.
+// Notable members of the hall of shame include:
+//   - github.com/ebitengine/purego
+//
+//go:linkname load_g
 func load_g()
 func save_g()
 

package/bin/go/src/runtime/stubs_ppc64x.go

@@ -9,6 +9,15 @@ package runtime
 import "unsafe"
 
 // Called from assembly only; declared for go vet.
+//
+// load_g is also called from runtime/cgo.
+//
+// load_g should be an internal detail,
+// but widely used packages access it using linkname.
+// Notable members of the hall of shame include:
+//   - github.com/ebitengine/purego
+//
+//go:linkname load_g
 func load_g()
 func save_g()
 func reginit()
@@ -16,9 +25,15 @@ func reginit()
 //go:noescape
 func asmcgocall_no_g(fn, arg unsafe.Pointer)
 
+// Used by reflectcall and the reflect package.
+//
 // Spills/loads arguments in registers to/from an internal/abi.RegArgs
 // respectively. Does not follow the Go ABI.
+//
+//go:linknamestd spillArgs
 func spillArgs()
+
+//go:linknamestd unspillArgs
 func unspillArgs()
 
 // getfp returns the frame pointer register of its caller or 0 if not implemented.

package/bin/go/src/runtime/stubs_riscv64.go

@@ -7,6 +7,15 @@ package runtime
 import "unsafe"
 
 // Called from assembly only; declared for go vet.
+//
+// load_g is also called from runtime/cgo.
+//
+// load_g should be an internal detail,
+// but widely used packages access it using linkname.
+// Notable members of the hall of shame include:
+//   - github.com/ebitengine/purego
+//
+//go:linkname load_g
 func load_g()
 func save_g()
 
@@ -17,7 +26,11 @@ func asmcgocall_no_g(fn, arg unsafe.Pointer)
 //
 // Spills/loads arguments in registers to/from an internal/abi.RegArgs
 // respectively. Does not follow the Go ABI.
+//
+//go:linknamestd spillArgs
 func spillArgs()
+
+//go:linknamestd unspillArgs
 func unspillArgs()
 
 // getfp returns the frame pointer register of its caller or 0 if not implemented.

package/bin/go/src/runtime/stubs_s390x.go

@@ -4,15 +4,33 @@
 
 package runtime
 
+import "unsafe"
+
 // Called from assembly only; declared for go vet.
+//
+// load_g is also called from runtime/cgo.
+//
+// load_g should be an internal detail,
+// but widely used packages access it using linkname.
+// Notable members of the hall of shame include:
+//   - github.com/ebitengine/purego
+//
+//go:linkname load_g
 func load_g()
 func save_g()
 
+//go:noescape
+func asmcgocall_no_g(fn, arg unsafe.Pointer)
+
 // Used by reflectcall and the reflect package.
 //
 // Spills/loads arguments in registers to/from an internal/abi.RegArgs
 // respectively. Does not follow the Go ABI.
+//
+//go:linknamestd spillArgs
 func spillArgs()
+
+//go:linknamestd unspillArgs
 func unspillArgs()
 
 // getfp returns the frame pointer register of its caller or 0 if not implemented.

package/bin/go/src/runtime/symtab.go

@@ -412,21 +412,20 @@ type moduledata struct {
 	findfunctab  uintptr
 	minpc, maxpc uintptr
 
-	text, etext           uintptr
-	noptrdata, enoptrdata uintptr
-	data, edata           uintptr
-	bss, ebss             uintptr
-	noptrbss, enoptrbss   uintptr
-	covctrs, ecovctrs     uintptr
-	end, gcdata, gcbss    uintptr
-	types, etypes         uintptr
-	rodata                uintptr
-	gofunc                uintptr // go.func.*
-	epclntab              uintptr
+	text, etext                uintptr
+	noptrdata, enoptrdata      uintptr
+	data, edata                uintptr
+	bss, ebss                  uintptr
+	noptrbss, enoptrbss        uintptr
+	covctrs, ecovctrs          uintptr
+	end, gcdata, gcbss         uintptr
+	types, typedesclen, etypes uintptr
+	itaboffset, itabsize       uintptr
+	rodata                     uintptr
+	gofunc                     uintptr // go.func.*
+	epclntab                   uintptr
 
 	textsectmap []textsect
-	typelinks   []int32 // offsets from types
-	itablinks   []*itab
 
 	ptab []ptabEntry
 
@@ -445,7 +444,7 @@ type moduledata struct {
 
 	gcdatamask, gcbssmask bitvector
 
-	typemap map[typeOff]*_type // offset to *_rtype in previous module
+	typemap map[*_type]*_type // *_type to use from previous module
 
 	next *moduledata
 }
@@ -468,14 +467,14 @@ type modulehash struct {
 	runtimehash  *string
 }
 
-// pinnedTypemaps are the map[typeOff]*_type from the moduledata objects.
+// pinnedTypemaps are the map[*_type]*_type from the moduledata objects.
 //
 // These typemap objects are allocated at run time on the heap, but the
 // only direct reference to them is in the moduledata, created by the
 // linker and marked SNOPTRDATA so it is ignored by the GC.
 //
 // To make sure the map isn't collected, we keep a second reference here.
-var pinnedTypemaps []map[typeOff]*_type
+var pinnedTypemaps []map[*_type]*_type
 
 // aixStaticDataBase (used only on AIX) holds the unrelocated address
 // of the data section, set by the linker.

package/bin/go/src/runtime/synctest.go

@@ -169,10 +169,6 @@ var bubbleGen atomic.Uint64 // bubble ID counter
 
 //go:linkname synctestRun internal/synctest.Run
 func synctestRun(f func()) {
-	if debug.asynctimerchan.Load() != 0 {
-		panic("synctest.Run not supported with asynctimerchan!=0")
-	}
-
 	gp := getg()
 	if gp.bubble != nil {
 		panic("synctest.Run called from within a synctest bubble")
@@ -262,6 +258,8 @@ type synctestDeadlockError struct {
 	bubble *synctestBubble
 }
 
+var _ error = synctestDeadlockError{}
+
 func (e synctestDeadlockError) Error() string {
 	return e.reason
 }

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

@@ -197,6 +197,15 @@ DATA	runtime·tstart+8(SB)/8, $TOC(SB)
 DATA	runtime·tstart+16(SB)/8, $0
 GLOBL	runtime·tstart(SB), NOPTR, $24
 
+// runtime.rt0LibGoDesc is a function descriptor to rt0_lib_go,
+// used by libInit to create a new thread on AIX where
+// pthread_create expects a function descriptor, not a raw
+// code address.
+DATA	runtime·rt0LibGoDesc+0(SB)/8, $runtime·rt0_lib_go(SB)
+DATA	runtime·rt0LibGoDesc+8(SB)/8, $TOC(SB)
+DATA	runtime·rt0LibGoDesc+16(SB)/8, $0
+GLOBL	runtime·rt0LibGoDesc(SB), NOPTR, $24
+
 TEXT tstart<>(SB),NOSPLIT,$0
 	XOR	 R0, R0 // reset R0
 

package/bin/go/src/runtime/sys_darwin.go

@@ -10,17 +10,6 @@ import (
 	"unsafe"
 )
 
-func libc_error_trampoline()
-
-// libc_error_addr puts the libc error
-// address into addr.
-//
-//go:nosplit
-//go:cgo_unsafe_args
-func libc_error_addr(addr **int32) {
-	libcCall(unsafe.Pointer(abi.FuncPCABI0(libc_error_trampoline)), unsafe.Pointer(&addr))
-}
-
 // libcCallInfo is a structure used to pass parameters to the system call.
 type libcCallInfo struct {
 	fn     uintptr
@@ -57,15 +46,8 @@ func syscall_rawsyscalln(fn uintptr, args ...uintptr) (r1, r2, err uintptr) {
 	if c.n != 0 {
 		c.args = uintptr(noescape(unsafe.Pointer(&args[0])))
 	}
-	libcCall(unsafe.Pointer(abi.FuncPCABI0(syscallN_trampoline)), unsafe.Pointer(c))
-	if gp := getg(); gp != nil && gp.m != nil && gp.m.errnoAddr != nil {
-		err = uintptr(*gp.m.errnoAddr)
-	} else {
-		var errnoAddr *int32
-		libc_error_addr(&errnoAddr)
-		err = uintptr(*errnoAddr)
-	}
-	return c.r1, c.r2, err
+	errno := libcCall(unsafe.Pointer(abi.FuncPCABI0(syscallN_trampoline)), unsafe.Pointer(c))
+	return c.r1, c.r2, uintptr(errno)
 }
 
 func syscallN_trampoline()

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

@@ -567,12 +567,9 @@ _0args:
 	// Return result.
 	MOVQ	AX, libcCallInfo_r1(R13)
 	MOVQ	DX, libcCallInfo_r2(R13)
-	RET
 
-TEXT runtime·libc_error_trampoline(SB),NOSPLIT,$0
-	MOVQ	0(DI), R14
 	CALL	libc_error(SB)
-	MOVQ	AX, (R14)
+	MOVL	(AX), AX	// errno
 	RET
 
 // syscall_x509 is for crypto/x509. It is like syscall6 but does not check for errors,

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

@@ -565,16 +565,13 @@ _0args:
 	MOVD	R0, libcCallInfo_r1(R19)
 	MOVD	R1, libcCallInfo_r2(R19)
 
+	BL	libc_error(SB)
+	MOVW	(R0), R0	// errno
+
 	// Restore callee-saved registers.
 	LDP	16(RSP), (R19, R20)
     RET
 
-TEXT runtime·libc_error_trampoline(SB),NOSPLIT,$0
-	MOVD	0(R0), R20
-	BL	libc_error(SB)
-	MOVD	R0, (R20)
-	RET
-
 // syscall_x509 is for crypto/x509. It is like syscall6 but does not check for errors,
 // takes 5 uintptrs and 1 float64, and only returns one value,
 // for use with standard C ABI functions.

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

@@ -96,9 +96,9 @@ TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0-4
 TEXT runtime·exitThread(SB),NOSPLIT|NOFRAME,$0-8
 	MOV	wait+0(FP), A0
 	// We're done using the stack.
-	FENCE
+	FENCE	RW, W
 	MOVW	ZERO, (A0)
-	FENCE
+	FENCE	RW, RW
 	MOV	$0, A0	// exit code
 	MOV	$SYS_thr_exit, T0
 	ECALL

package/bin/go/src/runtime/sys_ios_arm64.go

@@ -0,0 +1,151 @@
+// Copyright 2026 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package runtime
+
+import (
+	"internal/abi"
+	"unsafe"
+)
+
+// CoreFoundation linker flags for the external linker.
+//
+//go:cgo_ldflag "-framework"
+//go:cgo_ldflag "CoreFoundation"
+
+//go:nosplit
+func chdir(path *byte) int32 {
+	ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(chdir_trampoline)), unsafe.Pointer(&path))
+	KeepAlive(path)
+	return ret
+}
+func chdir_trampoline()
+
+//go:nosplit
+func cfBundleGetMainBundle() (bundle uintptr) {
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(cfBundleGetMainBundle_trampoline)), unsafe.Pointer(&bundle))
+	return bundle
+}
+func cfBundleGetMainBundle_trampoline()
+
+//go:nosplit
+func cfBundleCopyBundleURL(bundle uintptr) uintptr {
+	args := struct {
+		bundle uintptr
+		ret    uintptr
+	}{bundle: bundle}
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(cfBundleCopyBundleURL_trampoline)), unsafe.Pointer(&args))
+	return args.ret
+}
+func cfBundleCopyBundleURL_trampoline()
+
+//go:nosplit
+func cfBundleCopyResourceURL(bundle, resourceName, resourceType, subDirName uintptr) uintptr {
+	args := struct {
+		bundle       uintptr
+		resourceName uintptr
+		resourceType uintptr
+		subDirName   uintptr
+		ret          uintptr
+	}{
+		bundle:       bundle,
+		resourceName: resourceName,
+		resourceType: resourceType,
+		subDirName:   subDirName,
+	}
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(cfBundleCopyResourceURL_trampoline)), unsafe.Pointer(&args))
+	return args.ret
+}
+func cfBundleCopyResourceURL_trampoline()
+
+//go:nosplit
+func cfURLGetFileSystemRepresentation(url uintptr, resolveAgainstBase bool, path *byte, pathLen uintptr) bool {
+	args := struct {
+		url, resolveAgainstBase uintptr
+		path                    *byte
+		pathLen                 uintptr
+		ret                     uintptr
+	}{
+		url:     url,
+		path:    path,
+		pathLen: pathLen,
+	}
+	if resolveAgainstBase {
+		args.resolveAgainstBase = 1
+	}
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(cfURLGetFileSystemRepresentation_trampoline)), unsafe.Pointer(&args))
+	KeepAlive(path)
+	return args.ret != 0
+}
+func cfURLGetFileSystemRepresentation_trampoline()
+
+//go:nosplit
+func cfStringCreateWithCString(alloc uintptr, str *byte, encoding uintptr) uintptr {
+	args := struct {
+		alloc    uintptr
+		str      *byte
+		encoding uintptr
+		ret      uintptr
+	}{
+		alloc:    alloc,
+		str:      str,
+		encoding: encoding,
+	}
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(cfStringCreateWithCString_trampoline)), unsafe.Pointer(&args))
+	KeepAlive(str)
+	return args.ret
+}
+func cfStringCreateWithCString_trampoline()
+
+//go:nosplit
+func cfBundleGetValueForInfoDictionaryKey(bundle, key uintptr) uintptr {
+	args := struct {
+		bundle uintptr
+		key    uintptr
+		ret    uintptr
+	}{
+		bundle: bundle,
+		key:    key,
+	}
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(cfBundleGetValueForInfoDictionaryKey_trampoline)), unsafe.Pointer(&args))
+	return args.ret
+}
+func cfBundleGetValueForInfoDictionaryKey_trampoline()
+
+//go:nosplit
+func cfStringGetCString(str uintptr, buf *byte, bufLen uintptr, encoding uintptr) bool {
+	args := struct {
+		str      uintptr
+		buf      *byte
+		bufLen   uintptr
+		encoding uintptr
+		ret      uintptr
+	}{
+		str:      str,
+		buf:      buf,
+		bufLen:   bufLen,
+		encoding: encoding,
+	}
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(cfStringGetCString_trampoline)), unsafe.Pointer(&args))
+	KeepAlive(buf)
+	return args.ret != 0
+}
+func cfStringGetCString_trampoline()
+
+//go:nosplit
+func cfRelease(ref uintptr) {
+	libcCall(unsafe.Pointer(abi.FuncPCABI0(cfRelease_trampoline)), unsafe.Pointer(&ref))
+}
+func cfRelease_trampoline()
+
+//go:cgo_import_dynamic libc_chdir chdir "/usr/lib/libSystem.B.dylib"
+
+//go:cgo_import_dynamic libc_CFBundleGetMainBundle CFBundleGetMainBundle "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
+//go:cgo_import_dynamic libc_CFBundleCopyBundleURL CFBundleCopyBundleURL "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
+//go:cgo_import_dynamic libc_CFBundleCopyResourceURL CFBundleCopyResourceURL "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
+//go:cgo_import_dynamic libc_CFURLGetFileSystemRepresentation CFURLGetFileSystemRepresentation "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
+//go:cgo_import_dynamic libc_CFStringCreateWithCString CFStringCreateWithCString "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
+//go:cgo_import_dynamic libc_CFBundleGetValueForInfoDictionaryKey CFBundleGetValueForInfoDictionaryKey "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
+//go:cgo_import_dynamic libc_CFStringGetCString CFStringGetCString "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"
+//go:cgo_import_dynamic libc_CFRelease CFRelease "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"

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

@@ -0,0 +1,78 @@
+// Copyright 2026 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go_asm.h"
+#include "go_tls.h"
+#include "textflag.h"
+#include "cgo/abi_arm64.h"
+
+TEXT runtime·chdir_trampoline(SB),NOSPLIT,$0
+	MOVD	0(R0), R0	// arg 1 path
+	BL	libc_chdir(SB)
+	RET
+
+TEXT runtime·cfBundleGetMainBundle_trampoline(SB),NOSPLIT,$0
+	MOVD	R0, R19
+	BL	libc_CFBundleGetMainBundle(SB)
+	MOVD	R0, 0(R19)
+	RET
+
+TEXT runtime·cfBundleCopyBundleURL_trampoline(SB),NOSPLIT,$0
+	MOVD	R0, R19
+	MOVD	0(R0), R0	// arg 1 bundle
+	BL	libc_CFBundleCopyBundleURL(SB)
+	MOVD	R0, 8(R19)
+	RET
+
+TEXT runtime·cfBundleCopyResourceURL_trampoline(SB),NOSPLIT,$0
+	MOVD	R0, R19
+	MOVD	8(R0), R1	// arg 2 resourceName
+	MOVD	16(R0), R2	// arg 3 resourceType
+	MOVD	24(R0), R3	// arg 4 subDirName
+	MOVD	0(R0), R0	// arg 1 bundle
+	BL	libc_CFBundleCopyResourceURL(SB)
+	MOVD	R0, 32(R19)
+	RET
+
+TEXT runtime·cfURLGetFileSystemRepresentation_trampoline(SB),NOSPLIT,$0
+	MOVD	R0, R19
+	MOVD	8(R0), R1	// arg 2 resolveAgainstBase
+	MOVD	16(R0), R2	// arg 3 path
+	MOVD	24(R0), R3	// arg 4 pathLen
+	MOVD	0(R0), R0	// arg 1 url
+	BL	libc_CFURLGetFileSystemRepresentation(SB)
+	MOVD	R0, 32(R19)
+	RET
+
+TEXT runtime·cfStringCreateWithCString_trampoline(SB),NOSPLIT,$0
+	MOVD	R0, R19
+	MOVD	8(R0), R1	// arg 2 str
+	MOVD	16(R0), R2	// arg 3 encoding
+	MOVD	0(R0), R0	// arg 1 alloc
+	BL	libc_CFStringCreateWithCString(SB)
+	MOVD	R0, 24(R19)
+	RET
+
+TEXT runtime·cfBundleGetValueForInfoDictionaryKey_trampoline(SB),NOSPLIT,$0
+	MOVD	R0, R19
+	MOVD	8(R0), R1	// arg 2 key
+	MOVD	0(R0), R0	// arg 1 bundle
+	BL	libc_CFBundleGetValueForInfoDictionaryKey(SB)
+	MOVD	R0, 16(R19)
+	RET
+
+TEXT runtime·cfStringGetCString_trampoline(SB),NOSPLIT,$0
+	MOVD	R0, R19
+	MOVD	8(R0), R1	// arg 2 buf
+	MOVD	16(R0), R2	// arg 3 bufLen
+	MOVD	24(R0), R3	// arg 4 encoding
+	MOVD	0(R0), R0	// arg 1 str
+	BL	libc_CFStringGetCString(SB)
+	MOVD	R0, 32(R19)
+	RET
+
+TEXT runtime·cfRelease_trampoline(SB),NOSPLIT,$0
+	MOVD	0(R0), R0	// arg 1 ref
+	BL	libc_CFRelease(SB)
+	RET

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

@@ -480,7 +480,13 @@ sigtrampnog:
 // the name. The gdb source code is:
 // https://sourceware.org/git/?p=binutils-gdb.git;a=blob;f=gdb/amd64-linux-tdep.c;h=cbbac1a0c64e1deb8181b9d0ff6404e328e2979d#l178
 TEXT runtime·sigreturn__sigaction(SB),NOSPLIT,$0
-	MOVQ	$SYS_rt_sigreturn, AX
+	// The 7-byte sign-extended "48 c7 c0 0f 00 00 00" form of
+	// "MOVQ $SYS_rt_sigreturn, AX" is required: gdb and libgcc match
+	// these exact bytes to recognize the signal trampoline. The Go
+	// assembler now emits the 5-byte zero-extended "b8 0f 00 00 00"
+	// form for positive imm32, so write the bytes by hand.
+	BYTE $0x48; BYTE $0xc7; BYTE $0xc0
+	BYTE $0x0f; BYTE $0x00; BYTE $0x00; BYTE $0x00
 	SYSCALL
 	INT $3	// not reached