@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/runtime/cgo/asm_riscv64.s

@@ -3,6 +3,7 @@
 // license that can be found in the LICENSE file.
 
 #include "textflag.h"
+#include "abi_riscv64.h"
 
 // Set the x_crosscall2_ptr C function pointer variable point to crosscall2.
 // It's such a pointer chain: _crosscall2_ptr -> x_crosscall2_ptr -> crosscall2
@@ -31,61 +32,19 @@ TEXT crosscall2(SB),NOSPLIT|NOFRAME,$0
 	MOV	X10, (8*1)(X2) // fn unsafe.Pointer
 	MOV	X11, (8*2)(X2) // a unsafe.Pointer
 	MOV	X13, (8*3)(X2) // ctxt uintptr
-	MOV	X8, (8*4)(X2)
-	MOV	X9, (8*5)(X2)
-	MOV	X18, (8*6)(X2)
-	MOV	X19, (8*7)(X2)
-	MOV	X20, (8*8)(X2)
-	MOV	X21, (8*9)(X2)
-	MOV	X22, (8*10)(X2)
-	MOV	X23, (8*11)(X2)
-	MOV	X24, (8*12)(X2)
-	MOV	X25, (8*13)(X2)
-	MOV	X26, (8*14)(X2)
-	MOV	g, (8*15)(X2)
+
+	SAVE_GPR((8*4))
 	MOV	X1, (8*16)(X2)
-	MOVD	F8, (8*17)(X2)
-	MOVD	F9, (8*18)(X2)
-	MOVD	F18, (8*19)(X2)
-	MOVD	F19, (8*20)(X2)
-	MOVD	F20, (8*21)(X2)
-	MOVD	F21, (8*22)(X2)
-	MOVD	F22, (8*23)(X2)
-	MOVD	F23, (8*24)(X2)
-	MOVD	F24, (8*25)(X2)
-	MOVD	F25, (8*26)(X2)
-	MOVD	F26, (8*27)(X2)
-	MOVD	F27, (8*28)(X2)
+	SAVE_FPR((8*17))
 
 	// Initialize Go ABI environment
 	CALL	runtime·load_g(SB)
 	CALL	runtime·cgocallback(SB)
 
-	MOV	(8*4)(X2), X8
-	MOV	(8*5)(X2), X9
-	MOV	(8*6)(X2), X18
-	MOV	(8*7)(X2), X19
-	MOV	(8*8)(X2), X20
-	MOV	(8*9)(X2), X21
-	MOV	(8*10)(X2), X22
-	MOV	(8*11)(X2), X23
-	MOV	(8*12)(X2), X24
-	MOV	(8*13)(X2), X25
-	MOV	(8*14)(X2), X26
-	MOV	(8*15)(X2), g
+	RESTORE_GPR((8*4))
 	MOV	(8*16)(X2), X1
-	MOVD	(8*17)(X2), F8
-	MOVD	(8*18)(X2), F9
-	MOVD	(8*19)(X2), F18
-	MOVD	(8*20)(X2), F19
-	MOVD	(8*21)(X2), F20
-	MOVD	(8*22)(X2), F21
-	MOVD	(8*23)(X2), F22
-	MOVD	(8*24)(X2), F23
-	MOVD	(8*25)(X2), F24
-	MOVD	(8*26)(X2), F25
-	MOVD	(8*27)(X2), F26
-	MOVD	(8*28)(X2), F27
+	RESTORE_FPR((8*17))
+
 	ADD	$(8*29), X2
 
 	RET

package/bin/go/src/runtime/cgo/callbacks.go

@@ -47,30 +47,6 @@ func _cgo_panic(a *struct{ cstr *byte }) {
 	_runtime_cgo_panic_internal(a.cstr)
 }
 
-//go:cgo_import_static x_cgo_init
-//go:linkname x_cgo_init x_cgo_init
-//go:linkname _cgo_init _cgo_init
-var x_cgo_init byte
-var _cgo_init = &x_cgo_init
-
-//go:cgo_import_static x_cgo_thread_start
-//go:linkname x_cgo_thread_start x_cgo_thread_start
-//go:linkname _cgo_thread_start _cgo_thread_start
-var x_cgo_thread_start byte
-var _cgo_thread_start = &x_cgo_thread_start
-
-// Creates a new system thread without updating any Go state.
-//
-// This method is invoked during shared library loading to create a new OS
-// thread to perform the runtime initialization. This method is similar to
-// _cgo_sys_thread_start except that it doesn't update any Go state.
-
-//go:cgo_import_static x_cgo_sys_thread_create
-//go:linkname x_cgo_sys_thread_create x_cgo_sys_thread_create
-//go:linkname _cgo_sys_thread_create _cgo_sys_thread_create
-var x_cgo_sys_thread_create byte
-var _cgo_sys_thread_create = &x_cgo_sys_thread_create
-
 // Indicates whether a dummy thread key has been created or not.
 //
 // When calling go exported function from C, we register a destructor
@@ -98,15 +74,6 @@ func set_crosscall2()
 //go:linkname _set_crosscall2 runtime.set_crosscall2
 var _set_crosscall2 = set_crosscall2
 
-// Store the g into the thread-specific value.
-// So that pthread_key_destructor will dropm when the thread is exiting.
-
-//go:cgo_import_static x_cgo_bindm
-//go:linkname x_cgo_bindm x_cgo_bindm
-//go:linkname _cgo_bindm _cgo_bindm
-var x_cgo_bindm byte
-var _cgo_bindm = &x_cgo_bindm
-
 // Notifies that the runtime has been initialized.
 //
 // We currently block at every CGO entry point (via _cgo_wait_runtime_init_done)
@@ -158,12 +125,3 @@ var _cgo_yield unsafe.Pointer
 
 //go:cgo_export_static _cgo_topofstack
 //go:cgo_export_dynamic _cgo_topofstack
-
-// x_cgo_getstackbound gets the thread's C stack size and
-// set the G's stack bound based on the stack size.
-
-//go:cgo_import_static x_cgo_getstackbound
-//go:linkname x_cgo_getstackbound x_cgo_getstackbound
-//go:linkname _cgo_getstackbound _cgo_getstackbound
-var x_cgo_getstackbound byte
-var _cgo_getstackbound = &x_cgo_getstackbound

package/bin/go/src/runtime/cgo/callbacks_unix.go

@@ -0,0 +1,58 @@
+// 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.
+
+//go:build unix
+
+package cgo
+
+import _ "unsafe" // for go:linkname
+
+// We need to reference the addresses of the C functions in Go code,
+// but we don't want to reference them directly in text. Otherwise it
+// may cause dynamic relocations in the text segment, or even build
+// failures in some settings, e.g. linking with -Bsymbolic-functions.
+// Reference them via variables with an extra level of indirection to
+// avoid that.
+
+//go:cgo_import_static x_cgo_init
+//go:linkname x_cgo_init x_cgo_init
+//go:linkname _cgo_init _cgo_init
+var x_cgo_init byte
+var _cgo_init = &x_cgo_init
+
+//go:cgo_import_static x_cgo_thread_start
+//go:linkname x_cgo_thread_start x_cgo_thread_start
+//go:linkname _cgo_thread_start _cgo_thread_start
+var x_cgo_thread_start byte
+var _cgo_thread_start = &x_cgo_thread_start
+
+// Creates a new system thread without updating any Go state.
+//
+// This method is invoked during shared library loading to create a new OS
+// thread to perform the runtime initialization. This method is similar to
+// x_cgo_thread_start except that it doesn't update any Go state.
+
+//go:cgo_import_static x_cgo_sys_thread_create
+//go:linkname x_cgo_sys_thread_create x_cgo_sys_thread_create
+//go:linkname _cgo_sys_thread_create _cgo_sys_thread_create
+var x_cgo_sys_thread_create byte
+var _cgo_sys_thread_create = &x_cgo_sys_thread_create
+
+// Store the g into the thread-specific value.
+// So that pthread_key_destructor will dropm when the thread is exiting.
+
+//go:cgo_import_static x_cgo_bindm
+//go:linkname x_cgo_bindm x_cgo_bindm
+//go:linkname _cgo_bindm _cgo_bindm
+var x_cgo_bindm byte
+var _cgo_bindm = &x_cgo_bindm
+
+// x_cgo_getstackbound gets the thread's C stack size and
+// set the G's stack bound based on the stack size.
+
+//go:cgo_import_static x_cgo_getstackbound
+//go:linkname x_cgo_getstackbound x_cgo_getstackbound
+//go:linkname _cgo_getstackbound _cgo_getstackbound
+var x_cgo_getstackbound byte
+var _cgo_getstackbound = &x_cgo_getstackbound

package/bin/go/src/runtime/cgo/cgo.go

@@ -12,7 +12,6 @@ package cgo
 /*
 
 #cgo darwin,!arm64 LDFLAGS: -lpthread
-#cgo darwin,arm64 LDFLAGS: -framework CoreFoundation
 #cgo dragonfly LDFLAGS: -lpthread
 #cgo freebsd LDFLAGS: -lpthread
 #cgo android LDFLAGS: -llog
@@ -20,14 +19,18 @@ package cgo
 #cgo netbsd LDFLAGS: -lpthread
 #cgo openbsd LDFLAGS: -lpthread
 #cgo aix LDFLAGS: -Wl,-berok
-#cgo solaris LDFLAGS: -lxnet
-#cgo solaris LDFLAGS: -lsocket
 
 // Use -fno-stack-protector to avoid problems locating the
 // proper support functions. See issues #52919, #54313, #58385.
 // Use -Wdeclaration-after-statement because some CI builds use it.
 #cgo CFLAGS: -Wall -Werror -fno-stack-protector -Wdeclaration-after-statement
 
+// Use -std=gnu90 to maintain portability;
+// we don't use c90 because that doesn't permit C++ line comments,
+// which is just too painful.
+// We don't do it on windows-386 because it causes test failures.
+#cgo (!windows||!386) CFLAGS: -std=gnu90
+
 #cgo solaris CPPFLAGS: -D_POSIX_PTHREAD_SEMANTICS
 
 */

package/bin/go/src/runtime/cgo/gcc_aix_ppc64.S

@@ -5,23 +5,24 @@
 .file "gcc_aix_ppc64.S"
 
 /*
- * void crosscall_ppc64(void (*fn)(void), void *g)
+ * void crosscall1(void (*fn)(void), void (*setg_gcc)(void*), void *g)
  *
  * Calling into the gc tool chain, where all registers are caller save.
  * Called from standard ppc64 C ABI, where r2, r14-r31, f14-f31 are
  * callee-save, so they must be saved explicitly.
  * AIX has a special assembly syntax and keywords that can be mixed with
  * Linux assembly.
+ * ABI: r3=fn, r4=setg_gcc, r5=g
  */
   .toc
   .csect .text[PR]
-  .globl crosscall_ppc64
-  .globl .crosscall_ppc64
-  .csect crosscall_ppc64[DS]
-crosscall_ppc64:
-  .llong .crosscall_ppc64, TOC[tc0], 0
+  .globl crosscall1
+  .globl .crosscall1
+  .csect crosscall1[DS]
+crosscall1:
+  .llong .crosscall1, TOC[tc0], 0
   .csect .text[PR]
-.crosscall_ppc64:
+.crosscall1:
 	// Start with standard C stack frame layout and linkage
 	mflr	0
 	std	0, 16(1)	// Save LR in caller's frame
@@ -33,11 +34,22 @@ crosscall_ppc64:
 	// Must match _cgo_reginit in runtime package.
 	xor 0, 0, 0
 
+	// Save fn in r14 (callee-save) so we can reuse r3 for setg_gcc call
+	mr	14, 3
 	// Restore g pointer (r30 in Go ABI, which may have been clobbered by C)
-	mr	30, 4
+	mr	30, 5
+
+	// Call setg_gcc(g)
+	// Function pointers are function descriptors.
+	// Dereference setg_gcc to get the entry point and TOC.
+	mr	3, 5      // arg g
+	ld	12, 0(4)  // load entry point from function descriptor
+	ld	2, 8(4)   // load TOC from function descriptor
+	mtctr	12
+	bctrl
 
 	// Call fn
-	mr	12, 3
+	mr	12, 14
 	mtctr	12
 	bctrl
 

package/bin/go/src/runtime/cgo/gcc_android.c

@@ -2,36 +2,10 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include <stdarg.h>
-#include <android/log.h>
 #include <pthread.h>
 #include <dlfcn.h>
 #include "libcgo.h"
 
-void
-fatalf(const char* format, ...)
-{
-	va_list ap;
-
-	// Write to both stderr and logcat.
-	//
-	// When running from an .apk, /dev/stderr and /dev/stdout
-	// redirect to /dev/null. And when running a test binary
-	// via adb shell, it's easy to miss logcat.
-
-	fprintf(stderr, "runtime/cgo: ");
-	va_start(ap, format);
-	vfprintf(stderr, format, ap);
-	va_end(ap);
-	fprintf(stderr, "\n");
-
-	va_start(ap, format);
-	__android_log_vprint(ANDROID_LOG_FATAL, "runtime/cgo", format, ap);
-	va_end(ap);
-
-	abort();
-}
-
 // Truncated to a different magic value on 32-bit; that's ok.
 #define magic1 (0x23581321345589ULL)
 

package/bin/go/src/runtime/cgo/gcc_clearenv.c

@@ -10,7 +10,7 @@
 
 /* Stub for calling clearenv */
 void
-x_cgo_clearenv(void **_unused)
+x_cgo_clearenv(void **env __attribute__((unused)))
 {
 	_cgo_tsan_acquire();
 	clearenv();

package/bin/go/src/runtime/cgo/gcc_fatalf.c

@@ -2,11 +2,12 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build aix || (!android && linux) || dragonfly || freebsd || netbsd || openbsd || solaris
+//go:build unix
 
 #include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
+#ifdef __ANDROID__
+#include <android/log.h>
+#endif
 #include "libcgo.h"
 
 void
@@ -19,5 +20,15 @@ fatalf(const char* format, ...)
 	vfprintf(stderr, format, ap);
 	va_end(ap);
 	fprintf(stderr, "\n");
+
+#ifdef __ANDROID__
+	// When running from an Android .apk, /dev/stderr and /dev/stdout
+	// redirect to /dev/null. And when running a test binary
+	// via adb shell, it's easy to miss logcat. So write to both.
+	va_start(ap, format);
+	__android_log_vprint(ANDROID_LOG_FATAL, "runtime/cgo", format, ap);
+	va_end(ap);
+#endif
+
 	abort();
 }

package/bin/go/src/runtime/cgo/{gcc_libinit.c → gcc_libinit_unix.c}

@@ -12,11 +12,8 @@
 #pragma GCC diagnostic ignored "-Watomic-alignment"
 
 #include <pthread.h>
-#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h> // strerror
-#include <time.h>
 #include "libcgo.h"
 #include "libcgo_unix.h"
 
@@ -41,21 +38,6 @@ static void (*cgo_context_function)(struct cgoContextArg*);
 // The symbolizer function, used when symbolizing C frames.
 static void (*cgo_symbolizer_function)(struct cgoSymbolizerArg*);
 
-void
-x_cgo_sys_thread_create(void* (*func)(void*), void* arg) {
-	pthread_attr_t attr;
-	pthread_t p;
-	int err;
-
-	pthread_attr_init(&attr);
-	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
-	err = _cgo_try_pthread_create(&p, &attr, func, arg);
-	if (err != 0) {
-		fprintf(stderr, "pthread_create failed: %s", strerror(err));
-		abort();
-	}
-}
-
 uintptr_t
 _cgo_wait_runtime_init_done(void) {
 	void (*pfn)(struct cgoContextArg*);
@@ -101,30 +83,6 @@ _cgo_wait_runtime_init_done(void) {
 	return 0;
 }
 
-// _cgo_set_stacklo sets g->stacklo based on the stack size.
-// This is common code called from x_cgo_init, which is itself
-// called by rt0_go in the runtime package.
-void _cgo_set_stacklo(G *g, uintptr *pbounds)
-{
-	uintptr bounds[2];
-
-	// pbounds can be passed in by the caller; see gcc_linux_amd64.c.
-	if (pbounds == NULL) {
-		pbounds = &bounds[0];
-	}
-
-	x_cgo_getstackbound(pbounds);
-
-	g->stacklo = *pbounds;
-
-	// Sanity check the results now, rather than getting a
-	// morestack on g0 crash.
-	if (g->stacklo >= g->stackhi) {
-		fprintf(stderr, "runtime/cgo: bad stack bounds: lo=%p hi=%p\n", (void*)(g->stacklo), (void*)(g->stackhi));
-		abort();
-	}
-}
-
 // Store the g into a thread-specific value associated with the pthread key pthread_g.
 // And pthread_key_destructor will dropm when the thread is exiting.
 void x_cgo_bindm(void* g) {
@@ -208,29 +166,6 @@ void x_cgo_call_symbolizer_function(struct cgoSymbolizerArg* arg) {
 	_cgo_tsan_release();
 }
 
-// _cgo_try_pthread_create retries pthread_create if it fails with
-// EAGAIN.
-int
-_cgo_try_pthread_create(pthread_t* thread, const pthread_attr_t* attr, void* (*pfn)(void*), void* arg) {
-	int tries;
-	int err;
-	struct timespec ts;
-
-	for (tries = 0; tries < 20; tries++) {
-		err = pthread_create(thread, attr, pfn, arg);
-		if (err == 0) {
-			return 0;
-		}
-		if (err != EAGAIN) {
-			return err;
-		}
-		ts.tv_sec = 0;
-		ts.tv_nsec = (tries + 1) * 1000 * 1000; // Milliseconds.
-		nanosleep(&ts, nil);
-	}
-	return EAGAIN;
-}
-
 static void
 pthread_key_destructor(void* g) {
 	if (x_crosscall2_ptr != NULL) {
@@ -241,3 +176,21 @@ pthread_key_destructor(void* g) {
 		x_crosscall2_ptr(NULL, g, 0, 0);
 	}
 }
+
+void
+x_cgo_thread_start(ThreadStart *arg)
+{
+	ThreadStart *ts;
+
+	/* Make our own copy that can persist after we return. */
+	_cgo_tsan_acquire();
+	ts = malloc(sizeof *ts);
+	_cgo_tsan_release();
+	if(ts == nil) {
+		fprintf(stderr, "runtime/cgo: out of memory in thread_start\n");
+		abort();
+	}
+	*ts = *arg;
+
+	_cgo_sys_thread_start(ts);	/* OS-dependent half */
+}

package/bin/go/src/runtime/cgo/gcc_libinit_windows.c

@@ -13,7 +13,29 @@
 #include <stdlib.h>
 
 #include "libcgo.h"
-#include "libcgo_windows.h"
+
+#define IMAGE_GUARD_SECURITY_COOKIE_UNUSED 0x00000800
+// With modern mingw, we can use the normal struct:
+//
+// const IMAGE_LOAD_CONFIG_DIRECTORY _load_config_used = {
+// 	.Size = sizeof(_load_config_used),
+// 	.GuardFlags = IMAGE_GUARD_SECURITY_COOKIE_UNUSED
+// };
+//
+// But we support older toolchains, so instead, fix the offsets:
+#ifdef _WIN64
+const ULONGLONG _load_config_used[40] = {
+	sizeof(_load_config_used),
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	IMAGE_GUARD_SECURITY_COOKIE_UNUSED
+};
+#else
+const DWORD _load_config_used[48] = {
+	sizeof(_load_config_used),
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	IMAGE_GUARD_SECURITY_COOKIE_UNUSED
+};
+#endif
 
 static volatile LONG runtime_init_once_gate = 0;
 static volatile LONG runtime_init_once_done = 0;
@@ -56,11 +78,6 @@ _cgo_maybe_run_preinit() {
 	 }
 }
 
-void
-x_cgo_sys_thread_create(unsigned long (__stdcall *func)(void*), void* arg) {
-	_cgo_beginthread(func, arg);
-}
-
 int
 _cgo_is_runtime_initialized() {
 	 int status;
@@ -90,12 +107,6 @@ _cgo_wait_runtime_init_done(void) {
 	return 0;
 }
 
-// Should not be used since x_cgo_pthread_key_created will always be zero.
-void x_cgo_bindm(void* dummy) {
-	fprintf(stderr, "unexpected cgo_bindm on Windows\n");
-	abort();
-}
-
 void
 x_cgo_notify_runtime_init_done(void* dummy) {
 	 _cgo_maybe_run_preinit();
@@ -189,26 +200,3 @@ void x_cgo_call_symbolizer_function(struct cgoSymbolizerArg* arg) {
 
 	(*pfn)(arg);
 }
-
-void _cgo_beginthread(unsigned long (__stdcall *func)(void*), void* arg) {
-	int tries;
-	HANDLE thandle;
-
-	for (tries = 0; tries < 20; tries++) {
-		thandle = CreateThread(NULL, 0, func, arg, 0, NULL);
-		if (thandle == 0 && GetLastError() == ERROR_ACCESS_DENIED) {
-			// "Insufficient resources", try again in a bit.
-			//
-			// Note that the first Sleep(0) is a yield.
-			Sleep(tries); // milliseconds
-			continue;
-		} else if (thandle == 0) {
-			break;
-		}
-		CloseHandle(thandle);
-		return; // Success!
-	}
-
-	fprintf(stderr, "runtime: failed to create new OS thread (%lu)\n", GetLastError());
-	abort();
-}

package/bin/go/src/runtime/cgo/gcc_linux_ppc64x.S

@@ -38,14 +38,15 @@
 .endm
 
 /*
- * void crosscall_ppc64(void (*fn)(void), void *g)
+ * void crosscall1(void (*fn)(void), void (*setg_gcc)(void*), void *g)
  *
  * Calling into the gc tool chain, where all registers are caller save.
  * Called from standard ppc64 C ABI, where r2, r14-r31, f14-f31 are
  * callee-save, so they must be saved explicitly.
+ * ABI: r3=fn, r4=setg_gcc, r5=g on entry.
  */
-.globl crosscall_ppc64
-crosscall_ppc64:
+.globl crosscall1
+crosscall1:
 	// Start with standard C stack frame layout and linkage
 	mflr	%r0
 	std	%r0, 16(%r1)	// Save LR in caller's frame
@@ -61,12 +62,20 @@ crosscall_ppc64:
 	// Set up Go ABI constant registers
 	li	%r0, 0
 
+	// Save fn in r14 (callee-save) while we call setg_gcc
+	mr	%r14, %r3
 	// Restore g pointer (r30 in Go ABI, which may have been clobbered by C)
-	mr	%r30, %r4
+	mr	%r30, %r5
 
-	// Call fn
-	mr	%r12, %r3
-	mtctr	%r3
+	// Call setg_gcc(g)
+	mr	%r3, %r5        /* arg: g */
+	mr	%r12, %r4       /* setg_gcc */
+	mtctr	%r12
+	bctrl
+
+	// Call fn()
+	mr	%r12, %r14
+	mtctr	%r12
 	bctrl
 
 	FOR_EACH_GPR ld

package/bin/go/src/runtime/cgo/gcc_netbsd.c

@@ -2,62 +2,14 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build netbsd && (386 || amd64 || arm || arm64)
+//go:build netbsd
 
-#include <sys/types.h>
-#include <pthread.h>
-#include <signal.h>
 #include <string.h>
-#include "libcgo.h"
-#include "libcgo_unix.h"
-
-static void* threadentry(void*);
-static void (*setg_gcc)(void*);
-
-void
-x_cgo_init(G *g, void (*setg)(void*))
-{
-	setg_gcc = setg;
-	_cgo_set_stacklo(g, NULL);
-}
-
-
-void
-_cgo_sys_thread_start(ThreadStart *ts)
-{
-	pthread_attr_t attr;
-	sigset_t ign, oset;
-	pthread_t p;
-	size_t size;
-	int err;
-
-	sigfillset(&ign);
-	pthread_sigmask(SIG_SETMASK, &ign, &oset);
-
-	pthread_attr_init(&attr);
-	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
-	pthread_attr_getstacksize(&attr, &size);
-	// Leave stacklo=0 and set stackhi=size; mstart will do the rest.
-	ts->g->stackhi = size;
-	err = _cgo_try_pthread_create(&p, &attr, threadentry, ts);
-
-	pthread_sigmask(SIG_SETMASK, &oset, nil);
-
-	if (err != 0) {
-		fatalf("pthread_create failed: %s", strerror(err));
-	}
-}
+#include <signal.h>
 
-extern void crosscall1(void (*fn)(void), void (*setg_gcc)(void*), void *g);
-static void*
-threadentry(void *v)
+static void
+threadentry_platform(void)
 {
-	ThreadStart ts;
-	stack_t ss;
-
-	ts = *(ThreadStart*)v;
-	free(v);
-
 	// On NetBSD, a new thread inherits the signal stack of the
 	// creating thread. That confuses minit, so we remove that
 	// signal stack here before calling the regular mstart. It's
@@ -65,10 +17,10 @@ threadentry(void *v)
 	// in minit, but it's a simple change that keeps NetBSD
 	// working like other OS's. At this point all signals are
 	// blocked, so there is no race.
+	stack_t ss;
 	memset(&ss, 0, sizeof ss);
 	ss.ss_flags = SS_DISABLE;
-	sigaltstack(&ss, nil);
-
-	crosscall1(ts.fn, setg_gcc, ts.g);
-	return nil;
+	sigaltstack(&ss, NULL);
 }
+
+void (*x_cgo_threadentry_platform)(void) = threadentry_platform;