avoid go list for Plan9 assembly discovery

Author: cpunion

internal/build/build.go

@@ -617,8 +617,9 @@ type context struct {
 	envInputsCached    envSection
 	envInputsReady     bool
 
-	// go list derived file lists (SFiles, etc.)
+	// Plan9 assembly file discovery caches.
 	sfilesCache map[string][]string // pkg.ID -> absolute .s/.S file paths
+	asmDirCache map[string]bool     // package directory -> whether it contains any .s/.S files
 
 	// plan9asm package policy parsed from env.
 	plan9asmOnce sync.Once

internal/build/plan9asm.go

@@ -2,10 +2,9 @@ package build
 
 import (
 	"bytes"
-	"encoding/json"
 	"fmt"
+	"go/build"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"strings"
 	"sync"
@@ -17,12 +16,9 @@ import (
 	gllvm "github.com/goplus/llvm"
 )
 
-// compilePkgSFiles translates Go/Plan9 assembly files selected by `go list -json`
-// for this package/target into LLVM IR, compiles them to .o, and returns the
-// object files for linking.
-//
-// NOTE: golang.org/x/tools/go/packages.Package does not expose SFiles, so we
-// query `go list -json` here to get the exact filtered set for GOOS/GOARCH.
+// compilePkgSFiles translates Go/Plan9 assembly files selected for this
+// package/target into LLVM IR, compiles them to .o, and returns the object files
+// for linking.
 func compilePkgSFiles(ctx *context, aPkg *aPackage, pkg *packages.Package, dynimports []cgoImportDynamicDecl, verbose bool) ([]string, error) {
 	sfiles, err := pkgSFiles(ctx, pkg)
 	if err != nil {
@@ -365,6 +361,21 @@ func plan9asmEnabledByDefault(conf *Config, pkgPath string) bool {
 	return !llruntime.HasAltPkg(pkgPath) || llruntime.HasAdditiveAltPkg(pkgPath)
 }
 
+func (c *context) dirHasAsmFile(dir string) bool {
+	if c == nil {
+		return dirHasAsmFile(dir)
+	}
+	if c.asmDirCache == nil {
+		c.asmDirCache = make(map[string]bool)
+	}
+	if has, ok := c.asmDirCache[dir]; ok {
+		return has
+	}
+	has := dirHasAsmFile(dir)
+	c.asmDirCache[dir] = has
+	return has
+}
+
 func dirHasAsmFile(dir string) bool {
 	f, err := os.Open(dir)
 	if err != nil {
@@ -400,59 +411,52 @@ func pkgSFiles(ctx *context, pkg *packages.Package) ([]string, error) {
 		return v, nil
 	}
 
-	// Fast path: if directory has no .s/.S at all, skip `go list`.
-	if !dirHasAsmFile(pkg.Dir) {
-		ctx.sfilesCache[pkg.ID] = nil
-		return nil, nil
+	var metadataSFiles []string
+	for _, file := range pkg.OtherFiles {
+		if strings.HasSuffix(file, ".s") || strings.HasSuffix(file, ".S") {
+			metadataSFiles = append(metadataSFiles, file)
+		}
 	}
-
-	args := []string{"list", "-json"}
-	if ctx.conf != nil && len(ctx.conf.BuildFlags) > 0 {
-		args = append(args, ctx.conf.BuildFlags...)
+	if len(metadataSFiles) > 0 {
+		ctx.sfilesCache[pkg.ID] = metadataSFiles
+		return metadataSFiles, nil
 	}
-	args = append(args, pkg.PkgPath)
 
-	cmd := exec.Command("go", args...)
-	cmd.Dir = pkg.Dir
-	cmd.Env = append(os.Environ(),
-		"GOOS="+ctx.buildConf.Goos,
-		"GOARCH="+ctx.buildConf.Goarch,
-	)
-	out, err := cmd.Output()
-	if err != nil {
-		var errBuf bytes.Buffer
-		if ee, ok := err.(*exec.ExitError); ok && len(ee.Stderr) > 0 {
-			errBuf.Write(ee.Stderr)
-		}
-		return nil, fmt.Errorf("go list -json %s failed: %w\n%s", pkg.PkgPath, err, strings.TrimSpace(errBuf.String()))
+	// Fast path: if directory has no .s/.S at all, skip source selection.
+	if !ctx.dirHasAsmFile(pkg.Dir) {
+		ctx.sfilesCache[pkg.ID] = nil
+		return nil, nil
 	}
 
-	var lp struct {
-		Dir    string   `json:"Dir"`
-		SFiles []string `json:"SFiles"`
+	buildCtx := build.Default
+	buildCtx.GOOS = ctx.buildConf.Goos
+	buildCtx.GOARCH = ctx.buildConf.Goarch
+	if ctx.conf != nil {
+		buildCtx.BuildTags = parseSourcePatchBuildTags(ctx.conf.BuildFlags)
 	}
-	if err := json.Unmarshal(out, &lp); err != nil {
-		return nil, fmt.Errorf("go list -json %s: parse: %w", pkg.PkgPath, err)
+	bp, err := buildCtx.ImportDir(pkg.Dir, 0)
+	if err != nil {
+		return nil, fmt.Errorf("inspect asm files for %s: %w", pkg.PkgPath, err)
 	}
 
 	// internal/chacha8rand has highly optimized arch asm on amd64/arm64.
 	// Until full vector lowering lands, force the generic stub entry, which
 	// tail-jumps to block_generic and preserves package behavior.
-	if pkg.PkgPath == "internal/chacha8rand" && lp.Dir != "" {
-		stub := filepath.Join(lp.Dir, "chacha8_stub.s")
+	if pkg.PkgPath == "internal/chacha8rand" && bp.Dir != "" {
+		stub := filepath.Join(bp.Dir, "chacha8_stub.s")
 		if _, err := os.Stat(stub); err == nil {
 			paths := []string{stub}
 			ctx.sfilesCache[pkg.ID] = paths
 			return paths, nil
 		}
 	}
 
-	paths := make([]string, 0, len(lp.SFiles))
-	for _, f := range lp.SFiles {
-		if lp.Dir == "" {
+	paths := make([]string, 0, len(bp.SFiles))
+	for _, f := range bp.SFiles {
+		if bp.Dir == "" {
 			continue
 		}
-		paths = append(paths, filepath.Join(lp.Dir, f))
+		paths = append(paths, filepath.Join(bp.Dir, f))
 	}
 	ctx.sfilesCache[pkg.ID] = paths
 	return paths, nil

internal/build/plan9asm_altpkg_test.go

@@ -38,7 +38,55 @@ func TestDirHasAsmFile(t *testing.T) {
 		t.Fatal("directory with .S file should have asm files")
 	}
 	if !dirHasAsmFile(filepath.Join(t.TempDir(), "missing")) {
-		t.Fatal("unreadable/missing directory should fall back to go list")
+		t.Fatal("unreadable/missing directory should fall back to source selection")
+	}
+}
+
+func TestPkgSFilesUsesOtherFiles(t *testing.T) {
+	dir := t.TempDir()
+	pkg := &packages.Package{
+		ID:         "example.com/otherfiles",
+		PkgPath:    "example.com/otherfiles",
+		Dir:        dir,
+		OtherFiles: []string{filepath.Join(dir, "selected.s"), filepath.Join(dir, "note.txt")},
+	}
+	ctx := &context{conf: &packages.Config{}, buildConf: &Config{Goos: "linux", Goarch: "amd64"}}
+	files, err := pkgSFiles(ctx, pkg)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := filepath.Join(dir, "selected.s")
+	if len(files) != 1 || files[0] != want {
+		t.Fatalf("pkgSFiles returned %v, want [%s]", files, want)
+	}
+	if got := ctx.sfilesCache[pkg.ID]; len(got) != 1 || got[0] != want {
+		t.Fatalf("sfiles cache = %v, want [%s]", got, want)
+	}
+}
+
+func TestPkgSFilesUsesBuildContextSelection(t *testing.T) {
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "main.go"), []byte("package p\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "selected_amd64.s"), []byte("TEXT ·selected(SB),$0-0\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "skipped_arm64.s"), []byte("TEXT ·skipped(SB),$0-0\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	ctx := &context{conf: &packages.Config{}, buildConf: &Config{Goos: "linux", Goarch: "amd64"}}
+	pkg := &packages.Package{ID: "example.com/asmselect", PkgPath: "example.com/asmselect", Dir: dir}
+	files, err := pkgSFiles(ctx, pkg)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := filepath.Join(dir, "selected_amd64.s")
+	if len(files) != 1 || files[0] != want {
+		t.Fatalf("pkgSFiles returned %v, want [%s]", files, want)
+	}
+	if has, ok := ctx.asmDirCache[dir]; !ok || !has {
+		t.Fatalf("asm dir cache[%s] = %v, %v; want true", dir, has, ok)
 	}
 }
 
@@ -62,6 +110,9 @@ func TestPkgSFilesCachesNoAsmResult(t *testing.T) {
 	if _, ok := ctx.sfilesCache[pkg.ID]; !ok {
 		t.Fatal("no-asm result was not cached")
 	}
+	if has, ok := ctx.asmDirCache[dir]; !ok || has {
+		t.Fatalf("asm dir cache[%s] = %v, %v; want false", dir, has, ok)
+	}
 }
 
 func TestHasAltPkgForTarget_AllowsAdditivePatchWithPlan9Asm(t *testing.T) {