@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/math/big/nat.go

@@ -265,33 +265,27 @@ func (z nat) mulRange(stk *stack, a, b uint64) nat {
 	return z.mul(stk, nat(nil).mulRange(stk, a, m), nat(nil).mulRange(stk, m+1, b))
 }
 
-// A stack provides temporary storage for complex calculations
+// A stackInner provides temporary storage for complex calculations
 // such as multiplication and division.
-// The stack is a simple slice of words, extended as needed
-// to hold all the temporary storage for a calculation.
-// In general, if a function takes a *stack, it expects a non-nil *stack.
-// However, certain functions may allow passing a nil *stack instead,
-// so that they can handle trivial stack-free cases without forcing the
-// caller to obtain and free a stack that will be unused. These functions
-// document that they accept a nil *stack in their doc comments.
-type stack struct {
+// It should only be used by [stack], below.
+type stackInner struct {
 	w []Word
 }
 
-var stackPool sync.Pool
+var stackPool sync.Pool // pool of *stackInner
 
 // getStack returns a temporary stack.
 // The caller must call [stack.free] to give up use of the stack when finished.
-func getStack() *stack {
-	s, _ := stackPool.Get().(*stack)
+func getStackInner() *stackInner {
+	s, _ := stackPool.Get().(*stackInner)
 	if s == nil {
-		s = new(stack)
+		s = new(stackInner)
 	}
 	return s
 }
 
 // free returns the stack for use by another calculation.
-func (s *stack) free() {
+func (s *stackInner) free() {
 	s.w = s.w[:0]
 	stackPool.Put(s)
 }
@@ -299,7 +293,7 @@ func (s *stack) free() {
 // save returns the current stack pointer.
 // A future call to restore with the same value
 // frees any temporaries allocated on the stack after the call to save.
-func (s *stack) save() int {
+func (s *stackInner) save() int {
 	return len(s.w)
 }
 
@@ -310,12 +304,12 @@ func (s *stack) save() int {
 //
 // which makes sure to pop any temporaries allocated in the current function
 // from the stack before returning.
-func (s *stack) restore(n int) {
+func (s *stackInner) restore(n int) {
 	s.w = s.w[:n]
 }
 
 // nat returns a nat of n words, allocated on the stack.
-func (s *stack) nat(n int) nat {
+func (s *stackInner) nat(n int) nat {
 	nr := (n + 3) &^ 3 // round up to multiple of 4
 	off := len(s.w)
 	s.w = slices.Grow(s.w, nr)
@@ -327,6 +321,63 @@ func (s *stack) nat(n int) nat {
 	return x
 }
 
+// A stack provides temporary storage for complex calculations
+// such as multiplication and division.
+// In general, if a function takes a *stack, it expects a non-nil *stack.
+// However, certain functions may allow passing a nil *stack instead,
+// so that they can handle trivial stack-free cases without forcing the
+// caller to obtain and free a stack that will be unused. These functions
+// document that they accept a nil *stack in their doc comments.
+type stack struct {
+	si *stackInner
+}
+
+func getStack() *stack {
+	return &stack{}
+}
+func (s *stack) free() {
+	si := s.si
+	if si != nil {
+		si.free()
+	}
+}
+func (s *stack) save() int {
+	si := s.si
+	if si == nil {
+		return 0
+	}
+	return si.save()
+}
+func (s *stack) restore(n int) {
+	si := s.si
+	if si == nil {
+		return
+	}
+	si.restore(n)
+}
+func (s *stack) nat(n int) nat {
+	si := s.si
+	if si == nil {
+		if n <= 4 {
+			// For small allocations, just ask the allocator.
+			// It isn't worth pooling these allocations.
+			// See issue 73999.
+			r := slices.Grow(nat(nil), n)
+			r = r[:n]
+			if n > 0 {
+				r[0] = 0xabcdef
+			}
+			return r
+		}
+		si, _ = stackPool.Get().(*stackInner)
+		if si == nil {
+			si = new(stackInner)
+		}
+		s.si = si
+	}
+	return si.nat(n)
+}
+
 // bitLen returns the length of x in bits.
 // Unlike most methods, it works even if x is not normalized.
 func (x nat) bitLen() int {

package/bin/go/src/math/big/natdiv.go

@@ -676,16 +676,19 @@ func (q nat) divBasic(stk *stack, u, v nat) {
 			ujn2 := u[j+n-2]
 			for greaterThan(x1, x2, rhat, ujn2) { // x1x2 > r̂ u[j+n-2]
 				qhat--
-				prevRhat := rhat
 				rhat += vn1
 				// If r̂  overflows, then
 				// r̂ u[j+n-2]v[n-1] is now definitely > x1 x2.
-				if rhat < prevRhat {
+				if rhat < vn1 {
 					break
 				}
-				// TODO(rsc): No need for a full mulWW.
-				// x2 += vn2; if x2 overflows, x1++
-				x1, x2 = mulWW(qhat, vn2)
+
+				// Maintain (x1, x2) = qhat * vn2.
+				// Since we did qhat-- we need to do (x1, x2) -= vn2.
+				if vn2 > x2 {
+					x1--
+				}
+				x2 -= vn2
 			}
 		}
 

package/bin/go/src/math/big/roundingmode_string.go

@@ -21,8 +21,9 @@ const _RoundingMode_name = "ToNearestEvenToNearestAwayToZeroAwayFromZeroToNegati
 var _RoundingMode_index = [...]uint8{0, 13, 26, 32, 44, 57, 70}
 
 func (i RoundingMode) String() string {
-	if i >= RoundingMode(len(_RoundingMode_index)-1) {
+	idx := int(i) - 0
+	if i < 0 || idx >= len(_RoundingMode_index)-1 {
 		return "RoundingMode(" + strconv.FormatInt(int64(i), 10) + ")"
 	}
-	return _RoundingMode_name[_RoundingMode_index[i]:_RoundingMode_index[i+1]]
+	return _RoundingMode_name[_RoundingMode_index[idx]:_RoundingMode_index[idx+1]]
 }

package/bin/go/src/math/copysign.go

@@ -7,6 +7,5 @@ package math
 // Copysign returns a value with the magnitude of f
 // and the sign of sign.
 func Copysign(f, sign float64) float64 {
-	const signBit = 1 << 63
-	return Float64frombits(Float64bits(f)&^signBit | Float64bits(sign)&signBit)
+	return Float64frombits(Float64bits(f)&^signMask | Float64bits(sign)&signMask)
 }

package/bin/go/src/math/exp2_asm.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 arm64 || loong64
+//go:build arm64 || loong64 || riscv64
 
 package math
 

package/bin/go/src/math/exp2_noasm.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 !arm64 && !loong64
+//go:build !arm64 && !loong64 && !riscv64
 
 package math
 

package/bin/go/src/math/exp_asm.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 amd64 || arm64 || loong64 || s390x
+//go:build amd64 || arm64 || loong64 || riscv64 || s390x
 
 package math
 

package/bin/go/src/math/exp_loong64.s

@@ -62,13 +62,9 @@ TEXT ·archExp(SB),$0-16
 	MOVD	8(R10), F3
 	MOVD	48(R10), F2
 	CMPGTD	F0, F5, FCC0
-	BFPT	add		// x > 0
-sub:
-	FMSUBD	F3, F2, F0, F3	// Log2e*x - 0.5
-	JMP	2(PC)
-add:
+	FMSUBD	F3, F2, F0, F4	// Log2e*x - 0.5
 	FMADDD	F3, F2, F0, F3	// Log2e*x + 0.5
-
+	FSEL	FCC0, F3, F4, F3
 	FTINTRZVD F3, F4	// float64 -> int64
 	MOVV	F4, R5		// R5 = int(k)
 	FFINTDV	F4, F3		// int64 -> float64
@@ -162,13 +158,9 @@ TEXT ·archExp2(SB),$0-16
 	MOVD	0(R10), F10
 	MOVD	8(R10), F2
 	CMPGTD	F0, F10, FCC0
-	BFPT	add
-sub:
-	SUBD	F2, F0, F3	// x - 0.5
-	JMP	2(PC)
-add:
+	SUBD	F2, F0, F4	// x - 0.5
 	ADDD	F2, F0, F3	// x + 0.5
-
+	FSEL	FCC0, F3, F4, F3
 	FTINTRZVD F3, F4
 	MOVV	F4, R5
 	FFINTDV	F4, F3

package/bin/go/src/math/exp_noasm.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 !amd64 && !arm64 && !loong64 && !s390x
+//go:build !amd64 && !arm64 && !loong64 && !riscv64 && !s390x
 
 package math
 

package/bin/go/src/math/exp_riscv64.s

@@ -0,0 +1,236 @@
+// 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 "textflag.h"
+
+#define NearZero	0x3e30000000000000	// 2**-28
+#define PosInf		0x7ff0000000000000
+#define FracMask	0x000fffffffffffff
+#define C1		0x3cb0000000000000	// 2**-52
+
+DATA exprodata<>+0(SB)/8, $0.0
+DATA exprodata<>+8(SB)/8, $0.5
+DATA exprodata<>+16(SB)/8, $1.0
+DATA exprodata<>+24(SB)/8, $2.0
+DATA exprodata<>+32(SB)/8, $6.93147180369123816490e-01	// Ln2Hi
+DATA exprodata<>+40(SB)/8, $1.90821492927058770002e-10	// Ln2Lo
+DATA exprodata<>+48(SB)/8, $1.44269504088896338700e+00	// Log2e
+DATA exprodata<>+56(SB)/8, $7.09782712893383973096e+02	// Overflow
+DATA exprodata<>+64(SB)/8, $-7.45133219101941108420e+02	// Underflow
+DATA exprodata<>+72(SB)/8, $1.0239999999999999e+03	// Overflow2
+DATA exprodata<>+80(SB)/8, $-1.0740e+03			// Underflow2
+DATA exprodata<>+88(SB)/8, $3.7252902984619141e-09	// NearZero
+GLOBL exprodata<>+0(SB), NOPTR|RODATA, $96
+
+DATA expmultirodata<>+0(SB)/8, $1.66666666666666657415e-01	// P1
+DATA expmultirodata<>+8(SB)/8, $-2.77777777770155933842e-03	// P2
+DATA expmultirodata<>+16(SB)/8, $6.61375632143793436117e-05	// P3
+DATA expmultirodata<>+24(SB)/8, $-1.65339022054652515390e-06	// P4
+DATA expmultirodata<>+32(SB)/8, $4.13813679705723846039e-08	// P5
+GLOBL expmultirodata<>+0(SB), NOPTR|RODATA, $40
+
+// Exp returns e**x, the base-e exponential of x.
+// This is an assembly implementation of the method used for function Exp in file exp.go.
+//
+// func Exp(x float64) float64
+TEXT ·archExp(SB),$0-16
+	MOVD	x+0(FP), F0	// F0 = x
+
+	MOV	$exprodata<>+0(SB), X5
+	MOVD	56(X5), F1	// Overflow
+	MOVD	64(X5), F2	// Underflow
+	MOVD	88(X5), F3	// NearZero
+	MOVD	16(X5), F17	// 1.0
+
+	FEQD	F0, F0, X7
+	BEQ	X0, X7, isNaN		// x = NaN, return NaN
+
+	FLTD	F0, F1, X7
+	BNE	X0, X7, overflow	// x > Overflow, return PosInf
+
+	FLTD	F2, F0, X7
+	BNE	X0, X7, underflow	// x < Underflow, return 0
+
+	FABSD	F0, F5
+	FLTD	F3, F5, X7
+	BNE	X0, X7, nearzero	// fabs(x) < NearZero, return 1 + x
+
+	// argument reduction, x = k*ln2 + r,  |r| <= 0.5*ln2
+	// computed as r = hi - lo for extra precision.
+	MOVD	0(X5), F5
+	MOVD	8(X5), F3
+	MOVD	48(X5), F2
+	FLTD	F0, F5, X7
+	BNE	X0, X7, add		// x > 0
+sub:
+	FMSUBD	F0, F2, F3, F3	// Log2e*x - 0.5
+	JMP	2(PC)
+add:
+	FMADDD	F0, F2, F3, F3	// Log2e*x + 0.5
+
+	FCVTLD.RTZ	F3, X16	// float64 -> int64
+	FCVTDL	X16, F3		// int64 -> float64
+
+	MOVD	32(X5), F4
+	MOVD	40(X5), F5
+	FNMSUBD	F3, F4, F0, F4
+	FMULD	F3, F5, F5
+	FSUBD	F5, F4, F6
+	FMULD	F6, F6, F7
+
+	// compute c
+	// r=(FMA x y z) -> FMADDD z, y, x, r
+	// r=(FMA x y z) -> FMADDD x, y, z, r
+	MOV	$expmultirodata<>+0(SB), X6
+	MOVD	32(X6), F8
+	MOVD	24(X6), F9
+	FMADDD	F7, F8, F9, F13
+	MOVD	16(X6), F10
+	FMADDD	F7, F13, F10, F13
+	MOVD	8(X6), F11
+	FMADDD	F7, F13, F11, F13
+	MOVD	0(X6), F12
+	FMADDD	F7, F13, F12, F13
+	FNMSUBD	F7, F13, F6, F13
+
+	// compute y
+	MOVD	24(X5), F14
+	FSUBD	F13, F14, F14
+	FMULD	F6, F13, F15
+	FDIVD	F14, F15, F15
+	FSUBD	F15, F5, F15
+	FSUBD	F4, F15, F15
+	FSUBD	F15, F17, F16
+
+	// inline Ldexp(y, k), benefit:
+	// 1, no parameter pass overhead.
+	// 2, skip unnecessary checks for Inf/NaN/Zero
+	MOVD	F16, X15
+	MOV	$FracMask, X20
+	AND	X20, X15, X17	// fraction
+	SRL	$52, X15, X18	// exponent
+	ADD	X16, X18
+	MOV	$1, X21
+	BGE	X18, X21, normal
+	ADD	$52, X18		// denormal
+	MOV	$C1, X19
+	MOVD	X19, F17
+normal:
+	SLL	$52, X18
+	OR	X18, X17, X15
+	MOVD	X15, F0
+	FMULD	F17, F0, F0		// return m * x
+	MOVD	F0, ret+8(FP)
+	RET
+nearzero:
+	FADDD	F17, F0, F0
+isNaN:
+	MOVD	F0, ret+8(FP)
+	RET
+underflow:
+	MOV	X0, ret+8(FP)
+	RET
+overflow:
+	MOV	$PosInf, X15
+	MOV	X15, ret+8(FP)
+	RET
+
+
+// Exp2 returns 2**x, the base-2 exponential of x.
+// This is an assembly implementation of the method used for function Exp2 in file exp.go.
+//
+// func Exp2(x float64) float64
+TEXT ·archExp2(SB),$0-16
+	MOVD	x+0(FP), F0	// F0 = x
+
+	MOV	$exprodata<>+0(SB), X5
+	MOVD	72(X5), F1	// Overflow2
+	MOVD	80(X5), F2	// Underflow2
+	MOVD	88(X5), F3	// NearZero
+
+	FEQD	F0, F0, X7
+	BEQ	X0, X7, isNaN		// x = NaN, return NaN
+
+	FLTD	F0, F1, X7
+	BNE	X0, X7, overflow	// x > Overflow, return PosInf
+
+	FLTD	F2, F0, X7
+	BNE	X0, X7, underflow	// x < Underflow, return 0
+
+	// argument reduction; x = r*lg(e) + k with |r| <= ln(2)/2
+	// computed as r = hi - lo for extra precision.
+	MOVD	0(X5), F10
+	MOVD	8(X5), F2
+	FLTD	F0, F10, X7
+	BNE	X0, X7, add
+sub:
+	FSUBD	F2, F0, F3	// x - 0.5
+	JMP	2(PC)
+add:
+	FADDD	F2, F0, F3	// x + 0.5
+
+	FCVTLD.RTZ	F3, X16
+	FCVTDL	X16, F3
+
+	MOVD	32(X5), F4
+	MOVD	40(X5), F5
+	FSUBD	F3, F0, F3
+	FMULD	F3, F4, F4
+	FNMSUBD	F5, F3, F10, F5
+	FSUBD	F5, F4, F6
+	FMULD	F6, F6, F7
+
+	// compute c
+	MOV	$expmultirodata<>+0(SB), X6
+	MOVD	32(X6), F8
+	MOVD	24(X6), F9
+	FMADDD	F7, F8, F9, F13
+	MOVD	16(X6), F10
+	FMADDD	F7, F13, F10, F13
+	MOVD	8(X6), F11
+	FMADDD	F7, F13, F11, F13
+	MOVD	0(X6), F12
+	FMADDD	F7, F13, F12, F13
+	FNMSUBD	F7, F13, F6, F13
+
+	// compute y
+	MOVD	24(X5), F14
+	FSUBD	F13, F14, F14
+	FMULD	F6, F13, F15
+	FDIVD	F14, F15, F15
+
+	MOVD	16(X5), F17
+	FSUBD	F15, F5, F15
+	FSUBD	F4, F15, F15
+	FSUBD	F15, F17, F16
+
+	// inline Ldexp(y, k), benefit:
+	// 1, no parameter pass overhead.
+	// 2, skip unnecessary checks for Inf/NaN/Zero
+	MOVD	F16, X15
+	MOV	$FracMask, X20
+	SRL	$52, X15, X18	// exponent
+	AND	X20, X15, X17	// fraction
+	ADD	X16, X18
+	MOV	$1, X21
+	BGE	X18, X21, normal
+
+	ADD	$52, X18		// denormal
+	MOV	$C1, X19
+	MOVD	X19, F17
+normal:
+	SLL	$52, X18
+	OR	X18, X17, X15
+	MOVD	X15, F0
+	FMULD	F17, F0, F0
+isNaN:
+	MOVD	F0, ret+8(FP)
+	RET
+underflow:
+	MOV	X0, ret+8(FP)
+	RET
+overflow:
+	MOV	$PosInf, X15
+	MOV	X15, ret+8(FP)
+	RET

package/bin/go/src/math/nextafter.go

@@ -8,7 +8,8 @@ package math
 //
 // Special cases are:
 //
-//	Nextafter32(x, x)   = x
+//	Nextafter32(x, y)   = x when x == y
+//	Nextafter32(0, y)   = ±SmallestNonzeroFloat32 towards y, for y ≠ 0
 //	Nextafter32(NaN, y) = NaN
 //	Nextafter32(x, NaN) = NaN
 func Nextafter32(x, y float32) (r float32) {
@@ -31,7 +32,8 @@ func Nextafter32(x, y float32) (r float32) {
 //
 // Special cases are:
 //
-//	Nextafter(x, x)   = x
+//	Nextafter(x, y)   = x when x == y
+//	Nextafter(0, y)   = ±SmallestNonzeroFloat64 towards y, for y ≠ 0
 //	Nextafter(NaN, y) = NaN
 //	Nextafter(x, NaN) = NaN
 func Nextafter(x, y float64) (r float64) {

package/bin/go/src/math/pow10.go

@@ -33,7 +33,7 @@ func Pow10(n int) float64 {
 		return pow10postab32[uint(n)/32] * pow10tab[uint(n)%32]
 	}
 
-	if -323 <= n && n <= 0 {
+	if -323 <= n && n < 0 {
 		return pow10negtab32[uint(-n)/32] / pow10tab[uint(-n)%32]
 	}
 

package/bin/go/src/math/rand/v2/rand.go

@@ -12,6 +12,9 @@
 // Top-level functions, such as [Float64] and [Int],
 // are safe for concurrent use by multiple goroutines.
 //
+// The [ChaCha8] source is a general-purpose source resistant to prediction.
+// The [PCG] source is faster but unfit for security-relevant purposes.
+//
 // This package's outputs might be easily predictable regardless of how it's
 // seeded. For random numbers suitable for security-sensitive work, see the
 // [crypto/rand] package.
@@ -204,6 +207,16 @@ func (r *Rand) UintN(n uint) uint {
 	return uint(r.uint64n(uint64(n)))
 }
 
+// N returns a pseudo-random number in the half-open interval [0,n).
+// The type parameter Int can be any integer type.
+// It panics if n <= 0.
+func (r *Rand) N[Int intType](n Int) Int {
+	if n <= 0 {
+		panic("invalid argument to N")
+	}
+	return Int(r.uint64n(uint64(n)))
+}
+
 // Float64 returns, as a float64, a pseudo-random number in the half-open interval [0.0,1.0).
 func (r *Rand) Float64() float64 {
 	// There are exactly 1<<53 float64s in [0,1). Use Intn(1<<53) / (1<<53).
@@ -321,10 +334,7 @@ func UintN(n uint) uint { return globalRand.UintN(n) }
 // The type parameter Int can be any integer type.
 // It panics if n <= 0.
 func N[Int intType](n Int) Int {
-	if n <= 0 {
-		panic("invalid argument to N")
-	}
-	return Int(globalRand.uint64n(uint64(n)))
+	return globalRand.N(n)
 }
 
 type intType interface {

package/bin/go/src/mime/type.go

@@ -115,7 +115,8 @@ var builtinTypesLower = map[string]string{
 	".vtt":   "text/vtt; charset=utf-8",
 	".wasm":  "application/wasm",
 	".wav":   "audio/wav",
-	".webm":  "audio/webm",
+	".weba":  "audio/webm",
+	".webm":  "video/webm",
 	".webp":  "image/webp",
 	".xbl":   "text/xml; charset=utf-8",
 	".xbm":   "image/x-xbitmap",
@@ -245,7 +246,7 @@ func setExtensionType(extension, mimeType string) error {
 	}
 	if strings.HasPrefix(mimeType, "text/") && param["charset"] == "" {
 		param["charset"] = "utf-8"
-		mimeType = FormatMediaType(mimeType, param)
+		mimeType = FormatMediaType(justType, param)
 	}
 	extLower := strings.ToLower(extension)
 

package/bin/go/src/net/dial.go

@@ -160,10 +160,13 @@ type Dialer struct {
 	DualStack bool
 
 	// FallbackDelay specifies the length of time to wait before
-	// spawning a RFC 6555 Fast Fallback connection. That is, this
-	// is the amount of time to wait for IPv6 to succeed before
-	// assuming that IPv6 is misconfigured and falling back to
-	// IPv4.
+	// spawning a RFC 6555 Fast Fallback connection.
+	//
+	// When dialing "tcp" and both IPv6 and IPv4 addresses are
+	// available, the address family of the first resolved address
+	// is treated as the primary. After FallbackDelay, a connection
+	// attempt to the other address family is started if the primary
+	// connection has not yet succeeded.
 	//
 	// If zero, a default delay of 300ms is used.
 	// A negative value disables Fast Fallback support.
@@ -572,7 +575,8 @@ func (d *Dialer) dialCtx(ctx context.Context) (context.Context, context.CancelFu
 		}
 	}
 	if oldCancel := d.Cancel; oldCancel != nil {
-		subCtx, cancel2 := context.WithCancel(ctx)
+		var subCtx context.Context
+		subCtx, cancel2 = context.WithCancel(ctx)
 		go func() {
 			select {
 			case <-oldCancel:
@@ -662,7 +666,7 @@ func (sd *sysDialer) dialParallel(ctx context.Context, primaries, fallbacks addr
 
 	type dialResult struct {
 		Conn
-		error
+		error   error
 		primary bool
 		done    bool
 	}