internal/simdgen: initial work on Go<->SIMD generator

This can parse XED data into a unifier structure, and unify it with
hand-written definitions of SIMD-to-Go mappings.

Change-Id: Ie89e328845cde5752ddb3013ebfccc167e85b0bf
Reviewed-on: https://go-review.googlesource.com/c/arch/+/667035
Reviewed-by: David Chase <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>
Reviewed-by: Junyang Shao <[email protected]>

Author: aclements

internal/simdgen/asm.yaml.toy

@@ -0,0 +1,92 @@
+# Hand-written toy input like -xedPath would generate.
+# This input can be substituted for -xedPath.
+!sum
+- asm: ADDPS
+  goarch: amd64
+  feature: "SSE2"
+  in:
+    - asmPos: 0
+      base: float
+      bits: 32
+      w: 128
+    - asmPos: 1
+      base: float
+      bits: 32
+      w: 128
+  out:
+    - asmPos: 0
+      base: float
+      bits: 32
+      w: 128
+
+- asm: ADDPD
+  goarch: amd64
+  feature: "SSE2"
+  in:
+    - asmPos: 0
+      base: float
+      bits: 64
+      w: 128
+    - asmPos: 1
+      base: float
+      bits: 64
+      w: 128
+  out:
+    - asmPos: 0
+      base: float
+      bits: 64
+      w: 128
+
+- asm: PADDB
+  goarch: amd64
+  feature: "SSE2"
+  in:
+    - asmPos: 0
+      base: int|uint
+      bits: 32
+      w: 128
+    - asmPos: 1
+      base: int|uint
+      bits: 32
+      w: 128
+  out:
+    - asmPos: 0
+      base: int|uint
+      bits: 32
+      w: 128
+
+- asm: VPADDB
+  goarch: amd64
+  feature: "AVX"
+  in:
+    - asmPos: 1
+      base: int|uint
+      bits: 8
+      w: 128
+    - asmPos: 2
+      base: int|uint
+      bits: 8
+      w: 128
+  out:
+    - asmPos: 0
+      base: int|uint
+      bits: 8
+      w: 128
+
+- asm: VPADDB
+  goarch: amd64
+  feature: "AVX2"
+  in:
+    - asmPos: 1
+      base: int|uint
+      bits: 8
+      w: 256
+    - asmPos: 2
+      base: int|uint
+      bits: 8
+      w: 256
+  out:
+    - asmPos: 0
+      base: int|uint
+      bits: 8
+      w: 256

internal/simdgen/categories.yaml

@@ -0,0 +1,7 @@
+!sum
+- go: Add
+  category: binary
+- go: AddSaturated
+  category: binary
+- go: Sub
+  category: binary

internal/simdgen/go.yaml

@@ -0,0 +1,19 @@
+!sum
+# For binary operations, we constrain their two inputs and one output to the
+# same Go type using a variable.
+- go: Add
+  asm: "V?PADD$xi|V?ADDP$xf"
+  in:
+  - go: $t
+  - go: $t
+  out:
+  - go: $t
+
+- go: Sub
+  goarch: amd64
+  asm: "V?PSUB$xi|V?SUBP$xf"
+  in:
+  - go: $t
+  - go: $t
+  out:
+  - go: $t

internal/simdgen/godefs.go

@@ -0,0 +1,98 @@
+// Copyright 2025 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 main
+
+import (
+	"fmt"
+	"io"
+	"log"
+
+	"golang.org/x/arch/internal/unify"
+)
+
+type Operation struct {
+	Go       string  // Go method name
+	Category *string // General operation category (optional)
+
+	GoArch string // GOARCH for this definition
+	Asm    string // Assembly mnemonic
+
+	In  []Operand // Arguments
+	Out []Operand // Results
+}
+
+type Operand struct {
+	Go     string // Go type of this operand
+	AsmPos int    // Position of this operand in the assembly instruction
+
+	Base string // Base Go type ("int", "uint", "float")
+	Bits int    // Element bit width
+	W    int    // Total vector bit width
+}
+
+func writeGoDefs(w io.Writer, cl unify.Closure) {
+	// TODO: Merge operations with the same signature but multiple
+	// implementations (e.g., SSE vs AVX)
+
+	// TODO: This code is embarrassing, but I'm very tired.
+
+	var op Operation
+	for def := range cl.All() {
+		if !def.Exact() {
+			continue
+		}
+		if err := def.Decode(&op); err != nil {
+			log.Println(err.Error())
+			continue
+		}
+
+		fmt.Fprintf(w, "func (x %s) %s(", op.In[0].Go, op.Go)
+		for i, arg := range op.In[1:] {
+			if i > 0 {
+				fmt.Fprint(w, ", ")
+			}
+			fmt.Fprintf(w, "%c %s", 'y'+i, arg.Go)
+		}
+		fmt.Fprintf(w, ") (")
+		for i, res := range op.Out {
+			if i > 0 {
+				fmt.Fprint(w, ", ")
+			}
+			fmt.Fprintf(w, "%c %s", 'o'+i, res.Go)
+		}
+		fmt.Fprintf(w, ") {\n")
+
+		asmPosToArg := make(map[int]byte)
+		asmPosToRes := make(map[int]byte)
+		for i, arg := range op.In {
+			asmPosToArg[arg.AsmPos] = 'x' + byte(i)
+		}
+		for i, res := range op.Out {
+			asmPosToRes[res.AsmPos] = 'o' + byte(i)
+		}
+		fmt.Fprintf(w, "\t// %s", op.Asm)
+		for i := 0; ; i++ {
+			arg, okArg := asmPosToArg[i]
+			if okArg {
+				fmt.Fprintf(w, " %c", arg)
+			}
+			res, okRes := asmPosToRes[i]
+			if okRes {
+				if okArg {
+					fmt.Fprintf(w, "/")
+				} else {
+					fmt.Fprintf(w, " ")
+				}
+				fmt.Fprintf(w, "%c", res)
+			}
+			if !okArg && !okRes {
+				break
+			}
+		}
+		fmt.Fprintf(w, "\n")
+
+		fmt.Fprintf(w, "}\n")
+	}
+}