@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/os/signal/signal.go

@@ -54,6 +54,10 @@ func cancel(sigs []os.Signal, action func(int)) {
 	defer handlers.Unlock()
 
 	remove := func(n int) {
+		if n < 0 {
+			return
+		}
+
 		var zerohandler handler
 
 		for c, h := range handlers.m {
@@ -127,19 +131,27 @@ func Notify(c chan<- os.Signal, sig ...os.Signal) {
 	handlers.Lock()
 	defer handlers.Unlock()
 
-	h := handlers.m[c]
-	if h == nil {
-		if handlers.m == nil {
-			handlers.m = make(map[chan<- os.Signal]*handler)
+	// Lazily create the handler. If all of the signals are bogus there is
+	// no need to install a handler at all.
+	getHandler := func() *handler {
+		h := handlers.m[c]
+		if h == nil {
+			if handlers.m == nil {
+				handlers.m = make(map[chan<- os.Signal]*handler)
+			}
+			h = new(handler)
+			handlers.m[c] = h
 		}
-		h = new(handler)
-		handlers.m[c] = h
+
+		return h
 	}
 
 	add := func(n int) {
 		if n < 0 {
 			return
 		}
+
+		h := getHandler()
 		if !h.want(n) {
 			h.set(n)
 			if handlers.ref[n] == 0 {

package/bin/go/src/os/statat_unix.go

@@ -13,7 +13,11 @@ import (
 func (f *File) lstatatNolog(name string) (FileInfo, error) {
 	var fs fileStat
 	if err := f.pfd.Fstatat(name, &fs.sys, unix.AT_SYMLINK_NOFOLLOW); err != nil {
-		return nil, f.wrapErr("fstatat", err)
+		err = f.wrapErr("fstatat", err)
+		if pe, ok := err.(*PathError); ok {
+			pe.Path = pe.Path + string(PathSeparator) + name
+		}
+		return nil, err
 	}
 	fillFileStatFromSys(&fs, name)
 	return &fs, nil

package/bin/go/src/path/filepath/path.go

@@ -463,6 +463,10 @@ func Base(path string) string {
 // If the path is empty, Dir returns ".".
 // If the path consists entirely of separators, Dir returns a single separator.
 // The returned path does not end in a separator unless it is the root directory.
+//
+// On Windows, given a volume-only name such as "C:", Dir returns "C:.",
+// the current directory on drive C. To obtain the drive's root "C:\",
+// use [VolumeName] combined with a separator.
 func Dir(path string) string {
 	return filepathlite.Dir(path)
 }

package/bin/go/src/reflect/asm_s390x.s

@@ -32,13 +32,8 @@ TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$304
 	ADD	$LOCAL_REGARGS, R15, R10 // spillArgs using R10
 	BL	runtime·spillArgs(SB)
 	MOVD	R12, 32(R15) // save context reg R12 > args of moveMakeFuncArgPtrs < LOCAL_REGARGS
-#ifdef GOEXPERIMENT_regabiargs
 	MOVD	R12, R2
 	MOVD	R10, R3
-#else
-	MOVD	R12, 8(R15)
-	MOVD	R10, 16(R15)
-#endif
 	BL	·moveMakeFuncArgPtrs<ABIInternal>(SB)
 	MOVD	32(R15), R12 // restore context reg R12
 	MOVD	R12, 8(R15)
@@ -63,13 +58,8 @@ TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$304
 	ADD	$LOCAL_REGARGS, R15, R10 // spillArgs using R10
 	BL	runtime·spillArgs(SB)
 	MOVD	R12, 32(R15) // save context reg R12 > args of moveMakeFuncArgPtrs < LOCAL_REGARGS
-#ifdef GOEXPERIMENT_regabiargs
 	MOVD	R12, R2
 	MOVD	R10, R3
-#else
-	MOVD	R12, 8(R15)
-	MOVD	R10, 16(R15)
-#endif
 	BL	·moveMakeFuncArgPtrs<ABIInternal>(SB)
 	MOVD	32(R15), R12 // restore context reg R12
 	MOVD	R12, 8(R15)

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

@@ -29,14 +29,14 @@ func rangeNum[T int8 | int16 | int32 | int64 | int |
 }
 
 // Seq returns an iter.Seq[Value] that loops over the elements of v.
-// If v's kind is Func, it must be a function that has no results and
+// If v's kind is [Func], it must be a function that has no results and
 // that takes a single argument of type func(T) bool for some type T.
-// If v's kind is Pointer, the pointer element type must have kind Array.
-// Otherwise v's kind must be Int, Int8, Int16, Int32, Int64,
-// Uint, Uint8, Uint16, Uint32, Uint64, Uintptr,
-// Array, Chan, Map, Slice, or String.
+// If v's kind is [Pointer], the pointer element type must have kind [Array].
+// Otherwise v's kind must be [Int], [Int8], [Int16], [Int32], [Int64],
+// [Uint], [Uint8], [Uint16], [Uint32], [Uint64], [Uintptr],
+// [Array], [Chan], [Map], [Slice], or [String].
 func (v Value) Seq() iter.Seq[Value] {
-	if canRangeFunc(v.abiType()) {
+	if canRangeFunc(v.abiType(), 1) {
 		return func(yield func(Value) bool) {
 			rf := MakeFunc(v.Type().In(0), func(in []Value) []Value {
 				return []Value{ValueOf(yield(in[0]))}
@@ -68,12 +68,12 @@ func (v Value) Seq() iter.Seq[Value] {
 	case Uintptr:
 		return rangeNum[uintptr](v.Uint(), v.Type())
 	case Pointer:
-		if v.Elem().kind() != Array {
+		if v.Type().Elem().Kind() != Array {
 			break
 		}
+		n := v.Type().Elem().Len()
 		return func(yield func(Value) bool) {
-			v = v.Elem()
-			for i := range v.Len() {
+			for i := range n {
 				if !yield(ValueOf(i)) {
 					return
 				}
@@ -117,12 +117,12 @@ func (v Value) Seq() iter.Seq[Value] {
 }
 
 // Seq2 returns an iter.Seq2[Value, Value] that loops over the elements of v.
-// If v's kind is Func, it must be a function that has no results and
+// If v's kind is [Func], it must be a function that has no results and
 // that takes a single argument of type func(K, V) bool for some type K, V.
-// If v's kind is Pointer, the pointer element type must have kind Array.
-// Otherwise v's kind must be Array, Map, Slice, or String.
+// If v's kind is [Pointer], the pointer element type must have kind [Array].
+// Otherwise v's kind must be [Array], [Map], [Slice], or [String].
 func (v Value) Seq2() iter.Seq2[Value, Value] {
-	if canRangeFunc2(v.abiType()) {
+	if canRangeFunc(v.abiType(), 2) {
 		return func(yield func(Value, Value) bool) {
 			rf := MakeFunc(v.Type().In(0), func(in []Value) []Value {
 				return []Value{ValueOf(yield(in[0], in[1]))}

package/bin/go/src/reflect/makefunc.go

@@ -45,11 +45,12 @@ type makeFuncImpl struct {
 // The Examples section of the documentation includes an illustration
 // of how to use MakeFunc to build a swap function for different types.
 func MakeFunc(typ Type, fn func(args []Value) (results []Value)) Value {
+	t := typ.common()
+	typ = toType(t) // for #80332, ensure t's exported methods are not shadowed
 	if typ.Kind() != Func {
 		panic("reflect: call of MakeFunc with non-Func type")
 	}
 
-	t := typ.common()
 	ftyp := (*funcType)(unsafe.Pointer(t))
 
 	code := abi.FuncPCABI0(makeFuncStub)

package/bin/go/src/reflect/map.go

@@ -6,6 +6,7 @@ package reflect
 
 import (
 	"internal/abi"
+	"internal/goexperiment"
 	"internal/race"
 	"internal/runtime/maps"
 	"internal/runtime/sys"
@@ -29,6 +30,8 @@ func (t *rtype) Key() Type {
 func MapOf(key, elem Type) Type {
 	ktyp := key.common()
 	etyp := elem.common()
+	key = toType(ktyp)
+	elem = toType(etyp)
 
 	if ktyp.Equal == nil {
 		panic("reflect.MapOf: invalid key type " + stringFor(ktyp))
@@ -50,7 +53,7 @@ func MapOf(key, elem Type) Type {
 		}
 	}
 
-	group, slot := groupAndSlotOf(key, elem)
+	group := groupOf(key, elem)
 
 	// Make a map type.
 	// Note: flag values must match those used in the TMAP case
@@ -67,8 +70,25 @@ func MapOf(key, elem Type) Type {
 		return typehash(ktyp, p, seed)
 	}
 	mt.GroupSize = mt.Group.Size()
-	mt.SlotSize = slot.Size()
-	mt.ElemOff = slot.Field(1).Offset
+	if goexperiment.MapSplitGroup {
+		// Split layout: field 1 is keys array, field 2 is elems array.
+		mt.KeysOff = group.Field(1).Offset
+		mt.KeyStride = group.Field(1).Type.Elem().Size()
+		mt.ElemsOff = group.Field(2).Offset
+		mt.ElemStride = group.Field(2).Type.Elem().Size()
+		mt.ElemOff = 0
+	} else {
+		// Interleaved layout: field 1 is slots array.
+		// KeyStride = ElemStride = slot stride.
+		// ElemsOff = slots offset + elem offset within slot.
+		slot := group.Field(1).Type.Elem()
+		slotSize := slot.Size()
+		mt.KeysOff = group.Field(1).Offset
+		mt.KeyStride = slotSize
+		mt.ElemsOff = group.Field(1).Offset + slot.Field(1).Offset
+		mt.ElemStride = slotSize
+		mt.ElemOff = slot.Field(1).Offset
+	}
 	mt.Flags = 0
 	if needKeyUpdate(ktyp) {
 		mt.Flags |= abi.MapNeedKeyUpdate
@@ -79,7 +99,7 @@ func MapOf(key, elem Type) Type {
 	if ktyp.Size_ > abi.MapMaxKeyBytes {
 		mt.Flags |= abi.MapIndirectKey
 	}
-	if etyp.Size_ > abi.MapMaxKeyBytes {
+	if etyp.Size_ > abi.MapMaxElemBytes {
 		mt.Flags |= abi.MapIndirectElem
 	}
 	mt.PtrToThis = 0
@@ -88,15 +108,7 @@ func MapOf(key, elem Type) Type {
 	return ti.(Type)
 }
 
-func groupAndSlotOf(ktyp, etyp Type) (Type, Type) {
-	// type group struct {
-	//     ctrl uint64
-	//     slots [abi.MapGroupSlots]struct {
-	//         key  keyType
-	//         elem elemType
-	//     }
-	// }
-
+func groupOf(ktyp, etyp Type) Type {
 	if ktyp.Size() > abi.MapMaxKeyBytes {
 		ktyp = PointerTo(ktyp)
 	}
@@ -104,7 +116,39 @@ func groupAndSlotOf(ktyp, etyp Type) (Type, Type) {
 		etyp = PointerTo(etyp)
 	}
 
-	fields := []StructField{
+	if goexperiment.MapSplitGroup {
+		// Split layout (KKKKVVVV):
+		// type group struct {
+		//     ctrl  uint64
+		//     keys  [abi.MapGroupSlots]keyType
+		//     elems [abi.MapGroupSlots]elemType
+		// }
+		fields := []StructField{
+			{
+				Name: "Ctrl",
+				Type: TypeFor[uint64](),
+			},
+			{
+				Name: "Keys",
+				Type: ArrayOf(abi.MapGroupSlots, ktyp),
+			},
+			{
+				Name: "Elems",
+				Type: ArrayOf(abi.MapGroupSlots, etyp),
+			},
+		}
+		return StructOf(fields)
+	}
+
+	// Interleaved slot layout (KVKVKVKV):
+	// type group struct {
+	//     ctrl  uint64
+	//     slots [abi.MapGroupSlots]struct {
+	//         key  keyType
+	//         elem elemType
+	//     }
+	// }
+	slotFields := []StructField{
 		{
 			Name: "Key",
 			Type: ktyp,
@@ -114,9 +158,9 @@ func groupAndSlotOf(ktyp, etyp Type) (Type, Type) {
 			Type: etyp,
 		},
 	}
-	slot := StructOf(fields)
+	slot := StructOf(slotFields)
 
-	fields = []StructField{
+	fields := []StructField{
 		{
 			Name: "Ctrl",
 			Type: TypeFor[uint64](),
@@ -126,8 +170,7 @@ func groupAndSlotOf(ktyp, etyp Type) (Type, Type) {
 			Type: ArrayOf(abi.MapGroupSlots, slot),
 		},
 	}
-	group := StructOf(fields)
-	return group, slot
+	return StructOf(fields)
 }
 
 var stringType = rtypeOf("")

package/bin/go/src/reflect/type.go

@@ -906,42 +906,26 @@ func (t *rtype) CanSeq() bool {
 	case Int8, Int16, Int32, Int64, Int, Uint8, Uint16, Uint32, Uint64, Uint, Uintptr, Array, Slice, Chan, String, Map:
 		return true
 	case Func:
-		return canRangeFunc(&t.t)
+		return canRangeFunc(&t.t, 1)
 	case Pointer:
 		return t.Elem().Kind() == Array
 	}
 	return false
 }
 
-func canRangeFunc(t *abi.Type) bool {
-	if t.Kind() != abi.Func {
-		return false
-	}
-	f := t.FuncType()
-	if f.InCount != 1 || f.OutCount != 0 {
-		return false
-	}
-	y := f.In(0)
-	if y.Kind() != abi.Func {
-		return false
-	}
-	yield := y.FuncType()
-	return yield.InCount == 1 && yield.OutCount == 1 && yield.Out(0).Kind() == abi.Bool
-}
-
 func (t *rtype) CanSeq2() bool {
 	switch t.Kind() {
 	case Array, Slice, String, Map:
 		return true
 	case Func:
-		return canRangeFunc2(&t.t)
+		return canRangeFunc(&t.t, 2)
 	case Pointer:
 		return t.Elem().Kind() == Array
 	}
 	return false
 }
 
-func canRangeFunc2(t *abi.Type) bool {
+func canRangeFunc(t *abi.Type, seq uint16) bool {
 	if t.Kind() != abi.Func {
 		return false
 	}
@@ -954,7 +938,7 @@ func canRangeFunc2(t *abi.Type) bool {
 		return false
 	}
 	yield := y.FuncType()
-	return yield.InCount == 2 && yield.OutCount == 1 && yield.Out(0).Kind() == abi.Bool
+	return yield.InCount == seq && yield.OutCount == 1 && yield.Out(0).Kind() == abi.Bool && toRType(yield.Out(0)).PkgPath() == ""
 }
 
 func (t *rtype) Fields() iter.Seq[StructField] {
@@ -1726,26 +1710,18 @@ func haveIdenticalUnderlyingType(T, V *abi.Type, cmpTags bool) bool {
 	return false
 }
 
-// typelinks is implemented in package runtime.
-// It returns a slice of the sections in each module,
-// and a slice of *rtype offsets in each module.
-//
-// The types in each module are sorted by string. That is, the first
-// two linked types of the first module are:
-//
-//	d0 := sections[0]
-//	t1 := (*rtype)(add(d0, offset[0][0]))
-//	t2 := (*rtype)(add(d0, offset[0][1]))
-//
-// and
-//
-//	t1.String() < t2.String()
+// compiledTypelinks is implemented in package runtime.
+// It returns the types defined by the first module,
+// and a slice of types defined in any other modules.
+// Each slice of types is sorted by string.
 //
 // Note that strings are not unique identifiers for types:
 // there can be more than one with a given string.
 // Only types we might want to look up are included:
 // pointers, channels, maps, slices, and arrays.
-func typelinks() (sections []unsafe.Pointer, offset [][]int32)
+//
+//go:linknamestd compiledTypelinks
+func compiledTypelinks() ([]*abi.Type, [][]*abi.Type)
 
 // rtypeOff should be an internal detail,
 // but widely used packages access it using linkname.
@@ -1760,7 +1736,7 @@ func rtypeOff(section unsafe.Pointer, off int32) *abi.Type {
 	return (*abi.Type)(add(section, uintptr(off), "sizeof(rtype) > 0"))
 }
 
-// typesByString returns the subslice of typelinks() whose elements have
+// typesByString returns all known types whose elements have
 // the given string representation.
 // It may be empty (no known types with that string) or may have
 // multiple elements (multiple types with that string).
@@ -1776,19 +1752,17 @@ func rtypeOff(section unsafe.Pointer, off int32) *abi.Type {
 //
 //go:linkname typesByString
 func typesByString(s string) []*abi.Type {
-	sections, offset := typelinks()
+	first, rest := compiledTypelinks()
 	var ret []*abi.Type
 
-	for offsI, offs := range offset {
-		section := sections[offsI]
-
+	searchTypes := func(types []*abi.Type) {
 		// We are looking for the first index i where the string becomes >= s.
 		// This is a copy of sort.Search, with f(h) replaced by (*typ[h].String() >= s).
-		i, j := 0, len(offs)
+		i, j := 0, len(types)
 		for i < j {
 			h := int(uint(i+j) >> 1) // avoid overflow when computing h
 			// i ≤ h < j
-			if !(stringFor(rtypeOff(section, offs[h])) >= s) {
+			if !(stringFor(types[h]) >= s) {
 				i = h + 1 // preserves f(i-1) == false
 			} else {
 				j = h // preserves f(j) == true
@@ -1799,14 +1773,20 @@ func typesByString(s string) []*abi.Type {
 		// Having found the first, linear scan forward to find the last.
 		// We could do a second binary search, but the caller is going
 		// to do a linear scan anyway.
-		for j := i; j < len(offs); j++ {
-			typ := rtypeOff(section, offs[j])
+		for j := i; j < len(types); j++ {
+			typ := types[j]
 			if stringFor(typ) != s {
 				break
 			}
 			ret = append(ret, typ)
 		}
 	}
+
+	searchTypes(first)
+	for _, r := range rest {
+		searchTypes(r)
+	}
+
 	return ret
 }
 
@@ -1841,6 +1821,7 @@ var funcLookupCache struct {
 // If t's size is equal to or exceeds this limit, ChanOf panics.
 func ChanOf(dir ChanDir, t Type) Type {
 	typ := t.common()
+	t = toType(typ) // for #80332, ensure t's exported methods are not shadowed
 
 	// Look in cache.
 	ckey := cacheKey{Chan, typ, nil, uintptr(dir)}
@@ -1932,7 +1913,7 @@ func initFuncTypes(n int) Type {
 // panics if the in[len(in)-1] does not represent a slice and variadic is
 // true.
 func FuncOf(in, out []Type, variadic bool) Type {
-	if variadic && (len(in) == 0 || in[len(in)-1].Kind() != Slice) {
+	if variadic && (len(in) == 0 || toType(in[len(in)-1].common()).Kind() != Slice) {
 		panic("reflect.FuncOf: last arg of variadic func must be slice")
 	}
 
@@ -2148,6 +2129,7 @@ func emitGCMask(out []byte, base uintptr, typ *abi.Type, n uintptr) {
 // For example, if t represents int, SliceOf(t) represents []int.
 func SliceOf(t Type) Type {
 	typ := t.common()
+	t = toType(typ) // for #80332, ensure t's exported methods are not shadowed
 
 	// Look in cache.
 	ckey := cacheKey{Slice, typ, nil, 0}
@@ -2303,7 +2285,7 @@ func StructOf(fields []StructField) Type {
 			if pkgpath == "" {
 				pkgpath = fpkgpath
 			} else if pkgpath != fpkgpath {
-				panic("reflect.Struct: fields with different PkgPath " + pkgpath + " and " + fpkgpath)
+				panic("reflect.StructOf: fields with different PkgPath " + pkgpath + " and " + fpkgpath)
 			}
 		}
 
@@ -2580,6 +2562,9 @@ func StructOf(fields []StructField) Type {
 		// space to store it.
 		typ.TFlag |= abi.TFlagGCMaskOnDemand
 		typ.GCData = (*byte)(unsafe.Pointer(new(uintptr)))
+		if runtime.GOOS == "aix" {
+			typ.GCData = adjustAIXGCData(typ.GCData)
+		}
 	}
 
 	typ.Equal = nil
@@ -2673,6 +2658,7 @@ func ArrayOf(length int, elem Type) Type {
 	}
 
 	typ := elem.common()
+	elem = toType(typ) // for #80332, ensure elem's exported methods are not shadowed
 
 	// Look in cache.
 	ckey := cacheKey{Array, typ, nil, uintptr(length)}
@@ -2745,6 +2731,9 @@ func ArrayOf(length int, elem Type) Type {
 		// space to store it.
 		array.TFlag |= abi.TFlagGCMaskOnDemand
 		array.GCData = (*byte)(unsafe.Pointer(new(uintptr)))
+		if runtime.GOOS == "aix" {
+			array.GCData = adjustAIXGCData(array.GCData)
+		}
 	}
 
 	etyp := typ
@@ -2776,6 +2765,34 @@ func ArrayOf(length int, elem Type) Type {
 	return ti.(Type)
 }
 
+// adjustAIXGCData adjusts the GCData field pointer for AIX.
+// See runtime.getGCMaskOnDemand.
+func adjustAIXGCData(addr *byte) *byte {
+	adjusted := adjustAIXGCDataForRuntime(addr)
+	if adjusted != addr {
+		pinAIXGCDataMu.Lock()
+		pinAIXGCData = append(pinAIXGCData, addr)
+		pinAIXGCDataMu.Unlock()
+	}
+	return adjusted
+}
+
+// adjustAIXGCDataForRuntime adjusts the GCData field pointer
+// as the runtime requires for AIX. See runtime.getGCMaskOnDemand.
+//
+//go:linknamestd adjustAIXGCDataForRuntime
+//go:noescape
+func adjustAIXGCDataForRuntime(*byte) *byte
+
+// pinAIXGCDataMu proects pinAIXGCData.
+var pinAIXGCDataMu sync.Mutex
+
+// pinAIXGCData keeps the actual GCData pointer alive on AIX.
+// On AIX we need to use adjustAIXGCData to convert the GC pointer
+// to the value that the runtime expects. That means that the rtype
+// no longer refers to the original pointer. This slice keeps it alive.
+var pinAIXGCData []*byte
+
 func appendVarint(x []byte, v uintptr) []byte {
 	for ; v >= 0x80; v >>= 7 {
 		x = append(x, byte(v|0x80))