@ttsc/win32-arm64 0.33.0 → 0.34.0

package/bin/go/src/internal/testenv/testenv.go

@@ -275,12 +275,28 @@ var goTool = sync.OnceValues(func() (string, error) {
 
 // MustHaveSource checks that the entire source tree is available under GOROOT.
 // If not, it calls t.Skip with an explanation.
+//
+// This is needed when reading files from GOROOT that are not in ./testdata.
 func MustHaveSource(t testing.TB) {
+	t.Helper()
 	switch runtime.GOOS {
 	case "ios":
-		t.Helper()
 		t.Skip("skipping test: no source tree on " + runtime.GOOS)
 	}
+	if Builder() != "" {
+		// The builders have the source tree available, and if they don't the
+		// tests should error out.
+		return
+	}
+	// If not running on the builders, the test binary might have been copied to
+	// a target machine where the source tree isn't available.
+	goroot, err := findGOROOT()
+	if err != nil {
+		t.Skipf("skipping test: cannot locate GOROOT: %v", err)
+	}
+	if _, err := os.Stat(filepath.Join(goroot, "src", "go.mod")); err != nil {
+		t.Skipf("skipping test: GOROOT/src not available: %v", err)
+	}
 }
 
 // HasExternalNetwork reports whether the current system can use
@@ -546,3 +562,10 @@ func CPUProfilingBroken() bool {
 
 	return false
 }
+
+// SetGODEBUG appends v to the GODEBUG environment variable for the
+// duration of the test.
+func SetGODEBUG(t testing.TB, v string) {
+	t.Helper()
+	t.Setenv("GODEBUG", os.Getenv("GODEBUG")+","+v)
+}

package/bin/go/src/internal/trace/event.go

@@ -776,7 +776,7 @@ func makeStackSampleEvent(e Event, s Stack) (Event, error) {
 }
 
 func addStack(table *evTable, frames []StackFrame) stackID {
-	var pcs []uint64
+	pcs := make([]uint64, 0, len(frames))
 	for _, f := range frames {
 		table.pcs[f.PC] = frame{
 			pc:     f.PC,

package/bin/go/src/internal/trace/tracev2/events.go

@@ -555,6 +555,8 @@ func (s ProcStatus) String() string {
 		return "Idle"
 	case ProcSyscall:
 		return "Syscall"
+	case ProcSyscallAbandoned:
+		return "SyscallAbandoned"
 	}
 	return "Bad"
 }

package/bin/go/src/internal/trace/traceviewer/pprof.go

@@ -56,6 +56,7 @@ func SVGProfileHandlerFunc(f ProfileFunc) http.HandlerFunc {
 		records, err := f(r)
 		if err != nil {
 			http.Error(w, fmt.Sprintf("failed to generate profile: %v", err), http.StatusInternalServerError)
+			return
 		}
 		blockb := bufio.NewWriter(blockf)
 		if err := BuildProfile(records).Write(blockb); err != nil {

package/bin/go/src/internal/types/errors/generrordocs.go

@@ -67,7 +67,7 @@ func main() {
 
 func walkCodes(f func(string, *ast.ValueSpec)) {
 	fset := token.NewFileSet()
-	file, err := parser.ParseFile(fset, "codes.go", nil, parser.ParseComments)
+	file, err := parser.ParseFile(fset, "codes.go", nil, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		log.Fatalf("ParseFile failed: %s", err)
 	}

package/bin/go/src/io/fs/fs.go

@@ -155,9 +155,12 @@ var (
 	ErrPermission = errPermission() // "permission denied"
 	ErrExist      = errExist()      // "file already exists"
 	ErrNotExist   = errNotExist()   // "file does not exist"
-	ErrClosed     = errClosed()     // "file already closed"
 )
 
+// ErrClosed is returned when operations are attempted on a file that
+// has already been closed, including when Close is called more than once.
+var ErrClosed = errClosed()
+
 func errInvalid() error    { return oserror.ErrInvalid }
 func errPermission() error { return oserror.ErrPermission }
 func errExist() error      { return oserror.ErrExist }

package/bin/go/src/io/fs/glob.go

@@ -27,7 +27,7 @@ type GlobFS interface {
 // The only possible returned error is [path.ErrBadPattern], reporting that
 // the pattern is malformed.
 //
-// If fs implements [GlobFS], Glob calls fs.Glob.
+// If fsys implements [GlobFS], Glob calls fsys.Glob.
 // Otherwise, Glob uses [ReadDir] to traverse the directory tree
 // and look for matches for the pattern.
 func Glob(fsys FS, pattern string) (matches []string, err error) {

package/bin/go/src/io/fs/readdir.go

@@ -23,9 +23,9 @@ type ReadDirFS interface {
 // ReadDir reads the named directory
 // and returns a list of directory entries sorted by filename.
 //
-// If fs implements [ReadDirFS], ReadDir calls fs.ReadDir.
-// Otherwise ReadDir calls fs.Open and uses ReadDir and Close
-// on the returned file.
+// If fsys implements [ReadDirFS], ReadDir calls fsys.ReadDir.
+// Otherwise ReadDir calls fsys.Open and uses ReadDir and Close
+// on the returned [ReadDirFile].
 func ReadDir(fsys FS, name string) ([]DirEntry, error) {
 	if fsys, ok := fsys.(ReadDirFS); ok {
 		return fsys.ReadDir(name)

package/bin/go/src/io/fs/readfile.go

@@ -21,13 +21,13 @@ type ReadFileFS interface {
 	ReadFile(name string) ([]byte, error)
 }
 
-// ReadFile reads the named file from the file system fs and returns its contents.
+// ReadFile reads the named file from the file system fsys and returns its contents.
 // A successful call returns a nil error, not [io.EOF].
 // (Because ReadFile reads the whole file, the expected EOF
 // from the final Read is not treated as an error to be reported.)
 //
-// If fs implements [ReadFileFS], ReadFile calls fs.ReadFile.
-// Otherwise ReadFile calls fs.Open and uses Read and Close
+// If fsys implements [ReadFileFS], ReadFile calls fsys.ReadFile.
+// Otherwise ReadFile calls fsys.Open and uses Read and Close
 // on the returned [File].
 func ReadFile(fsys FS, name string) ([]byte, error) {
 	if fsys, ok := fsys.(ReadFileFS); ok {

package/bin/go/src/io/fs/stat.go

@@ -15,7 +15,7 @@ type StatFS interface {
 
 // Stat returns a [FileInfo] describing the named file from the file system.
 //
-// If fs implements [StatFS], Stat calls fs.Stat.
+// If fsys implements [StatFS], Stat calls fsys.Stat.
 // Otherwise, Stat opens the [File] to stat it.
 func Stat(fsys FS, name string) (FileInfo, error) {
 	if fsys, ok := fsys.(StatFS); ok {

package/bin/go/src/io/fs/sub.go

@@ -20,11 +20,12 @@ type SubFS interface {
 // Sub returns an [FS] corresponding to the subtree rooted at fsys's dir.
 //
 // If dir is ".", Sub returns fsys unchanged.
-// Otherwise, if fs implements [SubFS], Sub returns fsys.Sub(dir).
+// Otherwise, if fsys implements [SubFS], Sub returns fsys.Sub(dir).
 // Otherwise, Sub returns a new [FS] implementation sub that,
 // in effect, implements sub.Open(name) as fsys.Open(path.Join(dir, name)).
 // The implementation also translates calls to ReadDir, ReadFile,
-// ReadLink, Lstat, and Glob appropriately.
+// ReadLink, Lstat, and Glob appropriately. Sub does not check if the
+// directory currently exists.
 //
 // Note that Sub(os.DirFS("/"), "prefix") is equivalent to os.DirFS("/prefix")
 // and that neither of them guarantees to avoid operating system
@@ -32,6 +33,7 @@ type SubFS interface {
 // does not check for symbolic links inside "/prefix" that point to
 // other directories. That is, [os.DirFS] is not a general substitute for a
 // chroot-style security mechanism, and Sub does not change that fact.
+// Use [os.Root] to constrain access to particular directory trees.
 func Sub(fsys FS, dir string) (FS, error) {
 	if !ValidPath(dir) {
 		return nil, &PathError{Op: "sub", Path: dir, Err: ErrInvalid}

package/bin/go/src/iter/iter.go

@@ -230,10 +230,10 @@ type Seq2[K, V any] func(yield func(K, V) bool)
 
 type coro struct{}
 
-//go:linkname newcoro runtime.newcoro
+//go:linknamestd newcoro runtime.newcoro
 func newcoro(func(*coro)) *coro
 
-//go:linkname coroswitch runtime.coroswitch
+//go:linknamestd coroswitch runtime.coroswitch
 func coroswitch(*coro)
 
 // Pull converts the “push-style” iterator sequence seq

package/bin/go/src/log/slog/handler.go

@@ -204,7 +204,6 @@ type commonHandler struct {
 }
 
 func (h *commonHandler) clone() *commonHandler {
-	// We can't use assignment because we can't copy the mutex.
 	return &commonHandler{
 		json:              h.json,
 		opts:              h.opts,

package/bin/go/src/log/slog/json_handler.go

@@ -10,6 +10,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"internal/goexperiment"
 	"io"
 	"log/slog/internal/buffer"
 	"strconv"
@@ -95,6 +96,7 @@ func appendJSONTime(s *handleState, t time.Time) {
 		// RFC 3339 is clear that years are 4 digits exactly.
 		// See golang.org/issue/4556#c15 for more discussion.
 		s.appendError(errors.New("time.Time year outside of range [0,9999]"))
+		return
 	}
 	s.buf.WriteByte('"')
 	*s.buf = t.AppendFormat(*s.buf, time.RFC3339Nano)
@@ -219,7 +221,11 @@ func appendEscapedJSONString(buf []byte, s string) []byte {
 			if start < i {
 				str(s[start:i])
 			}
-			str(`\ufffd`)
+			if goexperiment.JSONv2 {
+				str("\ufffd") // see https://go.dev/cl/687116
+			} else {
+				str(`\ufffd`)
+			}
 			i += size
 			start = i
 			continue

package/bin/go/src/log/slog/logger.go

@@ -195,6 +195,8 @@ func (l *Logger) LogAttrs(ctx context.Context, level Level, msg string, attrs ..
 }
 
 // Debug logs at [LevelDebug].
+// It uses [context.Background] internally; to specify the context, use
+// [Logger.DebugContext].
 func (l *Logger) Debug(msg string, args ...any) {
 	l.log(context.Background(), LevelDebug, msg, args...)
 }
@@ -205,6 +207,8 @@ func (l *Logger) DebugContext(ctx context.Context, msg string, args ...any) {
 }
 
 // Info logs at [LevelInfo].
+// It uses [context.Background] internally; to specify the context, use
+// [Logger.InfoContext].
 func (l *Logger) Info(msg string, args ...any) {
 	l.log(context.Background(), LevelInfo, msg, args...)
 }
@@ -215,6 +219,8 @@ func (l *Logger) InfoContext(ctx context.Context, msg string, args ...any) {
 }
 
 // Warn logs at [LevelWarn].
+// It uses [context.Background] internally; to specify the context, use
+// [Logger.WarnContext].
 func (l *Logger) Warn(msg string, args ...any) {
 	l.log(context.Background(), LevelWarn, msg, args...)
 }
@@ -225,6 +231,8 @@ func (l *Logger) WarnContext(ctx context.Context, msg string, args ...any) {
 }
 
 // Error logs at [LevelError].
+// It uses [context.Background] internally; to specify the context, use
+// [Logger.ErrorContext].
 func (l *Logger) Error(msg string, args ...any) {
 	l.log(context.Background(), LevelError, msg, args...)
 }
@@ -277,6 +285,8 @@ func (l *Logger) logAttrs(ctx context.Context, level Level, msg string, attrs ..
 }
 
 // Debug calls [Logger.Debug] on the default logger.
+// It uses [context.Background] internally; to specify the context, use
+// [DebugContext].
 func Debug(msg string, args ...any) {
 	Default().log(context.Background(), LevelDebug, msg, args...)
 }
@@ -287,6 +297,8 @@ func DebugContext(ctx context.Context, msg string, args ...any) {
 }
 
 // Info calls [Logger.Info] on the default logger.
+// It uses [context.Background] internally; to specify the context, use
+// [InfoContext].
 func Info(msg string, args ...any) {
 	Default().log(context.Background(), LevelInfo, msg, args...)
 }
@@ -297,6 +309,8 @@ func InfoContext(ctx context.Context, msg string, args ...any) {
 }
 
 // Warn calls [Logger.Warn] on the default logger.
+// It uses [context.Background] internally; to specify the context, use
+// [WarnContext].
 func Warn(msg string, args ...any) {
 	Default().log(context.Background(), LevelWarn, msg, args...)
 }
@@ -307,6 +321,8 @@ func WarnContext(ctx context.Context, msg string, args ...any) {
 }
 
 // Error calls [Logger.Error] on the default logger.
+// It uses [context.Background] internally; to specify the context, use
+// [ErrorContext].
 func Error(msg string, args ...any) {
 	Default().log(context.Background(), LevelError, msg, args...)
 }

package/bin/go/src/log/slog/text_handler.go

@@ -100,7 +100,16 @@ func appendTextValue(s *handleState, v Value) error {
 	case KindTime:
 		s.appendTime(v.time())
 	case KindAny:
-		if tm, ok := v.any.(encoding.TextMarshaler); ok {
+		if ta, ok := v.any.(encoding.TextAppender); ok {
+			var buf []byte
+			buf, err := ta.AppendText(buf)
+			if err != nil {
+				return err
+			}
+			// TODO: append directly to buffer when possible
+			s.appendString(string(buf))
+			return nil
+		} else if tm, ok := v.any.(encoding.TextMarshaler); ok {
 			data, err := tm.MarshalText()
 			if err != nil {
 				return err

package/bin/go/src/log/slog/value.go

@@ -470,7 +470,7 @@ func (v Value) append(dst []byte) []byte {
 	case KindDuration:
 		return append(dst, v.duration().String()...)
 	case KindTime:
-		return append(dst, v.time().String()...)
+		return v.time().AppendFormat(dst, "2006-01-02 15:04:05.999999999 -0700 MST")
 	case KindGroup:
 		return fmt.Append(dst, v.group())
 	case KindAny, KindLogValuer:

package/bin/go/src/log/syslog/doc.go

@@ -22,3 +22,8 @@ package syslog
 // see https://golang.org/issue/1108.
 
 // BUG(akumar): This package is not implemented on Plan 9.
+
+// BUG(odeke-em): As of Darwin's macOS 12.X (Monterey), Apple's syslog daemon no
+// longer listens on a UNIX domain socket and instead now uses their proprietary
+// Apple Unified Logging (AUL) system, hence this package will no longer work.
+// Please see https://developer.apple.com/documentation/os/logging.

package/bin/go/src/math/abs.go

@@ -11,5 +11,5 @@ package math
 //	Abs(±Inf) = +Inf
 //	Abs(NaN) = NaN
 func Abs(x float64) float64 {
-	return Float64frombits(Float64bits(x) &^ (1 << 63))
+	return Float64frombits(Float64bits(x) &^ signMask)
 }

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

@@ -18,9 +18,9 @@ const _Accuracy_name = "BelowExactAbove"
 var _Accuracy_index = [...]uint8{0, 5, 10, 15}
 
 func (i Accuracy) String() string {
-	i -= -1
-	if i < 0 || i >= Accuracy(len(_Accuracy_index)-1) {
-		return "Accuracy(" + strconv.FormatInt(int64(i+-1), 10) + ")"
+	idx := int(i) - -1
+	if i < -1 || idx >= len(_Accuracy_index)-1 {
+		return "Accuracy(" + strconv.FormatInt(int64(i), 10) + ")"
 	}
-	return _Accuracy_name[_Accuracy_index[i]:_Accuracy_index[i+1]]
+	return _Accuracy_name[_Accuracy_index[idx]:_Accuracy_index[idx+1]]
 }

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

@@ -254,7 +254,7 @@ func mulAddVWW_g(z, x []Word, y, r Word) (c Word) {
 
 func addMulVVWW_g(z, x, y []Word, m, a Word) (c Word) {
 	if len(x) != len(z) || len(y) != len(z) {
-		panic("rshVU len")
+		panic("addMulVVWW len")
 	}
 
 	c = a

package/bin/go/src/math/big/arith_loong64.s

@@ -162,10 +162,8 @@ TEXT ·lshVU(SB), NOSPLIT, $0
 	MOVV x_base+24(FP), R6
 	MOVV z_base+0(FP), R7
 	// run loop backward
-	SLLV $3, R4, R8
-	ADDVU R8, R6
-	SLLV $3, R4, R8
-	ADDVU R8, R7
+	ALSLV $3, R4, R6, R6
+	ALSLV $3, R4, R7, R7
 	// shift first word into carry
 	MOVV -8(R6), R8
 	MOVV $64, R9

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

@@ -78,6 +78,8 @@ type ErrNaN struct {
 	msg string
 }
 
+var _ error = ErrNaN{}
+
 func (err ErrNaN) Error() string {
 	return err.msg
 }

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

@@ -4,7 +4,7 @@
 
 // This file implements Float-to-string conversion functions.
 // It is closely following the corresponding implementation
-// in strconv/ftoa.go, but modified and simplified for Float.
+// in internal/strconv/ftoa.go, but modified and simplified for Float.
 
 package big
 
@@ -44,6 +44,10 @@ import (
 // the smallest number of decimal digits necessary to identify the value x uniquely
 // using x.Prec() mantissa bits.
 // The prec value is ignored for the 'b' and 'p' formats.
+//
+// Note that Text may return a different result than strconv.FormatFloat for
+// corresponding arguments if the matching float32 or float64 number provided
+// to strconv.FormatFloat is a denormalized number.
 func (x *Float) Text(format byte, prec int) string {
 	cap := 10 // TODO(gri) determine a good/better value here
 	if prec > 0 {
@@ -177,9 +181,6 @@ func roundShortest(d *decimal, x *Float) {
 	// Compute the lower and upper bound in decimal form and find the
 	// shortest decimal number d such that lower <= d <= upper.
 
-	// TODO(gri) strconv/ftoa.do describes a shortcut in some cases.
-	// See if we can use it (in adjusted form) here as well.
-
 	// 1) Compute normalized mantissa mant and exponent exp for x such
 	// that the lsb of mant corresponds to 1/2 ulp for the precision of
 	// x (i.e., for mant we want x.prec + 1 bits).
@@ -222,7 +223,12 @@ func roundShortest(d *decimal, x *Float) {
 
 		// Okay to round up if upper has a different digit and either upper
 		// is inclusive or upper is bigger than the result of rounding up.
-		okup := m != u && (inclusive || m+1 < u || i+1 < len(upper.mant))
+		// The last clause handles digits past upper's trimmed mantissa:
+		// upper.at(i) returns '0' there, but the true upper bound was
+		// determined by earlier digits, so rounding up is valid unless
+		// m == '9' (which would carry onto the exclusive upper bound).
+		// See also go.dev/issue/80206.
+		okup := m != u && (inclusive || m+1 < u || i+1 < len(upper.mant) || i >= len(upper.mant) && m < '9')
 
 		// If it's okay to do either, then round to the nearest one.
 		// If it's okay to do only one, do it.

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

@@ -227,7 +227,7 @@ func (z *Int) MulRange(a, b int64) *Int {
 
 // Binomial sets z to the binomial coefficient C(n, k) and returns z.
 func (z *Int) Binomial(n, k int64) *Int {
-	if k > n {
+	if k > n || k < 0 {
 		return z.SetInt64(0)
 	}
 	// reduce the number of multiplications by reducing k
@@ -371,6 +371,89 @@ func (z *Int) DivMod(x, y, m *Int) (*Int, *Int) {
 	return z, m
 }
 
+// Rounding modes that determine how the integer quotient is adjusted in an integer division.
+// See Daan Leijen, “Division and Modulus for Computer Scientists”, for details.
+const (
+	Trunc = ToZero        // T-division (same as Go division)
+	Floor = ToNegativeInf // F-division
+	Round = ToNearestEven // R-division
+	Ceil  = ToPositiveInf // C-division
+)
+
+// Divide computes the integer quotient q and remainder r such that
+//
+//	q = f(x/y)
+//	r = x - y*q
+//
+// where f is described by the rounding mode,
+// which must be one of [Trunc], [Floor], [Round] or [Ceil].
+// Divide sets z to q if z != nil, updates r if r != nil,
+// and returns the pair (z, r) if y != 0.
+// If y == 0, a division-by-zero run-time panic occurs.
+func (z *Int) Divide(x, y, r *Int, mode RoundingMode) (*Int, *Int) {
+	// TODO: optimize the code where z or r is nil
+	var z_abs nat
+	if z != nil {
+		z_abs = z.abs
+	}
+	var r_neg bool
+	var r_abs nat
+	if r != nil {
+		r_abs = r.abs
+	}
+	y_abs := y.abs // save y
+	if z == y || alias(z_abs, y.abs) {
+		y_abs = nat(nil).set(y.abs)
+	}
+	neg := x.neg != y.neg
+	z_abs, r_abs = z_abs.div(nil, r_abs, x.abs, y.abs)
+	if len(r_abs) > 0 {
+		switch mode {
+		case Trunc:
+			r_neg = x.neg
+		case Floor:
+			r_neg = y.neg
+			if neg {
+				z_abs = z_abs.add(z_abs, natOne)
+				r_abs = r_abs.sub(y_abs, r_abs)
+			}
+		case Ceil:
+			r_neg = !y.neg
+			if !neg {
+				z_abs = z_abs.add(z_abs, natOne)
+				r_abs = r_abs.sub(y_abs, r_abs)
+			}
+		case Round:
+			switch nat(nil).mul(nil, r_abs, natTwo).cmp(y_abs) {
+			case -1:
+				r_neg = x.neg
+			case 0:
+				even := len(z_abs) == 0 || z_abs[0]&1 == 0
+				if even {
+					r_neg = x.neg
+					break
+				}
+				fallthrough
+			case 1:
+				r_neg = !x.neg
+				z_abs = z_abs.add(z_abs, natOne)
+				r_abs = r_abs.sub(y_abs, r_abs)
+			}
+		default:
+			panic("unsupported rounding mode")
+		}
+	}
+	if z != nil {
+		z.abs = z_abs
+		z.neg = neg && len(z_abs) > 0 // 0 has no sign
+	}
+	if r != nil {
+		r.abs = r_abs
+		r.neg = r_neg
+	}
+	return z, r
+}
+
 // Cmp compares x and y and returns:
 //   - -1 if x < y;
 //   - 0 if x == y;

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

@@ -42,12 +42,27 @@ func (x *Int) String() string {
 
 // write count copies of text to s.
 func writeMultiple(s fmt.State, text string, count int) {
-	if len(text) > 0 {
-		b := []byte(text)
-		for ; count > 0; count-- {
-			s.Write(b)
+	if len(text) <= 0 || count <= 0 {
+		return
+	}
+	if len(text) == 1 {
+		if bw, ok := s.(io.ByteWriter); ok {
+			for range count {
+				bw.WriteByte(text[0])
+			}
+			return
 		}
 	}
+	if sw, ok := s.(io.StringWriter); ok {
+		for range count {
+			sw.WriteString(text)
+		}
+		return
+	}
+	b := []byte(text)
+	for range count {
+		s.Write(b)
+	}
 }
 
 var _ fmt.Formatter = intOne // *Int must implement fmt.Formatter

package/bin/go/src/math/big/internal/asmgen/loong64.go

@@ -40,6 +40,8 @@ var ArchLoong64 = &Arch{
 	or:    "OR",
 	xor:   "XOR",
 
+	addWords: "ALSLV $3, %[1]s, %[2]s, %[3]s",
+
 	jmpZero:    "BEQ %s, %s",
 	jmpNonZero: "BNE %s, %s",
 }