@ttsc/win32-arm64 0.33.0 → 0.34.0

package/bin/go/src/runtime/type.go

@@ -352,15 +352,16 @@ func resolveTypeOff(ptrInModule unsafe.Pointer, off typeOff) *_type {
 		}
 		return (*_type)(res)
 	}
-	if t := md.typemap[off]; t != nil {
+	res := md.types + uintptr(off)
+	resType := (*_type)(unsafe.Pointer(res))
+	if t := md.typemap[resType]; t != nil {
 		return t
 	}
-	res := md.types + uintptr(off)
 	if res > md.etypes {
 		println("runtime: typeOff", hex(off), "out of range", hex(md.types), "-", hex(md.etypes))
 		throw("runtime: type offset out of range")
 	}
-	return (*_type)(unsafe.Pointer(res))
+	return resType
 }
 
 func (t rtype) typeOff(off typeOff) *_type {
@@ -435,22 +436,23 @@ func pkgPath(n name) string {
 // typelinksinit scans the types from extra modules and builds the
 // moduledata typemap used to de-duplicate type pointers.
 func typelinksinit() {
+	lockInit(&moduleToTypelinksLock, lockRankTypelinks)
+
 	if firstmoduledata.next == nil {
 		return
 	}
-	typehash := make(map[uint32][]*_type, len(firstmoduledata.typelinks))
 
 	modules := activeModules()
 	prev := modules[0]
+	prevTypelinks := moduleTypelinks(modules[0])
+	typehash := make(map[uint32][]*_type, len(prevTypelinks))
 	for _, md := range modules[1:] {
 		// Collect types from the previous module into typehash.
 	collect:
-		for _, tl := range prev.typelinks {
-			var t *_type
-			if prev.typemap == nil {
-				t = (*_type)(unsafe.Pointer(prev.types + uintptr(tl)))
-			} else {
-				t = prev.typemap[typeOff(tl)]
+		for _, tl := range prevTypelinks {
+			t := tl
+			if prev.typemap != nil {
+				t = prev.typemap[tl]
 			}
 			// Add to typehash if not seen before.
 			tlist := typehash[t.Hash]
@@ -462,28 +464,96 @@ func typelinksinit() {
 			typehash[t.Hash] = append(tlist, t)
 		}
 
+		mdTypelinks := moduleTypelinks(md)
+
 		if md.typemap == nil {
 			// If any of this module's typelinks match a type from a
 			// prior module, prefer that prior type by adding the offset
 			// to this module's typemap.
-			tm := make(map[typeOff]*_type, len(md.typelinks))
+			tm := make(map[*_type]*_type, len(mdTypelinks))
 			pinnedTypemaps = append(pinnedTypemaps, tm)
 			md.typemap = tm
-			for _, tl := range md.typelinks {
-				t := (*_type)(unsafe.Pointer(md.types + uintptr(tl)))
+			for _, t := range mdTypelinks {
+				set := t
 				for _, candidate := range typehash[t.Hash] {
 					seen := map[_typePair]struct{}{}
 					if typesEqual(t, candidate, seen) {
-						t = candidate
+						set = candidate
 						break
 					}
 				}
-				md.typemap[typeOff(tl)] = t
+				md.typemap[t] = set
 			}
 		}
 
 		prev = md
+		prevTypelinks = mdTypelinks
+	}
+}
+
+// moduleToTypelinks maps from moduledata to typelinks.
+// We build this lazily as needed, since most programs do not need it.
+var (
+	moduleToTypelinks     map[*moduledata][]*_type
+	moduleToTypelinksLock mutex
+)
+
+// moduleTypelinks takes a moduledata and returns the type
+// descriptors that the reflect package needs to know about.
+// These are the typelinks. They are the types that the user
+// can construct. This is used to ensure that we use a unique
+// type descriptor for all types. The returned types are sorted
+// by type string; the sorting is done by the linker.
+// This slice is constructed as needed.
+func moduleTypelinks(md *moduledata) []*_type {
+	lock(&moduleToTypelinksLock)
+	if raceenabled {
+		raceacquire(unsafe.Pointer(&moduleToTypelinksLock))
+	}
+
+	if typelinks, ok := moduleToTypelinks[md]; ok {
+		if raceenabled {
+			racerelease(unsafe.Pointer(&moduleToTypelinksLock))
+		}
+		unlock(&moduleToTypelinksLock)
+		return typelinks
+	}
+
+	// Allocate a very rough estimate of the number of types.
+	ret := make([]*_type, 0, md.typedesclen/(2*unsafe.Sizeof(_type{})))
+
+	td := md.types
+
+	// We have to increment by the pointer size to match the
+	// increment in cmd/link/internal/data.go createRelroSect
+	// in allocateDataSections.
+	//
+	// The linker doesn't do that increment when runtime.types
+	// has a non-zero size, but in that case the runtime.types
+	// symbol itself pushes the other symbols forward.
+	// So either way this increment is correct.
+	td += goarch.PtrSize
+
+	etypedesc := md.types + md.typedesclen
+	for td < etypedesc {
+		td = alignUp(td, goarch.PtrSize)
+
+		typ := (*_type)(unsafe.Pointer(td))
+		ret = append(ret, typ)
+
+		td += uintptr(typ.DescriptorSize())
+	}
+
+	if moduleToTypelinks == nil {
+		moduleToTypelinks = make(map[*moduledata][]*_type)
+	}
+	moduleToTypelinks[md] = ret
+
+	if raceenabled {
+		racerelease(unsafe.Pointer(&moduleToTypelinksLock))
 	}
+	unlock(&moduleToTypelinksLock)
+	return ret
 }
 
 type _typePair struct {

package/bin/go/src/runtime/utf8.go

@@ -57,10 +57,10 @@ func countrunes(s string) int {
 // If the string appears to be incomplete or decoding problems
 // are encountered (runeerror, k + 1) is returned to ensure
 // progress when decoderune is used to iterate over a string.
-func decoderune(s string, k int) (r rune, pos int) {
+func decoderune(s string, k uint) (r rune, pos uint) {
 	pos = k
 
-	if k >= len(s) {
+	if k >= uint(len(s)) {
 		return runeError, k + 1
 	}
 

package/bin/go/src/simd/archsimd/_gen/go.mod

@@ -1,8 +1,8 @@
 module simd/archsimd/_gen
 
-go 1.24
+go 1.25.0
 
 require (
-	golang.org/x/arch v0.20.0
+	golang.org/x/arch v0.26.0
 	gopkg.in/yaml.v3 v3.0.1
 )

package/bin/go/src/simd/archsimd/_gen/go.sum

@@ -1,5 +1,5 @@
-golang.org/x/arch v0.20.0 h1:dx1zTU0MAE98U+TQ8BLl7XsJbgze2WnNKF/8tGp/Q6c=
-golang.org/x/arch v0.20.0/go.mod h1:bdwinDaKcfZUGpH09BB7ZmOfhalA8lQdzl62l8gGWsk=
+golang.org/x/arch v0.26.0 h1:jZ6dpec5haP/fUv1kLCbuJy6dnRrfX6iVK08lZBFpk4=
+golang.org/x/arch v0.26.0/go.mod h1:0X+GdSIP+kL5wPmpK7sdkEVTt2XoYP0cSjQSbZBwOi8=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

package/bin/go/src/simd/archsimd/_gen/main.go

@@ -14,14 +14,21 @@ import (
 	"strings"
 )
 
+const defaultLocalISA = "ISA_A64_xml_A_profile-2026-03_96/ISA_A64_xml_A_profile_2026-03_96-2026-03_rel" // ISA_A64_xml_A_profile-2025-06"
 const defaultXedPath = "$XEDPATH" + string(filepath.ListSeparator) + "./simdgen/xeddata" + string(filepath.ListSeparator) + "$HOME/xed/obj/dgen"
+const defaultArm64Path = "$ARM64_ISA_PATH" + string(filepath.ListSeparator) + "./simdgen/armdata" + string(filepath.ListSeparator) + "$HOME/Downloads/" + defaultLocalISA
 
 var (
 	flagTmplgen = flag.Bool("tmplgen", true, "run tmplgen generator")
 	flagSimdgen = flag.Bool("simdgen", true, "run simdgen generator")
+	flagWasmgen = flag.Bool("wasmgen", true, "run wasmgen generator")
+	flagMidway  = flag.Bool("midway", true, "run midway generator")
 
-	flagN       = flag.Bool("n", false, "dry run")
-	flagXedPath = flag.String("xedPath", defaultXedPath, "load XED datafile from `path`, which must be the XED obj/dgen directory")
+	flagN         = flag.Bool("n", false, "dry run")
+	flagXedPath   = flag.String("xedPath", defaultXedPath, "load XED datafile from `path`, which must be the XED obj/dgen directory")
+	flagArm64Path = flag.String("arm64Path", defaultArm64Path, "load ARM64 ISA XML definitions from `path`")
+
+	flagGoRoot = flag.String("goroot", "", "destination go dev tree for generated files")
 )
 
 var goRoot string
@@ -39,6 +46,12 @@ func main() {
 		*flagXedPath = os.ExpandEnv(defaultXedPath)
 	}
 
+	if *flagArm64Path == defaultArm64Path {
+		// In general we want the shell to do variable expansion, but for the
+		// default value we don't get that, so do it ourselves.
+		*flagArm64Path = os.ExpandEnv(defaultArm64Path)
+	}
+
 	var err error
 	goRoot, err = resolveGOROOT()
 	if err != nil {
@@ -46,18 +59,63 @@ func main() {
 		os.Exit(1)
 	}
 
+	if *flagSimdgen {
+		fmt.Fprintln(os.Stderr, "# This may take a few minutes...")
+	}
+
 	if *flagTmplgen {
 		doTmplgen()
 	}
-	if *flagSimdgen {
-		doSimdgen()
+
+	if *flagWasmgen || *flagSimdgen {
+		ssaGenPath := prettyPath(".", filepath.Join(goRoot, "src", "cmd", "compile", "internal", "ssa", "_gen"))
+
+		// If there is garbage in ssa/_gen/simdgenericOps.go, it can affect the merge in simdgen/wasmgen.
+		removeSimdGenericOps(ssaGenPath)
+
+		if *flagWasmgen {
+			doWasmgen()
+		}
+		if *flagSimdgen {
+			doSimdgen()
+		}
+		ssaGen(ssaGenPath)
 	}
+
+	if *flagMidway {
+		doMidway()
+	}
+}
+
+func removeSimdGenericOps(ssaGenPath string) {
+	ssaSimdGenericOps := filepath.Join(ssaGenPath, "simdgenericOps.go")
+	if _, err := os.Stat(ssaSimdGenericOps); err == nil {
+		if err = os.Remove(ssaSimdGenericOps); err != nil {
+			fmt.Fprintf(os.Stderr, "Failed to delete %s before regenerating it, %v\n", ssaSimdGenericOps, err)
+			os.Exit(1)
+		}
+	}
+}
+
+func ssaGen(ssaGenPath string) {
+	// simdgen produces SSA rule files, so update the SSA files
+	goRun("-C", ssaGenPath, ".")
+
+	fmt.Fprintln(os.Stderr, "# Compiler changed. Consider running \"go install cmd/compile\"")
 }
 
 func doTmplgen() {
 	goRun("-C", "tmplgen", ".")
 }
 
+func doWasmgen() {
+	goRun("-C", "wasmgen", ".")
+}
+
+func doMidway() {
+	goRun("-C", "midway", ".")
+}
+
 func doSimdgen() {
 	xedPath, err := resolveXEDPath(*flagXedPath)
 	if err != nil {
@@ -65,13 +123,20 @@ func doSimdgen() {
 		os.Exit(1)
 	}
 
-	// Regenerate the XED-derived SIMD files
-	goRun("-C", "simdgen", ".", "-o", "godefs", "-goroot", goRoot, "-xedPath", prettyPath("./simdgen", xedPath), "go.yaml", "types.yaml", "categories.yaml")
+	armPath, err := resolveARMPath(*flagArm64Path)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
 
-	// simdgen produces SSA rule files, so update the SSA files
-	goRun("-C", prettyPath(".", filepath.Join(goRoot, "src", "cmd", "compile", "internal", "ssa", "_gen")), ".")
+	goRun("-C", "simdgen", ".", "-o", "godefs", "-goroot", goRoot, "-arch", "arm64", "-arm64Path", prettyPath("./simdgen", armPath), "go_arm64.yaml", "types.yaml", "categories.yaml")
+
+	// Regenerate the XED-derived SIMD files
+	goRun("-C", "simdgen", ".", "-o", "godefs", "-goroot", goRoot, "-arch", "amd64", "-xedPath", prettyPath("./simdgen", xedPath), "go_amd64.yaml", "types.yaml", "categories.yaml")
 }
 
+// simdgen -o godefs -goroot goRoot -arm64Path $ARM64_ISA_PATH arm64/go.yaml arm64/categories.yaml types.yaml
+
 func resolveXEDPath(pathList string) (xedPath string, err error) {
 	for _, path := range filepath.SplitList(pathList) {
 		if path == "" {
@@ -85,19 +150,44 @@ func resolveXEDPath(pathList string) (xedPath string, err error) {
 	return "", fmt.Errorf("set $XEDPATH or -xedPath to the XED obj/dgen directory")
 }
 
+func resolveARMPath(pathList string) (armPath string, err error) {
+	for _, path := range filepath.SplitList(pathList) {
+		if path == "" {
+			// Probably an unknown shell variable. Ignore.
+			continue
+		}
+		if _, err := os.Stat(filepath.Join(path, "abs_advsimd.xml")); err == nil {
+			return filepath.Abs(path)
+		}
+	}
+	return "", fmt.Errorf("set $ARM64_ISA_PATH or -armPath to the ARM64 ISA specification directory")
+}
+
 func resolveGOROOT() (goRoot string, err error) {
-	cmd := exec.Command("go", "env", "GOROOT")
-	cmd.Stderr = os.Stderr
-	out, err := cmd.Output()
+	goRoot = *flagGoRoot
+	if goRoot != "" {
+		return
+	}
+	// Using the current compiler's goroot depends on a working dev compiler,
+	// which is not guaranteed.  Instead, assume
+	cwd, err := os.Getwd()
+	if err != nil {
+		return "", fmt.Errorf("Getwd error: %s", err)
+	}
+	goRoot, err = filepath.Abs(filepath.Join(cwd, "..", "..", "..", ".."))
 	if err != nil {
-		return "", fmt.Errorf("%s: %s", cmd, err)
+		return "", fmt.Errorf("Abs path error: %s", err)
 	}
-	goRoot = strings.TrimSuffix(string(out), "\n")
-	return goRoot, nil
+	_, err = os.Stat(filepath.Join(goRoot, "src", "simd", "archsimd", "_gen"))
+	if err != nil {
+		return "", fmt.Errorf("-goroot not specified and not run in src/simd/archsimd/_gen")
+	}
+
+	return
 }
 
 func goRun(args ...string) {
-	exe := filepath.Join(goRoot, "bin", "go")
+	exe := "go" // Use go on the path, not GOROOT.  GOROOT could be broken
 	cmd := exec.Command(exe, append([]string{"run"}, args...)...)
 	run(cmd)
 }
@@ -111,6 +201,7 @@ func run(cmd *exec.Cmd) {
 	}
 	if err := cmd.Run(); err != nil {
 		fmt.Fprintf(os.Stderr, "%s failed: %s\n", cmd, err)
+		os.Exit(1)
 	}
 }
 

package/bin/go/src/simd/archsimd/_gen/midway/comments.yaml

@@ -0,0 +1,151 @@
+# Common methods shared across various SIMD types
+.common_methods: &common_methods
+  Abs: "Abs returns the element-wise absolute value of x."
+  Add: "Add returns the element-wise sum of x and y."
+  AddSaturated: "AddSaturated returns the element-wise saturated sum of x and y."
+  And: "And returns the bitwise AND of x and y."
+  AndNot: "AndNot returns the bitwise AND NOT of x and y."
+  Average: "Average returns the element-wise average of x and y."
+  Div: "Div returns the element-wise quotient of x and y."
+  Equal: "Equal returns a mask indicating where x and y are equal."
+  Greater: "Greater returns a mask indicating where x is greater than y."
+  GreaterEqual: "GreaterEqual returns a mask indicating where x is greater than or equal to y."
+  Len: "Len returns the number of elements in the vector."
+  Less: "Less returns a mask indicating where x is less than y."
+  LessEqual: "LessEqual returns a mask indicating where x is less than or equal to y."
+  Masked: "Masked returns a new vector with elements from x where mask is true, and zero elsewhere."
+  Max: "Max returns the element-wise maximum of x and y."
+  IfElse: "IfElse returns a new vector with elements from x where mask is true, and y where mask is false."
+  Min: "Min returns the element-wise minimum of x and y."
+  Mul: "Mul returns the element-wise product of x and y."
+  MulAdd: "MulAdd returns x * y + z element-wise."
+  Neg: "Neg returns the element-wise negation of x."
+  Not: "Not returns the bitwise NOT of x."
+  NotEqual: "NotEqual returns a mask indicating where x and y are not equal."
+  Or: "Or returns the bitwise OR of x and y."
+  RotateAllLeft: "RotatesAllLeft rotates all elements left by y bits."
+  RotateAllRight: "RotatesAllRight rotates all elements right by y bits."
+  ShiftAllLeft: "ShiftAllLeft shifts all elements left by y bits."
+  ShiftAllRight: "ShiftAllRight shifts all elements right by y bits."
+  Sqrt: "Sqrt returns the element-wise square root of x."
+  Store: "Store stores the vector elements into the slice s."
+  StorePart: "StorePart stores a partial vector into the slice s and returns the number actually stored."
+  String: "String returns a string representation of the vector."
+  Sub: "Sub returns the element-wise difference of x and y."
+  SubSaturated: "SubSaturated returns the element-wise saturated difference of x and y."
+  ToMask: "ToMask returns a mask representation of the vector."
+  Xor: "Xor returns the bitwise XOR of x and y."
+
+  # Conversions
+  ConvertToFloat32: "ConvertToFloat32 converts the vector elements to float32."
+  ConvertToInt32: "ConvertToInt32 converts the vector elements to int32."
+  ConvertToUint8: "ConvertToUint8 converts the vector elements to uint8."
+  ConvertToUint16: "ConvertToUint16 converts the vector elements to uint16."
+  ConvertToUint32: "ConvertToUint32 converts the vector elements to uint32."
+  ConvertToUint64: "ConvertToUint64 converts the vector elements to uint64."
+  ConvertToInt8: "ConvertToInt8 converts the vector elements to int8."
+  ConvertToInt16: "ConvertToInt16 converts the vector elements to int16."
+  ConvertToInt64: "ConvertToInt64 converts the vector elements to int64."
+  ToBits: "ToBits reinterprets the vector bits as an unsigned integer vector."
+  BitsToInt8: "BitsToInt8 reinterprets the vector bits as an Int8s vector."
+  BitsToInt16: "BitsToInt16 reinterprets the vector bits as an Int16s vector."
+  BitsToInt32: "BitsToInt32 reinterprets the vector bits as an Int32s vector."
+  BitsToInt64: "BitsToInt64 reinterprets the vector bits as an Int64s vector."
+  BitsToFloat32: "BitsToFloat32 reinterprets the vector bits as a Float32s vector."
+  BitsToFloat64: "BitsToFloat64 reinterprets the vector bits as a Float64s vector."
+  ReshapeToUint8s: "ReshapeToUint8s reinterprets the vector bits as a Uint8s vector."
+  ReshapeToUint16s: "ReshapeToUint16s reinterprets the vector bits as a Uint16s vector."
+  ReshapeToUint32s: "ReshapeToUint32s reinterprets the vector bits as a Uint32s vector."
+  ReshapeToUint64s: "ReshapeToUint64s reinterprets the vector bits as a Uint64s vector."
+
+  # Mask specific conversions
+  ToInt8s: "ToInt8s converts the mask to an Int8s vector."
+  ToInt16s: "ToInt16s converts the mask to an Int16s vector."
+  ToInt32s: "ToInt32s converts the mask to an Int32s vector."
+  ToInt64s: "ToInt64s converts the mask to an Int64s vector."
+
+  CarrylessMultiplyEven: |-
+    CarrylessMultiplyOdd computes the carryless
+    // multiplications of selected even indexed elements of x and y.
+    // Each product is 128 bits wide and fills the corresponding
+    // even-odd pairs in the result.
+    //
+    // A carryless multiplication uses bitwise XOR instead of
+    // add-with-carry, for example (in base two):
+    //
+    //  11 * 11 = 11 * (10 ^ 1) = (11 * 10) ^ (11 * 1) = 110 ^ 11 = 101
+    //
+    // This also models multiplication of polynomials with coefficients
+    // from GF(2) -- 11 * 11 models (x+1)*(x+1) = x**2 + (1^1)x + 1 =
+    // x**2 + 0x + 1 = x**2 + 1 modeled by 101.  (Note that "+" adds
+    // polynomial terms, but coefficients "add" with XOR.)"
+
+  CarrylessMultiplyOdd: |-
+    CarrylessMultiplyOdd computes the carryless
+    // multiplications of selected odd indexed elements of x and y.
+    // Each product is 128 bits wide and fills the corresponding
+    // even-odd pairs in the result.
+    //
+    // A carryless multiplication uses bitwise XOR instead of
+    // add-with-carry, for example (in base two):
+    //
+    //  11 * 11 = 11 * (10 ^ 1) = (11 * 10) ^ (11 * 1) = 110 ^ 11 = 101
+    //
+    // This also models multiplication of polynomials with coefficients
+    // from GF(2) -- 11 * 11 models (x+1)*(x+1) = x**2 + (1^1)x + 1 =
+    // x**2 + 0x + 1 = x**2 + 1 modeled by 101.  (Note that "+" adds
+    // polynomial terms, but coefficients "add" with XOR.)"
+
+types:
+  _simd: "internal SIMD marker."
+  Int8s: "Int8s represents a vector of 8-bit signed integers."
+  Int16s: "Int16s represents a vector of 16-bit signed integers."
+  Int32s: "Int32s represents a vector of 32-bit signed integers."
+  Int64s: "Int64s represents a vector of 64-bit signed integers."
+  Uint8s: "Uint8s represents a vector of 8-bit unsigned integers."
+  Uint16s: "Uint16s represents a vector of 16-bit unsigned integers."
+  Uint32s: "Uint32s represents a vector of 32-bit unsigned integers."
+  Uint64s: "Uint64s represents a vector of 64-bit unsigned integers."
+  Float32s: "Float32s represents a vector of 32-bit floating-point numbers."
+  Float64s: "Float64s represents a vector of 64-bit floating-point numbers."
+  Mask8s: "Mask8s represents a boolean mask for Int8s/Uint8s vectors."
+  Mask16s: "Mask16s represents a boolean mask for Int16s/Uint16s vectors."
+  Mask32s: "Mask32s represents a boolean mask for Int32s/Uint32s vectors."
+  Mask64s: "Mask64s represents a boolean mask for Int64s/Uint64s vectors."
+
+functions:
+  VectorSize: "VectorSize returns the size of the largest SIMD vector supported by the current CPU."
+  # Templates for Load functions
+  default_LoadSlice: "Load%s loads a slice of %s into an %ss vector."
+  default_LoadPart: "Load%sPart loads a partial slice of %s into an %ss vector, returning the vector and the number of elements loaded."
+  default_Broadcast: "Broadcast%s fills the elements of a slice with its argument value."
+
+methods:
+  Int8s:
+    <<: *common_methods
+  Int16s:
+    <<: *common_methods
+  Int32s:
+    <<: *common_methods
+  Int64s:
+    <<: *common_methods
+  Uint8s:
+    <<: *common_methods
+  Uint16s:
+    <<: *common_methods
+  Uint32s:
+    <<: *common_methods
+  Uint64s:
+    <<: *common_methods
+  Float32s:
+    <<: *common_methods
+  Float64s:
+    <<: *common_methods
+  Mask8s:
+    <<: *common_methods
+  Mask16s:
+    <<: *common_methods
+  Mask32s:
+    <<: *common_methods
+  Mask64s:
+    <<: *common_methods