feat(cmd): GOOS-aware headers, audit battery shapes and semicolon spacing

Assisted-by: GLM 5.3 Flash

cmd/gasm/asmhdr_test.go

@@ -22,12 +22,13 @@ func writePkg(t *testing.T, files map[string]string) string {
 	return dir
 }
 
-// generateFor generates the header for dir and returns its text.
-func generateFor(t *testing.T, dir, goarch string) string {
+// generateFor generates the header for dir and returns its text.  An empty
+// goos means the ambient one.
+func generateFor(t *testing.T, dir, goos, goarch string) string {
 	t.Helper()
-	hdrDir, err := generateGoAsmHeader(dir, goarch, t.TempDir())
+	hdrDir, err := generateGoAsmHeader(dir, goos, goarch, t.TempDir())
 	if err != nil {
-		t.Fatalf("generateGoAsmHeader(%q, %s): %v", dir, goarch, err)
+		t.Fatalf("generateGoAsmHeader(%q, %s, %s): %v", dir, goos, goarch, err)
 	}
 	b, err := os.ReadFile(filepath.Join(hdrDir, "go_asm.h"))
 	if err != nil {
@@ -72,7 +73,7 @@ type aliased struct {
 
 type alias = aliased
 `})
-	hdr := generateFor(t, dir, "amd64")
+	hdr := generateFor(t, dir, "", "amd64")
 	want := []string{
 		"#define const_bufSize 1024",
 		// iota resolves through go/types, one define per name.
@@ -133,8 +134,8 @@ package perarch
 const flavour = 2
 `,
 	})
-	amd64 := generateFor(t, dir, "amd64")
-	arm64 := generateFor(t, dir, "arm64")
+	amd64 := generateFor(t, dir, "", "amd64")
+	arm64 := generateFor(t, dir, "", "arm64")
 	if !strings.Contains(amd64, "#define const_flavour 1\n") {
 		t.Errorf("amd64 header misses const_flavour 1:\n%s", amd64)
 	}
@@ -149,19 +150,90 @@ const flavour = 2
 	if !strings.Contains(amd64, "#define layout__size 16\n") || !strings.Contains(amd64, "#define layout_p 8\n") {
 		t.Errorf("amd64 layout wrong:\n%s", amd64)
 	}
-	w386 := generateFor(t, dir, "386")
+	w386 := generateFor(t, dir, "", "386")
 	if !strings.Contains(w386, "#define layout__size 8\n") || !strings.Contains(w386, "#define layout_p 4\n") {
 		t.Errorf("386 layout wrong:\n%s", w386)
 	}
 }
 
+// TestGenerateGoAsmHeaderGOOS pins the GOOS half of the target: only the
+// platform's own files type-check into the header, which is why
+// sys_darwin_arm64.s cannot assemble against a linux-generated one.
+func TestGenerateGoAsmHeaderGOOS(t *testing.T) {
+	dir := writePkg(t, map[string]string{
+		"common.go": `package goosaware
+
+type shared struct {
+	a int32
+}
+`,
+		"plat_darwin.go": `//go:build darwin
+
+package goosaware
+
+type platform struct {
+	trampoline_numer int64
+}
+`,
+		"plat_windows.go": `//go:build windows
+
+package goosaware
+
+type platform struct {
+	callbackArgs__size int32
+}
+`,
+	})
+	darwin := generateFor(t, dir, "darwin", "arm64")
+	if !strings.Contains(darwin, "#define platform__size 8\n") || !strings.Contains(darwin, "#define platform_trampoline_numer 0\n") {
+		t.Errorf("darwin header misses the darwin layout:\n%s", darwin)
+	}
+	if strings.Contains(darwin, "callbackArgs") {
+		t.Errorf("darwin header must not carry the windows layout:\n%s", darwin)
+	}
+	windows := generateFor(t, dir, "windows", "arm64")
+	if !strings.Contains(windows, "#define platform_callbackArgs__size 0\n") {
+		t.Errorf("windows header misses the windows layout:\n%s", windows)
+	}
+	if strings.Contains(windows, "trampoline_numer") {
+		t.Errorf("windows header must not carry the darwin layout:\n%s", windows)
+	}
+	// The ambient GOOS is neither of the two, so only shared's defines are
+	// emitted; the shared type keeps its layout there.
+	ambient := generateFor(t, dir, "", "arm64")
+	if !strings.Contains(ambient, "#define shared__size 4\n") {
+		t.Errorf("ambient header misses the shared layout:\n%s", ambient)
+	}
+	if strings.Contains(ambient, "#define platform_") {
+		t.Errorf("ambient header must not carry either platform layout:\n%s", ambient)
+	}
+}
+
+func TestGoosFromFilename(t *testing.T) {
+	for path, want := range map[string]string{
+		"/x/sys_darwin_arm64.s":     "darwin",
+		"/x/sys_windows_arm64.s":    "windows",
+		"/x/asm_linux_amd64.s":      "linux",
+		"/x/rt0_darwin_arm64.s":     "darwin",
+		"/x/vgetrandom_zos_s390x.s": "zos",
+		"/x/rt0_js_wasm.s":          "js",
+		"/x/memmove_amd64.s":        "",
+		"/x/vlop_arm.s":             "",
+		"/x/stubs.s":                "",
+	} {
+		if got := goosFromFilename(path); got != want {
+			t.Errorf("goosFromFilename(%q) = %q, want %q", path, got, want)
+		}
+	}
+}
+
 func TestGenerateGoAsmHeaderErrors(t *testing.T) {
 	t.Run("type error", func(t *testing.T) {
 		dir := writePkg(t, map[string]string{"bad.go": `package bad
 
 const x = undefinedIdent
 `})
-		_, err := generateGoAsmHeader(dir, "amd64", t.TempDir())
+		_, err := generateGoAsmHeader(dir, "", "amd64", t.TempDir())
 		if err == nil {
 			t.Fatal("generation must fail for a package that does not type-check")
 		}
@@ -174,7 +246,7 @@ const x = undefinedIdent
 	})
 	t.Run("no go files", func(t *testing.T) {
 		dir := t.TempDir()
-		_, err := generateGoAsmHeader(dir, "amd64", t.TempDir())
+		_, err := generateGoAsmHeader(dir, "", "amd64", t.TempDir())
 		if err == nil {
 			t.Fatal("generation must fail without Go files")
 		}
@@ -281,6 +353,45 @@ type header struct {
 	}
 }
 
+// TestRunCorpusAuditGOOS covers the filename-derived GOOS end to end: a
+// kernel whose name names darwin must have its header type-checked with
+// GOOS=darwin, so the darwin-only constant it offsets with is defined.  The
+// operand mirrors sys_darwin_arm64.s's trampoline, where a missing define
+// leaves an unexpanded symbol in the offset and fails.
+func TestRunCorpusAuditGOOS(t *testing.T) {
+	dir := t.TempDir()
+	write := func(name, src string) {
+		t.Helper()
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(src), 0o644); err != nil {
+			t.Fatal(err)
+		}
+	}
+	write("pkg.go", "package corpus\n")
+	write("plat_darwin.go", "//go:build darwin\n\npackage corpus\n\nconst trampolineNumer = 8\n")
+	write("kern_darwin_arm64.s", "#include \"go_asm.h\"\n"+
+		"GLOBL timebase<>(SB), NOPTR, $16\n"+
+		"TEXT \xc2\xb7g(SB), NOSPLIT, $0-0\n"+
+		"\tMOVD\ttimebase<>+const_trampolineNumer(SB), R0\n"+
+		"\tRET\n")
+
+	stats, err := runCorpusAudit(dir, nil)
+	if err != nil {
+		t.Fatalf("runCorpusAudit: %v", err)
+	}
+	var arm *corpusTally
+	for i, tg := range stats.targets {
+		if tg.name == "arm64" {
+			arm = stats.tallies[i]
+		}
+	}
+	if arm == nil {
+		t.Fatal("no arm64 tally")
+	}
+	if arm.attempted != 1 || arm.assembled != 1 {
+		t.Errorf("arm64 = %d/%d, want 1/1; reasons: %v", arm.assembled, arm.attempted, arm.reasons)
+	}
+}
+
 // TestGenerateGoAsmHeaderRuntime pins the generator against the real thing:
 // the runtime package, whose header the toolchain's own -asmhdr output was
 // sampled from.  Skipped in short mode: it type-checks the whole package.
@@ -288,7 +399,7 @@ func TestGenerateGoAsmHeaderRuntime(t *testing.T) {
 	if testing.Short() {
 		t.Skip("type-checks the whole runtime package")
 	}
-	dir, err := generateGoAsmHeader("/usr/local/go/src/runtime", "amd64", t.TempDir())
+	dir, err := generateGoAsmHeader("/usr/local/go/src/runtime", "", "amd64", t.TempDir())
 	if err != nil {
 		t.Fatalf("generateGoAsmHeader(runtime): %v", err)
 	}