@ttsc/win32-arm64 0.33.0 → 0.34.0

package/bin/go/src/runtime/map.go

@@ -91,16 +91,16 @@ func mapaccess1(t *abi.MapType, m *maps.Map, key unsafe.Pointer) unsafe.Pointer
 func mapaccess2(t *abi.MapType, m *maps.Map, key unsafe.Pointer) (unsafe.Pointer, bool)
 
 func mapaccess1_fat(t *abi.MapType, m *maps.Map, key, zero unsafe.Pointer) unsafe.Pointer {
-	e := mapaccess1(t, m, key)
-	if e == unsafe.Pointer(&zeroVal[0]) {
+	e, ok := mapaccess2(t, m, key)
+	if !ok {
 		return zero
 	}
 	return e
 }
 
 func mapaccess2_fat(t *abi.MapType, m *maps.Map, key, zero unsafe.Pointer) (unsafe.Pointer, bool) {
-	e := mapaccess1(t, m, key)
-	if e == unsafe.Pointer(&zeroVal[0]) {
+	e, ok := mapaccess2(t, m, key)
+	if !ok {
 		return zero, false
 	}
 	return e, true

package/bin/go/src/runtime/mbitmap.go

@@ -626,10 +626,11 @@ func (span *mspan) writeHeapBitsSmall(x, dataSize uintptr, typ *_type) (scanSize
 	src0 := readUintptr(getGCMask(typ))
 
 	// Create repetitions of the bitmap if we have a small slice backing store.
-	scanSize = typ.PtrBytes
 	src := src0
 	if typ.Size_ == goarch.PtrSize {
 		src = (1 << (dataSize / goarch.PtrSize)) - 1
+		// This object is all pointers, so scanSize is just dataSize.
+		scanSize = dataSize
 	} else {
 		// N.B. We rely on dataSize being an exact multiple of the type size.
 		// The alternative is to be defensive and mask out src to the length
@@ -637,6 +638,7 @@ func (span *mspan) writeHeapBitsSmall(x, dataSize uintptr, typ *_type) (scanSize
 		if doubleCheckHeapSetType && !asanenabled && dataSize%typ.Size_ != 0 {
 			throw("runtime: (*mspan).writeHeapBitsSmall: dataSize is not a multiple of typ.Size_")
 		}
+		scanSize = typ.PtrBytes
 		for i := typ.Size_; i < dataSize; i += typ.Size_ {
 			src |= src0 << (i / goarch.PtrSize)
 			scanSize += typ.Size_

package/bin/go/src/runtime/mem.go

@@ -111,12 +111,8 @@ func sysHugePageCollapse(v unsafe.Pointer, n uintptr) {
 	sysHugePageCollapseOS(v, n)
 }
 
-// sysFree transitions a memory region from any state to None. Therefore, it
-// returns memory unconditionally. It is used if an out-of-memory error has been
-// detected midway through an allocation or to carve out an aligned section of
-// the address space. It is okay if sysFree is a no-op only if sysReserve always
-// returns a memory region aligned to the heap allocator's alignment
-// restrictions.
+// sysFree transitions a memory region from Ready to None. Therefore, it
+// returns memory unconditionally.
 //
 // sysStat must be non-nil.
 //

package/bin/go/src/runtime/mem_sbrk.go

@@ -206,6 +206,10 @@ func sysAllocOS(n uintptr, _ string) unsafe.Pointer {
 }
 
 func sysFreeOS(v unsafe.Pointer, n uintptr) {
+	if v == nil {
+		// A failed sysReserveOS returns nil, so freeing it is a no-op.
+		return
+	}
 	systemstack(func() {
 		lock(&memlock)
 		if uintptr(v)+n == bloc {

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

@@ -8,13 +8,8 @@
 
 // func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
 TEXT runtime·memclrNoHeapPointers<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-16
-#ifndef GOEXPERIMENT_regabiargs
-	MOVD	ptr+0(FP), R4
-	MOVD	n+8(FP), R5
-#else
 	MOVD	R2, R4
 	MOVD	R3, R5
-#endif
 	CMPBGE	R5, $32, clearge32
 
 start:

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

@@ -8,16 +8,9 @@
 
 // func memmove(to, from unsafe.Pointer, n uintptr)
 TEXT runtime·memmove<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-24
-#ifndef GOEXPERIMENT_regabiargs
-	MOVD	to+0(FP), R6
-	MOVD	from+8(FP), R4
-	MOVD	n+16(FP), R5
-#else
 	MOVD	R4, R5
 	MOVD	R3, R4
 	MOVD	R2, R6
-#endif
-
 	CMPBEQ	R6, R4, done
 
 start:

package/bin/go/src/runtime/metrics/doc.go

@@ -262,10 +262,6 @@ Below is the full list of supported metrics, ordered lexicographically.
 		package due to a non-default GODEBUG=allowmultiplevcs=...
 		setting.
 
-	/godebug/non-default-behavior/asynctimerchan:events
-		The number of non-default behaviors executed by the time package
-		due to a non-default GODEBUG=asynctimerchan=... setting.
-
 	/godebug/non-default-behavior/containermaxprocs:events
 		The number of non-default behaviors executed by the runtime
 		package due to a non-default GODEBUG=containermaxprocs=...
@@ -306,10 +302,6 @@ Below is the full list of supported metrics, ordered lexicographically.
 		package due to a non-default GODEBUG=gotestjsonbuildtext=...
 		setting.
 
-	/godebug/non-default-behavior/gotypesalias:events
-		The number of non-default behaviors executed by the go/types
-		package due to a non-default GODEBUG=gotypesalias=... setting.
-
 	/godebug/non-default-behavior/htmlmetacontenturlescape:events
 		The number of non-default behaviors executed by
 		the html/template package due to a non-default
@@ -390,30 +382,14 @@ Below is the full list of supported metrics, ordered lexicographically.
 		package due to a non-default GODEBUG=tarinsecurepath=...
 		setting.
 
-	/godebug/non-default-behavior/tls10server:events
-		The number of non-default behaviors executed by the crypto/tls
-		package due to a non-default GODEBUG=tls10server=... setting.
-
-	/godebug/non-default-behavior/tls3des:events
-		The number of non-default behaviors executed by the crypto/tls
-		package due to a non-default GODEBUG=tls3des=... setting.
-
 	/godebug/non-default-behavior/tlsmaxrsasize:events
 		The number of non-default behaviors executed by the crypto/tls
 		package due to a non-default GODEBUG=tlsmaxrsasize=... setting.
 
-	/godebug/non-default-behavior/tlsrsakex:events
-		The number of non-default behaviors executed by the crypto/tls
-		package due to a non-default GODEBUG=tlsrsakex=... setting.
-
 	/godebug/non-default-behavior/tlssha1:events
 		The number of non-default behaviors executed by the crypto/tls
 		package due to a non-default GODEBUG=tlssha1=... setting.
 
-	/godebug/non-default-behavior/tlsunsafeekm:events
-		The number of non-default behaviors executed by the crypto/tls
-		package due to a non-default GODEBUG=tlsunsafeekm=... setting.
-
 	/godebug/non-default-behavior/updatemaxprocs:events
 		The number of non-default behaviors executed by the runtime
 		package due to a non-default GODEBUG=updatemaxprocs=... setting.
@@ -436,11 +412,6 @@ Below is the full list of supported metrics, ordered lexicographically.
 		The number of non-default behaviors executed by the os package
 		due to a non-default GODEBUG=winsymlink=... setting.
 
-	/godebug/non-default-behavior/x509keypairleaf:events
-		The number of non-default behaviors executed by the crypto/tls
-		package due to a non-default GODEBUG=x509keypairleaf=...
-		setting.
-
 	/godebug/non-default-behavior/x509negativeserial:events
 		The number of non-default behaviors executed by the crypto/x509
 		package due to a non-default GODEBUG=x509negativeserial=...
@@ -454,6 +425,11 @@ Below is the full list of supported metrics, ordered lexicographically.
 		The number of non-default behaviors executed by the crypto/x509
 		package due to a non-default GODEBUG=x509sha256skid=... setting.
 
+	/godebug/non-default-behavior/x509sslcertoverrideplatform:events
+		The number of non-default behaviors executed by
+		the crypto/x509 package due to a non-default
+		GODEBUG=x509sslcertoverrideplatform=... setting.
+
 	/godebug/non-default-behavior/x509usefallbackroots:events
 		The number of non-default behaviors executed by the crypto/x509
 		package due to a non-default GODEBUG=x509usefallbackroots=...

package/bin/go/src/runtime/metrics/sample.go

@@ -43,5 +43,8 @@ func runtime_readMetrics(unsafe.Pointer, int, int)
 // Sample values with names not appearing in [All] will have their Value populated
 // as KindBad to indicate that the name is unknown.
 func Read(m []Sample) {
+	if len(m) == 0 {
+		return
+	}
 	runtime_readMetrics(unsafe.Pointer(&m[0]), len(m), cap(m))
 }

package/bin/go/src/runtime/metrics.go

@@ -862,9 +862,10 @@ func (a *schedStatsAggregate) compute() {
 	// include system goroutines in this count because we included
 	// them above.
 	a.gTotal = uint64(gcount(true))
-	a.gWaiting = a.gTotal - (a.gRunning + a.gRunnable + a.gNonGo)
-	if a.gWaiting < 0 {
+	if a.gTotal < a.gRunning+a.gRunnable+a.gNonGo {
 		a.gWaiting = 0
+	} else {
+		a.gWaiting = a.gTotal - (a.gRunning + a.gRunnable + a.gNonGo)
 	}
 
 	unlock(&sched.lock)

package/bin/go/src/runtime/mgc.go

@@ -839,30 +839,12 @@ func gcStart(trigger gcTrigger) {
 	work.cpuStats.accumulateGCPauseTime(stw.stoppingCPUTime, 1)
 
 	if goexperiment.RuntimeSecret {
-		// The world is stopped. Every M is either parked
-		// or in a syscall, or running some non-go code which can't run in secret mode.
-		// To get to a parked or a syscall state
-		// they have to transition through a point where we erase any
-		// confidential information in the registers. Making them
-		// handle a signal now would clobber the signal stack
-		// with non-confidential information.
-		//
-		// TODO(dmo): this is linear with respect to the number of Ms.
-		// Investigate just how long this takes and whether we can somehow
-		// loop over just the Ms that have secret info on their signal stack,
-		// or cooperatively have the Ms send signals to themselves just
-		// after they erase their registers, but before they enter a syscall
-		for mp := allm; mp != nil; mp = mp.alllink {
-			// even through the world is stopped, the kernel can still
-			// invoke our signal handlers. No confidential information can be spilled
-			// (because it's been erased by this time), but we can avoid
-			// sending additional signals by atomically inspecting this variable
-			if atomic.Xchg(&mp.signalSecret, 0) != 0 {
-				noopSignal(mp)
-			}
-			// TODO: syncronize with the signal handler to ensure that the signal
-			// was actually delivered.
-		}
+		// The world is stopped, which means every M is either idle, blocked
+		// in a syscall or this M that we are running on now.
+		// The blocked Ms had any secret spill on their signal stacks erased
+		// when they entered their respective states. Now we have to handle
+		// this one.
+		eraseSecretsSignalStk()
 	}
 
 	// Finish sweep before we start concurrent scan.
@@ -1167,7 +1149,7 @@ top:
 	// endCycle depends on all gcWork cache stats being flushed.
 	// The termination algorithm above ensured that up to
 	// allocations since the ragged barrier.
-	gcController.endCycle(now, int(gomaxprocs), work.userForced)
+	gcController.endCycle(now, int(gomaxprocs))
 
 	// Perform mark termination. This will restart the world.
 	gcMarkTermination(stw)
@@ -1333,6 +1315,40 @@ func findGoroutineLeaks() bool {
 			}
 		}
 	}
+
+	// Do not report the main goroutine if it is waiting on select{}.
+	//
+	// NOTE: We still treat the main goroutine as leaked during the analysis,
+	// but revert its status to _Gwaiting after the analysis to not include
+	// it in the goroutine leak profile.
+	// This preserves the effectiveness of goroutine leak detection
+	// if the main goroutine holds references to concurrency primitives causing
+	// other leaks.
+	//
+	// Example:
+	//
+	// ```go
+	// func main() {
+	// 	ch := make(chan int)
+	// 	go func() {
+	// 		...
+	// 		<-ch // Leaks
+	// 	}()
+	//
+	// 	select {}
+	// }
+	// ```
+	//
+	// The main goroutine is blocked by select{}, but holds a reference to "ch".
+	// Not treating the main goroutine as leaked would cause the analysis to
+	// miss the legitimate leak at the child goroutine.
+	//
+	// The main goroutine should always be allgs[0], but double check
+	// in case that invariant changes in the future.
+	if gp0 := allgs[0]; gp0.goid == 1 && gp0.waitreason == waitReasonSelectNoCases {
+		casgstatus(gp0, _Gleaked, _Gwaiting)
+	}
+
 	// Put the remaining roots as ready for marking and drain them.
 	work.markrootJobs.Add(int32(work.nStackRoots - work.nMaybeRunnableStackRoots))
 	work.nMaybeRunnableStackRoots = work.nStackRoots

package/bin/go/src/runtime/mgcmark.go

@@ -967,6 +967,11 @@ func scanstack(gp *g, gcw *gcWork) int64 {
 		scanblock(uintptr(unsafe.Pointer(&gp.sched.ctxt)), goarch.PtrSize, &oneptrmask[0], gcw, &state)
 	}
 
+	// Scan conservatively the extended register state.
+	if gp.asyncSafePoint {
+		xRegScan(gp, gcw, &state)
+	}
+
 	// Scan the stack. Accumulate a list of stack objects.
 	var u unwinder
 	for u.init(gp, 0); u.valid(); u.next() {

package/bin/go/src/runtime/mgcmark_greenteagc.go

@@ -15,7 +15,7 @@
 // optimize the scan loop by size class (not yet completed) all the way to the
 // point of applying SIMD techniques to really tear through the heap.
 //
-// Naturally, this depends on being able to create opportunties to batch objects
+// Naturally, this depends on being able to create opportunities to batch objects
 // together. The basic idea here is to have two sets of mark bits. One set is the
 // regular set of mark bits ("marks"), while the other essentially says that the
 // objects have been scanned already ("scans"). When we see a pointer for the first

package/bin/go/src/runtime/mgcpacer.go

@@ -595,9 +595,7 @@ func (c *gcControllerState) revise() {
 }
 
 // endCycle computes the consMark estimate for the next cycle.
-// userForced indicates whether the current GC cycle was forced
-// by the application.
-func (c *gcControllerState) endCycle(now int64, procs int, userForced bool) {
+func (c *gcControllerState) endCycle(now int64, procs int) {
 	// Record last heap goal for the scavenger.
 	// We'll be updating the heap goal soon.
 	gcController.lastHeapGoal = c.heapGoal()

package/bin/go/src/runtime/mgcscavenge.go

@@ -1135,7 +1135,7 @@ func (s *scavengeIndex) alloc(ci chunkIdx, npages uint) {
 	// TODO(mknyszek): Consider eagerly backing memory with huge pages
 	// here and track whether we believe this chunk is backed by huge pages.
 	// In the past we've attempted to use sysHugePageCollapse (which uses
-	// MADV_COLLAPSE on Linux, and is unsupported elswhere) for this purpose,
+	// MADV_COLLAPSE on Linux, and is unsupported elsewhere) for this purpose,
 	// but that caused performance issues in production environments.
 	s.chunks[ci].store(sc)
 }

package/bin/go/src/runtime/mheap.go

@@ -519,15 +519,6 @@ func (s *mspan) base() uintptr {
 	return s.startAddr
 }
 
-func (s *mspan) layout() (size, n, total uintptr) {
-	total = s.npages << gc.PageShift
-	size = s.elemsize
-	if size > 0 {
-		n = total / size
-	}
-	return
-}
-
 // recordspan adds a newly allocated span to h.allspans.
 //
 // This only happens the first time a span is allocated from
@@ -2799,7 +2790,7 @@ func freeSpecial(s *special, p unsafe.Pointer, size uintptr) {
 		unlock(&mheap_.speciallock)
 	case _KindSpecialProfile:
 		sp := (*specialprofile)(unsafe.Pointer(s))
-		mProf_Free(sp.b, size)
+		mProf_Free(sp.b)
 		lock(&mheap_.speciallock)
 		mheap_.specialprofilealloc.free(unsafe.Pointer(sp))
 		unlock(&mheap_.speciallock)

package/bin/go/src/runtime/mklockrank.go

@@ -102,6 +102,10 @@ NONE
 < itab
 < reflectOffs;
 
+# Typelinks
+NONE
+< typelinks;
+
 # Synctest
 hchan,
   notifyList,
@@ -138,6 +142,7 @@ allg,
   reflectOffs,
   timer,
   traceStrings,
+  typelinks,
   userArenaState,
   vgetrandom
 # Above MALLOC are things that can allocate memory.
@@ -320,7 +325,7 @@ func generateGo(w io.Writer, g *dag.Graph) {
 
 package runtime
 
-type lockRank int
+type lockRank int64
 
 `)
 

package/bin/go/src/runtime/mkpreempt.go

@@ -759,6 +759,13 @@ func genLoong64(g *gen) {
 		mov+" %d(R3), R5\n"+rs,
 		regsize)
 
+	// Add floating point control/status register fcsr0,
+	// fcsr1~fcsr3 are aliases for some fields in fcsr0.
+	l.addSpecial(
+		mov+" FCSR0, R5\n"+mov+" R5, %d(R3)",
+		mov+" %d(R3), R5\n"+mov+" R5, FCSR0",
+		regsize)
+
 	// Create layouts for lasx, lsx and fp registers.
 	lasxRegs := layout{sp: xReg}
 	lsxRegs := lasxRegs

package/bin/go/src/runtime/mprof.go

@@ -120,7 +120,6 @@ type memRecord struct {
 	// of the events from that cycle must be done. Specifically:
 	//
 	// Mallocs are accounted to cycle C+2.
-	// Explicit frees are accounted to cycle C+2.
 	// GC frees (done during sweeping) are accounted to cycle C+1.
 	//
 	// After mark termination, we increment the global heap
@@ -146,16 +145,13 @@ type memRecord struct {
 
 // memRecordCycle
 type memRecordCycle struct {
-	allocs, frees           uintptr
-	alloc_bytes, free_bytes uintptr
+	allocs, frees uintptr
 }
 
 // add accumulates b into a. It does not zero b.
 func (a *memRecordCycle) add(b *memRecordCycle) {
 	a.allocs += b.allocs
 	a.frees += b.frees
-	a.alloc_bytes += b.alloc_bytes
-	a.free_bytes += b.free_bytes
 }
 
 // A blockRecord is the bucket data for a bucket of type blockProfile,
@@ -453,7 +449,6 @@ func mProf_Malloc(mp *m, p unsafe.Pointer, size uintptr) {
 
 	lock(&profMemFutureLock[index])
 	mpc.allocs++
-	mpc.alloc_bytes += size
 	unlock(&profMemFutureLock[index])
 
 	// Setprofilebucket locks a bunch of other mutexes, so we call it outside of
@@ -466,7 +461,7 @@ func mProf_Malloc(mp *m, p unsafe.Pointer, size uintptr) {
 }
 
 // Called when freeing a profiled block.
-func mProf_Free(b *bucket, size uintptr) {
+func mProf_Free(b *bucket) {
 	index := (mProfCycle.read() + 1) % uint32(len(memRecord{}.future))
 
 	mp := b.mp()
@@ -474,7 +469,6 @@ func mProf_Free(b *bucket, size uintptr) {
 
 	lock(&profMemFutureLock[index])
 	mpc.frees++
-	mpc.free_bytes += size
 	unlock(&profMemFutureLock[index])
 }
 
@@ -696,8 +690,8 @@ func (prof *mLockProfile) recordUnlock(cycles int64) {
 		if cycles == 0 {
 			return
 		}
-		prevScore := uint64(cheaprand64()) % uint64(prev)
-		thisScore := uint64(cheaprand64()) % uint64(cycles)
+		prevScore := cheaprandu64() % uint64(prev)
+		thisScore := cheaprandu64() % uint64(cycles)
 		if prevScore > thisScore {
 			prof.cyclesLost += cycles
 			return
@@ -731,8 +725,6 @@ func (prof *mLockProfile) captureStack() {
 	}
 	prof.haveStack = true
 
-	prof.stack[0] = logicalStackSentinel
-
 	var nstk int
 	gp := getg()
 	sp := sys.GetCallerSP()
@@ -740,7 +732,7 @@ func (prof *mLockProfile) captureStack() {
 	systemstack(func() {
 		var u unwinder
 		u.initAt(pc, sp, 0, gp, unwindSilentErrors|unwindJumpStack)
-		nstk = 1 + tracebackPCs(&u, skip, prof.stack[1:])
+		nstk = tracebackPCs(&u, skip, prof.stack)
 	})
 	if nstk < len(prof.stack) {
 		prof.stack[nstk] = 0
@@ -753,7 +745,7 @@ func (prof *mLockProfile) captureStack() {
 //
 //go:nowritebarrierrec
 func (prof *mLockProfile) store() {
-	if gp := getg(); gp.m.locks == 1 && gp.m.mLockProfile.haveStack {
+	if gp := getg(); gp.m.locks/mutexMLocksDelta == 1 && gp.m.mLockProfile.haveStack {
 		prof.storeSlow()
 	}
 }
@@ -782,7 +774,6 @@ func (prof *mLockProfile) storeSlow() {
 	saveBlockEventStack(cycles, rate, prof.stack[:nstk], mutexProfile)
 	if lost > 0 {
 		lostStk := [...]uintptr{
-			logicalStackSentinel,
 			abi.FuncPCABIInternal(_LostContendedRuntimeLock) + sys.PCQuantum,
 		}
 		saveBlockEventStack(lost, rate, lostStk[:], mutexProfile)
@@ -834,7 +825,6 @@ func SetMutexProfileFraction(rate int) int {
 	return int(old)
 }
 
-//go:linkname mutexevent sync.event
 func mutexevent(cycles int64, skip int) {
 	if cycles < 0 {
 		cycles = 0
@@ -964,7 +954,7 @@ func memProfileInternal(size int, inuseZero bool, copyFn func(profilerecord.MemP
 	head := (*bucket)(mbuckets.Load())
 	for b := head; b != nil; b = b.allnext {
 		mp := b.mp()
-		if inuseZero || mp.active.alloc_bytes != mp.active.free_bytes {
+		if inuseZero || mp.active.allocs != mp.active.frees {
 			n++
 		}
 		if mp.active.allocs != 0 || mp.active.frees != 0 {
@@ -985,7 +975,7 @@ func memProfileInternal(size int, inuseZero bool, copyFn func(profilerecord.MemP
 				mp.future[c] = memRecordCycle{}
 				unlock(&profMemFutureLock[c])
 			}
-			if inuseZero || mp.active.alloc_bytes != mp.active.free_bytes {
+			if inuseZero || mp.active.allocs != mp.active.frees {
 				n++
 			}
 		}
@@ -994,10 +984,9 @@ func memProfileInternal(size int, inuseZero bool, copyFn func(profilerecord.MemP
 		ok = true
 		for b := head; b != nil; b = b.allnext {
 			mp := b.mp()
-			if inuseZero || mp.active.alloc_bytes != mp.active.free_bytes {
+			if inuseZero || mp.active.allocs != mp.active.frees {
 				r := profilerecord.MemProfileRecord{
-					AllocBytes:   int64(mp.active.alloc_bytes),
-					FreeBytes:    int64(mp.active.free_bytes),
+					ObjectSize:   int64(b.size),
 					AllocObjects: int64(mp.active.allocs),
 					FreeObjects:  int64(mp.active.frees),
 					Stack:        b.stk(),
@@ -1011,8 +1000,8 @@ func memProfileInternal(size int, inuseZero bool, copyFn func(profilerecord.MemP
 }
 
 func copyMemProfileRecord(dst *MemProfileRecord, src profilerecord.MemProfileRecord) {
-	dst.AllocBytes = src.AllocBytes
-	dst.FreeBytes = src.FreeBytes
+	dst.AllocBytes = src.AllocObjects * src.ObjectSize
+	dst.FreeBytes = src.FreeObjects * src.ObjectSize
 	dst.AllocObjects = src.AllocObjects
 	dst.FreeObjects = src.FreeObjects
 	if raceenabled {

package/bin/go/src/runtime/os2_aix.go

@@ -715,17 +715,17 @@ func pthread_attr_setstacksize(attr *pthread_attr, size uint64) int32 {
 func pthread_create1(tid, attr, fn, arg uintptr) int32
 
 //go:nosplit
-func pthread_create(tid *pthread, attr *pthread_attr, fn *funcDescriptor, arg unsafe.Pointer) int32 {
+func pthread_create(tid *pthread, attr *pthread_attr, fn unsafe.Pointer, arg unsafe.Pointer) int32 {
 	gp := getg()
 
 	// Check the validity of g because without a g during
 	// newosproc0.
 	if gp != nil {
-		r, _ := syscall4(&libpthread_create, uintptr(unsafe.Pointer(tid)), uintptr(unsafe.Pointer(attr)), uintptr(unsafe.Pointer(fn)), uintptr(arg))
+		r, _ := syscall4(&libpthread_create, uintptr(unsafe.Pointer(tid)), uintptr(unsafe.Pointer(attr)), uintptr(fn), uintptr(arg))
 		return int32(r)
 	}
 
-	return pthread_create1(uintptr(unsafe.Pointer(tid)), uintptr(unsafe.Pointer(attr)), uintptr(unsafe.Pointer(fn)), uintptr(arg))
+	return pthread_create1(uintptr(unsafe.Pointer(tid)), uintptr(unsafe.Pointer(attr)), uintptr(fn), uintptr(arg))
 }
 
 // On multi-thread program, sigprocmask must not be called.

package/bin/go/src/runtime/os3_solaris.go

@@ -644,3 +644,13 @@ const sigPerThreadSyscall = 1 << 31
 func runPerThreadSyscall() {
 	throw("runPerThreadSyscall only valid on linux")
 }
+
+//go:nowritebarrierrec
+//go:nosplit
+func libpreinit() {}
+
+//go:nowritebarrierrec
+//go:nosplit
+func newosproc0(stacksize uintptr, fn unsafe.Pointer) {
+	throw("bad newosproc0")
+}

package/bin/go/src/runtime/os_aix.go

@@ -112,7 +112,7 @@ func getCPUCount() int32 {
 // This function is not safe to use after initialization as it does not pass an M as fnarg.
 //
 //go:nosplit
-func newosproc0(stacksize uintptr, fn *funcDescriptor) {
+func newosproc0(stacksize uintptr, fn unsafe.Pointer) {
 	var (
 		attr pthread_attr
 		oset sigset
@@ -162,6 +162,10 @@ func newosproc0(stacksize uintptr, fn *funcDescriptor) {
 //go:nosplit
 //go:nowritebarrierrec
 func libpreinit() {
+	// On AIX, pthread_create expects a function descriptor pointer,
+	// not a raw code address. Set rt0LibGoFn to the descriptor
+	// so that libInit passes the right value.
+	rt0LibGoFn = uintptr(unsafe.Pointer(&rt0LibGoDesc))
 	initsig(true)
 }
 
@@ -203,6 +207,9 @@ func mdestroy(mp *m) {
 // tstart is a function descriptor to _tstart defined in assembly.
 var tstart funcDescriptor
 
+// rt0LibGoDesc is a function descriptor to rt0_lib_go defined in assembly.
+var rt0LibGoDesc funcDescriptor
+
 func newosproc(mp *m) {
 	var (
 		attr pthread_attr
@@ -226,7 +233,7 @@ func newosproc(mp *m) {
 	// with signals disabled. It will enable them in minit.
 	sigprocmask(_SIG_SETMASK, &sigset_all, &oset)
 	ret := retryOnEAGAIN(func() int32 {
-		return pthread_create(&tid, &attr, &tstart, unsafe.Pointer(mp))
+		return pthread_create(&tid, &attr, unsafe.Pointer(&tstart), unsafe.Pointer(mp))
 	})
 	sigprocmask(_SIG_SETMASK, &oset, nil)
 	if ret != 0 {

package/bin/go/src/runtime/os_darwin.go

@@ -15,11 +15,6 @@ type mOS struct {
 	mutex       pthreadmutex
 	cond        pthreadcond
 	count       int
-
-	// address of errno variable for this thread.
-	// This is an optimization to avoid calling libc_error
-	// on every syscall_rawsyscalln.
-	errnoAddr *int32
 }
 
 func unimplemented(name string) {
@@ -153,6 +148,7 @@ func osinit() {
 	physPageSize = getPageSize()
 
 	osinit_hack()
+	initWorkingDir()
 }
 
 func sysctlbynameInt32(name []byte) (int32, int32) {
@@ -273,7 +269,7 @@ func mstart_stub()
 // This function is not safe to use after initialization as it does not pass an M as fnarg.
 //
 //go:nosplit
-func newosproc0(stacksize uintptr, fn uintptr) {
+func newosproc0(stacksize uintptr, fn unsafe.Pointer) {
 	// Initialize an attribute object.
 	var attr pthreadattr
 	var err int32
@@ -305,7 +301,7 @@ func newosproc0(stacksize uintptr, fn uintptr) {
 	// setup and then calls mstart.
 	var oset sigset
 	sigprocmask(_SIG_SETMASK, &sigset_all, &oset)
-	err = pthread_create(&attr, fn, nil)
+	err = pthread_create(&attr, uintptr(fn), nil)
 	sigprocmask(_SIG_SETMASK, &oset, nil)
 	if err != 0 {
 		writeErrStr(failthreadcreate)
@@ -346,7 +342,6 @@ func minit() {
 	}
 	minitSignalMask()
 	getg().m.procid = uint64(pthread_self())
-	libc_error_addr(&getg().m.errnoAddr)
 }
 
 // Called from dropm to undo the effect of an minit.