@ttsc/win32-arm64 0.33.1 → 0.34.0

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

@@ -5,14 +5,15 @@
 .file "gcc_s390x.S"
 
 /*
- * void crosscall_s390x(void (*fn)(void), void *g)
+ * void crosscall1(void (*fn)(void), void (*setg_gcc)(void*), void *g)
  *
  * Calling into the go tool chain, where all registers are caller save.
  * Called from standard s390x C ABI, where r6-r13, r15, and f8-f15 are
  * callee-save, so they must be saved explicitly.
+ * ABI: r2=fn, r3=setg_gcc, r4=g.
  */
-.globl crosscall_s390x
-crosscall_s390x:
+.globl crosscall1
+crosscall1:
 	/* save r6-r15 in the register save area of the calling function */
 	stmg    %r6, %r15, 48(%r15)
 
@@ -29,10 +30,18 @@ crosscall_s390x:
 	std     %f14, 48(%r15)
 	std     %f15, 56(%r15)
 
+	/* save fn pointer in r6 (already saved to stack) */
+	lgr     %r6, %r2
 	/* restore g pointer */
-	lgr     %r13, %r3
+	lgr     %r13, %r4
+
+	/* prepare arg for setg_gcc: first argument in r2 */
+	lgr     %r2, %r4      /* r2 = g */
+	/* call setg_gcc(g) using function pointer in r3 */
+	basr    %r14, %r3
 
 	/* call fn */
+	lgr     %r2, %r6
 	basr    %r14, %r2
 
 	/* restore floating point registers */

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

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build linux && (386 || amd64 || arm64 || loong64 || ppc64le)
+//go:build linux && (386 || amd64 || arm64 || loong64 || ppc64 || ppc64le)
 
 #include <errno.h>
 #include <stddef.h>

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

@@ -0,0 +1,63 @@
+// Copyright 2009 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
+
+#include "libcgo.h"
+#include "libcgo_unix.h"
+
+// Platform-specific hooks.
+void (*x_cgo_inittls)(void **tlsg, void **tlsbase) __attribute__((weak));
+void (*x_cgo_threadentry_platform)(void) __attribute__((weak));
+
+static void (*setg_gcc)(void*);
+
+// _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.
+static void
+_cgo_set_stacklo(G *g)
+{
+	uintptr bounds[2];
+
+	x_cgo_getstackbound(bounds);
+
+	g->stacklo = bounds[0];
+
+	// 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();
+	}
+}
+
+void
+x_cgo_init(G *g, void (*setg)(void*), void **tlsg, void **tlsbase)
+{
+	setg_gcc = setg;
+	_cgo_set_stacklo(g);
+
+	if (x_cgo_inittls) {
+		x_cgo_inittls(tlsg, tlsbase);
+	}
+}
+
+void*
+threadentry(void *v)
+{
+	ThreadStart ts;
+
+	ts = *(ThreadStart*)v;
+	_cgo_tsan_acquire();
+	free(v);
+	_cgo_tsan_release();
+
+	if (x_cgo_threadentry_platform != NULL) {
+		x_cgo_threadentry_platform();
+	}
+
+	crosscall1(ts.fn, setg_gcc, ts.g);
+	return NULL;
+}

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

@@ -4,25 +4,6 @@
 
 #include "libcgo.h"
 
-/* Stub for creating a new thread */
-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 */
-}
-
 #ifndef CGO_TSAN
 void(* const _cgo_yield)() = NULL;
 #else

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

@@ -97,6 +97,9 @@ import (
 //	func main() {
 //		val := "hello Go"
 //		h := cgo.NewHandle(val)
+//		// In this example, unsafe.Pointer(&h) is valid because myprint
+//		// does not keep a copy of the pointer. If the C code keeps the
+//		// pointer after the call returns, use runtime.Pinner to pin it.
 //		C.myprint(unsafe.Pointer(&h))
 //		// Output: hello Go
 //	}

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

@@ -49,7 +49,7 @@ extern void (*_cgo_thread_start)(ThreadStart *ts);
  * Creates a new operating system thread without updating any Go state
  * (OS dependent).
  */
-extern void (*_cgo_sys_thread_create)(void* (*func)(void*), void* arg);
+extern void (*_cgo_sys_thread_create)(void* (*func)(void*));
 
 /*
  * Indicates whether a dummy pthread per-thread variable is allocated.
@@ -74,19 +74,16 @@ uintptr_t _cgo_wait_runtime_init_done(void);
 void x_cgo_getstackbound(uintptr bounds[2]);
 
 /*
- * Prints error then calls abort. For linux and android.
+ * Calls into the Go tool chain, where all registers are caller save.
+ * Called from C, it saves all callee-save registers and calls
+ * setg_gcc to set g before calling fn.
  */
-void fatalf(const char* format, ...) __attribute__ ((noreturn));
+void crosscall1(void (*fn)(void), void (*setg_gcc)(void*), void *g);
 
 /*
- * Registers the current mach thread port for EXC_BAD_ACCESS processing.
- */
-void darwin_arm_init_thread_exception_port(void);
-
-/*
- * Starts a mach message server processing EXC_BAD_ACCESS.
+ * Prints error then calls abort. For linux and android.
  */
-void darwin_arm_init_mach_exception_handler(void);
+void fatalf(const char* format, ...) __attribute__ ((noreturn));
 
 /*
  * The cgo traceback callback. See runtime.SetCgoTraceback.

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

@@ -2,19 +2,11 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-/*
- * Initialize g->stacklo.
- */
-extern void _cgo_set_stacklo(G *, uintptr *);
+#include <pthread.h>
 
 /*
  * Call pthread_create, retrying on EAGAIN.
  */
 extern int _cgo_try_pthread_create(pthread_t*, const pthread_attr_t*, void* (*)(void*), void*);
 
-/*
- * Same as _cgo_try_pthread_create, but passing on the pthread_create function.
- * Only defined on OpenBSD.
- */
-extern int _cgo_openbsd_try_pthread_create(int (*)(pthread_t*, const pthread_attr_t*, void *(*pfn)(void*), void*),
-	pthread_t*, const pthread_attr_t*, void* (*)(void*), void* arg);
+extern void* threadentry(void*);

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

@@ -0,0 +1,138 @@
+// Copyright 2025 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
+
+#ifndef _GNU_SOURCE // pthread_getattr_np
+#define _GNU_SOURCE
+#endif
+
+#include <pthread.h>
+#include <string.h>
+#include <signal.h>
+#include <errno.h>
+#include "libcgo.h"
+#include "libcgo_unix.h"
+
+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);
+#if defined(__APPLE__)
+	// Copy stack size from parent thread instead of using the
+	// non-main thread default stack size.
+	size = pthread_get_stacksize_np(pthread_self());
+	pthread_attr_setstacksize(&attr, size);
+#else
+	pthread_attr_getstacksize(&attr, &size);
+#endif
+
+#if defined(__sun)
+	// Solaris can report 0 stack size, fix it.
+	if (size == 0) {
+		size = 2 << 20;
+		if (pthread_attr_setstacksize(&attr, size) != 0) {
+			perror("runtime/cgo: pthread_attr_setstacksize failed");
+		}
+	}
+#endif
+
+	// 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));
+	}
+}
+
+void
+x_cgo_sys_thread_create(void* (*func)(void*)) {
+	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, NULL);
+	if (err != 0) {
+		fatalf("pthread_create failed: %s", strerror(err));
+	}
+}
+
+void
+x_cgo_getstackbound(uintptr bounds[2])
+{
+	pthread_attr_t attr;
+	void *addr;
+	size_t size;
+
+	// Needed before pthread_getattr_np, too, since before glibc 2.32
+	// it did not call pthread_attr_init in all cases (see #65625).
+	pthread_attr_init(&attr);
+#if defined(__APPLE__)
+	// On macOS/iOS, use the non-portable pthread_get_stackaddr_np
+	// and pthread_get_stacksize_np APIs (high address + size).
+	addr = pthread_get_stackaddr_np(pthread_self());
+	size = pthread_get_stacksize_np(pthread_self());
+	addr = (void*)((uintptr)addr - size); // convert to low address
+#elif defined(__GLIBC__) || defined(__BIONIC__) || (defined(__sun) && !defined(__illumos__))
+	// pthread_getattr_np is a GNU extension supported in glibc.
+	// Solaris is not glibc but does support pthread_getattr_np
+	// (and the fallback doesn't work...). Illumos does not.
+	pthread_getattr_np(pthread_self(), &attr);  // GNU extension
+	pthread_attr_getstack(&attr, &addr, &size); // low address
+#elif defined(__illumos__)
+	pthread_attr_get_np(pthread_self(), &attr);
+	pthread_attr_getstack(&attr, &addr, &size); // low address
+#else
+	// We don't know how to get the current stacks, leave it as
+	// 0 and the caller will use an estimate based on the current
+	// SP.
+	addr = 0;
+	size = 0;
+#endif
+	pthread_attr_destroy(&attr);
+
+	// bounds points into the Go stack. TSAN can't see the synchronization
+	// in Go around stack reuse.
+	_cgo_tsan_acquire();
+	bounds[0] = (uintptr)addr;
+	bounds[1] = (uintptr)addr + size;
+	_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;
+}

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

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (linux && (386 || amd64 || arm64 || loong64 || ppc64le)) || (freebsd && amd64)
+//go:build (linux && (386 || amd64 || arm64 || loong64 || ppc64 || ppc64le)) || (freebsd && amd64)
 
 package cgo
 

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

@@ -6,7 +6,7 @@
 
 package cgo
 
-import _ "unsafe" // for go:linkname
+import "unsafe"
 
 // _cgo_stub_export is only used to ensure there's at least one symbol
 // in the .def file passed to the external linker.
@@ -20,3 +20,20 @@ import _ "unsafe" // for go:linkname
 //go:cgo_export_static _cgo_stub_export
 //go:linkname _cgo_stub_export _cgo_stub_export
 var _cgo_stub_export uintptr
+
+// No pthreads on Windows, these are always zero.
+
+//go:linkname _cgo_init _cgo_init
+var _cgo_init unsafe.Pointer
+
+//go:linkname _cgo_thread_start _cgo_thread_start
+var _cgo_thread_start unsafe.Pointer
+
+//go:linkname _cgo_sys_thread_create _cgo_sys_thread_create
+var _cgo_sys_thread_create unsafe.Pointer
+
+//go:linkname _cgo_bindm _cgo_bindm
+var _cgo_bindm unsafe.Pointer
+
+//go:linkname _cgo_getstackbound _cgo_getstackbound
+var _cgo_getstackbound unsafe.Pointer

package/bin/go/src/runtime/cgo_ppc64x.go

@@ -6,7 +6,7 @@
 
 package runtime
 
-// crosscall_ppc64 calls into the runtime to set up the registers the
+// crosscall1 calls into the runtime to set up the registers the
 // Go runtime expects and so the symbol it calls needs to be exported
 // for external linking to work.
 //

package/bin/go/src/runtime/cgo_sigaction.go

@@ -6,7 +6,7 @@
 // Also used on linux/386 to clear the SA_RESTORER flag
 // when using cgo; see issue #75253.
 
-//go:build (linux && (386 || amd64 || arm64 || loong64 || ppc64le)) || (freebsd && amd64)
+//go:build (linux && (386 || amd64 || arm64 || loong64 || ppc64 || ppc64le)) || (freebsd && amd64)
 
 package runtime
 

package/bin/go/src/runtime/cgocall.go

@@ -424,8 +424,16 @@ func cgocallbackg1(fn, frame unsafe.Pointer, ctxt uintptr) {
 		// The C call to Go came from a thread not currently running
 		// any Go. In the case of -buildmode=c-archive or c-shared,
 		// this call may be coming in before package initialization
-		// is complete. Wait until it is.
-		<-main_init_done
+		// is complete. Don't proceed until it is.
+		//
+		// We check a bool first for speed, and wait on a channel
+		// if it's not ready.
+		//
+		// In race mode, skip the optimization and always use the
+		// channel, which has the race instrumentation.
+		if raceenabled || !mainInitDone.Load() {
+			<-mainInitDoneChan
+		}
 	}
 
 	// Check whether the profiler needs to be turned on or off; this route to

package/bin/go/src/runtime/chan.go

@@ -816,14 +816,7 @@ func reflect_chanrecv(c *hchan, nb bool, elem unsafe.Pointer) (selected bool, re
 }
 
 func chanlen(c *hchan) int {
-	if c == nil {
-		return 0
-	}
-	async := debug.asynctimerchan.Load() != 0
-	if c.timer != nil && async {
-		c.timer.maybeRunChan(c)
-	}
-	if c.timer != nil && !async {
+	if c == nil || c.timer != nil {
 		// timer channels have a buffered implementation
 		// but present to users as unbuffered, so that we can
 		// undo sends without users noticing.
@@ -833,14 +826,7 @@ func chanlen(c *hchan) int {
 }
 
 func chancap(c *hchan) int {
-	if c == nil {
-		return 0
-	}
-	if c.timer != nil {
-		async := debug.asynctimerchan.Load() != 0
-		if async {
-			return int(c.dataqsiz)
-		}
+	if c == nil || c.timer != nil {
 		// timer channels have a buffered implementation
 		// but present to users as unbuffered, so that we can
 		// undo sends without users noticing.

package/bin/go/src/runtime/coro.go

@@ -34,7 +34,7 @@ type coro struct {
 	lockedInt uint32 // mp's internal lockOSThread counter at coro creation time.
 }
 
-//go:linkname newcoro
+//go:linknamestd newcoro
 
 // newcoro creates a new coro containing a
 // goroutine blocked waiting to run f
@@ -84,7 +84,7 @@ func coroexit(c *coro) {
 	mcall(coroswitch_m)
 }
 
-//go:linkname coroswitch
+//go:linknamestd coroswitch
 
 // coroswitch switches to the goroutine blocked on c
 // and then blocks the current goroutine on c.

package/bin/go/src/runtime/cpuflags.go

@@ -37,9 +37,10 @@ var (
 
 	arm64HasATOMICS bool
 
-	loong64HasLAMCAS bool
-	loong64HasLAM_BH bool
-	loong64HasLSX    bool
+	loong64HasLAMCAS     bool
+	loong64HasLAM_BH     bool
+	loong64HasDBAR_HINTS bool
+	loong64HasLSX        bool
 
 	riscv64HasZbb bool
 )

package/bin/go/src/runtime/debug/garbage.go

@@ -89,7 +89,7 @@ func ReadGCStats(stats *GCStats) {
 // limit.
 // A negative percentage effectively disables garbage collection, unless
 // the memory limit is reached.
-// See SetMemoryLimit for more details.
+// See [SetMemoryLimit] for more details.
 func SetGCPercent(percent int) int {
 	return int(setGCPercent(int32(percent)))
 }
@@ -127,7 +127,7 @@ func SetMaxStack(bytes int) int {
 // The limit controls the number of operating system threads, not the number
 // of goroutines. A Go program creates a new thread only when a goroutine
 // is ready to run but all the existing threads are blocked in system calls, cgo calls,
-// or are locked to other goroutines due to use of runtime.LockOSThread.
+// or are locked to other goroutines due to use of [runtime.LockOSThread].
 //
 // SetMaxThreads is useful mainly for limiting the damage done by
 // programs that create an unbounded number of threads. The idea is
@@ -143,7 +143,7 @@ func SetMaxThreads(threads int) int {
 // manipulation of memory may cause faults at non-nil addresses in less
 // dramatic situations; SetPanicOnFault allows such programs to request
 // that the runtime trigger only a panic, not a crash.
-// The runtime.Error that the runtime panics with may have an additional method:
+// The [runtime.Error] that the runtime panics with may have an additional method:
 //
 //	Addr() uintptr
 //
@@ -184,7 +184,7 @@ func SetTraceback(level string)
 // memory limit, including adjustments to the frequency of garbage
 // collections and returning memory to the underlying system more
 // aggressively. This limit will be respected even if GOGC=off (or,
-// if SetGCPercent(-1) is executed).
+// if [SetGCPercent](-1) is executed).
 //
 // The input limit is provided as bytes, and includes all memory
 // mapped, managed, and not released by the Go runtime. Notably, it
@@ -201,7 +201,7 @@ func SetTraceback(level string)
 //
 //	runtime.MemStats.Sys - runtime.MemStats.HeapReleased
 //
-// or in terms of the runtime/metrics package:
+// or in terms of the [runtime/metrics] package:
 //
 //	/memory/classes/total:bytes - /memory/classes/heap/released:bytes
 //
@@ -220,7 +220,7 @@ func SetTraceback(level string)
 // the soft memory limit in more detail, as well as a variety of common
 // use-cases and scenarios.
 //
-// The initial setting is math.MaxInt64 unless the GOMEMLIMIT
+// The initial setting is [math.MaxInt64] unless the GOMEMLIMIT
 // environment variable is set, in which case it provides the initial
 // setting. GOMEMLIMIT is a numeric value in bytes with an optional
 // unit suffix. The supported suffixes include B, KiB, MiB, GiB, and

package/bin/go/src/runtime/debug/mod.go

@@ -151,7 +151,7 @@ func (bi *BuildInfo) String() string {
 }
 
 // ParseBuildInfo parses the string returned by [*BuildInfo.String],
-// restoring the original BuildInfo,
+// restoring the original [BuildInfo],
 // except that the GoVersion field is not set.
 // Programs should normally not call this function,
 // but instead call [ReadBuildInfo], [debug/buildinfo.ReadFile],

package/bin/go/src/runtime/debug/stack.go

@@ -13,7 +13,7 @@ import (
 	_ "unsafe" // for linkname
 )
 
-// PrintStack prints to standard error the stack trace returned by runtime.Stack.
+// PrintStack prints to standard error the stack trace returned by [runtime.Stack].
 func PrintStack() {
 	os.Stderr.Write(Stack())
 }

package/bin/go/src/runtime/debugcall.go

@@ -2,9 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Though the debug call function feature is not enabled on
-// ppc64, inserted ppc64 to avoid missing Go declaration error
-// for debugCallPanicked while building runtime.test
 //go:build amd64 || arm64 || loong64 || ppc64le || ppc64
 
 package runtime

package/bin/go/src/runtime/error.go

@@ -103,6 +103,8 @@ func (e errorAddressString) Error() string {
 	return "runtime error: " + e.msg
 }
 
+var _ error = errorAddressString{}
+
 // Addr returns the memory address where a fault occurred.
 // The address provided is best-effort.
 // The veracity of the result may depend on the platform.
@@ -123,6 +125,8 @@ func (e plainError) Error() string {
 	return string(e)
 }
 
+var _ error = plainError("")
+
 // A boundsError represents an indexing or slicing operation gone wrong.
 type boundsError struct {
 	x int64
@@ -135,6 +139,8 @@ type boundsError struct {
 	code   abi.BoundsErrorCode
 }
 
+var _ error = boundsError{}
+
 // boundsErrorFmts provide error text for various out-of-bounds panics.
 // Note: if you change these strings, you should adjust the size of the buffer
 // in boundsError.Error below as well.

package/bin/go/src/runtime/extern.go

@@ -280,16 +280,18 @@ AT_SECURE flag in the auxiliary vector, on the BSDs and Solaris/Illumos it is
 determined by checking the issetugid syscall, and on AIX it is determined by
 checking if the uid/gid match the effective uid/gid.
 
-When the runtime determines the binary is setuid/setgid-like, it does three main
+When the runtime determines the binary is setuid/setgid-like, it does two main
 things:
-  - The standard input/output file descriptors (0, 1, 2) are checked to be open.
-    If any of them are closed, they are opened pointing at /dev/null.
   - The value of the GOTRACEBACK environment variable is set to 'none'.
   - When a signal is received that terminates the program, or the program
     encounters an unrecoverable panic that would otherwise override the value
     of GOTRACEBACK, the goroutine stack, registers, and other memory related
     information are omitted.
 
+Additinally on Unix platforms the Go runtime automatically checks whether
+the standard input/output file descriptors (0, 1, 2) are open. If any of them are
+closed, they are opened pointing at /dev/null.
+
 [Race Detector article]: https://go.dev/doc/articles/race_detector
 */
 package runtime

package/bin/go/src/runtime/heapdump.go

@@ -480,7 +480,7 @@ func dumproots() {
 
 // Bit vector of free marks.
 // Needs to be as big as the largest number of objects per span.
-var freemark [pageSize / 8]bool
+var freemark [gc.MaxObjsPerSpan]bool
 
 func dumpobjs() {
 	// To protect mheap_.allspans.