@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/{runtime/hash64.go → internal/runtime/maps/runtime_hash64.go}

@@ -7,10 +7,10 @@
 
 //go:build amd64 || arm64 || loong64 || mips64 || mips64le || ppc64 || ppc64le || riscv64 || s390x
 
-package runtime
+package maps
 
 import (
-	"internal/runtime/math"
+	"math/bits"
 	"unsafe"
 )
 
@@ -18,7 +18,7 @@ const (
 	m5 = 0x1d8e4e27c47d124f
 )
 
-func memhashFallback(p unsafe.Pointer, seed, s uintptr) uintptr {
+func memHashFallback(p unsafe.Pointer, seed, s uintptr) uintptr {
 	var a, b uintptr
 	seed ^= hashkey[0]
 	switch {
@@ -64,18 +64,18 @@ func memhashFallback(p unsafe.Pointer, seed, s uintptr) uintptr {
 	return mix(m5^s, mix(a^hashkey[1], b^seed))
 }
 
-func memhash32Fallback(p unsafe.Pointer, seed uintptr) uintptr {
-	a := r4(p)
+func memHash32Fallback(k uint32, seed uintptr) uintptr {
+	a := uintptr(k)
 	return mix(m5^4, mix(a^hashkey[1], a^seed^hashkey[0]))
 }
 
-func memhash64Fallback(p unsafe.Pointer, seed uintptr) uintptr {
-	a := r8(p)
+func memHash64Fallback(k uint64, seed uintptr) uintptr {
+	a := uintptr(k)
 	return mix(m5^8, mix(a^hashkey[1], a^seed^hashkey[0]))
 }
 
 func mix(a, b uintptr) uintptr {
-	hi, lo := math.Mul64(uint64(a), uint64(b))
+	hi, lo := bits.Mul64(uint64(a), uint64(b))
 	return uintptr(hi ^ lo)
 }
 

package/bin/go/src/internal/runtime/maps/table.go

@@ -6,6 +6,7 @@ package maps
 
 import (
 	"internal/abi"
+	"internal/goexperiment"
 	"internal/runtime/math"
 	"unsafe"
 )
@@ -418,6 +419,61 @@ func (t *table) uncheckedPutSlot(typ *abi.MapType, hash uintptr, key, elem unsaf
 	}
 }
 
+// uncheckedPutSlotForAssign inserts a new key into the table for map
+// assignment and returns the element slot.
+//
+// Decrements growthLeft and increments used.
+//
+// Requires that the entry does not exist in the table, and that the table has
+// room for another element without rehashing.
+//
+// Before calling this method, you must ensure that the necessary check has
+// been performed in advance.
+//
+// For indirect keys, memory is allocated and the key is copied into it.
+// For indirect elements, memory is pre-allocated and the slot is returned
+// to the caller, who must write the element value into it.
+func (t *table) uncheckedPutSlotForAssign(typ *abi.MapType, hash uintptr, key unsafe.Pointer) unsafe.Pointer {
+	if t.growthLeft == 0 {
+		panic("invariant failed: growthLeft is unexpectedly 0")
+	}
+
+	// Given key and its hash hash(key), to insert it, we construct a
+	// probeSeq, and use it to find the first group with an unoccupied (empty
+	// or deleted) slot. We place the key into the first such slot in the
+	// group and mark it as full with key's H2. For indirect elements, we
+	// pre-allocate the element slot and return it to the caller.
+	seq := makeProbeSeq(h1(hash), t.groups.lengthMask)
+	for ; ; seq = seq.next() {
+		g := t.groups.group(typ, seq.offset)
+
+		match := g.ctrls().matchEmptyOrDeleted()
+		if match != 0 {
+			i := match.first()
+
+			slotKey := g.key(typ, i)
+			if typ.IndirectKey() {
+				kmem := newobject(typ.Key)
+				*(*unsafe.Pointer)(slotKey) = kmem
+				slotKey = kmem
+			}
+			typedmemmove(typ.Key, slotKey, key)
+
+			slotElem := g.elem(typ, i)
+			if typ.IndirectElem() {
+				emem := newobject(typ.Elem)
+				*(*unsafe.Pointer)(slotElem) = emem
+				slotElem = emem
+			}
+
+			t.growthLeft--
+			t.used++
+			g.ctrls().set(i, ctrl(h2(hash)))
+			return slotElem
+		}
+	}
+}
+
 // Delete returns true if it put a tombstone in t.
 func (t *table) Delete(typ *abi.MapType, m *Map, hash uintptr, key unsafe.Pointer) bool {
 	seq := makeProbeSeq(h1(hash), t.groups.lengthMask)
@@ -615,9 +671,16 @@ func (t *table) Clear(typ *abi.MapType) {
 	//  4) But if a group is really large, do the test anyway, as
 	//     clearing is expensive.
 	fullTest := uint64(t.used)*4 <= t.groups.lengthMask // less than ~0.25 entries per group -> >3/4 empty groups
-	if typ.SlotSize > 32 {
-		// For large slots, it is always worth doing the test first.
-		fullTest = true
+	if goexperiment.MapSplitGroup {
+		if (typ.KeyStride + typ.ElemStride) > 32 {
+			// For large slots, it is always worth doing the test first.
+			fullTest = true
+		}
+	} else {
+		if typ.KeyStride > 32 { // KeyStride == SlotSize in interleaved layout
+			// For large slots, it is always worth doing the test first.
+			fullTest = true
+		}
 	}
 	if fullTest {
 		for i := uint64(0); i <= t.groups.lengthMask; i++ {

package/bin/go/src/internal/runtime/math/math.go

@@ -25,27 +25,6 @@ func MulUintptr(a, b uintptr) (uintptr, bool) {
 	return a * b, overflow
 }
 
-// Mul64 returns the 128-bit product of x and y: (hi, lo) = x * y
-// with the product bits' upper half returned in hi and the lower
-// half returned in lo.
-// This is a copy from math/bits.Mul64
-// On supported platforms this is an intrinsic lowered by the compiler.
-func Mul64(x, y uint64) (hi, lo uint64) {
-	const mask32 = 1<<32 - 1
-	x0 := x & mask32
-	x1 := x >> 32
-	y0 := y & mask32
-	y1 := y >> 32
-	w0 := x0 * y0
-	t := x1*y0 + w0>>32
-	w1 := t & mask32
-	w2 := t >> 32
-	w1 += x0 * y1
-	hi = x1*y1 + w2 + w1>>32
-	lo = x * y
-	return
-}
-
 // Add64 returns the sum with carry of x, y and carry: sum = x + y + carry.
 // The carry input must be 0 or 1; otherwise the behavior is undefined.
 // The carryOut output is guaranteed to be 0 or 1.

package/bin/go/src/internal/runtime/startlinetest/func_amd64.s

@@ -24,5 +24,6 @@ TEXT	·AsmFunc<ABIInternal>(SB),NOSPLIT,$8-0
 	NO_LOCAL_POINTERS
 	MOVQ	$0, AX // wantInlined
 	MOVQ	·CallerStartLine(SB), DX
-	CALL	(DX)
+	MOVQ	(DX), DX // Move to a register first for -spectre
+	CALL	DX
 	RET

package/bin/go/src/internal/runtime/sys/dit_arm64.go

@@ -8,10 +8,13 @@ package sys
 
 import (
 	"internal/cpu"
+	"unsafe"
 )
 
 var DITSupported = cpu.ARM64.HasDIT
 
+const offsetARM64HasSB = unsafe.Offsetof(cpu.ARM64.HasSB)
+
 func EnableDIT() bool
 func DITEnabled() bool
 func DisableDIT()

package/bin/go/src/internal/runtime/sys/dit_arm64.s

@@ -2,16 +2,29 @@
 // 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 "textflag.h"
 
 TEXT ·EnableDIT(SB),$0-1
     MRS DIT, R0
     UBFX $24, R0, $1, R1
     MOVB R1, ret+0(FP)
+    TBNZ $0, R1, ret
     MSR $1, DIT
-    // TODO(roland): the SB instruction is significantly more
-    // performant when available. We should detect its availability
-    // and use it when we can.
+#ifdef GOOS_darwin
+    // Arm documents that barriers are not necessary when writing to, or reading
+    // from, PSTATE fields. However, Apple documentation indicates that barriers
+    // should be used, in particular when setting the PSTATE.DIT field. Barriers
+    // aren't cheap, so only use them on Apple silicon for now.
+    //
+    // See go.dev/issue/77776.
+    MOVBU internal∕cpu·ARM64+const_offsetARM64HasSB(SB), R2
+    TBZ $0, R2, sbFallback
+    SB
+#endif
+ret:
+    RET
+sbFallback:
     DSB $7  // nsh
     ISB $15 // sy
     RET

package/bin/go/src/internal/runtime/syscall/linux/asm_linux_s390x.s

@@ -6,7 +6,6 @@
 
 // func Syscall6(num, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, errno uintptr)
 TEXT ·Syscall6<ABIInternal>(SB),NOSPLIT,$0-80
-#ifdef GOEXPERIMENT_regabiargs
 	MOVD	R2, R1
 	MOVD	R3, R2
 	MOVD	R4, R3
@@ -14,35 +13,13 @@ TEXT ·Syscall6<ABIInternal>(SB),NOSPLIT,$0-80
 	MOVD	R6, R5
 	MOVD	R7, R6
 	MOVD	R8, R7
-#else
-	MOVD	num+0(FP), R1	// syscall entry
-	MOVD	a1+8(FP), R2
-	MOVD	a2+16(FP), R3
-	MOVD	a3+24(FP), R4
-	MOVD	a4+32(FP), R5
-	MOVD	a5+40(FP), R6
-	MOVD	a6+48(FP), R7
-#endif
 	SYSCALL
 	MOVD	$0xfffffffffffff001, R8
 	CMPUBLT	R2, R8, ok
-#ifdef GOEXPERIMENT_regabiargs
 	MOVD	$0, R3
 	NEG	R2, R4
 	MOVD    $-1, R2
-#else
-	MOVD	$-1, r1+56(FP)
-	MOVD	$0, r2+64(FP)
-	NEG	R2, R2
-	MOVD	R2, errno+72(FP)
-#endif
 	RET
 ok:
-#ifdef GOEXPERIMENT_regabiargs
 	MOVD	$0, R4
-#else
-	MOVD	R2, r1+56(FP)
-	MOVD	R3, r2+64(FP)
-	MOVD	$0, errno+72(FP)
-#endif
 	RET

package/bin/go/src/internal/runtime/syscall/windows/asm_windows_386.s

@@ -5,10 +5,14 @@
 #include "go_asm.h"
 #include "textflag.h"
 
-TEXT ·StdCall<ABIInternal>(SB),NOSPLIT,$0
-	JMP	·asmstdcall(SB)
+TEXT ·StdCall<ABIInternal>(SB),NOSPLIT,$4-8
+	MOVL	fn+0(FP), AX
+	MOVL	AX, 0(SP)
+	CALL	·asmstdcall(SB)
+	MOVL	AX, ret+4(FP)
+	RET
 
-TEXT ·asmstdcall(SB),NOSPLIT,$0
+TEXT ·asmstdcall(SB),NOSPLIT,$0-4
 	MOVL	fn+0(FP), BX
 	MOVL	SP, BP	// save stack pointer
 
@@ -43,6 +47,5 @@ docall:
 
 	// GetLastError().
 	MOVL	0x34(FS), AX
-	MOVL	AX, StdCallInfo_Err(BX)
 
 	RET

package/bin/go/src/internal/runtime/syscall/windows/asm_windows_amd64.s

@@ -23,19 +23,22 @@ TEXT ·asmstdcall(SB),NOSPLIT,$16
 	MOVQ	0x30(GS), DI
 	MOVL	$0, 0x68(DI)
 
-	SUBQ	$(const_MaxArgs*8), SP	// room for args
+	MOVQ	SP, R12	// save frame pointer in the callee-saved R12 register to restore it before return
+	SUBQ	$32, SP	// reserve shadow space (Windows x64 ABI)
 
-	// Fast version, do not store args on the stack.
+	// Fast version (n <= 4): no stack copy needed.
 	CMPL	CX, $0;	JE	_0args
 	CMPL	CX, $1;	JE	_1args
 	CMPL	CX, $2;	JE	_2args
 	CMPL	CX, $3;	JE	_3args
 	CMPL	CX, $4;	JE	_4args
 
-	// Check we have enough room for args.
-	CMPL	CX, $const_MaxArgs
-	JLE	2(PC)
-	INT	$3			// not enough room -> crash
+	// Slow version (n > 4): grow stack for remaining args.
+	// Stack stays 16-byte aligned by rounding extra slots to even.
+	LEAQ	-3(CX), R8
+	ANDQ	$~1, R8
+	SHLQ	$3, R8
+	SUBQ	R8, SP
 
 	// Copy args to the stack.
 	MOVQ	SP, DI
@@ -65,7 +68,7 @@ _0args:
 	// Call stdcall function.
 	CALL	AX
 
-	ADDQ	$(const_MaxArgs*8), SP
+	MOVQ	R12, SP	// restore frame pointer
 
 	// Return result.
 	MOVQ	0(SP), CX
@@ -79,6 +82,5 @@ _0args:
 	// GetLastError().
 	MOVQ	0x30(GS), DI
 	MOVL	0x68(DI), AX
-	MOVQ	AX, StdCallInfo_Err(CX)
 
 	RET

package/bin/go/src/internal/runtime/syscall/windows/asm_windows_arm64.s

@@ -83,7 +83,6 @@ _0args:
 
 	// GetLastError
 	MOVD	TEB_error(R18_PLATFORM), R0
-	MOVD	R0, StdCallInfo_Err(R19)
 
 	// Restore callee-saved registers.
 	LDP	16(RSP), (R19, R20)

package/bin/go/src/internal/runtime/syscall/windows/defs_windows.go

@@ -59,6 +59,10 @@ const (
 	EXCEPTION_INT_OVERFLOW         = 0xc0000095
 )
 
+const (
+	ERROR_ACCESS_DENIED = 5
+)
+
 const (
 	SEM_FAILCRITICALERRORS = 0x0001
 	SEM_NOGPFAULTERRORBOX  = 0x0002

package/bin/go/src/internal/runtime/syscall/windows/syscall_windows.go

@@ -10,13 +10,6 @@ import (
 	"internal/abi"
 )
 
-// MaxArgs should be divisible by 2, as Windows stack
-// must be kept 16-byte aligned on syscall entry.
-//
-// Although it only permits maximum 42 parameters, it
-// is arguably large enough.
-const MaxArgs = 42
-
 // StdCallInfo is a structure used to pass parameters to the system call.
 type StdCallInfo struct {
 	Fn   uintptr
@@ -24,15 +17,20 @@ type StdCallInfo struct {
 	Args uintptr // parameters
 	R1   uintptr // return values
 	R2   uintptr
-	Err  uintptr // error number
 }
 
 // StdCall calls a function using Windows' stdcall convention.
+// The calling thread's last-error code value is cleared before calling the function,
+// and stored in the return value.
 //
 //go:noescape
-func StdCall(fn *StdCallInfo)
+func StdCall(fn *StdCallInfo) uint32
 
 // asmstdcall is the function pointer for [AsmStdCallAddr].
+// The calling thread's last-error code value is cleared before calling the function,
+// and returned in the C ABI return register (not via Go stack convention).
+// This function is not called directly from Go; it is either jumped to from
+// [StdCall] or called from C via [AsmStdCallAddr].
 func asmstdcall(fn *StdCallInfo)
 
 // AsmStdCallAddr is the address of a function that accepts a pointer

package/bin/go/src/internal/strconv/atof.go

@@ -4,6 +4,17 @@
 
 package strconv
 
+type floatInfo struct {
+	mantbits uint
+	expbits  uint
+	bias     int
+}
+
+var (
+	float32info = floatInfo{float32MantBits, float32ExpBits, float32Bias}
+	float64info = floatInfo{float64MantBits, float64ExpBits, float64Bias}
+)
+
 // decimal to binary floating point conversion.
 // Algorithm:
 //   1) Store input in multiprecision decimal.
@@ -565,45 +576,54 @@ func atof32(s string) (f float32, n int, err error) {
 		return float32(val), n, nil
 	}
 
-	mantissa, exp, neg, trunc, hex, n, ok := readFloat(s)
+	d, p, neg, trunc, hex, n, ok := readFloat(s)
 	if !ok {
 		return 0, n, ErrSyntax
 	}
 
 	if hex {
-		f, err := atofHex(s[:n], &float32info, mantissa, exp, neg, trunc)
+		f, err := atofHex(s[:n], &float32info, d, p, neg, trunc)
 		return float32(f), n, err
 	}
 
 	if optimize {
-		// Try pure floating-point arithmetic conversion, and if that fails,
-		// the Eisel-Lemire algorithm.
+		sign := bool2[uint32](neg) << 31
+		if d == 0 {
+			return float32frombits(sign | 0), n, nil
+		}
+		if p > 40 { // overflow to ±Inf
+			return float32frombits(sign | 0xff<<23), n, ErrRange
+		}
+		if p < -70 { // underflow to ±0
+			return float32frombits(sign | 0), n, nil
+		}
 		if !trunc {
-			if f, ok := atof32exact(mantissa, exp, neg); ok {
+			// Exact rounding with single multiplication or division.
+			if f, ok := atof32exact(d, p, neg); ok {
 				return f, n, nil
 			}
 		}
-		f, ok := eiselLemire32(mantissa, exp, neg)
-		if ok {
-			if !trunc {
-				return f, n, nil
-			}
-			// Even if the mantissa was truncated, we may
-			// have found the correct result. Confirm by
-			// converting the upper mantissa bound.
-			fUp, ok := eiselLemire32(mantissa+1, exp, neg)
-			if ok && f == fUp {
-				return f, n, nil
-			}
+		// Use fast unrounded scaling.
+		// The only possible err is ErrRange, when the result overflows to ±Inf.
+		f, err := parseFloat32(d, p, sign)
+		if !trunc {
+			return f, n, err
+		}
+		// If additional digits were truncated from d
+		// but d+1 converts to the same value,
+		// then the additional digits don't matter.
+		f1, _ := parseFloat32(d+1, p, sign)
+		if f == f1 {
+			return f, n, err
 		}
 	}
 
 	// Slow fallback.
-	var d decimal
-	if !d.set(s[:n]) {
+	var dec decimal
+	if !dec.set(s[:n]) {
 		return 0, n, ErrSyntax
 	}
-	b, ovf := d.floatBits(&float32info)
+	b, ovf := dec.floatBits(&float32info)
 	f = float32frombits(uint32(b))
 	if ovf {
 		err = ErrRange
@@ -616,45 +636,52 @@ func atof64(s string) (f float64, n int, err error) {
 		return val, n, nil
 	}
 
-	mantissa, exp, neg, trunc, hex, n, ok := readFloat(s)
+	d, p, neg, trunc, hex, n, ok := readFloat(s)
 	if !ok {
 		return 0, n, ErrSyntax
 	}
-
 	if hex {
-		f, err := atofHex(s[:n], &float64info, mantissa, exp, neg, trunc)
+		f, err := atofHex(s[:n], &float64info, d, p, neg, trunc)
 		return f, n, err
 	}
-
 	if optimize {
-		// Try pure floating-point arithmetic conversion, and if that fails,
-		// the Eisel-Lemire algorithm.
+		sign := bool2[uint64](neg) << 63
+		if d == 0 {
+			return float64frombits(sign | 0), n, nil
+		}
+		if p > 310 { // overflow to ±Inf
+			return float64frombits(sign | 0x7ff<<52), n, ErrRange
+		}
+		if p < -345 { // underflow to ±0
+			return float64frombits(sign | 0), n, nil
+		}
 		if !trunc {
-			if f, ok := atof64exact(mantissa, exp, neg); ok {
+			// Exact rounding with single multiplication or division.
+			if f, ok := atof64exact(d, p, neg); ok {
 				return f, n, nil
 			}
 		}
-		f, ok := eiselLemire64(mantissa, exp, neg)
-		if ok {
-			if !trunc {
-				return f, n, nil
-			}
-			// Even if the mantissa was truncated, we may
-			// have found the correct result. Confirm by
-			// converting the upper mantissa bound.
-			fUp, ok := eiselLemire64(mantissa+1, exp, neg)
-			if ok && f == fUp {
-				return f, n, nil
-			}
+		// Use fast unrounded scaling.
+		// The only possible err is ErrRange, when the result overflows to ±Inf.
+		f, err := parseFloat64(d, p, sign)
+		if !trunc {
+			return f, n, err
+		}
+		// If additional digits were truncated from d
+		// but d+1 converts to the same value,
+		// then the additional digits don't matter.
+		f1, _ := parseFloat64(d+1, p, sign)
+		if f == f1 {
+			return f, n, err
 		}
 	}
 
 	// Slow fallback.
-	var d decimal
-	if !d.set(s[:n]) {
+	var dec decimal
+	if !dec.set(s[:n]) {
 		return 0, n, ErrSyntax
 	}
-	b, ovf := d.floatBits(&float64info)
+	b, ovf := dec.floatBits(&float64info)
 	f = float64frombits(b)
 	if ovf {
 		err = ErrRange

package/bin/go/src/internal/strconv/atoi.go

@@ -90,6 +90,7 @@ func ParseUint(s string, base int, bitSize int) (uint64, error) {
 
 	// Cutoff is the smallest number such that cutoff*base > maxUint64.
 	// Use compile-time constants for common cases.
+	const maxUint64 = 1<<64 - 1
 	var cutoff uint64
 	switch base {
 	case 10: