@ttsc/win32-arm64 0.33.0 → 0.34.0

package/bin/go/src/simd/archsimd/_gen/sgutil/asbits.go

@@ -0,0 +1,139 @@
+// 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 sgutil
+
+import (
+	"bytes"
+	"io"
+	"text/template"
+)
+
+type TforAsBits interface {
+	ElemBits() int
+	Name_() string
+}
+
+const (
+	ToBitsName        = "ToBits"
+	ToIntsName        = "BitsToInt{{.To.ElemBits}}"
+	ConvertToIntName  = "ConvertToInt{{.To.ElemBits}}"
+	ConvertToUintName = "ConvertToUint{{.From.ElemBits}}" // backwards because done with ToInts
+	ToFloatsName      = "BitsToFloat{{.To.ElemBits}}"
+	ReshapeName       = "ReshapeToUint{{.To.ElemBits}}s"
+)
+
+func templateOf(name, text string) *template.Template {
+	return template.Must(template.New(name).Parse(text))
+}
+
+var ToBitsCall = templateOf("toBitsCall", "."+ToBitsName+"()")
+var ToIntsCall = templateOf("toBitsCall", "."+ToIntsName+"()")
+var ToFloatsCall = templateOf("toBitsCall", "."+ToFloatsName+"()")
+var ReshapeCall = templateOf("toBitsCall", "."+ReshapeName+"()")
+
+var ToBitsDcl = templateOf("toBitsDcl", `
+	// `+ToBitsName+` reinterprets the bits of a {{.From.Name_}} vector as a {{.To.Name_}} vector
+	func (x {{.From.Name_}}) `+ToBitsName+`() {{.To.Name_}}
+`)
+
+// ToBitsIntrinsic is used in a uint -> T context, but reverse, so T is method receiver.
+var ToBitsIntrinsic = templateOf("toBitsIntrin", `{{.To.Name_}}.`+ToBitsName)
+
+var ToIntsDcl = templateOf("toIntsDcl", `
+	// `+ToIntsName+` reinterprets the bits of a {{.From.Name_}} vector as a {{.To.Name_}} vector
+	func (x {{.From.Name_}}) `+ToIntsName+`() {{.To.Name_}}
+
+	// `+ConvertToIntName+` converts a {{.From.Name_}} vector to a {{.To.Name_}} vector
+	func (x {{.From.Name_}}) `+ConvertToIntName+`() {{.To.Name_}}
+
+	// `+ConvertToUintName+` converts a {{.To.Name_}} vector to a {{.From.Name_}} vector
+	func (x {{.To.Name_}}) `+ConvertToUintName+`() {{.From.Name_}}
+`)
+
+var ToIntsIntrinsic = templateOf("toIntsIntrin", `{{.From.Name_}}.`+ToIntsName)
+var CvtToIntsIntrinsic = templateOf("cvtToIntIntrin", `{{.From.Name_}}.`+ConvertToIntName)
+
+// Also used in a to-from-reversed context.
+var CvtToUintsIntrinsic = templateOf("cvtToUintIntrin", `{{.To.Name_}}.`+ConvertToUintName)
+
+var ToFloatsDcl = templateOf("toFloatsDcl", `
+	// `+ToFloatsName+` reinterprets the bits of a {{.From.Name_}} vector as a {{.To.Name_}} vector
+	func (x {{.From.Name_}}) `+ToFloatsName+`() {{.To.Name_}}
+`)
+
+var ToFloatsIntrinsic = templateOf("toFloatsIntrin", `{{.From.Name_}}.`+ToFloatsName)
+
+var ReshapeDcl = templateOf("reshapeDcl", `
+	// `+ReshapeName+` reinterprets the bits of a {{.From.Name_}} vector as a {{.To.Name_}} vector
+	func (x {{.From.Name_}}) `+ReshapeName+`() {{.To.Name_}}
+`)
+
+var ReshapeIntrinsic = templateOf("reshapeIntrinsic", `{{.From.Name_}}.`+ReshapeName)
+
+var AsOp = templateOf("asConversion", `
+	// As{{.To.Name}} reinterprets the bits of a {{.From.Name}} vector as a {{.To.Name}} vector
+	//
+	// Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>
+	//
+	//go:fix inline
+	func (x {{.From.Name}}) As{{.To.Name}}() {{.To.Name}} {
+		return x{{.AsTranslation}}
+	}
+`)
+
+type AsConversion struct {
+	From, To TforAsBits
+}
+
+func Conversion(from, to TforAsBits) *AsConversion {
+	return &AsConversion{from, to}
+}
+
+type TypeDotMethod struct {
+	TypeDotMethod string
+}
+
+func (c *AsConversion) TypeDotMethod(t *template.Template) *TypeDotMethod {
+	var b bytes.Buffer
+	t.Execute(&b, c)
+	return &TypeDotMethod{b.String()}
+}
+
+// ExecuteIntrinsicTemplateOfTypeDotMethod executes the template t on a
+// variety of TypeDotMethod inputs with template parameter TypeDotMethod
+func (c *AsConversion) ExecuteIntrinsicTemplateOfTypeDotMethod(w io.Writer, t *template.Template) {
+	from, to := c.From, c.To
+	switch to.Name_()[0] {
+	case 'F': // U -> F
+		t.Execute(w, c.TypeDotMethod(ToFloatsIntrinsic))
+		t.Execute(w, c.TypeDotMethod(ToBitsIntrinsic))
+	case 'I': // U -> I
+		t.Execute(w, c.TypeDotMethod(ToIntsIntrinsic))
+		t.Execute(w, c.TypeDotMethod(CvtToIntsIntrinsic))
+		t.Execute(w, c.TypeDotMethod(CvtToUintsIntrinsic))
+		t.Execute(w, c.TypeDotMethod(ToBitsIntrinsic))
+	case 'U': // U -> U
+		if from.Name_()[0] == 'U' {
+			t.Execute(w, c.TypeDotMethod(ReshapeIntrinsic))
+		}
+	}
+}
+
+func (a *AsConversion) AsTranslation() string {
+	var b bytes.Buffer
+	if a.From.Name_()[0] != 'U' {
+		ToBitsCall.Execute(&b, a)
+	}
+	if a.From.ElemBits() != a.To.ElemBits() {
+		ReshapeCall.Execute(&b, a)
+	}
+	if a.To.Name_()[0] == 'F' {
+		ToFloatsCall.Execute(&b, a)
+	}
+	if a.To.Name_()[0] == 'I' {
+		ToIntsCall.Execute(&b, a)
+	}
+	return b.String()
+}

package/bin/go/src/simd/archsimd/_gen/sgutil/compare_natural.go

@@ -0,0 +1,73 @@
+// 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 sgutil
+
+import (
+	"strconv"
+	"strings"
+)
+
+// isDigit returns true if the byte is an ASCII digit.
+func isDigit(b byte) bool {
+	return b >= '0' && b <= '9'
+}
+
+// CompareNatural performs a "natural sort" comparison of two strings.
+// It compares non-digit sections lexicographically and digit sections
+// numerically.  In the case of string-unequal "equal" strings like
+// "a01b" and "a1b", strings.Compare breaks the tie.
+//
+// It returns:
+//
+//	-1 if s1 < s2
+//	 0 if s1 == s2
+//	+1 if s1 > s2
+func CompareNatural(s1, s2 string) int {
+	i, j := 0, 0
+	len1, len2 := len(s1), len(s2)
+
+	for i < len1 && j < len2 {
+		// Find a non-digit segment or a number segment in both strings.
+		if isDigit(s1[i]) && isDigit(s2[j]) {
+			// Number segment comparison.
+			numStart1 := i
+			for i < len1 && isDigit(s1[i]) {
+				i++
+			}
+			num1, _ := strconv.Atoi(s1[numStart1:i])
+
+			numStart2 := j
+			for j < len2 && isDigit(s2[j]) {
+				j++
+			}
+			num2, _ := strconv.Atoi(s2[numStart2:j])
+
+			if num1 < num2 {
+				return -1
+			}
+			if num1 > num2 {
+				return 1
+			}
+			// "1" < "01".  Don't expect it in simdgen, but just in case.
+			if ln1, ln2 := i-numStart1, j-numStart2; ln1 != ln2 {
+				return ln1 - ln2
+			}
+			// If numbers are equal, continue to the next segment.
+		} else {
+			// Non-digit comparison.
+			if s1[i] < s2[j] {
+				return -1
+			}
+			if s1[i] > s2[j] {
+				return 1
+			}
+			i++
+			j++
+		}
+	}
+
+	// deal with a01b vs a1b; there needs to be an order.
+	return strings.Compare(s1, s2)
+}

package/bin/go/src/simd/archsimd/_gen/sgutil/formatted_files.go

@@ -0,0 +1,66 @@
+// 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 sgutil
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"go/format"
+	"os"
+	"path/filepath"
+)
+
+func CreatePath(newFile string) (*os.File, error) {
+	dir := filepath.Dir(newFile)
+	err := os.MkdirAll(dir, 0755)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create directory %s: %w", dir, err)
+	}
+	f, err := os.Create(newFile)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create file %s: %w", newFile, err)
+	}
+	return f, nil
+}
+
+// FormatWriteAndClose formats the Go source code in source and writes it
+// to newFile.  If there is a problem with the formatting, the
+// entire source is numbered and emitted along with the error message,
+// to help figure out where the source code generation went wrong.
+func FormatWriteAndClose(source *bytes.Buffer, newFile string) {
+	b, err := format.Source(source.Bytes())
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "%v\n", err)
+		fmt.Fprintf(os.Stderr, "%s\n", NumberLines(source.Bytes()))
+		fmt.Fprintf(os.Stderr, "%v\n", err)
+		panic(err)
+	} else {
+		WriteAndClose(b, newFile)
+	}
+}
+
+// WriteAndClose creates newFile, writes g to it,
+// and closes the file.
+func WriteAndClose(b []byte, newFile string) {
+	ofile, err := CreatePath(newFile)
+	if err != nil {
+		panic(err)
+	}
+	ofile.Write(b)
+	ofile.Close()
+}
+
+// NumberLines takes a slice of bytes, and returns a string where each line
+// is numbered, starting from 1.
+func NumberLines(data []byte) string {
+	var buf bytes.Buffer
+	r := bytes.NewReader(data)
+	s := bufio.NewScanner(r)
+	for i := 1; s.Scan(); i++ {
+		fmt.Fprintf(&buf, "%d: %s\n", i, s.Text())
+	}
+	return buf.String()
+}

package/bin/go/src/simd/archsimd/_gen/sgutil/insert_ordered_map.go

@@ -0,0 +1,159 @@
+// 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 sgutil
+
+import "iter"
+
+type InsertMap[K comparable, V any] struct {
+	m map[K]uint32 // Maps keys to their insertion index in the values slice.
+	v []V          // Stores values in their insertion order.
+	k []K          // Lazy slice of keys in insertion order, for iterators.
+}
+
+// Put inserts or updates a key-value pair in the map.
+// If the key already exists, its value is updated while its insertion order
+// remains unchanged. Returns the old value if there is one,
+// and a boolean indicating whether an update occurred.
+func (im *InsertMap[K, V]) Put(key K, val V) (old V, updated bool) {
+	if im.m == nil {
+		im.m = make(map[K]uint32)
+	}
+
+	var index uint32
+	index, updated = im.m[key]
+	if updated {
+		// Key already exists; update its value in-place in the values slice.
+		old = im.v[index]
+		im.v[index] = val
+		return
+	}
+
+	// Keep the keys slice synchronized if it has already been initialized.
+	if len(im.v) > 0 && len(im.k) == len(im.v) {
+		im.k = append(im.k, key)
+	}
+
+	// Record the new key's insertion index and append the value.
+	im.m[key] = uint32(len(im.v))
+	im.v = append(im.v, val)
+	return
+}
+
+// updateKeys synchronizes the lazy keys slice (im.k) with the values slice (im.v).
+// It populates im.k with keys at their respective insertion indices using
+// the mapping stored in im.m.
+func (im *InsertMap[K, V]) updateKeys() {
+	if len(im.k) == len(im.v) {
+		return
+	}
+	im.k = make([]K, len(im.v))
+	for k, i := range im.m {
+		im.k[i] = k
+	}
+}
+
+// Contains reports whether the map contains the specified key.
+func (im *InsertMap[K, V]) Contains(key K) bool {
+	if im.m == nil {
+		return false
+	}
+	_, ok := im.m[key]
+	return ok
+}
+
+// Get returns the value associated with the specified key.
+// If the key does not exist, the zero value of type V is returned.
+func (im *InsertMap[K, V]) Get(key K) V {
+	if im.m != nil {
+		index, ok := im.m[key]
+		if ok {
+			return im.v[index]
+		}
+	}
+	var v V
+	return v
+}
+
+// GetOk returns the value associated with the specified key and
+// a boolean indicating whether the key exists in the map.
+// If the key is not in the map, the zero value is returned along with false.
+func (im *InsertMap[K, V]) GetOk(key K) (V, bool) {
+	if im.m != nil {
+		index, ok := im.m[key]
+		if ok {
+			return im.v[index], true
+		}
+	}
+	var v V
+	return v, false
+}
+
+// Compare compares two keys based on their insertion order.
+// It returns:
+//   - -1 if 'a' was inserted before 'b'
+//   - 1 if 'a' was inserted after 'b'
+//   - 0 if 'a' and 'b' are equal, or if neither key exists in the map.
+//
+// If only one of the keys exists in the map, the existing key is considered
+// to be "before" (less than) the non-existing key, returning -1 if 'a' exists,
+// and 1 if 'b' exists.
+func (im *InsertMap[K, V]) Compare(a, b K) int {
+	if im.m == nil {
+		return 0
+	}
+	ai, aok := im.m[a]
+	bi, bok := im.m[b]
+	if aok != bok {
+		if aok {
+			return -1
+		}
+		return 1
+	}
+	if !aok {
+		return 0
+	}
+	if ai < bi {
+		return -1
+	}
+	if ai > bi {
+		return 1
+	}
+	return 0
+}
+
+// All returns an iterator over the key-value pairs of the map in insertion order.
+func (im *InsertMap[K, V]) All() iter.Seq2[K, V] {
+	return func(yield func(K, V) bool) {
+		im.updateKeys()
+		for i, k := range im.k {
+			if !yield(k, im.v[i]) {
+				return
+			}
+		}
+	}
+}
+
+// Keys returns an iterator over the keys of the map in insertion order.
+func (im *InsertMap[K, V]) Keys() iter.Seq[K] {
+	return func(yield func(K) bool) {
+		im.updateKeys()
+		for _, k := range im.k {
+			if !yield(k) {
+				return
+			}
+		}
+	}
+}
+
+// Values returns an iterator over the values of the map in insertion order.
+func (im *InsertMap[K, V]) Values() iter.Seq[V] {
+	return func(yield func(V) bool) {
+		for _, v := range im.v {
+			if !yield(v) {
+				return
+			}
+		}
+	}
+}

package/bin/go/src/simd/archsimd/_gen/sgutil/merge_generic_ops.go

@@ -0,0 +1,245 @@
+// 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 sgutil provides shared utilities for SIMD file
+// generation across architectures.  This includes
+//
+// - "natural" comparison for better ordering
+// - formatted-Go file saving
+// - file merging for simdgenericOps.go
+// - naming conventions and templates for the
+//   bitwise vector reinterpretation no-op methods.
+
+package sgutil
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"os"
+	"regexp"
+	"slices"
+	"sort"
+	"strconv"
+	"strings"
+	"text/template"
+)
+
+const simdGenericOpsTmpl = `
+package main
+
+func simdGenericOps() []opData {
+	return []opData{
+{{- range .Ops }}
+		{name: "{{.OpName}}", argLength: {{.OpInLen}}{{if .Comm}}, commutative: true{{end}}}, // ARCH:{{.ArchTag}}
+{{- end }}
+{{- range .OpsImm }}
+		{name: "{{.OpName}}", argLength: {{.OpInLen}}{{if .Comm}}, commutative: true{{end}}, aux: "UInt8"}, // ARCH:{{.ArchTag}}
+{{- end }}
+	}
+}
+`
+
+// TemplateNamedreturns a parsed template from temp, named name.
+func TemplateNamed(name, temp string) *template.Template {
+	t, err := template.New(name).Parse(temp)
+	if err != nil {
+		panic(fmt.Errorf("failed to parse template %s: %w", name, err))
+	}
+	return t
+}
+
+// simdGenericOpsHeader is the arch-agnostic header for simdgenericOps.go.
+const simdGenericOpsHeader = "// Code generated by 'simdgen' (merged automatically); DO NOT EDIT.\n"
+
+// GenericOpsData holds one generic op entry for template rendering.
+type GenericOpsData struct {
+	OpName  string
+	OpInLen int
+	Comm    bool
+	HasAux  bool
+	Archs   []string // e.g. ["amd64","arm64"]
+}
+
+// ArchTag returns the comma-separated arch list for the template comment.
+func (d GenericOpsData) ArchTag() string {
+	return strings.Join(d.Archs, ",")
+}
+
+// Match lines like:
+//
+//	{name: "GetElemFloat32x4", argLength: 2, aux: "UInt8"}, // ARCH:amd64,arm64
+//	{name: "MulInt8x16", argLength: 2, commutative: true}, // ARCH:arm64
+var reEntry = regexp.MustCompile(`^\s*\{name:\s*"([^"]+)",\s*argLength:\s*(\d+)(?:,\s*commutative:\s*(true|false))?(?:,\s*aux:\s*"[^"]+")?\s*\}\s*,\s*(?://\s*ARCH:(\S+))?`)
+
+// parseOps reads an existing simdgenericOps.go and extracts op entries along with
+// their ARCH: tags. It strips currentArch from all parsed entries and drops those
+// with no remaining tags (ops that belonged only to the current arch).
+func parseOps(oldFile, currentArch string) ([]GenericOpsData, error) {
+	f, ferr := os.Open(oldFile)
+	if ferr != nil {
+		if os.IsNotExist(ferr) {
+			return nil, nil
+		}
+		return nil, ferr
+	}
+	defer f.Close()
+
+	untagged := 0
+	unmatched := 0
+	noarch := 0
+
+	var result []GenericOpsData
+	scanner := bufio.NewScanner(f)
+	for scanner.Scan() {
+		line := scanner.Text()
+		matches := reEntry.FindStringSubmatch(line)
+		if matches == nil {
+			unmatched++
+			continue
+		}
+		name := matches[1]
+		argLen, _ := strconv.Atoi(matches[2])
+		comm := matches[3] == "true" // matches[3] may be empty if commutative is omitted
+		hasAux := strings.Contains(line, `aux: "UInt8"`)
+		archTag := matches[4]
+
+		if archTag == "" {
+			untagged++
+			// Skip untagged entries (shouldn't occur after initial run).
+			continue
+		}
+
+		archs := slices.DeleteFunc(strings.Split(archTag, ","), func(a string) bool { return a == currentArch })
+		if len(archs) == 0 {
+			noarch++
+			continue
+		}
+
+		result = append(result, GenericOpsData{
+			OpName:  name,
+			OpInLen: argLen,
+			Comm:    comm,
+			HasAux:  hasAux,
+			Archs:   archs,
+		})
+	}
+	if err := scanner.Err(); err != nil {
+		return nil, err
+	}
+
+	return result, nil
+}
+
+// mergeOps merges existing and new op slices using a merge-sort walk.
+// Both inputs must be sorted by OpName (natural sort); the output is verified
+// to be sorted.
+//
+// existing must contain only tags from other architectures.
+// new entries must be tagged with currentArch.
+//
+// Overlapping names have their arch tags merged and properties verified for
+// consistency (argLength, commutativity, HasAux).
+func mergeOps(currentArch string, existing, new []GenericOpsData) ([]GenericOpsData, error) {
+	var (
+		result []GenericOpsData
+		i, j   int
+	)
+	for i < len(existing) || j < len(new) {
+		var cmp int
+		if i < len(existing) && j < len(new) {
+			cmp = CompareNatural(existing[i].OpName, new[j].OpName)
+		} else if i < len(existing) {
+			cmp = -1
+		} else {
+			cmp = 1
+		}
+
+		var entry GenericOpsData
+		switch cmp {
+		case -1:
+			entry = existing[i]
+			i++
+
+		case 1:
+			entry = new[j]
+			j++
+
+		case 0:
+			e, n := existing[i], new[j]
+			if e.OpInLen != n.OpInLen {
+				return nil, fmt.Errorf("simdgen: op %q has inconsistent argLength: existing=%d, new=%d", e.OpName, e.OpInLen, n.OpInLen)
+			}
+			if e.Comm != n.Comm {
+				return nil, fmt.Errorf("simdgen: op %q has inconsistent commutativity: existing=%v, new=%v", e.OpName, e.Comm, n.Comm)
+			}
+			if e.HasAux != n.HasAux {
+				return nil, fmt.Errorf("simdgen: op %q has inconsistent HasAux: existing=%v, new=%v", e.OpName, e.HasAux, n.HasAux)
+			}
+			entry = e
+			entry.Archs = append(entry.Archs, currentArch)
+			sort.Strings(entry.Archs)
+			i++
+			j++
+		}
+		if len(result) > 0 && CompareNatural(result[len(result)-1].OpName, entry.OpName) >= 0 {
+			return nil, fmt.Errorf("simdgen: mergeOps: sort invariant violated between %q and  %q",
+				result[len(result)-1].OpName, entry.OpName)
+		}
+		result = append(result, entry)
+	}
+
+	return result, nil
+}
+
+// MergeSIMDGenericOps merges a new set of generic ops with the existing ones read
+// from goroot "/" file.
+func MergeSIMDGenericOps(newOps []GenericOpsData, oldFile, currentArch string) *bytes.Buffer {
+	thisArch := []string{currentArch}
+	for i := range newOps {
+		newOps[i].Archs = thisArch
+	}
+
+	sortNatural := func(s []GenericOpsData) []GenericOpsData {
+		sort.Slice(s, func(i, j int) bool {
+			return CompareNatural(s[i].OpName, s[j].OpName) < 0
+		})
+		return s
+	}
+
+	existing, err := parseOps(oldFile, currentArch)
+	if err != nil {
+		panic(fmt.Errorf("failed to parse existing %s: %w", oldFile, err))
+	}
+
+	merged, err := mergeOps(currentArch, sortNatural(existing), sortNatural(newOps))
+	if err != nil {
+		panic(err)
+	}
+
+	// Split into ops/opsImm.
+	type opData struct {
+		Ops    []GenericOpsData
+		OpsImm []GenericOpsData
+	}
+	var opsData opData
+	for _, gOp := range merged {
+		if gOp.HasAux {
+			opsData.OpsImm = append(opsData.OpsImm, gOp)
+		} else {
+			opsData.Ops = append(opsData.Ops, gOp)
+		}
+	}
+
+	t := TemplateNamed("simdgenericOps", simdGenericOpsTmpl)
+	buffer := new(bytes.Buffer)
+	buffer.WriteString(simdGenericOpsHeader)
+
+	err = t.Execute(buffer, opsData)
+	if err != nil {
+		panic(fmt.Errorf("failed to execute template: %w", err))
+	}
+
+	return buffer
+}