@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/database/sql/closemu.go

@@ -0,0 +1,119 @@
+// 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.
+
+package sql
+
+import (
+	"sync"
+	"sync/atomic"
+)
+
+// A closingMutex is an RWMutex for synchronizing close.
+// Unlike a sync.RWMutex, RLock takes priority over Lock.
+// Reads can starve out close, but reads are safely reentrant.
+type closingMutex struct {
+	// state is 2*readers+writerWaiting.
+	//   0 is unlocked
+	//   1 is unlocked and a writer needs to wake
+	//   >0 is read-locked
+	//   <0 is write-locked
+	state atomic.Int64
+	mu    sync.Mutex
+	read  *sync.Cond
+	write *sync.Cond
+}
+
+func (m *closingMutex) RLock() {
+	if m.TryRLock() {
+		return
+	}
+
+	// Wait for writer.
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	for {
+		if m.TryRLock() {
+			return
+		}
+		m.init()
+		m.read.Wait()
+	}
+}
+
+func (m *closingMutex) RUnlock() {
+	for {
+		x := m.state.Load()
+		if x < 2 {
+			panic("runlock of un-rlocked mutex")
+		}
+		if m.state.CompareAndSwap(x, x-2) {
+			if x-2 == 1 {
+				// We were the last reader, and a writer is waiting.
+				// The lock makes sure the writer sees the broadcast.
+				m.mu.Lock()
+				defer m.mu.Unlock()
+				m.write.Broadcast()
+			}
+			return
+		}
+	}
+}
+
+func (m *closingMutex) Lock() {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	for {
+		x := m.state.Load()
+		if x == 0 || x == 1 {
+			if m.state.CompareAndSwap(x, -1) {
+				return
+			}
+			continue
+		}
+		// Set writer waiting bit and sleep.
+		if x&1 == 0 && !m.state.CompareAndSwap(x, x|1) {
+			continue
+		}
+		m.init()
+		m.write.Wait()
+	}
+}
+
+func (m *closingMutex) Unlock() {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if !m.state.CompareAndSwap(-1, 0) {
+		panic("unlock of unlocked mutex")
+	}
+	if m.read != nil {
+		m.read.Broadcast()
+		m.write.Broadcast()
+	}
+}
+
+func (m *closingMutex) TryRLock() bool {
+	for {
+		x := m.state.Load()
+		// Fail if the mutex is write locked (x < 0)
+		// or unlocked with a writer waiting (x == 1).
+		//
+		// If the mutex is read-locked (x > 1), try to add a reader
+		// even if this starves out a waiting writer.
+		if x < 0 || x == 1 {
+			return false
+		}
+		if m.state.CompareAndSwap(x, x+2) {
+			return true
+		}
+	}
+}
+
+func (m *closingMutex) init() {
+	// Lazily create the read/write Conds.
+	// In the common, uncontended case, we'll never need them.
+	if m.read == nil {
+		m.read = sync.NewCond(&m.mu)
+		m.write = sync.NewCond(&m.mu)
+	}
+}

package/bin/go/src/database/sql/convert.go

@@ -9,6 +9,7 @@ package sql
 import (
 	"bytes"
 	"database/sql/driver"
+	"database/sql/internal"
 	"errors"
 	"fmt"
 	"reflect"
@@ -17,6 +18,7 @@ import (
 	"unicode"
 	"unicode/utf8"
 	_ "unsafe" // for linkname
+	"uuid"
 )
 
 var errNilPtr = errors.New("destination pointer is nil") // embedded in descriptive error
@@ -218,10 +220,25 @@ func driverArgsConnLocked(ci driver.Conn, ds *driverStmt, args []any) ([]driver.
 // See go.dev/issue/67401.
 //
 //go:linkname convertAssign
-func convertAssign(dest, src any) error {
+func convertAssign(dest any, src any) error {
 	return convertAssignRows(dest, src, nil)
 }
 
+// ConvertAssign copies the value in src to the value pointed at by dest.
+// See the documentation on [Rows.Scan] for details on conversions.
+// dest must be a pointer or must implement [Scanner].
+//
+// Implementations of [driver.RowsColumnScanner] should pass through
+// their [driver.ScanContext] parameter.
+// In other cases, pass driver.ScanContext{} as the context.
+//
+// ConvertAssign is intended for use by driver implementations.
+// Most users should not need to use it directly.
+func ConvertAssign(scanCtx driver.ScanContext, dest any, src driver.Value) error {
+	rows, _ := internal.ScanContextValue(internal.ScanContext(scanCtx)).(*Rows)
+	return convertAssignRows(dest, src, rows)
+}
+
 // convertAssignRows copies to dest the value in src, converting it if possible.
 // An error is returned if the copy would result in loss of information.
 // dest should be a pointer type. If rows is passed in, the rows will
@@ -250,6 +267,16 @@ func convertAssignRows(dest, src any, rows *Rows) error {
 			}
 			*d = rows.setrawbuf(append(rows.rawbuf(), s...))
 			return nil
+		case *uuid.UUID:
+			if d == nil {
+				return errNilPtr
+			}
+			u, err := uuid.Parse(s)
+			if err != nil {
+				return fmt.Errorf("converting driver.Value type string (%q) to a UUID: %v", s, err)
+			}
+			*d = u
+			return nil
 		}
 	case []byte:
 		switch d := dest.(type) {
@@ -277,6 +304,21 @@ func convertAssignRows(dest, src any, rows *Rows) error {
 			}
 			*d = s
 			return nil
+		case *uuid.UUID:
+			if d == nil {
+				return errNilPtr
+			}
+			if len(s) == len(*d) {
+				copy((*d)[:], s)
+				return nil
+			}
+			var u uuid.UUID
+			err := u.UnmarshalText(s)
+			if err != nil {
+				return fmt.Errorf("converting driver.Value type []byte (%q) to a UUID: %v", s, err)
+			}
+			*d = u
+			return nil
 		}
 	case time.Time:
 		switch d := dest.(type) {
@@ -327,24 +369,41 @@ func convertAssignRows(dest, src any, rows *Rows) error {
 		}
 	// The driver is returning a cursor the client may iterate over.
 	case driver.Rows:
-		switch d := dest.(type) {
-		case *Rows:
+		d, ok := dest.(*Rows)
+		if ok {
 			if d == nil {
 				return errNilPtr
 			}
 			if rows == nil {
 				return errors.New("invalid context to convert cursor rows, missing parent *Rows")
 			}
+			// This is hazardous and not really correct: If the user provides us
+			// with the same *Rows for each Scan (which they very likely will),
+			// then this overwrites the previously-used Rows, including its mutexes.
+			// The chained row cancel function below will also repeatedly reference
+			// the same *Rows.
 			*d = Rows{
 				dc:          rows.dc,
 				releaseConn: func(error) {},
 				rowsi:       s,
 			}
 			// Chain the cancel function.
+			//
+			// This has problems:
+			//   - Repeatedly wrapping the cancel func is inefficient compared to
+			//     just storing a []*Rows of children.
+			//   - The cancel func is wrapped for each cursor read. If we scan N
+			//     rows, each with a child cursor, we end up with N chained cancel
+			//     funcs. (Also, if the user is reusing a Rows--see above--the cancel
+			//     funcs might all be referencing the same underlying Rows cursor.)
+			//   - It seems like it would be reasonable to invalidate a cursor
+			//     after advancing to the next parent row (the row which contains
+			//     the cursor). We don't do that now, and it isn't clear that we can
+			//     change this.
 			parentCancel := rows.cancel
 			rows.cancel = func() {
 				// When Rows.cancel is called, the closemu will be locked as well.
-				// So we can access rs.lasterr.
+				// So we can access rows.lasterr.
 				d.close(rows.lasterr)
 				if parentCancel != nil {
 					parentCancel()

package/bin/go/src/database/sql/driver/driver.go

@@ -40,6 +40,7 @@ package driver
 
 import (
 	"context"
+	"database/sql/internal"
 	"errors"
 	"reflect"
 )
@@ -443,6 +444,31 @@ type Rows interface {
 	Next(dest []Value) error
 }
 
+// ScanContext carries state related to the current query
+// through a [RowsColumnScanner.ScanColumn] function to [database/sql.ConvertAssign].
+type ScanContext internal.ScanContext
+
+// RowsColumnScanner extends the [Rows] interface by providing a way for the driver
+// to scan directly into the user-provided destination.
+//
+// RowsColumnScanner supersedes the [Rows.Next] method.
+//
+// As of Go 1.27, database/sql will not call Next if a Rows implements RowsColumnScanner.
+// Rows implementations may still implement the Next method to support older versions of Go.
+type RowsColumnScanner interface {
+	Rows
+
+	// NextRow advances to the next row of data.
+	// It should return io.EOF when there are no more rows.
+	NextRow() error
+
+	// ScanColumn copies the column at the given index in the current row
+	// into the value pointed to by dest.
+	//
+	// The driver may assign a driver.Value to dest using [database/sql.ConvertAssign].
+	ScanColumn(scanCtx ScanContext, index int, dest any) error
+}
+
 // RowsNextResultSet extends the [Rows] interface by providing a way to signal
 // the driver to advance to the next result set.
 type RowsNextResultSet interface {

package/bin/go/src/database/sql/driver/types.go

@@ -9,6 +9,7 @@ import (
 	"reflect"
 	"strconv"
 	"time"
+	"uuid"
 )
 
 // ValueConverter is the interface providing the ConvertValue method.
@@ -257,6 +258,9 @@ func (defaultConverter) ConvertValue(v any) (Value, error) {
 	// For now, continue to prefer the Valuer interface over the decimal decompose interface.
 	case decimalDecompose:
 		return vr, nil
+
+	case uuid.UUID:
+		return vr.String(), nil
 	}
 
 	rv := reflect.ValueOf(v)

package/bin/go/src/database/sql/internal/sql.go

@@ -0,0 +1,22 @@
+// 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.
+
+// Package internal contains internal symbols shared between
+// database/sql and database/sql/driver.
+package internal
+
+// ScanContext is database/sql/driver.ScanContext.
+// We define it here so driver.ScanContext can be opaque to users but
+// visible to database/sql.
+type ScanContext struct {
+	v any
+}
+
+func NewScanContext(v any) ScanContext {
+	return ScanContext{v}
+}
+
+func ScanContextValue(c ScanContext) any {
+	return c.v
+}

package/bin/go/src/database/sql/sql.go

@@ -18,6 +18,7 @@ package sql
 import (
 	"context"
 	"database/sql/driver"
+	"database/sql/internal"
 	"errors"
 	"fmt"
 	"io"
@@ -47,9 +48,6 @@ var driversMu sync.RWMutex
 //go:linkname drivers
 var drivers = make(map[string]driver.Driver)
 
-// nowFunc returns the current time; it's overridden in tests.
-var nowFunc = time.Now
-
 // Register makes a database driver available by the provided name.
 // If Register is called twice with the same name or if driver is nil,
 // it panics.
@@ -202,8 +200,9 @@ func (ns *NullString) Scan(value any) error {
 		ns.String, ns.Valid = "", false
 		return nil
 	}
-	ns.Valid = true
-	return convertAssign(&ns.String, value)
+	err := convertAssign(&ns.String, value)
+	ns.Valid = err == nil
+	return err
 }
 
 // Value implements the [driver.Valuer] interface.
@@ -228,8 +227,9 @@ func (n *NullInt64) Scan(value any) error {
 		n.Int64, n.Valid = 0, false
 		return nil
 	}
-	n.Valid = true
-	return convertAssign(&n.Int64, value)
+	err := convertAssign(&n.Int64, value)
+	n.Valid = err == nil
+	return err
 }
 
 // Value implements the [driver.Valuer] interface.
@@ -254,8 +254,9 @@ func (n *NullInt32) Scan(value any) error {
 		n.Int32, n.Valid = 0, false
 		return nil
 	}
-	n.Valid = true
-	return convertAssign(&n.Int32, value)
+	err := convertAssign(&n.Int32, value)
+	n.Valid = err == nil
+	return err
 }
 
 // Value implements the [driver.Valuer] interface.
@@ -334,8 +335,9 @@ func (n *NullFloat64) Scan(value any) error {
 		n.Float64, n.Valid = 0, false
 		return nil
 	}
-	n.Valid = true
-	return convertAssign(&n.Float64, value)
+	err := convertAssign(&n.Float64, value)
+	n.Valid = err == nil
+	return err
 }
 
 // Value implements the [driver.Valuer] interface.
@@ -360,8 +362,9 @@ func (n *NullBool) Scan(value any) error {
 		n.Bool, n.Valid = false, false
 		return nil
 	}
-	n.Valid = true
-	return convertAssign(&n.Bool, value)
+	err := convertAssign(&n.Bool, value)
+	n.Valid = err == nil
+	return err
 }
 
 // Value implements the [driver.Valuer] interface.
@@ -386,8 +389,9 @@ func (n *NullTime) Scan(value any) error {
 		n.Time, n.Valid = time.Time{}, false
 		return nil
 	}
-	n.Valid = true
-	return convertAssign(&n.Time, value)
+	err := convertAssign(&n.Time, value)
+	n.Valid = err == nil
+	return err
 }
 
 // Value implements the [driver.Valuer] interface.
@@ -422,8 +426,9 @@ func (n *Null[T]) Scan(value any) error {
 		n.V, n.Valid = *new(T), false
 		return nil
 	}
-	n.Valid = true
-	return convertAssign(&n.V, value)
+	err := convertAssign(&n.V, value)
+	n.Valid = err == nil
+	return err
 }
 
 func (n Null[T]) Value() (driver.Value, error) {
@@ -588,7 +593,7 @@ func (dc *driverConn) expired(timeout time.Duration) bool {
 	if timeout <= 0 {
 		return false
 	}
-	return dc.createdAt.Add(timeout).Before(nowFunc())
+	return dc.createdAt.Add(timeout).Before(time.Now())
 }
 
 // resetSession checks if the driver connection needs the
@@ -1144,7 +1149,7 @@ func (db *DB) connectionCleanerRunLocked(d time.Duration) (time.Duration, []*dri
 	if db.maxIdleTime > 0 {
 		// As freeConn is ordered by returnedAt process
 		// in reverse order to minimise the work needed.
-		idleSince := nowFunc().Add(-db.maxIdleTime)
+		idleSince := time.Now().Add(-db.maxIdleTime)
 		last := len(db.freeConn) - 1
 		for i := last; i >= 0; i-- {
 			c := db.freeConn[i]
@@ -1169,7 +1174,7 @@ func (db *DB) connectionCleanerRunLocked(d time.Duration) (time.Duration, []*dri
 	}
 
 	if db.maxLifetime > 0 {
-		expiredSince := nowFunc().Add(-db.maxLifetime)
+		expiredSince := time.Now().Add(-db.maxLifetime)
 		for i := 0; i < len(db.freeConn); i++ {
 			c := db.freeConn[i]
 			if c.createdAt.Before(expiredSince) {
@@ -1290,8 +1295,8 @@ func (db *DB) openNewConnection(ctx context.Context) {
 	}
 	dc := &driverConn{
 		db:         db,
-		createdAt:  nowFunc(),
-		returnedAt: nowFunc(),
+		createdAt:  time.Now(),
+		returnedAt: time.Now(),
 		ci:         ci,
 	}
 	if db.putConnDBLocked(dc, err) {
@@ -1363,7 +1368,7 @@ func (db *DB) conn(ctx context.Context, strategy connReuseStrategy) (*driverConn
 		db.waitCount++
 		db.mu.Unlock()
 
-		waitStart := nowFunc()
+		waitStart := time.Now()
 
 		// Timeout the connection request with the context.
 		select {
@@ -1439,8 +1444,8 @@ func (db *DB) conn(ctx context.Context, strategy connReuseStrategy) (*driverConn
 	db.mu.Lock()
 	dc := &driverConn{
 		db:         db,
-		createdAt:  nowFunc(),
-		returnedAt: nowFunc(),
+		createdAt:  time.Now(),
+		returnedAt: time.Now(),
 		ci:         ci,
 		inUse:      true,
 	}
@@ -1501,7 +1506,7 @@ func (db *DB) putConn(dc *driverConn, err error, resetSession bool) {
 		db.lastPut[dc] = stack()
 	}
 	dc.inUse = false
-	dc.returnedAt = nowFunc()
+	dc.returnedAt = time.Now()
 
 	for _, fn := range dc.onPut {
 		fn()
@@ -1979,7 +1984,7 @@ type Conn struct {
 	// closemu prevents the connection from closing while there
 	// is an active query. It is held for read during queries
 	// and exclusively during close.
-	closemu sync.RWMutex
+	closemu closingMutex
 
 	// dc is owned until close, at which point
 	// it's returned to the connection pool.
@@ -2169,7 +2174,7 @@ type Tx struct {
 	// closemu prevents the transaction from closing while there
 	// is an active query. It is held for read during queries
 	// and exclusively during close.
-	closemu sync.RWMutex
+	closemu closingMutex
 
 	// dc is owned exclusively until Commit or Rollback, at which point
 	// it's returned with putConn.
@@ -2606,7 +2611,7 @@ type Stmt struct {
 	query     string // that created the Stmt
 	stickyErr error  // if non-nil, this error is returned for all operations
 
-	closemu sync.RWMutex // held exclusively during close, for read otherwise.
+	closemu closingMutex // held exclusively during close, for read otherwise.
 
 	// If Stmt is prepared on a Tx or Conn then cg is present and will
 	// only ever grab a connection from cg.
@@ -2940,7 +2945,7 @@ type Rows struct {
 	// and exclusively during close.
 	//
 	// closemu guards lasterr and closed.
-	closemu sync.RWMutex
+	closemu closingMutex
 	lasterr error // non-nil only if closed is true
 	closed  bool
 
@@ -2959,10 +2964,16 @@ type Rows struct {
 	// expected not to be called concurrently.
 	hitEOF bool
 
+	// nextCalled is set by the first call to Next.
+	nextCalled bool
+
 	// lastcols is only used in Scan, Next, and NextResultSet which are expected
 	// not to be called concurrently.
 	lastcols []driver.Value
 
+	// numCols is the number of columns, and is initialized by the first Next call.
+	numCols int
+
 	// raw is a buffer for RawBytes that persists between Scan calls.
 	// This is used when the driver returns a mismatched type that requires
 	// a cloning allocation. For example, if the driver returns a *string and
@@ -3037,9 +3048,11 @@ func (rs *Rows) Next() bool {
 	}
 
 	var doClose, ok bool
-	withLock(rs.closemu.RLocker(), func() {
+	func() {
+		rs.closemu.RLock()
+		defer rs.closemu.RUnlock()
 		doClose, ok = rs.nextLocked()
-	})
+	}()
 	if doClose {
 		rs.Close()
 	}
@@ -3059,11 +3072,20 @@ func (rs *Rows) nextLocked() (doClose, ok bool) {
 	rs.dc.Lock()
 	defer rs.dc.Unlock()
 
-	if rs.lastcols == nil {
-		rs.lastcols = make([]driver.Value, len(rs.rowsi.Columns()))
+	if !rs.nextCalled {
+		rs.numCols = len(rs.rowsi.Columns())
+		rs.nextCalled = true
+	}
+
+	if rscan, ok := rs.rowsi.(driver.RowsColumnScanner); ok {
+		rs.lasterr = rscan.NextRow()
+	} else {
+		if rs.lastcols == nil {
+			rs.lastcols = make([]driver.Value, rs.numCols)
+		}
+		rs.lasterr = rs.rowsi.Next(rs.lastcols)
 	}
 
-	rs.lasterr = rs.rowsi.Next(rs.lastcols)
 	if rs.lasterr != nil {
 		// Close the connection if there is a driver error.
 		if rs.lasterr != io.EOF {
@@ -3111,6 +3133,7 @@ func (rs *Rows) NextResultSet() bool {
 		return false
 	}
 
+	rs.nextCalled = false
 	rs.lastcols = nil
 	nextResultSet, ok := rs.rowsi.(driver.RowsNextResultSet)
 	if !ok {
@@ -3315,9 +3338,11 @@ func rowsColumnInfoSetupConnLocked(rowsi driver.Rows) []*ColumnType {
 //	*uint, *uint8, *uint16, *uint32, *uint64
 //	*bool
 //	*float32, *float64
-//	*interface{}
+//	*any
 //	*RawBytes
 //	*Rows (cursor value)
+//	*time.Time
+//	*uuid.UUID
 //	any type implementing Scanner (see Scanner docs)
 //
 // In the most simple case, if the type of the value from the source
@@ -3340,7 +3365,7 @@ func rowsColumnInfoSetupConnLocked(rowsi driver.Rows) []*ColumnType {
 // using an argument of type [*RawBytes] instead; see the documentation
 // for [RawBytes] for restrictions on its use.
 //
-// If an argument has type *interface{}, Scan copies the value
+// If an argument has type *any, Scan copies the value
 // provided by the underlying driver without conversion. When scanning
 // from a source value of type []byte to *interface{}, a copy of the
 // slice is made and the caller owns the result.
@@ -3349,6 +3374,10 @@ func rowsColumnInfoSetupConnLocked(rowsi driver.Rows) []*ColumnType {
 // *time.Time, *interface{}, *string, or *[]byte. When converting to
 // the latter two, [time.RFC3339Nano] is used.
 //
+// Source values of type string and byte may be scanned into
+// values of type [*uuid.UUID]. The source may contain the string
+// representation of a UUID, or a 16-byte []byte.
+//
 // Source values of type bool may be scanned into types *bool,
 // *interface{}, *string, *[]byte, or [*RawBytes].
 //
@@ -3380,6 +3409,11 @@ func (rs *Rows) Scan(dest ...any) error {
 	return err
 }
 
+// rowsScanContext is used to pass a *Rows through ScanColumn into ConvertAssign.
+type rowsScanContext struct {
+	rs *Rows
+}
+
 func (rs *Rows) scanLocked(dest ...any) error {
 	if rs.lasterr != nil && rs.lasterr != io.EOF {
 		return rs.lasterr
@@ -3388,11 +3422,26 @@ func (rs *Rows) scanLocked(dest ...any) error {
 		return rs.lasterrOrErrLocked(errRowsClosed)
 	}
 
-	if rs.lastcols == nil {
+	if !rs.nextCalled {
 		return errors.New("sql: Scan called without calling Next")
 	}
-	if len(dest) != len(rs.lastcols) {
-		return fmt.Errorf("sql: expected %d destination arguments in Scan, not %d", len(rs.lastcols), len(dest))
+	if len(dest) != rs.numCols {
+		return fmt.Errorf("sql: expected %d destination arguments in Scan, not %d", rs.numCols, len(dest))
+	}
+
+	if rscan, ok := rs.rowsi.(driver.RowsColumnScanner); ok {
+		// Lock the driver connection before calling the driver interface
+		// rowsi to prevent a Tx from rolling back the connection at the same time.
+		rs.dc.Lock()
+		defer rs.dc.Unlock()
+
+		for i, d := range dest {
+			scanCtx := driver.ScanContext(internal.NewScanContext(rs))
+			if err := rscan.ScanColumn(scanCtx, i, d); err != nil {
+				return fmt.Errorf(`sql: Scan error on column index %d, name %q: %w`, i, rs.rowsi.Columns()[i], err)
+			}
+		}
+		return nil
 	}
 
 	for i, sv := range rs.lastcols {

package/bin/go/src/debug/buildinfo/buildinfo.go

@@ -458,11 +458,6 @@ func (x *elfExe) DataStart() (uint64, uint64) {
 			return s.Addr, s.Size
 		}
 	}
-	for _, p := range x.f.Progs {
-		if p.Type == elf.PT_LOAD && p.Flags&(elf.PF_X|elf.PF_W) == elf.PF_W {
-			return p.Vaddr, p.Memsz
-		}
-	}
 	return 0, 0
 }
 
@@ -543,14 +538,6 @@ func (x *machoExe) DataStart() (uint64, uint64) {
 			return sec.Addr, sec.Size
 		}
 	}
-	// Try the first non-empty writable segment.
-	const RW = 3
-	for _, load := range x.f.Loads {
-		seg, ok := load.(*macho.Segment)
-		if ok && seg.Addr != 0 && seg.Filesz != 0 && seg.Prot == RW && seg.Maxprot == RW {
-			return seg.Addr, seg.Memsz
-		}
-	}
 	return 0, 0
 }