Add files using upload-large-folder tool

go/src/cmd/addr2line/addr2line_test.go

@@ -0,0 +1,119 @@
+// Copyright 2014 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 (
+	"bufio"
+	"bytes"
+	"internal/testenv"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// TestMain executes the test binary as the addr2line command if
+// GO_ADDR2LINETEST_IS_ADDR2LINE is set, and runs the tests otherwise.
+func TestMain(m *testing.M) {
+	if os.Getenv("GO_ADDR2LINETEST_IS_ADDR2LINE") != "" {
+		main()
+		os.Exit(0)
+	}
+
+	os.Setenv("GO_ADDR2LINETEST_IS_ADDR2LINE", "1") // Set for subprocesses to inherit.
+	os.Exit(m.Run())
+}
+
+func loadSyms(t *testing.T, dbgExePath string) map[string]string {
+	cmd := testenv.Command(t, testenv.GoToolPath(t), "tool", "nm", dbgExePath)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("%v: %v\n%s", cmd, err, string(out))
+	}
+	syms := make(map[string]string)
+	scanner := bufio.NewScanner(bytes.NewReader(out))
+	for scanner.Scan() {
+		f := strings.Fields(scanner.Text())
+		if len(f) < 3 {
+			continue
+		}
+		syms[f[2]] = f[0]
+	}
+	if err := scanner.Err(); err != nil {
+		t.Fatalf("error reading symbols: %v", err)
+	}
+	return syms
+}
+
+func runAddr2Line(t *testing.T, dbgExePath, addr string) (funcname, path, lineno string) {
+	cmd := testenv.Command(t, testenv.Executable(t), dbgExePath)
+	cmd.Stdin = strings.NewReader(addr)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("go tool addr2line %v: %v\n%s", os.Args[0], err, string(out))
+	}
+	f := strings.Split(string(out), "\n")
+	if len(f) < 3 && f[2] == "" {
+		t.Fatal("addr2line output must have 2 lines")
+	}
+	funcname = f[0]
+	pathAndLineNo := f[1]
+	f = strings.Split(pathAndLineNo, ":")
+	if runtime.GOOS == "windows" && len(f) == 3 {
+		// Reattach drive letter.
+		f = []string{f[0] + ":" + f[1], f[2]}
+	}
+	if len(f) != 2 {
+		t.Fatalf("no line number found in %q", pathAndLineNo)
+	}
+	return funcname, f[0], f[1]
+}
+
+const symName = "cmd/addr2line.TestAddr2Line"
+
+func testAddr2Line(t *testing.T, dbgExePath, addr string) {
+	funcName, srcPath, srcLineNo := runAddr2Line(t, dbgExePath, addr)
+	if symName != funcName {
+		t.Fatalf("expected function name %v; got %v", symName, funcName)
+	}
+	fi1, err := os.Stat("addr2line_test.go")
+	if err != nil {
+		t.Fatalf("Stat failed: %v", err)
+	}
+
+	// Debug paths are stored slash-separated, so convert to system-native.
+	srcPath = filepath.FromSlash(srcPath)
+	fi2, err := os.Stat(srcPath)
+	if err != nil {
+		t.Fatalf("Stat failed: %v", err)
+	}
+	if !os.SameFile(fi1, fi2) {
+		t.Fatalf("addr2line_test.go and %s are not same file", srcPath)
+	}
+	if want := "102"; srcLineNo != want {
+		t.Fatalf("line number = %v; want %s", srcLineNo, want)
+	}
+}
+
+// This is line 101. The test depends on that.
+func TestAddr2Line(t *testing.T) {
+	testenv.MustHaveGoBuild(t)
+
+	tmpDir := t.TempDir()
+
+	// Build copy of test binary with debug symbols,
+	// since the one running now may not have them.
+	exepath := filepath.Join(tmpDir, "testaddr2line_test.exe")
+	out, err := testenv.Command(t, testenv.GoToolPath(t), "test", "-c", "-o", exepath, "cmd/addr2line").CombinedOutput()
+	if err != nil {
+		t.Fatalf("go test -c -o %v cmd/addr2line: %v\n%s", exepath, err, string(out))
+	}
+
+	syms := loadSyms(t, exepath)
+
+	testAddr2Line(t, exepath, syms[symName])
+	testAddr2Line(t, exepath, "0x"+syms[symName])
+}

go/src/cmd/addr2line/main.go

@@ -0,0 +1,101 @@
+// Copyright 2012 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.
+
+// Addr2line is a minimal simulation of the GNU addr2line tool,
+// just enough to support pprof.
+//
+// Usage:
+//
+//	go tool addr2line binary
+//
+// Addr2line reads hexadecimal addresses, one per line and with optional 0x prefix,
+// from standard input. For each input address, addr2line prints two output lines,
+// first the name of the function containing the address and second the file:line
+// of the source code corresponding to that address.
+//
+// This tool is intended for use only by pprof; its interface may change or
+// it may be deleted entirely in future releases.
+package main
+
+import (
+	"bufio"
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"strconv"
+	"strings"
+
+	"cmd/internal/objfile"
+	"cmd/internal/telemetry/counter"
+)
+
+func printUsage(w *os.File) {
+	fmt.Fprintf(w, "usage: addr2line binary\n")
+	fmt.Fprintf(w, "reads addresses from standard input and writes two lines for each:\n")
+	fmt.Fprintf(w, "\tfunction name\n")
+	fmt.Fprintf(w, "\tfile:line\n")
+}
+
+func usage() {
+	printUsage(os.Stderr)
+	os.Exit(2)
+}
+
+func main() {
+	log.SetFlags(0)
+	log.SetPrefix("addr2line: ")
+	counter.Open()
+
+	// pprof expects this behavior when checking for addr2line
+	if len(os.Args) > 1 && os.Args[1] == "--help" {
+		printUsage(os.Stdout)
+		os.Exit(0)
+	}
+
+	flag.Usage = usage
+	flag.Parse()
+	counter.Inc("addr2line/invocations")
+	counter.CountFlags("addr2line/flag:", *flag.CommandLine)
+	if flag.NArg() != 1 {
+		usage()
+	}
+
+	f, err := objfile.Open(flag.Arg(0))
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer f.Close()
+
+	tab, err := f.PCLineTable()
+	if err != nil {
+		log.Fatalf("reading %s: %v", flag.Arg(0), err)
+	}
+
+	stdin := bufio.NewScanner(os.Stdin)
+	stdout := bufio.NewWriter(os.Stdout)
+
+	for stdin.Scan() {
+		p := stdin.Text()
+		if strings.Contains(p, ":") {
+			// Reverse translate file:line to pc.
+			// This was an extension in the old C version of 'go tool addr2line'
+			// and is probably not used by anyone, but recognize the syntax.
+			// We don't have an implementation.
+			fmt.Fprintf(stdout, "!reverse translation not implemented\n")
+			continue
+		}
+		pc, _ := strconv.ParseUint(strings.TrimPrefix(p, "0x"), 16, 64)
+		file, line, fn := tab.PCToLine(pc)
+		name := "?"
+		if fn != nil {
+			name = fn.Name
+		} else {
+			file = "?"
+			line = 0
+		}
+		fmt.Fprintf(stdout, "%s\n%s:%d\n", name, file, line)
+	}
+	stdout.Flush()
+}

go/src/cmd/api/api_test.go

@@ -0,0 +1,337 @@
+// Copyright 2011 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 (
+	"flag"
+	"fmt"
+	"go/build"
+	"internal/testenv"
+	"os"
+	"path/filepath"
+	"slices"
+	"strings"
+	"sync"
+	"testing"
+)
+
+var flagCheck = flag.Bool("check", false, "run API checks")
+
+func TestMain(m *testing.M) {
+	flag.Parse()
+	for _, c := range contexts {
+		c.Compiler = build.Default.Compiler
+	}
+	build.Default.GOROOT = testenv.GOROOT(nil)
+
+	os.Exit(m.Run())
+}
+
+var (
+	updateGolden = flag.Bool("updategolden", false, "update golden files")
+)
+
+func TestGolden(t *testing.T) {
+	if *flagCheck {
+		// slow, not worth repeating in -check
+		t.Skip("skipping with -check set")
+	}
+
+	testenv.MustHaveGoBuild(t)
+
+	td, err := os.Open("testdata/src/pkg")
+	if err != nil {
+		t.Fatal(err)
+	}
+	fis, err := td.Readdir(0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fi := range fis {
+		if !fi.IsDir() {
+			continue
+		}
+
+		// TODO(gri) remove extra pkg directory eventually
+		goldenFile := filepath.Join("testdata", "src", "pkg", fi.Name(), "golden.txt")
+		w := NewWalker(nil, "testdata/src/pkg")
+		pkg, err := w.import_(fi.Name())
+		if err != nil {
+			t.Fatalf("import %s: %v", fi.Name(), err)
+		}
+		w.export(pkg)
+
+		if *updateGolden {
+			os.Remove(goldenFile)
+			f, err := os.Create(goldenFile)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, feat := range w.Features() {
+				fmt.Fprintf(f, "%s\n", feat)
+			}
+			f.Close()
+		}
+
+		bs, err := os.ReadFile(goldenFile)
+		if err != nil {
+			t.Fatalf("opening golden.txt for package %q: %v", fi.Name(), err)
+		}
+		wanted := strings.Split(string(bs), "\n")
+		slices.Sort(wanted)
+		for _, feature := range wanted {
+			if feature == "" {
+				continue
+			}
+			_, ok := w.features[feature]
+			if !ok {
+				t.Errorf("package %s: missing feature %q", fi.Name(), feature)
+			}
+			delete(w.features, feature)
+		}
+
+		for _, feature := range w.Features() {
+			t.Errorf("package %s: extra feature not in golden file: %q", fi.Name(), feature)
+		}
+	}
+}
+
+func TestCompareAPI(t *testing.T) {
+	if *flagCheck {
+		// not worth repeating in -check
+		t.Skip("skipping with -check set")
+	}
+
+	tests := []struct {
+		name                          string
+		features, required, exception []string
+		ok                            bool   // want
+		out                           string // want
+	}{
+		{
+			name:     "equal",
+			features: []string{"A", "B", "C"},
+			required: []string{"A", "B", "C"},
+			ok:       true,
+			out:      "",
+		},
+		{
+			name:     "feature added",
+			features: []string{"A", "B", "C", "D", "E", "F"},
+			required: []string{"B", "D"},
+			ok:       false,
+			out:      "+A\n+C\n+E\n+F\n",
+		},
+		{
+			name:     "feature removed",
+			features: []string{"C", "A"},
+			required: []string{"A", "B", "C"},
+			ok:       false,
+			out:      "-B\n",
+		},
+		{
+			name:      "exception removal",
+			features:  []string{"A", "C"},
+			required:  []string{"A", "B", "C"},
+			exception: []string{"B"},
+			ok:        true,
+			out:       "",
+		},
+
+		// Test that a feature required on a subset of ports is implicitly satisfied
+		// by the same feature being implemented on all ports. That is, it shouldn't
+		// say "pkg syscall (darwin-amd64), type RawSockaddrInet6 struct" is missing.
+		// See https://go.dev/issue/4303.
+		{
+			name: "contexts reconverging after api/next/* update",
+			features: []string{
+				"A",
+				"pkg syscall, type RawSockaddrInet6 struct",
+			},
+			required: []string{
+				"A",
+				"pkg syscall (darwin-amd64), type RawSockaddrInet6 struct", // api/go1.n.txt
+				"pkg syscall, type RawSockaddrInet6 struct",                // api/next/n.txt
+			},
+			ok:  true,
+			out: "",
+		},
+		{
+			name: "contexts reconverging before api/next/* update",
+			features: []string{
+				"A",
+				"pkg syscall, type RawSockaddrInet6 struct",
+			},
+			required: []string{
+				"A",
+				"pkg syscall (darwin-amd64), type RawSockaddrInet6 struct",
+			},
+			ok:  false,
+			out: "+pkg syscall, type RawSockaddrInet6 struct\n",
+		},
+	}
+	for _, tt := range tests {
+		buf := new(strings.Builder)
+		gotOK := compareAPI(buf, tt.features, tt.required, tt.exception)
+		if gotOK != tt.ok {
+			t.Errorf("%s: ok = %v; want %v", tt.name, gotOK, tt.ok)
+		}
+		if got := buf.String(); got != tt.out {
+			t.Errorf("%s: output differs\nGOT:\n%s\nWANT:\n%s", tt.name, got, tt.out)
+		}
+	}
+}
+
+func TestSkipInternal(t *testing.T) {
+	if *flagCheck {
+		// not worth repeating in -check
+		t.Skip("skipping with -check set")
+	}
+
+	tests := []struct {
+		pkg  string
+		want bool
+	}{
+		{"net/http", true},
+		{"net/http/internal-foo", true},
+		{"net/http/internal", false},
+		{"net/http/internal/bar", false},
+		{"internal/foo", false},
+		{"internal", false},
+	}
+	for _, tt := range tests {
+		got := !internalPkg.MatchString(tt.pkg)
+		if got != tt.want {
+			t.Errorf("%s is internal = %v; want %v", tt.pkg, got, tt.want)
+		}
+	}
+}
+
+func BenchmarkAll(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		for _, context := range contexts {
+			w := NewWalker(context, filepath.Join(testenv.GOROOT(b), "src"))
+			for _, name := range w.stdPackages {
+				pkg, err := w.import_(name)
+				if _, nogo := err.(*build.NoGoError); nogo {
+					continue
+				}
+				if err != nil {
+					b.Fatalf("import %s (%s-%s): %v", name, context.GOOS, context.GOARCH, err)
+				}
+				w.export(pkg)
+			}
+			w.Features()
+		}
+	}
+}
+
+var warmupCache = sync.OnceFunc(func() {
+	// Warm up the import cache in parallel.
+	var wg sync.WaitGroup
+	for _, context := range contexts {
+		context := context
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			_ = NewWalker(context, filepath.Join(testenv.GOROOT(nil), "src"))
+		}()
+	}
+	wg.Wait()
+})
+
+func TestIssue21181(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping with -short")
+	}
+	if *flagCheck {
+		// slow, not worth repeating in -check
+		t.Skip("skipping with -check set")
+	}
+	testenv.MustHaveGoBuild(t)
+
+	warmupCache()
+
+	for _, context := range contexts {
+		w := NewWalker(context, "testdata/src/issue21181")
+		pkg, err := w.import_("p")
+		if err != nil {
+			t.Fatalf("import %s (%s-%s): %v", "p", context.GOOS, context.GOARCH, err)
+		}
+		w.export(pkg)
+	}
+}
+
+func TestIssue29837(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping with -short")
+	}
+	if *flagCheck {
+		// slow, not worth repeating in -check
+		t.Skip("skipping with -check set")
+	}
+	testenv.MustHaveGoBuild(t)
+
+	warmupCache()
+
+	for _, context := range contexts {
+		w := NewWalker(context, "testdata/src/issue29837")
+		_, err := w.ImportFrom("p", "", 0)
+		if _, nogo := err.(*build.NoGoError); !nogo {
+			t.Errorf("expected *build.NoGoError, got %T", err)
+		}
+	}
+}
+
+func TestIssue41358(t *testing.T) {
+	if *flagCheck {
+		// slow, not worth repeating in -check
+		t.Skip("skipping with -check set")
+	}
+	testenv.MustHaveGoBuild(t)
+	context := new(build.Context)
+	*context = build.Default
+	context.Dir = filepath.Join(testenv.GOROOT(t), "src")
+
+	w := NewWalker(context, context.Dir)
+	for _, pkg := range w.stdPackages {
+		if strings.HasPrefix(pkg, "vendor/") || strings.HasPrefix(pkg, "golang.org/x/") {
+			t.Fatalf("stdPackages contains unexpected package %s", pkg)
+		}
+	}
+}
+
+func TestIssue64958(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping with -short")
+	}
+	if *flagCheck {
+		// slow, not worth repeating in -check
+		t.Skip("skipping with -check set")
+	}
+	testenv.MustHaveGoBuild(t)
+
+	defer func() {
+		if x := recover(); x != nil {
+			t.Errorf("expected no panic; recovered %v", x)
+		}
+	}()
+	for _, context := range contexts {
+		w := NewWalker(context, "testdata/src/issue64958")
+		pkg, err := w.importFrom("p", "", 0)
+		if err != nil {
+			t.Errorf("expected no error importing; got %T", err)
+		}
+		w.export(pkg)
+	}
+}
+
+func TestCheck(t *testing.T) {
+	if !*flagCheck {
+		t.Skip("-check not specified")
+	}
+	testenv.MustHaveGoBuild(t)
+	Check(t)
+}

go/src/cmd/api/boring_test.go

@@ -0,0 +1,17 @@
+// Copyright 2022 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.
+
+//go:build boringcrypto
+
+package main
+
+import (
+	"fmt"
+	"os"
+)
+
+func init() {
+	fmt.Printf("SKIP with boringcrypto enabled\n")
+	os.Exit(0)
+}

go/src/cmd/api/main_test.go

@@ -0,0 +1,1244 @@
+// Copyright 2011 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.
+
+// This package computes the exported API of a set of Go packages.
+// It is only a test, not a command, nor a usefully importable package.
+
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"internal/testenv"
+	"io"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"slices"
+	"strconv"
+	"strings"
+	"sync"
+	"testing"
+)
+
+const verbose = false
+
+func goCmd() string {
+	var exeSuffix string
+	if runtime.GOOS == "windows" {
+		exeSuffix = ".exe"
+	}
+	path := filepath.Join(testenv.GOROOT(nil), "bin", "go"+exeSuffix)
+	if _, err := os.Stat(path); err == nil {
+		return path
+	}
+	return "go"
+}
+
+// contexts are the default contexts which are scanned.
+var contexts = []*build.Context{
+	{GOOS: "linux", GOARCH: "386", CgoEnabled: true},
+	{GOOS: "linux", GOARCH: "386"},
+	{GOOS: "linux", GOARCH: "amd64", CgoEnabled: true},
+	{GOOS: "linux", GOARCH: "amd64"},
+	{GOOS: "linux", GOARCH: "arm", CgoEnabled: true},
+	{GOOS: "linux", GOARCH: "arm"},
+	{GOOS: "darwin", GOARCH: "amd64", CgoEnabled: true},
+	{GOOS: "darwin", GOARCH: "amd64"},
+	{GOOS: "darwin", GOARCH: "arm64", CgoEnabled: true},
+	{GOOS: "darwin", GOARCH: "arm64"},
+	{GOOS: "windows", GOARCH: "amd64"},
+	{GOOS: "windows", GOARCH: "386"},
+	{GOOS: "freebsd", GOARCH: "386", CgoEnabled: true},
+	{GOOS: "freebsd", GOARCH: "386"},
+	{GOOS: "freebsd", GOARCH: "amd64", CgoEnabled: true},
+	{GOOS: "freebsd", GOARCH: "amd64"},
+	{GOOS: "freebsd", GOARCH: "arm", CgoEnabled: true},
+	{GOOS: "freebsd", GOARCH: "arm"},
+	{GOOS: "freebsd", GOARCH: "arm64", CgoEnabled: true},
+	{GOOS: "freebsd", GOARCH: "arm64"},
+	{GOOS: "freebsd", GOARCH: "riscv64", CgoEnabled: true},
+	{GOOS: "freebsd", GOARCH: "riscv64"},
+	{GOOS: "netbsd", GOARCH: "386", CgoEnabled: true},
+	{GOOS: "netbsd", GOARCH: "386"},
+	{GOOS: "netbsd", GOARCH: "amd64", CgoEnabled: true},
+	{GOOS: "netbsd", GOARCH: "amd64"},
+	{GOOS: "netbsd", GOARCH: "arm", CgoEnabled: true},
+	{GOOS: "netbsd", GOARCH: "arm"},
+	{GOOS: "netbsd", GOARCH: "arm64", CgoEnabled: true},
+	{GOOS: "netbsd", GOARCH: "arm64"},
+	{GOOS: "openbsd", GOARCH: "386", CgoEnabled: true},
+	{GOOS: "openbsd", GOARCH: "386"},
+	{GOOS: "openbsd", GOARCH: "amd64", CgoEnabled: true},
+	{GOOS: "openbsd", GOARCH: "amd64"},
+}
+
+func contextName(c *build.Context) string {
+	s := c.GOOS + "-" + c.GOARCH
+	if c.CgoEnabled {
+		s += "-cgo"
+	}
+	if c.Dir != "" {
+		s += fmt.Sprintf(" [%s]", c.Dir)
+	}
+	return s
+}
+
+var internalPkg = regexp.MustCompile(`(^|/)internal($|/)`)
+
+var exitCode = 0
+
+func Check(t *testing.T) {
+	checkFiles, err := filepath.Glob(filepath.Join(testenv.GOROOT(t), "api/go1*.txt"))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var nextFiles []string
+	if v := runtime.Version(); strings.Contains(v, "devel") || strings.Contains(v, "beta") {
+		next, err := filepath.Glob(filepath.Join(testenv.GOROOT(t), "api/next/*.txt"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		nextFiles = next
+	}
+
+	for _, c := range contexts {
+		c.Compiler = build.Default.Compiler
+	}
+
+	walkers := make([]*Walker, len(contexts))
+	var wg sync.WaitGroup
+	for i, context := range contexts {
+		i, context := i, context
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			walkers[i] = NewWalker(context, filepath.Join(testenv.GOROOT(t), "src"))
+		}()
+	}
+	wg.Wait()
+
+	var featureCtx = make(map[string]map[string]bool) // feature -> context name -> true
+	for _, w := range walkers {
+		for _, name := range w.stdPackages {
+			pkg, err := w.import_(name)
+			if _, nogo := err.(*build.NoGoError); nogo {
+				continue
+			}
+			if err != nil {
+				log.Fatalf("Import(%q): %v", name, err)
+			}
+			w.export(pkg)
+		}
+
+		ctxName := contextName(w.context)
+		for _, f := range w.Features() {
+			if featureCtx[f] == nil {
+				featureCtx[f] = make(map[string]bool)
+			}
+			featureCtx[f][ctxName] = true
+		}
+	}
+
+	var features []string
+	for f, cmap := range featureCtx {
+		if len(cmap) == len(contexts) {
+			features = append(features, f)
+			continue
+		}
+		comma := strings.Index(f, ",")
+		for cname := range cmap {
+			f2 := fmt.Sprintf("%s (%s)%s", f[:comma], cname, f[comma:])
+			features = append(features, f2)
+		}
+	}
+
+	bw := bufio.NewWriter(os.Stdout)
+	defer bw.Flush()
+
+	var required []string
+	for _, file := range checkFiles {
+		required = append(required, fileFeatures(file, needApproval(file))...)
+	}
+	for _, file := range nextFiles {
+		required = append(required, fileFeatures(file, true)...)
+	}
+	exception := fileFeatures(filepath.Join(testenv.GOROOT(t), "api/except.txt"), false)
+
+	if exitCode == 1 {
+		t.Errorf("API database problems found")
+	}
+	if !compareAPI(bw, features, required, exception) {
+		t.Errorf("API differences found")
+	}
+}
+
+// export emits the exported package features.
+func (w *Walker) export(pkg *apiPackage) {
+	if verbose {
+		log.Println(pkg)
+	}
+	pop := w.pushScope("pkg " + pkg.Path())
+	w.current = pkg
+	w.collectDeprecated()
+	scope := pkg.Scope()
+	for _, name := range scope.Names() {
+		if token.IsExported(name) {
+			w.emitObj(scope.Lookup(name))
+		}
+	}
+	pop()
+}
+
+func set(items []string) map[string]bool {
+	s := make(map[string]bool)
+	for _, v := range items {
+		s[v] = true
+	}
+	return s
+}
+
+var spaceParensRx = regexp.MustCompile(` \(\S+?\)`)
+
+func featureWithoutContext(f string) string {
+	if !strings.Contains(f, "(") {
+		return f
+	}
+	return spaceParensRx.ReplaceAllString(f, "")
+}
+
+// portRemoved reports whether the given port-specific API feature is
+// okay to no longer exist because its port was removed.
+func portRemoved(feature string) bool {
+	return strings.Contains(feature, "(darwin-386)") ||
+		strings.Contains(feature, "(darwin-386-cgo)")
+}
+
+func compareAPI(w io.Writer, features, required, exception []string) (ok bool) {
+	ok = true
+
+	featureSet := set(features)
+	exceptionSet := set(exception)
+
+	slices.Sort(features)
+	slices.Sort(required)
+
+	take := func(sl *[]string) string {
+		s := (*sl)[0]
+		*sl = (*sl)[1:]
+		return s
+	}
+
+	for len(features) > 0 || len(required) > 0 {
+		switch {
+		case len(features) == 0 || (len(required) > 0 && required[0] < features[0]):
+			feature := take(&required)
+			if exceptionSet[feature] {
+				// An "unfortunate" case: the feature was once
+				// included in the API (e.g. go1.txt), but was
+				// subsequently removed. These are already
+				// acknowledged by being in the file
+				// "api/except.txt". No need to print them out
+				// here.
+			} else if portRemoved(feature) {
+				// okay.
+			} else if featureSet[featureWithoutContext(feature)] {
+				// okay.
+			} else {
+				fmt.Fprintf(w, "-%s\n", feature)
+				ok = false // broke compatibility
+			}
+		case len(required) == 0 || (len(features) > 0 && required[0] > features[0]):
+			newFeature := take(&features)
+			fmt.Fprintf(w, "+%s\n", newFeature)
+			ok = false // feature not in api/next/*
+		default:
+			take(&required)
+			take(&features)
+		}
+	}
+
+	return ok
+}
+
+// aliasReplacer applies type aliases to earlier API files,
+// to avoid misleading negative results.
+// This makes all the references to os.FileInfo in go1.txt
+// be read as if they said fs.FileInfo, since os.FileInfo is now an alias.
+// If there are many of these, we could do a more general solution,
+// but for now the replacer is fine.
+var aliasReplacer = strings.NewReplacer(
+	"os.FileInfo", "fs.FileInfo",
+	"os.FileMode", "fs.FileMode",
+	"os.PathError", "fs.PathError",
+)
+
+func fileFeatures(filename string, needApproval bool) []string {
+	bs, err := os.ReadFile(filename)
+	if err != nil {
+		log.Fatal(err)
+	}
+	s := string(bs)
+
+	// Diagnose common mistakes people make,
+	// since there is no apifmt to format these files.
+	// The missing final newline is important for the
+	// final release step of cat next/*.txt >go1.X.txt.
+	// If the files don't end in full lines, the concatenation goes awry.
+	if strings.Contains(s, "\r") {
+		log.Printf("%s: contains CRLFs", filename)
+		exitCode = 1
+	}
+	if filepath.Base(filename) == "go1.4.txt" {
+		// No use for blank lines in api files, except go1.4.txt
+		// used them in a reasonable way and we should let it be.
+	} else if strings.HasPrefix(s, "\n") || strings.Contains(s, "\n\n") {
+		log.Printf("%s: contains a blank line", filename)
+		exitCode = 1
+	}
+	if s == "" {
+		log.Printf("%s: empty file", filename)
+		exitCode = 1
+	} else if s[len(s)-1] != '\n' {
+		log.Printf("%s: missing final newline", filename)
+		exitCode = 1
+	}
+	s = aliasReplacer.Replace(s)
+	lines := strings.Split(s, "\n")
+	var nonblank []string
+	for i, line := range lines {
+		line = strings.TrimSpace(line)
+		if line == "" || strings.HasPrefix(line, "#") {
+			continue
+		}
+		if needApproval {
+			feature, approval, ok := strings.Cut(line, "#")
+			if !ok {
+				log.Printf("%s:%d: missing proposal approval\n", filename, i+1)
+				exitCode = 1
+			} else {
+				_, err := strconv.Atoi(approval)
+				if err != nil {
+					log.Printf("%s:%d: malformed proposal approval #%s\n", filename, i+1, approval)
+					exitCode = 1
+				}
+			}
+			line = strings.TrimSpace(feature)
+		} else {
+			if strings.Contains(line, " #") {
+				log.Printf("%s:%d: unexpected approval\n", filename, i+1)
+				exitCode = 1
+			}
+		}
+		nonblank = append(nonblank, line)
+	}
+	return nonblank
+}
+
+var fset = token.NewFileSet()
+
+type Walker struct {
+	context     *build.Context
+	root        string
+	scope       []string
+	current     *apiPackage
+	deprecated  map[token.Pos]bool
+	features    map[string]bool              // set
+	imported    map[string]*apiPackage       // packages already imported
+	stdPackages []string                     // names, omitting "unsafe", internal, and vendored packages
+	importMap   map[string]map[string]string // importer dir -> import path -> canonical path
+	importDir   map[string]string            // canonical import path -> dir
+
+}
+
+func NewWalker(context *build.Context, root string) *Walker {
+	w := &Walker{
+		context:  context,
+		root:     root,
+		features: map[string]bool{},
+		imported: map[string]*apiPackage{"unsafe": &apiPackage{Package: types.Unsafe}},
+	}
+	w.loadImports()
+	return w
+}
+
+func (w *Walker) Features() (fs []string) {
+	for f := range w.features {
+		fs = append(fs, f)
+	}
+	slices.Sort(fs)
+	return
+}
+
+var parsedFileCache = make(map[string]*ast.File)
+
+func (w *Walker) parseFile(dir, file string) (*ast.File, error) {
+	filename := filepath.Join(dir, file)
+	if f := parsedFileCache[filename]; f != nil {
+		return f, nil
+	}
+
+	f, err := parser.ParseFile(fset, filename, nil, parser.ParseComments)
+	if err != nil {
+		return nil, err
+	}
+	parsedFileCache[filename] = f
+
+	return f, nil
+}
+
+// Disable before debugging non-obvious errors from the type-checker.
+const usePkgCache = true
+
+var (
+	pkgCache = map[string]*apiPackage{} // map tagKey to package
+	pkgTags  = map[string][]string{}    // map import dir to list of relevant tags
+)
+
+// tagKey returns the tag-based key to use in the pkgCache.
+// It is a comma-separated string; the first part is dir, the rest tags.
+// The satisfied tags are derived from context but only those that
+// matter (the ones listed in the tags argument plus GOOS and GOARCH) are used.
+// The tags list, which came from go/build's Package.AllTags,
+// is known to be sorted.
+func tagKey(dir string, context *build.Context, tags []string) string {
+	ctags := map[string]bool{
+		context.GOOS:   true,
+		context.GOARCH: true,
+	}
+	if context.CgoEnabled {
+		ctags["cgo"] = true
+	}
+	for _, tag := range context.BuildTags {
+		ctags[tag] = true
+	}
+	// TODO: ReleaseTags (need to load default)
+	key := dir
+
+	// explicit on GOOS and GOARCH as global cache will use "all" cached packages for
+	// an indirect imported package. See https://github.com/golang/go/issues/21181
+	// for more detail.
+	tags = append(tags, context.GOOS, context.GOARCH)
+	slices.Sort(tags)
+
+	for _, tag := range tags {
+		if ctags[tag] {
+			key += "," + tag
+			ctags[tag] = false
+		}
+	}
+	return key
+}
+
+type listImports struct {
+	stdPackages []string                     // names, omitting "unsafe", internal, and vendored packages
+	importDir   map[string]string            // canonical import path → directory
+	importMap   map[string]map[string]string // import path → canonical import path
+}
+
+var listCache sync.Map // map[string]listImports, keyed by contextName
+
+// listSem is a semaphore restricting concurrent invocations of 'go list'. 'go
+// list' has its own internal concurrency, so we use a hard-coded constant (to
+// allow the I/O-intensive phases of 'go list' to overlap) instead of scaling
+// all the way up to GOMAXPROCS.
+var listSem = make(chan semToken, 2)
+
+type semToken struct{}
+
+// loadImports populates w with information about the packages in the standard
+// library and the packages they themselves import in w's build context.
+//
+// The source import path and expanded import path are identical except for vendored packages.
+// For example, on return:
+//
+//	w.importMap["math"] = "math"
+//	w.importDir["math"] = "<goroot>/src/math"
+//
+//	w.importMap["golang.org/x/net/route"] = "vendor/golang.org/x/net/route"
+//	w.importDir["vendor/golang.org/x/net/route"] = "<goroot>/src/vendor/golang.org/x/net/route"
+//
+// Since the set of packages that exist depends on context, the result of
+// loadImports also depends on context. However, to improve test running time
+// the configuration for each environment is cached across runs.
+func (w *Walker) loadImports() {
+	if w.context == nil {
+		return // test-only Walker; does not use the import map
+	}
+
+	name := contextName(w.context)
+
+	imports, ok := listCache.Load(name)
+	if !ok {
+		listSem <- semToken{}
+		defer func() { <-listSem }()
+
+		cmd := exec.Command(goCmd(), "list", "-e", "-deps", "-json", "std")
+		cmd.Env = listEnv(w.context)
+		if w.context.Dir != "" {
+			cmd.Dir = w.context.Dir
+		}
+		cmd.Stderr = os.Stderr
+		out, err := cmd.Output()
+		if err != nil {
+			log.Fatalf("loading imports: %v\n%s", err, out)
+		}
+
+		var stdPackages []string
+		importMap := make(map[string]map[string]string)
+		importDir := make(map[string]string)
+		dec := json.NewDecoder(bytes.NewReader(out))
+		for {
+			var pkg struct {
+				ImportPath, Dir string
+				ImportMap       map[string]string
+				Standard        bool
+			}
+			err := dec.Decode(&pkg)
+			if err == io.EOF {
+				break
+			}
+			if err != nil {
+				log.Fatalf("go list: invalid output: %v", err)
+			}
+
+			// - Package "unsafe" contains special signatures requiring
+			//   extra care when printing them - ignore since it is not
+			//   going to change w/o a language change.
+			// - Internal and vendored packages do not contribute to our
+			//   API surface. (If we are running within the "std" module,
+			//   vendored dependencies appear as themselves instead of
+			//   their "vendor/" standard-library copies.)
+			// - 'go list std' does not include commands, which cannot be
+			//   imported anyway.
+			if ip := pkg.ImportPath; pkg.Standard && ip != "unsafe" && !strings.HasPrefix(ip, "vendor/") && !internalPkg.MatchString(ip) {
+				stdPackages = append(stdPackages, ip)
+			}
+			importDir[pkg.ImportPath] = pkg.Dir
+			if len(pkg.ImportMap) > 0 {
+				importMap[pkg.Dir] = make(map[string]string, len(pkg.ImportMap))
+			}
+			for k, v := range pkg.ImportMap {
+				importMap[pkg.Dir][k] = v
+			}
+		}
+
+		slices.Sort(stdPackages)
+		imports = listImports{
+			stdPackages: stdPackages,
+			importMap:   importMap,
+			importDir:   importDir,
+		}
+		imports, _ = listCache.LoadOrStore(name, imports)
+	}
+
+	li := imports.(listImports)
+	w.stdPackages = li.stdPackages
+	w.importDir = li.importDir
+	w.importMap = li.importMap
+}
+
+// listEnv returns the process environment to use when invoking 'go list' for
+// the given context.
+func listEnv(c *build.Context) []string {
+	if c == nil {
+		return os.Environ()
+	}
+
+	environ := append(os.Environ(),
+		"GOOS="+c.GOOS,
+		"GOARCH="+c.GOARCH)
+	if c.CgoEnabled {
+		environ = append(environ, "CGO_ENABLED=1")
+	} else {
+		environ = append(environ, "CGO_ENABLED=0")
+	}
+	return environ
+}
+
+type apiPackage struct {
+	*types.Package
+	Files []*ast.File
+}
+
+// Importing is a sentinel taking the place in Walker.imported
+// for a package that is in the process of being imported.
+var importing apiPackage
+
+// Import implements types.Importer.
+func (w *Walker) Import(name string) (*types.Package, error) {
+	return w.ImportFrom(name, "", 0)
+}
+
+// ImportFrom implements types.ImporterFrom.
+func (w *Walker) ImportFrom(fromPath, fromDir string, mode types.ImportMode) (*types.Package, error) {
+	pkg, err := w.importFrom(fromPath, fromDir, mode)
+	if err != nil {
+		return nil, err
+	}
+	return pkg.Package, nil
+}
+
+func (w *Walker) import_(name string) (*apiPackage, error) {
+	return w.importFrom(name, "", 0)
+}
+
+func (w *Walker) importFrom(fromPath, fromDir string, mode types.ImportMode) (*apiPackage, error) {
+	name := fromPath
+	if canonical, ok := w.importMap[fromDir][fromPath]; ok {
+		name = canonical
+	}
+
+	pkg := w.imported[name]
+	if pkg != nil {
+		if pkg == &importing {
+			log.Fatalf("cycle importing package %q", name)
+		}
+		return pkg, nil
+	}
+	w.imported[name] = &importing
+
+	// Determine package files.
+	dir := w.importDir[name]
+	if dir == "" {
+		dir = filepath.Join(w.root, filepath.FromSlash(name))
+	}
+	if fi, err := os.Stat(dir); err != nil || !fi.IsDir() {
+		log.Panicf("no source in tree for import %q (from import %s in %s): %v", name, fromPath, fromDir, err)
+	}
+
+	context := w.context
+	if context == nil {
+		context = &build.Default
+	}
+
+	// Look in cache.
+	// If we've already done an import with the same set
+	// of relevant tags, reuse the result.
+	var key string
+	if usePkgCache {
+		if tags, ok := pkgTags[dir]; ok {
+			key = tagKey(dir, context, tags)
+			if pkg := pkgCache[key]; pkg != nil {
+				w.imported[name] = pkg
+				return pkg, nil
+			}
+		}
+	}
+
+	info, err := context.ImportDir(dir, 0)
+	if err != nil {
+		if _, nogo := err.(*build.NoGoError); nogo {
+			return nil, err
+		}
+		log.Fatalf("pkg %q, dir %q: ScanDir: %v", name, dir, err)
+	}
+
+	// Save tags list first time we see a directory.
+	if usePkgCache {
+		if _, ok := pkgTags[dir]; !ok {
+			pkgTags[dir] = info.AllTags
+			key = tagKey(dir, context, info.AllTags)
+		}
+	}
+
+	filenames := append(append([]string{}, info.GoFiles...), info.CgoFiles...)
+
+	// Parse package files.
+	var files []*ast.File
+	for _, file := range filenames {
+		f, err := w.parseFile(dir, file)
+		if err != nil {
+			log.Fatalf("error parsing package %s: %s", name, err)
+		}
+		files = append(files, f)
+	}
+
+	// Type-check package files.
+	var sizes types.Sizes
+	if w.context != nil {
+		sizes = types.SizesFor(w.context.Compiler, w.context.GOARCH)
+	}
+	conf := types.Config{
+		IgnoreFuncBodies: true,
+		FakeImportC:      true,
+		Importer:         w,
+		Sizes:            sizes,
+	}
+	tpkg, err := conf.Check(name, fset, files, nil)
+	if err != nil {
+		ctxt := "<no context>"
+		if w.context != nil {
+			ctxt = fmt.Sprintf("%s-%s", w.context.GOOS, w.context.GOARCH)
+		}
+		log.Fatalf("error typechecking package %s: %s (%s)", name, err, ctxt)
+	}
+	pkg = &apiPackage{tpkg, files}
+
+	if usePkgCache {
+		pkgCache[key] = pkg
+	}
+
+	w.imported[name] = pkg
+	return pkg, nil
+}
+
+// pushScope enters a new scope (walking a package, type, node, etc)
+// and returns a function that will leave the scope (with sanity checking
+// for mismatched pushes & pops)
+func (w *Walker) pushScope(name string) (popFunc func()) {
+	w.scope = append(w.scope, name)
+	return func() {
+		if len(w.scope) == 0 {
+			log.Fatalf("attempt to leave scope %q with empty scope list", name)
+		}
+		if w.scope[len(w.scope)-1] != name {
+			log.Fatalf("attempt to leave scope %q, but scope is currently %#v", name, w.scope)
+		}
+		w.scope = w.scope[:len(w.scope)-1]
+	}
+}
+
+func sortedMethodNames(typ *types.Interface) []string {
+	n := typ.NumMethods()
+	list := make([]string, n)
+	for i := range list {
+		list[i] = typ.Method(i).Name()
+	}
+	slices.Sort(list)
+	return list
+}
+
+// sortedEmbeddeds returns constraint types embedded in an
+// interface. It does not include embedded interface types or methods.
+func (w *Walker) sortedEmbeddeds(typ *types.Interface) []string {
+	n := typ.NumEmbeddeds()
+	list := make([]string, 0, n)
+	for i := 0; i < n; i++ {
+		emb := typ.EmbeddedType(i)
+		switch emb := emb.(type) {
+		case *types.Interface:
+			list = append(list, w.sortedEmbeddeds(emb)...)
+		case *types.Union:
+			var buf bytes.Buffer
+			nu := emb.Len()
+			for i := 0; i < nu; i++ {
+				if i > 0 {
+					buf.WriteString(" | ")
+				}
+				term := emb.Term(i)
+				if term.Tilde() {
+					buf.WriteByte('~')
+				}
+				w.writeType(&buf, term.Type())
+			}
+			list = append(list, buf.String())
+		}
+	}
+	slices.Sort(list)
+	return list
+}
+
+func (w *Walker) writeType(buf *bytes.Buffer, typ types.Type) {
+	switch typ := typ.(type) {
+	case *types.Basic:
+		s := typ.Name()
+		switch typ.Kind() {
+		case types.UnsafePointer:
+			s = "unsafe.Pointer"
+		case types.UntypedBool:
+			s = "ideal-bool"
+		case types.UntypedInt:
+			s = "ideal-int"
+		case types.UntypedRune:
+			// "ideal-char" for compatibility with old tool
+			// TODO(gri) change to "ideal-rune"
+			s = "ideal-char"
+		case types.UntypedFloat:
+			s = "ideal-float"
+		case types.UntypedComplex:
+			s = "ideal-complex"
+		case types.UntypedString:
+			s = "ideal-string"
+		case types.UntypedNil:
+			panic("should never see untyped nil type")
+		default:
+			switch s {
+			case "byte":
+				s = "uint8"
+			case "rune":
+				s = "int32"
+			}
+		}
+		buf.WriteString(s)
+
+	case *types.Array:
+		fmt.Fprintf(buf, "[%d]", typ.Len())
+		w.writeType(buf, typ.Elem())
+
+	case *types.Slice:
+		buf.WriteString("[]")
+		w.writeType(buf, typ.Elem())
+
+	case *types.Struct:
+		buf.WriteString("struct")
+
+	case *types.Pointer:
+		buf.WriteByte('*')
+		w.writeType(buf, typ.Elem())
+
+	case *types.Tuple:
+		panic("should never see a tuple type")
+
+	case *types.Signature:
+		buf.WriteString("func")
+		w.writeSignature(buf, typ)
+
+	case *types.Interface:
+		buf.WriteString("interface{")
+		if typ.NumMethods() > 0 || typ.NumEmbeddeds() > 0 {
+			buf.WriteByte(' ')
+		}
+		if typ.NumMethods() > 0 {
+			buf.WriteString(strings.Join(sortedMethodNames(typ), ", "))
+		}
+		if typ.NumEmbeddeds() > 0 {
+			buf.WriteString(strings.Join(w.sortedEmbeddeds(typ), ", "))
+		}
+		if typ.NumMethods() > 0 || typ.NumEmbeddeds() > 0 {
+			buf.WriteByte(' ')
+		}
+		buf.WriteString("}")
+
+	case *types.Map:
+		buf.WriteString("map[")
+		w.writeType(buf, typ.Key())
+		buf.WriteByte(']')
+		w.writeType(buf, typ.Elem())
+
+	case *types.Chan:
+		var s string
+		switch typ.Dir() {
+		case types.SendOnly:
+			s = "chan<- "
+		case types.RecvOnly:
+			s = "<-chan "
+		case types.SendRecv:
+			s = "chan "
+		default:
+			panic("unreachable")
+		}
+		buf.WriteString(s)
+		w.writeType(buf, typ.Elem())
+
+	case *types.Alias:
+		w.writeType(buf, types.Unalias(typ))
+
+	case *types.Named:
+		obj := typ.Obj()
+		pkg := obj.Pkg()
+		if pkg != nil && pkg != w.current.Package {
+			buf.WriteString(pkg.Name())
+			buf.WriteByte('.')
+		}
+		buf.WriteString(typ.Obj().Name())
+		if targs := typ.TypeArgs(); targs.Len() > 0 {
+			buf.WriteByte('[')
+			for i := 0; i < targs.Len(); i++ {
+				if i > 0 {
+					buf.WriteString(", ")
+				}
+				w.writeType(buf, targs.At(i))
+			}
+			buf.WriteByte(']')
+		}
+
+	case *types.TypeParam:
+		// Type parameter names may change, so use a placeholder instead.
+		fmt.Fprintf(buf, "$%d", typ.Index())
+
+	default:
+		panic(fmt.Sprintf("unknown type %T", typ))
+	}
+}
+
+func (w *Walker) writeSignature(buf *bytes.Buffer, sig *types.Signature) {
+	if tparams := sig.TypeParams(); tparams != nil {
+		w.writeTypeParams(buf, tparams, true)
+	}
+	w.writeParams(buf, sig.Params(), sig.Variadic())
+	switch res := sig.Results(); res.Len() {
+	case 0:
+		// nothing to do
+	case 1:
+		buf.WriteByte(' ')
+		w.writeType(buf, res.At(0).Type())
+	default:
+		buf.WriteByte(' ')
+		w.writeParams(buf, res, false)
+	}
+}
+
+func (w *Walker) writeTypeParams(buf *bytes.Buffer, tparams *types.TypeParamList, withConstraints bool) {
+	buf.WriteByte('[')
+	c := tparams.Len()
+	for i := 0; i < c; i++ {
+		if i > 0 {
+			buf.WriteString(", ")
+		}
+		tp := tparams.At(i)
+		w.writeType(buf, tp)
+		if withConstraints {
+			buf.WriteByte(' ')
+			w.writeType(buf, tp.Constraint())
+		}
+	}
+	buf.WriteByte(']')
+}
+
+func (w *Walker) writeParams(buf *bytes.Buffer, t *types.Tuple, variadic bool) {
+	buf.WriteByte('(')
+	for i, n := 0, t.Len(); i < n; i++ {
+		if i > 0 {
+			buf.WriteString(", ")
+		}
+		typ := t.At(i).Type()
+		if variadic && i+1 == n {
+			buf.WriteString("...")
+			typ = typ.(*types.Slice).Elem()
+		}
+		w.writeType(buf, typ)
+	}
+	buf.WriteByte(')')
+}
+
+func (w *Walker) typeString(typ types.Type) string {
+	var buf bytes.Buffer
+	w.writeType(&buf, typ)
+	return buf.String()
+}
+
+func (w *Walker) signatureString(sig *types.Signature) string {
+	var buf bytes.Buffer
+	w.writeSignature(&buf, sig)
+	return buf.String()
+}
+
+func (w *Walker) emitObj(obj types.Object) {
+	switch obj := obj.(type) {
+	case *types.Const:
+		if w.isDeprecated(obj) {
+			w.emitf("const %s //deprecated", obj.Name())
+		}
+		w.emitf("const %s %s", obj.Name(), w.typeString(obj.Type()))
+		x := obj.Val()
+		short := x.String()
+		exact := x.ExactString()
+		if short == exact {
+			w.emitf("const %s = %s", obj.Name(), short)
+		} else {
+			w.emitf("const %s = %s  // %s", obj.Name(), short, exact)
+		}
+	case *types.Var:
+		if w.isDeprecated(obj) {
+			w.emitf("var %s //deprecated", obj.Name())
+		}
+		w.emitf("var %s %s", obj.Name(), w.typeString(obj.Type()))
+	case *types.TypeName:
+		w.emitType(obj)
+	case *types.Func:
+		w.emitFunc(obj)
+	default:
+		panic("unknown object: " + obj.String())
+	}
+}
+
+func (w *Walker) emitType(obj *types.TypeName) {
+	name := obj.Name()
+	if w.isDeprecated(obj) {
+		w.emitf("type %s //deprecated", name)
+	}
+	typ := obj.Type()
+	if obj.IsAlias() {
+		w.emitf("type %s = %s", name, w.typeString(typ))
+		return
+	}
+	if tparams := obj.Type().(*types.Named).TypeParams(); tparams != nil {
+		var buf bytes.Buffer
+		buf.WriteString(name)
+		w.writeTypeParams(&buf, tparams, true)
+		name = buf.String()
+	}
+	switch typ := typ.Underlying().(type) {
+	case *types.Struct:
+		w.emitStructType(name, typ)
+	case *types.Interface:
+		w.emitIfaceType(name, typ)
+		return // methods are handled by emitIfaceType
+	default:
+		w.emitf("type %s %s", name, w.typeString(typ.Underlying()))
+	}
+
+	// emit methods with value receiver
+	var methodNames map[string]bool
+	vset := types.NewMethodSet(typ)
+	for i, n := 0, vset.Len(); i < n; i++ {
+		m := vset.At(i)
+		if m.Obj().Exported() {
+			w.emitMethod(m)
+			if methodNames == nil {
+				methodNames = make(map[string]bool)
+			}
+			methodNames[m.Obj().Name()] = true
+		}
+	}
+
+	// emit methods with pointer receiver; exclude
+	// methods that we have emitted already
+	// (the method set of *T includes the methods of T)
+	pset := types.NewMethodSet(types.NewPointer(typ))
+	for i, n := 0, pset.Len(); i < n; i++ {
+		m := pset.At(i)
+		if m.Obj().Exported() && !methodNames[m.Obj().Name()] {
+			w.emitMethod(m)
+		}
+	}
+}
+
+func (w *Walker) emitStructType(name string, typ *types.Struct) {
+	typeStruct := fmt.Sprintf("type %s struct", name)
+	w.emitf("%s", typeStruct)
+	defer w.pushScope(typeStruct)()
+
+	for i := 0; i < typ.NumFields(); i++ {
+		f := typ.Field(i)
+		if !f.Exported() {
+			continue
+		}
+		typ := f.Type()
+		if f.Anonymous() {
+			if w.isDeprecated(f) {
+				w.emitf("embedded %s //deprecated", w.typeString(typ))
+			}
+			w.emitf("embedded %s", w.typeString(typ))
+			continue
+		}
+		if w.isDeprecated(f) {
+			w.emitf("%s //deprecated", f.Name())
+		}
+		w.emitf("%s %s", f.Name(), w.typeString(typ))
+	}
+}
+
+func (w *Walker) emitIfaceType(name string, typ *types.Interface) {
+	pop := w.pushScope("type " + name + " interface")
+
+	var methodNames []string
+	complete := true
+	mset := types.NewMethodSet(typ)
+	for i, n := 0, mset.Len(); i < n; i++ {
+		m := mset.At(i).Obj().(*types.Func)
+		if !m.Exported() {
+			complete = false
+			continue
+		}
+		methodNames = append(methodNames, m.Name())
+		if w.isDeprecated(m) {
+			w.emitf("%s //deprecated", m.Name())
+		}
+		w.emitf("%s%s", m.Name(), w.signatureString(m.Signature()))
+	}
+
+	if !complete {
+		// The method set has unexported methods, so all the
+		// implementations are provided by the same package,
+		// so the method set can be extended. Instead of recording
+		// the full set of names (below), record only that there were
+		// unexported methods. (If the interface shrinks, we will notice
+		// because a method signature emitted during the last loop
+		// will disappear.)
+		w.emitf("unexported methods")
+	}
+
+	pop()
+
+	if !complete {
+		return
+	}
+
+	if len(methodNames) == 0 {
+		w.emitf("type %s interface {}", name)
+		return
+	}
+
+	slices.Sort(methodNames)
+	w.emitf("type %s interface { %s }", name, strings.Join(methodNames, ", "))
+}
+
+func (w *Walker) emitFunc(f *types.Func) {
+	sig := f.Signature()
+	if sig.Recv() != nil {
+		panic("method considered a regular function: " + f.String())
+	}
+	if w.isDeprecated(f) {
+		w.emitf("func %s //deprecated", f.Name())
+	}
+	w.emitf("func %s%s", f.Name(), w.signatureString(sig))
+}
+
+func (w *Walker) emitMethod(m *types.Selection) {
+	sig := m.Type().(*types.Signature)
+	recv := sig.Recv().Type()
+	// report exported methods with unexported receiver base type
+	if true {
+		base := recv
+		if p, _ := recv.(*types.Pointer); p != nil {
+			base = p.Elem()
+		}
+		if obj := base.(*types.Named).Obj(); !obj.Exported() {
+			log.Fatalf("exported method with unexported receiver base type: %s", m)
+		}
+	}
+	tps := ""
+	if rtp := sig.RecvTypeParams(); rtp != nil {
+		var buf bytes.Buffer
+		w.writeTypeParams(&buf, rtp, false)
+		tps = buf.String()
+	}
+	if w.isDeprecated(m.Obj()) {
+		w.emitf("method (%s%s) %s //deprecated", w.typeString(recv), tps, m.Obj().Name())
+	}
+	w.emitf("method (%s%s) %s%s", w.typeString(recv), tps, m.Obj().Name(), w.signatureString(sig))
+}
+
+func (w *Walker) emitf(format string, args ...any) {
+	f := strings.Join(w.scope, ", ") + ", " + fmt.Sprintf(format, args...)
+	if strings.Contains(f, "\n") {
+		panic("feature contains newlines: " + f)
+	}
+
+	if _, dup := w.features[f]; dup {
+		panic("duplicate feature inserted: " + f)
+	}
+	w.features[f] = true
+
+	if verbose {
+		log.Printf("feature: %s", f)
+	}
+}
+
+func needApproval(filename string) bool {
+	name := filepath.Base(filename)
+	if name == "go1.txt" {
+		return false
+	}
+	minor := strings.TrimSuffix(strings.TrimPrefix(name, "go1."), ".txt")
+	n, err := strconv.Atoi(minor)
+	if err != nil {
+		log.Fatalf("unexpected api file: %v", name)
+	}
+	return n >= 19 // started tracking approvals in Go 1.19
+}
+
+func (w *Walker) collectDeprecated() {
+	isDeprecated := func(doc *ast.CommentGroup) bool {
+		if doc != nil {
+			for _, c := range doc.List {
+				if strings.HasPrefix(c.Text, "// Deprecated:") {
+					return true
+				}
+			}
+		}
+		return false
+	}
+
+	w.deprecated = make(map[token.Pos]bool)
+	mark := func(id *ast.Ident) {
+		if id != nil {
+			w.deprecated[id.Pos()] = true
+		}
+	}
+	for _, file := range w.current.Files {
+		ast.Inspect(file, func(n ast.Node) bool {
+			switch n := n.(type) {
+			case *ast.File:
+				if isDeprecated(n.Doc) {
+					mark(n.Name)
+				}
+				return true
+			case *ast.GenDecl:
+				if isDeprecated(n.Doc) {
+					for _, spec := range n.Specs {
+						switch spec := spec.(type) {
+						case *ast.ValueSpec:
+							for _, id := range spec.Names {
+								mark(id)
+							}
+						case *ast.TypeSpec:
+							mark(spec.Name)
+						}
+					}
+				}
+				return true // look at specs
+			case *ast.FuncDecl:
+				if isDeprecated(n.Doc) {
+					mark(n.Name)
+				}
+				return false
+			case *ast.TypeSpec:
+				if isDeprecated(n.Doc) {
+					mark(n.Name)
+				}
+				return true // recurse into struct or interface type
+			case *ast.StructType:
+				return true // recurse into fields
+			case *ast.InterfaceType:
+				return true // recurse into methods
+			case *ast.FieldList:
+				return true // recurse into fields
+			case *ast.ValueSpec:
+				if isDeprecated(n.Doc) {
+					for _, id := range n.Names {
+						mark(id)
+					}
+				}
+				return false
+			case *ast.Field:
+				if isDeprecated(n.Doc) {
+					for _, id := range n.Names {
+						mark(id)
+					}
+					if len(n.Names) == 0 {
+						// embedded field T or *T?
+						typ := n.Type
+						if ptr, ok := typ.(*ast.StarExpr); ok {
+							typ = ptr.X
+						}
+						if id, ok := typ.(*ast.Ident); ok {
+							mark(id)
+						}
+					}
+				}
+				return false
+			default:
+				return false
+			}
+		})
+	}
+}
+
+func (w *Walker) isDeprecated(obj types.Object) bool {
+	return w.deprecated[obj.Pos()]
+}

go/src/cmd/asm/doc.go

@@ -0,0 +1,62 @@
+// Copyright 2015 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.
+
+/*
+Asm, typically invoked as “go tool asm”, assembles the source file into an object
+file named for the basename of the argument source file with a .o suffix. The
+object file can then be combined with other objects into a package archive.
+
+# Command Line
+
+Usage:
+
+	go tool asm [flags] file
+
+The specified file must be a Go assembly file.
+The same assembler is used for all target operating systems and architectures.
+The GOOS and GOARCH environment variables set the desired target.
+
+Flags:
+
+	-D name[=value]
+		Predefine symbol name with an optional simple value.
+		Can be repeated to define multiple symbols.
+	-I dir1 -I dir2
+		Search for #include files in dir1, dir2, etc,
+		after consulting $GOROOT/pkg/$GOOS_$GOARCH.
+	-S
+		Print assembly and machine code.
+	-V
+		Print assembler version and exit.
+	-debug
+		Dump instructions as they are parsed.
+	-dynlink
+		Support references to Go symbols defined in other shared libraries.
+	-e
+		No limit on number of errors reported.
+	-gensymabis
+		Write symbol ABI information to output file. Don't assemble.
+	-o file
+		Write output to file. The default is foo.o for /a/b/c/foo.s.
+	-p pkgpath
+		Set expected package import to pkgpath.
+	-shared
+		Generate code that can be linked into a shared library.
+	-spectre list
+		Enable spectre mitigations in list (all, ret).
+	-trimpath prefix
+		Remove prefix from recorded source file paths.
+	-v
+		Print debug output.
+
+Input language:
+
+The assembler uses mostly the same syntax for all architectures,
+the main variation having to do with addressing modes. Input is
+run through a simplified C preprocessor that implements #include,
+#define, #ifdef/endif, but not #if or ##.
+
+For more information, see https://golang.org/doc/asm.
+*/
+package main

go/src/cmd/asm/main.go

@@ -0,0 +1,130 @@
+// Copyright 2014 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 (
+	"bufio"
+	"flag"
+	"fmt"
+	"internal/buildcfg"
+	"log"
+	"os"
+
+	"cmd/asm/internal/arch"
+	"cmd/asm/internal/asm"
+	"cmd/asm/internal/flags"
+	"cmd/asm/internal/lex"
+
+	"cmd/internal/bio"
+	"cmd/internal/obj"
+	"cmd/internal/objabi"
+	"cmd/internal/telemetry/counter"
+)
+
+func main() {
+	log.SetFlags(0)
+	log.SetPrefix("asm: ")
+	counter.Open()
+
+	buildcfg.Check()
+	GOARCH := buildcfg.GOARCH
+
+	flags.Parse()
+	counter.Inc("asm/invocations")
+	counter.CountFlags("asm/flag:", *flag.CommandLine)
+
+	architecture := arch.Set(GOARCH, *flags.Shared || *flags.Dynlink)
+	if architecture == nil {
+		log.Fatalf("unrecognized architecture %s", GOARCH)
+	}
+	ctxt := obj.Linknew(architecture.LinkArch)
+	ctxt.CompressInstructions = flags.DebugFlags.CompressInstructions != 0
+	ctxt.Debugasm = flags.PrintOut
+	ctxt.Debugvlog = flags.DebugV
+	ctxt.Flag_dynlink = *flags.Dynlink
+	ctxt.Flag_linkshared = *flags.Linkshared
+	ctxt.Flag_shared = *flags.Shared || *flags.Dynlink
+	ctxt.Flag_maymorestack = flags.DebugFlags.MayMoreStack
+	ctxt.Debugpcln = flags.DebugFlags.PCTab
+	ctxt.IsAsm = true
+	ctxt.Pkgpath = *flags.Importpath
+	ctxt.DwTextCount = objabi.DummyDwarfFunctionCountForAssembler()
+	switch *flags.Spectre {
+	default:
+		log.Printf("unknown setting -spectre=%s", *flags.Spectre)
+		os.Exit(2)
+	case "":
+		// nothing
+	case "index":
+		// known to compiler; ignore here so people can use
+		// the same list with -gcflags=-spectre=LIST and -asmflags=-spectre=LIST
+	case "all", "ret":
+		ctxt.Retpoline = true
+	}
+
+	ctxt.Bso = bufio.NewWriter(os.Stdout)
+	defer ctxt.Bso.Flush()
+
+	architecture.Init(ctxt)
+
+	// Create object file, write header.
+	buf, err := bio.Create(*flags.OutputFile)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer buf.Close()
+
+	if !*flags.SymABIs {
+		buf.WriteString(objabi.HeaderString())
+		fmt.Fprintf(buf, "!\n")
+	}
+
+	// Set macros for GOEXPERIMENTs so we can easily switch
+	// runtime assembly code based on them.
+	if objabi.LookupPkgSpecial(ctxt.Pkgpath).AllowAsmABI {
+		for _, exp := range buildcfg.Experiment.Enabled() {
+			flags.D = append(flags.D, "GOEXPERIMENT_"+exp)
+		}
+	}
+
+	var ok, diag bool
+	var failedFile string
+	for _, f := range flag.Args() {
+		lexer := lex.NewLexer(f)
+		parser := asm.NewParser(ctxt, architecture, lexer)
+		ctxt.DiagFunc = func(format string, args ...any) {
+			diag = true
+			log.Printf(format, args...)
+		}
+		if *flags.SymABIs {
+			ok = parser.ParseSymABIs(buf)
+		} else {
+			pList := new(obj.Plist)
+			pList.Firstpc, ok = parser.Parse()
+			// reports errors to parser.Errorf
+			if ok {
+				obj.Flushplist(ctxt, pList, nil)
+			}
+		}
+		if !ok {
+			failedFile = f
+			break
+		}
+	}
+	if ok && !*flags.SymABIs {
+		ctxt.NumberSyms()
+		obj.WriteObjFile(ctxt, buf)
+	}
+	if !ok || diag {
+		if failedFile != "" {
+			log.Printf("assembly of %s failed", failedFile)
+		} else {
+			log.Print("assembly failed")
+		}
+		buf.Close()
+		os.Remove(*flags.OutputFile)
+		os.Exit(1)
+	}
+}

go/src/cmd/buildid/buildid.go

@@ -0,0 +1,84 @@
+// Copyright 2017 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 (
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"strings"
+
+	"cmd/internal/buildid"
+	"cmd/internal/telemetry/counter"
+)
+
+func usage() {
+	fmt.Fprintf(os.Stderr, "usage: go tool buildid [-w] file\n")
+	flag.PrintDefaults()
+	os.Exit(2)
+}
+
+var wflag = flag.Bool("w", false, "write build ID")
+
+func main() {
+	log.SetPrefix("buildid: ")
+	log.SetFlags(0)
+	counter.Open()
+	flag.Usage = usage
+	flag.Parse()
+	counter.Inc("buildid/invocations")
+	counter.CountFlags("buildid/flag:", *flag.CommandLine)
+	if flag.NArg() != 1 {
+		usage()
+	}
+
+	file := flag.Arg(0)
+	id, err := buildid.ReadFile(file)
+	if err != nil {
+		log.Fatal(err)
+	}
+	if !*wflag {
+		fmt.Printf("%s\n", id)
+		return
+	}
+
+	// Keep in sync with src/cmd/go/internal/work/buildid.go:updateBuildID
+
+	f, err := os.Open(file)
+	if err != nil {
+		log.Fatal(err)
+	}
+	matches, hash, err := buildid.FindAndHash(f, id, 0)
+	f.Close()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// <= go 1.7 doesn't embed the contentID or actionID, so no slash is present
+	if !strings.Contains(id, "/") {
+		log.Fatalf("%s: build ID is a legacy format...binary too old for this tool", file)
+	}
+
+	newID := id[:strings.LastIndex(id, "/")] + "/" + buildid.HashToString(hash)
+	if len(newID) != len(id) {
+		log.Fatalf("%s: build ID length mismatch %q vs %q", file, id, newID)
+	}
+
+	if len(matches) == 0 {
+		return
+	}
+
+	f, err = os.OpenFile(file, os.O_RDWR, 0)
+	if err != nil {
+		log.Fatal(err)
+	}
+	if err := buildid.Rewrite(f, matches, newID); err != nil {
+		log.Fatal(err)
+	}
+	if err := f.Close(); err != nil {
+		log.Fatal(err)
+	}
+}

go/src/cmd/buildid/doc.go

@@ -0,0 +1,19 @@
+// Copyright 2017 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.
+
+/*
+Buildid displays or updates the build ID stored in a Go package or binary.
+
+Usage:
+
+	go tool buildid [-w] file
+
+By default, buildid prints the build ID found in the named file.
+If the -w option is given, buildid rewrites the build ID found in
+the file to accurately record a content hash of the file.
+
+This tool is only intended for use by the go command or
+other build systems.
+*/
+package main

go/src/cmd/cgo/ast.go

@@ -0,0 +1,576 @@
+// Copyright 2009 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.
+
+// Parse input AST and prepare Prog structure.
+
+package main
+
+import (
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/scanner"
+	"go/token"
+	"os"
+	"strings"
+)
+
+func parse(name string, src []byte, flags parser.Mode) *ast.File {
+	ast1, err := parser.ParseFile(fset, name, src, flags)
+	if err != nil {
+		if list, ok := err.(scanner.ErrorList); ok {
+			// If err is a scanner.ErrorList, its String will print just
+			// the first error and then (+n more errors).
+			// Instead, turn it into a new Error that will return
+			// details for all the errors.
+			for _, e := range list {
+				fmt.Fprintln(os.Stderr, e)
+			}
+			os.Exit(2)
+		}
+		fatalf("parsing %s: %s", name, err)
+	}
+	return ast1
+}
+
+func sourceLine(n ast.Node) int {
+	return fset.Position(n.Pos()).Line
+}
+
+// ParseGo populates f with information learned from the Go source code
+// which was read from the named file. It gathers the C preamble
+// attached to the import "C" comment, a list of references to C.xxx,
+// a list of exported functions, and the actual AST, to be rewritten and
+// printed.
+func (f *File) ParseGo(abspath string, src []byte) {
+	// Two different parses: once with comments, once without.
+	// The printer is not good enough at printing comments in the
+	// right place when we start editing the AST behind its back,
+	// so we use ast1 to look for the doc comments on import "C"
+	// and on exported functions, and we use ast2 for translating
+	// and reprinting.
+	// In cgo mode, we ignore ast2 and just apply edits directly
+	// the text behind ast1. In godefs mode we modify and print ast2.
+	ast1 := parse(abspath, src, parser.SkipObjectResolution|parser.ParseComments)
+	ast2 := parse(abspath, src, parser.SkipObjectResolution)
+
+	f.Package = ast1.Name.Name
+	f.Name = make(map[string]*Name)
+	f.NamePos = make(map[*Name]token.Pos)
+
+	// In ast1, find the import "C" line and get any extra C preamble.
+	sawC := false
+	for _, decl := range ast1.Decls {
+		switch decl := decl.(type) {
+		case *ast.GenDecl:
+			for _, spec := range decl.Specs {
+				s, ok := spec.(*ast.ImportSpec)
+				if !ok || s.Path.Value != `"C"` {
+					continue
+				}
+				sawC = true
+				if s.Name != nil {
+					error_(s.Path.Pos(), `cannot rename import "C"`)
+				}
+				cg := s.Doc
+				if cg == nil && len(decl.Specs) == 1 {
+					cg = decl.Doc
+				}
+				if cg != nil {
+					if strings.ContainsAny(abspath, "\r\n") {
+						// This should have been checked when the file path was first resolved,
+						// but we double check here just to be sure.
+						fatalf("internal error: ParseGo: abspath contains unexpected newline character: %q", abspath)
+					}
+					f.Preamble += fmt.Sprintf("#line %d %q\n", sourceLine(cg), abspath)
+					f.Preamble += commentText(cg) + "\n"
+					f.Preamble += "#line 1 \"cgo-generated-wrapper\"\n"
+				}
+			}
+
+		case *ast.FuncDecl:
+			// Also, reject attempts to declare methods on C.T or *C.T.
+			// (The generated code would otherwise accept this
+			// invalid input; see issue #57926.)
+			if decl.Recv != nil && len(decl.Recv.List) > 0 {
+				recvType := decl.Recv.List[0].Type
+				if recvType != nil {
+					t := recvType
+					if star, ok := unparen(t).(*ast.StarExpr); ok {
+						t = star.X
+					}
+					if sel, ok := unparen(t).(*ast.SelectorExpr); ok {
+						var buf strings.Builder
+						format.Node(&buf, fset, recvType)
+						error_(sel.Pos(), `cannot define new methods on non-local type %s`, &buf)
+					}
+				}
+			}
+		}
+
+	}
+	if !sawC {
+		error_(ast1.Package, `cannot find import "C"`)
+	}
+
+	// In ast2, strip the import "C" line.
+	if *godefs {
+		w := 0
+		for _, decl := range ast2.Decls {
+			d, ok := decl.(*ast.GenDecl)
+			if !ok {
+				ast2.Decls[w] = decl
+				w++
+				continue
+			}
+			ws := 0
+			for _, spec := range d.Specs {
+				s, ok := spec.(*ast.ImportSpec)
+				if !ok || s.Path.Value != `"C"` {
+					d.Specs[ws] = spec
+					ws++
+				}
+			}
+			if ws == 0 {
+				continue
+			}
+			d.Specs = d.Specs[0:ws]
+			ast2.Decls[w] = d
+			w++
+		}
+		ast2.Decls = ast2.Decls[0:w]
+	} else {
+		for _, decl := range ast2.Decls {
+			d, ok := decl.(*ast.GenDecl)
+			if !ok {
+				continue
+			}
+			for _, spec := range d.Specs {
+				if s, ok := spec.(*ast.ImportSpec); ok && s.Path.Value == `"C"` {
+					// Replace "C" with _ "unsafe", to keep program valid.
+					// (Deleting import statement or clause is not safe if it is followed
+					// in the source by an explicit semicolon.)
+					f.Edit.Replace(f.offset(s.Path.Pos()), f.offset(s.Path.End()), `_ "unsafe"`)
+				}
+			}
+		}
+	}
+
+	// Accumulate pointers to uses of C.x.
+	if f.Ref == nil {
+		f.Ref = make([]*Ref, 0, 8)
+	}
+	f.walk(ast2, ctxProg, (*File).validateIdents)
+	f.walk(ast2, ctxProg, (*File).saveExprs)
+
+	// Accumulate exported functions.
+	// The comments are only on ast1 but we need to
+	// save the function bodies from ast2.
+	// The first walk fills in ExpFunc, and the
+	// second walk changes the entries to
+	// refer to ast2 instead.
+	f.walk(ast1, ctxProg, (*File).saveExport)
+	f.walk(ast2, ctxProg, (*File).saveExport2)
+
+	f.Comments = ast1.Comments
+	f.AST = ast2
+}
+
+// Like ast.CommentGroup's Text method but preserves
+// leading blank lines, so that line numbers line up.
+func commentText(g *ast.CommentGroup) string {
+	pieces := make([]string, 0, len(g.List))
+	for _, com := range g.List {
+		c := com.Text
+		// Remove comment markers.
+		// The parser has given us exactly the comment text.
+		switch c[1] {
+		case '/':
+			//-style comment (no newline at the end)
+			c = c[2:] + "\n"
+		case '*':
+			/*-style comment */
+			c = c[2 : len(c)-2]
+		}
+		pieces = append(pieces, c)
+	}
+	return strings.Join(pieces, "")
+}
+
+func (f *File) validateIdents(x any, context astContext) {
+	if x, ok := x.(*ast.Ident); ok {
+		if f.isMangledName(x.Name) {
+			error_(x.Pos(), "identifier %q may conflict with identifiers generated by cgo", x.Name)
+		}
+	}
+}
+
+// Save various references we are going to need later.
+func (f *File) saveExprs(x any, context astContext) {
+	switch x := x.(type) {
+	case *ast.Expr:
+		switch (*x).(type) {
+		case *ast.SelectorExpr:
+			f.saveRef(x, context)
+		}
+	case *ast.CallExpr:
+		f.saveCall(x, context)
+	}
+}
+
+// Save references to C.xxx for later processing.
+func (f *File) saveRef(n *ast.Expr, context astContext) {
+	sel := (*n).(*ast.SelectorExpr)
+	// For now, assume that the only instance of capital C is when
+	// used as the imported package identifier.
+	// The parser should take care of scoping in the future, so
+	// that we will be able to distinguish a "top-level C" from a
+	// local C.
+	if l, ok := sel.X.(*ast.Ident); !ok || l.Name != "C" {
+		return
+	}
+	if context == ctxAssign2 {
+		context = ctxExpr
+	}
+	if context == ctxEmbedType {
+		error_(sel.Pos(), "cannot embed C type")
+	}
+	goname := sel.Sel.Name
+	if goname == "errno" {
+		error_(sel.Pos(), "cannot refer to errno directly; see documentation")
+		return
+	}
+	if goname == "_CMalloc" {
+		error_(sel.Pos(), "cannot refer to C._CMalloc; use C.malloc")
+		return
+	}
+	if goname == "malloc" {
+		goname = "_CMalloc"
+	}
+	name := f.Name[goname]
+	if name == nil {
+		name = &Name{
+			Go: goname,
+		}
+		f.Name[goname] = name
+		f.NamePos[name] = sel.Pos()
+	}
+	f.Ref = append(f.Ref, &Ref{
+		Name:    name,
+		Expr:    n,
+		Context: context,
+	})
+}
+
+// Save calls to C.xxx for later processing.
+func (f *File) saveCall(call *ast.CallExpr, context astContext) {
+	sel, ok := call.Fun.(*ast.SelectorExpr)
+	if !ok {
+		return
+	}
+	if l, ok := sel.X.(*ast.Ident); !ok || l.Name != "C" {
+		return
+	}
+	c := &Call{Call: call, Deferred: context == ctxDefer}
+	f.Calls = append(f.Calls, c)
+}
+
+// If a function should be exported add it to ExpFunc.
+func (f *File) saveExport(x any, context astContext) {
+	n, ok := x.(*ast.FuncDecl)
+	if !ok {
+		return
+	}
+
+	if n.Doc == nil {
+		return
+	}
+	for _, c := range n.Doc.List {
+		if !strings.HasPrefix(c.Text, "//export ") {
+			continue
+		}
+
+		name := strings.TrimSpace(c.Text[9:])
+		if name == "" {
+			error_(c.Pos(), "export missing name")
+		}
+
+		if name != n.Name.Name {
+			error_(c.Pos(), "export comment has wrong name %q, want %q", name, n.Name.Name)
+		}
+
+		f.ExpFunc = append(f.ExpFunc, &ExpFunc{
+			Func:    n,
+			ExpName: name,
+			// Caution: Do not set the Doc field on purpose
+			// to ensure that there are no unintended artifacts
+			// in the binary. See https://go.dev/issue/76697.
+		})
+		break
+	}
+}
+
+// Make f.ExpFunc[i] point at the Func from this AST instead of the other one.
+func (f *File) saveExport2(x any, context astContext) {
+	n, ok := x.(*ast.FuncDecl)
+	if !ok {
+		return
+	}
+
+	for _, exp := range f.ExpFunc {
+		if exp.Func.Name.Name == n.Name.Name {
+			exp.Func = n
+			break
+		}
+	}
+}
+
+type astContext int
+
+const (
+	ctxProg astContext = iota
+	ctxEmbedType
+	ctxType
+	ctxStmt
+	ctxExpr
+	ctxField
+	ctxParam
+	ctxAssign2 // assignment of a single expression to two variables
+	ctxSwitch
+	ctxTypeSwitch
+	ctxFile
+	ctxDecl
+	ctxSpec
+	ctxDefer
+	ctxCall  // any function call other than ctxCall2
+	ctxCall2 // function call whose result is assigned to two variables
+	ctxSelector
+)
+
+// walk walks the AST x, calling visit(f, x, context) for each node.
+func (f *File) walk(x any, context astContext, visit func(*File, any, astContext)) {
+	visit(f, x, context)
+	switch n := x.(type) {
+	case *ast.Expr:
+		f.walk(*n, context, visit)
+
+	// everything else just recurs
+	default:
+		error_(token.NoPos, "unexpected type %T in walk", x)
+		panic("unexpected type")
+
+	case nil:
+
+	// These are ordered and grouped to match ../../go/ast/ast.go
+	case *ast.Field:
+		if len(n.Names) == 0 && context == ctxField {
+			f.walk(&n.Type, ctxEmbedType, visit)
+		} else {
+			f.walk(&n.Type, ctxType, visit)
+		}
+	case *ast.FieldList:
+		for _, field := range n.List {
+			f.walk(field, context, visit)
+		}
+	case *ast.BadExpr:
+	case *ast.Ident:
+	case *ast.Ellipsis:
+		f.walk(&n.Elt, ctxType, visit)
+	case *ast.BasicLit:
+	case *ast.FuncLit:
+		f.walk(n.Type, ctxType, visit)
+		f.walk(n.Body, ctxStmt, visit)
+	case *ast.CompositeLit:
+		f.walk(&n.Type, ctxType, visit)
+		f.walk(n.Elts, ctxExpr, visit)
+	case *ast.ParenExpr:
+		f.walk(&n.X, context, visit)
+	case *ast.SelectorExpr:
+		f.walk(&n.X, ctxSelector, visit)
+	case *ast.IndexExpr:
+		f.walk(&n.X, ctxExpr, visit)
+		f.walk(&n.Index, ctxExpr, visit)
+	case *ast.IndexListExpr:
+		f.walk(&n.X, ctxExpr, visit)
+		f.walk(n.Indices, ctxExpr, visit)
+	case *ast.SliceExpr:
+		f.walk(&n.X, ctxExpr, visit)
+		if n.Low != nil {
+			f.walk(&n.Low, ctxExpr, visit)
+		}
+		if n.High != nil {
+			f.walk(&n.High, ctxExpr, visit)
+		}
+		if n.Max != nil {
+			f.walk(&n.Max, ctxExpr, visit)
+		}
+	case *ast.TypeAssertExpr:
+		f.walk(&n.X, ctxExpr, visit)
+		f.walk(&n.Type, ctxType, visit)
+	case *ast.CallExpr:
+		if context == ctxAssign2 {
+			f.walk(&n.Fun, ctxCall2, visit)
+		} else {
+			f.walk(&n.Fun, ctxCall, visit)
+		}
+		f.walk(n.Args, ctxExpr, visit)
+	case *ast.StarExpr:
+		f.walk(&n.X, context, visit)
+	case *ast.UnaryExpr:
+		f.walk(&n.X, ctxExpr, visit)
+	case *ast.BinaryExpr:
+		f.walk(&n.X, ctxExpr, visit)
+		f.walk(&n.Y, ctxExpr, visit)
+	case *ast.KeyValueExpr:
+		f.walk(&n.Key, ctxExpr, visit)
+		f.walk(&n.Value, ctxExpr, visit)
+
+	case *ast.ArrayType:
+		f.walk(&n.Len, ctxExpr, visit)
+		f.walk(&n.Elt, ctxType, visit)
+	case *ast.StructType:
+		f.walk(n.Fields, ctxField, visit)
+	case *ast.FuncType:
+		if n.TypeParams != nil {
+			f.walk(n.TypeParams, ctxParam, visit)
+		}
+		f.walk(n.Params, ctxParam, visit)
+		if n.Results != nil {
+			f.walk(n.Results, ctxParam, visit)
+		}
+	case *ast.InterfaceType:
+		f.walk(n.Methods, ctxField, visit)
+	case *ast.MapType:
+		f.walk(&n.Key, ctxType, visit)
+		f.walk(&n.Value, ctxType, visit)
+	case *ast.ChanType:
+		f.walk(&n.Value, ctxType, visit)
+
+	case *ast.BadStmt:
+	case *ast.DeclStmt:
+		f.walk(n.Decl, ctxDecl, visit)
+	case *ast.EmptyStmt:
+	case *ast.LabeledStmt:
+		f.walk(n.Stmt, ctxStmt, visit)
+	case *ast.ExprStmt:
+		f.walk(&n.X, ctxExpr, visit)
+	case *ast.SendStmt:
+		f.walk(&n.Chan, ctxExpr, visit)
+		f.walk(&n.Value, ctxExpr, visit)
+	case *ast.IncDecStmt:
+		f.walk(&n.X, ctxExpr, visit)
+	case *ast.AssignStmt:
+		f.walk(n.Lhs, ctxExpr, visit)
+		if len(n.Lhs) == 2 && len(n.Rhs) == 1 {
+			f.walk(n.Rhs, ctxAssign2, visit)
+		} else {
+			f.walk(n.Rhs, ctxExpr, visit)
+		}
+	case *ast.GoStmt:
+		f.walk(n.Call, ctxExpr, visit)
+	case *ast.DeferStmt:
+		f.walk(n.Call, ctxDefer, visit)
+	case *ast.ReturnStmt:
+		f.walk(n.Results, ctxExpr, visit)
+	case *ast.BranchStmt:
+	case *ast.BlockStmt:
+		f.walk(n.List, context, visit)
+	case *ast.IfStmt:
+		f.walk(n.Init, ctxStmt, visit)
+		f.walk(&n.Cond, ctxExpr, visit)
+		f.walk(n.Body, ctxStmt, visit)
+		f.walk(n.Else, ctxStmt, visit)
+	case *ast.CaseClause:
+		if context == ctxTypeSwitch {
+			context = ctxType
+		} else {
+			context = ctxExpr
+		}
+		f.walk(n.List, context, visit)
+		f.walk(n.Body, ctxStmt, visit)
+	case *ast.SwitchStmt:
+		f.walk(n.Init, ctxStmt, visit)
+		f.walk(&n.Tag, ctxExpr, visit)
+		f.walk(n.Body, ctxSwitch, visit)
+	case *ast.TypeSwitchStmt:
+		f.walk(n.Init, ctxStmt, visit)
+		f.walk(n.Assign, ctxStmt, visit)
+		f.walk(n.Body, ctxTypeSwitch, visit)
+	case *ast.CommClause:
+		f.walk(n.Comm, ctxStmt, visit)
+		f.walk(n.Body, ctxStmt, visit)
+	case *ast.SelectStmt:
+		f.walk(n.Body, ctxStmt, visit)
+	case *ast.ForStmt:
+		f.walk(n.Init, ctxStmt, visit)
+		f.walk(&n.Cond, ctxExpr, visit)
+		f.walk(n.Post, ctxStmt, visit)
+		f.walk(n.Body, ctxStmt, visit)
+	case *ast.RangeStmt:
+		f.walk(&n.Key, ctxExpr, visit)
+		f.walk(&n.Value, ctxExpr, visit)
+		f.walk(&n.X, ctxExpr, visit)
+		f.walk(n.Body, ctxStmt, visit)
+
+	case *ast.ImportSpec:
+	case *ast.ValueSpec:
+		f.walk(&n.Type, ctxType, visit)
+		if len(n.Names) == 2 && len(n.Values) == 1 {
+			f.walk(&n.Values[0], ctxAssign2, visit)
+		} else {
+			f.walk(n.Values, ctxExpr, visit)
+		}
+	case *ast.TypeSpec:
+		if n.TypeParams != nil {
+			f.walk(n.TypeParams, ctxParam, visit)
+		}
+		f.walk(&n.Type, ctxType, visit)
+
+	case *ast.BadDecl:
+	case *ast.GenDecl:
+		f.walk(n.Specs, ctxSpec, visit)
+	case *ast.FuncDecl:
+		if n.Recv != nil {
+			f.walk(n.Recv, ctxParam, visit)
+		}
+		f.walk(n.Type, ctxType, visit)
+		if n.Body != nil {
+			f.walk(n.Body, ctxStmt, visit)
+		}
+
+	case *ast.File:
+		f.walk(n.Decls, ctxDecl, visit)
+
+	case *ast.Package:
+		for _, file := range n.Files {
+			f.walk(file, ctxFile, visit)
+		}
+
+	case []ast.Decl:
+		for _, d := range n {
+			f.walk(d, context, visit)
+		}
+	case []ast.Expr:
+		for i := range n {
+			f.walk(&n[i], context, visit)
+		}
+	case []ast.Stmt:
+		for _, s := range n {
+			f.walk(s, context, visit)
+		}
+	case []ast.Spec:
+		for _, s := range n {
+			f.walk(s, context, visit)
+		}
+	}
+}
+
+// If x is of the form (T), unparen returns unparen(T), otherwise it returns x.
+func unparen(x ast.Expr) ast.Expr {
+	if p, isParen := x.(*ast.ParenExpr); isParen {
+		x = unparen(p.X)
+	}
+	return x
+}

go/src/cmd/cgo/doc.go

@@ -0,0 +1,1111 @@
+// Copyright 2009 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.
+
+/*
+Cgo enables the creation of Go packages that call C code.
+
+# Using cgo with the go command
+
+To use cgo write normal Go code that imports a pseudo-package "C".
+The Go code can then refer to types such as C.size_t, variables such
+as C.stdout, or functions such as C.putchar.
+
+If the import of "C" is immediately preceded by a comment, that
+comment, called the preamble, is used as a header when compiling
+the C parts of the package. For example:
+
+	// #include <stdio.h>
+	// #include <errno.h>
+	import "C"
+
+The preamble may contain any C code, including function and variable
+declarations and definitions. These may then be referred to from Go
+code as though they were defined in the package "C". All names
+declared in the preamble may be used, even if they start with a
+lower-case letter. Exception: static variables in the preamble may
+not be referenced from Go code; static functions are permitted.
+
+See $GOROOT/cmd/cgo/internal/teststdio and $GOROOT/misc/cgo/gmp for examples. See
+"C? Go? Cgo!" for an introduction to using cgo:
+https://golang.org/doc/articles/c_go_cgo.html.
+
+CFLAGS, CPPFLAGS, CXXFLAGS, FFLAGS and LDFLAGS may be defined with pseudo
+#cgo directives within these comments to tweak the behavior of the C, C++
+or Fortran compiler. Values defined in multiple directives are concatenated
+together. The directive can include a list of build constraints limiting its
+effect to systems satisfying one of the constraints
+(see https://golang.org/pkg/go/build/#hdr-Build_Constraints for details about the constraint syntax).
+For example:
+
+	// #cgo CFLAGS: -DPNG_DEBUG=1
+	// #cgo amd64 386 CFLAGS: -DX86=1
+	// #cgo LDFLAGS: -lpng
+	// #include <png.h>
+	import "C"
+
+Alternatively, CPPFLAGS and LDFLAGS may be obtained via the pkg-config tool
+using a '#cgo pkg-config:' directive followed by the package names.
+For example:
+
+	// #cgo pkg-config: png cairo
+	// #include <png.h>
+	import "C"
+
+The default pkg-config tool may be changed by setting the PKG_CONFIG environment variable.
+
+For security reasons, only a limited set of flags are allowed, notably -D, -U, -I, and -l.
+To allow additional flags, set CGO_CFLAGS_ALLOW to a regular expression
+matching the new flags. To disallow flags that would otherwise be allowed,
+set CGO_CFLAGS_DISALLOW to a regular expression matching arguments
+that must be disallowed. In both cases the regular expression must match
+a full argument: to allow -mfoo=bar, use CGO_CFLAGS_ALLOW='-mfoo.*',
+not just CGO_CFLAGS_ALLOW='-mfoo'. Similarly named variables control
+the allowed CPPFLAGS, CXXFLAGS, FFLAGS, and LDFLAGS.
+
+Also for security reasons, only a limited set of characters are
+permitted, notably alphanumeric characters and a few symbols, such as
+'.', that will not be interpreted in unexpected ways. Attempts to use
+forbidden characters will get a "malformed #cgo argument" error.
+
+When building, the CGO_CFLAGS, CGO_CPPFLAGS, CGO_CXXFLAGS, CGO_FFLAGS and
+CGO_LDFLAGS environment variables are added to the flags derived from
+these directives. Package-specific flags should be set using the
+directives, not the environment variables, so that builds work in
+unmodified environments. Flags obtained from environment variables
+are not subject to the security limitations described above.
+
+All the cgo CPPFLAGS and CFLAGS directives in a package are concatenated and
+used to compile C files in that package. All the CPPFLAGS and CXXFLAGS
+directives in a package are concatenated and used to compile C++ files in that
+package. All the CPPFLAGS and FFLAGS directives in a package are concatenated
+and used to compile Fortran files in that package. All the LDFLAGS directives
+in any package in the program are concatenated and used at link time. All the
+pkg-config directives are concatenated and sent to pkg-config simultaneously
+to add to each appropriate set of command-line flags.
+
+When the cgo directives are parsed, any occurrence of the string ${SRCDIR}
+will be replaced by the absolute path to the directory containing the source
+file. This allows pre-compiled static libraries to be included in the package
+directory and linked properly.
+For example if package foo is in the directory /go/src/foo:
+
+	// #cgo LDFLAGS: -L${SRCDIR}/libs -lfoo
+
+Will be expanded to:
+
+	// #cgo LDFLAGS: -L/go/src/foo/libs -lfoo
+
+When the Go tool sees that one or more Go files use the special import
+"C", it will look for other non-Go files in the directory and compile
+them as part of the Go package. Any .c, .s, .S or .sx files will be
+compiled with the C compiler. Any .cc, .cpp, or .cxx files will be
+compiled with the C++ compiler. Any .f, .F, .for or .f90 files will be
+compiled with the fortran compiler. Any .h, .hh, .hpp, or .hxx files will
+not be compiled separately, but, if these header files are changed,
+the package (including its non-Go source files) will be recompiled.
+Note that changes to files in other directories do not cause the package
+to be recompiled, so all non-Go source code for the package should be
+stored in the package directory, not in subdirectories.
+The default C and C++ compilers may be changed by the CC and CXX
+environment variables, respectively; those environment variables
+may include command line options.
+
+The cgo tool will always invoke the C compiler with the source file's
+directory in the include path; i.e. -I${SRCDIR} is always implied. This
+means that if a header file foo/bar.h exists both in the source
+directory and also in the system include directory (or some other place
+specified by a -I flag), then "#include <foo/bar.h>" will always find the
+local version in preference to any other version.
+
+The cgo tool is enabled by default for native builds on systems where
+it is expected to work. It is disabled by default when cross-compiling
+as well as when the CC environment variable is unset and the default
+C compiler (typically gcc or clang) cannot be found on the system PATH.
+You can override the default by setting the CGO_ENABLED
+environment variable when running the go tool: set it to 1 to enable
+the use of cgo, and to 0 to disable it. The go tool will set the
+build constraint "cgo" if cgo is enabled. The special import "C"
+implies the "cgo" build constraint, as though the file also said
+"//go:build cgo". Therefore, if cgo is disabled, files that import
+"C" will not be built by the go tool. (For more about build constraints
+see https://golang.org/pkg/go/build/#hdr-Build_Constraints).
+
+When cross-compiling, you must specify a C cross-compiler for cgo to
+use. You can do this by setting the generic CC_FOR_TARGET or the
+more specific CC_FOR_${GOOS}_${GOARCH} (for example, CC_FOR_linux_arm)
+environment variable when building the toolchain using make.bash,
+or you can set the CC environment variable any time you run the go tool.
+
+The CXX_FOR_TARGET, CXX_FOR_${GOOS}_${GOARCH}, and CXX
+environment variables work in a similar way for C++ code.
+
+# Go references to C
+
+Within the Go file, C's struct field names that are keywords in Go
+can be accessed by prefixing them with an underscore: if x points at a C
+struct with a field named "type", x._type accesses the field.
+C struct fields that cannot be expressed in Go, such as bit fields
+or misaligned data, are omitted in the Go struct, replaced by
+appropriate padding to reach the next field or the end of the struct.
+
+The standard C numeric types are available under the names
+C.char, C.schar (signed char), C.uchar (unsigned char),
+C.short, C.ushort (unsigned short), C.int, C.uint (unsigned int),
+C.long, C.ulong (unsigned long), C.longlong (long long),
+C.ulonglong (unsigned long long), C.float, C.double,
+C.complexfloat (complex float), and C.complexdouble (complex double).
+The C type void* is represented by Go's unsafe.Pointer.
+The C types __int128_t and __uint128_t are represented by [16]byte.
+
+A few special C types which would normally be represented by a pointer
+type in Go are instead represented by a uintptr.  See the Special
+cases section below.
+
+To access a struct, union, or enum type directly, prefix it with
+struct_, union_, or enum_, as in C.struct_stat. The size of any C type
+T is available as C.sizeof_T, as in C.sizeof_struct_stat. These
+special prefixes means that there is no way to directly reference a C
+identifier that starts with "struct_", "union_", "enum_", or
+"sizeof_", such as a function named "struct_function".
+A workaround is to use a "#define" in the preamble, as in
+"#define c_struct_function struct_function" and then in the
+Go code refer to "C.c_struct_function".
+
+A C function may be declared in the Go file with a parameter type of
+the special name _GoString_. This function may be called with an
+ordinary Go string value. The string length, and a pointer to the
+string contents, may be accessed by calling the C functions
+
+	size_t _GoStringLen(_GoString_ s);
+	const char *_GoStringPtr(_GoString_ s);
+
+These functions are only available in the preamble, not in other C
+files. The C code must not modify the contents of the pointer returned
+by _GoStringPtr. Note that the string contents may not have a trailing
+NUL byte.
+
+As Go doesn't have support for C's union type in the general case,
+C's union types are represented as a Go byte array with the same length.
+
+Go structs cannot embed fields with C types.
+
+Go code cannot refer to zero-sized fields that occur at the end of
+non-empty C structs. To get the address of such a field (which is the
+only operation you can do with a zero-sized field) you must take the
+address of the struct and add the size of the struct.
+
+Cgo translates C types into equivalent unexported Go types.
+Because the translations are unexported, a Go package should not
+expose C types in its exported API: a C type used in one Go package
+is different from the same C type used in another.
+
+Any C function (even void functions) may be called in a multiple
+assignment context to retrieve both the return value (if any) and the
+C errno variable as an error (use _ to skip the result value if the
+function returns void). For example:
+
+	n, err = C.sqrt(-1)
+	_, err := C.voidFunc()
+	var n, err = C.sqrt(1)
+
+Note that the C errno value may be non-zero, and thus the err result may be
+non-nil, even if the function call is successful. Unlike normal Go conventions,
+you should first check whether the call succeeded before checking the error
+result. For example:
+
+	n, err := C.setenv(key, value, 1)
+	if n != 0 {
+		// we know the call failed, so it is now valid to use err
+		return err
+	}
+
+Calling C function pointers is currently not supported, however you can
+declare Go variables which hold C function pointers and pass them
+back and forth between Go and C. C code may call function pointers
+received from Go. For example:
+
+	package main
+
+	// typedef int (*intFunc) ();
+	//
+	// int
+	// bridge_int_func(intFunc f)
+	// {
+	//		return f();
+	// }
+	//
+	// int fortytwo()
+	// {
+	//	    return 42;
+	// }
+	import "C"
+	import "fmt"
+
+	func main() {
+		f := C.intFunc(C.fortytwo)
+		fmt.Println(int(C.bridge_int_func(f)))
+		// Output: 42
+	}
+
+In C, a function argument written as a fixed size array
+actually requires a pointer to the first element of the array.
+C compilers are aware of this calling convention and adjust
+the call accordingly, but Go cannot. In Go, you must pass
+the pointer to the first element explicitly: C.f(&C.x[0]).
+
+Calling variadic C functions is not supported. It is possible to
+circumvent this by using a C function wrapper. For example:
+
+	package main
+
+	// #include <stdio.h>
+	// #include <stdlib.h>
+	//
+	// static void myprint(char* s) {
+	//   printf("%s\n", s);
+	// }
+	import "C"
+	import "unsafe"
+
+	func main() {
+		cs := C.CString("Hello from stdio")
+		C.myprint(cs)
+		C.free(unsafe.Pointer(cs))
+	}
+
+A few special functions convert between Go and C types
+by making copies of the data. In pseudo-Go definitions:
+
+	// Go string to C string
+	// The C string is allocated in the C heap using malloc.
+	// It is the caller's responsibility to arrange for it to be
+	// freed, such as by calling C.free (be sure to include stdlib.h
+	// if C.free is needed).
+	func C.CString(string) *C.char
+
+	// Go []byte slice to C array
+	// The C array is allocated in the C heap using malloc.
+	// It is the caller's responsibility to arrange for it to be
+	// freed, such as by calling C.free (be sure to include stdlib.h
+	// if C.free is needed).
+	func C.CBytes([]byte) unsafe.Pointer
+
+	// C string to Go string
+	func C.GoString(*C.char) string
+
+	// C data with explicit length to Go string
+	func C.GoStringN(*C.char, C.int) string
+
+	// C data with explicit length to Go []byte
+	func C.GoBytes(unsafe.Pointer, C.int) []byte
+
+As a special case, C.malloc does not call the C library malloc directly
+but instead calls a Go helper function that wraps the C library malloc
+but guarantees never to return nil. If C's malloc indicates out of memory,
+the helper function crashes the program, like when Go itself runs out
+of memory. Because C.malloc cannot fail, it has no two-result form
+that returns errno.
+
+# C references to Go
+
+Go functions can be exported for use by C code in the following way:
+
+	//export MyFunction
+	func MyFunction(arg1, arg2 int, arg3 string) int64 {...}
+
+	//export MyFunction2
+	func MyFunction2(arg1, arg2 int, arg3 string) (int64, *C.char) {...}
+
+They will be available in the C code as:
+
+	extern GoInt64 MyFunction(int arg1, int arg2, GoString arg3);
+	extern struct MyFunction2_return MyFunction2(int arg1, int arg2, GoString arg3);
+
+found in the _cgo_export.h generated header, after any preambles
+copied from the cgo input files. Functions with multiple
+return values are mapped to functions returning a struct.
+
+Not all Go types can be mapped to C types in a useful way.
+Go struct types are not supported; use a C struct type.
+Go array types are not supported; use a C pointer.
+
+Go functions that take arguments of type string may be called with the
+C type _GoString_, described above. The _GoString_ type will be
+automatically defined in the preamble. Note that there is no way for C
+code to create a value of this type; this is only useful for passing
+string values from Go to C and back to Go.
+
+Using //export in a file places a restriction on the preamble:
+since it is copied into two different C output files, it must not
+contain any definitions, only declarations. If a file contains both
+definitions and declarations, then the two output files will produce
+duplicate symbols and the linker will fail. To avoid this, definitions
+must be placed in preambles in other files, or in C source files.
+
+# Passing pointers
+
+Go is a garbage collected language, and the garbage collector needs to
+know the location of every pointer to Go memory. Because of this,
+there are restrictions on passing pointers between Go and C.
+
+In this section the term Go pointer means a pointer to memory
+allocated by Go (such as by using the & operator or calling the
+predefined new function) and the term C pointer means a pointer to
+memory allocated by C (such as by a call to C.malloc). Whether a
+pointer is a Go pointer or a C pointer is a dynamic property
+determined by how the memory was allocated; it has nothing to do with
+the type of the pointer.
+
+Note that values of some Go types, other than the type's zero value,
+always include Go pointers. This is true of interface, channel, map,
+and function types. A pointer type may hold a Go pointer or a C pointer.
+Array, slice, string, and struct types may or may not include Go pointers,
+depending on their type and how they are constructed. All the discussion
+below about Go pointers applies not just to pointer types,
+but also to other types that include Go pointers.
+
+All Go pointers passed to C must point to pinned Go memory. Go pointers
+passed as function arguments to C functions have the memory they point to
+implicitly pinned for the duration of the call. Go memory reachable from
+these function arguments must be pinned as long as the C code has access
+to it. Whether Go memory is pinned is a dynamic property of that memory
+region; it has nothing to do with the type of the pointer.
+
+Go values created by calling new, by taking the address of a composite
+literal, or by taking the address of a local variable may also have their
+memory pinned using [runtime.Pinner]. This type may be used to manage
+the duration of the memory's pinned status, potentially beyond the
+duration of a C function call. Memory may be pinned more than once and
+must be unpinned exactly the same number of times it has been pinned.
+
+Go code may pass a Go pointer to C provided the memory to which it
+points does not contain any Go pointers to memory that is unpinned. When
+passing a pointer to a field in a struct, the Go memory in question is
+the memory occupied by the field, not the entire struct. When passing a
+pointer to an element in an array or slice, the Go memory in question is
+the entire array or the entire backing array of the slice.
+
+C code may keep a copy of a Go pointer only as long as the memory it
+points to is pinned.
+
+C code may not keep a copy of a Go pointer after the call returns,
+unless the memory it points to is pinned with [runtime.Pinner] and the
+Pinner is not unpinned while the Go pointer is stored in C memory.
+This implies that C code may not keep a copy of a string, slice,
+channel, and so forth, because they cannot be pinned with
+[runtime.Pinner].
+
+The _GoString_ type also may not be pinned with [runtime.Pinner].
+Because it includes a Go pointer, the memory it points to is only pinned
+for the duration of the call; _GoString_ values may not be retained by C
+code.
+
+A Go function called by C code may return a Go pointer to pinned memory
+(which implies that it may not return a string, slice, channel, and so
+forth). A Go function called by C code may take C pointers as arguments,
+and it may store non-pointer data, C pointers, or Go pointers to pinned
+memory through those pointers. It may not store a Go pointer to unpinned
+memory in memory pointed to by a C pointer (which again, implies that it
+may not store a string, slice, channel, and so forth). A Go function
+called by C code may take a Go pointer but it must preserve the property
+that the Go memory to which it points (and the Go memory to which that
+memory points, and so on) is pinned.
+
+These rules are checked dynamically at runtime. The checking is
+controlled by the cgocheck setting of the GODEBUG environment
+variable. The default setting is GODEBUG=cgocheck=1, which implements
+reasonably cheap dynamic checks. These checks may be disabled
+entirely using GODEBUG=cgocheck=0. Complete checking of pointer
+handling, at some cost in run time, is available by setting
+GOEXPERIMENT=cgocheck2 at build time.
+
+It is possible to defeat this enforcement by using the unsafe package,
+and of course there is nothing stopping the C code from doing anything
+it likes. However, programs that break these rules are likely to fail
+in unexpected and unpredictable ways.
+
+The type [runtime/cgo.Handle] can be used to safely pass Go values
+between Go and C.
+
+Note: the current implementation has a bug. While Go code is permitted
+to write nil or a C pointer (but not a Go pointer) to C memory, the
+current implementation may sometimes cause a runtime error if the
+contents of the C memory appear to be a Go pointer. Therefore, avoid
+passing uninitialized C memory to Go code if the Go code is going to
+store pointer values in it. Zero out the memory in C before passing it
+to Go.
+
+# Optimizing calls of C code
+
+When passing a Go pointer to a C function the compiler normally ensures
+that the Go object lives on the heap. If the C function does not keep
+a copy of the Go pointer, and never passes the Go pointer back to Go code,
+then this is unnecessary. The #cgo noescape directive may be used to tell
+the compiler that no Go pointers escape via the named C function.
+If the noescape directive is used and the C function does not handle the
+pointer safely, the program may crash or see memory corruption.
+
+For example:
+
+	// #cgo noescape cFunctionName
+
+When a Go function calls a C function, it prepares for the C function to
+call back to a Go function. The #cgo nocallback directive may be used to
+tell the compiler that these preparations are not necessary.
+If the nocallback directive is used and the C function does call back into
+Go code, the program will panic.
+
+For example:
+
+	// #cgo nocallback cFunctionName
+
+# Special cases
+
+A few special C types which would normally be represented by a pointer
+type in Go are instead represented by a uintptr. Those include:
+
+1. The *Ref types on Darwin, rooted at CoreFoundation's CFTypeRef type.
+
+2. The object types from Java's JNI interface:
+
+	jobject
+	jclass
+	jthrowable
+	jstring
+	jarray
+	jbooleanArray
+	jbyteArray
+	jcharArray
+	jshortArray
+	jintArray
+	jlongArray
+	jfloatArray
+	jdoubleArray
+	jobjectArray
+	jweak
+
+3. The EGLDisplay and EGLConfig types from the EGL API.
+
+These types are uintptr on the Go side because they would otherwise
+confuse the Go garbage collector; they are sometimes not really
+pointers but data structures encoded in a pointer type. All operations
+on these types must happen in C. The proper constant to initialize an
+empty such reference is 0, not nil.
+
+These special cases were introduced in Go 1.10. For auto-updating code
+from Go 1.9 and earlier, use the cftype or jni rewrites in the Go fix tool:
+
+	go tool fix -r cftype <pkg>
+	go tool fix -r jni <pkg>
+
+It will replace nil with 0 in the appropriate places.
+
+The EGLDisplay case was introduced in Go 1.12. Use the egl rewrite
+to auto-update code from Go 1.11 and earlier:
+
+	go tool fix -r egl <pkg>
+
+The EGLConfig case was introduced in Go 1.15. Use the eglconf rewrite
+to auto-update code from Go 1.14 and earlier:
+
+	go tool fix -r eglconf <pkg>
+
+# Using cgo directly
+
+Usage:
+
+	go tool cgo [cgo options] [-- compiler options] gofiles...
+
+Cgo transforms the specified input Go source files into several output
+Go and C source files.
+
+The compiler options are passed through uninterpreted when
+invoking the C compiler to compile the C parts of the package.
+
+The following options are available when running cgo directly:
+
+	-V
+		Print cgo version and exit.
+	-debug-define
+		Debugging option. Print #defines.
+	-debug-gcc
+		Debugging option. Trace C compiler execution and output.
+	-dynimport file
+		Write list of symbols imported by file. Write to
+		-dynout argument or to standard output. Used by go
+		build when building a cgo package.
+	-dynlinker
+		Write dynamic linker as part of -dynimport output.
+	-dynout file
+		Write -dynimport output to file.
+	-dynpackage package
+		Set Go package for -dynimport output.
+	-exportheader file
+		If there are any exported functions, write the
+		generated export declarations to file.
+		C code can #include this to see the declarations.
+	-gccgo
+		Generate output for the gccgo compiler rather than the
+		gc compiler.
+	-gccgoprefix prefix
+		The -fgo-prefix option to be used with gccgo.
+	-gccgopkgpath path
+		The -fgo-pkgpath option to be used with gccgo.
+	-gccgo_define_cgoincomplete
+		Define cgo.Incomplete locally rather than importing it from
+		the "runtime/cgo" package. Used for old gccgo versions.
+	-godefs
+		Write out input file in Go syntax replacing C package
+		names with real values. Used to generate files in the
+		syscall package when bootstrapping a new target.
+	-importpath string
+		The import path for the Go package. Optional; used for
+		nicer comments in the generated files.
+	-import_runtime_cgo
+		If set (which it is by default) import runtime/cgo in
+		generated output.
+	-import_syscall
+		If set (which it is by default) import syscall in
+		generated output.
+	-ldflags flags
+		Flags to pass to the C linker. The cmd/go tool uses
+		this to pass in the flags in the CGO_LDFLAGS variable.
+	-objdir directory
+		Put all generated files in directory.
+	-srcdir directory
+		Find the Go input files, listed on the command line,
+		in directory.
+	-trimpath rewrites
+		Apply trims and rewrites to source file paths.
+*/
+package main
+
+/*
+Implementation details.
+
+Cgo provides a way for Go programs to call C code linked into the same
+address space. This comment explains the operation of cgo.
+
+Cgo reads a set of Go source files and looks for statements saying
+import "C". If the import has a doc comment, that comment is
+taken as literal C code to be used as a preamble to any C code
+generated by cgo. A typical preamble #includes necessary definitions:
+
+	// #include <stdio.h>
+	import "C"
+
+For more details about the usage of cgo, see the documentation
+comment at the top of this file.
+
+Understanding C
+
+Cgo scans the Go source files that import "C" for uses of that
+package, such as C.puts. It collects all such identifiers. The next
+step is to determine each kind of name. In C.xxx the xxx might refer
+to a type, a function, a constant, or a global variable. Cgo must
+decide which.
+
+The obvious thing for cgo to do is to process the preamble, expanding
+#includes and processing the corresponding C code. That would require
+a full C parser and type checker that was also aware of any extensions
+known to the system compiler (for example, all the GNU C extensions) as
+well as the system-specific header locations and system-specific
+pre-#defined macros. This is certainly possible to do, but it is an
+enormous amount of work.
+
+Cgo takes a different approach. It determines the meaning of C
+identifiers not by parsing C code but by feeding carefully constructed
+programs into the system C compiler and interpreting the generated
+error messages, debug information, and object files. In practice,
+parsing these is significantly less work and more robust than parsing
+C source.
+
+Cgo first invokes gcc -E -dM on the preamble, in order to find out
+about simple #defines for constants and the like. These are recorded
+for later use.
+
+Next, cgo needs to identify the kinds for each identifier. For the
+identifiers C.foo, cgo generates this C program:
+
+	<preamble>
+	#line 1 "not-declared"
+	void __cgo_f_1_1(void) { __typeof__(foo) *__cgo_undefined__1; }
+	#line 1 "not-type"
+	void __cgo_f_1_2(void) { foo *__cgo_undefined__2; }
+	#line 1 "not-int-const"
+	void __cgo_f_1_3(void) { enum { __cgo_undefined__3 = (foo)*1 }; }
+	#line 1 "not-num-const"
+	void __cgo_f_1_4(void) { static const double __cgo_undefined__4 = (foo); }
+	#line 1 "not-str-lit"
+	void __cgo_f_1_5(void) { static const char __cgo_undefined__5[] = (foo); }
+
+This program will not compile, but cgo can use the presence or absence
+of an error message on a given line to deduce the information it
+needs. The program is syntactically valid regardless of whether each
+name is a type or an ordinary identifier, so there will be no syntax
+errors that might stop parsing early.
+
+An error on not-declared:1 indicates that foo is undeclared.
+An error on not-type:1 indicates that foo is not a type (if declared at all, it is an identifier).
+An error on not-int-const:1 indicates that foo is not an integer constant.
+An error on not-num-const:1 indicates that foo is not a number constant.
+An error on not-str-lit:1 indicates that foo is not a string literal.
+An error on not-signed-int-const:1 indicates that foo is not a signed integer constant.
+
+The line number specifies the name involved. In the example, 1 is foo.
+
+Next, cgo must learn the details of each type, variable, function, or
+constant. It can do this by reading object files. If cgo has decided
+that t1 is a type, v2 and v3 are variables or functions, and i4, i5
+are integer constants, u6 is an unsigned integer constant, and f7 and f8
+are float constants, and s9 and s10 are string constants, it generates:
+
+	<preamble>
+	__typeof__(t1) *__cgo__1;
+	__typeof__(v2) *__cgo__2;
+	__typeof__(v3) *__cgo__3;
+	__typeof__(i4) *__cgo__4;
+	enum { __cgo_enum__4 = i4 };
+	__typeof__(i5) *__cgo__5;
+	enum { __cgo_enum__5 = i5 };
+	__typeof__(u6) *__cgo__6;
+	enum { __cgo_enum__6 = u6 };
+	__typeof__(f7) *__cgo__7;
+	__typeof__(f8) *__cgo__8;
+	__typeof__(s9) *__cgo__9;
+	__typeof__(s10) *__cgo__10;
+
+	long long __cgodebug_ints[] = {
+		0, // t1
+		0, // v2
+		0, // v3
+		i4,
+		i5,
+		u6,
+		0, // f7
+		0, // f8
+		0, // s9
+		0, // s10
+		1
+	};
+
+	double __cgodebug_floats[] = {
+		0, // t1
+		0, // v2
+		0, // v3
+		0, // i4
+		0, // i5
+		0, // u6
+		f7,
+		f8,
+		0, // s9
+		0, // s10
+		1
+	};
+
+	const char __cgodebug_str__9[] = s9;
+	const unsigned long long __cgodebug_strlen__9 = sizeof(s9)-1;
+	const char __cgodebug_str__10[] = s10;
+	const unsigned long long __cgodebug_strlen__10 = sizeof(s10)-1;
+
+and again invokes the system C compiler, to produce an object file
+containing debug information. Cgo parses the DWARF debug information
+for __cgo__N to learn the type of each identifier. (The types also
+distinguish functions from global variables.) Cgo reads the constant
+values from the __cgodebug_* from the object file's data segment.
+
+At this point cgo knows the meaning of each C.xxx well enough to start
+the translation process.
+
+Translating Go
+
+Given the input Go files x.go and y.go, cgo generates these source
+files:
+
+	x.cgo1.go       # for gc (cmd/compile)
+	y.cgo1.go       # for gc
+	_cgo_gotypes.go # for gc
+	_cgo_import.go  # for gc (if -dynout _cgo_import.go)
+	x.cgo2.c        # for gcc
+	y.cgo2.c        # for gcc
+	_cgo_defun.c    # for gcc (if -gccgo)
+	_cgo_export.c   # for gcc
+	_cgo_export.h   # for gcc
+	_cgo_main.c     # for gcc
+	_cgo_flags      # for build tool (if -gccgo)
+
+The file x.cgo1.go is a copy of x.go with the import "C" removed and
+references to C.xxx replaced with names like _Cfunc_xxx or _Ctype_xxx.
+The definitions of those identifiers, written as Go functions, types,
+or variables, are provided in _cgo_gotypes.go.
+
+Here is a _cgo_gotypes.go containing definitions for needed C types:
+
+	type _Ctype_char int8
+	type _Ctype_int int32
+	type _Ctype_void [0]byte
+
+The _cgo_gotypes.go file also contains the definitions of the
+functions. They all have similar bodies that invoke runtime·cgocall
+to make a switch from the Go runtime world to the system C (GCC-based)
+world.
+
+For example, here is the definition of _Cfunc_puts:
+
+	//go:cgo_import_static _cgo_be59f0f25121_Cfunc_puts
+	//go:linkname __cgofn__cgo_be59f0f25121_Cfunc_puts _cgo_be59f0f25121_Cfunc_puts
+	var __cgofn__cgo_be59f0f25121_Cfunc_puts byte
+	var _cgo_be59f0f25121_Cfunc_puts = unsafe.Pointer(&__cgofn__cgo_be59f0f25121_Cfunc_puts)
+
+	func _Cfunc_puts(p0 *_Ctype_char) (r1 _Ctype_int) {
+		_cgo_runtime_cgocall(_cgo_be59f0f25121_Cfunc_puts, uintptr(unsafe.Pointer(&p0)))
+		return
+	}
+
+The hexadecimal number is a hash of cgo's input, chosen to be
+deterministic yet unlikely to collide with other uses. The actual
+function _cgo_be59f0f25121_Cfunc_puts is implemented in a C source
+file compiled by gcc, the file x.cgo2.c:
+
+	void
+	_cgo_be59f0f25121_Cfunc_puts(void *v)
+	{
+		struct {
+			char* p0;
+			int r;
+			char __pad12[4];
+		} __attribute__((__packed__, __gcc_struct__)) *a = v;
+		a->r = puts((void*)a->p0);
+	}
+
+It extracts the arguments from the pointer to _Cfunc_puts's argument
+frame, invokes the system C function (in this case, puts), stores the
+result in the frame, and returns.
+
+Linking
+
+Once the _cgo_export.c and *.cgo2.c files have been compiled with gcc,
+they need to be linked into the final binary, along with the libraries
+they might depend on (in the case of puts, stdio). cmd/link has been
+extended to understand basic ELF files, but it does not understand ELF
+in the full complexity that modern C libraries embrace, so it cannot
+in general generate direct references to the system libraries.
+
+Instead, the build process generates an object file using dynamic
+linkage to the desired libraries. The main function is provided by
+_cgo_main.c:
+
+	int main(int argc, char **argv) { return 0; }
+	void crosscall2(void(*fn)(void*), void *a, int c, uintptr_t ctxt) { }
+	uintptr_t _cgo_wait_runtime_init_done(void) { return 0; }
+	void _cgo_release_context(uintptr_t ctxt) { }
+	char* _cgo_topofstack(void) { return (char*)0; }
+	void _cgo_allocate(void *a, int c) { }
+	void _cgo_panic(void *a, int c) { }
+	void _cgo_reginit(void) { }
+
+The extra functions here are stubs to satisfy the references in the C
+code generated for gcc. The build process links this stub, along with
+_cgo_export.c and *.cgo2.c, into a dynamic executable and then lets
+cgo examine the executable. Cgo records the list of shared library
+references and resolved names and writes them into a new file
+_cgo_import.go, which looks like:
+
+	//go:cgo_dynamic_linker "/lib64/ld-linux-x86-64.so.2"
+	//go:cgo_import_dynamic puts puts#GLIBC_2.2.5 "libc.so.6"
+	//go:cgo_import_dynamic __libc_start_main __libc_start_main#GLIBC_2.2.5 "libc.so.6"
+	//go:cgo_import_dynamic stdout stdout#GLIBC_2.2.5 "libc.so.6"
+	//go:cgo_import_dynamic fflush fflush#GLIBC_2.2.5 "libc.so.6"
+	//go:cgo_import_dynamic _ _ "libpthread.so.0"
+	//go:cgo_import_dynamic _ _ "libc.so.6"
+
+In the end, the compiled Go package, which will eventually be
+presented to cmd/link as part of a larger program, contains:
+
+	_go_.o        # gc-compiled object for _cgo_gotypes.go, _cgo_import.go, *.cgo1.go
+	_all.o        # gcc-compiled object for _cgo_export.c, *.cgo2.c
+
+If there is an error generating the _cgo_import.go file, then, instead
+of adding _cgo_import.go to the package, the go tool adds an empty
+file named dynimportfail. The _cgo_import.go file is only needed when
+using internal linking mode, which is not the default when linking
+programs that use cgo (as described below). If the linker sees a file
+named dynimportfail it reports an error if it has been told to use
+internal linking mode. This approach is taken because generating
+_cgo_import.go requires doing a full C link of the package, which can
+fail for reasons that are irrelevant when using external linking mode.
+
+The final program will be a dynamic executable, so that cmd/link can avoid
+needing to process arbitrary .o files. It only needs to process the .o
+files generated from C files that cgo writes, and those are much more
+limited in the ELF or other features that they use.
+
+In essence, the _cgo_import.o file includes the extra linking
+directives that cmd/link is not sophisticated enough to derive from _all.o
+on its own. Similarly, the _all.o uses dynamic references to real
+system object code because cmd/link is not sophisticated enough to process
+the real code.
+
+The main benefits of this system are that cmd/link remains relatively simple
+(it does not need to implement a complete ELF and Mach-O linker) and
+that gcc is not needed after the package is compiled. For example,
+package net uses cgo for access to name resolution functions provided
+by libc. Although gcc is needed to compile package net, gcc is not
+needed to link programs that import package net.
+
+Runtime
+
+When using cgo, Go must not assume that it owns all details of the
+process. In particular it needs to coordinate with C in the use of
+threads and thread-local storage. The runtime package declares a few
+variables:
+
+	var (
+		iscgo             bool
+		_cgo_init         unsafe.Pointer
+		_cgo_thread_start unsafe.Pointer
+	)
+
+Any package using cgo imports "runtime/cgo", which provides
+initializations for these variables. It sets iscgo to true, _cgo_init
+to a gcc-compiled function that can be called early during program
+startup, and _cgo_thread_start to a gcc-compiled function that can be
+used to create a new thread, in place of the runtime's usual direct
+system calls.
+
+Internal and External Linking
+
+The text above describes "internal" linking, in which cmd/link parses and
+links host object files (ELF, Mach-O, PE, and so on) into the final
+executable itself. Keeping cmd/link simple means we cannot possibly
+implement the full semantics of the host linker, so the kinds of
+objects that can be linked directly into the binary is limited (other
+code can only be used as a dynamic library). On the other hand, when
+using internal linking, cmd/link can generate Go binaries by itself.
+
+In order to allow linking arbitrary object files without requiring
+dynamic libraries, cgo supports an "external" linking mode too. In
+external linking mode, cmd/link does not process any host object files.
+Instead, it collects all the Go code and writes a single go.o object
+file containing it. Then it invokes the host linker (usually gcc) to
+combine the go.o object file and any supporting non-Go code into a
+final executable. External linking avoids the dynamic library
+requirement but introduces a requirement that the host linker be
+present to create such a binary.
+
+Most builds both compile source code and invoke the linker to create a
+binary. When cgo is involved, the compile step already requires gcc, so
+it is not problematic for the link step to require gcc too.
+
+An important exception is builds using a pre-compiled copy of the
+standard library. In particular, package net uses cgo on most systems,
+and we want to preserve the ability to compile pure Go code that
+imports net without requiring gcc to be present at link time. (In this
+case, the dynamic library requirement is less significant, because the
+only library involved is libc.so, which can usually be assumed
+present.)
+
+This conflict between functionality and the gcc requirement means we
+must support both internal and external linking, depending on the
+circumstances: if net is the only cgo-using package, then internal
+linking is probably fine, but if other packages are involved, so that there
+are dependencies on libraries beyond libc, external linking is likely
+to work better. The compilation of a package records the relevant
+information to support both linking modes, leaving the decision
+to be made when linking the final binary.
+
+Linking Directives
+
+In either linking mode, package-specific directives must be passed
+through to cmd/link. These are communicated by writing //go: directives in a
+Go source file compiled by gc. The directives are copied into the .o
+object file and then processed by the linker.
+
+The directives are:
+
+//go:cgo_import_dynamic <local> [<remote> ["<library>"]]
+
+	In internal linking mode, allow an unresolved reference to
+	<local>, assuming it will be resolved by a dynamic library
+	symbol. The optional <remote> specifies the symbol's name and
+	possibly version in the dynamic library, and the optional "<library>"
+	names the specific library where the symbol should be found.
+
+	On AIX, the library pattern is slightly different. It must be
+	"lib.a/obj.o" with obj.o the member of this library exporting
+	this symbol.
+
+	In the <remote>, # or @ can be used to introduce a symbol version.
+
+	Examples:
+	//go:cgo_import_dynamic puts
+	//go:cgo_import_dynamic puts puts#GLIBC_2.2.5
+	//go:cgo_import_dynamic puts puts#GLIBC_2.2.5 "libc.so.6"
+
+	A side effect of the cgo_import_dynamic directive with a
+	library is to make the final binary depend on that dynamic
+	library. To get the dependency without importing any specific
+	symbols, use _ for local and remote.
+
+	Example:
+	//go:cgo_import_dynamic _ _ "libc.so.6"
+
+	For compatibility with current versions of SWIG,
+	#pragma dynimport is an alias for //go:cgo_import_dynamic.
+
+//go:cgo_dynamic_linker "<path>"
+
+	In internal linking mode, use "<path>" as the dynamic linker
+	in the final binary. This directive is only needed from one
+	package when constructing a binary; by convention it is
+	supplied by runtime/cgo.
+
+	Example:
+	//go:cgo_dynamic_linker "/lib/ld-linux.so.2"
+
+//go:cgo_export_dynamic <local> <remote>
+
+	In internal linking mode, put the Go symbol
+	named <local> into the program's exported symbol table as
+	<remote>, so that C code can refer to it by that name. This
+	mechanism makes it possible for C code to call back into Go or
+	to share Go's data.
+
+	For compatibility with current versions of SWIG,
+	#pragma dynexport is an alias for //go:cgo_export_dynamic.
+
+//go:cgo_import_static <local>
+
+	In external linking mode, allow unresolved references to
+	<local> in the go.o object file prepared for the host linker,
+	under the assumption that <local> will be supplied by the
+	other object files that will be linked with go.o.
+
+	Example:
+	//go:cgo_import_static puts_wrapper
+
+//go:cgo_export_static <local> <remote>
+
+	In external linking mode, put the Go symbol
+	named <local> into the program's exported symbol table as
+	<remote>, so that C code can refer to it by that name. This
+	mechanism makes it possible for C code to call back into Go or
+	to share Go's data.
+
+//go:cgo_ldflag "<arg>"
+
+	In external linking mode, invoke the host linker (usually gcc)
+	with "<arg>" as a command-line argument following the .o files.
+	Note that the arguments are for "gcc", not "ld".
+
+	Example:
+	//go:cgo_ldflag "-lpthread"
+	//go:cgo_ldflag "-L/usr/local/sqlite3/lib"
+
+A package compiled with cgo will include directives for both
+internal and external linking; the linker will select the appropriate
+subset for the chosen linking mode.
+
+Example
+
+As a simple example, consider a package that uses cgo to call C.sin.
+The following code will be generated by cgo:
+
+	// compiled by gc
+
+	//go:cgo_ldflag "-lm"
+
+	type _Ctype_double float64
+
+	//go:cgo_import_static _cgo_gcc_Cfunc_sin
+	//go:linkname __cgo_gcc_Cfunc_sin _cgo_gcc_Cfunc_sin
+	var __cgo_gcc_Cfunc_sin byte
+	var _cgo_gcc_Cfunc_sin = unsafe.Pointer(&__cgo_gcc_Cfunc_sin)
+
+	func _Cfunc_sin(p0 _Ctype_double) (r1 _Ctype_double) {
+		_cgo_runtime_cgocall(_cgo_gcc_Cfunc_sin, uintptr(unsafe.Pointer(&p0)))
+		return
+	}
+
+	// compiled by gcc, into foo.cgo2.o
+
+	void
+	_cgo_gcc_Cfunc_sin(void *v)
+	{
+		struct {
+			double p0;
+			double r;
+		} __attribute__((__packed__)) *a = v;
+		a->r = sin(a->p0);
+	}
+
+What happens at link time depends on whether the final binary is linked
+using the internal or external mode. If other packages are compiled in
+"external only" mode, then the final link will be an external one.
+Otherwise the link will be an internal one.
+
+The linking directives are used according to the kind of final link
+used.
+
+In internal mode, cmd/link itself processes all the host object files, in
+particular foo.cgo2.o. To do so, it uses the cgo_import_dynamic and
+cgo_dynamic_linker directives to learn that the otherwise undefined
+reference to sin in foo.cgo2.o should be rewritten to refer to the
+symbol sin with version GLIBC_2.2.5 from the dynamic library
+"libm.so.6", and the binary should request "/lib/ld-linux.so.2" as its
+runtime dynamic linker.
+
+In external mode, cmd/link does not process any host object files, in
+particular foo.cgo2.o. It links together the gc-generated object
+files, along with any other Go code, into a go.o file. While doing
+that, cmd/link will discover that there is no definition for
+_cgo_gcc_Cfunc_sin, referred to by the gc-compiled source file. This
+is okay, because cmd/link also processes the cgo_import_static directive and
+knows that _cgo_gcc_Cfunc_sin is expected to be supplied by a host
+object file, so cmd/link does not treat the missing symbol as an error when
+creating go.o. Indeed, the definition for _cgo_gcc_Cfunc_sin will be
+provided to the host linker by foo2.cgo.o, which in turn will need the
+symbol 'sin'. cmd/link also processes the cgo_ldflag directives, so that it
+knows that the eventual host link command must include the -lm
+argument, so that the host linker will be able to find 'sin' in the
+math library.
+
+cmd/link Command Line Interface
+
+The go command and any other Go-aware build systems invoke cmd/link
+to link a collection of packages into a single binary. By default, cmd/link will
+present the same interface it does today:
+
+	cmd/link main.a
+
+produces a file named a.out, even if cmd/link does so by invoking the host
+linker in external linking mode.
+
+By default, cmd/link will decide the linking mode as follows: if the only
+packages using cgo are those on a list of known standard library
+packages (net, os/user, runtime/cgo), cmd/link will use internal linking
+mode. Otherwise, there are non-standard cgo packages involved, and cmd/link
+will use external linking mode. The first rule means that a build of
+the godoc binary, which uses net but no other cgo, can run without
+needing gcc available. The second rule means that a build of a
+cgo-wrapped library like sqlite3 can generate a standalone executable
+instead of needing to refer to a dynamic library. The specific choice
+can be overridden using a command line flag: cmd/link -linkmode=internal or
+cmd/link -linkmode=external.
+
+In an external link, cmd/link will create a temporary directory, write any
+host object files found in package archives to that directory (renamed
+to avoid conflicts), write the go.o file to that directory, and invoke
+the host linker. The default value for the host linker is $CC, split
+into fields, or else "gcc". The specific host linker command line can
+be overridden using command line flags: cmd/link -extld=clang
+-extldflags='-ggdb -O3'. If any package in a build includes a .cc or
+other file compiled by the C++ compiler, the go tool will use the
+-extld option to set the host linker to the C++ compiler.
+
+These defaults mean that Go-aware build systems can ignore the linking
+changes and keep running plain 'cmd/link' and get reasonable results, but
+they can also control the linking details if desired.
+
+*/

go/src/cmd/cgo/godefs.go

@@ -0,0 +1,127 @@
+// Copyright 2011 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"
+	"go/ast"
+	"go/printer"
+	"go/token"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// godefs returns the output for -godefs mode.
+func (p *Package) godefs(f *File, args []string) string {
+	var buf strings.Builder
+
+	fmt.Fprintf(&buf, "// Code generated by cmd/cgo -godefs; DO NOT EDIT.\n")
+	fmt.Fprintf(&buf, "// %s %s\n", filepath.Base(args[0]), strings.Join(args[1:], " "))
+	fmt.Fprintf(&buf, "\n")
+
+	override := make(map[string]string)
+
+	// Allow source file to specify override mappings.
+	// For example, the socket data structures refer
+	// to in_addr and in_addr6 structs but we want to be
+	// able to treat them as byte arrays, so the godefs
+	// inputs in package syscall say
+	//
+	//	// +godefs map struct_in_addr [4]byte
+	//	// +godefs map struct_in_addr6 [16]byte
+	//
+	for _, g := range f.Comments {
+		for _, c := range g.List {
+			i := strings.Index(c.Text, "+godefs map")
+			if i < 0 {
+				continue
+			}
+			s := strings.TrimSpace(c.Text[i+len("+godefs map"):])
+			i = strings.Index(s, " ")
+			if i < 0 {
+				fmt.Fprintf(os.Stderr, "invalid +godefs map comment: %s\n", c.Text)
+				continue
+			}
+			override["_Ctype_"+strings.TrimSpace(s[:i])] = strings.TrimSpace(s[i:])
+		}
+	}
+	for _, n := range f.Name {
+		if s := override[n.Go]; s != "" {
+			override[n.Mangle] = s
+		}
+	}
+
+	// Otherwise, if the source file says type T C.whatever,
+	// use "T" as the mangling of C.whatever,
+	// except in the definition (handled at end of function).
+	refName := make(map[*ast.Expr]*Name)
+	for _, r := range f.Ref {
+		refName[r.Expr] = r.Name
+	}
+	for _, d := range f.AST.Decls {
+		d, ok := d.(*ast.GenDecl)
+		if !ok || d.Tok != token.TYPE {
+			continue
+		}
+		for _, s := range d.Specs {
+			s := s.(*ast.TypeSpec)
+			n := refName[&s.Type]
+			if n != nil && n.Mangle != "" {
+				override[n.Mangle] = s.Name.Name
+			}
+		}
+	}
+
+	// Extend overrides using typedefs:
+	// If we know that C.xxx should format as T
+	// and xxx is a typedef for yyy, make C.yyy format as T.
+	for typ, def := range typedef {
+		if new := override[typ]; new != "" {
+			if id, ok := def.Go.(*ast.Ident); ok {
+				override[id.Name] = new
+			}
+		}
+	}
+
+	// Apply overrides.
+	for old, new := range override {
+		if id := goIdent[old]; id != nil {
+			id.Name = new
+		}
+	}
+
+	// Any names still using the _C syntax are not going to compile,
+	// although in general we don't know whether they all made it
+	// into the file, so we can't warn here.
+	//
+	// The most common case is union types, which begin with
+	// _Ctype_union and for which typedef[name] is a Go byte
+	// array of the appropriate size (such as [4]byte).
+	// Substitute those union types with byte arrays.
+	for name, id := range goIdent {
+		if id.Name == name && strings.Contains(name, "_Ctype_union") {
+			if def := typedef[name]; def != nil {
+				id.Name = gofmt(def)
+			}
+		}
+	}
+
+	conf.Fprint(&buf, fset, f.AST)
+
+	return buf.String()
+}
+
+var gofmtBuf strings.Builder
+
+// gofmt returns the gofmt-formatted string for an AST node.
+func gofmt(n any) string {
+	gofmtBuf.Reset()
+	err := printer.Fprint(&gofmtBuf, fset, n)
+	if err != nil {
+		return "<" + err.Error() + ">"
+	}
+	return gofmtBuf.String()
+}

go/src/cmd/cgo/main.go

@@ -0,0 +1,617 @@
+// Copyright 2009 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.
+
+// Cgo; see doc.go for an overview.
+
+// TODO(rsc):
+//	Emit correct line number annotations.
+//	Make gc understand the annotations.
+
+package main
+
+import (
+	"flag"
+	"fmt"
+	"go/ast"
+	"go/printer"
+	"go/token"
+	"internal/buildcfg"
+	"io"
+	"maps"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"sort"
+	"strings"
+	"sync"
+
+	"cmd/internal/edit"
+	"cmd/internal/hash"
+	"cmd/internal/objabi"
+	"cmd/internal/par"
+	"cmd/internal/telemetry/counter"
+)
+
+// A Package collects information about the package we're going to write.
+type Package struct {
+	PackageName string // name of package
+	PackagePath string
+	PtrSize     int64
+	IntSize     int64
+	GccOptions  []string
+	GccIsClang  bool
+	LdFlags     []string // #cgo LDFLAGS
+	Written     map[string]bool
+	Name        map[string]*Name // accumulated Name from Files
+	ExpFunc     []*ExpFunc       // accumulated ExpFunc from Files
+	Decl        []ast.Decl
+	GoFiles     []string        // list of Go files
+	GccFiles    []string        // list of gcc output files
+	Preamble    string          // collected preamble for _cgo_export.h
+	noCallbacks map[string]bool // C function names with #cgo nocallback directive
+	noEscapes   map[string]bool // C function names with #cgo noescape directive
+}
+
+// A typedefInfo is an element on Package.typedefList: a typedef name
+// and the position where it was required.
+type typedefInfo struct {
+	typedef string
+	pos     token.Pos
+}
+
+// A File collects information about a single Go input file.
+type File struct {
+	AST         *ast.File           // parsed AST
+	Comments    []*ast.CommentGroup // comments from file
+	Package     string              // Package name
+	Preamble    string              // C preamble (doc comment on import "C")
+	Ref         []*Ref              // all references to C.xxx in AST
+	Calls       []*Call             // all calls to C.xxx in AST
+	ExpFunc     []*ExpFunc          // exported functions for this file
+	Name        map[string]*Name    // map from Go name to Name
+	NamePos     map[*Name]token.Pos // map from Name to position of the first reference
+	NoCallbacks map[string]bool     // C function names with #cgo nocallback directive
+	NoEscapes   map[string]bool     // C function names with #cgo noescape directive
+	Edit        *edit.Buffer
+
+	debugs []*debug // debug data from iterations of gccDebug. Initialized by File.loadDebug.
+}
+
+func (f *File) offset(p token.Pos) int {
+	return fset.Position(p).Offset
+}
+
+func nameKeys(m map[string]*Name) []string {
+	ks := make([]string, 0, len(m))
+	for k := range m {
+		ks = append(ks, k)
+	}
+	sort.Strings(ks)
+	return ks
+}
+
+// A Call refers to a call of a C.xxx function in the AST.
+type Call struct {
+	Call     *ast.CallExpr
+	Deferred bool
+	Done     bool
+}
+
+// A Ref refers to an expression of the form C.xxx in the AST.
+type Ref struct {
+	Name    *Name
+	Expr    *ast.Expr
+	Context astContext
+	Done    bool
+}
+
+func (r *Ref) Pos() token.Pos {
+	return (*r.Expr).Pos()
+}
+
+var nameKinds = []string{"iconst", "fconst", "sconst", "type", "var", "fpvar", "func", "macro", "not-type"}
+
+// A Name collects information about C.xxx.
+type Name struct {
+	Go       string // name used in Go referring to package C
+	Mangle   string // name used in generated Go
+	C        string // name used in C
+	Define   string // #define expansion
+	Kind     string // one of the nameKinds
+	Type     *Type  // the type of xxx
+	FuncType *FuncType
+	AddError bool
+	Const    string // constant definition
+}
+
+// IsVar reports whether Kind is either "var" or "fpvar"
+func (n *Name) IsVar() bool {
+	return n.Kind == "var" || n.Kind == "fpvar"
+}
+
+// IsConst reports whether Kind is either "iconst", "fconst" or "sconst"
+func (n *Name) IsConst() bool {
+	return strings.HasSuffix(n.Kind, "const")
+}
+
+// An ExpFunc is an exported function, callable from C.
+// Such functions are identified in the Go input file
+// by doc comments containing the line //export ExpName
+type ExpFunc struct {
+	Func    *ast.FuncDecl
+	ExpName string // name to use from C
+	Doc     string
+}
+
+// A TypeRepr contains the string representation of a type.
+type TypeRepr struct {
+	Repr       string
+	FormatArgs []any
+}
+
+// A Type collects information about a type in both the C and Go worlds.
+type Type struct {
+	Size       int64
+	Align      int64
+	C          *TypeRepr
+	Go         ast.Expr
+	EnumValues map[string]int64
+	Typedef    string
+	BadPointer bool // this pointer type should be represented as a uintptr (deprecated)
+}
+
+func (t *Type) fuzzyMatch(t2 *Type) bool {
+	if t == nil || t2 == nil {
+		return false
+	}
+	return t.Size == t2.Size && t.Align == t2.Align
+}
+
+// A FuncType collects information about a function type in both the C and Go worlds.
+type FuncType struct {
+	Params []*Type
+	Result *Type
+	Go     *ast.FuncType
+}
+
+func (t *FuncType) fuzzyMatch(t2 *FuncType) bool {
+	if t == nil || t2 == nil {
+		return false
+	}
+	if !t.Result.fuzzyMatch(t2.Result) {
+		return false
+	}
+	if len(t.Params) != len(t2.Params) {
+		return false
+	}
+	for i := range t.Params {
+		if !t.Params[i].fuzzyMatch(t2.Params[i]) {
+			return false
+		}
+	}
+	return true
+}
+
+func usage() {
+	fmt.Fprint(os.Stderr, "usage: cgo -- [compiler options] file.go ...\n")
+	flag.PrintDefaults()
+	os.Exit(2)
+}
+
+var ptrSizeMap = map[string]int64{
+	"386":      4,
+	"alpha":    8,
+	"amd64":    8,
+	"arm":      4,
+	"arm64":    8,
+	"loong64":  8,
+	"m68k":     4,
+	"mips":     4,
+	"mipsle":   4,
+	"mips64":   8,
+	"mips64le": 8,
+	"nios2":    4,
+	"ppc":      4,
+	"ppc64":    8,
+	"ppc64le":  8,
+	"riscv":    4,
+	"riscv64":  8,
+	"s390":     4,
+	"s390x":    8,
+	"sh":       4,
+	"shbe":     4,
+	"sparc":    4,
+	"sparc64":  8,
+}
+
+var intSizeMap = map[string]int64{
+	"386":      4,
+	"alpha":    8,
+	"amd64":    8,
+	"arm":      4,
+	"arm64":    8,
+	"loong64":  8,
+	"m68k":     4,
+	"mips":     4,
+	"mipsle":   4,
+	"mips64":   8,
+	"mips64le": 8,
+	"nios2":    4,
+	"ppc":      4,
+	"ppc64":    8,
+	"ppc64le":  8,
+	"riscv":    4,
+	"riscv64":  8,
+	"s390":     4,
+	"s390x":    8,
+	"sh":       4,
+	"shbe":     4,
+	"sparc":    4,
+	"sparc64":  8,
+}
+
+var cPrefix string
+
+var fset = token.NewFileSet()
+
+var dynobj = flag.String("dynimport", "", "if non-empty, print dynamic import data for that file")
+var dynout = flag.String("dynout", "", "write -dynimport output to this file")
+var dynpackage = flag.String("dynpackage", "main", "set Go package for -dynimport output")
+var dynlinker = flag.Bool("dynlinker", false, "record dynamic linker information in -dynimport mode")
+
+// This flag is for bootstrapping a new Go implementation,
+// to generate Go types that match the data layout and
+// constant values used in the host's C libraries and system calls.
+var godefs = flag.Bool("godefs", false, "for bootstrap: write Go definitions for C file to standard output")
+
+var srcDir = flag.String("srcdir", "", "source directory")
+var objDir = flag.String("objdir", "", "object directory")
+var importPath = flag.String("importpath", "", "import path of package being built (for comments in generated files)")
+var exportHeader = flag.String("exportheader", "", "where to write export header if any exported functions")
+
+var ldflags = flag.String("ldflags", "", "flags to pass to C linker")
+
+var gccgo = flag.Bool("gccgo", false, "generate files for use with gccgo")
+var gccgoprefix = flag.String("gccgoprefix", "", "-fgo-prefix option used with gccgo")
+var gccgopkgpath = flag.String("gccgopkgpath", "", "-fgo-pkgpath option used with gccgo")
+var gccgoMangler func(string) string
+var gccgoDefineCgoIncomplete = flag.Bool("gccgo_define_cgoincomplete", false, "define cgo.Incomplete for older gccgo/GoLLVM")
+var importRuntimeCgo = flag.Bool("import_runtime_cgo", true, "import runtime/cgo in generated code")
+var importSyscall = flag.Bool("import_syscall", true, "import syscall in generated code")
+var trimpath = flag.String("trimpath", "", "applies supplied rewrites or trims prefixes to recorded source file paths")
+
+var goarch, goos, gomips, gomips64 string
+var gccBaseCmd []string
+
+func main() {
+	counter.Open()
+	objabi.AddVersionFlag() // -V
+	objabi.Flagparse(usage)
+	counter.Inc("cgo/invocations")
+	counter.CountFlags("cgo/flag:", *flag.CommandLine)
+
+	if *gccgoDefineCgoIncomplete {
+		if !*gccgo {
+			fmt.Fprintf(os.Stderr, "cgo: -gccgo_define_cgoincomplete without -gccgo\n")
+			os.Exit(2)
+		}
+		incomplete = "_cgopackage_Incomplete"
+	}
+
+	if *dynobj != "" {
+		// cgo -dynimport is essentially a separate helper command
+		// built into the cgo binary. It scans a gcc-produced executable
+		// and dumps information about the imported symbols and the
+		// imported libraries. The 'go build' rules for cgo prepare an
+		// appropriate executable and then use its import information
+		// instead of needing to make the linkers duplicate all the
+		// specialized knowledge gcc has about where to look for imported
+		// symbols and which ones to use.
+		dynimport(*dynobj)
+		return
+	}
+
+	if *godefs {
+		// Generating definitions pulled from header files,
+		// to be checked into Go repositories.
+		// Line numbers are just noise.
+		conf.Mode &^= printer.SourcePos
+	}
+
+	args := flag.Args()
+	if len(args) < 1 {
+		usage()
+	}
+
+	// Find first arg that looks like a go file and assume everything before
+	// that are options to pass to gcc.
+	var i int
+	for i = len(args); i > 0; i-- {
+		if !strings.HasSuffix(args[i-1], ".go") {
+			break
+		}
+	}
+	if i == len(args) {
+		usage()
+	}
+
+	// Save original command line arguments for the godefs generated comment. Relative file
+	// paths in os.Args will be rewritten to absolute file paths in the loop below.
+	osArgs := make([]string, len(os.Args))
+	copy(osArgs, os.Args[:])
+	goFiles := args[i:]
+
+	for _, arg := range args[:i] {
+		if arg == "-fsanitize=thread" {
+			tsanProlog = yesTsanProlog
+		}
+		if arg == "-fsanitize=memory" {
+			msanProlog = yesMsanProlog
+		}
+	}
+
+	p := newPackage(args[:i])
+
+	// We need a C compiler to be available. Check this.
+	var err error
+	gccBaseCmd, err = checkGCCBaseCmd()
+	if err != nil {
+		fatalf("%v", err)
+		os.Exit(2)
+	}
+
+	// Record linker flags for external linking.
+	if *ldflags != "" {
+		args, err := splitQuoted(*ldflags)
+		if err != nil {
+			fatalf("bad -ldflags option: %q (%s)", *ldflags, err)
+		}
+		p.addToFlag("LDFLAGS", args)
+	}
+
+	// For backward compatibility for Bazel, record CGO_LDFLAGS
+	// from the environment for external linking.
+	// This should not happen with cmd/go, which removes CGO_LDFLAGS
+	// from the environment when invoking cgo.
+	// This can be removed when we no longer need to support
+	// older versions of Bazel. See issue #66456 and
+	// https://github.com/bazelbuild/rules_go/issues/3979.
+	if envFlags := os.Getenv("CGO_LDFLAGS"); envFlags != "" {
+		args, err := splitQuoted(envFlags)
+		if err != nil {
+			fatalf("bad CGO_LDFLAGS: %q (%s)", envFlags, err)
+		}
+		p.addToFlag("LDFLAGS", args)
+	}
+
+	// Need a unique prefix for the global C symbols that
+	// we use to coordinate between gcc and ourselves.
+	// We already put _cgo_ at the beginning, so the main
+	// concern is other cgo wrappers for the same functions.
+	// Use the beginning of the 16 bytes hash of the input to disambiguate.
+	h := hash.New32()
+	io.WriteString(h, *importPath)
+	var once sync.Once
+	q := par.NewQueue(runtime.GOMAXPROCS(0))
+	fs := make([]*File, len(goFiles))
+	for i, input := range goFiles {
+		if *srcDir != "" {
+			input = filepath.Join(*srcDir, input)
+		}
+
+		// Create absolute path for file, so that it will be used in error
+		// messages and recorded in debug line number information.
+		// This matches the rest of the toolchain. See golang.org/issue/5122.
+		if aname, err := filepath.Abs(input); err == nil {
+			input = aname
+		}
+
+		b, err := os.ReadFile(input)
+		if err != nil {
+			fatalf("%s", err)
+		}
+		if _, err = h.Write(b); err != nil {
+			fatalf("%s", err)
+		}
+
+		q.Add(func() {
+			// Apply trimpath to the file path. The path won't be read from after this point.
+			input, _ = objabi.ApplyRewrites(input, *trimpath)
+			if strings.ContainsAny(input, "\r\n") {
+				// ParseGo, (*Package).writeOutput, and printer.Fprint in SourcePos mode
+				// all emit line directives, which don't permit newlines in the file path.
+				// Bail early if we see anything newline-like in the trimmed path.
+				fatalf("input path contains newline character: %q", input)
+			}
+			goFiles[i] = input
+
+			f := new(File)
+			f.Edit = edit.NewBuffer(b)
+			f.ParseGo(input, b)
+			f.ProcessCgoDirectives()
+			gccIsClang := f.loadDefines(p.GccOptions)
+			once.Do(func() {
+				p.GccIsClang = gccIsClang
+			})
+
+			fs[i] = f
+
+			f.loadDebug(p)
+		})
+	}
+
+	<-q.Idle()
+
+	cPrefix = fmt.Sprintf("_%x", h.Sum(nil)[0:6])
+
+	if *objDir == "" {
+		*objDir = "_obj"
+	}
+	// make sure that `objDir` directory exists, so that we can write
+	// all the output files there.
+	os.MkdirAll(*objDir, 0o700)
+	*objDir += string(filepath.Separator)
+
+	for i, input := range goFiles {
+		f := fs[i]
+		p.Translate(f)
+		for _, cref := range f.Ref {
+			switch cref.Context {
+			case ctxCall, ctxCall2:
+				if cref.Name.Kind != "type" {
+					break
+				}
+				old := *cref.Expr
+				*cref.Expr = cref.Name.Type.Go
+				f.Edit.Replace(f.offset(old.Pos()), f.offset(old.End()), gofmt(cref.Name.Type.Go))
+			}
+		}
+		if nerrors > 0 {
+			os.Exit(2)
+		}
+		p.PackagePath = f.Package
+		p.Record(f)
+		if *godefs {
+			os.Stdout.WriteString(p.godefs(f, osArgs))
+		} else {
+			p.writeOutput(f, input)
+		}
+	}
+	cFunctions := make(map[string]bool)
+	for _, key := range nameKeys(p.Name) {
+		n := p.Name[key]
+		if n.FuncType != nil {
+			cFunctions[n.C] = true
+		}
+	}
+
+	for funcName := range p.noEscapes {
+		if _, found := cFunctions[funcName]; !found {
+			error_(token.NoPos, "#cgo noescape %s: no matched C function", funcName)
+		}
+	}
+
+	for funcName := range p.noCallbacks {
+		if _, found := cFunctions[funcName]; !found {
+			error_(token.NoPos, "#cgo nocallback %s: no matched C function", funcName)
+		}
+	}
+
+	if !*godefs {
+		p.writeDefs()
+	}
+	if nerrors > 0 {
+		os.Exit(2)
+	}
+}
+
+// newPackage returns a new Package that will invoke
+// gcc with the additional arguments specified in args.
+func newPackage(args []string) *Package {
+	goarch = runtime.GOARCH
+	if s := os.Getenv("GOARCH"); s != "" {
+		goarch = s
+	}
+	goos = runtime.GOOS
+	if s := os.Getenv("GOOS"); s != "" {
+		goos = s
+	}
+	buildcfg.Check()
+	gomips = buildcfg.GOMIPS
+	gomips64 = buildcfg.GOMIPS64
+	ptrSize := ptrSizeMap[goarch]
+	if ptrSize == 0 {
+		fatalf("unknown ptrSize for $GOARCH %q", goarch)
+	}
+	intSize := intSizeMap[goarch]
+	if intSize == 0 {
+		fatalf("unknown intSize for $GOARCH %q", goarch)
+	}
+
+	// Reset locale variables so gcc emits English errors [sic].
+	os.Setenv("LANG", "en_US.UTF-8")
+	os.Setenv("LC_ALL", "C")
+
+	p := &Package{
+		PtrSize:     ptrSize,
+		IntSize:     intSize,
+		Written:     make(map[string]bool),
+		noCallbacks: make(map[string]bool),
+		noEscapes:   make(map[string]bool),
+	}
+	p.addToFlag("CFLAGS", args)
+	return p
+}
+
+// Record what needs to be recorded about f.
+func (p *Package) Record(f *File) {
+	if p.PackageName == "" {
+		p.PackageName = f.Package
+	} else if p.PackageName != f.Package {
+		error_(token.NoPos, "inconsistent package names: %s, %s", p.PackageName, f.Package)
+	}
+
+	if p.Name == nil {
+		p.Name = f.Name
+	} else {
+		// Merge the new file's names in with the existing names.
+		for k, v := range f.Name {
+			if p.Name[k] == nil {
+				// Never seen before, just save it.
+				p.Name[k] = v
+			} else if p.incompleteTypedef(p.Name[k].Type) && p.Name[k].FuncType == nil {
+				// Old one is incomplete, just use new one.
+				p.Name[k] = v
+			} else if p.incompleteTypedef(v.Type) && v.FuncType == nil {
+				// New one is incomplete, just use old one.
+				// Nothing to do.
+			} else if _, ok := nameToC[k]; ok {
+				// Names we predefine may appear inconsistent
+				// if some files typedef them and some don't.
+				// Issue 26743.
+			} else if !reflect.DeepEqual(p.Name[k], v) {
+				// We don't require strict func type equality, because some functions
+				// can have things like typedef'd arguments that are equivalent to
+				// the standard arguments. e.g.
+				//     int usleep(unsigned);
+				//     int usleep(useconds_t);
+				// So we just check size/alignment of arguments. At least that
+				// avoids problems like those in #67670 and #67699.
+				ok := false
+				ft1 := p.Name[k].FuncType
+				ft2 := v.FuncType
+				if ft1.fuzzyMatch(ft2) {
+					// Retry DeepEqual with the FuncType field cleared.
+					x1 := *p.Name[k]
+					x2 := *v
+					x1.FuncType = nil
+					x2.FuncType = nil
+					if reflect.DeepEqual(&x1, &x2) {
+						ok = true
+					}
+				}
+				if !ok {
+					error_(token.NoPos, "inconsistent definitions for C.%s", fixGo(k))
+				}
+			}
+		}
+	}
+
+	// merge nocallback & noescape
+	maps.Copy(p.noCallbacks, f.NoCallbacks)
+	maps.Copy(p.noEscapes, f.NoEscapes)
+
+	if f.ExpFunc != nil {
+		p.ExpFunc = append(p.ExpFunc, f.ExpFunc...)
+		p.Preamble += "\n" + f.Preamble
+	}
+	p.Decl = append(p.Decl, f.AST.Decls...)
+}
+
+// incompleteTypedef reports whether t appears to be an incomplete
+// typedef definition.
+func (p *Package) incompleteTypedef(t *Type) bool {
+	return t == nil || (t.Size == 0 && t.Align == -1)
+}

go/src/cmd/cgo/out.go

@@ -0,0 +1,2099 @@
+// Copyright 2009 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 (
+	"bytes"
+	"cmd/internal/pkgpath"
+	"debug/elf"
+	"debug/macho"
+	"debug/pe"
+	"fmt"
+	"go/ast"
+	"go/printer"
+	"go/token"
+	"internal/xcoff"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+	"unicode"
+)
+
+var (
+	conf         = printer.Config{Mode: printer.SourcePos, Tabwidth: 8}
+	noSourceConf = printer.Config{Tabwidth: 8}
+)
+
+// writeDefs creates output files to be compiled by gc and gcc.
+func (p *Package) writeDefs() {
+	var fgo2, fc io.Writer
+	f := creat(*objDir + "_cgo_gotypes.go")
+	defer f.Close()
+	fgo2 = f
+	if *gccgo {
+		f := creat(*objDir + "_cgo_defun.c")
+		defer f.Close()
+		fc = f
+	}
+	fm := creat(*objDir + "_cgo_main.c")
+
+	var gccgoInit strings.Builder
+
+	if !*gccgo {
+		for _, arg := range p.LdFlags {
+			fmt.Fprintf(fgo2, "//go:cgo_ldflag %q\n", arg)
+		}
+	} else {
+		fflg := creat(*objDir + "_cgo_flags")
+		for _, arg := range p.LdFlags {
+			fmt.Fprintf(fflg, "_CGO_LDFLAGS=%s\n", arg)
+		}
+		fflg.Close()
+	}
+
+	// Write C main file for using gcc to resolve imports.
+	fmt.Fprintf(fm, "#include <stddef.h>\n") // For size_t below.
+	fmt.Fprintf(fm, "int main(int argc __attribute__((unused)), char **argv __attribute__((unused))) { return 0; }\n")
+	if *importRuntimeCgo {
+		fmt.Fprintf(fm, "void crosscall2(void(*fn)(void*) __attribute__((unused)), void *a __attribute__((unused)), int c __attribute__((unused)), size_t ctxt __attribute__((unused))) { }\n")
+		fmt.Fprintf(fm, "size_t _cgo_wait_runtime_init_done(void) { return 0; }\n")
+		fmt.Fprintf(fm, "void _cgo_release_context(size_t ctxt __attribute__((unused))) { }\n")
+		fmt.Fprintf(fm, "char* _cgo_topofstack(void) { return (char*)0; }\n")
+	} else {
+		// If we're not importing runtime/cgo, we *are* runtime/cgo,
+		// which provides these functions. We just need a prototype.
+		fmt.Fprintf(fm, "void crosscall2(void(*fn)(void*), void *a, int c, size_t ctxt);\n")
+		fmt.Fprintf(fm, "size_t _cgo_wait_runtime_init_done(void);\n")
+		fmt.Fprintf(fm, "void _cgo_release_context(size_t);\n")
+	}
+	fmt.Fprintf(fm, "void _cgo_allocate(void *a __attribute__((unused)), int c __attribute__((unused))) { }\n")
+	fmt.Fprintf(fm, "void _cgo_panic(void *a __attribute__((unused)), int c __attribute__((unused))) { }\n")
+	fmt.Fprintf(fm, "void _cgo_reginit(void) { }\n")
+
+	// Write second Go output: definitions of _C_xxx.
+	// In a separate file so that the import of "unsafe" does not
+	// pollute the original file.
+	fmt.Fprintf(fgo2, "// Code generated by cmd/cgo; DO NOT EDIT.\n\n")
+	fmt.Fprintf(fgo2, "package %s\n\n", p.PackageName)
+	fmt.Fprintf(fgo2, "import \"unsafe\"\n\n")
+	if *importSyscall {
+		fmt.Fprintf(fgo2, "import \"syscall\"\n\n")
+	}
+	if *importRuntimeCgo {
+		if !*gccgoDefineCgoIncomplete {
+			fmt.Fprintf(fgo2, "import _cgopackage \"runtime/cgo\"\n\n")
+			fmt.Fprintf(fgo2, "type _ _cgopackage.Incomplete\n") // prevent import-not-used error
+		} else {
+			fmt.Fprintf(fgo2, "//go:notinheap\n")
+			fmt.Fprintf(fgo2, "type _cgopackage_Incomplete struct{ _ struct{ _ struct{} } }\n")
+		}
+	}
+	if *importSyscall {
+		fmt.Fprintf(fgo2, "var _ syscall.Errno\n")
+	}
+	fmt.Fprintf(fgo2, "func _Cgo_ptr(ptr unsafe.Pointer) unsafe.Pointer { return ptr }\n\n")
+
+	if !*gccgo {
+		fmt.Fprintf(fgo2, "//go:linkname _Cgo_always_false runtime.cgoAlwaysFalse\n")
+		fmt.Fprintf(fgo2, "var _Cgo_always_false bool\n")
+		fmt.Fprintf(fgo2, "//go:linkname _Cgo_use runtime.cgoUse\n")
+		fmt.Fprintf(fgo2, "func _Cgo_use(interface{})\n")
+		fmt.Fprintf(fgo2, "//go:linkname _Cgo_keepalive runtime.cgoKeepAlive\n")
+		fmt.Fprintf(fgo2, "//go:noescape\n")
+		fmt.Fprintf(fgo2, "func _Cgo_keepalive(interface{})\n")
+	}
+	fmt.Fprintf(fgo2, "//go:linkname _Cgo_no_callback runtime.cgoNoCallback\n")
+	fmt.Fprintf(fgo2, "func _Cgo_no_callback(bool)\n")
+
+	typedefNames := make([]string, 0, len(typedef))
+	for name := range typedef {
+		if name == "_Ctype_void" {
+			// We provide an appropriate declaration for
+			// _Ctype_void below (#39877).
+			continue
+		}
+		typedefNames = append(typedefNames, name)
+	}
+	sort.Strings(typedefNames)
+	for _, name := range typedefNames {
+		def := typedef[name]
+		fmt.Fprintf(fgo2, "type %s ", name)
+		// We don't have source info for these types, so write them out without source info.
+		// Otherwise types would look like:
+		//
+		// type _Ctype_struct_cb struct {
+		// //line :1
+		//        on_test *[0]byte
+		// //line :1
+		// }
+		//
+		// Which is not useful. Moreover we never override source info,
+		// so subsequent source code uses the same source info.
+		// Moreover, empty file name makes compile emit no source debug info at all.
+		var buf bytes.Buffer
+		noSourceConf.Fprint(&buf, fset, def.Go)
+		if bytes.HasPrefix(buf.Bytes(), []byte("_Ctype_")) ||
+			strings.HasPrefix(name, "_Ctype_enum_") ||
+			strings.HasPrefix(name, "_Ctype_union_") {
+			// This typedef is of the form `typedef a b` and should be an alias.
+			fmt.Fprintf(fgo2, "= ")
+		}
+		fmt.Fprintf(fgo2, "%s", buf.Bytes())
+		fmt.Fprintf(fgo2, "\n\n")
+	}
+	if *gccgo {
+		fmt.Fprintf(fgo2, "type _Ctype_void byte\n")
+	} else {
+		fmt.Fprintf(fgo2, "type _Ctype_void [0]byte\n")
+	}
+
+	if *gccgo {
+		fmt.Fprint(fgo2, gccgoGoProlog)
+		fmt.Fprint(fc, p.cPrologGccgo())
+	} else {
+		fmt.Fprint(fgo2, goProlog)
+	}
+
+	if fc != nil {
+		fmt.Fprintf(fc, "#line 1 \"cgo-generated-wrappers\"\n")
+	}
+	if fm != nil {
+		fmt.Fprintf(fm, "#line 1 \"cgo-generated-wrappers\"\n")
+	}
+
+	gccgoSymbolPrefix := p.gccgoSymbolPrefix()
+
+	cVars := make(map[string]bool)
+	for _, key := range nameKeys(p.Name) {
+		n := p.Name[key]
+		if !n.IsVar() {
+			continue
+		}
+
+		if !cVars[n.C] {
+			if *gccgo {
+				fmt.Fprintf(fc, "extern byte *%s;\n", n.C)
+			} else {
+				// Force a reference to all symbols so that
+				// the external linker will add DT_NEEDED
+				// entries as needed on ELF systems.
+				// Treat function variables differently
+				// to avoid type conflict errors from LTO
+				// (Link Time Optimization).
+				if n.Kind == "fpvar" {
+					fmt.Fprintf(fm, "extern void %s();\n", n.C)
+				} else {
+					fmt.Fprintf(fm, "extern char %s[];\n", n.C)
+					fmt.Fprintf(fm, "void *_cgohack_%s = %s;\n\n", n.C, n.C)
+				}
+				fmt.Fprintf(fgo2, "//go:linkname __cgo_%s %s\n", n.C, n.C)
+				fmt.Fprintf(fgo2, "//go:cgo_import_static %s\n", n.C)
+				fmt.Fprintf(fgo2, "var __cgo_%s byte\n", n.C)
+			}
+			cVars[n.C] = true
+		}
+
+		var node ast.Node
+		if n.Kind == "var" {
+			node = &ast.StarExpr{X: n.Type.Go}
+		} else if n.Kind == "fpvar" {
+			node = n.Type.Go
+		} else {
+			panic(fmt.Errorf("invalid var kind %q", n.Kind))
+		}
+		if *gccgo {
+			fmt.Fprintf(fc, `extern void *%s __asm__("%s.%s");`, n.Mangle, gccgoSymbolPrefix, gccgoToSymbol(n.Mangle))
+			fmt.Fprintf(&gccgoInit, "\t%s = &%s;\n", n.Mangle, n.C)
+			fmt.Fprintf(fc, "\n")
+		}
+
+		fmt.Fprintf(fgo2, "var %s ", n.Mangle)
+		conf.Fprint(fgo2, fset, node)
+		if !*gccgo {
+			fmt.Fprintf(fgo2, " = (")
+			conf.Fprint(fgo2, fset, node)
+			fmt.Fprintf(fgo2, ")(unsafe.Pointer(&__cgo_%s))", n.C)
+		}
+		fmt.Fprintf(fgo2, "\n")
+	}
+	if *gccgo {
+		fmt.Fprintf(fc, "\n")
+	}
+
+	for _, key := range nameKeys(p.Name) {
+		n := p.Name[key]
+		if n.Const != "" {
+			fmt.Fprintf(fgo2, "const %s = %s\n", n.Mangle, n.Const)
+		}
+	}
+	fmt.Fprintf(fgo2, "\n")
+
+	callsMalloc := false
+	for _, key := range nameKeys(p.Name) {
+		n := p.Name[key]
+		if n.FuncType != nil {
+			p.writeDefsFunc(fgo2, n, &callsMalloc)
+		}
+	}
+
+	fgcc := creat(*objDir + "_cgo_export.c")
+	fgcch := creat(*objDir + "_cgo_export.h")
+	if *gccgo {
+		p.writeGccgoExports(fgo2, fm, fgcc, fgcch)
+	} else {
+		p.writeExports(fgo2, fm, fgcc, fgcch)
+	}
+
+	if callsMalloc && !*gccgo {
+		fmt.Fprint(fgo2, strings.ReplaceAll(cMallocDefGo, "PREFIX", cPrefix))
+		fmt.Fprint(fgcc, strings.ReplaceAll(strings.Replace(cMallocDefC, "PREFIX", cPrefix, -1), "PACKED", p.packedAttribute()))
+	}
+
+	if err := fgcc.Close(); err != nil {
+		fatalf("%s", err)
+	}
+	if err := fgcch.Close(); err != nil {
+		fatalf("%s", err)
+	}
+
+	if *exportHeader != "" && len(p.ExpFunc) > 0 {
+		fexp := creat(*exportHeader)
+		fgcch, err := os.Open(*objDir + "_cgo_export.h")
+		if err != nil {
+			fatalf("%s", err)
+		}
+		defer fgcch.Close()
+		_, err = io.Copy(fexp, fgcch)
+		if err != nil {
+			fatalf("%s", err)
+		}
+		if err = fexp.Close(); err != nil {
+			fatalf("%s", err)
+		}
+	}
+
+	init := gccgoInit.String()
+	if init != "" {
+		// The init function does nothing but simple
+		// assignments, so it won't use much stack space, so
+		// it's OK to not split the stack. Splitting the stack
+		// can run into a bug in clang (as of 2018-11-09):
+		// this is a leaf function, and when clang sees a leaf
+		// function it won't emit the split stack prologue for
+		// the function. However, if this function refers to a
+		// non-split-stack function, which will happen if the
+		// cgo code refers to a C function not compiled with
+		// -fsplit-stack, then the linker will think that it
+		// needs to adjust the split stack prologue, but there
+		// won't be one. Marking the function explicitly
+		// no_split_stack works around this problem by telling
+		// the linker that it's OK if there is no split stack
+		// prologue.
+		fmt.Fprintln(fc, "static void init(void) __attribute__ ((constructor, no_split_stack));")
+		fmt.Fprintln(fc, "static void init(void) {")
+		fmt.Fprint(fc, init)
+		fmt.Fprintln(fc, "}")
+	}
+}
+
+// elfImportedSymbols is like elf.File.ImportedSymbols, but it
+// includes weak symbols.
+//
+// A bug in some versions of LLD (at least LLD 8) cause it to emit
+// several pthreads symbols as weak, but we need to import those. See
+// issue #31912 or https://bugs.llvm.org/show_bug.cgi?id=42442.
+//
+// When doing external linking, we hand everything off to the external
+// linker, which will create its own dynamic symbol tables. For
+// internal linking, this may turn weak imports into strong imports,
+// which could cause dynamic linking to fail if a symbol really isn't
+// defined. However, the standard library depends on everything it
+// imports, and this is the primary use of dynamic symbol tables with
+// internal linking.
+func elfImportedSymbols(f *elf.File) []elf.ImportedSymbol {
+	syms, _ := f.DynamicSymbols()
+	var imports []elf.ImportedSymbol
+	for _, s := range syms {
+		if (elf.ST_BIND(s.Info) == elf.STB_GLOBAL || elf.ST_BIND(s.Info) == elf.STB_WEAK) && s.Section == elf.SHN_UNDEF {
+			imports = append(imports, elf.ImportedSymbol{
+				Name:    s.Name,
+				Library: s.Library,
+				Version: s.Version,
+			})
+		}
+	}
+	return imports
+}
+
+func dynimport(obj string) {
+	stdout := os.Stdout
+	if *dynout != "" {
+		f, err := os.Create(*dynout)
+		if err != nil {
+			fatalf("%s", err)
+		}
+		defer func() {
+			if err = f.Close(); err != nil {
+				fatalf("error closing %s: %v", *dynout, err)
+			}
+		}()
+
+		stdout = f
+	}
+
+	fmt.Fprintf(stdout, "package %s\n", *dynpackage)
+
+	if f, err := elf.Open(obj); err == nil {
+		defer f.Close()
+		if *dynlinker {
+			// Emit the cgo_dynamic_linker line.
+			if sec := f.Section(".interp"); sec != nil {
+				if data, err := sec.Data(); err == nil && len(data) > 1 {
+					// skip trailing \0 in data
+					fmt.Fprintf(stdout, "//go:cgo_dynamic_linker %q\n", string(data[:len(data)-1]))
+				}
+			}
+		}
+		sym := elfImportedSymbols(f)
+		for _, s := range sym {
+			targ := s.Name
+			if s.Version != "" {
+				targ += "#" + s.Version
+			}
+			checkImportSymName(s.Name)
+			checkImportSymName(targ)
+			fmt.Fprintf(stdout, "//go:cgo_import_dynamic %s %s %q\n", s.Name, targ, s.Library)
+		}
+		lib, _ := f.ImportedLibraries()
+		for _, l := range lib {
+			fmt.Fprintf(stdout, "//go:cgo_import_dynamic _ _ %q\n", l)
+		}
+		return
+	}
+
+	if f, err := macho.Open(obj); err == nil {
+		defer f.Close()
+		sym, _ := f.ImportedSymbols()
+		for _, s := range sym {
+			s = strings.TrimPrefix(s, "_")
+			checkImportSymName(s)
+			fmt.Fprintf(stdout, "//go:cgo_import_dynamic %s %s %q\n", s, s, "")
+		}
+		lib, _ := f.ImportedLibraries()
+		for _, l := range lib {
+			fmt.Fprintf(stdout, "//go:cgo_import_dynamic _ _ %q\n", l)
+		}
+		return
+	}
+
+	if f, err := pe.Open(obj); err == nil {
+		defer f.Close()
+		sym, _ := f.ImportedSymbols()
+		for _, s := range sym {
+			ss := strings.Split(s, ":")
+			name := strings.Split(ss[0], "@")[0]
+			checkImportSymName(name)
+			checkImportSymName(ss[0])
+			fmt.Fprintf(stdout, "//go:cgo_import_dynamic %s %s %q\n", name, ss[0], strings.ToLower(ss[1]))
+		}
+		return
+	}
+
+	if f, err := xcoff.Open(obj); err == nil {
+		defer f.Close()
+		sym, err := f.ImportedSymbols()
+		if err != nil {
+			fatalf("cannot load imported symbols from XCOFF file %s: %v", obj, err)
+		}
+		for _, s := range sym {
+			if s.Name == "runtime_rt0_go" || s.Name == "_rt0_ppc64_aix_lib" {
+				// These symbols are imported by runtime/cgo but
+				// must not be added to _cgo_import.go as there are
+				// Go symbols.
+				continue
+			}
+			checkImportSymName(s.Name)
+			fmt.Fprintf(stdout, "//go:cgo_import_dynamic %s %s %q\n", s.Name, s.Name, s.Library)
+		}
+		lib, err := f.ImportedLibraries()
+		if err != nil {
+			fatalf("cannot load imported libraries from XCOFF file %s: %v", obj, err)
+		}
+		for _, l := range lib {
+			fmt.Fprintf(stdout, "//go:cgo_import_dynamic _ _ %q\n", l)
+		}
+		return
+	}
+
+	fatalf("cannot parse %s as ELF, Mach-O, PE or XCOFF", obj)
+}
+
+// checkImportSymName checks a symbol name we are going to emit as part
+// of a //go:cgo_import_dynamic pragma. These names come from object
+// files, so they may be corrupt. We are going to emit them unquoted,
+// so while they don't need to be valid symbol names (and in some cases,
+// involving symbol versions, they won't be) they must contain only
+// graphic characters and must not contain Go comments.
+func checkImportSymName(s string) {
+	for _, c := range s {
+		if !unicode.IsGraphic(c) || unicode.IsSpace(c) {
+			fatalf("dynamic symbol %q contains unsupported character", s)
+		}
+	}
+	if strings.Contains(s, "//") || strings.Contains(s, "/*") {
+		fatalf("dynamic symbol %q contains Go comment", s)
+	}
+}
+
+// Construct a gcc struct matching the gc argument frame.
+// Assumes that in gcc, char is 1 byte, short 2 bytes, int 4 bytes, long long 8 bytes.
+// These assumptions are checked by the gccProlog.
+// Also assumes that gc convention is to word-align the
+// input and output parameters.
+func (p *Package) structType(n *Name) (string, int64) {
+	// It's possible for us to see a type with a top-level const here,
+	// which will give us an unusable struct type. See #75751.
+	// The top-level const will always appear as a final qualifier,
+	// constructed by typeConv.loadType in the dwarf.QualType case.
+	// The top-level const is meaningless here and can simply be removed.
+	stripConst := func(s string) string {
+		i := strings.LastIndex(s, "const")
+		if i == -1 {
+			return s
+		}
+
+		// A top-level const can only be followed by other qualifiers.
+		if r, ok := strings.CutSuffix(s, "const"); ok {
+			return strings.TrimSpace(r)
+		}
+
+		var nonConst []string
+		for _, f := range strings.Fields(s[i:]) {
+			switch f {
+			case "const":
+			case "restrict", "volatile":
+				nonConst = append(nonConst, f)
+			default:
+				return s
+			}
+		}
+
+		return strings.TrimSpace(s[:i]) + " " + strings.Join(nonConst, " ")
+	}
+
+	var buf strings.Builder
+	fmt.Fprint(&buf, "struct {\n")
+	off := int64(0)
+	for i, t := range n.FuncType.Params {
+		if off%t.Align != 0 {
+			pad := t.Align - off%t.Align
+			fmt.Fprintf(&buf, "\t\tchar __pad%d[%d];\n", off, pad)
+			off += pad
+		}
+		c := t.Typedef
+		if c == "" {
+			c = stripConst(t.C.String())
+		}
+		fmt.Fprintf(&buf, "\t\t%s p%d;\n", c, i)
+		off += t.Size
+	}
+	if off%p.PtrSize != 0 {
+		pad := p.PtrSize - off%p.PtrSize
+		fmt.Fprintf(&buf, "\t\tchar __pad%d[%d];\n", off, pad)
+		off += pad
+	}
+	if t := n.FuncType.Result; t != nil {
+		if off%t.Align != 0 {
+			pad := t.Align - off%t.Align
+			fmt.Fprintf(&buf, "\t\tchar __pad%d[%d];\n", off, pad)
+			off += pad
+		}
+		fmt.Fprintf(&buf, "\t\t%s r;\n", stripConst(t.C.String()))
+		off += t.Size
+	}
+	if off%p.PtrSize != 0 {
+		pad := p.PtrSize - off%p.PtrSize
+		fmt.Fprintf(&buf, "\t\tchar __pad%d[%d];\n", off, pad)
+		off += pad
+	}
+	if off == 0 {
+		fmt.Fprintf(&buf, "\t\tchar unused;\n") // avoid empty struct
+	}
+	fmt.Fprintf(&buf, "\t}")
+	return buf.String(), off
+}
+
+func (p *Package) writeDefsFunc(fgo2 io.Writer, n *Name, callsMalloc *bool) {
+	name := n.Go
+	gtype := n.FuncType.Go
+	void := gtype.Results == nil || len(gtype.Results.List) == 0
+	if n.AddError {
+		// Add "error" to return type list.
+		// Type list is known to be 0 or 1 element - it's a C function.
+		err := &ast.Field{Type: ast.NewIdent("error")}
+		l := gtype.Results.List
+		if len(l) == 0 {
+			l = []*ast.Field{err}
+		} else {
+			l = []*ast.Field{l[0], err}
+		}
+		t := new(ast.FuncType)
+		*t = *gtype
+		t.Results = &ast.FieldList{List: l}
+		gtype = t
+	}
+
+	// Go func declaration.
+	d := &ast.FuncDecl{
+		Name: ast.NewIdent(n.Mangle),
+		Type: gtype,
+	}
+
+	// Builtins defined in the C prolog.
+	inProlog := builtinDefs[name] != ""
+	cname := fmt.Sprintf("_cgo%s%s", cPrefix, n.Mangle)
+	paramnames := []string(nil)
+	if d.Type.Params != nil {
+		for i, param := range d.Type.Params.List {
+			paramName := fmt.Sprintf("p%d", i)
+			param.Names = []*ast.Ident{ast.NewIdent(paramName)}
+			paramnames = append(paramnames, paramName)
+		}
+	}
+
+	if *gccgo {
+		// Gccgo style hooks.
+		fmt.Fprint(fgo2, "\n")
+		conf.Fprint(fgo2, fset, d)
+		fmt.Fprint(fgo2, " {\n")
+		if !inProlog {
+			fmt.Fprint(fgo2, "\tdefer syscall.CgocallDone()\n")
+			fmt.Fprint(fgo2, "\tsyscall.Cgocall()\n")
+		}
+		if n.AddError {
+			fmt.Fprint(fgo2, "\tsyscall.SetErrno(0)\n")
+		}
+		fmt.Fprint(fgo2, "\t")
+		if !void {
+			fmt.Fprint(fgo2, "r := ")
+		}
+		fmt.Fprintf(fgo2, "%s(%s)\n", cname, strings.Join(paramnames, ", "))
+
+		if n.AddError {
+			fmt.Fprint(fgo2, "\te := syscall.GetErrno()\n")
+			fmt.Fprint(fgo2, "\tif e != 0 {\n")
+			fmt.Fprint(fgo2, "\t\treturn ")
+			if !void {
+				fmt.Fprint(fgo2, "r, ")
+			}
+			fmt.Fprint(fgo2, "e\n")
+			fmt.Fprint(fgo2, "\t}\n")
+			fmt.Fprint(fgo2, "\treturn ")
+			if !void {
+				fmt.Fprint(fgo2, "r, ")
+			}
+			fmt.Fprint(fgo2, "nil\n")
+		} else if !void {
+			fmt.Fprint(fgo2, "\treturn r\n")
+		}
+
+		fmt.Fprint(fgo2, "}\n")
+
+		// declare the C function.
+		fmt.Fprintf(fgo2, "//extern %s\n", cname)
+		d.Name = ast.NewIdent(cname)
+		if n.AddError {
+			l := d.Type.Results.List
+			d.Type.Results.List = l[:len(l)-1]
+		}
+		conf.Fprint(fgo2, fset, d)
+		fmt.Fprint(fgo2, "\n")
+
+		return
+	}
+
+	if inProlog {
+		fmt.Fprint(fgo2, builtinDefs[name])
+		if strings.Contains(builtinDefs[name], "_cgo_cmalloc") {
+			*callsMalloc = true
+		}
+		return
+	}
+
+	// Wrapper calls into gcc, passing a pointer to the argument frame.
+	fmt.Fprintf(fgo2, "//go:cgo_import_static %s\n", cname)
+	fmt.Fprintf(fgo2, "//go:linkname __cgofn_%s %s\n", cname, cname)
+	fmt.Fprintf(fgo2, "var __cgofn_%s byte\n", cname)
+	fmt.Fprintf(fgo2, "var %s = unsafe.Pointer(&__cgofn_%s)\n", cname, cname)
+
+	nret := 0
+	if !void {
+		d.Type.Results.List[0].Names = []*ast.Ident{ast.NewIdent("r1")}
+		nret = 1
+	}
+	if n.AddError {
+		d.Type.Results.List[nret].Names = []*ast.Ident{ast.NewIdent("r2")}
+	}
+
+	fmt.Fprint(fgo2, "\n")
+	fmt.Fprint(fgo2, "//go:cgo_unsafe_args\n")
+	conf.Fprint(fgo2, fset, d)
+	fmt.Fprint(fgo2, " {\n")
+
+	// NOTE: Using uintptr to hide from escape analysis.
+	arg := "0"
+	if len(paramnames) > 0 {
+		arg = "uintptr(unsafe.Pointer(&p0))"
+	} else if !void {
+		arg = "uintptr(unsafe.Pointer(&r1))"
+	}
+
+	noCallback := p.noCallbacks[n.C]
+	if noCallback {
+		// disable cgocallback, will check it in runtime.
+		fmt.Fprintf(fgo2, "\t_Cgo_no_callback(true)\n")
+	}
+
+	prefix := ""
+	if n.AddError {
+		prefix = "errno := "
+	}
+	fmt.Fprintf(fgo2, "\t%s_cgo_runtime_cgocall(%s, %s)\n", prefix, cname, arg)
+	if n.AddError {
+		fmt.Fprintf(fgo2, "\tif errno != 0 { r2 = syscall.Errno(errno) }\n")
+	}
+	if noCallback {
+		fmt.Fprintf(fgo2, "\t_Cgo_no_callback(false)\n")
+	}
+
+	// Use _Cgo_keepalive instead of _Cgo_use when noescape & nocallback exist,
+	// so that the compiler won't force to escape them to heap.
+	// Instead, make the compiler keep them alive by using _Cgo_keepalive.
+	touchFunc := "_Cgo_use"
+	if p.noEscapes[n.C] && p.noCallbacks[n.C] {
+		touchFunc = "_Cgo_keepalive"
+	}
+
+	if len(paramnames) > 0 {
+		fmt.Fprintf(fgo2, "\tif _Cgo_always_false {\n")
+		for _, name := range paramnames {
+			fmt.Fprintf(fgo2, "\t\t%s(%s)\n", touchFunc, name)
+		}
+		fmt.Fprintf(fgo2, "\t}\n")
+	}
+
+	fmt.Fprintf(fgo2, "\treturn\n")
+	fmt.Fprintf(fgo2, "}\n")
+}
+
+// writeOutput creates stubs for a specific source file to be compiled by gc
+func (p *Package) writeOutput(f *File, srcfile string) {
+	base := srcfile
+	base = strings.TrimSuffix(base, ".go")
+	base = filepath.Base(base)
+	fgo1 := creat(*objDir + base + ".cgo1.go")
+	fgcc := creat(*objDir + base + ".cgo2.c")
+
+	p.GoFiles = append(p.GoFiles, base+".cgo1.go")
+	p.GccFiles = append(p.GccFiles, base+".cgo2.c")
+
+	// Write Go output: Go input with rewrites of C.xxx to _C_xxx.
+	fmt.Fprintf(fgo1, "// Code generated by cmd/cgo; DO NOT EDIT.\n\n")
+	if strings.ContainsAny(srcfile, "\r\n") {
+		// This should have been checked when the file path was first resolved,
+		// but we double check here just to be sure.
+		fatalf("internal error: writeOutput: srcfile contains unexpected newline character: %q", srcfile)
+	}
+	fmt.Fprintf(fgo1, "//line %s:1:1\n", srcfile)
+	fgo1.Write(f.Edit.Bytes())
+
+	// While we process the vars and funcs, also write gcc output.
+	// Gcc output starts with the preamble.
+	fmt.Fprintf(fgcc, "%s\n", builtinProlog)
+	fmt.Fprintf(fgcc, "%s\n", f.Preamble)
+	fmt.Fprintf(fgcc, "%s\n", gccProlog)
+	fmt.Fprintf(fgcc, "%s\n", tsanProlog)
+	fmt.Fprintf(fgcc, "%s\n", msanProlog)
+
+	for _, key := range nameKeys(f.Name) {
+		n := f.Name[key]
+		if n.FuncType != nil {
+			p.writeOutputFunc(fgcc, n)
+		}
+	}
+
+	fgo1.Close()
+	fgcc.Close()
+}
+
+// fixGo converts the internal Name.Go field into the name we should show
+// to users in error messages. There's only one for now: on input we rewrite
+// C.malloc into C._CMalloc, so change it back here.
+func fixGo(name string) string {
+	if name == "_CMalloc" {
+		return "malloc"
+	}
+	return name
+}
+
+var isBuiltin = map[string]bool{
+	"_Cfunc_CString":   true,
+	"_Cfunc_CBytes":    true,
+	"_Cfunc_GoString":  true,
+	"_Cfunc_GoStringN": true,
+	"_Cfunc_GoBytes":   true,
+	"_Cfunc__CMalloc":  true,
+}
+
+func (p *Package) writeOutputFunc(fgcc *os.File, n *Name) {
+	name := n.Mangle
+	if isBuiltin[name] || p.Written[name] {
+		// The builtins are already defined in the C prolog, and we don't
+		// want to duplicate function definitions we've already done.
+		return
+	}
+	p.Written[name] = true
+
+	if *gccgo {
+		p.writeGccgoOutputFunc(fgcc, n)
+		return
+	}
+
+	ctype, _ := p.structType(n)
+
+	// Gcc wrapper unpacks the C argument struct
+	// and calls the actual C function.
+	fmt.Fprintf(fgcc, "CGO_NO_SANITIZE_THREAD\n")
+	if n.AddError {
+		fmt.Fprintf(fgcc, "int\n")
+	} else {
+		fmt.Fprintf(fgcc, "void\n")
+	}
+	fmt.Fprintf(fgcc, "_cgo%s%s(void *v)\n", cPrefix, n.Mangle)
+	fmt.Fprintf(fgcc, "{\n")
+	if n.AddError {
+		fmt.Fprintf(fgcc, "\tint _cgo_errno;\n")
+	}
+	// We're trying to write a gcc struct that matches gc's layout.
+	// Use packed attribute to force no padding in this struct in case
+	// gcc has different packing requirements.
+	tr := n.FuncType.Result
+	if (n.Kind != "macro" && len(n.FuncType.Params) > 0) || tr != nil {
+		fmt.Fprintf(fgcc, "\t%s %v *_cgo_a = v;\n", ctype, p.packedAttribute())
+	}
+	if tr != nil {
+		// Save the stack top for use below.
+		fmt.Fprintf(fgcc, "\tchar *_cgo_stktop = _cgo_topofstack();\n")
+		fmt.Fprintf(fgcc, "\t__typeof__(_cgo_a->r) _cgo_r;\n")
+	}
+	fmt.Fprintf(fgcc, "\t_cgo_tsan_acquire();\n")
+	if n.AddError {
+		fmt.Fprintf(fgcc, "\terrno = 0;\n")
+	}
+	fmt.Fprintf(fgcc, "\t")
+	if tr != nil {
+		fmt.Fprintf(fgcc, "_cgo_r = ")
+		if c := tr.C.String(); c[len(c)-1] == '*' {
+			fmt.Fprint(fgcc, "(__typeof__(_cgo_a->r)) ")
+		}
+	}
+	if n.Kind == "macro" {
+		fmt.Fprintf(fgcc, "%s;\n", n.C)
+	} else {
+		fmt.Fprintf(fgcc, "%s(", n.C)
+		for i := range n.FuncType.Params {
+			if i > 0 {
+				fmt.Fprintf(fgcc, ", ")
+			}
+			fmt.Fprintf(fgcc, "_cgo_a->p%d", i)
+		}
+		fmt.Fprintf(fgcc, ");\n")
+	}
+	if n.AddError {
+		fmt.Fprintf(fgcc, "\t_cgo_errno = errno;\n")
+	}
+	fmt.Fprintf(fgcc, "\t_cgo_tsan_release();\n")
+	if tr != nil {
+		// The cgo call may have caused a stack copy (via a callback).
+		// Adjust the return value pointer appropriately.
+		fmt.Fprintf(fgcc, "\t_cgo_a = (void*)((char*)_cgo_a + (_cgo_topofstack() - _cgo_stktop));\n")
+		// Save the return value.
+		fmt.Fprintf(fgcc, "\t_cgo_a->r = _cgo_r;\n")
+		// The return value is on the Go stack. If we are using msan,
+		// and if the C value is partially or completely uninitialized,
+		// the assignment will mark the Go stack as uninitialized.
+		// The Go compiler does not update msan for changes to the
+		// stack. It is possible that the stack will remain
+		// uninitialized, and then later be used in a way that is
+		// visible to msan, possibly leading to a false positive.
+		// Mark the stack space as written, to avoid this problem.
+		// See issue 26209.
+		fmt.Fprintf(fgcc, "\t_cgo_msan_write(&_cgo_a->r, sizeof(_cgo_a->r));\n")
+	}
+	if n.AddError {
+		fmt.Fprintf(fgcc, "\treturn _cgo_errno;\n")
+	}
+	fmt.Fprintf(fgcc, "}\n")
+	fmt.Fprintf(fgcc, "\n")
+}
+
+// Write out a wrapper for a function when using gccgo. This is a
+// simple wrapper that just calls the real function. We only need a
+// wrapper to support static functions in the prologue--without a
+// wrapper, we can't refer to the function, since the reference is in
+// a different file.
+func (p *Package) writeGccgoOutputFunc(fgcc *os.File, n *Name) {
+	fmt.Fprintf(fgcc, "CGO_NO_SANITIZE_THREAD\n")
+	if t := n.FuncType.Result; t != nil {
+		fmt.Fprintf(fgcc, "%s\n", t.C.String())
+	} else {
+		fmt.Fprintf(fgcc, "void\n")
+	}
+	fmt.Fprintf(fgcc, "_cgo%s%s(", cPrefix, n.Mangle)
+	for i, t := range n.FuncType.Params {
+		if i > 0 {
+			fmt.Fprintf(fgcc, ", ")
+		}
+		c := t.Typedef
+		if c == "" {
+			c = t.C.String()
+		}
+		fmt.Fprintf(fgcc, "%s p%d", c, i)
+	}
+	fmt.Fprintf(fgcc, ")\n")
+	fmt.Fprintf(fgcc, "{\n")
+	if t := n.FuncType.Result; t != nil {
+		fmt.Fprintf(fgcc, "\t%s _cgo_r;\n", t.C.String())
+	}
+	fmt.Fprintf(fgcc, "\t_cgo_tsan_acquire();\n")
+	fmt.Fprintf(fgcc, "\t")
+	if t := n.FuncType.Result; t != nil {
+		fmt.Fprintf(fgcc, "_cgo_r = ")
+		// Cast to void* to avoid warnings due to omitted qualifiers.
+		if c := t.C.String(); c[len(c)-1] == '*' {
+			fmt.Fprintf(fgcc, "(void*)")
+		}
+	}
+	if n.Kind == "macro" {
+		fmt.Fprintf(fgcc, "%s;\n", n.C)
+	} else {
+		fmt.Fprintf(fgcc, "%s(", n.C)
+		for i := range n.FuncType.Params {
+			if i > 0 {
+				fmt.Fprintf(fgcc, ", ")
+			}
+			fmt.Fprintf(fgcc, "p%d", i)
+		}
+		fmt.Fprintf(fgcc, ");\n")
+	}
+	fmt.Fprintf(fgcc, "\t_cgo_tsan_release();\n")
+	if t := n.FuncType.Result; t != nil {
+		fmt.Fprintf(fgcc, "\treturn ")
+		// Cast to void* to avoid warnings due to omitted qualifiers
+		// and explicit incompatible struct types.
+		if c := t.C.String(); c[len(c)-1] == '*' {
+			fmt.Fprintf(fgcc, "(void*)")
+		}
+		fmt.Fprintf(fgcc, "_cgo_r;\n")
+	}
+	fmt.Fprintf(fgcc, "}\n")
+	fmt.Fprintf(fgcc, "\n")
+}
+
+// packedAttribute returns host compiler struct attribute that will be
+// used to match gc's struct layout. For example, on 386 Windows,
+// gcc wants to 8-align int64s, but gc does not.
+// Use __gcc_struct__ to work around https://gcc.gnu.org/PR52991 on x86,
+// and https://golang.org/issue/5603.
+func (p *Package) packedAttribute() string {
+	s := "__attribute__((__packed__"
+	if !p.GccIsClang && (goarch == "amd64" || goarch == "386") {
+		s += ", __gcc_struct__"
+	}
+	return s + "))"
+}
+
+// exportParamName returns the value of param as it should be
+// displayed in a c header file. If param contains any non-ASCII
+// characters, this function will return the character p followed by
+// the value of position; otherwise, this function will return the
+// value of param.
+func exportParamName(param string, position int) string {
+	if param == "" {
+		return fmt.Sprintf("p%d", position)
+	}
+
+	pname := param
+
+	for i := 0; i < len(param); i++ {
+		if param[i] > unicode.MaxASCII {
+			pname = fmt.Sprintf("p%d", position)
+			break
+		}
+	}
+
+	return pname
+}
+
+// Write out the various stubs we need to support functions exported
+// from Go so that they are callable from C.
+func (p *Package) writeExports(fgo2, fm, fgcc, fgcch io.Writer) {
+	p.writeExportHeader(fgcch)
+
+	fmt.Fprintf(fgcc, "/* Code generated by cmd/cgo; DO NOT EDIT. */\n\n")
+	fmt.Fprintf(fgcc, "#include <stdlib.h>\n")
+	fmt.Fprintf(fgcc, "#include \"_cgo_export.h\"\n\n")
+
+	// We use packed structs, but they are always aligned.
+	// The pragmas and address-of-packed-member are only recognized as
+	// warning groups in clang 4.0+, so ignore unknown pragmas first.
+	fmt.Fprintf(fgcc, "#pragma GCC diagnostic ignored \"-Wunknown-pragmas\"\n")
+	fmt.Fprintf(fgcc, "#pragma GCC diagnostic ignored \"-Wpragmas\"\n")
+	fmt.Fprintf(fgcc, "#pragma GCC diagnostic ignored \"-Waddress-of-packed-member\"\n")
+	fmt.Fprintf(fgcc, "#pragma GCC diagnostic ignored \"-Wunknown-warning-option\"\n")
+	fmt.Fprintf(fgcc, "#pragma GCC diagnostic ignored \"-Wunaligned-access\"\n")
+
+	fmt.Fprintf(fgcc, "extern void crosscall2(void (*fn)(void *), void *, int, size_t);\n")
+	fmt.Fprintf(fgcc, "extern size_t _cgo_wait_runtime_init_done(void);\n")
+	fmt.Fprintf(fgcc, "extern void _cgo_release_context(size_t);\n\n")
+	fmt.Fprintf(fgcc, "extern char* _cgo_topofstack(void);")
+	fmt.Fprintf(fgcc, "%s\n", tsanProlog)
+	fmt.Fprintf(fgcc, "%s\n", msanProlog)
+
+	for _, exp := range p.ExpFunc {
+		fn := exp.Func
+
+		// Construct a struct that will be used to communicate
+		// arguments from C to Go. The C and Go definitions
+		// just have to agree. The gcc struct will be compiled
+		// with __attribute__((packed)) so all padding must be
+		// accounted for explicitly.
+		var ctype strings.Builder
+		const start = "struct {\n"
+		ctype.WriteString(start)
+		gotype := new(bytes.Buffer)
+		fmt.Fprintf(gotype, "struct {\n")
+		off := int64(0)
+		npad := 0
+		// the align is at least 1 (for char)
+		maxAlign := int64(1)
+		argField := func(typ ast.Expr, namePat string, args ...any) {
+			name := fmt.Sprintf(namePat, args...)
+			t := p.cgoType(typ)
+			if off%t.Align != 0 {
+				pad := t.Align - off%t.Align
+				fmt.Fprintf(&ctype, "\t\tchar __pad%d[%d];\n", npad, pad)
+				off += pad
+				npad++
+			}
+			fmt.Fprintf(&ctype, "\t\t%s %s;\n", t.C, name)
+			fmt.Fprintf(gotype, "\t\t%s ", name)
+			noSourceConf.Fprint(gotype, fset, typ)
+			fmt.Fprintf(gotype, "\n")
+			off += t.Size
+			// keep track of the maximum alignment among all fields
+			// so that we can align the struct correctly
+			if t.Align > maxAlign {
+				maxAlign = t.Align
+			}
+		}
+		if fn.Recv != nil {
+			argField(fn.Recv.List[0].Type, "recv")
+		}
+		fntype := fn.Type
+		forFieldList(fntype.Params,
+			func(i int, aname string, atype ast.Expr) {
+				argField(atype, "p%d", i)
+			})
+		forFieldList(fntype.Results,
+			func(i int, aname string, atype ast.Expr) {
+				argField(atype, "r%d", i)
+			})
+		if ctype.Len() == len(start) {
+			ctype.WriteString("\t\tchar unused;\n") // avoid empty struct
+		}
+		ctype.WriteString("\t}")
+		fmt.Fprintf(gotype, "\t}")
+
+		// Get the return type of the wrapper function
+		// compiled by gcc.
+		gccResult := ""
+		if fntype.Results == nil || len(fntype.Results.List) == 0 {
+			gccResult = "void"
+		} else if len(fntype.Results.List) == 1 && len(fntype.Results.List[0].Names) <= 1 {
+			gccResult = p.cgoType(fntype.Results.List[0].Type).C.String()
+		} else {
+			fmt.Fprintf(fgcch, "\n/* Return type for %s */\n", exp.ExpName)
+			fmt.Fprintf(fgcch, "struct %s_return {\n", exp.ExpName)
+			forFieldList(fntype.Results,
+				func(i int, aname string, atype ast.Expr) {
+					fmt.Fprintf(fgcch, "\t%s r%d;", p.cgoType(atype).C, i)
+					if len(aname) > 0 {
+						fmt.Fprintf(fgcch, " /* %s */", aname)
+					}
+					fmt.Fprint(fgcch, "\n")
+				})
+			fmt.Fprintf(fgcch, "};\n")
+			gccResult = "struct " + exp.ExpName + "_return"
+		}
+
+		// Build the wrapper function compiled by gcc.
+		var s strings.Builder
+		fmt.Fprintf(&s, "%s %s(", gccResult, exp.ExpName)
+		if fn.Recv != nil {
+			s.WriteString(p.cgoType(fn.Recv.List[0].Type).C.String())
+			s.WriteString(" recv")
+		}
+
+		if len(fntype.Params.List) > 0 {
+			forFieldList(fntype.Params,
+				func(i int, aname string, atype ast.Expr) {
+					if i > 0 || fn.Recv != nil {
+						s.WriteString(", ")
+					}
+					fmt.Fprintf(&s, "%s %s", p.cgoType(atype).C, exportParamName(aname, i))
+				})
+		} else {
+			s.WriteString("void")
+		}
+		s.WriteByte(')')
+
+		if len(exp.Doc) > 0 {
+			fmt.Fprintf(fgcch, "\n%s", exp.Doc)
+			if !strings.HasSuffix(exp.Doc, "\n") {
+				fmt.Fprint(fgcch, "\n")
+			}
+		}
+		fmt.Fprintf(fgcch, "extern %s;\n", s.String())
+
+		fmt.Fprintf(fgcc, "extern void _cgoexp%s_%s(void *);\n", cPrefix, exp.ExpName)
+		fmt.Fprintf(fgcc, "\nCGO_NO_SANITIZE_THREAD")
+		fmt.Fprintf(fgcc, "\n%s\n", s.String())
+		fmt.Fprintf(fgcc, "{\n")
+		fmt.Fprintf(fgcc, "\tsize_t _cgo_ctxt = _cgo_wait_runtime_init_done();\n")
+		// The results part of the argument structure must be
+		// initialized to 0 so the write barriers generated by
+		// the assignments to these fields in Go are safe.
+		//
+		// We use a local static variable to get the zeroed
+		// value of the argument type. This avoids including
+		// string.h for memset, and is also robust to C++
+		// types with constructors. Both GCC and LLVM optimize
+		// this into just zeroing _cgo_a.
+		//
+		// The struct should be aligned to the maximum alignment
+		// of any of its fields. This to avoid alignment
+		// issues.
+		fmt.Fprintf(fgcc, "\ttypedef %s %v __attribute__((aligned(%d))) _cgo_argtype;\n", ctype.String(), p.packedAttribute(), maxAlign)
+		fmt.Fprintf(fgcc, "\tstatic _cgo_argtype _cgo_zero;\n")
+		fmt.Fprintf(fgcc, "\t_cgo_argtype _cgo_a = _cgo_zero;\n")
+		if gccResult != "void" && (len(fntype.Results.List) > 1 || len(fntype.Results.List[0].Names) > 1) {
+			fmt.Fprintf(fgcc, "\t%s r;\n", gccResult)
+		}
+		if fn.Recv != nil {
+			fmt.Fprintf(fgcc, "\t_cgo_a.recv = recv;\n")
+		}
+		forFieldList(fntype.Params,
+			func(i int, aname string, atype ast.Expr) {
+				fmt.Fprintf(fgcc, "\t_cgo_a.p%d = %s;\n", i, exportParamName(aname, i))
+			})
+		fmt.Fprintf(fgcc, "\t_cgo_tsan_release();\n")
+		fmt.Fprintf(fgcc, "\tcrosscall2(_cgoexp%s_%s, &_cgo_a, %d, _cgo_ctxt);\n", cPrefix, exp.ExpName, off)
+		fmt.Fprintf(fgcc, "\t_cgo_tsan_acquire();\n")
+		fmt.Fprintf(fgcc, "\t_cgo_release_context(_cgo_ctxt);\n")
+		if gccResult != "void" {
+			if len(fntype.Results.List) == 1 && len(fntype.Results.List[0].Names) <= 1 {
+				fmt.Fprintf(fgcc, "\treturn _cgo_a.r0;\n")
+			} else {
+				forFieldList(fntype.Results,
+					func(i int, aname string, atype ast.Expr) {
+						fmt.Fprintf(fgcc, "\tr.r%d = _cgo_a.r%d;\n", i, i)
+					})
+				fmt.Fprintf(fgcc, "\treturn r;\n")
+			}
+		}
+		fmt.Fprintf(fgcc, "}\n")
+
+		// In internal linking mode, the Go linker sees both
+		// the C wrapper written above and the Go wrapper it
+		// references. Hence, export the C wrapper (e.g., for
+		// if we're building a shared object). The Go linker
+		// will resolve the C wrapper's reference to the Go
+		// wrapper without a separate export.
+		fmt.Fprintf(fgo2, "//go:cgo_export_dynamic %s\n", exp.ExpName)
+		// cgo_export_static refers to a symbol by its linker
+		// name, so set the linker name of the Go wrapper.
+		fmt.Fprintf(fgo2, "//go:linkname _cgoexp%s_%s _cgoexp%s_%s\n", cPrefix, exp.ExpName, cPrefix, exp.ExpName)
+		// In external linking mode, the Go linker sees the Go
+		// wrapper, but not the C wrapper. For this case,
+		// export the Go wrapper so the host linker can
+		// resolve the reference from the C wrapper to the Go
+		// wrapper.
+		fmt.Fprintf(fgo2, "//go:cgo_export_static _cgoexp%s_%s\n", cPrefix, exp.ExpName)
+
+		// Build the wrapper function compiled by cmd/compile.
+		// This unpacks the argument struct above and calls the Go function.
+		fmt.Fprintf(fgo2, "func _cgoexp%s_%s(a *%s) {\n", cPrefix, exp.ExpName, gotype)
+
+		fmt.Fprintf(fm, "void _cgoexp%s_%s(void* p __attribute__((unused))){}\n", cPrefix, exp.ExpName)
+
+		fmt.Fprintf(fgo2, "\t")
+
+		if gccResult != "void" {
+			// Write results back to frame.
+			forFieldList(fntype.Results,
+				func(i int, aname string, atype ast.Expr) {
+					if i > 0 {
+						fmt.Fprintf(fgo2, ", ")
+					}
+					fmt.Fprintf(fgo2, "a.r%d", i)
+				})
+			fmt.Fprintf(fgo2, " = ")
+		}
+		if fn.Recv != nil {
+			fmt.Fprintf(fgo2, "a.recv.")
+		}
+		fmt.Fprintf(fgo2, "%s(", exp.Func.Name)
+		forFieldList(fntype.Params,
+			func(i int, aname string, atype ast.Expr) {
+				if i > 0 {
+					fmt.Fprint(fgo2, ", ")
+				}
+				fmt.Fprintf(fgo2, "a.p%d", i)
+			})
+		fmt.Fprint(fgo2, ")\n")
+		if gccResult != "void" {
+			// Verify that any results don't contain any
+			// Go pointers.
+			forFieldList(fntype.Results,
+				func(i int, aname string, atype ast.Expr) {
+					if !p.hasPointer(nil, atype, false) {
+						return
+					}
+
+					// Use the export'ed file/line in error messages.
+					pos := fset.Position(exp.Func.Pos())
+					fmt.Fprintf(fgo2, "//line %s:%d\n", pos.Filename, pos.Line)
+					fmt.Fprintf(fgo2, "\t_cgoCheckResult(a.r%d)\n", i)
+				})
+		}
+		fmt.Fprint(fgo2, "}\n")
+	}
+
+	fmt.Fprintf(fgcch, "%s", gccExportHeaderEpilog)
+}
+
+// Write out the C header allowing C code to call exported gccgo functions.
+func (p *Package) writeGccgoExports(fgo2, fm, fgcc, fgcch io.Writer) {
+	gccgoSymbolPrefix := p.gccgoSymbolPrefix()
+
+	p.writeExportHeader(fgcch)
+
+	fmt.Fprintf(fgcc, "/* Code generated by cmd/cgo; DO NOT EDIT. */\n\n")
+	fmt.Fprintf(fgcc, "#include \"_cgo_export.h\"\n")
+
+	fmt.Fprintf(fgcc, "%s\n", gccgoExportFileProlog)
+	fmt.Fprintf(fgcc, "%s\n", tsanProlog)
+	fmt.Fprintf(fgcc, "%s\n", msanProlog)
+
+	for _, exp := range p.ExpFunc {
+		fn := exp.Func
+		fntype := fn.Type
+
+		cdeclBuf := new(strings.Builder)
+		resultCount := 0
+		forFieldList(fntype.Results,
+			func(i int, aname string, atype ast.Expr) { resultCount++ })
+		switch resultCount {
+		case 0:
+			fmt.Fprintf(cdeclBuf, "void")
+		case 1:
+			forFieldList(fntype.Results,
+				func(i int, aname string, atype ast.Expr) {
+					t := p.cgoType(atype)
+					fmt.Fprintf(cdeclBuf, "%s", t.C)
+				})
+		default:
+			// Declare a result struct.
+			fmt.Fprintf(fgcch, "\n/* Return type for %s */\n", exp.ExpName)
+			fmt.Fprintf(fgcch, "struct %s_return {\n", exp.ExpName)
+			forFieldList(fntype.Results,
+				func(i int, aname string, atype ast.Expr) {
+					t := p.cgoType(atype)
+					fmt.Fprintf(fgcch, "\t%s r%d;", t.C, i)
+					if len(aname) > 0 {
+						fmt.Fprintf(fgcch, " /* %s */", aname)
+					}
+					fmt.Fprint(fgcch, "\n")
+				})
+			fmt.Fprintf(fgcch, "};\n")
+			fmt.Fprintf(cdeclBuf, "struct %s_return", exp.ExpName)
+		}
+
+		cRet := cdeclBuf.String()
+
+		cdeclBuf = new(strings.Builder)
+		fmt.Fprintf(cdeclBuf, "(")
+		if fn.Recv != nil {
+			fmt.Fprintf(cdeclBuf, "%s recv", p.cgoType(fn.Recv.List[0].Type).C.String())
+		}
+		// Function parameters.
+		forFieldList(fntype.Params,
+			func(i int, aname string, atype ast.Expr) {
+				if i > 0 || fn.Recv != nil {
+					fmt.Fprintf(cdeclBuf, ", ")
+				}
+				t := p.cgoType(atype)
+				fmt.Fprintf(cdeclBuf, "%s p%d", t.C, i)
+			})
+		fmt.Fprintf(cdeclBuf, ")")
+		cParams := cdeclBuf.String()
+
+		if len(exp.Doc) > 0 {
+			fmt.Fprintf(fgcch, "\n%s", exp.Doc)
+		}
+
+		fmt.Fprintf(fgcch, "extern %s %s%s;\n", cRet, exp.ExpName, cParams)
+
+		// We need to use a name that will be exported by the
+		// Go code; otherwise gccgo will make it static and we
+		// will not be able to link against it from the C
+		// code.
+		goName := "Cgoexp_" + exp.ExpName
+		fmt.Fprintf(fgcc, `extern %s %s %s __asm__("%s.%s");`, cRet, goName, cParams, gccgoSymbolPrefix, gccgoToSymbol(goName))
+		fmt.Fprint(fgcc, "\n")
+
+		fmt.Fprint(fgcc, "\nCGO_NO_SANITIZE_THREAD\n")
+		fmt.Fprintf(fgcc, "%s %s %s {\n", cRet, exp.ExpName, cParams)
+		if resultCount > 0 {
+			fmt.Fprintf(fgcc, "\t%s r;\n", cRet)
+		}
+		fmt.Fprintf(fgcc, "\tif(_cgo_wait_runtime_init_done)\n")
+		fmt.Fprintf(fgcc, "\t\t_cgo_wait_runtime_init_done();\n")
+		fmt.Fprintf(fgcc, "\t_cgo_tsan_release();\n")
+		fmt.Fprint(fgcc, "\t")
+		if resultCount > 0 {
+			fmt.Fprint(fgcc, "r = ")
+		}
+		fmt.Fprintf(fgcc, "%s(", goName)
+		if fn.Recv != nil {
+			fmt.Fprint(fgcc, "recv")
+		}
+		forFieldList(fntype.Params,
+			func(i int, aname string, atype ast.Expr) {
+				if i > 0 || fn.Recv != nil {
+					fmt.Fprintf(fgcc, ", ")
+				}
+				fmt.Fprintf(fgcc, "p%d", i)
+			})
+		fmt.Fprint(fgcc, ");\n")
+		fmt.Fprintf(fgcc, "\t_cgo_tsan_acquire();\n")
+		if resultCount > 0 {
+			fmt.Fprint(fgcc, "\treturn r;\n")
+		}
+		fmt.Fprint(fgcc, "}\n")
+
+		// Dummy declaration for _cgo_main.c
+		fmt.Fprintf(fm, `char %s[1] __asm__("%s.%s");`, goName, gccgoSymbolPrefix, gccgoToSymbol(goName))
+		fmt.Fprint(fm, "\n")
+
+		// For gccgo we use a wrapper function in Go, in order
+		// to call CgocallBack and CgocallBackDone.
+
+		// This code uses printer.Fprint, not conf.Fprint,
+		// because we don't want //line comments in the middle
+		// of the function types.
+		fmt.Fprint(fgo2, "\n")
+		fmt.Fprintf(fgo2, "func %s(", goName)
+		if fn.Recv != nil {
+			fmt.Fprint(fgo2, "recv ")
+			printer.Fprint(fgo2, fset, fn.Recv.List[0].Type)
+		}
+		forFieldList(fntype.Params,
+			func(i int, aname string, atype ast.Expr) {
+				if i > 0 || fn.Recv != nil {
+					fmt.Fprintf(fgo2, ", ")
+				}
+				fmt.Fprintf(fgo2, "p%d ", i)
+				printer.Fprint(fgo2, fset, atype)
+			})
+		fmt.Fprintf(fgo2, ")")
+		if resultCount > 0 {
+			fmt.Fprintf(fgo2, " (")
+			forFieldList(fntype.Results,
+				func(i int, aname string, atype ast.Expr) {
+					if i > 0 {
+						fmt.Fprint(fgo2, ", ")
+					}
+					printer.Fprint(fgo2, fset, atype)
+				})
+			fmt.Fprint(fgo2, ")")
+		}
+		fmt.Fprint(fgo2, " {\n")
+		fmt.Fprint(fgo2, "\tsyscall.CgocallBack()\n")
+		fmt.Fprint(fgo2, "\tdefer syscall.CgocallBackDone()\n")
+		fmt.Fprint(fgo2, "\t")
+		if resultCount > 0 {
+			fmt.Fprint(fgo2, "return ")
+		}
+		if fn.Recv != nil {
+			fmt.Fprint(fgo2, "recv.")
+		}
+		fmt.Fprintf(fgo2, "%s(", exp.Func.Name)
+		forFieldList(fntype.Params,
+			func(i int, aname string, atype ast.Expr) {
+				if i > 0 {
+					fmt.Fprint(fgo2, ", ")
+				}
+				fmt.Fprintf(fgo2, "p%d", i)
+			})
+		fmt.Fprint(fgo2, ")\n")
+		fmt.Fprint(fgo2, "}\n")
+	}
+
+	fmt.Fprintf(fgcch, "%s", gccExportHeaderEpilog)
+}
+
+// writeExportHeader writes out the start of the _cgo_export.h file.
+func (p *Package) writeExportHeader(fgcch io.Writer) {
+	fmt.Fprintf(fgcch, "/* Code generated by cmd/cgo; DO NOT EDIT. */\n\n")
+	pkg := *importPath
+	if pkg == "" {
+		pkg = p.PackagePath
+	}
+	fmt.Fprintf(fgcch, "/* package %s */\n\n", pkg)
+	fmt.Fprintf(fgcch, "%s\n", builtinExportProlog)
+
+	// Remove absolute paths from #line comments in the preamble.
+	// They aren't useful for people using the header file,
+	// and they mean that the header files change based on the
+	// exact location of GOPATH.
+	re := regexp.MustCompile(`(?m)^(#line\s+\d+\s+")[^"]*[/\\]([^"]*")`)
+	preamble := re.ReplaceAllString(p.Preamble, "$1$2")
+
+	fmt.Fprintf(fgcch, "/* Start of preamble from import \"C\" comments.  */\n\n")
+	fmt.Fprintf(fgcch, "%s\n", preamble)
+	fmt.Fprintf(fgcch, "\n/* End of preamble from import \"C\" comments.  */\n\n")
+
+	fmt.Fprintf(fgcch, "%s\n", p.gccExportHeaderProlog())
+}
+
+// gccgoToSymbol converts a name to a mangled symbol for gccgo.
+func gccgoToSymbol(ppath string) string {
+	if gccgoMangler == nil {
+		var err error
+		cmd := os.Getenv("GCCGO")
+		if cmd == "" {
+			cmd, err = exec.LookPath("gccgo")
+			if err != nil {
+				fatalf("unable to locate gccgo: %v", err)
+			}
+		}
+		gccgoMangler, err = pkgpath.ToSymbolFunc(cmd, *objDir)
+		if err != nil {
+			fatalf("%v", err)
+		}
+	}
+	return gccgoMangler(ppath)
+}
+
+// Return the package prefix when using gccgo.
+func (p *Package) gccgoSymbolPrefix() string {
+	if !*gccgo {
+		return ""
+	}
+
+	if *gccgopkgpath != "" {
+		return gccgoToSymbol(*gccgopkgpath)
+	}
+	if *gccgoprefix == "" && p.PackageName == "main" {
+		return "main"
+	}
+	prefix := gccgoToSymbol(*gccgoprefix)
+	if prefix == "" {
+		prefix = "go"
+	}
+	return prefix + "." + p.PackageName
+}
+
+// Call a function for each entry in an ast.FieldList, passing the
+// index into the list, the name if any, and the type.
+func forFieldList(fl *ast.FieldList, fn func(int, string, ast.Expr)) {
+	if fl == nil {
+		return
+	}
+	i := 0
+	for _, r := range fl.List {
+		if r.Names == nil {
+			fn(i, "", r.Type)
+			i++
+		} else {
+			for _, n := range r.Names {
+				fn(i, n.Name, r.Type)
+				i++
+			}
+		}
+	}
+}
+
+func c(repr string, args ...any) *TypeRepr {
+	return &TypeRepr{repr, args}
+}
+
+// Map predeclared Go types to Type.
+var goTypes = map[string]*Type{
+	"bool":       {Size: 1, Align: 1, C: c("GoUint8")},
+	"byte":       {Size: 1, Align: 1, C: c("GoUint8")},
+	"int":        {Size: 0, Align: 0, C: c("GoInt")},
+	"uint":       {Size: 0, Align: 0, C: c("GoUint")},
+	"rune":       {Size: 4, Align: 4, C: c("GoInt32")},
+	"int8":       {Size: 1, Align: 1, C: c("GoInt8")},
+	"uint8":      {Size: 1, Align: 1, C: c("GoUint8")},
+	"int16":      {Size: 2, Align: 2, C: c("GoInt16")},
+	"uint16":     {Size: 2, Align: 2, C: c("GoUint16")},
+	"int32":      {Size: 4, Align: 4, C: c("GoInt32")},
+	"uint32":     {Size: 4, Align: 4, C: c("GoUint32")},
+	"int64":      {Size: 8, Align: 8, C: c("GoInt64")},
+	"uint64":     {Size: 8, Align: 8, C: c("GoUint64")},
+	"float32":    {Size: 4, Align: 4, C: c("GoFloat32")},
+	"float64":    {Size: 8, Align: 8, C: c("GoFloat64")},
+	"complex64":  {Size: 8, Align: 4, C: c("GoComplex64")},
+	"complex128": {Size: 16, Align: 8, C: c("GoComplex128")},
+}
+
+// Map an ast type to a Type.
+func (p *Package) cgoType(e ast.Expr) *Type {
+	return p.doCgoType(e, make(map[ast.Expr]bool))
+}
+
+// Map an ast type to a Type, avoiding cycles.
+func (p *Package) doCgoType(e ast.Expr, m map[ast.Expr]bool) *Type {
+	if m[e] {
+		fatalf("%s: invalid recursive type", fset.Position(e.Pos()))
+	}
+	m[e] = true
+	switch t := e.(type) {
+	case *ast.StarExpr:
+		x := p.doCgoType(t.X, m)
+		return &Type{Size: p.PtrSize, Align: p.PtrSize, C: c("%s*", x.C)}
+	case *ast.ArrayType:
+		if t.Len == nil {
+			// Slice: pointer, len, cap.
+			return &Type{Size: p.PtrSize * 3, Align: p.PtrSize, C: c("GoSlice")}
+		}
+		// Non-slice array types are not supported.
+	case *ast.StructType:
+		// Not supported.
+	case *ast.FuncType:
+		return &Type{Size: p.PtrSize, Align: p.PtrSize, C: c("void*")}
+	case *ast.InterfaceType:
+		return &Type{Size: 2 * p.PtrSize, Align: p.PtrSize, C: c("GoInterface")}
+	case *ast.MapType:
+		return &Type{Size: p.PtrSize, Align: p.PtrSize, C: c("GoMap")}
+	case *ast.ChanType:
+		return &Type{Size: p.PtrSize, Align: p.PtrSize, C: c("GoChan")}
+	case *ast.Ident:
+		goTypesFixup := func(r *Type) *Type {
+			if r.Size == 0 { // int or uint
+				rr := new(Type)
+				*rr = *r
+				rr.Size = p.IntSize
+				rr.Align = p.IntSize
+				r = rr
+			}
+			if r.Align > p.PtrSize {
+				r.Align = p.PtrSize
+			}
+			return r
+		}
+		// Look up the type in the top level declarations.
+		// TODO: Handle types defined within a function.
+		for _, d := range p.Decl {
+			gd, ok := d.(*ast.GenDecl)
+			if !ok || gd.Tok != token.TYPE {
+				continue
+			}
+			for _, spec := range gd.Specs {
+				ts, ok := spec.(*ast.TypeSpec)
+				if !ok {
+					continue
+				}
+				if ts.Name.Name == t.Name {
+					// Give a better error than the one
+					// above if we detect a recursive type.
+					if m[ts.Type] {
+						fatalf("%s: invalid recursive type: %s refers to itself", fset.Position(e.Pos()), t.Name)
+					}
+					return p.doCgoType(ts.Type, m)
+				}
+			}
+		}
+		if def := typedef[t.Name]; def != nil {
+			if defgo, ok := def.Go.(*ast.Ident); ok {
+				switch defgo.Name {
+				case "complex64", "complex128":
+					// MSVC does not support the _Complex keyword
+					// nor the complex macro.
+					// Use GoComplex64 and GoComplex128 instead,
+					// which are typedef-ed to a compatible type.
+					// See go.dev/issues/36233.
+					return goTypesFixup(goTypes[defgo.Name])
+				}
+			}
+			return def
+		}
+		if t.Name == "uintptr" {
+			return &Type{Size: p.PtrSize, Align: p.PtrSize, C: c("GoUintptr")}
+		}
+		if t.Name == "string" {
+			// The string data is 1 pointer + 1 (pointer-sized) int.
+			return &Type{Size: 2 * p.PtrSize, Align: p.PtrSize, C: c("GoString")}
+		}
+		if t.Name == "error" {
+			return &Type{Size: 2 * p.PtrSize, Align: p.PtrSize, C: c("GoInterface")}
+		}
+		if t.Name == "any" {
+			return &Type{Size: 2 * p.PtrSize, Align: p.PtrSize, C: c("GoInterface")}
+		}
+		if r, ok := goTypes[t.Name]; ok {
+			return goTypesFixup(r)
+		}
+		error_(e.Pos(), "unrecognized Go type %s", t.Name)
+		return &Type{Size: 4, Align: 4, C: c("int")}
+	case *ast.SelectorExpr:
+		id, ok := t.X.(*ast.Ident)
+		if ok && id.Name == "unsafe" && t.Sel.Name == "Pointer" {
+			return &Type{Size: p.PtrSize, Align: p.PtrSize, C: c("void*")}
+		}
+	}
+	error_(e.Pos(), "Go type not supported in export: %s", gofmt(e))
+	return &Type{Size: 4, Align: 4, C: c("int")}
+}
+
+const gccProlog = `
+#line 1 "cgo-gcc-prolog"
+/*
+  If x and y are not equal, the type will be invalid
+  (have a negative array count) and an inscrutable error will come
+  out of the compiler and hopefully mention "name".
+*/
+#define __cgo_compile_assert_eq(x, y, name) typedef char name[(x-y)*(x-y)*-2UL+1UL];
+
+/* Check at compile time that the sizes we use match our expectations. */
+#define __cgo_size_assert(t, n) __cgo_compile_assert_eq(sizeof(t), (size_t)n, _cgo_sizeof_##t##_is_not_##n)
+
+__cgo_size_assert(char, 1)
+__cgo_size_assert(short, 2)
+__cgo_size_assert(int, 4)
+typedef long long __cgo_long_long;
+__cgo_size_assert(__cgo_long_long, 8)
+__cgo_size_assert(float, 4)
+__cgo_size_assert(double, 8)
+
+extern char* _cgo_topofstack(void);
+
+/*
+  We use packed structs, but they are always aligned.
+  The pragmas and address-of-packed-member are only recognized as warning
+  groups in clang 4.0+, so ignore unknown pragmas first.
+*/
+#pragma GCC diagnostic ignored "-Wunknown-pragmas"
+#pragma GCC diagnostic ignored "-Wpragmas"
+#pragma GCC diagnostic ignored "-Waddress-of-packed-member"
+#pragma GCC diagnostic ignored "-Wunknown-warning-option"
+#pragma GCC diagnostic ignored "-Wunaligned-access"
+
+#include <errno.h>
+#include <string.h>
+`
+
+// Prologue defining TSAN functions in C.
+const noTsanProlog = `
+#define CGO_NO_SANITIZE_THREAD
+#define _cgo_tsan_acquire()
+#define _cgo_tsan_release()
+`
+
+// This must match the TSAN code in runtime/cgo/libcgo.h.
+// This is used when the code is built with the C/C++ Thread SANitizer,
+// which is not the same as the Go race detector.
+// __tsan_acquire tells TSAN that we are acquiring a lock on a variable,
+// in this case _cgo_sync. __tsan_release releases the lock.
+// (There is no actual lock, we are just telling TSAN that there is.)
+//
+// When we call from Go to C we call _cgo_tsan_acquire.
+// When the C function returns we call _cgo_tsan_release.
+// Similarly, when C calls back into Go we call _cgo_tsan_release
+// and then call _cgo_tsan_acquire when we return to C.
+// These calls tell TSAN that there is a serialization point at the C call.
+//
+// This is necessary because TSAN, which is a C/C++ tool, can not see
+// the synchronization in the Go code. Without these calls, when
+// multiple goroutines call into C code, TSAN does not understand
+// that the calls are properly synchronized on the Go side.
+//
+// To be clear, if the calls are not properly synchronized on the Go side,
+// we will be hiding races. But when using TSAN on mixed Go C/C++ code
+// it is more important to avoid false positives, which reduce confidence
+// in the tool, than to avoid false negatives.
+const yesTsanProlog = `
+#line 1 "cgo-tsan-prolog"
+#define CGO_NO_SANITIZE_THREAD __attribute__ ((no_sanitize_thread))
+
+long long _cgo_sync __attribute__ ((common));
+
+extern void __tsan_acquire(void*);
+extern void __tsan_release(void*);
+
+__attribute__ ((unused))
+static void _cgo_tsan_acquire() {
+	__tsan_acquire(&_cgo_sync);
+}
+
+__attribute__ ((unused))
+static void _cgo_tsan_release() {
+	__tsan_release(&_cgo_sync);
+}
+`
+
+// Set to yesTsanProlog if we see -fsanitize=thread in the flags for gcc.
+var tsanProlog = noTsanProlog
+
+// noMsanProlog is a prologue defining an MSAN function in C.
+// This is used when not compiling with -fsanitize=memory.
+const noMsanProlog = `
+#define _cgo_msan_write(addr, sz)
+`
+
+// yesMsanProlog is a prologue defining an MSAN function in C.
+// This is used when compiling with -fsanitize=memory.
+// See the comment above where _cgo_msan_write is called.
+const yesMsanProlog = `
+extern void __msan_unpoison(const volatile void *, size_t);
+
+#define _cgo_msan_write(addr, sz) __msan_unpoison((addr), (sz))
+`
+
+// msanProlog is set to yesMsanProlog if we see -fsanitize=memory in the flags
+// for the C compiler.
+var msanProlog = noMsanProlog
+
+const builtinProlog = `
+#line 1 "cgo-builtin-prolog"
+#include <stddef.h>
+
+/* Define intgo when compiling with GCC.  */
+typedef ptrdiff_t intgo;
+
+#define GO_CGO_GOSTRING_TYPEDEF
+typedef struct { const char *p; intgo n; } _GoString_;
+typedef struct { char *p; intgo n; intgo c; } _GoBytes_;
+_GoString_ GoString(char *p);
+_GoString_ GoStringN(char *p, int l);
+_GoBytes_ GoBytes(void *p, int n);
+char *CString(_GoString_);
+void *CBytes(_GoBytes_);
+void *_CMalloc(size_t);
+
+__attribute__ ((unused))
+static size_t _GoStringLen(_GoString_ s) { return (size_t)s.n; }
+
+__attribute__ ((unused))
+static const char *_GoStringPtr(_GoString_ s) { return s.p; }
+`
+
+const goProlog = `
+//go:linkname _cgo_runtime_cgocall runtime.cgocall
+func _cgo_runtime_cgocall(unsafe.Pointer, uintptr) int32
+
+//go:linkname _cgoCheckPointer runtime.cgoCheckPointer
+//go:noescape
+func _cgoCheckPointer(interface{}, interface{})
+
+//go:linkname _cgoCheckResult runtime.cgoCheckResult
+//go:noescape
+func _cgoCheckResult(interface{})
+`
+
+const gccgoGoProlog = `
+func _cgoCheckPointer(interface{}, interface{})
+
+func _cgoCheckResult(interface{})
+`
+
+const goStringDef = `
+//go:linkname _cgo_runtime_gostring runtime.gostring
+func _cgo_runtime_gostring(*_Ctype_char) string
+
+// GoString converts the C string p into a Go string.
+func _Cfunc_GoString(p *_Ctype_char) string {
+	return _cgo_runtime_gostring(p)
+}
+`
+
+const goStringNDef = `
+//go:linkname _cgo_runtime_gostringn runtime.gostringn
+func _cgo_runtime_gostringn(*_Ctype_char, int) string
+
+// GoStringN converts the C data p with explicit length l to a Go string.
+func _Cfunc_GoStringN(p *_Ctype_char, l _Ctype_int) string {
+	return _cgo_runtime_gostringn(p, int(l))
+}
+`
+
+const goBytesDef = `
+//go:linkname _cgo_runtime_gobytes runtime.gobytes
+func _cgo_runtime_gobytes(unsafe.Pointer, int) []byte
+
+// GoBytes converts the C data p with explicit length l to a Go []byte.
+func _Cfunc_GoBytes(p unsafe.Pointer, l _Ctype_int) []byte {
+	return _cgo_runtime_gobytes(p, int(l))
+}
+`
+
+const cStringDef = `
+// CString converts the Go string s to a C string.
+//
+// The C string is allocated in the C heap using malloc.
+// It is the caller's responsibility to arrange for it to be
+// freed, such as by calling C.free (be sure to include stdlib.h
+// if C.free is needed).
+func _Cfunc_CString(s string) *_Ctype_char {
+	if len(s)+1 <= 0 {
+		panic("string too large")
+	}
+	p := _cgo_cmalloc(uint64(len(s)+1))
+	sliceHeader := struct {
+		p   unsafe.Pointer
+		len int
+		cap int
+	}{p, len(s)+1, len(s)+1}
+	b := *(*[]byte)(unsafe.Pointer(&sliceHeader))
+	copy(b, s)
+	b[len(s)] = 0
+	return (*_Ctype_char)(p)
+}
+`
+
+const cBytesDef = `
+// CBytes converts the Go []byte slice b to a C array.
+//
+// The C array is allocated in the C heap using malloc.
+// It is the caller's responsibility to arrange for it to be
+// freed, such as by calling C.free (be sure to include stdlib.h
+// if C.free is needed).
+func _Cfunc_CBytes(b []byte) unsafe.Pointer {
+	p := _cgo_cmalloc(uint64(len(b)))
+	sliceHeader := struct {
+		p   unsafe.Pointer
+		len int
+		cap int
+	}{p, len(b), len(b)}
+	s := *(*[]byte)(unsafe.Pointer(&sliceHeader))
+	copy(s, b)
+	return p
+}
+`
+
+const cMallocDef = `
+func _Cfunc__CMalloc(n _Ctype_size_t) unsafe.Pointer {
+	return _cgo_cmalloc(uint64(n))
+}
+`
+
+var builtinDefs = map[string]string{
+	"GoString":  goStringDef,
+	"GoStringN": goStringNDef,
+	"GoBytes":   goBytesDef,
+	"CString":   cStringDef,
+	"CBytes":    cBytesDef,
+	"_CMalloc":  cMallocDef,
+}
+
+// Definitions for C.malloc in Go and in C. We define it ourselves
+// since we call it from functions we define, such as C.CString.
+// Also, we have historically ensured that C.malloc does not return
+// nil even for an allocation of 0.
+
+const cMallocDefGo = `
+//go:cgo_import_static _cgoPREFIX_Cfunc__Cmalloc
+//go:linkname __cgofn__cgoPREFIX_Cfunc__Cmalloc _cgoPREFIX_Cfunc__Cmalloc
+var __cgofn__cgoPREFIX_Cfunc__Cmalloc byte
+var _cgoPREFIX_Cfunc__Cmalloc = unsafe.Pointer(&__cgofn__cgoPREFIX_Cfunc__Cmalloc)
+
+//go:linkname runtime_throw runtime.throw
+func runtime_throw(string)
+
+//go:cgo_unsafe_args
+func _cgo_cmalloc(p0 uint64) (r1 unsafe.Pointer) {
+	_cgo_runtime_cgocall(_cgoPREFIX_Cfunc__Cmalloc, uintptr(unsafe.Pointer(&p0)))
+	if r1 == nil {
+		runtime_throw("runtime: C malloc failed")
+	}
+	return
+}
+`
+
+// cMallocDefC defines the C version of C.malloc for the gc compiler.
+// It is defined here because C.CString and friends need a definition.
+// We define it by hand, rather than simply inventing a reference to
+// C.malloc, because <stdlib.h> may not have been included.
+// This is approximately what writeOutputFunc would generate, but
+// skips the cgo_topofstack code (which is only needed if the C code
+// calls back into Go). This also avoids returning nil for an
+// allocation of 0 bytes.
+const cMallocDefC = `
+CGO_NO_SANITIZE_THREAD
+void _cgoPREFIX_Cfunc__Cmalloc(void *v) {
+	struct {
+		unsigned long long p0;
+		void *r1;
+	} PACKED *a = v;
+	void *ret;
+	_cgo_tsan_acquire();
+	ret = malloc(a->p0);
+	if (ret == NULL && a->p0 == 0) {
+		ret = malloc(1);
+	}
+	a->r1 = ret;
+	_cgo_tsan_release();
+}
+`
+
+func (p *Package) cPrologGccgo() string {
+	r := strings.NewReplacer(
+		"PREFIX", cPrefix,
+		"GCCGOSYMBOLPREF", p.gccgoSymbolPrefix(),
+		"_cgoCheckPointer", gccgoToSymbol("_cgoCheckPointer"),
+		"_cgoCheckResult", gccgoToSymbol("_cgoCheckResult"))
+	return r.Replace(cPrologGccgo)
+}
+
+const cPrologGccgo = `
+#line 1 "cgo-c-prolog-gccgo"
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef unsigned char byte;
+typedef intptr_t intgo;
+
+struct __go_string {
+	const unsigned char *__data;
+	intgo __length;
+};
+
+typedef struct __go_open_array {
+	void* __values;
+	intgo __count;
+	intgo __capacity;
+} Slice;
+
+struct __go_string __go_byte_array_to_string(const void* p, intgo len);
+struct __go_open_array __go_string_to_byte_array (struct __go_string str);
+
+extern void runtime_throw(const char *);
+
+const char *_cgoPREFIX_Cfunc_CString(struct __go_string s) {
+	char *p = malloc(s.__length+1);
+	if(p == NULL)
+		runtime_throw("runtime: C malloc failed");
+	memmove(p, s.__data, s.__length);
+	p[s.__length] = 0;
+	return p;
+}
+
+void *_cgoPREFIX_Cfunc_CBytes(struct __go_open_array b) {
+	char *p = malloc(b.__count);
+	if(p == NULL)
+		runtime_throw("runtime: C malloc failed");
+	memmove(p, b.__values, b.__count);
+	return p;
+}
+
+struct __go_string _cgoPREFIX_Cfunc_GoString(char *p) {
+	intgo len = (p != NULL) ? strlen(p) : 0;
+	return __go_byte_array_to_string(p, len);
+}
+
+struct __go_string _cgoPREFIX_Cfunc_GoStringN(char *p, int32_t n) {
+	return __go_byte_array_to_string(p, n);
+}
+
+Slice _cgoPREFIX_Cfunc_GoBytes(char *p, int32_t n) {
+	struct __go_string s = { (const unsigned char *)p, n };
+	return __go_string_to_byte_array(s);
+}
+
+void *_cgoPREFIX_Cfunc__CMalloc(size_t n) {
+	void *p = malloc(n);
+	if(p == NULL && n == 0)
+		p = malloc(1);
+	if(p == NULL)
+		runtime_throw("runtime: C malloc failed");
+	return p;
+}
+
+struct __go_type_descriptor;
+typedef struct __go_empty_interface {
+	const struct __go_type_descriptor *__type_descriptor;
+	void *__object;
+} Eface;
+
+extern void runtimeCgoCheckPointer(Eface, Eface)
+	__asm__("runtime.cgoCheckPointer")
+	__attribute__((weak));
+
+extern void localCgoCheckPointer(Eface, Eface)
+	__asm__("GCCGOSYMBOLPREF._cgoCheckPointer");
+
+void localCgoCheckPointer(Eface ptr, Eface arg) {
+	if(runtimeCgoCheckPointer) {
+		runtimeCgoCheckPointer(ptr, arg);
+	}
+}
+
+extern void runtimeCgoCheckResult(Eface)
+	__asm__("runtime.cgoCheckResult")
+	__attribute__((weak));
+
+extern void localCgoCheckResult(Eface)
+	__asm__("GCCGOSYMBOLPREF._cgoCheckResult");
+
+void localCgoCheckResult(Eface val) {
+	if(runtimeCgoCheckResult) {
+		runtimeCgoCheckResult(val);
+	}
+}
+`
+
+// builtinExportProlog is a shorter version of builtinProlog,
+// to be put into the _cgo_export.h file.
+// For historical reasons we can't use builtinProlog in _cgo_export.h,
+// because _cgo_export.h defines GoString as a struct while builtinProlog
+// defines it as a function. We don't change this to avoid unnecessarily
+// breaking existing code.
+// The test of GO_CGO_GOSTRING_TYPEDEF avoids a duplicate definition
+// error if a Go file with a cgo comment #include's the export header
+// generated by a different package.
+const builtinExportProlog = `
+#line 1 "cgo-builtin-export-prolog"
+
+#include <stddef.h>
+
+#ifndef GO_CGO_EXPORT_PROLOGUE_H
+#define GO_CGO_EXPORT_PROLOGUE_H
+
+#ifndef GO_CGO_GOSTRING_TYPEDEF
+typedef struct { const char *p; ptrdiff_t n; } _GoString_;
+extern size_t _GoStringLen(_GoString_ s);
+extern const char *_GoStringPtr(_GoString_ s);
+#endif
+
+#endif
+`
+
+func (p *Package) gccExportHeaderProlog() string {
+	return strings.ReplaceAll(gccExportHeaderProlog, "GOINTBITS", fmt.Sprint(8*p.IntSize))
+}
+
+// gccExportHeaderProlog is written to the exported header, after the
+// import "C" comment preamble but before the generated declarations
+// of exported functions. This permits the generated declarations to
+// use the type names that appear in goTypes, above.
+//
+// The test of GO_CGO_GOSTRING_TYPEDEF avoids a duplicate definition
+// error if a Go file with a cgo comment #include's the export header
+// generated by a different package. Unfortunately GoString means two
+// different things: in this prolog it means a C name for the Go type,
+// while in the prolog written into the start of the C code generated
+// from a cgo-using Go file it means the C.GoString function. There is
+// no way to resolve this conflict, but it also doesn't make much
+// difference, as Go code never wants to refer to the latter meaning.
+const gccExportHeaderProlog = `
+/* Start of boilerplate cgo prologue.  */
+#line 1 "cgo-gcc-export-header-prolog"
+
+#ifndef GO_CGO_PROLOGUE_H
+#define GO_CGO_PROLOGUE_H
+
+typedef signed char GoInt8;
+typedef unsigned char GoUint8;
+typedef short GoInt16;
+typedef unsigned short GoUint16;
+typedef int GoInt32;
+typedef unsigned int GoUint32;
+typedef long long GoInt64;
+typedef unsigned long long GoUint64;
+typedef GoIntGOINTBITS GoInt;
+typedef GoUintGOINTBITS GoUint;
+typedef size_t GoUintptr;
+typedef float GoFloat32;
+typedef double GoFloat64;
+#ifdef _MSC_VER
+#if !defined(__cplusplus) || _MSVC_LANG <= 201402L
+#include <complex.h>
+typedef _Fcomplex GoComplex64;
+typedef _Dcomplex GoComplex128;
+#else
+#include <complex>
+typedef std::complex<float> GoComplex64;
+typedef std::complex<double> GoComplex128;
+#endif
+#else
+typedef float _Complex GoComplex64;
+typedef double _Complex GoComplex128;
+#endif
+
+/*
+  static assertion to make sure the file is being used on architecture
+  at least with matching size of GoInt.
+*/
+typedef char _check_for_GOINTBITS_bit_pointer_matching_GoInt[sizeof(void*)==GOINTBITS/8 ? 1:-1];
+
+#ifndef GO_CGO_GOSTRING_TYPEDEF
+typedef _GoString_ GoString;
+#endif
+typedef void *GoMap;
+typedef void *GoChan;
+typedef struct { void *t; void *v; } GoInterface;
+typedef struct { void *data; GoInt len; GoInt cap; } GoSlice;
+
+#endif
+
+/* End of boilerplate cgo prologue.  */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+`
+
+// gccExportHeaderEpilog goes at the end of the generated header file.
+const gccExportHeaderEpilog = `
+#ifdef __cplusplus
+}
+#endif
+`
+
+// gccgoExportFileProlog is written to the _cgo_export.c file when
+// using gccgo.
+// We use weak declarations, and test the addresses, so that this code
+// works with older versions of gccgo.
+const gccgoExportFileProlog = `
+#line 1 "cgo-gccgo-export-file-prolog"
+extern _Bool runtime_iscgo __attribute__ ((weak));
+
+static void GoInit(void) __attribute__ ((constructor));
+static void GoInit(void) {
+	if(&runtime_iscgo)
+		runtime_iscgo = 1;
+}
+
+extern size_t _cgo_wait_runtime_init_done(void) __attribute__ ((weak));
+`

go/src/cmd/cgo/util.go

@@ -0,0 +1,106 @@
+// Copyright 2009 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 (
+	"bytes"
+	"fmt"
+	"go/token"
+	"os"
+	"os/exec"
+	"slices"
+)
+
+// run runs the command argv, feeding in stdin on standard input.
+// It returns the output to standard output and standard error.
+// ok indicates whether the command exited successfully.
+func run(stdin []byte, argv []string) (stdout, stderr []byte, ok bool) {
+	if i := slices.Index(argv, "-xc"); i >= 0 && argv[len(argv)-1] == "-" {
+		// Some compilers have trouble with standard input.
+		// Others have trouble with -xc.
+		// Avoid both problems by writing a file with a .c extension.
+		f, err := os.CreateTemp("", "cgo-gcc-input-")
+		if err != nil {
+			fatalf("%s", err)
+		}
+		name := f.Name()
+		f.Close()
+		if err := os.WriteFile(name+".c", stdin, 0666); err != nil {
+			os.Remove(name)
+			fatalf("%s", err)
+		}
+		defer os.Remove(name)
+		defer os.Remove(name + ".c")
+
+		// Build new argument list without -xc and trailing -.
+		new := append(argv[:i:i], argv[i+1:len(argv)-1]...)
+
+		// Since we are going to write the file to a temporary directory,
+		// we will need to add -I . explicitly to the command line:
+		// any #include "foo" before would have looked in the current
+		// directory as the directory "holding" standard input, but now
+		// the temporary directory holds the input.
+		// We've also run into compilers that reject "-I." but allow "-I", ".",
+		// so be sure to use two arguments.
+		// This matters mainly for people invoking cgo -godefs by hand.
+		new = append(new, "-I", ".")
+
+		// Finish argument list with path to C file.
+		new = append(new, name+".c")
+
+		argv = new
+		stdin = nil
+	}
+
+	p := exec.Command(argv[0], argv[1:]...)
+	p.Stdin = bytes.NewReader(stdin)
+	var bout, berr bytes.Buffer
+	p.Stdout = &bout
+	p.Stderr = &berr
+	// Disable escape codes in clang error messages.
+	p.Env = append(os.Environ(), "TERM=dumb")
+	err := p.Run()
+	if _, ok := err.(*exec.ExitError); err != nil && !ok {
+		fatalf("exec %s: %s", argv[0], err)
+	}
+	ok = p.ProcessState.Success()
+	stdout, stderr = bout.Bytes(), berr.Bytes()
+	return
+}
+
+func lineno(pos token.Pos) string {
+	return fset.Position(pos).String()
+}
+
+// Die with an error message.
+func fatalf(msg string, args ...any) {
+	// If we've already printed other errors, they might have
+	// caused the fatal condition. Assume they're enough.
+	if nerrors == 0 {
+		fmt.Fprintf(os.Stderr, "cgo: "+msg+"\n", args...)
+	}
+	os.Exit(2)
+}
+
+var nerrors int
+
+func error_(pos token.Pos, msg string, args ...any) {
+	nerrors++
+	if pos.IsValid() {
+		fmt.Fprintf(os.Stderr, "%s: ", fset.Position(pos).String())
+	} else {
+		fmt.Fprintf(os.Stderr, "cgo: ")
+	}
+	fmt.Fprintf(os.Stderr, msg, args...)
+	fmt.Fprintf(os.Stderr, "\n")
+}
+
+func creat(name string) *os.File {
+	f, err := os.Create(name)
+	if err != nil {
+		fatalf("%s", err)
+	}
+	return f
+}

go/src/cmd/cgo/zdefaultcc.go

@@ -0,0 +1,23 @@
+// Code generated by go tool dist; DO NOT EDIT.
+
+package main
+
+const defaultPkgConfig = `pkg-config`
+func defaultCC(goos, goarch string) string {
+	switch goos+`/`+goarch {
+	}
+	switch goos {
+	case "darwin", "ios", "freebsd", "openbsd":
+		return "clang"
+	}
+	return "gcc"
+}
+func defaultCXX(goos, goarch string) string {
+	switch goos+`/`+goarch {
+	}
+	switch goos {
+	case "darwin", "ios", "freebsd", "openbsd":
+		return "clang++"
+	}
+	return "g++"
+}

go/src/cmd/compile/README.md

@@ -0,0 +1,366 @@
+<!---
+// Copyright 2018 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.
+-->
+
+## Introduction to the Go compiler
+
+`cmd/compile` contains the main packages that form the Go compiler. The compiler
+may be logically split in four phases, which we will briefly describe alongside
+the list of packages that contain their code.
+
+You may sometimes hear the terms "front-end" and "back-end" when referring to
+the compiler. Roughly speaking, these translate to the first two and last two
+phases we are going to list here. A third term, "middle-end", often refers to
+much of the work that happens in the second phase.
+
+Note that the `go/*` family of packages, such as `go/parser` and
+`go/types`, are mostly unused by the compiler. Since the compiler was
+initially written in C, the `go/*` packages were developed to enable
+writing tools working with Go code, such as `gofmt` and `vet`.
+However, over time the compiler's internal APIs have slowly evolved to
+be more familiar to users of the `go/*` packages.
+
+It should be clarified that the name "gc" stands for "Go compiler", and has
+little to do with uppercase "GC", which stands for garbage collection.
+
+### 1. Parsing
+
+* `cmd/compile/internal/syntax` (lexer, parser, syntax tree)
+
+In the first phase of compilation, source code is tokenized (lexical analysis),
+parsed (syntax analysis), and a syntax tree is constructed for each source
+file.
+
+Each syntax tree is an exact representation of the respective source file, with
+nodes corresponding to the various elements of the source such as expressions,
+declarations, and statements. The syntax tree also includes position information
+which is used for error reporting and the creation of debugging information.
+
+### 2. Type checking
+
+* `cmd/compile/internal/types2` (type checking)
+
+The types2 package is a port of `go/types` to use the syntax package's
+AST instead of `go/ast`.
+
+### 3. IR construction ("noding")
+
+* `cmd/compile/internal/types` (compiler types)
+* `cmd/compile/internal/ir` (compiler AST)
+* `cmd/compile/internal/noder` (create compiler AST)
+
+The compiler middle end uses its own AST definition and representation of Go
+types carried over from when it was written in C. All of its code is written in
+terms of these, so the next step after type checking is to convert the syntax
+and types2 representations to ir and types. This process is referred to as
+"noding."
+
+Noding uses a process called Unified IR, which builds a node representation
+using a serialized version of the typechecked code from step 2.
+Unified IR is also involved in import/export of packages and inlining.
+
+### 4. Middle end
+
+* `cmd/compile/internal/inline` (function call inlining)
+* `cmd/compile/internal/devirtualize` (devirtualization of known interface method calls)
+* `cmd/compile/internal/escape` (escape analysis)
+
+Several optimization passes are performed on the IR representation:
+dead code elimination, (early) devirtualization, function call
+inlining, and escape analysis.
+
+The early dead code elimination pass is integrated into the unified IR writer phase.
+
+### 5. Walk
+
+* `cmd/compile/internal/walk` (order of evaluation, desugaring)
+
+The final pass over the IR representation is "walk," which serves two purposes:
+
+1. It decomposes complex statements into individual, simpler statements,
+   introducing temporary variables and respecting order of evaluation. This step
+   is also referred to as "order."
+
+2. It desugars higher-level Go constructs into more primitive ones. For example,
+   `switch` statements are turned into binary search or jump tables, and
+   operations on maps and channels are replaced with runtime calls.
+
+### 6. Generic SSA
+
+* `cmd/compile/internal/ssa` (SSA passes and rules)
+* `cmd/compile/internal/ssagen` (converting IR to SSA)
+
+In this phase, IR is converted into Static Single Assignment (SSA) form, a
+lower-level intermediate representation with specific properties that make it
+easier to implement optimizations and to eventually generate machine code from
+it.
+
+During this conversion, function intrinsics are applied. These are special
+functions that the compiler has been taught to replace with heavily optimized
+code on a case-by-case basis.
+
+Certain nodes are also lowered into simpler components during the AST to SSA
+conversion, so that the rest of the compiler can work with them. For instance,
+the copy builtin is replaced by memory moves, and range loops are rewritten into
+for loops. Some of these currently happen before the conversion to SSA due to
+historical reasons, but the long-term plan is to move all of them here.
+
+Then, a series of machine-independent passes and rules are applied. These do not
+concern any single computer architecture, and thus run on all `GOARCH` variants.
+These passes include dead code elimination, removal of
+unneeded nil checks, and removal of unused branches. The generic rewrite rules
+mainly concern expressions, such as replacing some expressions with constant
+values, and optimizing multiplications and float operations.
+
+### 7. Generating machine code
+
+* `cmd/compile/internal/ssa` (SSA lowering and arch-specific passes)
+* `cmd/internal/obj` (machine code generation)
+
+The machine-dependent phase of the compiler begins with the "lower" pass, which
+rewrites generic values into their machine-specific variants. For example, on
+amd64 memory operands are possible, so many load-store operations may be combined.
+
+Note that the lower pass runs all machine-specific rewrite rules, and thus it
+currently applies lots of optimizations too.
+
+Once the SSA has been "lowered" and is more specific to the target architecture,
+the final code optimization passes are run. This includes yet another dead code
+elimination pass, moving values closer to their uses, the removal of local
+variables that are never read from, and register allocation.
+
+Other important pieces of work done as part of this step include stack frame
+layout, which assigns stack offsets to local variables, and pointer liveness
+analysis, which computes which on-stack pointers are live at each GC safe point.
+
+At the end of the SSA generation phase, Go functions have been transformed into
+a series of obj.Prog instructions. These are passed to the assembler
+(`cmd/internal/obj`), which turns them into machine code and writes out the
+final object file. The object file will also contain reflect data, export data,
+and debugging information.
+
+### 7a. Export
+
+In addition to writing a file of object code for the linker, the
+compiler also writes a file of "export data" for downstream
+compilation units. The export data file holds all the information
+computed during compilation of package P that may be needed when
+compiling a package Q that directly imports P. It includes type
+information for all exported declarations, IR for bodies of functions
+that are candidates for inlining, IR for bodies of generic functions
+that may be instantiated in another package, and a summary of the
+findings of escape analysis on function parameters.
+
+The format of the export data file has gone through a number of
+iterations. Its current form is called "unified", and it is a
+serialized representation of an object graph, with an index allowing
+lazy decoding of parts of the whole (since most imports are used to
+provide only a handful of symbols).
+
+The GOROOT repository contains a reader and a writer for the unified
+format; it encodes from/decodes to the compiler's IR.
+The golang.org/x/tools repository also provides a public API for an export
+data reader (using the go/types representation) that always supports the
+compiler's current file format and a small number of historic versions.
+(It is used by x/tools/go/packages in modes that require type information
+but not type-annotated syntax.)
+
+The x/tools repository also provides public APIs for reading and
+writing exported type information (but nothing more) using the older
+"indexed" format. (For example, gopls uses this version for its
+database of workspace information, which includes types.)
+
+Export data usually provides a "deep" summary, so that compilation of
+package Q can read the export data files only for each direct import,
+and be assured that these provide all necessary information about
+declarations in indirect imports, such as the methods and struct
+fields of types referred to in P's public API. Deep export data is
+simpler for build systems, since only one file is needed per direct
+dependency. However, it does have a tendency to grow as one gets
+higher up the import graph of a big repository: if there is a set of
+very commonly used types with a large API, nearly every package's
+export data will include a copy. This problem motivated the "indexed"
+design, which allowed partial loading on demand.
+(gopls does less work than the compiler for each import and is thus
+more sensitive to export data overheads. For this reason, it uses
+"shallow" export data, in which indirect information is not recorded
+at all. This demands random access to the export data files of all
+dependencies, so is not suitable for distributed build systems.)
+
+
+### 8. Tips
+
+#### Getting Started
+
+* If you have never contributed to the compiler before, a simple way to begin
+  can be adding a log statement or `panic("here")` to get some
+  initial insight into whatever you are investigating.
+
+* The compiler itself provides logging, debugging and visualization capabilities,
+  such as:
+   ```
+   $ go build -gcflags=-m=2                   # print optimization info, including inlining, escape analysis
+   $ go build -gcflags=-d=ssa/check_bce/debug # print bounds check info
+   $ go build -gcflags=-W                     # print internal parse tree after type checking
+   $ GOSSAFUNC=Foo go build                   # generate ssa.html file for func Foo
+   $ go build -gcflags=-S                     # print assembly
+   $ go tool compile -bench=out.txt x.go      # print timing of compiler phases
+   ```
+
+  Some flags alter the compiler behavior, such as:
+   ```
+   $ go tool compile -h file.go               # panic on first compile error encountered
+   $ go build -gcflags=-d=checkptr=2          # enable additional unsafe pointer checking
+   ```
+
+  There are many additional flags. Some descriptions are available via:
+   ```
+   $ go tool compile -h              # compiler flags, e.g., go build -gcflags='-m=1 -l'
+   $ go tool compile -d help         # debug flags, e.g., go build -gcflags=-d=checkptr=2
+   $ go tool compile -d ssa/help     # ssa flags, e.g., go build -gcflags=-d=ssa/prove/debug=2
+   ```
+
+  There are some additional details about `-gcflags` and the differences between `go build`
+  vs. `go tool compile` in a [section below](#-gcflags-and-go-build-vs-go-tool-compile).
+
+* In general, when investigating a problem in the compiler you usually want to
+  start with the simplest possible reproduction and understand exactly what is
+  happening with it.
+
+#### Testing your changes
+
+* Be sure to read the [Quickly testing your changes](https://go.dev/doc/contribute#quick_test)
+  section of the Go Contribution Guide.
+
+* Some tests live within the cmd/compile packages and can be run by `go test ./...` or similar,
+  but many cmd/compile tests are in the top-level
+  [test](https://github.com/golang/go/tree/master/test) directory:
+
+  ```
+  $ go test cmd/internal/testdir                           # all tests in 'test' dir
+  $ go test cmd/internal/testdir -run='Test/escape.*.go'   # test specific files in 'test' dir
+  ```
+  For details, see the [testdir README](https://github.com/golang/go/tree/master/test#readme).
+  The `errorCheck` method in [testdir_test.go](https://github.com/golang/go/blob/master/src/cmd/internal/testdir/testdir_test.go)
+  is helpful for a description of the `ERROR` comments used in many of those tests.
+
+  In addition, the `go/types` package from the standard library and `cmd/compile/internal/types2`
+  have shared tests in `src/internal/types/testdata`, and both type checkers
+  should be checked if anything changes there.
+
+* The new [application-based coverage profiling](https://go.dev/testing/coverage/) can be used
+  with the compiler, such as:
+
+  ```
+  $ go install -cover -coverpkg=cmd/compile/... cmd/compile  # build compiler with coverage instrumentation
+  $ mkdir /tmp/coverdir                                      # pick location for coverage data
+  $ GOCOVERDIR=/tmp/coverdir go test [...]                   # use compiler, saving coverage data
+  $ go tool covdata textfmt -i=/tmp/coverdir -o coverage.out # convert to traditional coverage format
+  $ go tool cover -html coverage.out                         # view coverage via traditional tools
+  ```
+
+#### Juggling compiler versions
+
+* Many of the compiler tests use the version of the `go` command found in your PATH and
+  its corresponding `compile` binary.
+
+* If you are in a branch and your PATH includes `<go-repo>/bin`,
+  doing `go install cmd/compile` will build the compiler using the code from your
+  branch and install it to the proper location so that subsequent `go` commands
+  like `go build` or `go test ./...` will exercise your freshly built compiler.
+
+* [toolstash](https://pkg.go.dev/golang.org/x/tools/cmd/toolstash) provides a way
+  to save, run, and restore a known good copy of the Go toolchain. For example, it can be
+  a good practice to initially build your branch, save that version of
+  the toolchain, then restore the known good version of the tools to compile
+  your work-in-progress version of the compiler.
+
+  Sample set up steps:
+  ```
+  $ go install golang.org/x/tools/cmd/toolstash@latest
+  $ git clone https://go.googlesource.com/go
+  $ export PATH=$PWD/go/bin:$PATH
+  $ cd go/src
+  $ git checkout -b mybranch
+  $ ./all.bash                      # build and confirm good starting point
+  $ toolstash save                  # save current tools
+  ```
+  After that, your edit/compile/test cycle can be similar to:
+  ```
+  [... make edits to cmd/compile source ...]
+  $ toolstash restore && go install cmd/compile   # restore known good tools to build compiler
+  [... 'go build', 'go test', etc. ...]           # use freshly built compiler
+  ```
+
+* toolstash also allows comparing the installed vs. stashed copy of
+  the compiler, such as if you expect equivalent behavior after a refactor.
+  For example, to check that your changed compiler produces identical object files to
+  the stashed compiler while building the standard library:
+  ```
+  $ toolstash restore && go install cmd/compile   # build latest compiler
+  $ go build -toolexec "toolstash -cmp" -a -v std # compare latest vs. saved compiler
+  ```
+
+* If versions appear to get out of sync (for example, with errors like
+  `linked object header mismatch` with version strings like
+  `devel go1.21-db3f952b1f`), you might need to do
+  `toolstash restore && go install cmd/...` to update all the tools under cmd.
+
+#### Additional helpful tools
+
+* [compilebench](https://pkg.go.dev/golang.org/x/tools/cmd/compilebench) benchmarks
+  the speed of the compiler.
+
+* [benchstat](https://pkg.go.dev/golang.org/x/perf/cmd/benchstat) is the standard tool
+  for reporting performance changes resulting from compiler modifications,
+  including whether any improvements are statistically significant:
+  ```
+  $ go test -bench=SomeBenchmarks -count=20 > new.txt   # use new compiler
+  $ toolstash restore                                   # restore old compiler
+  $ go test -bench=SomeBenchmarks -count=20 > old.txt   # use old compiler
+  $ benchstat old.txt new.txt                           # compare old vs. new
+  ```
+
+* [bent](https://pkg.go.dev/golang.org/x/benchmarks/cmd/bent) facilitates running a
+  large set of benchmarks from various community Go projects inside a Docker container.
+
+* [perflock](https://github.com/aclements/perflock) helps obtain more consistent
+  benchmark results, including by manipulating CPU frequency scaling settings on Linux.
+
+* [view-annotated-file](https://github.com/loov/view-annotated-file) (from the community)
+   overlays inlining, bounds check, and escape info back onto the source code.
+
+* [godbolt.org](https://go.godbolt.org) is widely used to examine
+  and share assembly output from many compilers, including the Go compiler. It can also
+  [compare](https://go.godbolt.org/z/5Gs1G4bKG) assembly for different versions of
+  a function or across Go compiler versions, which can be helpful for investigations and
+  bug reports.
+
+#### -gcflags and 'go build' vs. 'go tool compile'
+
+* `-gcflags` is a go command [build flag](https://pkg.go.dev/cmd/go#hdr-Compile_packages_and_dependencies).
+  `go build -gcflags=<args>` passes the supplied `<args>` to the underlying
+  `compile` invocation(s) while still doing everything that the `go build` command
+  normally does (e.g., handling the build cache, modules, and so on). In contrast,
+  `go tool compile <args>` asks the `go` command to invoke `compile <args>` a single time
+  without involving the standard `go build` machinery. In some cases, it can be helpful to have
+  fewer moving parts by doing `go tool compile <args>`, such as if you have a
+  small standalone source file that can be compiled without any assistance from `go build`.
+  In other cases, it is more convenient to pass `-gcflags` to a build command like
+  `go build`, `go test`, or `go install`.
+
+* `-gcflags` by default applies to the packages named on the command line, but can
+  use package patterns such as `-gcflags='all=-m=1 -l'`, or multiple package patterns such as
+  `-gcflags='all=-m=1' -gcflags='fmt=-m=2'`. For details, see the
+  [cmd/go documentation](https://pkg.go.dev/cmd/go#hdr-Compile_packages_and_dependencies).
+
+### Further reading
+
+To dig deeper into how the SSA package works, including its passes and rules,
+head to [cmd/compile/internal/ssa/README.md](internal/ssa/README.md).
+
+Finally, if something in this README or the SSA README is unclear
+or if you have an idea for an improvement, feel free to leave a comment in
+[issue 30074](https://go.dev/issue/30074).

go/src/cmd/compile/abi-internal.md

@@ -0,0 +1,1016 @@
+# Go internal ABI specification
+
+Self-link: [go.dev/s/regabi](https://go.dev/s/regabi)
+
+This document describes Go’s internal application binary interface
+(ABI), known as ABIInternal.
+Go's ABI defines the layout of data in memory and the conventions for
+calling between Go functions.
+This ABI is *unstable* and will change between Go versions.
+If you’re writing assembly code, please instead refer to Go’s
+[assembly documentation](/doc/asm.html), which describes Go’s stable
+ABI, known as ABI0.
+
+All functions defined in Go source follow ABIInternal.
+However, ABIInternal and ABI0 functions are able to call each other
+through transparent *ABI wrappers*, described in the [internal calling
+convention proposal](https://golang.org/design/27539-internal-abi).
+
+Go uses a common ABI design across all architectures.
+We first describe the common ABI, and then cover per-architecture
+specifics.
+
+*Rationale*: For the reasoning behind using a common ABI across
+architectures instead of the platform ABI, see the [register-based Go
+calling convention proposal](https://golang.org/design/40724-register-calling).
+
+## Memory layout
+
+Go's built-in types have the following sizes and alignments.
+Many, though not all, of these sizes are guaranteed by the [language
+specification](/doc/go_spec.html#Size_and_alignment_guarantees).
+Those that aren't guaranteed may change in future versions of Go (for
+example, we've considered changing the alignment of int64 on 32-bit).
+
+| Type                        | 64-bit |       | 32-bit |       |
+|-----------------------------|--------|-------|--------|-------|
+|                             | Size   | Align | Size   | Align |
+| bool, uint8, int8           | 1      | 1     | 1      | 1     |
+| uint16, int16               | 2      | 2     | 2      | 2     |
+| uint32, int32               | 4      | 4     | 4      | 4     |
+| uint64, int64               | 8      | 8     | 8      | 4     |
+| int, uint                   | 8      | 8     | 4      | 4     |
+| float32                     | 4      | 4     | 4      | 4     |
+| float64                     | 8      | 8     | 8      | 4     |
+| complex64                   | 8      | 4     | 8      | 4     |
+| complex128                  | 16     | 8     | 16     | 4     |
+| uintptr, *T, unsafe.Pointer | 8      | 8     | 4      | 4     |
+
+The types `byte` and `rune` are aliases for `uint8` and `int32`,
+respectively, and hence have the same size and alignment as these
+types.
+
+The layout of `map`, `chan`, and `func` types is equivalent to *T.
+
+To describe the layout of the remaining composite types, we first
+define the layout of a *sequence* S of N fields with types
+t<sub>1</sub>, t<sub>2</sub>, ..., t<sub>N</sub>.
+We define the byte offset at which each field begins relative to a
+base address of 0, as well as the size and alignment of the sequence
+as follows:
+
+```
+offset(S, i) = 0  if i = 1
+             = align(offset(S, i-1) + sizeof(t_(i-1)), alignof(t_i))
+alignof(S)   = 1  if N = 0
+             = max(alignof(t_i) | 1 <= i <= N)
+sizeof(S)    = 0  if N = 0
+             = align(offset(S, N) + sizeof(t_N), alignof(S))
+```
+
+Where sizeof(T) and alignof(T) are the size and alignment of type T,
+respectively, and align(x, y) rounds x up to a multiple of y.
+
+The `interface{}` type is a sequence of 1. a pointer to the runtime type
+description for the interface's dynamic type and 2. an `unsafe.Pointer`
+data field.
+Any other interface type (besides the empty interface) is a sequence
+of 1. a pointer to the runtime "itab" that gives the method pointers and
+the type of the data field and 2. an `unsafe.Pointer` data field.
+An interface can be "direct" or "indirect" depending on the dynamic
+type: a direct interface stores the value directly in the data field,
+and an indirect interface stores a pointer to the value in the data
+field.
+An interface can only be direct if the value consists of a single
+pointer word.
+
+An array type `[N]T` is a sequence of N fields of type T.
+
+The slice type `[]T` is a sequence of a `*[cap]T` pointer to the slice
+backing store, an `int` giving the `len` of the slice, and an `int`
+giving the `cap` of the slice.
+
+The `string` type is a sequence of a `*[len]byte` pointer to the
+string backing store, and an `int` giving the `len` of the string.
+
+A struct type `struct { f1 t1; ...; fM tM }` is laid out as the
+sequence t1, ..., tM, tP, where tP is either:
+
+- Type `byte` if sizeof(tM) = 0 and any of sizeof(t*i*) ≠ 0.
+- Empty (size 0 and align 1) otherwise.
+
+The padding byte prevents creating a past-the-end pointer by taking
+the address of the final, empty fN field.
+
+Note that user-written assembly code should generally not depend on Go
+type layout and should instead use the constants defined in
+[`go_asm.h`](/doc/asm.html#data-offsets).
+
+## Function call argument and result passing
+
+Function calls pass arguments and results using a combination of the
+stack and machine registers.
+Each argument or result is passed either entirely in registers or
+entirely on the stack.
+Because access to registers is generally faster than access to the
+stack, arguments and results are preferentially passed in registers.
+However, any argument or result that contains a non-trivial array or
+does not fit entirely in the remaining available registers is passed
+on the stack.
+
+Each architecture defines a sequence of integer registers and a
+sequence of floating-point registers.
+At a high level, arguments and results are recursively broken down
+into values of base types and these base values are assigned to
+registers from these sequences.
+
+Arguments and results can share the same registers, but do not share
+the same stack space.
+Beyond the arguments and results passed on the stack, the caller also
+reserves spill space on the stack for all register-based arguments
+(but does not populate this space).
+
+The receiver, arguments, and results of function or method F are
+assigned to registers or the stack using the following algorithm:
+
+1. Let NI and NFP be the length of integer and floating-point register
+   sequences defined by the architecture.
+   Let I and FP be 0; these are the indexes of the next integer and
+   floating-point register.
+   Let S, the type sequence defining the stack frame, be empty.
+1. If F is a method, assign F’s receiver.
+1. For each argument A of F, assign A.
+1. Add a pointer-alignment field to S. This has size 0 and the same
+   alignment as `uintptr`.
+1. Reset I and FP to 0.
+1. For each result R of F, assign R.
+1. Add a pointer-alignment field to S.
+1. For each register-assigned receiver and argument of F, let T be its
+   type and add T to the stack sequence S.
+   This is the argument's (or receiver's) spill space and will be
+   uninitialized at the call.
+1. Add a pointer-alignment field to S.
+
+Assigning a receiver, argument, or result V of underlying type T works
+as follows:
+
+1. Remember I and FP.
+1. If T has zero size, add T to the stack sequence S and return.
+1. Try to register-assign V.
+1. If step 3 failed, reset I and FP to the values from step 1, add T
+   to the stack sequence S, and assign V to this field in S.
+
+Register-assignment of a value V of underlying type T works as follows:
+
+1. If T is a boolean or integral type that fits in an integer
+   register, assign V to register I and increment I.
+1. If T is an integral type that fits in two integer registers, assign
+   the least significant and most significant halves of V to registers
+   I and I+1, respectively, and increment I by 2
+1. If T is a floating-point type and can be represented without loss
+   of precision in a floating-point register, assign V to register FP
+   and increment FP.
+1. If T is a complex type, recursively register-assign its real and
+   imaginary parts.
+1. If T is a pointer type, map type, channel type, or function type,
+   assign V to register I and increment I.
+1. If T is a string type, interface type, or slice type, recursively
+   register-assign V’s components (2 for strings and interfaces, 3 for
+   slices).
+1. If T is a struct type, recursively register-assign each field of V.
+1. If T is an array type of length 0, do nothing.
+1. If T is an array type of length 1, recursively register-assign its
+   one element.
+1. If T is an array type of length > 1, fail.
+1. If I > NI or FP > NFP, fail.
+1. If any recursive assignment above fails, fail.
+
+The above algorithm produces an assignment of each receiver, argument,
+and result to registers or to a field in the stack sequence.
+The final stack sequence looks like: stack-assigned receiver,
+stack-assigned arguments, pointer-alignment, stack-assigned results,
+pointer-alignment, spill space for each register-assigned argument,
+pointer-alignment.
+The following diagram shows what this stack frame looks like on the
+stack, using the typical convention where address 0 is at the bottom:
+
+    +------------------------------+
+    |             . . .            |
+    | 2nd reg argument spill space |
+    | 1st reg argument spill space |
+    | <pointer-sized alignment>    |
+    |             . . .            |
+    | 2nd stack-assigned result    |
+    | 1st stack-assigned result    |
+    | <pointer-sized alignment>    |
+    |             . . .            |
+    | 2nd stack-assigned argument  |
+    | 1st stack-assigned argument  |
+    | stack-assigned receiver      |
+    +------------------------------+ ↓ lower addresses
+
+To perform a call, the caller reserves space starting at the lowest
+address in its stack frame for the call stack frame, stores arguments
+in the registers and argument stack fields determined by the above
+algorithm, and performs the call.
+At the time of a call, spill space, result stack fields, and result
+registers are left uninitialized.
+Upon return, the callee must have stored results to all result
+registers and result stack fields determined by the above algorithm.
+
+There are no callee-save registers, so a call may overwrite any
+register that doesn’t have a fixed meaning, including argument
+registers.
+
+### Example
+
+Consider the function `func f(a1 uint8, a2 [2]uintptr, a3 uint8) (r1
+struct { x uintptr; y [2]uintptr }, r2 string)` on a 64-bit
+architecture with hypothetical integer registers R0–R9.
+
+On entry, `a1` is assigned to `R0`, `a3` is assigned to `R1` and the
+stack frame is laid out in the following sequence:
+
+    a2      [2]uintptr
+    r1.x    uintptr
+    r1.y    [2]uintptr
+    a1Spill uint8
+    a3Spill uint8
+    _       [6]uint8  // alignment padding
+
+In the stack frame, only the `a2` field is initialized on entry; the
+rest of the frame is left uninitialized.
+
+On exit, `r2.base` is assigned to `R0`, `r2.len` is assigned to `R1`,
+and `r1.x` and `r1.y` are initialized in the stack frame.
+
+There are several things to note in this example.
+First, `a2` and `r1` are stack-assigned because they contain arrays.
+The other arguments and results are register-assigned.
+Result `r2` is decomposed into its components, which are individually
+register-assigned.
+On the stack, the stack-assigned arguments appear at lower addresses
+than the stack-assigned results, which appear at lower addresses than
+the argument spill area.
+Only arguments, not results, are assigned a spill area on the stack.
+
+### Rationale
+
+Each base value is assigned to its own register to optimize
+construction and access.
+An alternative would be to pack multiple sub-word values into
+registers, or to simply map an argument's in-memory layout to
+registers (this is common in C ABIs), but this typically adds cost to
+pack and unpack these values.
+Modern architectures have more than enough registers to pass all
+arguments and results this way for nearly all functions (see the
+appendix), so there’s little downside to spreading base values across
+registers.
+
+Arguments that can’t be fully assigned to registers are passed
+entirely on the stack in case the callee takes the address of that
+argument.
+If an argument could be split across the stack and registers and the
+callee took its address, it would need to be reconstructed in memory,
+a process that would be proportional to the size of the argument.
+
+Non-trivial arrays are always passed on the stack because indexing
+into an array typically requires a computed offset, which generally
+isn’t possible with registers.
+Arrays in general are rare in function signatures (only 0.7% of
+functions in the Go 1.15 standard library and 0.2% in kubelet).
+We considered allowing array fields to be passed on the stack while
+the rest of an argument’s fields are passed in registers, but this
+creates the same problems as other large structs if the callee takes
+the address of an argument, and would benefit <0.1% of functions in
+kubelet (and even these very little).
+
+We make exceptions for 0 and 1-element arrays because these don’t
+require computed offsets, and 1-element arrays are already decomposed
+in the compiler’s SSA representation.
+
+The ABI assignment algorithm above is equivalent to Go’s stack-based
+ABI0 calling convention if there are zero architecture registers.
+This is intended to ease the transition to the register-based internal
+ABI and make it easy for the compiler to generate either calling
+convention.
+An architecture may still define register meanings that aren’t
+compatible with ABI0, but these differences should be easy to account
+for in the compiler.
+
+The assignment algorithm assigns zero-sized values to the stack
+(assignment step 2) in order to support ABI0-equivalence.
+While these values take no space themselves, they do result in
+alignment padding on the stack in ABI0.
+Without this step, the internal ABI would register-assign zero-sized
+values even on architectures that provide no argument registers
+because they don't consume any registers, and hence not add alignment
+padding to the stack.
+
+The algorithm reserves spill space for arguments in the caller’s frame
+so that the compiler can generate a stack growth path that spills into
+this reserved space.
+If the callee has to grow the stack, it may not be able to reserve
+enough additional stack space in its own frame to spill these, which
+is why it’s important that the caller do so.
+These slots also act as the home location if these arguments need to
+be spilled for any other reason, which simplifies traceback printing.
+
+There are several options for how to lay out the argument spill space.
+We chose to lay out each argument according to its type's usual memory
+layout but to separate the spill space from the regular argument
+space.
+Using the usual memory layout simplifies the compiler because it
+already understands this layout.
+Also, if a function takes the address of a register-assigned argument,
+the compiler must spill that argument to memory in its usual memory
+layout and it's more convenient to use the argument spill space for
+this purpose.
+
+Alternatively, the spill space could be structured around argument
+registers.
+In this approach, the stack growth spill path would spill each
+argument register to a register-sized stack word.
+However, if the function takes the address of a register-assigned
+argument, the compiler would have to reconstruct it in memory layout
+elsewhere on the stack.
+
+The spill space could also be interleaved with the stack-assigned
+arguments so the arguments appear in order whether they are register-
+or stack-assigned.
+This would be close to ABI0, except that register-assigned arguments
+would be uninitialized on the stack and there's no need to reserve
+stack space for register-assigned results.
+We expect separating the spill space to perform better because of
+memory locality.
+Separating the space is also potentially simpler for `reflect` calls
+because this allows `reflect` to summarize the spill space as a single
+number.
+Finally, the long-term intent is to remove reserved spill slots
+entirely – allowing most functions to be called without any stack
+setup and easing the introduction of callee-save registers – and
+separating the spill space makes that transition easier.
+
+## Closures
+
+A func value (e.g., `var x func()`) is a pointer to a closure object.
+A closure object begins with a pointer-sized program counter
+representing the entry point of the function, followed by zero or more
+bytes containing the closed-over environment.
+
+Closure calls follow the same conventions as static function and
+method calls, with one addition. Each architecture specifies a
+*closure context pointer* register and calls to closures store the
+address of the closure object in the closure context pointer register
+prior to the call.
+
+## Software floating-point mode
+
+In "softfloat" mode, the ABI simply treats the hardware as having zero
+floating-point registers.
+As a result, any arguments containing floating-point values will be
+passed on the stack.
+
+*Rationale*: Softfloat mode is about compatibility over performance
+and is not commonly used.
+Hence, we keep the ABI as simple as possible in this case, rather than
+adding additional rules for passing floating-point values in integer
+registers.
+
+## Architecture specifics
+
+This section describes per-architecture register mappings, as well as
+other per-architecture special cases.
+
+### amd64 architecture
+
+The amd64 architecture uses the following sequence of 9 registers for
+integer arguments and results:
+
+    RAX, RBX, RCX, RDI, RSI, R8, R9, R10, R11
+
+It uses X0 – X14 for floating-point arguments and results.
+
+*Rationale*: These sequences are chosen from the available registers
+to be relatively easy to remember.
+
+Registers R12 and R13 are permanent scratch registers.
+R15 is a scratch register except in dynamically linked binaries.
+
+*Rationale*: Some operations such as stack growth and reflection calls
+need dedicated scratch registers in order to manipulate call frames
+without corrupting arguments or results.
+
+Special-purpose registers are as follows:
+
+| Register | Call meaning | Return meaning | Body meaning |
+| --- | --- | --- | --- |
+| RSP | Stack pointer | Same | Same |
+| RBP | Frame pointer | Same | Same |
+| RDX | Closure context pointer | Scratch | Scratch |
+| R12 | Scratch | Scratch | Scratch |
+| R13 | Scratch | Scratch | Scratch |
+| R14 | Current goroutine | Same | Same |
+| R15 | GOT reference temporary if dynlink | Same | Same |
+| X15 | Zero value (*) | Same | Scratch |
+
+(*) Except on Plan 9, where X15 is a scratch register because SSE
+registers cannot be used in note handlers (so the compiler avoids
+using them except when absolutely necessary).
+
+*Rationale*: These register meanings are compatible with Go’s
+stack-based calling convention except for R14 and X15, which will have
+to be restored on transitions from ABI0 code to ABIInternal code.
+In ABI0, these are undefined, so transitions from ABIInternal to ABI0
+can ignore these registers.
+
+*Rationale*: For the current goroutine pointer, we chose a register
+that requires an additional REX byte.
+While this adds one byte to every function prologue, it is hardly ever
+accessed outside the function prologue and we expect making more
+single-byte registers available to be a net win.
+
+*Rationale*: We could allow R14 (the current goroutine pointer) to be
+a scratch register in function bodies because it can always be
+restored from TLS on amd64.
+However, we designate it as a fixed register for simplicity and for
+consistency with other architectures that may not have a copy of the
+current goroutine pointer in TLS.
+
+*Rationale*: We designate X15 as a fixed zero register because
+functions often have to bulk zero their stack frames, and this is more
+efficient with a designated zero register.
+
+*Implementation note*: Registers with fixed meaning at calls but not
+in function bodies must be initialized by "injected" calls such as
+signal-based panics.
+
+#### Stack layout
+
+The stack pointer, RSP, grows down and is always aligned to 8 bytes.
+
+The amd64 architecture does not use a link register.
+
+A function's stack frame is laid out as follows:
+
+    +------------------------------+
+    | return PC                    |
+    | RBP on entry                 |
+    | ... locals ...               |
+    | ... outgoing arguments ...   |
+    +------------------------------+ ↓ lower addresses
+
+The "return PC" is pushed as part of the standard amd64 `CALL`
+operation.
+On entry, a function subtracts from RSP to open its stack frame and
+saves the value of RBP directly below the return PC.
+A leaf function that does not require any stack space may omit the
+saved RBP.
+
+The Go ABI's use of RBP as a frame pointer register is compatible with
+amd64 platform conventions so that Go can inter-operate with platform
+debuggers and profilers.
+
+#### Flags
+
+The direction flag (D) is always cleared (set to the “forward”
+direction) at a call.
+The arithmetic status flags are treated like scratch registers and not
+preserved across calls.
+All other bits in RFLAGS are system flags.
+
+At function calls and returns, the CPU is in x87 mode (not MMX
+technology mode).
+
+*Rationale*: Go on amd64 does not use either the x87 registers or MMX
+registers. Hence, we follow the SysV platform conventions in order to
+simplify transitions to and from the C ABI.
+
+At calls, the MXCSR control bits are always set as follows:
+
+| Flag | Bit | Value | Meaning |
+| --- | --- | --- | --- |
+| FZ | 15 | 0 | Do not flush to zero |
+| RC | 14/13 | 0 (RN) | Round to nearest |
+| PM | 12 | 1 | Precision masked |
+| UM | 11 | 1 | Underflow masked |
+| OM | 10 | 1 | Overflow masked |
+| ZM | 9 | 1 | Divide-by-zero masked |
+| DM | 8 | 1 | Denormal operations masked |
+| IM | 7 | 1 | Invalid operations masked |
+| DAZ | 6 | 0 | Do not zero de-normals |
+
+The MXCSR status bits are callee-save.
+
+*Rationale*: Having a fixed MXCSR control configuration allows Go
+functions to use SSE operations without modifying or saving the MXCSR.
+Functions are allowed to modify it between calls (as long as they
+restore it), but as of this writing Go code never does.
+The above fixed configuration matches the process initialization
+control bits specified by the ELF AMD64 ABI.
+
+The x87 floating-point control word is not used by Go on amd64.
+
+### arm64 architecture
+
+The arm64 architecture uses R0 – R15 for integer arguments and results.
+
+It uses F0 – F15 for floating-point arguments and results.
+
+*Rationale*: 16 integer registers and 16 floating-point registers are
+more than enough for passing arguments and results for practically all
+functions (see Appendix). While there are more registers available,
+using more registers provides little benefit. Additionally, it will add
+overhead on code paths where the number of arguments are not statically
+known (e.g. reflect call), and will consume more stack space when there
+is only limited stack space available to fit in the nosplit limit.
+
+Registers R16 and R17 are permanent scratch registers. They are also
+used as scratch registers by the linker (Go linker and external
+linker) in trampolines.
+
+Register R18 is reserved and never used. It is reserved for the OS
+on some platforms (e.g. macOS).
+
+Registers R19 – R25 are permanent scratch registers. In addition,
+R27 is a permanent scratch register used by the assembler when
+expanding instructions.
+
+Floating-point registers F16 – F31 are also permanent scratch
+registers.
+
+Special-purpose registers are as follows:
+
+| Register | Call meaning | Return meaning | Body meaning |
+| --- | --- | --- | --- |
+| RSP | Stack pointer | Same | Same |
+| R30 | Link register | Same | Scratch (non-leaf functions) |
+| R29 | Frame pointer | Same | Same |
+| R28 | Current goroutine | Same | Same |
+| R27 | Scratch | Scratch | Scratch |
+| R26 | Closure context pointer | Scratch | Scratch |
+| R18 | Reserved (not used) | Same | Same |
+| ZR  | Zero value | Same | Same |
+
+*Rationale*: These register meanings are compatible with Go’s
+stack-based calling convention.
+
+*Rationale*: The link register, R30, holds the function return
+address at the function entry. For functions that have frames
+(including most non-leaf functions), R30 is saved to stack in the
+function prologue and restored in the epilogue. Within the function
+body, R30 can be used as a scratch register.
+
+*Implementation note*: Registers with fixed meaning at calls but not
+in function bodies must be initialized by "injected" calls such as
+signal-based panics.
+
+#### Stack layout
+
+The stack pointer, RSP, grows down and is always aligned to 16 bytes.
+
+*Rationale*: The arm64 architecture requires the stack pointer to be
+16-byte aligned.
+
+A function's stack frame, after the frame is created, is laid out as
+follows:
+
+    +------------------------------+
+    | ... locals ...               |
+    | ... outgoing arguments ...   |
+    | return PC                    | ← RSP points to
+    | frame pointer on entry       |
+    +------------------------------+ ↓ lower addresses
+
+The "return PC" is loaded to the link register, R30, as part of the
+arm64 `CALL` operation.
+
+On entry, a function subtracts from RSP to open its stack frame, and
+saves the values of R30 and R29 at the bottom of the frame.
+Specifically, R30 is saved at 0(RSP) and R29 is saved at -8(RSP),
+after RSP is updated.
+
+A leaf function that does not require any stack space may omit the
+saved R30 and R29.
+
+The Go ABI's use of R29 as a frame pointer register is compatible with
+arm64 architecture requirement so that Go can inter-operate with platform
+debuggers and profilers.
+
+This stack layout is used by both register-based (ABIInternal) and
+stack-based (ABI0) calling conventions.
+
+#### Flags
+
+The arithmetic status flags (NZCV) are treated like scratch registers
+and not preserved across calls.
+All other bits in PSTATE are system flags and are not modified by Go.
+
+The floating-point status register (FPSR) is treated like scratch
+registers and not preserved across calls.
+
+At calls, the floating-point control register (FPCR) bits are always
+set as follows:
+
+| Flag | Bit | Value | Meaning |
+| --- | --- | --- | --- |
+| DN  | 25 | 0 | Propagate NaN operands |
+| FZ  | 24 | 0 | Do not flush to zero |
+| RC  | 23/22 | 0 (RN) | Round to nearest, choose even if tied |
+| IDE | 15 | 0 | Denormal operations trap disabled |
+| IXE | 12 | 0 | Inexact trap disabled |
+| UFE | 11 | 0 | Underflow trap disabled |
+| OFE | 10 | 0 | Overflow trap disabled |
+| DZE | 9 | 0 | Divide-by-zero trap disabled |
+| IOE | 8 | 0 | Invalid operations trap disabled |
+| NEP | 2 | 0 | Scalar operations do not affect higher elements in vector registers |
+| AH  | 1 | 0 | No alternate handling of de-normal inputs |
+| FIZ | 0 | 0 | Do not zero de-normals |
+
+*Rationale*: Having a fixed FPCR control configuration allows Go
+functions to use floating-point and vector (SIMD) operations without
+modifying or saving the FPCR.
+Functions are allowed to modify it between calls (as long as they
+restore it), but as of this writing Go code never does.
+
+### loong64 architecture
+
+The loong64 architecture uses R4 – R19 for integer arguments and integer results.
+
+It uses F0 – F15 for floating-point arguments and results.
+
+Registers R20 - R21, R23 – R28, R30 - R31, F16 – F31 are permanent scratch registers.
+
+Register R2 is reserved and never used.
+
+Register R20, R21 is Used by runtime.duffcopy, runtime.duffzero.
+
+Special-purpose registers used within Go generated code and Go assembly code
+are as follows:
+
+| Register | Call meaning | Return meaning | Body meaning |
+| --- | --- | --- | --- |
+| R0 | Zero value | Same | Same |
+| R1 | Link register | Link register | Scratch |
+| R3 | Stack pointer | Same | Same |
+| R20,R21 | Scratch | Scratch | Used by duffcopy, duffzero |
+| R22 | Current goroutine | Same | Same |
+| R29 | Closure context pointer | Same | Same |
+| R30, R31 | used by the assembler | Same | Same |
+
+*Rationale*: These register meanings are compatible with Go’s stack-based
+calling convention.
+
+#### Stack layout
+
+The stack pointer, R3, grows down and is aligned to 8 bytes.
+
+A function's stack frame, after the frame is created, is laid out as
+follows:
+
+    +------------------------------+
+    | ... locals ...               |
+    | ... outgoing arguments ...   |
+    | return PC                    | ← R3 points to
+    +------------------------------+ ↓ lower addresses
+
+This stack layout is used by both register-based (ABIInternal) and
+stack-based (ABI0) calling conventions.
+
+The "return PC" is loaded to the link register, R1, as part of the
+loong64 `JAL` operation.
+
+#### Flags
+All bits in CSR are system flags and are not modified by Go.
+
+### ppc64 architecture
+
+The ppc64 architecture uses R3 – R10 and R14 – R17 for integer arguments
+and results.
+
+It uses F1 – F12 for floating-point arguments and results.
+
+Register R31 is a permanent scratch register in Go.
+
+Special-purpose registers used within Go generated code and Go
+assembly code are as follows:
+
+| Register | Call meaning | Return meaning | Body meaning |
+| --- | --- | --- | --- |
+| R0  | Zero value | Same | Same |
+| R1  | Stack pointer | Same | Same |
+| R2  | TOC register | Same | Same |
+| R11 | Closure context pointer | Scratch | Scratch |
+| R12 | Function address on indirect calls | Scratch | Scratch |
+| R13 | TLS pointer | Same | Same |
+| R20,R21 | Scratch | Scratch | Used by duffcopy, duffzero |
+| R30 | Current goroutine | Same | Same |
+| R31 | Scratch | Scratch | Scratch |
+| LR  | Link register | Link register | Scratch |
+*Rationale*: These register meanings are compatible with Go’s
+stack-based calling convention.
+
+The link register, LR, holds the function return
+address at the function entry and is set to the correct return
+address before exiting the function. It is also used
+in some cases as the function address when doing an indirect call.
+
+The register R2 contains the address of the TOC (table of contents) which
+contains data or code addresses used when generating position independent
+code. Non-Go code generated when using cgo contains TOC-relative addresses
+which depend on R2 holding a valid TOC. Go code compiled with -shared or
+-dynlink initializes and maintains R2 and uses it in some cases for
+function calls; Go code compiled without these options does not modify R2.
+
+When making a function call R12 contains the function address for use by the
+code to generate R2 at the beginning of the function. R12 can be used for
+other purposes within the body of the function, such as trampoline generation.
+
+R20 and R21 are used in duffcopy and duffzero which could be generated
+before arguments are saved so should not be used for register arguments.
+
+The Count register CTR can be used as the call target for some branch instructions.
+It holds the return address when preemption has occurred.
+
+On PPC64 when a float32 is loaded it becomes a float64 in the register, which is
+different from other platforms and that needs to be recognized by the internal
+implementation of reflection so that float32 arguments are passed correctly.
+
+Registers R18 - R29 and F13 - F31 are considered scratch registers.
+
+#### Stack layout
+
+The stack pointer, R1, grows down and is aligned to 8 bytes in Go, but changed
+to 16 bytes when calling cgo.
+
+A function's stack frame, after the frame is created, is laid out as
+follows:
+
+    +------------------------------+
+    | ... locals ...               |
+    | ... outgoing arguments ...   |
+    | 24  TOC register R2 save     | When compiled with -shared/-dynlink
+    | 16  Unused in Go             | Not used in Go
+    |  8  CR save                  | nonvolatile CR fields
+    |  0  return PC                | ← R1 points to
+    +------------------------------+ ↓ lower addresses
+
+The "return PC" is loaded to the link register, LR, as part of the
+ppc64 `BL` operations.
+
+On entry to a non-leaf function, the stack frame size is subtracted from R1 to
+create its stack frame, and saves the value of LR at the bottom of the frame.
+
+A leaf function that does not require any stack space does not modify R1 and
+does not save LR.
+
+*NOTE*: We might need to save the frame pointer on the stack as
+in the PPC64 ELF v2 ABI so Go can inter-operate with platform debuggers
+and profilers.
+
+This stack layout is used by both register-based (ABIInternal) and
+stack-based (ABI0) calling conventions.
+
+#### Flags
+
+The condition register consists of 8 condition code register fields
+CR0-CR7. Go generated code only sets and uses CR0, commonly set by
+compare functions and use to determine the target of a conditional
+branch. The generated code does not set or use CR1-CR7.
+
+The floating point status and control register (FPSCR) is initialized
+to 0 by the kernel at startup of the Go program and not changed by
+the Go generated code.
+
+### riscv64 architecture
+
+The riscv64 architecture uses X10 – X17, X8, X9, X18 – X23 for integer arguments
+and results.
+
+It uses F10 – F17, F8, F9, F18 – F23 for floating-point arguments and results.
+
+Special-purpose registers used within Go generated code and Go
+assembly code are as follows:
+
+| Register | Call meaning | Return meaning | Body meaning |
+| --- | --- | --- | --- |
+| X0  | Zero value | Same | Same |
+| X1  | Link register | Link register | Scratch |
+| X2  | Stack pointer | Same | Same |
+| X3  | Global pointer | Same | Used by dynamic linker |
+| X4  | TLS (thread pointer) | TLS | Scratch |
+| X26 | Closure context pointer | Scratch | Scratch |
+| X27 | Current goroutine | Same | Same |
+| X31 | Scratch | Scratch | Scratch |
+
+*Rationale*: These register meanings are compatible with Go’s
+stack-based calling convention.
+X10 – X17, X8, X9, X18 – X23, is the same order as A0 – A7, S0 – S7 in platform ABI.
+F10 – F17, F8, F9, F18 – F23, is the same order as FA0 – FA7, FS0 – FS7 in platform ABI.
+X8 – X23, F8 – F15 are used for compressed instruction (RVC) which benefits code size.
+
+#### Stack layout
+
+The stack pointer, X2, grows down and is aligned to 8 bytes.
+
+A function's stack frame, after the frame is created, is laid out as
+follows:
+
+    +------------------------------+
+    | ... locals ...               |
+    | ... outgoing arguments ...   |
+    | return PC                    | ← X2 points to
+    +------------------------------+ ↓ lower addresses
+
+The "return PC" is loaded to the link register, X1, as part of the
+riscv64 `CALL` operation.
+
+#### Flags
+
+The riscv64 has Zicsr extension for control and status register (CSR) and
+treated as scratch register.
+All bits in CSR are system flags and are not modified by Go.
+
+### s390x architecture
+
+The s390x architecture uses R2 – R9 for integer arguments and integer results.
+
+It uses F0 – F15 for floating-point arguments and results.
+
+Special-purpose registers used within Go generated code and Go assembly code
+are as follows:
+
+| Register | Call meaning | Return meaning | Body meaning |
+| --- | --- | --- | --- |
+| R0 | Zero value | Same | Same |
+| R1 | Scratch | Scratch | Scratch |
+| R10, R11 | used by the assembler | Same | Same |
+| R12 | Closure context pointer | Same | Same |
+| R13 | Current goroutine | Same | Same |
+| R14 | Link register | Link register | Scratch |
+| R15 | Stack pointer | Same | Same |
+
+*Rationale*: These register meanings are compatible with Go’s stack-based
+calling convention.
+
+#### Stack layout
+
+The stack pointer, R15, grows down and is aligned to 8 bytes.
+
+A function's stack frame, after the frame is created, is laid out as
+follows:
+
+    +------------------------------+
+    | ... locals ...               |
+    | ... outgoing arguments ...   |
+    | return PC                    | ← R15 points to
+    +------------------------------+ ↓ lower addresses
+
+This stack layout is used by both register-based (ABIInternal) and
+stack-based (ABI0) calling conventions.
+
+The "return PC" is loaded to the link register R14, as part of the
+s390x `BL` operation.
+
+#### Flags
+The s390x architecture maintains a single condition code (CC) field in the Program Status Word (PSW).
+Go-generated code sets and tests this condition code to control conditional branches.
+
+## Future directions
+
+### Spill path improvements
+
+The ABI currently reserves spill space for argument registers so the
+compiler can statically generate an argument spill path before calling
+into `runtime.morestack` to grow the stack.
+This ensures there will be sufficient spill space even when the stack
+is nearly exhausted and keeps stack growth and stack scanning
+essentially unchanged from ABI0.
+
+However, this wastes stack space (the median wastage is 16 bytes per
+call), resulting in larger stacks and increased cache footprint.
+A better approach would be to reserve stack space only when spilling.
+One way to ensure enough space is available to spill would be for
+every function to ensure there is enough space for the function's own
+frame *as well as* the spill space of all functions it calls.
+For most functions, this would change the threshold for the prologue
+stack growth check.
+For `nosplit` functions, this would change the threshold used in the
+linker's static stack size check.
+
+Allocating spill space in the callee rather than the caller may also
+allow for faster reflection calls in the common case where a function
+takes only register arguments, since it would allow reflection to make
+these calls directly without allocating any frame.
+
+The statically-generated spill path also increases code size.
+It is possible to instead have a generic spill path in the runtime, as
+part of `morestack`.
+However, this complicates reserving the spill space, since spilling
+all possible register arguments would, in most cases, take
+significantly more space than spilling only those used by a particular
+function.
+Some options are to spill to a temporary space and copy back only the
+registers used by the function, or to grow the stack if necessary
+before spilling to it (using a temporary space if necessary), or to
+use a heap-allocated space if insufficient stack space is available.
+These options all add enough complexity that we will have to make this
+decision based on the actual code size growth caused by the static
+spill paths.
+
+### Clobber sets
+
+As defined, the ABI does not use callee-save registers.
+This significantly simplifies the garbage collector and the compiler's
+register allocator, but at some performance cost.
+A potentially better balance for Go code would be to use *clobber
+sets*: for each function, the compiler records the set of registers it
+clobbers (including those clobbered by functions it calls) and any
+register not clobbered by function F can remain live across calls to
+F.
+
+This is generally a good fit for Go because Go's package DAG allows
+function metadata like the clobber set to flow up the call graph, even
+across package boundaries.
+Clobber sets would require relatively little change to the garbage
+collector, unlike general callee-save registers.
+One disadvantage of clobber sets over callee-save registers is that
+they don't help with indirect function calls or interface method
+calls, since static information isn't available in these cases.
+
+### Large aggregates
+
+Go encourages passing composite values by value, and this simplifies
+reasoning about mutation and races.
+However, this comes at a performance cost for large composite values.
+It may be possible to instead transparently pass large composite
+values by reference and delay copying until it is actually necessary.
+
+## Appendix: Register usage analysis
+
+In order to understand the impacts of the above design on register
+usage, we
+[analyzed](https://github.com/aclements/go-misc/tree/master/abi) the
+impact of the above ABI on a large code base: cmd/kubelet from
+[Kubernetes](https://github.com/kubernetes/kubernetes) at tag v1.18.8.
+
+The following table shows the impact of different numbers of available
+integer and floating-point registers on argument assignment:
+
+```
+|      |        |       |      stack args |          spills |     stack total |
+| ints | floats | % fit | p50 | p95 | p99 | p50 | p95 | p99 | p50 | p95 | p99 |
+|    0 |      0 |  6.3% |  32 | 152 | 256 |   0 |   0 |   0 |  32 | 152 | 256 |
+|    0 |      8 |  6.4% |  32 | 152 | 256 |   0 |   0 |   0 |  32 | 152 | 256 |
+|    1 |      8 | 21.3% |  24 | 144 | 248 |   8 |   8 |   8 |  32 | 152 | 256 |
+|    2 |      8 | 38.9% |  16 | 128 | 224 |   8 |  16 |  16 |  24 | 136 | 240 |
+|    3 |      8 | 57.0% |   0 | 120 | 224 |  16 |  24 |  24 |  24 | 136 | 240 |
+|    4 |      8 | 73.0% |   0 | 120 | 216 |  16 |  32 |  32 |  24 | 136 | 232 |
+|    5 |      8 | 83.3% |   0 | 112 | 216 |  16 |  40 |  40 |  24 | 136 | 232 |
+|    6 |      8 | 87.5% |   0 | 112 | 208 |  16 |  48 |  48 |  24 | 136 | 232 |
+|    7 |      8 | 89.8% |   0 | 112 | 208 |  16 |  48 |  56 |  24 | 136 | 232 |
+|    8 |      8 | 91.3% |   0 | 112 | 200 |  16 |  56 |  64 |  24 | 136 | 232 |
+|    9 |      8 | 92.1% |   0 | 112 | 192 |  16 |  56 |  72 |  24 | 136 | 232 |
+|   10 |      8 | 92.6% |   0 | 104 | 192 |  16 |  56 |  72 |  24 | 136 | 232 |
+|   11 |      8 | 93.1% |   0 | 104 | 184 |  16 |  56 |  80 |  24 | 128 | 232 |
+|   12 |      8 | 93.4% |   0 | 104 | 176 |  16 |  56 |  88 |  24 | 128 | 232 |
+|   13 |      8 | 94.0% |   0 |  88 | 176 |  16 |  56 |  96 |  24 | 128 | 232 |
+|   14 |      8 | 94.4% |   0 |  80 | 152 |  16 |  64 | 104 |  24 | 128 | 232 |
+|   15 |      8 | 94.6% |   0 |  80 | 152 |  16 |  64 | 112 |  24 | 128 | 232 |
+|   16 |      8 | 94.9% |   0 |  16 | 152 |  16 |  64 | 112 |  24 | 128 | 232 |
+|    ∞ |      8 | 99.8% |   0 |   0 |   0 |  24 | 112 | 216 |  24 | 120 | 216 |
+```
+
+The first two columns show the number of available integer and
+floating-point registers.
+The first row shows the results for 0 integer and 0 floating-point
+registers, which is equivalent to ABI0.
+We found that any reasonable number of floating-point registers has
+the same effect, so we fixed it at 8 for all other rows.
+
+The “% fit” column gives the fraction of functions where all arguments
+and results are register-assigned and no arguments are passed on the
+stack.
+The three “stack args” columns give the median, 95th and 99th
+percentile number of bytes of stack arguments.
+The “spills” columns likewise summarize the number of bytes in
+on-stack spill space.
+And “stack total” summarizes the sum of stack arguments and on-stack
+spill slots.
+Note that these are three different distributions; for example,
+there’s no single function that takes 0 stack argument bytes, 16 spill
+bytes, and 24 total stack bytes.
+
+From this, we can see that the fraction of functions that fit entirely
+in registers grows very slowly once it reaches about 90%, though
+curiously there is a small minority of functions that could benefit
+from a huge number of registers.
+Making 9 integer registers available on amd64 puts it in this realm.
+We also see that the stack space required for most functions is fairly
+small.
+While the increasing space required for spills largely balances out
+the decreasing space required for stack arguments as the number of
+available registers increases, there is a general reduction in the
+total stack space required with more available registers.
+This does, however, suggest that eliminating spill slots in the future
+would noticeably reduce stack requirements.

go/src/cmd/compile/doc.go

@@ -0,0 +1,360 @@
+// Copyright 2009 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.
+
+/*
+Compile, typically invoked as ``go tool compile,'' compiles a single Go package
+comprising the files named on the command line. It then writes a single
+object file named for the basename of the first source file with a .o suffix.
+The object file can then be combined with other objects into a package archive
+or passed directly to the linker (``go tool link''). If invoked with -pack, the compiler
+writes an archive directly, bypassing the intermediate object file.
+
+The generated files contain type information about the symbols exported by
+the package and about types used by symbols imported by the package from
+other packages. It is therefore not necessary when compiling client C of
+package P to read the files of P's dependencies, only the compiled output of P.
+
+# Command Line
+
+Usage:
+
+	go tool compile [flags] file...
+
+The specified files must be Go source files and all part of the same package.
+The same compiler is used for all target operating systems and architectures.
+The GOOS and GOARCH environment variables set the desired target.
+
+Flags:
+
+	-D path
+		Set relative path for local imports.
+	-I dir1 -I dir2
+		Search for imported packages in dir1, dir2, etc,
+		after consulting $GOROOT/pkg/$GOOS_$GOARCH.
+	-L
+		Show complete file path in error messages.
+	-N
+		Disable optimizations.
+	-S
+		Print assembly listing to standard output (code only).
+	-S -S
+		Print assembly listing to standard output (code and data).
+	-V
+		Print compiler version and exit.
+	-asmhdr file
+		Write assembly header to file.
+	-asan
+		Insert calls to C/C++ address sanitizer.
+	-buildid id
+		Record id as the build id in the export metadata.
+	-blockprofile file
+		Write block profile for the compilation to file.
+	-c int
+		Concurrency during compilation. Set 1 for no concurrency (default is 1).
+	-complete
+		Assume package has no non-Go components.
+	-cpuprofile file
+		Write a CPU profile for the compilation to file.
+	-dynlink
+		Allow references to Go symbols in shared libraries (experimental).
+	-e
+		Remove the limit on the number of errors reported (default limit is 10).
+	-embedcfg file
+		Read go:embed configuration from file.
+		This is required if any //go:embed directives are used.
+		The file is a JSON file mapping patterns to lists of filenames
+		and filenames to full path names.
+	-goversion string
+		Specify required go tool version of the runtime.
+		Exits when the runtime go version does not match goversion.
+	-h
+		Halt with a stack trace at the first error detected.
+	-importcfg file
+		Read import configuration from file.
+		In the file, set importmap, packagefile to specify import resolution.
+	-installsuffix suffix
+		Look for packages in $GOROOT/pkg/$GOOS_$GOARCH_suffix
+		instead of $GOROOT/pkg/$GOOS_$GOARCH.
+	-l
+		Disable inlining.
+	-lang version
+		Set language version to compile, as in -lang=go1.12.
+		Default is current version.
+	-linkobj file
+		Write linker-specific object to file and compiler-specific
+		object to usual output file (as specified by -o).
+		Without this flag, the -o output is a combination of both
+		linker and compiler input.
+	-m
+		Print optimization decisions. Higher values or repetition
+		produce more detail.
+	-memprofile file
+		Write memory profile for the compilation to file.
+	-memprofilerate rate
+		Set runtime.MemProfileRate for the compilation to rate.
+	-msan
+		Insert calls to C/C++ memory sanitizer.
+	-mutexprofile file
+		Write mutex profile for the compilation to file.
+	-nolocalimports
+		Disallow local (relative) imports.
+	-o file
+		Write object to file (default file.o or, with -pack, file.a).
+	-p path
+		Set expected package import path for the code being compiled,
+		and diagnose imports that would cause a circular dependency.
+	-pack
+		Write a package (archive) file rather than an object file
+	-race
+		Compile with race detector enabled.
+	-s
+		Warn about composite literals that can be simplified.
+	-shared
+		Generate code that can be linked into a shared library.
+	-spectre list
+		Enable spectre mitigations in list (all, index, ret).
+	-traceprofile file
+		Write an execution trace to file.
+	-trimpath prefix
+		Remove prefix from recorded source file paths.
+
+Flags related to debugging information:
+
+	-dwarf
+		Generate DWARF symbols.
+	-dwarflocationlists
+		Add location lists to DWARF in optimized mode.
+	-gendwarfinl int
+		Generate DWARF inline info records (default 2).
+
+Flags to debug the compiler itself:
+
+	-E
+		Debug symbol export.
+	-K
+		Debug missing line numbers.
+	-d list
+		Print debug information about items in list. Try -d help for further information.
+	-live
+		Debug liveness analysis.
+	-v
+		Increase debug verbosity.
+	-%
+		Debug non-static initializers.
+	-W
+		Debug parse tree after type checking.
+	-f
+		Debug stack frames.
+	-i
+		Debug line number stack.
+	-j
+		Debug runtime-initialized variables.
+	-r
+		Debug generated wrappers.
+	-w
+		Debug type checking.
+
+# Compiler Directives
+
+The compiler accepts directives in the form of comments.
+Each directive must be placed its own line, with only leading spaces and tabs
+allowed before the comment, and there must be no space between the comment
+opening and the name of the directive, to distinguish it from a regular comment.
+Tools unaware of the directive convention or of a particular
+directive can skip over a directive like any other comment.
+
+Other than the line directive, which is a historical special case;
+all other compiler directives are of the form
+//go:name, indicating that they are defined by the Go toolchain.
+*/
+// # Line Directives
+//
+// Line directives come in several forms:
+//
+// 	//line :line
+// 	//line :line:col
+// 	//line filename:line
+// 	//line filename:line:col
+// 	/*line :line*/
+// 	/*line :line:col*/
+// 	/*line filename:line*/
+// 	/*line filename:line:col*/
+//
+// In order to be recognized as a line directive, the comment must start with
+// //line or /*line followed by a space, and must contain at least one colon.
+// The //line form must start at the beginning of a line.
+// A line directive specifies the source position for the character immediately following
+// the comment as having come from the specified file, line and column:
+// For a //line comment, this is the first character of the next line, and
+// for a /*line comment this is the character position immediately following the closing */.
+// If no filename is given, the recorded filename is empty if there is also no column number;
+// otherwise it is the most recently recorded filename (actual filename or filename specified
+// by previous line directive).
+// If a line directive doesn't specify a column number, the column is "unknown" until
+// the next directive and the compiler does not report column numbers for that range.
+// The line directive text is interpreted from the back: First the trailing :ddd is peeled
+// off from the directive text if ddd is a valid number > 0. Then the second :ddd
+// is peeled off the same way if it is valid. Anything before that is considered the filename
+// (possibly including blanks and colons). Invalid line or column values are reported as errors.
+//
+// Examples:
+//
+//	//line foo.go:10      the filename is foo.go, and the line number is 10 for the next line
+//	//line C:foo.go:10    colons are permitted in filenames, here the filename is C:foo.go, and the line is 10
+//	//line  a:100 :10     blanks are permitted in filenames, here the filename is " a:100 " (excluding quotes)
+//	/*line :10:20*/x      the position of x is in the current file with line number 10 and column number 20
+//	/*line foo: 10 */     this comment is recognized as invalid line directive (extra blanks around line number)
+//
+// Line directives typically appear in machine-generated code, so that compilers and debuggers
+// will report positions in the original input to the generator.
+/*
+# Function Directives
+
+A function directive applies to the Go function that immediately follows it.
+
+	//go:noescape
+
+The //go:noescape directive must be followed by a function declaration without
+a body (meaning that the function has an implementation not written in Go).
+It specifies that the function does not allow any of the pointers passed as
+arguments to escape into the heap or into the values returned from the function.
+This information can be used during the compiler's escape analysis of Go code
+calling the function.
+
+	//go:uintptrescapes
+
+The //go:uintptrescapes directive must be followed by a function declaration.
+It specifies that the function's uintptr arguments may be pointer values that
+have been converted to uintptr and must be on the heap and kept alive for the
+duration of the call, even though from the types alone it would appear that the
+object is no longer needed during the call. The conversion from pointer to
+uintptr must appear in the argument list of any call to this function. This
+directive is necessary for some low-level system call implementations and
+should be avoided otherwise.
+
+	//go:noinline
+
+The //go:noinline directive must be followed by a function declaration.
+It specifies that calls to the function should not be inlined, overriding
+the compiler's usual optimization rules. This is typically only needed
+for special runtime functions or when debugging the compiler.
+
+	//go:norace
+
+The //go:norace directive must be followed by a function declaration.
+It specifies that the function's memory accesses must be ignored by the
+race detector. This is most commonly used in low-level code invoked
+at times when it is unsafe to call into the race detector runtime.
+
+	//go:nosplit
+
+The //go:nosplit directive must be followed by a function declaration.
+It specifies that the function must omit its usual stack overflow check.
+This is most commonly used by low-level runtime code invoked
+at times when it is unsafe for the calling goroutine to be preempted.
+Using this directive outside of low-level runtime code is not safe,
+because it permits the nosplit function to overwrite the end of stack,
+leading to memory corruption and arbitrary program failure.
+
+# Linkname Directive
+
+	//go:linkname localname [importpath.name]
+
+The //go:linkname directive conventionally precedes the var or func
+declaration named by ``localname``, though its position does not
+change its effect.
+This directive determines the object-file symbol used for a Go var or
+func declaration, allowing two Go symbols to alias the same
+object-file symbol, thereby enabling one package to access a symbol in
+another package even when this would violate the usual encapsulation
+of unexported declarations, or even type safety.
+For that reason, it is only enabled in files that have imported "unsafe".
+
+It may be used in two scenarios. Let's assume that package upper
+imports package lower, perhaps indirectly. In the first scenario,
+package lower defines a symbol whose object file name belongs to
+package upper. Both packages contain a linkname directive: package
+lower uses the two-argument form and package upper uses the
+one-argument form. In the example below, lower.f is an alias for the
+function upper.g:
+
+    package upper
+    import _ "unsafe"
+    //go:linkname g
+    func g()
+
+    package lower
+    import _ "unsafe"
+    //go:linkname f upper.g
+    func f() { ... }
+
+The linkname directive in package upper suppresses the usual error for
+a function that lacks a body. (That check may alternatively be
+suppressed by including a .s file, even an empty one, in the package.)
+
+In the second scenario, package upper unilaterally creates an alias
+for a symbol in package lower. In the example below, upper.g is an alias
+for the function lower.f.
+
+    package upper
+    import _ "unsafe"
+    //go:linkname g lower.f
+    func g()
+
+    package lower
+    func f() { ... }
+
+The declaration of lower.f may also have a linkname directive with a
+single argument, f. This is optional, but helps alert the reader that
+the function is accessed from outside the package.
+
+# WebAssembly Directives
+
+	//go:wasmimport importmodule importname
+
+The //go:wasmimport directive is wasm-only and must be followed by a
+function declaration with no body.
+It specifies that the function is provided by a wasm module identified
+by ``importmodule'' and ``importname''. For example,
+
+	//go:wasmimport a_module f
+	func g()
+
+causes g to refer to the WebAssembly function f from module a_module.
+
+	//go:wasmexport exportname
+
+The //go:wasmexport directive is wasm-only and must be followed by a
+function definition.
+It specifies that the function is exported to the wasm host as ``exportname''.
+For example,
+
+	//go:wasmexport h
+	func hWasm() { ... }
+
+make Go function hWasm available outside this WebAssembly module as h.
+
+For both go:wasmimport and go:wasmexport,
+the types of parameters and return values to the Go function are translated to
+Wasm according to the following table:
+
+    Go types        Wasm types
+    bool            i32
+    int32, uint32   i32
+    int64, uint64   i64
+    float32         f32
+    float64         f64
+    unsafe.Pointer  i32
+    pointer         i32 (more restrictions below)
+    string          (i32, i32) (only permitted as a parameters, not a result)
+
+Any other parameter types are disallowed by the compiler.
+
+For a pointer type, its element type must be a bool, int8, uint8, int16, uint16,
+int32, uint32, int64, uint64, float32, float64, an array whose element type is
+a permitted pointer element type, or a struct, which, if non-empty, embeds
+[structs.HostLayout], and contains only fields whose types are permitted pointer
+element types.
+*/
+package main

go/src/cmd/compile/main.go

@@ -0,0 +1,59 @@
+// Copyright 2015 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 (
+	"cmd/compile/internal/amd64"
+	"cmd/compile/internal/arm"
+	"cmd/compile/internal/arm64"
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/gc"
+	"cmd/compile/internal/loong64"
+	"cmd/compile/internal/mips"
+	"cmd/compile/internal/mips64"
+	"cmd/compile/internal/ppc64"
+	"cmd/compile/internal/riscv64"
+	"cmd/compile/internal/s390x"
+	"cmd/compile/internal/ssagen"
+	"cmd/compile/internal/wasm"
+	"cmd/compile/internal/x86"
+	"fmt"
+	"internal/buildcfg"
+	"log"
+	"os"
+)
+
+var archInits = map[string]func(*ssagen.ArchInfo){
+	"386":      x86.Init,
+	"amd64":    amd64.Init,
+	"arm":      arm.Init,
+	"arm64":    arm64.Init,
+	"loong64":  loong64.Init,
+	"mips":     mips.Init,
+	"mipsle":   mips.Init,
+	"mips64":   mips64.Init,
+	"mips64le": mips64.Init,
+	"ppc64":    ppc64.Init,
+	"ppc64le":  ppc64.Init,
+	"riscv64":  riscv64.Init,
+	"s390x":    s390x.Init,
+	"wasm":     wasm.Init,
+}
+
+func main() {
+	// disable timestamps for reproducible output
+	log.SetFlags(0)
+	log.SetPrefix("compile: ")
+
+	buildcfg.Check()
+	archInit, ok := archInits[buildcfg.GOARCH]
+	if !ok {
+		fmt.Fprintf(os.Stderr, "compile: unknown architecture %q\n", buildcfg.GOARCH)
+		os.Exit(2)
+	}
+
+	gc.Main(archInit)
+	base.Exit(0)
+}

go/src/cmd/compile/profile.sh

@@ -0,0 +1,21 @@
+# Copyright 2023 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.
+
+# This script collects a CPU profile of the compiler
+# for building all targets in std and cmd, and puts
+# the profile at cmd/compile/default.pgo.
+
+dir=$(mktemp -d)
+cd $dir
+seed=$(date)
+
+for p in $(go list std cmd); do
+	h=$(echo $seed $p | md5sum | cut -d ' ' -f 1)
+	echo $p $h
+	go build -o /dev/null -gcflags=-cpuprofile=$PWD/prof.$h $p
+done
+
+go tool pprof -proto prof.* > $(go env GOROOT)/src/cmd/compile/default.pgo
+
+rm -r $dir

go/src/cmd/compile/script_test.go

@@ -0,0 +1,67 @@
+// Copyright 2024 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 (
+	"cmd/internal/script/scripttest"
+	"flag"
+	"internal/testenv"
+	"os"
+	"runtime"
+	"testing"
+)
+
+//go:generate go test cmd/compile -v -run=TestScript/README --fixreadme
+
+var fixReadme = flag.Bool("fixreadme", false, "if true, update README for script tests")
+
+var testCompiler string
+
+// TestMain allows this test binary to run as the compiler
+// itself, which is helpful for running script tests.
+// If COMPILE_TEST_EXEC_COMPILE is set, we treat the run
+// as a 'go tool compile' invocation, otherwise behave
+// as a normal test binary.
+func TestMain(m *testing.M) {
+	// Are we being asked to run as the compiler?
+	// If so then kick off main.
+	if os.Getenv("COMPILE_TEST_EXEC_COMPILE") != "" {
+		main()
+		os.Exit(0)
+	}
+
+	if testExe, err := os.Executable(); err == nil {
+		// on wasm, some phones, we expect an error from os.Executable()
+		testCompiler = testExe
+	}
+
+	// Regular run, just execute tests.
+	os.Exit(m.Run())
+}
+
+func TestScript(t *testing.T) {
+	testenv.MustHaveGoBuild(t)
+	doReplacement := true
+	switch runtime.GOOS {
+	case "wasip1", "js":
+		// wasm doesn't support os.Executable, so we'll skip replacing
+		// the installed linker with our test binary.
+		doReplacement = false
+	}
+	repls := []scripttest.ToolReplacement{}
+	if doReplacement {
+		if testCompiler == "" {
+			t.Fatalf("testCompiler not set, can't replace")
+		}
+		repls = []scripttest.ToolReplacement{
+			scripttest.ToolReplacement{
+				ToolName:        "compile",
+				ReplacementPath: testCompiler,
+				EnvVar:          "COMPILE_TEST_EXEC_COMPILE=1",
+			},
+		}
+	}
+	scripttest.RunToolScriptTest(t, repls, "testdata/script", *fixReadme)
+}

go/src/cmd/covdata/argsmerge.go

@@ -0,0 +1,56 @@
+// Copyright 2022 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"
+	"slices"
+	"strconv"
+)
+
+type argvalues struct {
+	osargs []string
+	goos   string
+	goarch string
+}
+
+type argstate struct {
+	state       argvalues
+	initialized bool
+}
+
+func (a *argstate) Merge(state argvalues) {
+	if !a.initialized {
+		a.state = state
+		a.initialized = true
+		return
+	}
+	if !slices.Equal(a.state.osargs, state.osargs) {
+		a.state.osargs = nil
+	}
+	if state.goos != a.state.goos {
+		a.state.goos = ""
+	}
+	if state.goarch != a.state.goarch {
+		a.state.goarch = ""
+	}
+}
+
+func (a *argstate) ArgsSummary() map[string]string {
+	m := make(map[string]string)
+	if len(a.state.osargs) != 0 {
+		m["argc"] = strconv.Itoa(len(a.state.osargs))
+		for k, a := range a.state.osargs {
+			m[fmt.Sprintf("argv%d", k)] = a
+		}
+	}
+	if a.state.goos != "" {
+		m["GOOS"] = a.state.goos
+	}
+	if a.state.goarch != "" {
+		m["GOARCH"] = a.state.goarch
+	}
+	return m
+}

go/src/cmd/covdata/covdata.go

@@ -0,0 +1,237 @@
+// Copyright 2022 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 (
+	"cmd/internal/cov"
+	"cmd/internal/pkgpattern"
+	"cmd/internal/telemetry/counter"
+	"flag"
+	"fmt"
+	"os"
+	"runtime"
+	"runtime/pprof"
+	"strings"
+)
+
+var verbflag = flag.Int("v", 0, "Verbose trace output level")
+var hflag = flag.Bool("h", false, "Panic on fatal errors (for stack trace)")
+var hwflag = flag.Bool("hw", false, "Panic on warnings (for stack trace)")
+var indirsflag = flag.String("i", "", "Input dirs to examine (comma separated)")
+var pkgpatflag = flag.String("pkg", "", "Restrict output to package(s) matching specified package pattern.")
+var cpuprofileflag = flag.String("cpuprofile", "", "Write CPU profile to specified file")
+var memprofileflag = flag.String("memprofile", "", "Write memory profile to specified file")
+var memprofilerateflag = flag.Int("memprofilerate", 0, "Set memprofile sampling rate to value")
+
+var matchpkg func(name string) bool
+
+var atExitFuncs []func()
+
+func atExit(f func()) {
+	atExitFuncs = append(atExitFuncs, f)
+}
+
+func Exit(code int) {
+	for i := len(atExitFuncs) - 1; i >= 0; i-- {
+		f := atExitFuncs[i]
+		atExitFuncs = atExitFuncs[:i]
+		f()
+	}
+	os.Exit(code)
+}
+
+func dbgtrace(vlevel int, s string, a ...any) {
+	if *verbflag >= vlevel {
+		fmt.Printf(s, a...)
+		fmt.Printf("\n")
+	}
+}
+
+func warn(s string, a ...any) {
+	fmt.Fprintf(os.Stderr, "warning: ")
+	fmt.Fprintf(os.Stderr, s, a...)
+	fmt.Fprintf(os.Stderr, "\n")
+	if *hwflag {
+		panic("unexpected warning")
+	}
+}
+
+func fatal(s string, a ...any) {
+	fmt.Fprintf(os.Stderr, "error: ")
+	fmt.Fprintf(os.Stderr, s, a...)
+	fmt.Fprintf(os.Stderr, "\n")
+	if *hflag {
+		panic("fatal error")
+	}
+	Exit(1)
+}
+
+func usage(msg string) {
+	if len(msg) > 0 {
+		fmt.Fprintf(os.Stderr, "error: %s\n", msg)
+	}
+	fmt.Fprintf(os.Stderr, "usage: go tool covdata [command]\n")
+	fmt.Fprintf(os.Stderr, `
+Commands are:
+
+textfmt     convert coverage data to textual format
+percent     output total percentage of statements covered
+pkglist     output list of package import paths
+func        output coverage profile information for each function
+merge       merge data files together
+subtract    subtract one set of data files from another set
+intersect   generate intersection of two sets of data files
+debugdump   dump data in human-readable format for debugging purposes
+`)
+	fmt.Fprintf(os.Stderr, "\nFor help on a specific subcommand, try:\n")
+	fmt.Fprintf(os.Stderr, "\ngo tool covdata <cmd> -help\n")
+	Exit(2)
+}
+
+type covOperation interface {
+	cov.CovDataVisitor
+	Setup()
+	Usage(string)
+}
+
+// Modes of operation.
+const (
+	funcMode      = "func"
+	mergeMode     = "merge"
+	intersectMode = "intersect"
+	subtractMode  = "subtract"
+	percentMode   = "percent"
+	pkglistMode   = "pkglist"
+	textfmtMode   = "textfmt"
+	debugDumpMode = "debugdump"
+)
+
+func main() {
+	counter.Open()
+
+	// First argument should be mode/subcommand.
+	if len(os.Args) < 2 {
+		usage("missing command selector")
+	}
+
+	// Select mode
+	var op covOperation
+	cmd := os.Args[1]
+	switch cmd {
+	case mergeMode:
+		op = makeMergeOp()
+	case debugDumpMode:
+		op = makeDumpOp(debugDumpMode)
+	case textfmtMode:
+		op = makeDumpOp(textfmtMode)
+	case percentMode:
+		op = makeDumpOp(percentMode)
+	case funcMode:
+		op = makeDumpOp(funcMode)
+	case pkglistMode:
+		op = makeDumpOp(pkglistMode)
+	case subtractMode:
+		op = makeSubtractIntersectOp(subtractMode)
+	case intersectMode:
+		op = makeSubtractIntersectOp(intersectMode)
+	default:
+		usage(fmt.Sprintf("unknown command selector %q", cmd))
+	}
+
+	// Edit out command selector, then parse flags.
+	os.Args = append(os.Args[:1], os.Args[2:]...)
+	flag.Usage = func() {
+		op.Usage("")
+	}
+	flag.Parse()
+	counter.Inc("covdata/invocations")
+	counter.CountFlags("covdata/flag:", *flag.CommandLine)
+
+	// Mode-independent flag setup
+	dbgtrace(1, "starting mode-independent setup")
+	if flag.NArg() != 0 {
+		op.Usage("unknown extra arguments")
+	}
+	if *pkgpatflag != "" {
+		pats := strings.Split(*pkgpatflag, ",")
+		matchers := []func(name string) bool{}
+		for _, p := range pats {
+			if p == "" {
+				continue
+			}
+			f := pkgpattern.MatchSimplePattern(p)
+			matchers = append(matchers, f)
+		}
+		matchpkg = func(name string) bool {
+			for _, f := range matchers {
+				if f(name) {
+					return true
+				}
+			}
+			return false
+		}
+	}
+	if *cpuprofileflag != "" {
+		f, err := os.Create(*cpuprofileflag)
+		if err != nil {
+			fatal("%v", err)
+		}
+		if err := pprof.StartCPUProfile(f); err != nil {
+			fatal("%v", err)
+		}
+		atExit(func() {
+			pprof.StopCPUProfile()
+			if err = f.Close(); err != nil {
+				fatal("error closing cpu profile: %v", err)
+			}
+		})
+	}
+	if *memprofileflag != "" {
+		if *memprofilerateflag != 0 {
+			runtime.MemProfileRate = *memprofilerateflag
+		}
+		f, err := os.Create(*memprofileflag)
+		if err != nil {
+			fatal("%v", err)
+		}
+		atExit(func() {
+			runtime.GC()
+			const writeLegacyFormat = 1
+			if err := pprof.Lookup("heap").WriteTo(f, writeLegacyFormat); err != nil {
+				fatal("%v", err)
+			}
+			if err = f.Close(); err != nil {
+				fatal("error closing memory profile: %v", err)
+			}
+		})
+	} else {
+		// Not doing memory profiling; disable it entirely.
+		runtime.MemProfileRate = 0
+	}
+
+	// Mode-dependent setup.
+	op.Setup()
+
+	// ... off and running now.
+	dbgtrace(1, "starting perform")
+
+	indirs := strings.Split(*indirsflag, ",")
+	vis := cov.CovDataVisitor(op)
+	var flags cov.CovDataReaderFlags
+	if *hflag {
+		flags |= cov.PanicOnError
+	}
+	if *hwflag {
+		flags |= cov.PanicOnWarning
+	}
+	reader := cov.MakeCovDataReader(vis, indirs, *verbflag, flags, matchpkg)
+	st := 0
+	if err := reader.Visit(); err != nil {
+		fmt.Fprintf(os.Stderr, "error: %v\n", err)
+		st = 1
+	}
+	dbgtrace(1, "leaving main")
+	Exit(st)
+}

go/src/cmd/covdata/doc.go

@@ -0,0 +1,80 @@
+// Copyright 2022 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.
+
+/*
+Covdata is a program for manipulating and generating reports
+from 2nd-generation coverage testing output files, those produced
+from running applications or integration tests. E.g.
+
+	$ mkdir ./profiledir
+	$ go build -cover -o myapp.exe .
+	$ GOCOVERDIR=./profiledir ./myapp.exe <arguments>
+	$ ls ./profiledir
+	covcounters.cce1b350af34b6d0fb59cc1725f0ee27.821598.1663006712821344241
+	covmeta.cce1b350af34b6d0fb59cc1725f0ee27
+	$
+
+Run covdata via "go tool covdata <mode>", where 'mode' is a subcommand
+selecting a specific reporting, merging, or data manipulation operation.
+Descriptions on the various modes (run "go tool cover <mode> -help" for
+specifics on usage of a given mode):
+
+1. Report percent of statements covered in each profiled package
+
+	$ go tool covdata percent -i=profiledir
+	cov-example/p	coverage: 41.1% of statements
+	main	coverage: 87.5% of statements
+	$
+
+2. Report import paths of packages profiled
+
+	$ go tool covdata pkglist -i=profiledir
+	cov-example/p
+	main
+	$
+
+3. Report percent statements covered by function:
+
+	$ go tool covdata func -i=profiledir
+	cov-example/p/p.go:12:		emptyFn			0.0%
+	cov-example/p/p.go:32:		Small			100.0%
+	cov-example/p/p.go:47:		Medium			90.9%
+	...
+	$
+
+4. Convert coverage data to legacy textual format:
+
+	$ go tool covdata textfmt -i=profiledir -o=cov.txt
+	$ head cov.txt
+	mode: set
+	cov-example/p/p.go:12.22,13.2 0 0
+	cov-example/p/p.go:15.31,16.2 1 0
+	cov-example/p/p.go:16.3,18.3 0 0
+	cov-example/p/p.go:19.3,21.3 0 0
+	...
+	$ go tool cover -html=cov.txt
+	$
+
+5. Merge profiles together:
+
+	$ go tool covdata merge -i=indir1,indir2 -o=outdir -modpaths=github.com/go-delve/delve
+	$
+
+6. Subtract one profile from another
+
+	$ go tool covdata subtract -i=indir1,indir2 -o=outdir
+	$
+
+7. Intersect profiles
+
+	$ go tool covdata intersect -i=indir1,indir2 -o=outdir
+	$
+
+8. Dump a profile for debugging purposes.
+
+	$ go tool covdata debugdump -i=indir
+	<human readable output>
+	$
+*/
+package main

go/src/cmd/covdata/dump.go

@@ -0,0 +1,357 @@
+// Copyright 2022 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
+
+// This file contains functions and apis to support the "go tool
+// covdata" sub-commands that relate to dumping text format summaries
+// and reports: "pkglist", "func",  "debugdump", "percent", and
+// "textfmt".
+
+import (
+	"flag"
+	"fmt"
+	"internal/coverage"
+	"internal/coverage/calloc"
+	"internal/coverage/cformat"
+	"internal/coverage/cmerge"
+	"internal/coverage/decodecounter"
+	"internal/coverage/decodemeta"
+	"internal/coverage/pods"
+	"os"
+	"sort"
+	"strings"
+)
+
+var textfmtoutflag *string
+var liveflag *bool
+
+func makeDumpOp(cmd string) covOperation {
+	if cmd == textfmtMode || cmd == percentMode {
+		textfmtoutflag = flag.String("o", "", "Output text format to file")
+	}
+	if cmd == debugDumpMode {
+		liveflag = flag.Bool("live", false, "Select only live (executed) functions for dump output.")
+	}
+	d := &dstate{
+		cmd: cmd,
+		cm:  &cmerge.Merger{},
+	}
+	// For these modes (percent, pkglist, func, etc), use a relaxed
+	// policy when it comes to counter mode clashes. For a percent
+	// report, for example, we only care whether a given line is
+	// executed at least once, so it's ok to (effectively) merge
+	// together runs derived from different counter modes.
+	if d.cmd == percentMode || d.cmd == funcMode || d.cmd == pkglistMode {
+		d.cm.SetModeMergePolicy(cmerge.ModeMergeRelaxed)
+	}
+	if d.cmd == pkglistMode {
+		d.pkgpaths = make(map[string]struct{})
+	}
+	return d
+}
+
+// dstate encapsulates state and provides methods for implementing
+// various dump operations. Specifically, dstate implements the
+// CovDataVisitor interface, and is designed to be used in
+// concert with the CovDataReader utility, which abstracts away most
+// of the grubby details of reading coverage data files.
+type dstate struct {
+	// for batch allocation of counter arrays
+	calloc.BatchCounterAlloc
+
+	// counter merging state + methods
+	cm *cmerge.Merger
+
+	// counter data formatting helper
+	format *cformat.Formatter
+
+	// 'mm' stores values read from a counter data file; the pkfunc key
+	// is a pkgid/funcid pair that uniquely identifies a function in
+	// instrumented application.
+	mm map[pkfunc]decodecounter.FuncPayload
+
+	// pkm maps package ID to the number of functions in the package
+	// with that ID. It is used to report inconsistencies in counter
+	// data (for example, a counter data entry with pkgid=N funcid=10
+	// where package N only has 3 functions).
+	pkm map[uint32]uint32
+
+	// pkgpaths records all package import paths encountered while
+	// visiting coverage data files (used to implement the "pkglist"
+	// subcommand).
+	pkgpaths map[string]struct{}
+
+	// Current package name and import path.
+	pkgName       string
+	pkgImportPath string
+
+	// Module path for current package (may be empty).
+	modulePath string
+
+	// Dump subcommand (ex: "textfmt", "debugdump", etc).
+	cmd string
+
+	// File to which we will write text format output, if enabled.
+	textfmtoutf *os.File
+
+	// Total and covered statements (used by "debugdump" subcommand).
+	totalStmts, coveredStmts int
+
+	// Records whether preamble has been emitted for current pkg
+	// (used when in "debugdump" mode)
+	preambleEmitted bool
+}
+
+func (d *dstate) Usage(msg string) {
+	if len(msg) > 0 {
+		fmt.Fprintf(os.Stderr, "error: %s\n", msg)
+	}
+	fmt.Fprintf(os.Stderr, "usage: go tool covdata %s -i=<directories>\n\n", d.cmd)
+	flag.PrintDefaults()
+	fmt.Fprintf(os.Stderr, "\nExamples:\n\n")
+	switch d.cmd {
+	case pkglistMode:
+		fmt.Fprintf(os.Stderr, "  go tool covdata pkglist -i=dir1,dir2\n\n")
+		fmt.Fprintf(os.Stderr, "  \treads coverage data files from dir1+dirs2\n")
+		fmt.Fprintf(os.Stderr, "  \tand writes out a list of the import paths\n")
+		fmt.Fprintf(os.Stderr, "  \tof all compiled packages.\n")
+	case textfmtMode:
+		fmt.Fprintf(os.Stderr, "  go tool covdata textfmt -i=dir1,dir2 -o=out.txt\n\n")
+		fmt.Fprintf(os.Stderr, "  \tmerges data from input directories dir1+dir2\n")
+		fmt.Fprintf(os.Stderr, "  \tand emits text format into file 'out.txt'\n")
+	case percentMode:
+		fmt.Fprintf(os.Stderr, "  go tool covdata percent -i=dir1,dir2\n\n")
+		fmt.Fprintf(os.Stderr, "  \tmerges data from input directories dir1+dir2\n")
+		fmt.Fprintf(os.Stderr, "  \tand emits percentage of statements covered\n\n")
+	case funcMode:
+		fmt.Fprintf(os.Stderr, "  go tool covdata func -i=dir1,dir2\n\n")
+		fmt.Fprintf(os.Stderr, "  \treads coverage data files from dir1+dirs2\n")
+		fmt.Fprintf(os.Stderr, "  \tand writes out coverage profile data for\n")
+		fmt.Fprintf(os.Stderr, "  \teach function.\n")
+	case debugDumpMode:
+		fmt.Fprintf(os.Stderr, "  go tool covdata debugdump [flags] -i=dir1,dir2\n\n")
+		fmt.Fprintf(os.Stderr, "  \treads coverage data from dir1+dir2 and dumps\n")
+		fmt.Fprintf(os.Stderr, "  \tcontents in human-readable form to stdout, for\n")
+		fmt.Fprintf(os.Stderr, "  \tdebugging purposes.\n")
+	default:
+		panic("unexpected")
+	}
+	Exit(2)
+}
+
+// Setup is called once at program startup time to vet flag values
+// and do any necessary setup operations.
+func (d *dstate) Setup() {
+	if *indirsflag == "" {
+		d.Usage("select input directories with '-i' option")
+	}
+	if d.cmd == textfmtMode || (d.cmd == percentMode && *textfmtoutflag != "") {
+		if *textfmtoutflag == "" {
+			d.Usage("select output file name with '-o' option")
+		}
+		var err error
+		d.textfmtoutf, err = os.Create(*textfmtoutflag)
+		if err != nil {
+			d.Usage(fmt.Sprintf("unable to open textfmt output file %q: %v", *textfmtoutflag, err))
+		}
+	}
+	if d.cmd == debugDumpMode {
+		fmt.Printf("/* WARNING: the format of this dump is not stable and is\n")
+		fmt.Printf(" * expected to change from one Go release to the next.\n")
+		fmt.Printf(" *\n")
+		fmt.Printf(" * produced by:\n")
+		args := append([]string{os.Args[0]}, debugDumpMode)
+		args = append(args, os.Args[1:]...)
+		fmt.Printf(" *\t%s\n", strings.Join(args, " "))
+		fmt.Printf(" */\n")
+	}
+}
+
+func (d *dstate) BeginPod(p pods.Pod) {
+	d.mm = make(map[pkfunc]decodecounter.FuncPayload)
+}
+
+func (d *dstate) EndPod(p pods.Pod) {
+	if d.cmd == debugDumpMode {
+		d.cm.ResetModeAndGranularity()
+	}
+}
+
+func (d *dstate) BeginCounterDataFile(cdf string, cdr *decodecounter.CounterDataReader, dirIdx int) {
+	dbgtrace(2, "visit counter data file %s dirIdx %d", cdf, dirIdx)
+	if d.cmd == debugDumpMode {
+		fmt.Printf("data file %s", cdf)
+		if cdr.Goos() != "" {
+			fmt.Printf(" GOOS=%s", cdr.Goos())
+		}
+		if cdr.Goarch() != "" {
+			fmt.Printf(" GOARCH=%s", cdr.Goarch())
+		}
+		if len(cdr.OsArgs()) != 0 {
+			fmt.Printf("  program args: %+v\n", cdr.OsArgs())
+		}
+		fmt.Printf("\n")
+	}
+}
+
+func (d *dstate) EndCounterDataFile(cdf string, cdr *decodecounter.CounterDataReader, dirIdx int) {
+}
+
+func (d *dstate) VisitFuncCounterData(data decodecounter.FuncPayload) {
+	if nf, ok := d.pkm[data.PkgIdx]; !ok || data.FuncIdx > nf {
+		warn("func payload inconsistency: id [p=%d,f=%d] nf=%d len(ctrs)=%d in VisitFuncCounterData, ignored", data.PkgIdx, data.FuncIdx, nf, len(data.Counters))
+		return
+	}
+	key := pkfunc{pk: data.PkgIdx, fcn: data.FuncIdx}
+	val, found := d.mm[key]
+
+	dbgtrace(5, "ctr visit pk=%d fid=%d found=%v len(val.ctrs)=%d len(data.ctrs)=%d", data.PkgIdx, data.FuncIdx, found, len(val.Counters), len(data.Counters))
+
+	if len(val.Counters) < len(data.Counters) {
+		t := val.Counters
+		val.Counters = d.AllocateCounters(len(data.Counters))
+		copy(val.Counters, t)
+	}
+	err, overflow := d.cm.MergeCounters(val.Counters, data.Counters)
+	if err != nil {
+		fatal("%v", err)
+	}
+	if overflow {
+		warn("uint32 overflow during counter merge")
+	}
+	d.mm[key] = val
+}
+
+func (d *dstate) EndCounters() {
+}
+
+func (d *dstate) VisitMetaDataFile(mdf string, mfr *decodemeta.CoverageMetaFileReader) {
+	newgran := mfr.CounterGranularity()
+	newmode := mfr.CounterMode()
+	if err := d.cm.SetModeAndGranularity(mdf, newmode, newgran); err != nil {
+		fatal("%v", err)
+	}
+	if d.cmd == debugDumpMode {
+		fmt.Printf("Cover mode: %s\n", newmode.String())
+		fmt.Printf("Cover granularity: %s\n", newgran.String())
+	}
+	if d.format == nil {
+		d.format = cformat.NewFormatter(mfr.CounterMode())
+	}
+
+	// To provide an additional layer of checking when reading counter
+	// data, walk the meta-data file to determine the set of legal
+	// package/function combinations. This will help catch bugs in the
+	// counter file reader.
+	d.pkm = make(map[uint32]uint32)
+	np := uint32(mfr.NumPackages())
+	payload := []byte{}
+	for pkIdx := uint32(0); pkIdx < np; pkIdx++ {
+		var pd *decodemeta.CoverageMetaDataDecoder
+		var err error
+		pd, payload, err = mfr.GetPackageDecoder(pkIdx, payload)
+		if err != nil {
+			fatal("reading pkg %d from meta-file %s: %s", pkIdx, mdf, err)
+		}
+		d.pkm[pkIdx] = pd.NumFuncs()
+	}
+}
+
+func (d *dstate) BeginPackage(pd *decodemeta.CoverageMetaDataDecoder, pkgIdx uint32) {
+	d.preambleEmitted = false
+	d.pkgImportPath = pd.PackagePath()
+	d.pkgName = pd.PackageName()
+	d.modulePath = pd.ModulePath()
+	if d.cmd == pkglistMode {
+		d.pkgpaths[d.pkgImportPath] = struct{}{}
+	}
+	d.format.SetPackage(pd.PackagePath())
+}
+
+func (d *dstate) EndPackage(pd *decodemeta.CoverageMetaDataDecoder, pkgIdx uint32) {
+}
+
+func (d *dstate) VisitFunc(pkgIdx uint32, fnIdx uint32, fd *coverage.FuncDesc) {
+	var counters []uint32
+	key := pkfunc{pk: pkgIdx, fcn: fnIdx}
+	v, haveCounters := d.mm[key]
+
+	dbgtrace(5, "meta visit pk=%d fid=%d fname=%s file=%s found=%v len(val.ctrs)=%d", pkgIdx, fnIdx, fd.Funcname, fd.Srcfile, haveCounters, len(v.Counters))
+
+	suppressOutput := false
+	if haveCounters {
+		counters = v.Counters
+	} else if d.cmd == debugDumpMode && *liveflag {
+		suppressOutput = true
+	}
+
+	if d.cmd == debugDumpMode && !suppressOutput {
+		if !d.preambleEmitted {
+			fmt.Printf("\nPackage path: %s\n", d.pkgImportPath)
+			fmt.Printf("Package name: %s\n", d.pkgName)
+			fmt.Printf("Module path: %s\n", d.modulePath)
+			d.preambleEmitted = true
+		}
+		fmt.Printf("\nFunc: %s\n", fd.Funcname)
+		fmt.Printf("Srcfile: %s\n", fd.Srcfile)
+		fmt.Printf("Literal: %v\n", fd.Lit)
+	}
+	for i := 0; i < len(fd.Units); i++ {
+		u := fd.Units[i]
+		var count uint32
+		if counters != nil {
+			count = counters[i]
+		}
+		d.format.AddUnit(fd.Srcfile, fd.Funcname, fd.Lit, u, count)
+		if d.cmd == debugDumpMode && !suppressOutput {
+			fmt.Printf("%d: L%d:C%d -- L%d:C%d ",
+				i, u.StLine, u.StCol, u.EnLine, u.EnCol)
+			if u.Parent != 0 {
+				fmt.Printf("Parent:%d = %d\n", u.Parent, count)
+			} else {
+				fmt.Printf("NS=%d = %d\n", u.NxStmts, count)
+			}
+		}
+		d.totalStmts += int(u.NxStmts)
+		if count != 0 {
+			d.coveredStmts += int(u.NxStmts)
+		}
+	}
+}
+
+func (d *dstate) Finish() {
+	// d.format maybe nil here if the specified input dir was empty.
+	if d.format != nil {
+		if d.cmd == percentMode {
+			d.format.EmitPercent(os.Stdout, nil, "", false, false)
+		}
+		if d.cmd == funcMode {
+			d.format.EmitFuncs(os.Stdout)
+		}
+		if d.textfmtoutf != nil {
+			if err := d.format.EmitTextual(nil, d.textfmtoutf); err != nil {
+				fatal("writing to %s: %v", *textfmtoutflag, err)
+			}
+		}
+	}
+	if d.textfmtoutf != nil {
+		if err := d.textfmtoutf.Close(); err != nil {
+			fatal("closing textfmt output file %s: %v", *textfmtoutflag, err)
+		}
+	}
+	if d.cmd == debugDumpMode {
+		fmt.Printf("totalStmts: %d coveredStmts: %d\n", d.totalStmts, d.coveredStmts)
+	}
+	if d.cmd == pkglistMode {
+		pkgs := make([]string, 0, len(d.pkgpaths))
+		for p := range d.pkgpaths {
+			pkgs = append(pkgs, p)
+		}
+		sort.Strings(pkgs)
+		for _, p := range pkgs {
+			fmt.Printf("%s\n", p)
+		}
+	}
+}

go/src/cmd/covdata/export_test.go

@@ -0,0 +1,7 @@
+// Copyright 2022 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
+
+func Main() { main() }

go/src/cmd/covdata/merge.go

@@ -0,0 +1,111 @@
+// Copyright 2022 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
+
+// This file contains functions and apis to support the "merge"
+// subcommand of "go tool covdata".
+
+import (
+	"flag"
+	"fmt"
+	"internal/coverage"
+	"internal/coverage/cmerge"
+	"internal/coverage/decodecounter"
+	"internal/coverage/decodemeta"
+	"internal/coverage/pods"
+	"os"
+)
+
+var outdirflag *string
+var pcombineflag *bool
+
+func makeMergeOp() covOperation {
+	outdirflag = flag.String("o", "", "Output directory to write")
+	pcombineflag = flag.Bool("pcombine", false, "Combine profiles derived from distinct program executables")
+	m := &mstate{
+		mm: newMetaMerge(),
+	}
+	return m
+}
+
+// mstate encapsulates state and provides methods for implementing the
+// merge operation. This type implements the CovDataVisitor interface,
+// and is designed to be used in concert with the CovDataReader
+// utility, which abstracts away most of the grubby details of reading
+// coverage data files. Most of the heavy lifting for merging is done
+// using apis from 'metaMerge' (this is mainly a wrapper around that
+// functionality).
+type mstate struct {
+	mm *metaMerge
+}
+
+func (m *mstate) Usage(msg string) {
+	if len(msg) > 0 {
+		fmt.Fprintf(os.Stderr, "error: %s\n", msg)
+	}
+	fmt.Fprintf(os.Stderr, "usage: go tool covdata merge -i=<directories> -o=<dir>\n\n")
+	flag.PrintDefaults()
+	fmt.Fprintf(os.Stderr, "\nExamples:\n\n")
+	fmt.Fprintf(os.Stderr, "  go tool covdata merge -i=dir1,dir2,dir3 -o=outdir\n\n")
+	fmt.Fprintf(os.Stderr, "  \tmerges all files in dir1/dir2/dir3\n")
+	fmt.Fprintf(os.Stderr, "  \tinto output dir outdir\n")
+	Exit(2)
+}
+
+func (m *mstate) Setup() {
+	if *indirsflag == "" {
+		m.Usage("select input directories with '-i' option")
+	}
+	if *outdirflag == "" {
+		m.Usage("select output directory with '-o' option")
+	}
+	m.mm.SetModeMergePolicy(cmerge.ModeMergeRelaxed)
+}
+
+func (m *mstate) BeginPod(p pods.Pod) {
+	m.mm.beginPod()
+}
+
+func (m *mstate) EndPod(p pods.Pod) {
+	m.mm.endPod(*pcombineflag)
+}
+
+func (m *mstate) BeginCounterDataFile(cdf string, cdr *decodecounter.CounterDataReader, dirIdx int) {
+	dbgtrace(2, "visit counter data file %s dirIdx %d", cdf, dirIdx)
+	m.mm.beginCounterDataFile(cdr)
+}
+
+func (m *mstate) EndCounterDataFile(cdf string, cdr *decodecounter.CounterDataReader, dirIdx int) {
+}
+
+func (m *mstate) VisitFuncCounterData(data decodecounter.FuncPayload) {
+	m.mm.visitFuncCounterData(data)
+}
+
+func (m *mstate) EndCounters() {
+}
+
+func (m *mstate) VisitMetaDataFile(mdf string, mfr *decodemeta.CoverageMetaFileReader) {
+	m.mm.visitMetaDataFile(mdf, mfr)
+}
+
+func (m *mstate) BeginPackage(pd *decodemeta.CoverageMetaDataDecoder, pkgIdx uint32) {
+	dbgtrace(3, "VisitPackage(pk=%d path=%s)", pkgIdx, pd.PackagePath())
+	m.mm.visitPackage(pd, pkgIdx, *pcombineflag)
+}
+
+func (m *mstate) EndPackage(pd *decodemeta.CoverageMetaDataDecoder, pkgIdx uint32) {
+}
+
+func (m *mstate) VisitFunc(pkgIdx uint32, fnIdx uint32, fd *coverage.FuncDesc) {
+	m.mm.visitFunc(pkgIdx, fnIdx, fd, mergeMode, *pcombineflag)
+}
+
+func (m *mstate) Finish() {
+	if *pcombineflag {
+		finalHash := m.mm.emitMeta(*outdirflag, true)
+		m.mm.emitCounters(*outdirflag, finalHash)
+	}
+}

go/src/cmd/covdata/metamerge.go

@@ -0,0 +1,431 @@
+// Copyright 2022 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
+
+// This file contains functions and apis that support merging of
+// meta-data information.  It helps implement the "merge", "subtract",
+// and "intersect" subcommands.
+
+import (
+	"fmt"
+	"hash/fnv"
+	"internal/coverage"
+	"internal/coverage/calloc"
+	"internal/coverage/cmerge"
+	"internal/coverage/decodecounter"
+	"internal/coverage/decodemeta"
+	"internal/coverage/encodecounter"
+	"internal/coverage/encodemeta"
+	"internal/coverage/slicewriter"
+	"io"
+	"os"
+	"path/filepath"
+	"sort"
+	"time"
+	"unsafe"
+)
+
+// metaMerge provides state and methods to help manage the process
+// of selecting or merging meta data files. There are three cases
+// of interest here: the "-pcombine" flag provided by merge, the
+// "-pkg" option provided by all merge/subtract/intersect, and
+// a regular vanilla merge with no package selection
+//
+// In the -pcombine case, we're essentially glomming together all the
+// meta-data for all packages and all functions, meaning that
+// everything we see in a given package needs to be added into the
+// meta-data file builder; we emit a single meta-data file at the end
+// of the run.
+//
+// In the -pkg case, we will typically emit a single meta-data file
+// per input pod, where that new meta-data file contains entries for
+// just the selected packages.
+//
+// In the third case (vanilla merge with no combining or package
+// selection) we can carry over meta-data files without touching them
+// at all (only counter data files will be merged).
+type metaMerge struct {
+	calloc.BatchCounterAlloc
+	cmerge.Merger
+	// maps package import path to package state
+	pkm map[string]*pkstate
+	// list of packages
+	pkgs []*pkstate
+	// current package state
+	p *pkstate
+	// current pod state
+	pod *podstate
+	// counter data file osargs/goos/goarch state
+	astate *argstate
+}
+
+// pkstate
+type pkstate struct {
+	// index of package within meta-data file.
+	pkgIdx uint32
+	// this maps function index within the package to counter data payload
+	ctab map[uint32]decodecounter.FuncPayload
+	// pointer to meta-data blob for package
+	mdblob []byte
+	// filled in only for -pcombine merges
+	*pcombinestate
+}
+
+type podstate struct {
+	pmm      map[pkfunc]decodecounter.FuncPayload
+	mdf      string
+	mfr      *decodemeta.CoverageMetaFileReader
+	fileHash [16]byte
+}
+
+type pkfunc struct {
+	pk, fcn uint32
+}
+
+// pcombinestate
+type pcombinestate struct {
+	// Meta-data builder for the package.
+	cmdb *encodemeta.CoverageMetaDataBuilder
+	// Maps function meta-data hash to new function index in the
+	// new version of the package we're building.
+	ftab map[[16]byte]uint32
+}
+
+func newMetaMerge() *metaMerge {
+	return &metaMerge{
+		pkm:    make(map[string]*pkstate),
+		astate: &argstate{},
+	}
+}
+
+func (mm *metaMerge) visitMetaDataFile(mdf string, mfr *decodemeta.CoverageMetaFileReader) {
+	dbgtrace(2, "visitMetaDataFile(mdf=%s)", mdf)
+
+	// Record meta-data file name.
+	mm.pod.mdf = mdf
+	// Keep a pointer to the file-level reader.
+	mm.pod.mfr = mfr
+	// Record file hash.
+	mm.pod.fileHash = mfr.FileHash()
+	// Counter mode and granularity -- detect and record clashes here.
+	newgran := mfr.CounterGranularity()
+	newmode := mfr.CounterMode()
+	if err := mm.SetModeAndGranularity(mdf, newmode, newgran); err != nil {
+		fatal("%v", err)
+	}
+}
+
+func (mm *metaMerge) beginCounterDataFile(cdr *decodecounter.CounterDataReader) {
+	state := argvalues{
+		osargs: cdr.OsArgs(),
+		goos:   cdr.Goos(),
+		goarch: cdr.Goarch(),
+	}
+	mm.astate.Merge(state)
+}
+
+func copyMetaDataFile(inpath, outpath string) {
+	inf, err := os.Open(inpath)
+	if err != nil {
+		fatal("opening input meta-data file %s: %v", inpath, err)
+	}
+	defer inf.Close()
+
+	fi, err := inf.Stat()
+	if err != nil {
+		fatal("accessing input meta-data file %s: %v", inpath, err)
+	}
+
+	outf, err := os.OpenFile(outpath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, fi.Mode())
+	if err != nil {
+		fatal("opening output meta-data file %s: %v", outpath, err)
+	}
+
+	_, err = io.Copy(outf, inf)
+	outf.Close()
+	if err != nil {
+		fatal("writing output meta-data file %s: %v", outpath, err)
+	}
+}
+
+func (mm *metaMerge) beginPod() {
+	mm.pod = &podstate{
+		pmm: make(map[pkfunc]decodecounter.FuncPayload),
+	}
+}
+
+// metaEndPod handles actions needed when we're done visiting all of
+// the things in a pod -- counter files and meta-data file. There are
+// three cases of interest here:
+//
+// Case 1: in an unconditional merge (we're not selecting a specific set of
+// packages using "-pkg", and the "-pcombine" option is not in use),
+// we can simply copy over the meta-data file from input to output.
+//
+// Case 2: if this is a select merge (-pkg is in effect), then at
+// this point we write out a new smaller meta-data file that includes
+// only the packages of interest. At this point we also emit a merged
+// counter data file as well.
+//
+// Case 3: if "-pcombine" is in effect, we don't write anything at
+// this point (all writes will happen at the end of the run).
+func (mm *metaMerge) endPod(pcombine bool) {
+	if pcombine {
+		// Just clear out the pod data, we'll do all the
+		// heavy lifting at the end.
+		mm.pod = nil
+		return
+	}
+
+	finalHash := mm.pod.fileHash
+	if matchpkg != nil {
+		// Emit modified meta-data file for this pod.
+		finalHash = mm.emitMeta(*outdirflag, pcombine)
+	} else {
+		// Copy meta-data file for this pod to the output directory.
+		inpath := mm.pod.mdf
+		mdfbase := filepath.Base(mm.pod.mdf)
+		outpath := filepath.Join(*outdirflag, mdfbase)
+		copyMetaDataFile(inpath, outpath)
+	}
+
+	// Emit accumulated counter data for this pod.
+	mm.emitCounters(*outdirflag, finalHash)
+
+	// Reset package state.
+	mm.pkm = make(map[string]*pkstate)
+	mm.pkgs = nil
+	mm.pod = nil
+
+	// Reset counter mode and granularity
+	mm.ResetModeAndGranularity()
+}
+
+// emitMeta encodes and writes out a new coverage meta-data file as
+// part of a merge operation, specifically a merge with the
+// "-pcombine" flag.
+func (mm *metaMerge) emitMeta(outdir string, pcombine bool) [16]byte {
+	fh := fnv.New128a()
+	fhSum := fnv.New128a()
+	blobs := [][]byte{}
+	tlen := uint64(unsafe.Sizeof(coverage.MetaFileHeader{}))
+	for _, p := range mm.pkgs {
+		var blob []byte
+		if pcombine {
+			mdw := &slicewriter.WriteSeeker{}
+			p.cmdb.Emit(mdw)
+			blob = mdw.BytesWritten()
+		} else {
+			blob = p.mdblob
+		}
+		fhSum.Reset()
+		fhSum.Write(blob)
+		ph := fhSum.Sum(nil)
+		blobs = append(blobs, blob)
+		if _, err := fh.Write(ph[:]); err != nil {
+			panic(fmt.Sprintf("internal error: md5 sum failed: %v", err))
+		}
+		tlen += uint64(len(blob))
+	}
+	var finalHash [16]byte
+	fhh := fh.Sum(nil)
+	copy(finalHash[:], fhh)
+
+	// Open meta-file for writing.
+	fn := fmt.Sprintf("%s.%x", coverage.MetaFilePref, finalHash)
+	fpath := filepath.Join(outdir, fn)
+	mf, err := os.OpenFile(fpath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
+	if err != nil {
+		fatal("unable to open output meta-data file %s: %v", fpath, err)
+	}
+
+	defer func() {
+		if err := mf.Close(); err != nil {
+			fatal("error closing output meta-data file %s: %v", fpath, err)
+		}
+	}()
+
+	// Encode and write.
+	mfw := encodemeta.NewCoverageMetaFileWriter(fpath, mf)
+	err = mfw.Write(finalHash, blobs, mm.Mode(), mm.Granularity())
+	if err != nil {
+		fatal("error writing %s: %v\n", fpath, err)
+	}
+	return finalHash
+}
+
+func (mm *metaMerge) emitCounters(outdir string, metaHash [16]byte) {
+	// Open output file. The file naming scheme is intended to mimic
+	// that used when running a coverage-instrumented binary, for
+	// consistency (however the process ID is not meaningful here, so
+	// use a value of zero).
+	var dummyPID int
+	fn := fmt.Sprintf(coverage.CounterFileTempl, coverage.CounterFilePref, metaHash, dummyPID, time.Now().UnixNano())
+	fpath := filepath.Join(outdir, fn)
+	cf, err := os.OpenFile(fpath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
+	if err != nil {
+		fatal("opening counter data file %s: %v", fpath, err)
+	}
+	defer func() {
+		if err := cf.Close(); err != nil {
+			fatal("error closing output meta-data file %s: %v", fpath, err)
+		}
+	}()
+
+	args := mm.astate.ArgsSummary()
+	cfw := encodecounter.NewCoverageDataWriter(cf, coverage.CtrULeb128)
+	if err := cfw.Write(metaHash, args, mm); err != nil {
+		fatal("counter file write failed: %v", err)
+	}
+	mm.astate = &argstate{}
+}
+
+// VisitFuncs is used while writing the counter data files; it
+// implements the 'VisitFuncs' method required by the interface
+// internal/coverage/encodecounter/CounterVisitor.
+func (mm *metaMerge) VisitFuncs(f encodecounter.CounterVisitorFn) error {
+	if *verbflag >= 4 {
+		fmt.Printf("counterVisitor invoked\n")
+	}
+	// For each package, for each function, construct counter
+	// array and then call "f" on it.
+	for pidx, p := range mm.pkgs {
+		fids := make([]int, 0, len(p.ctab))
+		for fid := range p.ctab {
+			fids = append(fids, int(fid))
+		}
+		sort.Ints(fids)
+		if *verbflag >= 4 {
+			fmt.Printf("fids for pk=%d: %+v\n", pidx, fids)
+		}
+		for _, fid := range fids {
+			fp := p.ctab[uint32(fid)]
+			if *verbflag >= 4 {
+				fmt.Printf("counter write for pk=%d fid=%d len(ctrs)=%d\n", pidx, fid, len(fp.Counters))
+			}
+			if err := f(uint32(pidx), uint32(fid), fp.Counters); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func (mm *metaMerge) visitPackage(pd *decodemeta.CoverageMetaDataDecoder, pkgIdx uint32, pcombine bool) {
+	p, ok := mm.pkm[pd.PackagePath()]
+	if !ok {
+		p = &pkstate{
+			pkgIdx: uint32(len(mm.pkgs)),
+		}
+		mm.pkgs = append(mm.pkgs, p)
+		mm.pkm[pd.PackagePath()] = p
+		if pcombine {
+			p.pcombinestate = new(pcombinestate)
+			cmdb, err := encodemeta.NewCoverageMetaDataBuilder(pd.PackagePath(), pd.PackageName(), pd.ModulePath())
+			if err != nil {
+				fatal("fatal error creating meta-data builder: %v", err)
+			}
+			dbgtrace(2, "install new pkm entry for package %s pk=%d", pd.PackagePath(), pkgIdx)
+			p.cmdb = cmdb
+			p.ftab = make(map[[16]byte]uint32)
+		} else {
+			var err error
+			p.mdblob, err = mm.pod.mfr.GetPackagePayload(pkgIdx, nil)
+			if err != nil {
+				fatal("error extracting package %d payload from %s: %v",
+					pkgIdx, mm.pod.mdf, err)
+			}
+		}
+		p.ctab = make(map[uint32]decodecounter.FuncPayload)
+	}
+	mm.p = p
+}
+
+func (mm *metaMerge) visitFuncCounterData(data decodecounter.FuncPayload) {
+	key := pkfunc{pk: data.PkgIdx, fcn: data.FuncIdx}
+	val := mm.pod.pmm[key]
+	// FIXME: in theory either A) len(val.Counters) is zero, or B)
+	// the two lengths are equal. Assert if not? Of course, we could
+	// see odd stuff if there is source file skew.
+	if *verbflag > 4 {
+		fmt.Printf("visit pk=%d fid=%d len(counters)=%d\n", data.PkgIdx, data.FuncIdx, len(data.Counters))
+	}
+	if len(val.Counters) < len(data.Counters) {
+		t := val.Counters
+		val.Counters = mm.AllocateCounters(len(data.Counters))
+		copy(val.Counters, t)
+	}
+	err, overflow := mm.MergeCounters(val.Counters, data.Counters)
+	if err != nil {
+		fatal("%v", err)
+	}
+	if overflow {
+		warn("uint32 overflow during counter merge")
+	}
+	mm.pod.pmm[key] = val
+}
+
+func (mm *metaMerge) visitFunc(pkgIdx uint32, fnIdx uint32, fd *coverage.FuncDesc, verb string, pcombine bool) {
+	if *verbflag >= 3 {
+		fmt.Printf("visit pk=%d fid=%d func %s\n", pkgIdx, fnIdx, fd.Funcname)
+	}
+
+	var counters []uint32
+	key := pkfunc{pk: pkgIdx, fcn: fnIdx}
+	v, haveCounters := mm.pod.pmm[key]
+	if haveCounters {
+		counters = v.Counters
+	}
+
+	if pcombine {
+		// If the merge is running in "combine programs" mode, then hash
+		// the function and look it up in the package ftab to see if we've
+		// encountered it before. If we haven't, then register it with the
+		// meta-data builder.
+		fnhash := encodemeta.HashFuncDesc(fd)
+		gfidx, ok := mm.p.ftab[fnhash]
+		if !ok {
+			// We haven't seen this function before, need to add it to
+			// the meta data.
+			gfidx = uint32(mm.p.cmdb.AddFunc(*fd))
+			mm.p.ftab[fnhash] = gfidx
+			if *verbflag >= 3 {
+				fmt.Printf("new meta entry for fn %s fid=%d\n", fd.Funcname, gfidx)
+			}
+		}
+		fnIdx = gfidx
+	}
+	if !haveCounters {
+		return
+	}
+
+	// Install counters in package ctab.
+	gfp, ok := mm.p.ctab[fnIdx]
+	if ok {
+		if verb == "subtract" || verb == "intersect" {
+			panic("should never see this for intersect/subtract")
+		}
+		if *verbflag >= 3 {
+			fmt.Printf("counter merge for %s fidx=%d\n", fd.Funcname, fnIdx)
+		}
+		// Merge.
+		err, overflow := mm.MergeCounters(gfp.Counters, counters)
+		if err != nil {
+			fatal("%v", err)
+		}
+		if overflow {
+			warn("uint32 overflow during counter merge")
+		}
+		mm.p.ctab[fnIdx] = gfp
+	} else {
+		if *verbflag >= 3 {
+			fmt.Printf("null merge for %s fidx %d\n", fd.Funcname, fnIdx)
+		}
+		gfp := v
+		gfp.PkgIdx = mm.p.pkgIdx
+		gfp.FuncIdx = fnIdx
+		mm.p.ctab[fnIdx] = gfp
+	}
+}

go/src/cmd/covdata/subtractintersect.go

@@ -0,0 +1,196 @@
+// Copyright 2022 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
+
+// This file contains functions and apis to support the "subtract" and
+// "intersect" subcommands of "go tool covdata".
+
+import (
+	"flag"
+	"fmt"
+	"internal/coverage"
+	"internal/coverage/decodecounter"
+	"internal/coverage/decodemeta"
+	"internal/coverage/pods"
+	"os"
+	"strings"
+)
+
+// makeSubtractIntersectOp creates a subtract or intersect operation.
+// 'mode' here must be either "subtract" or "intersect".
+func makeSubtractIntersectOp(mode string) covOperation {
+	outdirflag = flag.String("o", "", "Output directory to write")
+	s := &sstate{
+		mode:  mode,
+		mm:    newMetaMerge(),
+		inidx: -1,
+	}
+	return s
+}
+
+// sstate holds state needed to implement subtraction and intersection
+// operations on code coverage data files. This type provides methods
+// to implement the CovDataVisitor interface, and is designed to be
+// used in concert with the CovDataReader utility, which abstracts
+// away most of the grubby details of reading coverage data files.
+type sstate struct {
+	mm    *metaMerge
+	inidx int
+	mode  string
+	// Used only for intersection; keyed by pkg/fn ID, it keeps track of
+	// just the set of functions for which we have data in the current
+	// input directory.
+	imm map[pkfunc]struct{}
+}
+
+func (s *sstate) Usage(msg string) {
+	if len(msg) > 0 {
+		fmt.Fprintf(os.Stderr, "error: %s\n", msg)
+	}
+	fmt.Fprintf(os.Stderr, "usage: go tool covdata %s -i=dir1,dir2 -o=<dir>\n\n", s.mode)
+	flag.PrintDefaults()
+	fmt.Fprintf(os.Stderr, "\nExamples:\n\n")
+	op := "from"
+	if s.mode == intersectMode {
+		op = "with"
+	}
+	fmt.Fprintf(os.Stderr, "  go tool covdata %s -i=dir1,dir2 -o=outdir\n\n", s.mode)
+	fmt.Fprintf(os.Stderr, "  \t%ss dir2 %s dir1, writing result\n", s.mode, op)
+	fmt.Fprintf(os.Stderr, "  \tinto output dir outdir.\n")
+	os.Exit(2)
+}
+
+func (s *sstate) Setup() {
+	if *indirsflag == "" {
+		usage("select input directories with '-i' option")
+	}
+	indirs := strings.Split(*indirsflag, ",")
+	if s.mode == subtractMode && len(indirs) != 2 {
+		usage("supply exactly two input dirs for subtract operation")
+	}
+	if *outdirflag == "" {
+		usage("select output directory with '-o' option")
+	}
+}
+
+func (s *sstate) BeginPod(p pods.Pod) {
+	s.mm.beginPod()
+}
+
+func (s *sstate) EndPod(p pods.Pod) {
+	const pcombine = false
+	s.mm.endPod(pcombine)
+}
+
+func (s *sstate) EndCounters() {
+	if s.imm != nil {
+		s.pruneCounters()
+	}
+}
+
+// pruneCounters performs a function-level partial intersection using the
+// current POD counter data (s.mm.pod.pmm) and the intersected data from
+// PODs in previous dirs (s.imm).
+func (s *sstate) pruneCounters() {
+	pkeys := make([]pkfunc, 0, len(s.mm.pod.pmm))
+	for k := range s.mm.pod.pmm {
+		pkeys = append(pkeys, k)
+	}
+	// Remove anything from pmm not found in imm. We don't need to
+	// go the other way (removing things from imm not found in pmm)
+	// since we don't add anything to imm if there is no pmm entry.
+	for _, k := range pkeys {
+		if _, found := s.imm[k]; !found {
+			delete(s.mm.pod.pmm, k)
+		}
+	}
+	s.imm = nil
+}
+
+func (s *sstate) BeginCounterDataFile(cdf string, cdr *decodecounter.CounterDataReader, dirIdx int) {
+	dbgtrace(2, "visiting counter data file %s diridx %d", cdf, dirIdx)
+	if s.inidx != dirIdx {
+		if s.inidx > dirIdx {
+			// We're relying on having data files presented in
+			// the order they appear in the inputs (e.g. first all
+			// data files from input dir 0, then dir 1, etc).
+			panic("decreasing dir index, internal error")
+		}
+		if dirIdx == 0 {
+			// No need to keep track of the functions in the first
+			// directory, since that info will be replicated in
+			// s.mm.pod.pmm.
+			s.imm = nil
+		} else {
+			// We're now starting to visit the Nth directory, N != 0.
+			if s.mode == intersectMode {
+				if s.imm != nil {
+					s.pruneCounters()
+				}
+				s.imm = make(map[pkfunc]struct{})
+			}
+		}
+		s.inidx = dirIdx
+	}
+}
+
+func (s *sstate) EndCounterDataFile(cdf string, cdr *decodecounter.CounterDataReader, dirIdx int) {
+}
+
+func (s *sstate) VisitFuncCounterData(data decodecounter.FuncPayload) {
+	key := pkfunc{pk: data.PkgIdx, fcn: data.FuncIdx}
+
+	if *verbflag >= 5 {
+		fmt.Printf("ctr visit fid=%d pk=%d inidx=%d data.Counters=%+v\n", data.FuncIdx, data.PkgIdx, s.inidx, data.Counters)
+	}
+
+	// If we're processing counter data from the initial (first) input
+	// directory, then just install it into the counter data map
+	// as usual.
+	if s.inidx == 0 {
+		s.mm.visitFuncCounterData(data)
+		return
+	}
+
+	// If we're looking at counter data from a dir other than
+	// the first, then perform the intersect/subtract.
+	if val, ok := s.mm.pod.pmm[key]; ok {
+		if s.mode == subtractMode {
+			for i := 0; i < len(data.Counters); i++ {
+				if data.Counters[i] != 0 {
+					val.Counters[i] = 0
+				}
+			}
+		} else if s.mode == intersectMode {
+			s.imm[key] = struct{}{}
+			for i := 0; i < len(data.Counters); i++ {
+				if data.Counters[i] == 0 {
+					val.Counters[i] = 0
+				}
+			}
+		}
+	}
+}
+
+func (s *sstate) VisitMetaDataFile(mdf string, mfr *decodemeta.CoverageMetaFileReader) {
+	if s.mode == intersectMode {
+		s.imm = make(map[pkfunc]struct{})
+	}
+	s.mm.visitMetaDataFile(mdf, mfr)
+}
+
+func (s *sstate) BeginPackage(pd *decodemeta.CoverageMetaDataDecoder, pkgIdx uint32) {
+	s.mm.visitPackage(pd, pkgIdx, false)
+}
+
+func (s *sstate) EndPackage(pd *decodemeta.CoverageMetaDataDecoder, pkgIdx uint32) {
+}
+
+func (s *sstate) VisitFunc(pkgIdx uint32, fnIdx uint32, fd *coverage.FuncDesc) {
+	s.mm.visitFunc(pkgIdx, fnIdx, fd, s.mode, false)
+}
+
+func (s *sstate) Finish() {
+}

go/src/cmd/covdata/tool_test.go

@@ -0,0 +1,943 @@
+// Copyright 2022 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_test
+
+import (
+	cmdcovdata "cmd/covdata"
+	"flag"
+	"fmt"
+	"internal/coverage/pods"
+	"internal/testenv"
+	"log"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"sync"
+	"testing"
+)
+
+// Top level tempdir for test.
+var testTempDir string
+
+// If set, this will preserve all the tmpdir files from the test run.
+var preserveTmp = flag.Bool("preservetmp", false, "keep tmpdir files for debugging")
+
+// TestMain used here so that we can leverage the test executable
+// itself as a cmd/covdata executable; compare to similar usage in
+// the cmd/go tests.
+func TestMain(m *testing.M) {
+	// When CMDCOVDATA_TEST_RUN_MAIN is set, we're reusing the test
+	// binary as cmd/cover. In this case we run the main func exported
+	// via export_test.go, and exit; CMDCOVDATA_TEST_RUN_MAIN is set below
+	// for actual test invocations.
+	if os.Getenv("CMDCOVDATA_TEST_RUN_MAIN") != "" {
+		cmdcovdata.Main()
+		os.Exit(0)
+	}
+	flag.Parse()
+	topTmpdir, err := os.MkdirTemp("", "cmd-covdata-test-")
+	if err != nil {
+		log.Fatal(err)
+	}
+	testTempDir = topTmpdir
+	if !*preserveTmp {
+		defer os.RemoveAll(topTmpdir)
+	} else {
+		fmt.Fprintf(os.Stderr, "debug: preserving tmpdir %s\n", topTmpdir)
+	}
+	os.Setenv("CMDCOVDATA_TEST_RUN_MAIN", "true")
+	os.Exit(m.Run())
+}
+
+var tdmu sync.Mutex
+var tdcount int
+
+func tempDir(t *testing.T) string {
+	tdmu.Lock()
+	dir := filepath.Join(testTempDir, fmt.Sprintf("%03d", tdcount))
+	tdcount++
+	if err := os.Mkdir(dir, 0777); err != nil {
+		t.Fatal(err)
+	}
+	defer tdmu.Unlock()
+	return dir
+}
+
+const debugtrace = false
+
+func gobuild(t *testing.T, indir string, bargs []string) {
+	t.Helper()
+
+	if debugtrace {
+		if indir != "" {
+			t.Logf("in dir %s: ", indir)
+		}
+		t.Logf("cmd: %s %+v\n", testenv.GoToolPath(t), bargs)
+	}
+	cmd := testenv.Command(t, testenv.GoToolPath(t), bargs...)
+	cmd.Dir = indir
+	b, err := cmd.CombinedOutput()
+	if len(b) != 0 {
+		t.Logf("## build output:\n%s", b)
+	}
+	if err != nil {
+		t.Fatalf("build error: %v", err)
+	}
+}
+
+func emitFile(t *testing.T, dst, src string) {
+	payload, err := os.ReadFile(src)
+	if err != nil {
+		t.Fatalf("error reading %q: %v", src, err)
+	}
+	if err := os.WriteFile(dst, payload, 0666); err != nil {
+		t.Fatalf("writing %q: %v", dst, err)
+	}
+}
+
+const mainPkgPath = "prog"
+
+func buildProg(t *testing.T, prog string, dir string, tag string, flags []string) (string, string) {
+	// Create subdirs.
+	subdir := filepath.Join(dir, prog+"dir"+tag)
+	if err := os.Mkdir(subdir, 0777); err != nil {
+		t.Fatalf("can't create outdir %s: %v", subdir, err)
+	}
+	depdir := filepath.Join(subdir, "dep")
+	if err := os.Mkdir(depdir, 0777); err != nil {
+		t.Fatalf("can't create outdir %s: %v", depdir, err)
+	}
+
+	// Emit program.
+	insrc := filepath.Join("testdata", prog+".go")
+	src := filepath.Join(subdir, prog+".go")
+	emitFile(t, src, insrc)
+	indep := filepath.Join("testdata", "dep.go")
+	dep := filepath.Join(depdir, "dep.go")
+	emitFile(t, dep, indep)
+
+	// Emit go.mod.
+	mod := filepath.Join(subdir, "go.mod")
+	modsrc := "\nmodule " + mainPkgPath + "\n\ngo 1.19\n"
+	if err := os.WriteFile(mod, []byte(modsrc), 0666); err != nil {
+		t.Fatal(err)
+	}
+	exepath := filepath.Join(subdir, prog+".exe")
+	bargs := []string{"build", "-cover", "-o", exepath}
+	bargs = append(bargs, flags...)
+	gobuild(t, subdir, bargs)
+	return exepath, subdir
+}
+
+type state struct {
+	dir      string
+	exedir1  string
+	exedir2  string
+	exedir3  string
+	exepath1 string
+	exepath2 string
+	exepath3 string
+	tool     string
+	outdirs  [4]string
+}
+
+const debugWorkDir = false
+
+func TestCovTool(t *testing.T) {
+	testenv.MustHaveGoBuild(t)
+	dir := tempDir(t)
+	if testing.Short() {
+		t.Skip()
+	}
+	if debugWorkDir {
+		// debugging
+		dir = "/tmp/qqq"
+		os.RemoveAll(dir)
+		os.Mkdir(dir, 0777)
+	}
+
+	s := state{
+		dir: dir,
+	}
+	s.exepath1, s.exedir1 = buildProg(t, "prog1", dir, "", nil)
+	s.exepath2, s.exedir2 = buildProg(t, "prog2", dir, "", nil)
+	flags := []string{"-covermode=atomic"}
+	s.exepath3, s.exedir3 = buildProg(t, "prog1", dir, "atomic", flags)
+
+	// Reuse unit test executable as tool to be tested.
+	s.tool = testenv.Executable(t)
+
+	// Create a few coverage output dirs.
+	for i := 0; i < 4; i++ {
+		d := filepath.Join(dir, fmt.Sprintf("covdata%d", i))
+		s.outdirs[i] = d
+		if err := os.Mkdir(d, 0777); err != nil {
+			t.Fatalf("can't create outdir %s: %v", d, err)
+		}
+	}
+
+	// Run instrumented program to generate some coverage data output files,
+	// as follows:
+	//
+	//   <tmp>/covdata0   -- prog1.go compiled -cover
+	//   <tmp>/covdata1   -- prog1.go compiled -cover
+	//   <tmp>/covdata2   -- prog1.go compiled -covermode=atomic
+	//   <tmp>/covdata3   -- prog1.go compiled -covermode=atomic
+	//
+	for m := 0; m < 2; m++ {
+		for k := 0; k < 2; k++ {
+			args := []string{}
+			if k != 0 {
+				args = append(args, "foo", "bar")
+			}
+			for i := 0; i <= k; i++ {
+				exepath := s.exepath1
+				if m != 0 {
+					exepath = s.exepath3
+				}
+				cmd := testenv.Command(t, exepath, args...)
+				cmd.Env = append(cmd.Env, "GOCOVERDIR="+s.outdirs[m*2+k])
+				b, err := cmd.CombinedOutput()
+				if len(b) != 0 {
+					t.Logf("## instrumented run output:\n%s", b)
+				}
+				if err != nil {
+					t.Fatalf("instrumented run error: %v", err)
+				}
+			}
+		}
+	}
+
+	// At this point we can fork off a bunch of child tests
+	// to check different tool modes.
+	t.Run("MergeSimple", func(t *testing.T) {
+		t.Parallel()
+		testMergeSimple(t, s, s.outdirs[0], s.outdirs[1], "set")
+		testMergeSimple(t, s, s.outdirs[2], s.outdirs[3], "atomic")
+	})
+	t.Run("MergeSelect", func(t *testing.T) {
+		t.Parallel()
+		testMergeSelect(t, s, s.outdirs[0], s.outdirs[1], "set")
+		testMergeSelect(t, s, s.outdirs[2], s.outdirs[3], "atomic")
+	})
+	t.Run("MergePcombine", func(t *testing.T) {
+		t.Parallel()
+		testMergeCombinePrograms(t, s)
+	})
+	t.Run("Dump", func(t *testing.T) {
+		t.Parallel()
+		testDump(t, s)
+	})
+	t.Run("Percent", func(t *testing.T) {
+		t.Parallel()
+		testPercent(t, s)
+	})
+	t.Run("PkgList", func(t *testing.T) {
+		t.Parallel()
+		testPkgList(t, s)
+	})
+	t.Run("Textfmt", func(t *testing.T) {
+		t.Parallel()
+		testTextfmt(t, s)
+	})
+	t.Run("Subtract", func(t *testing.T) {
+		t.Parallel()
+		testSubtract(t, s)
+	})
+	t.Run("Intersect", func(t *testing.T) {
+		t.Parallel()
+		testIntersect(t, s, s.outdirs[0], s.outdirs[1], "set")
+		testIntersect(t, s, s.outdirs[2], s.outdirs[3], "atomic")
+	})
+	t.Run("CounterClash", func(t *testing.T) {
+		t.Parallel()
+		testCounterClash(t, s)
+	})
+	t.Run("TestEmpty", func(t *testing.T) {
+		t.Parallel()
+		testEmpty(t, s)
+	})
+	t.Run("TestCommandLineErrors", func(t *testing.T) {
+		t.Parallel()
+		testCommandLineErrors(t, s, s.outdirs[0])
+	})
+}
+
+const showToolInvocations = true
+
+func runToolOp(t *testing.T, s state, op string, args []string) []string {
+	// Perform tool run.
+	t.Helper()
+	args = append([]string{op}, args...)
+	if showToolInvocations {
+		t.Logf("%s cmd is: %s %+v", op, s.tool, args)
+	}
+	cmd := testenv.Command(t, s.tool, args...)
+	b, err := cmd.CombinedOutput()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "## %s output: %s\n", op, b)
+		t.Fatalf("%q run error: %v", op, err)
+	}
+	output := strings.TrimSpace(string(b))
+	lines := strings.Split(output, "\n")
+	if len(lines) == 1 && lines[0] == "" {
+		lines = nil
+	}
+	return lines
+}
+
+func testDump(t *testing.T, s state) {
+	// Run the dumper on the two dirs we generated.
+	dargs := []string{"-pkg=" + mainPkgPath, "-live", "-i=" + s.outdirs[0] + "," + s.outdirs[1]}
+	lines := runToolOp(t, s, "debugdump", dargs)
+
+	// Sift through the output to make sure it has some key elements.
+	testpoints := []struct {
+		tag string
+		re  *regexp.Regexp
+	}{
+		{
+			"args",
+			regexp.MustCompile(`^data file .+ GOOS=.+ GOARCH=.+ program args: .+$`),
+		},
+		{
+			"main package",
+			regexp.MustCompile(`^Package path: ` + mainPkgPath + `\s*$`),
+		},
+		{
+			"main function",
+			regexp.MustCompile(`^Func: main\s*$`),
+		},
+	}
+
+	bad := false
+	for _, testpoint := range testpoints {
+		found := false
+		for _, line := range lines {
+			if m := testpoint.re.FindStringSubmatch(line); m != nil {
+				found = true
+				break
+			}
+		}
+		if !found {
+			t.Errorf("dump output regexp match failed for %q", testpoint.tag)
+			bad = true
+		}
+	}
+	if bad {
+		dumplines(lines)
+	}
+}
+
+func testPercent(t *testing.T, s state) {
+	// Run the dumper on the two dirs we generated.
+	dargs := []string{"-pkg=" + mainPkgPath, "-i=" + s.outdirs[0] + "," + s.outdirs[1]}
+	lines := runToolOp(t, s, "percent", dargs)
+
+	// Sift through the output to make sure it has the needful.
+	testpoints := []struct {
+		tag string
+		re  *regexp.Regexp
+	}{
+		{
+			"statement coverage percent",
+			regexp.MustCompile(`coverage: \d+\.\d% of statements\s*$`),
+		},
+	}
+
+	bad := false
+	for _, testpoint := range testpoints {
+		found := false
+		for _, line := range lines {
+			if m := testpoint.re.FindStringSubmatch(line); m != nil {
+				found = true
+				break
+			}
+		}
+		if !found {
+			t.Errorf("percent output regexp match failed for %s", testpoint.tag)
+			bad = true
+		}
+	}
+	if bad {
+		dumplines(lines)
+	}
+}
+
+func testPkgList(t *testing.T, s state) {
+	dargs := []string{"-i=" + s.outdirs[0] + "," + s.outdirs[1]}
+	lines := runToolOp(t, s, "pkglist", dargs)
+
+	want := []string{mainPkgPath, mainPkgPath + "/dep"}
+	bad := false
+	if len(lines) != 2 {
+		t.Errorf("expect pkglist to return two lines")
+		bad = true
+	} else {
+		for i := 0; i < 2; i++ {
+			lines[i] = strings.TrimSpace(lines[i])
+			if want[i] != lines[i] {
+				t.Errorf("line %d want %s got %s", i, want[i], lines[i])
+				bad = true
+			}
+		}
+	}
+	if bad {
+		dumplines(lines)
+	}
+}
+
+func testTextfmt(t *testing.T, s state) {
+	outf := s.dir + "/" + "t.txt"
+	dargs := []string{"-pkg=" + mainPkgPath, "-i=" + s.outdirs[0] + "," + s.outdirs[1],
+		"-o", outf}
+	lines := runToolOp(t, s, "textfmt", dargs)
+
+	// No output expected.
+	if len(lines) != 0 {
+		dumplines(lines)
+		t.Errorf("unexpected output from go tool covdata textfmt")
+	}
+
+	// Open and read the first few bits of the file.
+	payload, err := os.ReadFile(outf)
+	if err != nil {
+		t.Errorf("opening %s: %v\n", outf, err)
+	}
+	lines = strings.Split(string(payload), "\n")
+	want0 := "mode: set"
+	if lines[0] != want0 {
+		dumplines(lines[0:10])
+		t.Errorf("textfmt: want %s got %s", want0, lines[0])
+	}
+	want1 := mainPkgPath + "/prog1.go:13.14,15.2 1 1"
+	if lines[1] != want1 {
+		dumplines(lines[0:10])
+		t.Errorf("textfmt: want %s got %s", want1, lines[1])
+	}
+}
+
+func dumplines(lines []string) {
+	for i := range lines {
+		fmt.Fprintf(os.Stderr, "%s\n", lines[i])
+	}
+}
+
+type dumpCheck struct {
+	tag     string
+	re      *regexp.Regexp
+	negate  bool
+	nonzero bool
+	zero    bool
+}
+
+// runDumpChecks examines the output of "go tool covdata debugdump"
+// for a given output directory, looking for the presence or absence
+// of specific markers.
+func runDumpChecks(t *testing.T, s state, dir string, flags []string, checks []dumpCheck) {
+	dargs := []string{"-i", dir}
+	dargs = append(dargs, flags...)
+	lines := runToolOp(t, s, "debugdump", dargs)
+	if len(lines) == 0 {
+		t.Fatalf("dump run produced no output")
+	}
+
+	bad := false
+	for _, check := range checks {
+		found := false
+		for _, line := range lines {
+			if m := check.re.FindStringSubmatch(line); m != nil {
+				found = true
+				if check.negate {
+					t.Errorf("tag %q: unexpected match", check.tag)
+					bad = true
+
+				}
+				if check.nonzero || check.zero {
+					if len(m) < 2 {
+						t.Errorf("tag %s: submatch failed (short m)", check.tag)
+						bad = true
+						continue
+					}
+					if m[1] == "" {
+						t.Errorf("tag %s: submatch failed", check.tag)
+						bad = true
+						continue
+					}
+					i, err := strconv.Atoi(m[1])
+					if err != nil {
+						t.Errorf("tag %s: match Atoi failed on %s",
+							check.tag, m[1])
+						continue
+					}
+					if check.zero && i != 0 {
+						t.Errorf("tag %s: match zero failed on %s",
+							check.tag, m[1])
+					} else if check.nonzero && i == 0 {
+						t.Errorf("tag %s: match nonzero failed on %s",
+							check.tag, m[1])
+					}
+				}
+				break
+			}
+		}
+		if !found && !check.negate {
+			t.Errorf("dump output regexp match failed for %s", check.tag)
+			bad = true
+		}
+	}
+	if bad {
+		fmt.Printf("output from 'dump' run:\n")
+		dumplines(lines)
+	}
+}
+
+func testMergeSimple(t *testing.T, s state, indir1, indir2, tag string) {
+	outdir := filepath.Join(s.dir, "simpleMergeOut"+tag)
+	if err := os.Mkdir(outdir, 0777); err != nil {
+		t.Fatalf("can't create outdir %s: %v", outdir, err)
+	}
+
+	// Merge the two dirs into a final result.
+	ins := fmt.Sprintf("-i=%s,%s", indir1, indir2)
+	out := fmt.Sprintf("-o=%s", outdir)
+	margs := []string{ins, out}
+	lines := runToolOp(t, s, "merge", margs)
+	if len(lines) != 0 {
+		t.Errorf("merge run produced %d lines of unexpected output", len(lines))
+		dumplines(lines)
+	}
+
+	// We expect the merge tool to produce exactly two files: a meta
+	// data file and a counter file. If we get more than just this one
+	// pair, something went wrong.
+	podlist, err := pods.CollectPods([]string{outdir}, true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(podlist) != 1 {
+		t.Fatalf("expected 1 pod, got %d pods", len(podlist))
+	}
+	ncdfs := len(podlist[0].CounterDataFiles)
+	if ncdfs != 1 {
+		t.Fatalf("expected 1 counter data file, got %d", ncdfs)
+	}
+
+	// Sift through the output to make sure it has some key elements.
+	// In particular, we want to see entries for all three functions
+	// ("first", "second", and "third").
+	testpoints := []dumpCheck{
+		{
+			tag: "first function",
+			re:  regexp.MustCompile(`^Func: first\s*$`),
+		},
+		{
+			tag: "second function",
+			re:  regexp.MustCompile(`^Func: second\s*$`),
+		},
+		{
+			tag: "third function",
+			re:  regexp.MustCompile(`^Func: third\s*$`),
+		},
+		{
+			tag:     "third function unit 0",
+			re:      regexp.MustCompile(`^0: L23:C23 -- L24:C12 NS=1 = (\d+)$`),
+			nonzero: true,
+		},
+		{
+			tag:     "third function unit 1",
+			re:      regexp.MustCompile(`^1: L27:C2 -- L28:C10 NS=2 = (\d+)$`),
+			nonzero: true,
+		},
+		{
+			tag:     "third function unit 2",
+			re:      regexp.MustCompile(`^2: L24:C12 -- L26:C3 NS=1 = (\d+)$`),
+			nonzero: true,
+		},
+	}
+	flags := []string{"-live", "-pkg=" + mainPkgPath}
+	runDumpChecks(t, s, outdir, flags, testpoints)
+}
+
+func testMergeSelect(t *testing.T, s state, indir1, indir2 string, tag string) {
+	outdir := filepath.Join(s.dir, "selectMergeOut"+tag)
+	if err := os.Mkdir(outdir, 0777); err != nil {
+		t.Fatalf("can't create outdir %s: %v", outdir, err)
+	}
+
+	// Merge two input dirs into a final result, but filter
+	// based on package.
+	ins := fmt.Sprintf("-i=%s,%s", indir1, indir2)
+	out := fmt.Sprintf("-o=%s", outdir)
+	margs := []string{"-pkg=" + mainPkgPath + "/dep", ins, out}
+	lines := runToolOp(t, s, "merge", margs)
+	if len(lines) != 0 {
+		t.Errorf("merge run produced %d lines of unexpected output", len(lines))
+		dumplines(lines)
+	}
+
+	// Dump the files in the merged output dir and examine the result.
+	// We expect to see only the functions in package "dep".
+	dargs := []string{"-i=" + outdir}
+	lines = runToolOp(t, s, "debugdump", dargs)
+	if len(lines) == 0 {
+		t.Fatalf("dump run produced no output")
+	}
+	want := map[string]int{
+		"Package path: " + mainPkgPath + "/dep": 0,
+		"Func: Dep1":                            0,
+		"Func: PDep":                            0,
+	}
+	bad := false
+	for _, line := range lines {
+		if v, ok := want[line]; ok {
+			if v != 0 {
+				t.Errorf("duplicate line %s", line)
+				bad = true
+				break
+			}
+			want[line] = 1
+			continue
+		}
+		// no other functions or packages expected.
+		if strings.HasPrefix(line, "Func:") || strings.HasPrefix(line, "Package path:") {
+			t.Errorf("unexpected line: %s", line)
+			bad = true
+			break
+		}
+	}
+	if bad {
+		dumplines(lines)
+	}
+}
+
+func testMergeCombinePrograms(t *testing.T, s state) {
+
+	// Run the new program, emitting output into a new set
+	// of outdirs.
+	runout := [2]string{}
+	for k := 0; k < 2; k++ {
+		runout[k] = filepath.Join(s.dir, fmt.Sprintf("newcovdata%d", k))
+		if err := os.Mkdir(runout[k], 0777); err != nil {
+			t.Fatalf("can't create outdir %s: %v", runout[k], err)
+		}
+		args := []string{}
+		if k != 0 {
+			args = append(args, "foo", "bar")
+		}
+		cmd := testenv.Command(t, s.exepath2, args...)
+		cmd.Env = append(cmd.Env, "GOCOVERDIR="+runout[k])
+		b, err := cmd.CombinedOutput()
+		if len(b) != 0 {
+			t.Logf("## instrumented run output:\n%s", b)
+		}
+		if err != nil {
+			t.Fatalf("instrumented run error: %v", err)
+		}
+	}
+
+	// Create out dir for -pcombine merge.
+	moutdir := filepath.Join(s.dir, "mergeCombineOut")
+	if err := os.Mkdir(moutdir, 0777); err != nil {
+		t.Fatalf("can't create outdir %s: %v", moutdir, err)
+	}
+
+	// Run a merge over both programs, using the -pcombine
+	// flag to do maximal combining.
+	ins := fmt.Sprintf("-i=%s,%s,%s,%s", s.outdirs[0], s.outdirs[1],
+		runout[0], runout[1])
+	out := fmt.Sprintf("-o=%s", moutdir)
+	margs := []string{"-pcombine", ins, out}
+	lines := runToolOp(t, s, "merge", margs)
+	if len(lines) != 0 {
+		t.Errorf("merge run produced unexpected output: %v", lines)
+	}
+
+	// We expect the merge tool to produce exactly two files: a meta
+	// data file and a counter file. If we get more than just this one
+	// pair, something went wrong.
+	podlist, err := pods.CollectPods([]string{moutdir}, true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(podlist) != 1 {
+		t.Fatalf("expected 1 pod, got %d pods", len(podlist))
+	}
+	ncdfs := len(podlist[0].CounterDataFiles)
+	if ncdfs != 1 {
+		t.Fatalf("expected 1 counter data file, got %d", ncdfs)
+	}
+
+	// Sift through the output to make sure it has some key elements.
+	testpoints := []dumpCheck{
+		{
+			tag: "first function",
+			re:  regexp.MustCompile(`^Func: first\s*$`),
+		},
+		{
+			tag: "sixth function",
+			re:  regexp.MustCompile(`^Func: sixth\s*$`),
+		},
+	}
+
+	flags := []string{"-live", "-pkg=" + mainPkgPath}
+	runDumpChecks(t, s, moutdir, flags, testpoints)
+}
+
+func testSubtract(t *testing.T, s state) {
+	// Create out dir for subtract merge.
+	soutdir := filepath.Join(s.dir, "subtractOut")
+	if err := os.Mkdir(soutdir, 0777); err != nil {
+		t.Fatalf("can't create outdir %s: %v", soutdir, err)
+	}
+
+	// Subtract the two dirs into a final result.
+	ins := fmt.Sprintf("-i=%s,%s", s.outdirs[0], s.outdirs[1])
+	out := fmt.Sprintf("-o=%s", soutdir)
+	sargs := []string{ins, out}
+	lines := runToolOp(t, s, "subtract", sargs)
+	if len(lines) != 0 {
+		t.Errorf("subtract run produced unexpected output: %+v", lines)
+	}
+
+	// Dump the files in the subtract output dir and examine the result.
+	dargs := []string{"-pkg=" + mainPkgPath, "-live", "-i=" + soutdir}
+	lines = runToolOp(t, s, "debugdump", dargs)
+	if len(lines) == 0 {
+		t.Errorf("dump run produced no output")
+	}
+
+	// Vet the output.
+	testpoints := []dumpCheck{
+		{
+			tag: "first function",
+			re:  regexp.MustCompile(`^Func: first\s*$`),
+		},
+		{
+			tag: "dep function",
+			re:  regexp.MustCompile(`^Func: Dep1\s*$`),
+		},
+		{
+			tag: "third function",
+			re:  regexp.MustCompile(`^Func: third\s*$`),
+		},
+		{
+			tag:  "third function unit 0",
+			re:   regexp.MustCompile(`^0: L23:C23 -- L24:C12 NS=1 = (\d+)$`),
+			zero: true,
+		},
+		{
+			tag:     "third function unit 1",
+			re:      regexp.MustCompile(`^1: L27:C2 -- L28:C10 NS=2 = (\d+)$`),
+			nonzero: true,
+		},
+		{
+			tag:  "third function unit 2",
+			re:   regexp.MustCompile(`^2: L24:C12 -- L26:C3 NS=1 = (\d+)$`),
+			zero: true,
+		},
+	}
+	flags := []string{}
+	runDumpChecks(t, s, soutdir, flags, testpoints)
+}
+
+func testIntersect(t *testing.T, s state, indir1, indir2, tag string) {
+	// Create out dir for intersection.
+	ioutdir := filepath.Join(s.dir, "intersectOut"+tag)
+	if err := os.Mkdir(ioutdir, 0777); err != nil {
+		t.Fatalf("can't create outdir %s: %v", ioutdir, err)
+	}
+
+	// Intersect the two dirs into a final result.
+	ins := fmt.Sprintf("-i=%s,%s", indir1, indir2)
+	out := fmt.Sprintf("-o=%s", ioutdir)
+	sargs := []string{ins, out}
+	lines := runToolOp(t, s, "intersect", sargs)
+	if len(lines) != 0 {
+		t.Errorf("intersect run produced unexpected output: %+v", lines)
+	}
+
+	// Dump the files in the subtract output dir and examine the result.
+	dargs := []string{"-pkg=" + mainPkgPath, "-live", "-i=" + ioutdir}
+	lines = runToolOp(t, s, "debugdump", dargs)
+	if len(lines) == 0 {
+		t.Errorf("dump run produced no output")
+	}
+
+	// Vet the output.
+	testpoints := []dumpCheck{
+		{
+			tag:    "first function",
+			re:     regexp.MustCompile(`^Func: first\s*$`),
+			negate: true,
+		},
+		{
+			tag: "third function",
+			re:  regexp.MustCompile(`^Func: third\s*$`),
+		},
+	}
+	flags := []string{"-live"}
+	runDumpChecks(t, s, ioutdir, flags, testpoints)
+}
+
+func testCounterClash(t *testing.T, s state) {
+	// Create out dir.
+	ccoutdir := filepath.Join(s.dir, "ccOut")
+	if err := os.Mkdir(ccoutdir, 0777); err != nil {
+		t.Fatalf("can't create outdir %s: %v", ccoutdir, err)
+	}
+
+	// Try to merge covdata0 (from prog1.go -countermode=set) with
+	// covdata1 (from prog1.go -countermode=atomic"). This should
+	// work properly, but result in multiple meta-data files.
+	ins := fmt.Sprintf("-i=%s,%s", s.outdirs[0], s.outdirs[3])
+	out := fmt.Sprintf("-o=%s", ccoutdir)
+	args := append([]string{}, "merge", ins, out, "-pcombine")
+	if debugtrace {
+		t.Logf("cc merge command is %s %v\n", s.tool, args)
+	}
+	cmd := testenv.Command(t, s.tool, args...)
+	b, err := cmd.CombinedOutput()
+	t.Logf("%% output: %s\n", string(b))
+	if err != nil {
+		t.Fatalf("clash merge failed: %v", err)
+	}
+
+	// Ask for a textual report from the two dirs. Here we have
+	// to report the mode clash.
+	out = "-o=" + filepath.Join(ccoutdir, "file.txt")
+	args = append([]string{}, "textfmt", ins, out)
+	if debugtrace {
+		t.Logf("clash textfmt command is %s %v\n", s.tool, args)
+	}
+	cmd = testenv.Command(t, s.tool, args...)
+	b, err = cmd.CombinedOutput()
+	t.Logf("%% output: %s\n", string(b))
+	if err == nil {
+		t.Fatalf("expected mode clash")
+	}
+	got := string(b)
+	want := "counter mode clash while reading meta-data"
+	if !strings.Contains(got, want) {
+		t.Errorf("counter clash textfmt: wanted %s got %s", want, got)
+	}
+}
+
+func testEmpty(t *testing.T, s state) {
+
+	// Create a new empty directory.
+	empty := filepath.Join(s.dir, "empty")
+	if err := os.Mkdir(empty, 0777); err != nil {
+		t.Fatalf("can't create dir %s: %v", empty, err)
+	}
+
+	// Create out dir.
+	eoutdir := filepath.Join(s.dir, "emptyOut")
+	if err := os.Mkdir(eoutdir, 0777); err != nil {
+		t.Fatalf("can't create outdir %s: %v", eoutdir, err)
+	}
+
+	// Run various operations (merge, dump, textfmt, and so on)
+	// using the empty directory. We're not interested in the output
+	// here, just making sure that you can do these runs without
+	// any error or crash.
+
+	scenarios := []struct {
+		tag  string
+		args []string
+	}{
+		{
+			tag:  "merge",
+			args: []string{"merge", "-o", eoutdir},
+		},
+		{
+			tag:  "textfmt",
+			args: []string{"textfmt", "-o", filepath.Join(eoutdir, "foo.txt")},
+		},
+		{
+			tag:  "func",
+			args: []string{"func"},
+		},
+		{
+			tag:  "pkglist",
+			args: []string{"pkglist"},
+		},
+		{
+			tag:  "debugdump",
+			args: []string{"debugdump"},
+		},
+		{
+			tag:  "percent",
+			args: []string{"percent"},
+		},
+	}
+
+	for _, x := range scenarios {
+		ins := fmt.Sprintf("-i=%s", empty)
+		args := append([]string{}, x.args...)
+		args = append(args, ins)
+		if false {
+			t.Logf("cmd is %s %v\n", s.tool, args)
+		}
+		cmd := testenv.Command(t, s.tool, args...)
+		b, err := cmd.CombinedOutput()
+		t.Logf("%% output: %s\n", string(b))
+		if err != nil {
+			t.Fatalf("command %s %+v failed with %v",
+				s.tool, x.args, err)
+		}
+	}
+}
+
+func testCommandLineErrors(t *testing.T, s state, outdir string) {
+
+	// Create out dir.
+	eoutdir := filepath.Join(s.dir, "errorsOut")
+	if err := os.Mkdir(eoutdir, 0777); err != nil {
+		t.Fatalf("can't create outdir %s: %v", eoutdir, err)
+	}
+
+	// Run various operations (merge, dump, textfmt, and so on)
+	// using the empty directory. We're not interested in the output
+	// here, just making sure that you can do these runs without
+	// any error or crash.
+
+	scenarios := []struct {
+		tag  string
+		args []string
+		exp  string
+	}{
+		{
+			tag:  "input missing",
+			args: []string{"merge", "-o", eoutdir, "-i", "not there"},
+			exp:  "error: reading inputs: ",
+		},
+		{
+			tag:  "badv",
+			args: []string{"textfmt", "-i", outdir, "-v=abc"},
+		},
+	}
+
+	for _, x := range scenarios {
+		args := append([]string{}, x.args...)
+		if false {
+			t.Logf("cmd is %s %v\n", s.tool, args)
+		}
+		cmd := testenv.Command(t, s.tool, args...)
+		b, err := cmd.CombinedOutput()
+		if err == nil {
+			t.Logf("%% output: %s\n", string(b))
+			t.Fatalf("command %s %+v unexpectedly succeeded",
+				s.tool, x.args)
+		} else {
+			if !strings.Contains(string(b), x.exp) {
+				t.Fatalf("command %s %+v:\ngot:\n%s\nwanted to see: %v\n",
+					s.tool, x.args, string(b), x.exp)
+			}
+		}
+	}
+}

go/src/cmd/cover/cfg_test.go

@@ -0,0 +1,271 @@
+// Copyright 2022 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_test
+
+import (
+	"cmd/internal/cov/covcmd"
+	"encoding/json"
+	"fmt"
+	"internal/testenv"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func writeFile(t *testing.T, path string, contents []byte) {
+	if err := os.WriteFile(path, contents, 0666); err != nil {
+		t.Fatalf("os.WriteFile(%s) failed: %v", path, err)
+	}
+}
+
+func writePkgConfig(t *testing.T, outdir, tag, ppath, pname string, gran string, mpath string) string {
+	incfg := filepath.Join(outdir, tag+"incfg.txt")
+	outcfg := filepath.Join(outdir, "outcfg.txt")
+	p := covcmd.CoverPkgConfig{
+		PkgPath:      ppath,
+		PkgName:      pname,
+		Granularity:  gran,
+		OutConfig:    outcfg,
+		EmitMetaFile: mpath,
+	}
+	data, err := json.Marshal(p)
+	if err != nil {
+		t.Fatalf("json.Marshal failed: %v", err)
+	}
+	writeFile(t, incfg, data)
+	return incfg
+}
+
+func writeOutFileList(t *testing.T, infiles []string, outdir, tag string) ([]string, string) {
+	outfilelist := filepath.Join(outdir, tag+"outfilelist.txt")
+	var sb strings.Builder
+	cv := filepath.Join(outdir, "covervars.go")
+	outfs := []string{cv}
+	fmt.Fprintf(&sb, "%s\n", cv)
+	for _, inf := range infiles {
+		base := filepath.Base(inf)
+		of := filepath.Join(outdir, tag+".cov."+base)
+		outfs = append(outfs, of)
+		fmt.Fprintf(&sb, "%s\n", of)
+	}
+	if err := os.WriteFile(outfilelist, []byte(sb.String()), 0666); err != nil {
+		t.Fatalf("writing %s: %v", outfilelist, err)
+	}
+	return outfs, outfilelist
+}
+
+func runPkgCover(t *testing.T, outdir string, tag string, incfg string, mode string, infiles []string, errExpected bool) ([]string, string, string) {
+	// Write the pkgcfg file.
+	outcfg := filepath.Join(outdir, "outcfg.txt")
+
+	// Form up the arguments and run the tool.
+	outfiles, outfilelist := writeOutFileList(t, infiles, outdir, tag)
+	args := []string{"-pkgcfg", incfg, "-mode=" + mode, "-var=var" + tag, "-outfilelist", outfilelist}
+	args = append(args, infiles...)
+	cmd := testenv.Command(t, testcover(t), args...)
+	if errExpected {
+		errmsg := runExpectingError(cmd, t)
+		return nil, "", errmsg
+	} else {
+		run(cmd, t)
+		return outfiles, outcfg, ""
+	}
+}
+
+func TestCoverWithCfg(t *testing.T) {
+	testenv.MustHaveGoRun(t)
+
+	t.Parallel()
+
+	// Subdir in testdata that has our input files of interest.
+	tpath := filepath.Join("testdata", "pkgcfg")
+	dir := tempDir(t)
+	instdira := filepath.Join(dir, "insta")
+	if err := os.Mkdir(instdira, 0777); err != nil {
+		t.Fatal(err)
+	}
+
+	scenarios := []struct {
+		mode, gran string
+	}{
+		{
+			mode: "count",
+			gran: "perblock",
+		},
+		{
+			mode: "set",
+			gran: "perfunc",
+		},
+		{
+			mode: "regonly",
+			gran: "perblock",
+		},
+	}
+
+	var incfg string
+	apkgfiles := []string{filepath.Join(tpath, "a", "a.go")}
+	for _, scenario := range scenarios {
+		// Instrument package "a", producing a set of instrumented output
+		// files and an 'output config' file to pass on to the compiler.
+		ppath := "cfg/a"
+		pname := "a"
+		mode := scenario.mode
+		gran := scenario.gran
+		tag := mode + "_" + gran
+		incfg = writePkgConfig(t, instdira, tag, ppath, pname, gran, "")
+		ofs, outcfg, _ := runPkgCover(t, instdira, tag, incfg, mode,
+			apkgfiles, false)
+		t.Logf("outfiles: %+v\n", ofs)
+
+		// Run the compiler on the files to make sure the result is
+		// buildable.
+		bargs := []string{"tool", "compile", "-p", "a", "-coveragecfg", outcfg}
+		bargs = append(bargs, ofs...)
+		cmd := testenv.Command(t, testenv.GoToolPath(t), bargs...)
+		cmd.Dir = instdira
+		run(cmd, t)
+	}
+
+	// Do some error testing to ensure that various bad options and
+	// combinations are properly rejected.
+
+	// Expect error if config file inaccessible/unreadable.
+	mode := "atomic"
+	errExpected := true
+	tag := "errors"
+	_, _, errmsg := runPkgCover(t, instdira, tag, "/not/a/file", mode,
+		apkgfiles, errExpected)
+	want := "error reading pkgconfig file"
+	if !strings.Contains(errmsg, want) {
+		t.Errorf("'bad config file' test: wanted %s got %s", want, errmsg)
+	}
+
+	// Expect err if config file contains unknown stuff.
+	t.Logf("mangling in config")
+	writeFile(t, incfg, []byte("blah=foo\n"))
+	_, _, errmsg = runPkgCover(t, instdira, tag, incfg, mode,
+		apkgfiles, errExpected)
+	want = "error reading pkgconfig file"
+	if !strings.Contains(errmsg, want) {
+		t.Errorf("'bad config file' test: wanted %s got %s", want, errmsg)
+	}
+
+	// Expect error on empty config file.
+	t.Logf("writing empty config")
+	writeFile(t, incfg, []byte("\n"))
+	_, _, errmsg = runPkgCover(t, instdira, tag, incfg, mode,
+		apkgfiles, errExpected)
+	if !strings.Contains(errmsg, want) {
+		t.Errorf("'bad config file' test: wanted %s got %s", want, errmsg)
+	}
+}
+
+func TestCoverOnPackageWithNoTestFiles(t *testing.T) {
+	testenv.MustHaveGoRun(t)
+
+	// For packages with no test files, the new "go test -cover"
+	// strategy is to run cmd/cover on the package in a special
+	// "EmitMetaFile" mode. When running in this mode, cmd/cover walks
+	// the package doing instrumentation, but when finished, instead of
+	// writing out instrumented source files, it directly emits a
+	// meta-data file for the package in question, essentially
+	// simulating the effect that you would get if you added a dummy
+	// "no-op" x_test.go file and then did a build and run of the test.
+
+	t.Run("YesFuncsNoTests", func(t *testing.T) {
+		testCoverNoTestsYesFuncs(t)
+	})
+	t.Run("NoFuncsNoTests", func(t *testing.T) {
+		testCoverNoTestsNoFuncs(t)
+	})
+}
+
+func testCoverNoTestsYesFuncs(t *testing.T) {
+	t.Parallel()
+	dir := tempDir(t)
+
+	// Run the cover command with "emit meta" enabled on a package
+	// with functions but no test files.
+	tpath := filepath.Join("testdata", "pkgcfg")
+	pkg1files := []string{filepath.Join(tpath, "yesFuncsNoTests", "yfnt.go")}
+	ppath := "cfg/yesFuncsNoTests"
+	pname := "yesFuncsNoTests"
+	mode := "count"
+	gran := "perblock"
+	tag := mode + "_" + gran
+	instdir := filepath.Join(dir, "inst")
+	if err := os.Mkdir(instdir, 0777); err != nil {
+		t.Fatal(err)
+	}
+	mdir := filepath.Join(dir, "meta")
+	if err := os.Mkdir(mdir, 0777); err != nil {
+		t.Fatal(err)
+	}
+	mpath := filepath.Join(mdir, "covmeta.xxx")
+	incfg := writePkgConfig(t, instdir, tag, ppath, pname, gran, mpath)
+	_, _, errmsg := runPkgCover(t, instdir, tag, incfg, mode,
+		pkg1files, false)
+	if errmsg != "" {
+		t.Fatalf("runPkgCover err: %q", errmsg)
+	}
+
+	// Check for existence of meta-data file.
+	if inf, err := os.Open(mpath); err != nil {
+		t.Fatalf("meta-data file not created: %v", err)
+	} else {
+		inf.Close()
+	}
+
+	// Make sure it is digestible.
+	cdargs := []string{"tool", "covdata", "percent", "-i", mdir}
+	cmd := testenv.Command(t, testenv.GoToolPath(t), cdargs...)
+	run(cmd, t)
+}
+
+func testCoverNoTestsNoFuncs(t *testing.T) {
+	t.Parallel()
+	dir := tempDir(t)
+
+	// Run the cover command with "emit meta" enabled on a package
+	// with no functions and no test files.
+	tpath := filepath.Join("testdata", "pkgcfg")
+	pkgfiles := []string{filepath.Join(tpath, "noFuncsNoTests", "nfnt.go")}
+	pname := "noFuncsNoTests"
+	mode := "count"
+	gran := "perblock"
+	ppath := "cfg/" + pname
+	tag := mode + "_" + gran
+	instdir := filepath.Join(dir, "inst2")
+	if err := os.Mkdir(instdir, 0777); err != nil {
+		t.Fatal(err)
+	}
+	mdir := filepath.Join(dir, "meta2")
+	if err := os.Mkdir(mdir, 0777); err != nil {
+		t.Fatal(err)
+	}
+	mpath := filepath.Join(mdir, "covmeta.yyy")
+	incfg := writePkgConfig(t, instdir, tag, ppath, pname, gran, mpath)
+	_, _, errmsg := runPkgCover(t, instdir, tag, incfg, mode,
+		pkgfiles, false)
+	if errmsg != "" {
+		t.Fatalf("runPkgCover err: %q", errmsg)
+	}
+
+	// We expect to see an empty meta-data file in this case.
+	if inf, err := os.Open(mpath); err != nil {
+		t.Fatalf("opening meta-data file: error %v", err)
+	} else {
+		defer inf.Close()
+		fi, err := inf.Stat()
+		if err != nil {
+			t.Fatalf("stat meta-data file: %v", err)
+		}
+		if fi.Size() != 0 {
+			t.Fatalf("want zero-sized meta-data file got size %d",
+				fi.Size())
+		}
+	}
+}

go/src/cmd/cover/cover.go

@@ -0,0 +1,1211 @@
+// Copyright 2013 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 (
+	"bytes"
+	"cmd/internal/cov/covcmd"
+	"cmp"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"internal/coverage"
+	"internal/coverage/encodemeta"
+	"internal/coverage/slicewriter"
+	"io"
+	"log"
+	"os"
+	"path/filepath"
+	"slices"
+	"strconv"
+	"strings"
+
+	"cmd/internal/edit"
+	"cmd/internal/objabi"
+	"cmd/internal/telemetry/counter"
+)
+
+const usageMessage = "" +
+	`Usage of 'go tool cover':
+Given a coverage profile produced by 'go test':
+	go test -coverprofile=c.out
+
+Open a web browser displaying annotated source code:
+	go tool cover -html=c.out
+
+Write out an HTML file instead of launching a web browser:
+	go tool cover -html=c.out -o coverage.html
+
+Display coverage percentages to stdout for each function:
+	go tool cover -func=c.out
+
+Finally, to generate modified source code with coverage annotations
+for a package (what go test -cover does):
+	go tool cover -mode=set -var=CoverageVariableName \
+		-pkgcfg=<config> -outfilelist=<file> file1.go ... fileN.go
+
+where -pkgcfg points to a file containing the package path,
+package name, module path, and related info from "go build",
+and -outfilelist points to a file containing the filenames
+of the instrumented output files (one per input file).
+See https://pkg.go.dev/cmd/internal/cov/covcmd#CoverPkgConfig for
+more on the package config.
+`
+
+func usage() {
+	fmt.Fprint(os.Stderr, usageMessage)
+	fmt.Fprintln(os.Stderr, "\nFlags:")
+	flag.PrintDefaults()
+	fmt.Fprintln(os.Stderr, "\n  Only one of -html, -func, or -mode may be set.")
+	os.Exit(2)
+}
+
+var (
+	mode             = flag.String("mode", "", "coverage mode: set, count, atomic")
+	varVar           = flag.String("var", "GoCover", "name of coverage variable to generate")
+	output           = flag.String("o", "", "file for output")
+	outfilelist      = flag.String("outfilelist", "", "file containing list of output files (one per line) if -pkgcfg is in use")
+	htmlOut          = flag.String("html", "", "generate HTML representation of coverage profile")
+	funcOut          = flag.String("func", "", "output coverage profile information for each function")
+	pkgcfg           = flag.String("pkgcfg", "", "enable full-package instrumentation mode using params from specified config file")
+	pkgconfig        covcmd.CoverPkgConfig
+	outputfiles      []string // list of *.cover.go instrumented outputs to write, one per input (set when -pkgcfg is in use)
+	profile          string   // The profile to read; the value of -html or -func
+	counterStmt      func(*File, string) string
+	covervarsoutfile string // an additional Go source file into which we'll write definitions of coverage counter variables + meta data variables (set when -pkgcfg is in use).
+	cmode            coverage.CounterMode
+	cgran            coverage.CounterGranularity
+)
+
+const (
+	atomicPackagePath = "sync/atomic"
+	atomicPackageName = "_cover_atomic_"
+)
+
+func main() {
+	counter.Open()
+
+	objabi.AddVersionFlag()
+	flag.Usage = usage
+	objabi.Flagparse(usage)
+	counter.Inc("cover/invocations")
+	counter.CountFlags("cover/flag:", *flag.CommandLine)
+
+	// Usage information when no arguments.
+	if flag.NFlag() == 0 && flag.NArg() == 0 {
+		flag.Usage()
+	}
+
+	err := parseFlags()
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		fmt.Fprintln(os.Stderr, `For usage information, run "go tool cover -help"`)
+		os.Exit(2)
+	}
+
+	// Generate coverage-annotated source.
+	if *mode != "" {
+		annotate(flag.Args())
+		return
+	}
+
+	// Output HTML or function coverage information.
+	if *htmlOut != "" {
+		err = htmlOutput(profile, *output)
+	} else {
+		err = funcOutput(profile, *output)
+	}
+
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "cover: %v\n", err)
+		os.Exit(2)
+	}
+}
+
+// parseFlags sets the profile and counterStmt globals and performs validations.
+func parseFlags() error {
+	profile = *htmlOut
+	if *funcOut != "" {
+		if profile != "" {
+			return fmt.Errorf("too many options")
+		}
+		profile = *funcOut
+	}
+
+	// Must either display a profile or rewrite Go source.
+	if (profile == "") == (*mode == "") {
+		return fmt.Errorf("too many options")
+	}
+
+	if *varVar != "" && !token.IsIdentifier(*varVar) {
+		return fmt.Errorf("-var: %q is not a valid identifier", *varVar)
+	}
+
+	if *mode != "" {
+		switch *mode {
+		case "set":
+			counterStmt = setCounterStmt
+			cmode = coverage.CtrModeSet
+		case "count":
+			counterStmt = incCounterStmt
+			cmode = coverage.CtrModeCount
+		case "atomic":
+			counterStmt = atomicCounterStmt
+			cmode = coverage.CtrModeAtomic
+		case "regonly":
+			counterStmt = nil
+			cmode = coverage.CtrModeRegOnly
+		case "testmain":
+			counterStmt = nil
+			cmode = coverage.CtrModeTestMain
+		default:
+			return fmt.Errorf("unknown -mode %v", *mode)
+		}
+
+		if flag.NArg() == 0 {
+			return fmt.Errorf("missing source file(s)")
+		} else {
+			if *pkgcfg != "" {
+				if *output != "" {
+					return fmt.Errorf("please use '-outfilelist' flag instead of '-o'")
+				}
+				var err error
+				if outputfiles, err = readOutFileList(*outfilelist); err != nil {
+					return err
+				}
+				covervarsoutfile = outputfiles[0]
+				outputfiles = outputfiles[1:]
+				numInputs := len(flag.Args())
+				numOutputs := len(outputfiles)
+				if numOutputs != numInputs {
+					return fmt.Errorf("number of output files (%d) not equal to number of input files (%d)", numOutputs, numInputs)
+				}
+				if err := readPackageConfig(*pkgcfg); err != nil {
+					return err
+				}
+				return nil
+			} else {
+				if *outfilelist != "" {
+					return fmt.Errorf("'-outfilelist' flag applicable only when -pkgcfg used")
+				}
+			}
+			if flag.NArg() == 1 {
+				return nil
+			}
+		}
+	} else if flag.NArg() == 0 {
+		return nil
+	}
+	return fmt.Errorf("too many arguments")
+}
+
+func readOutFileList(path string) ([]string, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return nil, fmt.Errorf("error reading -outfilelist file %q: %v", path, err)
+	}
+	return strings.Split(strings.TrimSpace(string(data)), "\n"), nil
+}
+
+func readPackageConfig(path string) error {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return fmt.Errorf("error reading pkgconfig file %q: %v", path, err)
+	}
+	if err := json.Unmarshal(data, &pkgconfig); err != nil {
+		return fmt.Errorf("error reading pkgconfig file %q: %v", path, err)
+	}
+	switch pkgconfig.Granularity {
+	case "perblock":
+		cgran = coverage.CtrGranularityPerBlock
+	case "perfunc":
+		cgran = coverage.CtrGranularityPerFunc
+	default:
+		return fmt.Errorf(`%s: pkgconfig requires perblock/perfunc value`, path)
+	}
+	return nil
+}
+
+// Block represents the information about a basic block to be recorded in the analysis.
+// Note: Our definition of basic block is based on control structures; we don't break
+// apart && and ||. We could but it doesn't seem important enough to bother.
+type Block struct {
+	startByte token.Pos
+	endByte   token.Pos
+	numStmt   int
+}
+
+// Package holds package-specific state.
+type Package struct {
+	mdb            *encodemeta.CoverageMetaDataBuilder
+	counterLengths []int
+}
+
+// Function holds func-specific state.
+type Func struct {
+	units      []coverage.CoverableUnit
+	counterVar string
+}
+
+// File is a wrapper for the state of a file used in the parser.
+// The basic parse tree walker is a method of this type.
+type File struct {
+	fset    *token.FileSet
+	name    string // Name of file.
+	astFile *ast.File
+	blocks  []Block
+	content []byte
+	edit    *edit.Buffer
+	mdb     *encodemeta.CoverageMetaDataBuilder
+	fn      Func
+	pkg     *Package
+}
+
+// findText finds text in the original source, starting at pos.
+// It correctly skips over comments and assumes it need not
+// handle quoted strings.
+// It returns a byte offset within f.src.
+func (f *File) findText(pos token.Pos, text string) int {
+	b := []byte(text)
+	start := f.offset(pos)
+	i := start
+	s := f.content
+	for i < len(s) {
+		if bytes.HasPrefix(s[i:], b) {
+			return i
+		}
+		if i+2 <= len(s) && s[i] == '/' && s[i+1] == '/' {
+			for i < len(s) && s[i] != '\n' {
+				i++
+			}
+			continue
+		}
+		if i+2 <= len(s) && s[i] == '/' && s[i+1] == '*' {
+			for i += 2; ; i++ {
+				if i+2 > len(s) {
+					return 0
+				}
+				if s[i] == '*' && s[i+1] == '/' {
+					i += 2
+					break
+				}
+			}
+			continue
+		}
+		i++
+	}
+	return -1
+}
+
+// Visit implements the ast.Visitor interface.
+func (f *File) Visit(node ast.Node) ast.Visitor {
+	switch n := node.(type) {
+	case *ast.BlockStmt:
+		// If it's a switch or select, the body is a list of case clauses; don't tag the block itself.
+		if len(n.List) > 0 {
+			switch n.List[0].(type) {
+			case *ast.CaseClause: // switch
+				for _, n := range n.List {
+					clause := n.(*ast.CaseClause)
+					f.addCounters(clause.Colon+1, clause.Colon+1, clause.End(), clause.Body, false)
+				}
+				return f
+			case *ast.CommClause: // select
+				for _, n := range n.List {
+					clause := n.(*ast.CommClause)
+					f.addCounters(clause.Colon+1, clause.Colon+1, clause.End(), clause.Body, false)
+				}
+				return f
+			}
+		}
+		f.addCounters(n.Lbrace, n.Lbrace+1, n.Rbrace+1, n.List, true) // +1 to step past closing brace.
+	case *ast.IfStmt:
+		if n.Init != nil {
+			ast.Walk(f, n.Init)
+		}
+		ast.Walk(f, n.Cond)
+		ast.Walk(f, n.Body)
+		if n.Else == nil {
+			return nil
+		}
+		// The elses are special, because if we have
+		//	if x {
+		//	} else if y {
+		//	}
+		// we want to cover the "if y". To do this, we need a place to drop the counter,
+		// so we add a hidden block:
+		//	if x {
+		//	} else {
+		//		if y {
+		//		}
+		//	}
+		elseOffset := f.findText(n.Body.End(), "else")
+		if elseOffset < 0 {
+			panic("lost else")
+		}
+		f.edit.Insert(elseOffset+4, "{")
+		f.edit.Insert(f.offset(n.Else.End()), "}")
+
+		// We just created a block, now walk it.
+		// Adjust the position of the new block to start after
+		// the "else". That will cause it to follow the "{"
+		// we inserted above.
+		pos := f.fset.File(n.Body.End()).Pos(elseOffset + 4)
+		switch stmt := n.Else.(type) {
+		case *ast.IfStmt:
+			block := &ast.BlockStmt{
+				Lbrace: pos,
+				List:   []ast.Stmt{stmt},
+				Rbrace: stmt.End(),
+			}
+			n.Else = block
+		case *ast.BlockStmt:
+			stmt.Lbrace = pos
+		default:
+			panic("unexpected node type in if")
+		}
+		ast.Walk(f, n.Else)
+		return nil
+	case *ast.SelectStmt:
+		// Don't annotate an empty select - creates a syntax error.
+		if n.Body == nil || len(n.Body.List) == 0 {
+			return nil
+		}
+	case *ast.SwitchStmt:
+		// Don't annotate an empty switch - creates a syntax error.
+		if n.Body == nil || len(n.Body.List) == 0 {
+			if n.Init != nil {
+				ast.Walk(f, n.Init)
+			}
+			if n.Tag != nil {
+				ast.Walk(f, n.Tag)
+			}
+			return nil
+		}
+	case *ast.TypeSwitchStmt:
+		// Don't annotate an empty type switch - creates a syntax error.
+		if n.Body == nil || len(n.Body.List) == 0 {
+			if n.Init != nil {
+				ast.Walk(f, n.Init)
+			}
+			ast.Walk(f, n.Assign)
+			return nil
+		}
+	case *ast.FuncDecl:
+		// Don't annotate functions with blank names - they cannot be executed.
+		// Similarly for bodyless funcs.
+		if n.Name.Name == "_" || n.Body == nil {
+			return nil
+		}
+		fname := n.Name.Name
+		// Skip AddUint32 and StoreUint32 if we're instrumenting
+		// sync/atomic itself in atomic mode (out of an abundance of
+		// caution), since as part of the instrumentation process we
+		// add calls to AddUint32/StoreUint32, and we don't want to
+		// somehow create an infinite loop.
+		//
+		// Note that in the current implementation (Go 1.20) both
+		// routines are assembly stubs that forward calls to the
+		// internal/runtime/atomic equivalents, hence the infinite
+		// loop scenario is purely theoretical (maybe if in some
+		// future implementation one of these functions might be
+		// written in Go). See #57445 for more details.
+		if atomicOnAtomic() && (fname == "AddUint32" || fname == "StoreUint32") {
+			return nil
+		}
+		// Determine proper function or method name.
+		if r := n.Recv; r != nil && len(r.List) == 1 {
+			t := r.List[0].Type
+			star := ""
+			if p, _ := t.(*ast.StarExpr); p != nil {
+				t = p.X
+				star = "*"
+			}
+			if p, _ := t.(*ast.Ident); p != nil {
+				fname = star + p.Name + "." + fname
+			}
+		}
+		walkBody := true
+		if *pkgcfg != "" {
+			f.preFunc(n, fname)
+			if pkgconfig.Granularity == "perfunc" {
+				walkBody = false
+			}
+		}
+		if walkBody {
+			ast.Walk(f, n.Body)
+		}
+		if *pkgcfg != "" {
+			flit := false
+			f.postFunc(n, fname, flit, n.Body)
+		}
+		return nil
+	case *ast.FuncLit:
+		// For function literals enclosed in functions, just glom the
+		// code for the literal in with the enclosing function (for now).
+		if f.fn.counterVar != "" {
+			return f
+		}
+
+		// Hack: function literals aren't named in the go/ast representation,
+		// and we don't know what name the compiler will choose. For now,
+		// just make up a descriptive name.
+		pos := n.Pos()
+		p := f.fset.File(pos).Position(pos)
+		fname := fmt.Sprintf("func.L%d.C%d", p.Line, p.Column)
+		if *pkgcfg != "" {
+			f.preFunc(n, fname)
+		}
+		if pkgconfig.Granularity != "perfunc" {
+			ast.Walk(f, n.Body)
+		}
+		if *pkgcfg != "" {
+			flit := true
+			f.postFunc(n, fname, flit, n.Body)
+		}
+		return nil
+	}
+	return f
+}
+
+func mkCounterVarName(idx int) string {
+	return fmt.Sprintf("%s_%d", *varVar, idx)
+}
+
+func mkPackageIdVar() string {
+	return *varVar + "P"
+}
+
+func mkMetaVar() string {
+	return *varVar + "M"
+}
+
+func mkPackageIdExpression() string {
+	ppath := pkgconfig.PkgPath
+	if hcid := coverage.HardCodedPkgID(ppath); hcid != -1 {
+		return fmt.Sprintf("uint32(%d)", uint32(hcid))
+	}
+	return mkPackageIdVar()
+}
+
+func (f *File) preFunc(fn ast.Node, fname string) {
+	f.fn.units = f.fn.units[:0]
+
+	// create a new counter variable for this function.
+	cv := mkCounterVarName(len(f.pkg.counterLengths))
+	f.fn.counterVar = cv
+}
+
+func (f *File) postFunc(fn ast.Node, funcname string, flit bool, body *ast.BlockStmt) {
+
+	// Tack on single counter write if we are in "perfunc" mode.
+	singleCtr := ""
+	if pkgconfig.Granularity == "perfunc" {
+		singleCtr = "; " + f.newCounter(fn.Pos(), fn.Pos(), 1)
+	}
+
+	// record the length of the counter var required.
+	nc := len(f.fn.units) + coverage.FirstCtrOffset
+	f.pkg.counterLengths = append(f.pkg.counterLengths, nc)
+
+	// FIXME: for windows, do we want "\" and not "/"? Need to test here.
+	// Currently filename is formed as packagepath + "/" + basename.
+	fnpos := f.fset.Position(fn.Pos())
+	ppath := pkgconfig.PkgPath
+	filename := ppath + "/" + filepath.Base(fnpos.Filename)
+
+	// The convention for cmd/cover is that if the go command that
+	// kicks off coverage specifies a local import path (e.g. "go test
+	// -cover ./thispackage"), the tool will capture full pathnames
+	// for source files instead of relative paths, which tend to work
+	// more smoothly for "go tool cover -html". See also issue #56433
+	// for more details.
+	if pkgconfig.Local {
+		filename = f.name
+	}
+
+	// Hand off function to meta-data builder.
+	fd := coverage.FuncDesc{
+		Funcname: funcname,
+		Srcfile:  filename,
+		Units:    f.fn.units,
+		Lit:      flit,
+	}
+	funcId := f.mdb.AddFunc(fd)
+
+	hookWrite := func(cv string, which int, val string) string {
+		return fmt.Sprintf("%s[%d] = %s", cv, which, val)
+	}
+	if *mode == "atomic" {
+		hookWrite = func(cv string, which int, val string) string {
+			return fmt.Sprintf("%sStoreUint32(&%s[%d], %s)",
+				atomicPackagePrefix(), cv, which, val)
+		}
+	}
+
+	// Generate the registration hook sequence for the function. This
+	// sequence looks like
+	//
+	//   counterVar[0] = <num_units>
+	//   counterVar[1] = pkgId
+	//   counterVar[2] = fnId
+	//
+	cv := f.fn.counterVar
+	regHook := hookWrite(cv, 0, strconv.Itoa(len(f.fn.units))) + " ; " +
+		hookWrite(cv, 1, mkPackageIdExpression()) + " ; " +
+		hookWrite(cv, 2, strconv.Itoa(int(funcId))) + singleCtr
+
+	// Insert the registration sequence into the function. We want this sequence to
+	// appear before any counter updates, so use a hack to ensure that this edit
+	// applies before the edit corresponding to the prolog counter update.
+
+	boff := f.offset(body.Pos())
+	ipos := f.fset.File(body.Pos()).Pos(boff)
+	ip := f.offset(ipos)
+	f.edit.Replace(ip, ip+1, string(f.content[ipos-1])+regHook+" ; ")
+
+	f.fn.counterVar = ""
+}
+
+func annotate(names []string) {
+	var p *Package
+	if *pkgcfg != "" {
+		pp := pkgconfig.PkgPath
+		pn := pkgconfig.PkgName
+		mp := pkgconfig.ModulePath
+		mdb, err := encodemeta.NewCoverageMetaDataBuilder(pp, pn, mp)
+		if err != nil {
+			log.Fatalf("creating coverage meta-data builder: %v\n", err)
+		}
+		p = &Package{
+			mdb: mdb,
+		}
+	}
+	// TODO: process files in parallel here if it matters.
+	for k, name := range names {
+		if strings.ContainsAny(name, "\r\n") {
+			// annotateFile uses '//line' directives, which don't permit newlines.
+			log.Fatalf("cover: input path contains newline character: %q", name)
+		}
+
+		fd := os.Stdout
+		isStdout := true
+		if *pkgcfg != "" {
+			var err error
+			fd, err = os.Create(outputfiles[k])
+			if err != nil {
+				log.Fatalf("cover: %s", err)
+			}
+			isStdout = false
+		} else if *output != "" {
+			var err error
+			fd, err = os.Create(*output)
+			if err != nil {
+				log.Fatalf("cover: %s", err)
+			}
+			isStdout = false
+		}
+		p.annotateFile(name, fd)
+		if !isStdout {
+			if err := fd.Close(); err != nil {
+				log.Fatalf("cover: %s", err)
+			}
+		}
+	}
+
+	if *pkgcfg != "" {
+		fd, err := os.Create(covervarsoutfile)
+		if err != nil {
+			log.Fatalf("cover: %s", err)
+		}
+		p.emitMetaData(fd)
+		if err := fd.Close(); err != nil {
+			log.Fatalf("cover: %s", err)
+		}
+	}
+}
+
+func (p *Package) annotateFile(name string, fd io.Writer) {
+	fset := token.NewFileSet()
+	content, err := os.ReadFile(name)
+	if err != nil {
+		log.Fatalf("cover: %s: %s", name, err)
+	}
+	parsedFile, err := parser.ParseFile(fset, name, content, parser.ParseComments)
+	if err != nil {
+		log.Fatalf("cover: %s: %s", name, err)
+	}
+
+	file := &File{
+		fset:    fset,
+		name:    name,
+		content: content,
+		edit:    edit.NewBuffer(content),
+		astFile: parsedFile,
+	}
+	if p != nil {
+		file.mdb = p.mdb
+		file.pkg = p
+	}
+
+	if *mode == "atomic" {
+		// Add import of sync/atomic immediately after package clause.
+		// We do this even if there is an existing import, because the
+		// existing import may be shadowed at any given place we want
+		// to refer to it, and our name (_cover_atomic_) is less likely to
+		// be shadowed. The one exception is if we're visiting the
+		// sync/atomic package itself, in which case we can refer to
+		// functions directly without an import prefix. See also #57445.
+		if pkgconfig.PkgPath != "sync/atomic" {
+			file.edit.Insert(file.offset(file.astFile.Name.End()),
+				fmt.Sprintf("; import %s %q", atomicPackageName, atomicPackagePath))
+		}
+	}
+	if pkgconfig.PkgName == "main" {
+		file.edit.Insert(file.offset(file.astFile.Name.End()),
+			"; import _ \"runtime/coverage\"")
+	}
+
+	if counterStmt != nil {
+		ast.Walk(file, file.astFile)
+	}
+	newContent := file.edit.Bytes()
+
+	if strings.ContainsAny(name, "\r\n") {
+		// This should have been checked by the caller already, but we double check
+		// here just to be sure we haven't missed a caller somewhere.
+		panic(fmt.Sprintf("annotateFile: name contains unexpected newline character: %q", name))
+	}
+	fmt.Fprintf(fd, "//line %s:1:1\n", name)
+	fd.Write(newContent)
+
+	// After printing the source tree, add some declarations for the
+	// counters etc. We could do this by adding to the tree, but it's
+	// easier just to print the text.
+	file.addVariables(fd)
+
+	// Emit a reference to the atomic package to avoid
+	// import and not used error when there's no code in a file.
+	if *mode == "atomic" {
+		fmt.Fprintf(fd, "\nvar _ = %sLoadUint32\n", atomicPackagePrefix())
+	}
+}
+
+// setCounterStmt returns the expression: __count[23] = 1.
+func setCounterStmt(f *File, counter string) string {
+	return fmt.Sprintf("%s = 1", counter)
+}
+
+// incCounterStmt returns the expression: __count[23]++.
+func incCounterStmt(f *File, counter string) string {
+	return fmt.Sprintf("%s++", counter)
+}
+
+// atomicCounterStmt returns the expression: atomic.AddUint32(&__count[23], 1)
+func atomicCounterStmt(f *File, counter string) string {
+	return fmt.Sprintf("%sAddUint32(&%s, 1)", atomicPackagePrefix(), counter)
+}
+
+// newCounter creates a new counter expression of the appropriate form.
+func (f *File) newCounter(start, end token.Pos, numStmt int) string {
+	var stmt string
+	if *pkgcfg != "" {
+		slot := len(f.fn.units) + coverage.FirstCtrOffset
+		if f.fn.counterVar == "" {
+			panic("internal error: counter var unset")
+		}
+		stmt = counterStmt(f, fmt.Sprintf("%s[%d]", f.fn.counterVar, slot))
+		stpos := f.fset.Position(start)
+		enpos := f.fset.Position(end)
+		stpos, enpos = dedup(stpos, enpos)
+		unit := coverage.CoverableUnit{
+			StLine:  uint32(stpos.Line),
+			StCol:   uint32(stpos.Column),
+			EnLine:  uint32(enpos.Line),
+			EnCol:   uint32(enpos.Column),
+			NxStmts: uint32(numStmt),
+		}
+		f.fn.units = append(f.fn.units, unit)
+	} else {
+		stmt = counterStmt(f, fmt.Sprintf("%s.Count[%d]", *varVar,
+			len(f.blocks)))
+		f.blocks = append(f.blocks, Block{start, end, numStmt})
+	}
+	return stmt
+}
+
+// addCounters takes a list of statements and adds counters to the beginning of
+// each basic block at the top level of that list. For instance, given
+//
+//	S1
+//	if cond {
+//		S2
+//	}
+//	S3
+//
+// counters will be added before S1 and before S3. The block containing S2
+// will be visited in a separate call.
+// TODO: Nested simple blocks get unnecessary (but correct) counters
+func (f *File) addCounters(pos, insertPos, blockEnd token.Pos, list []ast.Stmt, extendToClosingBrace bool) {
+	// Special case: make sure we add a counter to an empty block. Can't do this below
+	// or we will add a counter to an empty statement list after, say, a return statement.
+	if len(list) == 0 {
+		f.edit.Insert(f.offset(insertPos), f.newCounter(insertPos, blockEnd, 0)+";")
+		return
+	}
+	// Make a copy of the list, as we may mutate it and should leave the
+	// existing list intact.
+	list = append([]ast.Stmt(nil), list...)
+	// We have a block (statement list), but it may have several basic blocks due to the
+	// appearance of statements that affect the flow of control.
+	for {
+		// Find first statement that affects flow of control (break, continue, if, etc.).
+		// It will be the last statement of this basic block.
+		var last int
+		end := blockEnd
+		for last = 0; last < len(list); last++ {
+			stmt := list[last]
+			end = f.statementBoundary(stmt)
+			if f.endsBasicSourceBlock(stmt) {
+				// If it is a labeled statement, we need to place a counter between
+				// the label and its statement because it may be the target of a goto
+				// and thus start a basic block. That is, given
+				//	foo: stmt
+				// we need to create
+				//	foo: ; stmt
+				// and mark the label as a block-terminating statement.
+				// The result will then be
+				//	foo: COUNTER[n]++; stmt
+				// However, we can't do this if the labeled statement is already
+				// a control statement, such as a labeled for.
+				if label, isLabel := stmt.(*ast.LabeledStmt); isLabel && !f.isControl(label.Stmt) {
+					newLabel := *label
+					newLabel.Stmt = &ast.EmptyStmt{
+						Semicolon: label.Stmt.Pos(),
+						Implicit:  true,
+					}
+					end = label.Pos() // Previous block ends before the label.
+					list[last] = &newLabel
+					// Open a gap and drop in the old statement, now without a label.
+					list = append(list, nil)
+					copy(list[last+1:], list[last:])
+					list[last+1] = label.Stmt
+				}
+				last++
+				extendToClosingBrace = false // Block is broken up now.
+				break
+			}
+		}
+		if extendToClosingBrace {
+			end = blockEnd
+		}
+		if pos != end { // Can have no source to cover if e.g. blocks abut.
+			f.edit.Insert(f.offset(insertPos), f.newCounter(pos, end, last)+";")
+		}
+		list = list[last:]
+		if len(list) == 0 {
+			break
+		}
+		pos = list[0].Pos()
+		insertPos = pos
+	}
+}
+
+// hasFuncLiteral reports the existence and position of the first func literal
+// in the node, if any. If a func literal appears, it usually marks the termination
+// of a basic block because the function body is itself a block.
+// Therefore we draw a line at the start of the body of the first function literal we find.
+// TODO: what if there's more than one? Probably doesn't matter much.
+func hasFuncLiteral(n ast.Node) (bool, token.Pos) {
+	if n == nil {
+		return false, 0
+	}
+	var literal funcLitFinder
+	ast.Walk(&literal, n)
+	return literal.found(), token.Pos(literal)
+}
+
+// statementBoundary finds the location in s that terminates the current basic
+// block in the source.
+func (f *File) statementBoundary(s ast.Stmt) token.Pos {
+	// Control flow statements are easy.
+	switch s := s.(type) {
+	case *ast.BlockStmt:
+		// Treat blocks like basic blocks to avoid overlapping counters.
+		return s.Lbrace
+	case *ast.IfStmt:
+		found, pos := hasFuncLiteral(s.Init)
+		if found {
+			return pos
+		}
+		found, pos = hasFuncLiteral(s.Cond)
+		if found {
+			return pos
+		}
+		return s.Body.Lbrace
+	case *ast.ForStmt:
+		found, pos := hasFuncLiteral(s.Init)
+		if found {
+			return pos
+		}
+		found, pos = hasFuncLiteral(s.Cond)
+		if found {
+			return pos
+		}
+		found, pos = hasFuncLiteral(s.Post)
+		if found {
+			return pos
+		}
+		return s.Body.Lbrace
+	case *ast.LabeledStmt:
+		return f.statementBoundary(s.Stmt)
+	case *ast.RangeStmt:
+		found, pos := hasFuncLiteral(s.X)
+		if found {
+			return pos
+		}
+		return s.Body.Lbrace
+	case *ast.SwitchStmt:
+		found, pos := hasFuncLiteral(s.Init)
+		if found {
+			return pos
+		}
+		found, pos = hasFuncLiteral(s.Tag)
+		if found {
+			return pos
+		}
+		return s.Body.Lbrace
+	case *ast.SelectStmt:
+		return s.Body.Lbrace
+	case *ast.TypeSwitchStmt:
+		found, pos := hasFuncLiteral(s.Init)
+		if found {
+			return pos
+		}
+		return s.Body.Lbrace
+	}
+	// If not a control flow statement, it is a declaration, expression, call, etc. and it may have a function literal.
+	// If it does, that's tricky because we want to exclude the body of the function from this block.
+	// Draw a line at the start of the body of the first function literal we find.
+	// TODO: what if there's more than one? Probably doesn't matter much.
+	found, pos := hasFuncLiteral(s)
+	if found {
+		return pos
+	}
+	return s.End()
+}
+
+// endsBasicSourceBlock reports whether s changes the flow of control: break, if, etc.,
+// or if it's just problematic, for instance contains a function literal, which will complicate
+// accounting due to the block-within-an expression.
+func (f *File) endsBasicSourceBlock(s ast.Stmt) bool {
+	switch s := s.(type) {
+	case *ast.BlockStmt:
+		// Treat blocks like basic blocks to avoid overlapping counters.
+		return true
+	case *ast.BranchStmt:
+		return true
+	case *ast.ForStmt:
+		return true
+	case *ast.IfStmt:
+		return true
+	case *ast.LabeledStmt:
+		return true // A goto may branch here, starting a new basic block.
+	case *ast.RangeStmt:
+		return true
+	case *ast.SwitchStmt:
+		return true
+	case *ast.SelectStmt:
+		return true
+	case *ast.TypeSwitchStmt:
+		return true
+	case *ast.ExprStmt:
+		// Calls to panic change the flow.
+		// We really should verify that "panic" is the predefined function,
+		// but without type checking we can't and the likelihood of it being
+		// an actual problem is vanishingly small.
+		if call, ok := s.X.(*ast.CallExpr); ok {
+			if ident, ok := call.Fun.(*ast.Ident); ok && ident.Name == "panic" && len(call.Args) == 1 {
+				return true
+			}
+		}
+	}
+	found, _ := hasFuncLiteral(s)
+	return found
+}
+
+// isControl reports whether s is a control statement that, if labeled, cannot be
+// separated from its label.
+func (f *File) isControl(s ast.Stmt) bool {
+	switch s.(type) {
+	case *ast.ForStmt, *ast.RangeStmt, *ast.SwitchStmt, *ast.SelectStmt, *ast.TypeSwitchStmt:
+		return true
+	}
+	return false
+}
+
+// funcLitFinder implements the ast.Visitor pattern to find the location of any
+// function literal in a subtree.
+type funcLitFinder token.Pos
+
+func (f *funcLitFinder) Visit(node ast.Node) (w ast.Visitor) {
+	if f.found() {
+		return nil // Prune search.
+	}
+	switch n := node.(type) {
+	case *ast.FuncLit:
+		*f = funcLitFinder(n.Body.Lbrace)
+		return nil // Prune search.
+	}
+	return f
+}
+
+func (f *funcLitFinder) found() bool {
+	return token.Pos(*f) != token.NoPos
+}
+
+// Sort interface for []block1; used for self-check in addVariables.
+
+type block1 struct {
+	Block
+	index int
+}
+
+// offset translates a token position into a 0-indexed byte offset.
+func (f *File) offset(pos token.Pos) int {
+	return f.fset.Position(pos).Offset
+}
+
+// addVariables adds to the end of the file the declarations to set up the counter and position variables.
+func (f *File) addVariables(w io.Writer) {
+	if *pkgcfg != "" {
+		return
+	}
+	// Self-check: Verify that the instrumented basic blocks are disjoint.
+	t := make([]block1, len(f.blocks))
+	for i := range f.blocks {
+		t[i].Block = f.blocks[i]
+		t[i].index = i
+	}
+	slices.SortFunc(t, func(a, b block1) int {
+		return cmp.Compare(a.startByte, b.startByte)
+	})
+	for i := 1; i < len(t); i++ {
+		if t[i-1].endByte > t[i].startByte {
+			fmt.Fprintf(os.Stderr, "cover: internal error: block %d overlaps block %d\n", t[i-1].index, t[i].index)
+			// Note: error message is in byte positions, not token positions.
+			fmt.Fprintf(os.Stderr, "\t%s:#%d,#%d %s:#%d,#%d\n",
+				f.name, f.offset(t[i-1].startByte), f.offset(t[i-1].endByte),
+				f.name, f.offset(t[i].startByte), f.offset(t[i].endByte))
+		}
+	}
+
+	// Declare the coverage struct as a package-level variable.
+	fmt.Fprintf(w, "\nvar %s = struct {\n", *varVar)
+	fmt.Fprintf(w, "\tCount     [%d]uint32\n", len(f.blocks))
+	fmt.Fprintf(w, "\tPos       [3 * %d]uint32\n", len(f.blocks))
+	fmt.Fprintf(w, "\tNumStmt   [%d]uint16\n", len(f.blocks))
+	fmt.Fprintf(w, "} {\n")
+
+	// Initialize the position array field.
+	fmt.Fprintf(w, "\tPos: [3 * %d]uint32{\n", len(f.blocks))
+
+	// A nice long list of positions. Each position is encoded as follows to reduce size:
+	// - 32-bit starting line number
+	// - 32-bit ending line number
+	// - (16 bit ending column number << 16) | (16-bit starting column number).
+	for i, block := range f.blocks {
+		start := f.fset.Position(block.startByte)
+		end := f.fset.Position(block.endByte)
+
+		start, end = dedup(start, end)
+
+		fmt.Fprintf(w, "\t\t%d, %d, %#x, // [%d]\n", start.Line, end.Line, (end.Column&0xFFFF)<<16|(start.Column&0xFFFF), i)
+	}
+
+	// Close the position array.
+	fmt.Fprintf(w, "\t},\n")
+
+	// Initialize the position array field.
+	fmt.Fprintf(w, "\tNumStmt: [%d]uint16{\n", len(f.blocks))
+
+	// A nice long list of statements-per-block, so we can give a conventional
+	// valuation of "percent covered". To save space, it's a 16-bit number, so we
+	// clamp it if it overflows - won't matter in practice.
+	for i, block := range f.blocks {
+		n := block.numStmt
+		if n > 1<<16-1 {
+			n = 1<<16 - 1
+		}
+		fmt.Fprintf(w, "\t\t%d, // %d\n", n, i)
+	}
+
+	// Close the statements-per-block array.
+	fmt.Fprintf(w, "\t},\n")
+
+	// Close the struct initialization.
+	fmt.Fprintf(w, "}\n")
+}
+
+// It is possible for positions to repeat when there is a line
+// directive that does not specify column information and the input
+// has not been passed through gofmt.
+// See issues #27530 and #30746.
+// Tests are TestHtmlUnformatted and TestLineDup.
+// We use a map to avoid duplicates.
+
+// pos2 is a pair of token.Position values, used as a map key type.
+type pos2 struct {
+	p1, p2 token.Position
+}
+
+// seenPos2 tracks whether we have seen a token.Position pair.
+var seenPos2 = make(map[pos2]bool)
+
+// dedup takes a token.Position pair and returns a pair that does not
+// duplicate any existing pair. The returned pair will have the Offset
+// fields cleared.
+func dedup(p1, p2 token.Position) (r1, r2 token.Position) {
+	key := pos2{
+		p1: p1,
+		p2: p2,
+	}
+
+	// We want to ignore the Offset fields in the map,
+	// since cover uses only file/line/column.
+	key.p1.Offset = 0
+	key.p2.Offset = 0
+
+	for seenPos2[key] {
+		key.p2.Column++
+	}
+	seenPos2[key] = true
+
+	return key.p1, key.p2
+}
+
+func (p *Package) emitMetaData(w io.Writer) {
+	if *pkgcfg == "" {
+		return
+	}
+
+	// If the "EmitMetaFile" path has been set, invoke a helper
+	// that will write out a pre-cooked meta-data file for this package
+	// to the specified location, in effect simulating the execution
+	// of a test binary that doesn't do any testing to speak of.
+	if pkgconfig.EmitMetaFile != "" {
+		p.emitMetaFile(pkgconfig.EmitMetaFile)
+	}
+
+	// Something went wrong if regonly/testmain mode is in effect and
+	// we have instrumented functions.
+	if counterStmt == nil && len(p.counterLengths) != 0 {
+		panic("internal error: seen functions with regonly/testmain")
+	}
+
+	// Emit package name.
+	fmt.Fprintf(w, "\npackage %s\n\n", pkgconfig.PkgName)
+
+	// Emit package ID var.
+	fmt.Fprintf(w, "\nvar %sP uint32\n", *varVar)
+
+	// Emit all of the counter variables.
+	for k := range p.counterLengths {
+		cvn := mkCounterVarName(k)
+		fmt.Fprintf(w, "var %s [%d]uint32\n", cvn, p.counterLengths[k])
+	}
+
+	// Emit encoded meta-data.
+	var sws slicewriter.WriteSeeker
+	digest, err := p.mdb.Emit(&sws)
+	if err != nil {
+		log.Fatalf("encoding meta-data: %v", err)
+	}
+	p.mdb = nil
+	fmt.Fprintf(w, "var %s = [...]byte{\n", mkMetaVar())
+	payload := sws.BytesWritten()
+	for k, b := range payload {
+		fmt.Fprintf(w, " 0x%x,", b)
+		if k != 0 && k%8 == 0 {
+			fmt.Fprintf(w, "\n")
+		}
+	}
+	fmt.Fprintf(w, "}\n")
+
+	fixcfg := covcmd.CoverFixupConfig{
+		Strategy:           "normal",
+		MetaVar:            mkMetaVar(),
+		MetaLen:            len(payload),
+		MetaHash:           fmt.Sprintf("%x", digest),
+		PkgIdVar:           mkPackageIdVar(),
+		CounterPrefix:      *varVar,
+		CounterGranularity: pkgconfig.Granularity,
+		CounterMode:        *mode,
+	}
+	fixdata, err := json.Marshal(fixcfg)
+	if err != nil {
+		log.Fatalf("marshal fixupcfg: %v", err)
+	}
+	if err := os.WriteFile(pkgconfig.OutConfig, fixdata, 0666); err != nil {
+		log.Fatalf("error writing %s: %v", pkgconfig.OutConfig, err)
+	}
+}
+
+// atomicOnAtomic returns true if we're instrumenting
+// the sync/atomic package AND using atomic mode.
+func atomicOnAtomic() bool {
+	return *mode == "atomic" && pkgconfig.PkgPath == "sync/atomic"
+}
+
+// atomicPackagePrefix returns the import path prefix used to refer to
+// our special import of sync/atomic; this is either set to the
+// constant atomicPackageName plus a dot or the empty string if we're
+// instrumenting the sync/atomic package itself.
+func atomicPackagePrefix() string {
+	if atomicOnAtomic() {
+		return ""
+	}
+	return atomicPackageName + "."
+}
+
+func (p *Package) emitMetaFile(outpath string) {
+	// Open output file.
+	of, err := os.OpenFile(outpath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
+	if err != nil {
+		log.Fatalf("opening covmeta %s: %v", outpath, err)
+	}
+
+	if len(p.counterLengths) == 0 {
+		// This corresponds to the case where we have no functions
+		// in the package to instrument. Leave the file empty file if
+		// this happens.
+		if err = of.Close(); err != nil {
+			log.Fatalf("closing meta-data file: %v", err)
+		}
+		return
+	}
+
+	// Encode meta-data.
+	var sws slicewriter.WriteSeeker
+	digest, err := p.mdb.Emit(&sws)
+	if err != nil {
+		log.Fatalf("encoding meta-data: %v", err)
+	}
+	payload := sws.BytesWritten()
+	blobs := [][]byte{payload}
+
+	// Write meta-data file directly.
+	mfw := encodemeta.NewCoverageMetaFileWriter(outpath, of)
+	err = mfw.Write(digest, blobs, cmode, cgran)
+	if err != nil {
+		log.Fatalf("writing meta-data file: %v", err)
+	}
+	if err = of.Close(); err != nil {
+		log.Fatalf("closing meta-data file: %v", err)
+	}
+}

go/src/cmd/cover/cover_test.go

@@ -0,0 +1,640 @@
+// Copyright 2013 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_test
+
+import (
+	"bufio"
+	"bytes"
+	cmdcover "cmd/cover"
+	"flag"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"internal/testenv"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"sync"
+	"testing"
+)
+
+const (
+	// Data directory, also the package directory for the test.
+	testdata = "testdata"
+)
+
+// testcover returns the path to the cmd/cover binary that we are going to
+// test. At one point this was created via "go build"; we now reuse the unit
+// test executable itself.
+func testcover(t testing.TB) string {
+	return testenv.Executable(t)
+}
+
+// testTempDir is a temporary directory created in TestMain.
+var testTempDir string
+
+// If set, this will preserve all the tmpdir files from the test run.
+var debug = flag.Bool("debug", false, "keep tmpdir files for debugging")
+
+// TestMain used here so that we can leverage the test executable
+// itself as a cmd/cover executable; compare to similar usage in
+// the cmd/go tests.
+func TestMain(m *testing.M) {
+	if os.Getenv("CMDCOVER_TOOLEXEC") != "" {
+		// When CMDCOVER_TOOLEXEC is set, the test binary is also
+		// running as a -toolexec wrapper.
+		tool := strings.TrimSuffix(filepath.Base(os.Args[1]), ".exe")
+		if tool == "cover" {
+			// Inject this test binary as cmd/cover in place of the
+			// installed tool, so that the go command's invocations of
+			// cover produce coverage for the configuration in which
+			// the test was built.
+			os.Args = os.Args[1:]
+			cmdcover.Main()
+		} else {
+			cmd := exec.Command(os.Args[1], os.Args[2:]...)
+			cmd.Stdout = os.Stdout
+			cmd.Stderr = os.Stderr
+			if err := cmd.Run(); err != nil {
+				os.Exit(1)
+			}
+		}
+		os.Exit(0)
+	}
+	if os.Getenv("CMDCOVER_TEST_RUN_MAIN") != "" {
+		// When CMDCOVER_TEST_RUN_MAIN is set, we're reusing the test
+		// binary as cmd/cover. In this case we run the main func exported
+		// via export_test.go, and exit; CMDCOVER_TEST_RUN_MAIN is set below
+		// for actual test invocations.
+		cmdcover.Main()
+		os.Exit(0)
+	}
+	flag.Parse()
+	topTmpdir, err := os.MkdirTemp("", "cmd-cover-test-")
+	if err != nil {
+		log.Fatal(err)
+	}
+	testTempDir = topTmpdir
+	if !*debug {
+		defer os.RemoveAll(topTmpdir)
+	} else {
+		fmt.Fprintf(os.Stderr, "debug: preserving tmpdir %s\n", topTmpdir)
+	}
+	os.Setenv("CMDCOVER_TEST_RUN_MAIN", "normal")
+	os.Exit(m.Run())
+}
+
+var tdmu sync.Mutex
+var tdcount int
+
+func tempDir(t *testing.T) string {
+	tdmu.Lock()
+	dir := filepath.Join(testTempDir, fmt.Sprintf("%03d", tdcount))
+	tdcount++
+	if err := os.Mkdir(dir, 0777); err != nil {
+		t.Fatal(err)
+	}
+	defer tdmu.Unlock()
+	return dir
+}
+
+// TestCoverWithToolExec runs a set of subtests that all make use of a
+// "-toolexec" wrapper program to invoke the cover test executable
+// itself via "go test -cover".
+func TestCoverWithToolExec(t *testing.T) {
+	toolexecArg := "-toolexec=" + testcover(t)
+
+	t.Run("CoverHTML", func(t *testing.T) {
+		testCoverHTML(t, toolexecArg)
+	})
+	t.Run("HtmlUnformatted", func(t *testing.T) {
+		testHtmlUnformatted(t, toolexecArg)
+	})
+	t.Run("FuncWithDuplicateLines", func(t *testing.T) {
+		testFuncWithDuplicateLines(t, toolexecArg)
+	})
+	t.Run("MissingTrailingNewlineIssue58370", func(t *testing.T) {
+		testMissingTrailingNewlineIssue58370(t, toolexecArg)
+	})
+}
+
+// Execute this command sequence:
+//
+//	replace the word LINE with the line number < testdata/test.go > testdata/test_line.go
+//	testcover -mode=count -var=CoverTest -o ./testdata/test_cover.go testdata/test_line.go
+//	go run ./testdata/main.go ./testdata/test.go
+func TestCover(t *testing.T) {
+	testenv.MustHaveGoRun(t)
+	t.Parallel()
+	dir := tempDir(t)
+
+	// Read in the test file (testTest) and write it, with LINEs specified, to coverInput.
+	testTest := filepath.Join(testdata, "test.go")
+	file, err := os.ReadFile(testTest)
+	if err != nil {
+		t.Fatal(err)
+	}
+	lines := bytes.Split(file, []byte("\n"))
+	for i, line := range lines {
+		lines[i] = bytes.ReplaceAll(line, []byte("LINE"), []byte(fmt.Sprint(i+1)))
+	}
+
+	// Add a function that is not gofmt'ed. This used to cause a crash.
+	// We don't put it in test.go because then we would have to gofmt it.
+	// Issue 23927.
+	lines = append(lines, []byte("func unFormatted() {"),
+		[]byte("\tif true {"),
+		[]byte("\t}else{"),
+		[]byte("\t}"),
+		[]byte("}"))
+	lines = append(lines, []byte("func unFormatted2(b bool) {if b{}else{}}"))
+
+	coverInput := filepath.Join(dir, "test_line.go")
+	if err := os.WriteFile(coverInput, bytes.Join(lines, []byte("\n")), 0666); err != nil {
+		t.Fatal(err)
+	}
+
+	// testcover -mode=count -var=thisNameMustBeVeryLongToCauseOverflowOfCounterIncrementStatementOntoNextLineForTest -o ./testdata/test_cover.go testdata/test_line.go
+	coverOutput := filepath.Join(dir, "test_cover.go")
+	cmd := testenv.Command(t, testcover(t), "-mode=count", "-var=thisNameMustBeVeryLongToCauseOverflowOfCounterIncrementStatementOntoNextLineForTest", "-o", coverOutput, coverInput)
+	run(cmd, t)
+
+	cmd = testenv.Command(t, testcover(t), "-mode=set", "-var=Not_an-identifier", "-o", coverOutput, coverInput)
+	err = cmd.Run()
+	if err == nil {
+		t.Error("Expected cover to fail with an error")
+	}
+
+	// Copy testmain to tmpdir, so that it is in the same directory
+	// as coverOutput.
+	testMain := filepath.Join(testdata, "main.go")
+	b, err := os.ReadFile(testMain)
+	if err != nil {
+		t.Fatal(err)
+	}
+	tmpTestMain := filepath.Join(dir, "main.go")
+	if err := os.WriteFile(tmpTestMain, b, 0444); err != nil {
+		t.Fatal(err)
+	}
+
+	// go run ./testdata/main.go ./testdata/test.go
+	cmd = testenv.Command(t, testenv.GoToolPath(t), "run", tmpTestMain, coverOutput)
+	run(cmd, t)
+
+	file, err = os.ReadFile(coverOutput)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// compiler directive must appear right next to function declaration.
+	if got, err := regexp.MatchString(".*\n//go:nosplit\nfunc someFunction().*", string(file)); err != nil || !got {
+		t.Error("misplaced compiler directive")
+	}
+	// "go:linkname" compiler directive should be present.
+	if got, err := regexp.MatchString(`.*go\:linkname some\_name some\_name.*`, string(file)); err != nil || !got {
+		t.Error("'go:linkname' compiler directive not found")
+	}
+
+	// Other comments should be preserved too.
+	c := ".*// This comment didn't appear in generated go code.*"
+	if got, err := regexp.MatchString(c, string(file)); err != nil || !got {
+		t.Errorf("non compiler directive comment %q not found", c)
+	}
+}
+
+// TestDirectives checks that compiler directives are preserved and positioned
+// correctly. Directives that occur before top-level declarations should remain
+// above those declarations, even if they are not part of the block of
+// documentation comments.
+func TestDirectives(t *testing.T) {
+	testenv.MustHaveExec(t)
+	t.Parallel()
+
+	// Read the source file and find all the directives. We'll keep
+	// track of whether each one has been seen in the output.
+	testDirectives := filepath.Join(testdata, "directives.go")
+	source, err := os.ReadFile(testDirectives)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sourceDirectives := findDirectives(source)
+
+	// testcover -mode=atomic ./testdata/directives.go
+	cmd := testenv.Command(t, testcover(t), "-mode=atomic", testDirectives)
+	cmd.Stderr = os.Stderr
+	output, err := cmd.Output()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Check that all directives are present in the output.
+	outputDirectives := findDirectives(output)
+	foundDirective := make(map[string]bool)
+	for _, p := range sourceDirectives {
+		foundDirective[p.name] = false
+	}
+	for _, p := range outputDirectives {
+		if found, ok := foundDirective[p.name]; !ok {
+			t.Errorf("unexpected directive in output: %s", p.text)
+		} else if found {
+			t.Errorf("directive found multiple times in output: %s", p.text)
+		}
+		foundDirective[p.name] = true
+	}
+	for name, found := range foundDirective {
+		if !found {
+			t.Errorf("missing directive: %s", name)
+		}
+	}
+
+	// Check that directives that start with the name of top-level declarations
+	// come before the beginning of the named declaration and after the end
+	// of the previous declaration.
+	fset := token.NewFileSet()
+	astFile, err := parser.ParseFile(fset, testDirectives, output, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	prevEnd := 0
+	for _, decl := range astFile.Decls {
+		var name string
+		switch d := decl.(type) {
+		case *ast.FuncDecl:
+			name = d.Name.Name
+		case *ast.GenDecl:
+			if len(d.Specs) == 0 {
+				// An empty group declaration. We still want to check that
+				// directives can be associated with it, so we make up a name
+				// to match directives in the test data.
+				name = "_empty"
+			} else if spec, ok := d.Specs[0].(*ast.TypeSpec); ok {
+				name = spec.Name.Name
+			}
+		}
+		pos := fset.Position(decl.Pos()).Offset
+		end := fset.Position(decl.End()).Offset
+		if name == "" {
+			prevEnd = end
+			continue
+		}
+		for _, p := range outputDirectives {
+			if !strings.HasPrefix(p.name, name) {
+				continue
+			}
+			if p.offset < prevEnd || pos < p.offset {
+				t.Errorf("directive %s does not appear before definition %s", p.text, name)
+			}
+		}
+		prevEnd = end
+	}
+}
+
+type directiveInfo struct {
+	text   string // full text of the comment, not including newline
+	name   string // text after //go:
+	offset int    // byte offset of first slash in comment
+}
+
+func findDirectives(source []byte) []directiveInfo {
+	var directives []directiveInfo
+	directivePrefix := []byte("\n//go:")
+	offset := 0
+	for {
+		i := bytes.Index(source[offset:], directivePrefix)
+		if i < 0 {
+			break
+		}
+		i++ // skip newline
+		p := source[offset+i:]
+		j := bytes.IndexByte(p, '\n')
+		if j < 0 {
+			// reached EOF
+			j = len(p)
+		}
+		directive := directiveInfo{
+			text:   string(p[:j]),
+			name:   string(p[len(directivePrefix)-1 : j]),
+			offset: offset + i,
+		}
+		directives = append(directives, directive)
+		offset += i + j
+	}
+	return directives
+}
+
+// Makes sure that `cover -func=profile.cov` reports accurate coverage.
+// Issue #20515.
+func TestCoverFunc(t *testing.T) {
+	// testcover -func ./testdata/profile.cov
+	coverProfile := filepath.Join(testdata, "profile.cov")
+	cmd := testenv.Command(t, testcover(t), "-func", coverProfile)
+	out, err := cmd.Output()
+	if err != nil {
+		if ee, ok := err.(*exec.ExitError); ok {
+			t.Logf("%s", ee.Stderr)
+		}
+		t.Fatal(err)
+	}
+
+	if got, err := regexp.Match(".*total:.*100.0.*", out); err != nil || !got {
+		t.Logf("%s", out)
+		t.Errorf("invalid coverage counts. got=(%v, %v); want=(true; nil)", got, err)
+	}
+}
+
+// Check that cover produces correct HTML.
+// Issue #25767.
+func testCoverHTML(t *testing.T, toolexecArg string) {
+	testenv.MustHaveGoRun(t)
+	dir := tempDir(t)
+
+	t.Parallel()
+
+	// go test -coverprofile testdata/html/html.cov cmd/cover/testdata/html
+	htmlProfile := filepath.Join(dir, "html.cov")
+	cmd := testenv.Command(t, testenv.GoToolPath(t), "test", toolexecArg, "-coverprofile", htmlProfile, "cmd/cover/testdata/html")
+	cmd.Env = append(cmd.Environ(), "CMDCOVER_TOOLEXEC=true")
+	run(cmd, t)
+	// testcover -html testdata/html/html.cov -o testdata/html/html.html
+	htmlHTML := filepath.Join(dir, "html.html")
+	cmd = testenv.Command(t, testcover(t), "-html", htmlProfile, "-o", htmlHTML)
+	run(cmd, t)
+
+	// Extract the parts of the HTML with comment markers,
+	// and compare against a golden file.
+	entireHTML, err := os.ReadFile(htmlHTML)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var out strings.Builder
+	scan := bufio.NewScanner(bytes.NewReader(entireHTML))
+	in := false
+	for scan.Scan() {
+		line := scan.Text()
+		if strings.Contains(line, "// START") {
+			in = true
+		}
+		if in {
+			fmt.Fprintln(&out, line)
+		}
+		if strings.Contains(line, "// END") {
+			in = false
+		}
+	}
+	if scan.Err() != nil {
+		t.Error(scan.Err())
+	}
+	htmlGolden := filepath.Join(testdata, "html", "html.golden")
+	golden, err := os.ReadFile(htmlGolden)
+	if err != nil {
+		t.Fatalf("reading golden file: %v", err)
+	}
+	// Ignore white space differences.
+	// Break into lines, then compare by breaking into words.
+	goldenLines := strings.Split(string(golden), "\n")
+	outLines := strings.Split(out.String(), "\n")
+	// Compare at the line level, stopping at first different line so
+	// we don't generate tons of output if there's an inserted or deleted line.
+	for i, goldenLine := range goldenLines {
+		if i >= len(outLines) {
+			t.Fatalf("output shorter than golden; stops before line %d: %s\n", i+1, goldenLine)
+		}
+		// Convert all white space to simple spaces, for easy comparison.
+		goldenLine = strings.Join(strings.Fields(goldenLine), " ")
+		outLine := strings.Join(strings.Fields(outLines[i]), " ")
+		if outLine != goldenLine {
+			t.Fatalf("line %d differs: got:\n\t%s\nwant:\n\t%s", i+1, outLine, goldenLine)
+		}
+	}
+	if len(goldenLines) != len(outLines) {
+		t.Fatalf("output longer than golden; first extra output line %d: %q\n", len(goldenLines)+1, outLines[len(goldenLines)])
+	}
+}
+
+// Test HTML processing with a source file not run through gofmt.
+// Issue #27350.
+func testHtmlUnformatted(t *testing.T, toolexecArg string) {
+	testenv.MustHaveGoRun(t)
+	dir := tempDir(t)
+
+	t.Parallel()
+
+	htmlUDir := filepath.Join(dir, "htmlunformatted")
+	htmlU := filepath.Join(htmlUDir, "htmlunformatted.go")
+	htmlUTest := filepath.Join(htmlUDir, "htmlunformatted_test.go")
+	htmlUProfile := filepath.Join(htmlUDir, "htmlunformatted.cov")
+	htmlUHTML := filepath.Join(htmlUDir, "htmlunformatted.html")
+
+	if err := os.Mkdir(htmlUDir, 0777); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := os.WriteFile(filepath.Join(htmlUDir, "go.mod"), []byte("module htmlunformatted\n"), 0666); err != nil {
+		t.Fatal(err)
+	}
+
+	const htmlUContents = `
+package htmlunformatted
+
+var g int
+
+func F() {
+//line x.go:1
+	{ { F(); goto lab } }
+lab:
+}`
+
+	const htmlUTestContents = `package htmlunformatted`
+
+	if err := os.WriteFile(htmlU, []byte(htmlUContents), 0444); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(htmlUTest, []byte(htmlUTestContents), 0444); err != nil {
+		t.Fatal(err)
+	}
+
+	// go test -covermode=count -coverprofile TMPDIR/htmlunformatted.cov
+	cmd := testenv.Command(t, testenv.GoToolPath(t), "test", "-test.v", toolexecArg, "-covermode=count", "-coverprofile", htmlUProfile)
+	cmd.Env = append(cmd.Environ(), "CMDCOVER_TOOLEXEC=true")
+	cmd.Dir = htmlUDir
+	run(cmd, t)
+
+	// testcover -html TMPDIR/htmlunformatted.cov -o unformatted.html
+	cmd = testenv.Command(t, testcover(t), "-html", htmlUProfile, "-o", htmlUHTML)
+	cmd.Dir = htmlUDir
+	run(cmd, t)
+}
+
+// lineDupContents becomes linedup.go in testFuncWithDuplicateLines.
+const lineDupContents = `
+package linedup
+
+var G int
+
+func LineDup(c int) {
+	for i := 0; i < c; i++ {
+//line ld.go:100
+		if i % 2 == 0 {
+			G++
+		}
+		if i % 3 == 0 {
+			G++; G++
+		}
+//line ld.go:100
+		if i % 4 == 0 {
+			G++; G++; G++
+		}
+		if i % 5 == 0 {
+			G++; G++; G++; G++
+		}
+	}
+}
+`
+
+// lineDupTestContents becomes linedup_test.go in testFuncWithDuplicateLines.
+const lineDupTestContents = `
+package linedup
+
+import "testing"
+
+func TestLineDup(t *testing.T) {
+	LineDup(100)
+}
+`
+
+// Test -func with duplicate //line directives with different numbers
+// of statements.
+func testFuncWithDuplicateLines(t *testing.T, toolexecArg string) {
+	testenv.MustHaveGoRun(t)
+	dir := tempDir(t)
+
+	t.Parallel()
+
+	lineDupDir := filepath.Join(dir, "linedup")
+	lineDupGo := filepath.Join(lineDupDir, "linedup.go")
+	lineDupTestGo := filepath.Join(lineDupDir, "linedup_test.go")
+	lineDupProfile := filepath.Join(lineDupDir, "linedup.out")
+
+	if err := os.Mkdir(lineDupDir, 0777); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := os.WriteFile(filepath.Join(lineDupDir, "go.mod"), []byte("module linedup\n"), 0666); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(lineDupGo, []byte(lineDupContents), 0444); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(lineDupTestGo, []byte(lineDupTestContents), 0444); err != nil {
+		t.Fatal(err)
+	}
+
+	// go test -cover -covermode count -coverprofile TMPDIR/linedup.out
+	cmd := testenv.Command(t, testenv.GoToolPath(t), "test", toolexecArg, "-cover", "-covermode", "count", "-coverprofile", lineDupProfile)
+	cmd.Env = append(cmd.Environ(), "CMDCOVER_TOOLEXEC=true")
+	cmd.Dir = lineDupDir
+	run(cmd, t)
+
+	// testcover -func=TMPDIR/linedup.out
+	cmd = testenv.Command(t, testcover(t), "-func", lineDupProfile)
+	cmd.Dir = lineDupDir
+	run(cmd, t)
+}
+
+func run(c *exec.Cmd, t *testing.T) {
+	t.Helper()
+	t.Log("running", c.Args)
+	out, err := c.CombinedOutput()
+	if len(out) > 0 {
+		t.Logf("%s", out)
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func runExpectingError(c *exec.Cmd, t *testing.T) string {
+	t.Helper()
+	t.Log("running", c.Args)
+	out, err := c.CombinedOutput()
+	if err == nil {
+		return fmt.Sprintf("unexpected pass for %+v", c.Args)
+	}
+	return string(out)
+}
+
+// Test instrumentation of package that ends before an expected
+// trailing newline following package clause. Issue #58370.
+func testMissingTrailingNewlineIssue58370(t *testing.T, toolexecArg string) {
+	testenv.MustHaveGoBuild(t)
+	dir := tempDir(t)
+
+	t.Parallel()
+
+	noeolDir := filepath.Join(dir, "issue58370")
+	noeolGo := filepath.Join(noeolDir, "noeol.go")
+	noeolTestGo := filepath.Join(noeolDir, "noeol_test.go")
+
+	if err := os.Mkdir(noeolDir, 0777); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := os.WriteFile(filepath.Join(noeolDir, "go.mod"), []byte("module noeol\n"), 0666); err != nil {
+		t.Fatal(err)
+	}
+	const noeolContents = `package noeol`
+	if err := os.WriteFile(noeolGo, []byte(noeolContents), 0444); err != nil {
+		t.Fatal(err)
+	}
+	const noeolTestContents = `
+package noeol
+import "testing"
+func TestCoverage(t *testing.T) { }
+`
+	if err := os.WriteFile(noeolTestGo, []byte(noeolTestContents), 0444); err != nil {
+		t.Fatal(err)
+	}
+
+	// go test -covermode atomic
+	cmd := testenv.Command(t, testenv.GoToolPath(t), "test", toolexecArg, "-covermode", "atomic")
+	cmd.Env = append(cmd.Environ(), "CMDCOVER_TOOLEXEC=true")
+	cmd.Dir = noeolDir
+	run(cmd, t)
+}
+
+func TestSrcPathWithNewline(t *testing.T) {
+	testenv.MustHaveExec(t)
+	t.Parallel()
+
+	// srcPath is intentionally not clean so that the path passed to testcover
+	// will not normalize the trailing / to a \ on Windows.
+	srcPath := t.TempDir() + string(filepath.Separator) + "\npackage main\nfunc main() { panic(string([]rune{'u', 'h', '-', 'o', 'h'}))\n/*/main.go"
+	mainSrc := ` package main
+
+func main() {
+	/* nothing here */
+	println("ok")
+}
+`
+	if err := os.MkdirAll(filepath.Dir(srcPath), 0777); err != nil {
+		t.Skipf("creating directory with bogus path: %v", err)
+	}
+	if err := os.WriteFile(srcPath, []byte(mainSrc), 0666); err != nil {
+		t.Skipf("writing file with bogus directory: %v", err)
+	}
+
+	cmd := testenv.Command(t, testcover(t), "-mode=atomic", srcPath)
+	cmd.Stderr = new(bytes.Buffer)
+	out, err := cmd.Output()
+	t.Logf("%v:\n%s", cmd, out)
+	t.Logf("stderr:\n%s", cmd.Stderr)
+	if err == nil {
+		t.Errorf("unexpected success; want failure due to newline in file path")
+	}
+}

go/src/cmd/cover/doc.go

@@ -0,0 +1,32 @@
+// Copyright 2013 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.
+
+/*
+Cover is a program for analyzing the coverage profiles generated by
+'go test -coverprofile=cover.out'.
+
+Cover is also used by 'go test -cover' to rewrite the source code with
+annotations to track which parts of each function are executed (this
+is referred to "instrumentation"). Cover can operate in "legacy mode"
+on a single Go source file at a time, or when invoked by the Go tool
+it will process all the source files in a single package at a time
+(package-scope instrumentation is enabled via "-pkgcfg" option).
+
+When generated instrumented code, the cover tool computes approximate
+basic block information by studying the source. It is thus more
+portable than binary-rewriting coverage tools, but also a little less
+capable. For instance, it does not probe inside && and || expressions,
+and can be mildly confused by single statements with multiple function
+literals.
+
+When computing coverage of a package that uses cgo, the cover tool
+must be applied to the output of cgo preprocessing, not the input,
+because cover deletes comments that are significant to cgo.
+
+For usage information, please see:
+
+	go help testflag
+	go tool cover -help
+*/
+package main

go/src/cmd/cover/export_test.go

@@ -0,0 +1,7 @@
+// Copyright 2022 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
+
+func Main() { main() }

go/src/cmd/cover/func.go

@@ -0,0 +1,248 @@
+// Copyright 2013 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.
+
+// This file implements the visitor that computes the (line, column)-(line-column) range for each function.
+
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"io"
+	"os"
+	"os/exec"
+	"path"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"text/tabwriter"
+
+	"golang.org/x/tools/cover"
+)
+
+// funcOutput takes two file names as arguments, a coverage profile to read as input and an output
+// file to write ("" means to write to standard output). The function reads the profile and produces
+// as output the coverage data broken down by function, like this:
+//
+//	fmt/format.go:30:	init			100.0%
+//	fmt/format.go:57:	clearflags		100.0%
+//	...
+//	fmt/scan.go:1046:	doScan			100.0%
+//	fmt/scan.go:1075:	advance			96.2%
+//	fmt/scan.go:1119:	doScanf			96.8%
+//	total:		(statements)			91.9%
+
+func funcOutput(profile, outputFile string) error {
+	profiles, err := cover.ParseProfiles(profile)
+	if err != nil {
+		return err
+	}
+
+	dirs, err := findPkgs(profiles)
+	if err != nil {
+		return err
+	}
+
+	var out *bufio.Writer
+	if outputFile == "" {
+		out = bufio.NewWriter(os.Stdout)
+	} else {
+		fd, err := os.Create(outputFile)
+		if err != nil {
+			return err
+		}
+		defer fd.Close()
+		out = bufio.NewWriter(fd)
+	}
+	defer out.Flush()
+
+	tabber := tabwriter.NewWriter(out, 1, 8, 1, '\t', 0)
+	defer tabber.Flush()
+
+	var total, covered int64
+	for _, profile := range profiles {
+		fn := profile.FileName
+		file, err := findFile(dirs, fn)
+		if err != nil {
+			return err
+		}
+		funcs, err := findFuncs(file)
+		if err != nil {
+			return err
+		}
+		// Now match up functions and profile blocks.
+		for _, f := range funcs {
+			c, t := f.coverage(profile)
+			fmt.Fprintf(tabber, "%s:%d:\t%s\t%.1f%%\n", fn, f.startLine, f.name, percent(c, t))
+			total += t
+			covered += c
+		}
+	}
+	fmt.Fprintf(tabber, "total:\t(statements)\t%.1f%%\n", percent(covered, total))
+
+	return nil
+}
+
+// findFuncs parses the file and returns a slice of FuncExtent descriptors.
+func findFuncs(name string) ([]*FuncExtent, error) {
+	fset := token.NewFileSet()
+	parsedFile, err := parser.ParseFile(fset, name, nil, 0)
+	if err != nil {
+		return nil, err
+	}
+	visitor := &FuncVisitor{
+		fset:    fset,
+		name:    name,
+		astFile: parsedFile,
+	}
+	ast.Walk(visitor, visitor.astFile)
+	return visitor.funcs, nil
+}
+
+// FuncExtent describes a function's extent in the source by file and position.
+type FuncExtent struct {
+	name      string
+	startLine int
+	startCol  int
+	endLine   int
+	endCol    int
+}
+
+// FuncVisitor implements the visitor that builds the function position list for a file.
+type FuncVisitor struct {
+	fset    *token.FileSet
+	name    string // Name of file.
+	astFile *ast.File
+	funcs   []*FuncExtent
+}
+
+// Visit implements the ast.Visitor interface.
+func (v *FuncVisitor) Visit(node ast.Node) ast.Visitor {
+	switch n := node.(type) {
+	case *ast.FuncDecl:
+		if n.Body == nil {
+			// Do not count declarations of assembly functions.
+			break
+		}
+		start := v.fset.Position(n.Pos())
+		end := v.fset.Position(n.End())
+		fe := &FuncExtent{
+			name:      n.Name.Name,
+			startLine: start.Line,
+			startCol:  start.Column,
+			endLine:   end.Line,
+			endCol:    end.Column,
+		}
+		v.funcs = append(v.funcs, fe)
+	}
+	return v
+}
+
+// coverage returns the fraction of the statements in the function that were covered, as a numerator and denominator.
+func (f *FuncExtent) coverage(profile *cover.Profile) (num, den int64) {
+	// We could avoid making this n^2 overall by doing a single scan and annotating the functions,
+	// but the sizes of the data structures is never very large and the scan is almost instantaneous.
+	var covered, total int64
+	// The blocks are sorted, so we can stop counting as soon as we reach the end of the relevant block.
+	for _, b := range profile.Blocks {
+		if b.StartLine > f.endLine || (b.StartLine == f.endLine && b.StartCol >= f.endCol) {
+			// Past the end of the function.
+			break
+		}
+		if b.EndLine < f.startLine || (b.EndLine == f.startLine && b.EndCol <= f.startCol) {
+			// Before the beginning of the function
+			continue
+		}
+		total += int64(b.NumStmt)
+		if b.Count > 0 {
+			covered += int64(b.NumStmt)
+		}
+	}
+	return covered, total
+}
+
+// Pkg describes a single package, compatible with the JSON output from 'go list'; see 'go help list'.
+type Pkg struct {
+	ImportPath string
+	Dir        string
+	Error      *struct {
+		Err string
+	}
+}
+
+func findPkgs(profiles []*cover.Profile) (map[string]*Pkg, error) {
+	// Run go list to find the location of every package we care about.
+	pkgs := make(map[string]*Pkg)
+	var list []string
+	for _, profile := range profiles {
+		if strings.HasPrefix(profile.FileName, ".") || filepath.IsAbs(profile.FileName) {
+			// Relative or absolute path.
+			continue
+		}
+		pkg := path.Dir(profile.FileName)
+		if _, ok := pkgs[pkg]; !ok {
+			pkgs[pkg] = nil
+			list = append(list, pkg)
+		}
+	}
+
+	if len(list) == 0 {
+		return pkgs, nil
+	}
+
+	// Note: usually run as "go tool cover" in which case $GOROOT is set,
+	// in which case runtime.GOROOT() does exactly what we want.
+	goTool := filepath.Join(runtime.GOROOT(), "bin/go")
+	cmd := exec.Command(goTool, append([]string{"list", "-e", "-json"}, list...)...)
+	var stderr bytes.Buffer
+	cmd.Stderr = &stderr
+	stdout, err := cmd.Output()
+	if err != nil {
+		return nil, fmt.Errorf("cannot run go list: %v\n%s", err, stderr.Bytes())
+	}
+	dec := json.NewDecoder(bytes.NewReader(stdout))
+	for {
+		var pkg Pkg
+		err := dec.Decode(&pkg)
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return nil, fmt.Errorf("decoding go list json: %v", err)
+		}
+		pkgs[pkg.ImportPath] = &pkg
+	}
+	return pkgs, nil
+}
+
+// findFile finds the location of the named file in GOROOT, GOPATH etc.
+func findFile(pkgs map[string]*Pkg, file string) (string, error) {
+	if strings.HasPrefix(file, ".") || filepath.IsAbs(file) {
+		// Relative or absolute path.
+		return file, nil
+	}
+	pkg := pkgs[path.Dir(file)]
+	if pkg != nil {
+		if pkg.Dir != "" {
+			return filepath.Join(pkg.Dir, path.Base(file)), nil
+		}
+		if pkg.Error != nil {
+			return "", errors.New(pkg.Error.Err)
+		}
+	}
+	return "", fmt.Errorf("did not find package for %s in go list output", file)
+}
+
+func percent(covered, total int64) float64 {
+	if total == 0 {
+		total = 1 // Avoid zero denominator.
+	}
+	return 100.0 * float64(covered) / float64(total)
+}

go/src/cmd/cover/html.go

@@ -0,0 +1,306 @@
+// Copyright 2013 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 (
+	"bufio"
+	"cmd/internal/browser"
+	"fmt"
+	"html/template"
+	"io"
+	"math"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"golang.org/x/tools/cover"
+)
+
+// htmlOutput reads the profile data from profile and generates an HTML
+// coverage report, writing it to outfile. If outfile is empty,
+// it writes the report to a temporary file and opens it in a web browser.
+func htmlOutput(profile, outfile string) error {
+	profiles, err := cover.ParseProfiles(profile)
+	if err != nil {
+		return err
+	}
+
+	var d templateData
+
+	dirs, err := findPkgs(profiles)
+	if err != nil {
+		return err
+	}
+
+	for _, profile := range profiles {
+		fn := profile.FileName
+		if profile.Mode == "set" {
+			d.Set = true
+		}
+		file, err := findFile(dirs, fn)
+		if err != nil {
+			return err
+		}
+		src, err := os.ReadFile(file)
+		if err != nil {
+			return fmt.Errorf("can't read %q: %v", fn, err)
+		}
+		var buf strings.Builder
+		err = htmlGen(&buf, src, profile.Boundaries(src))
+		if err != nil {
+			return err
+		}
+		d.Files = append(d.Files, &templateFile{
+			Name:     fn,
+			Body:     template.HTML(buf.String()),
+			Coverage: percentCovered(profile),
+		})
+	}
+
+	var out *os.File
+	if outfile == "" {
+		var dir string
+		dir, err = os.MkdirTemp("", "cover")
+		if err != nil {
+			return err
+		}
+		out, err = os.Create(filepath.Join(dir, "coverage.html"))
+	} else {
+		out, err = os.Create(outfile)
+	}
+	if err != nil {
+		return err
+	}
+	err = htmlTemplate.Execute(out, d)
+	if err2 := out.Close(); err == nil {
+		err = err2
+	}
+	if err != nil {
+		return err
+	}
+
+	if outfile == "" {
+		if !browser.Open("file://" + out.Name()) {
+			fmt.Fprintf(os.Stderr, "HTML output written to %s\n", out.Name())
+		}
+	}
+
+	return nil
+}
+
+// percentCovered returns, as a percentage, the fraction of the statements in
+// the profile covered by the test run.
+// In effect, it reports the coverage of a given source file.
+func percentCovered(p *cover.Profile) float64 {
+	var total, covered int64
+	for _, b := range p.Blocks {
+		total += int64(b.NumStmt)
+		if b.Count > 0 {
+			covered += int64(b.NumStmt)
+		}
+	}
+	if total == 0 {
+		return 0
+	}
+	return float64(covered) / float64(total) * 100
+}
+
+// htmlGen generates an HTML coverage report with the provided filename,
+// source code, and tokens, and writes it to the given Writer.
+func htmlGen(w io.Writer, src []byte, boundaries []cover.Boundary) error {
+	dst := bufio.NewWriter(w)
+	for i := range src {
+		for len(boundaries) > 0 && boundaries[0].Offset == i {
+			b := boundaries[0]
+			if b.Start {
+				n := 0
+				if b.Count > 0 {
+					n = int(math.Floor(b.Norm*9)) + 1
+				}
+				fmt.Fprintf(dst, `<span class="cov%v" title="%v">`, n, b.Count)
+			} else {
+				dst.WriteString("</span>")
+			}
+			boundaries = boundaries[1:]
+		}
+		switch b := src[i]; b {
+		case '>':
+			dst.WriteString("&gt;")
+		case '<':
+			dst.WriteString("&lt;")
+		case '&':
+			dst.WriteString("&amp;")
+		case '\t':
+			dst.WriteString("        ")
+		default:
+			dst.WriteByte(b)
+		}
+	}
+	return dst.Flush()
+}
+
+// rgb returns an rgb value for the specified coverage value
+// between 0 (no coverage) and 10 (max coverage).
+func rgb(n int) string {
+	if n == 0 {
+		return "rgb(192, 0, 0)" // Red
+	}
+	// Gradient from gray to green.
+	r := 128 - 12*(n-1)
+	g := 128 + 12*(n-1)
+	b := 128 + 3*(n-1)
+	return fmt.Sprintf("rgb(%v, %v, %v)", r, g, b)
+}
+
+// colors generates the CSS rules for coverage colors.
+func colors() template.CSS {
+	var buf strings.Builder
+	for i := 0; i < 11; i++ {
+		fmt.Fprintf(&buf, ".cov%v { color: %v }\n", i, rgb(i))
+	}
+	return template.CSS(buf.String())
+}
+
+var htmlTemplate = template.Must(template.New("html").Funcs(template.FuncMap{
+	"colors": colors,
+}).Parse(tmplHTML))
+
+type templateData struct {
+	Files []*templateFile
+	Set   bool
+}
+
+// PackageName returns a name for the package being shown.
+// It does this by choosing the penultimate element of the path
+// name, so foo.bar/baz/foo.go chooses 'baz'. This is cheap
+// and easy, avoids parsing the Go file, and gets a better answer
+// for package main. It returns the empty string if there is
+// a problem.
+func (td templateData) PackageName() string {
+	if len(td.Files) == 0 {
+		return ""
+	}
+	fileName := td.Files[0].Name
+	elems := strings.Split(fileName, "/") // Package path is always slash-separated.
+	// Return the penultimate non-empty element.
+	for i := len(elems) - 2; i >= 0; i-- {
+		if elems[i] != "" {
+			return elems[i]
+		}
+	}
+	return ""
+}
+
+type templateFile struct {
+	Name     string
+	Body     template.HTML
+	Coverage float64
+}
+
+const tmplHTML = `
+<!DOCTYPE html>
+<html>
+	<head>
+		<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+		<title>{{$pkg := .PackageName}}{{if $pkg}}{{$pkg}}: {{end}}Go Coverage Report</title>
+		<style>
+			body {
+				background: black;
+				color: rgb(80, 80, 80);
+			}
+			body, pre, #legend span {
+				font-family: Menlo, monospace;
+				font-weight: bold;
+			}
+			#topbar {
+				background: black;
+				position: fixed;
+				top: 0; left: 0; right: 0;
+				height: 42px;
+				border-bottom: 1px solid rgb(80, 80, 80);
+			}
+			#content {
+				margin-top: 50px;
+			}
+			#nav, #legend {
+				float: left;
+				margin-left: 10px;
+			}
+			#legend {
+				margin-top: 12px;
+			}
+			#nav {
+				margin-top: 10px;
+			}
+			#legend span {
+				margin: 0 5px;
+			}
+			{{colors}}
+		</style>
+	</head>
+	<body>
+		<div id="topbar">
+			<div id="nav">
+				<select id="files">
+				{{range $i, $f := .Files}}
+				<option value="file{{$i}}">{{$f.Name}} ({{printf "%.1f" $f.Coverage}}%)</option>
+				{{end}}
+				</select>
+			</div>
+			<div id="legend">
+				<span>not tracked</span>
+			{{if .Set}}
+				<span class="cov0">not covered</span>
+				<span class="cov8">covered</span>
+			{{else}}
+				<span class="cov0">no coverage</span>
+				<span class="cov1">low coverage</span>
+				<span class="cov2">*</span>
+				<span class="cov3">*</span>
+				<span class="cov4">*</span>
+				<span class="cov5">*</span>
+				<span class="cov6">*</span>
+				<span class="cov7">*</span>
+				<span class="cov8">*</span>
+				<span class="cov9">*</span>
+				<span class="cov10">high coverage</span>
+			{{end}}
+			</div>
+		</div>
+		<div id="content">
+		{{range $i, $f := .Files}}
+		<pre class="file" id="file{{$i}}" style="display: none">{{$f.Body}}</pre>
+		{{end}}
+		</div>
+	</body>
+	<script>
+	(function() {
+		var files = document.getElementById('files');
+		var visible;
+		files.addEventListener('change', onChange, false);
+		function select(part) {
+			if (visible)
+				visible.style.display = 'none';
+			visible = document.getElementById(part);
+			if (!visible)
+				return;
+			files.value = part;
+			visible.style.display = 'block';
+			location.hash = part;
+		}
+		function onChange() {
+			select(files.value);
+			window.scrollTo(0, 0);
+		}
+		if (location.hash != "") {
+			select(location.hash.substr(1));
+		}
+		if (!visible) {
+			select("file0");
+		}
+	})();
+	</script>
+</html>
+`

go/src/cmd/cover/pkgname_test.go

@@ -0,0 +1,31 @@
+// Copyright 2020 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 "testing"
+
+func TestPackageName(t *testing.T) {
+	var tests = []struct {
+		fileName, pkgName string
+	}{
+		{"", ""},
+		{"///", ""},
+		{"fmt", ""}, // No Go file, improper form.
+		{"fmt/foo.go", "fmt"},
+		{"encoding/binary/foo.go", "binary"},
+		{"encoding/binary/////foo.go", "binary"},
+	}
+	var tf templateFile
+	for _, test := range tests {
+		tf.Name = test.fileName
+		td := templateData{
+			Files: []*templateFile{&tf},
+		}
+		got := td.PackageName()
+		if got != test.pkgName {
+			t.Errorf("%s: got %s want %s", test.fileName, got, test.pkgName)
+		}
+	}
+}

go/src/cmd/dist/README

@@ -0,0 +1,20 @@
+This program, dist, is the bootstrapping tool for the Go distribution.
+
+As of Go 1.5, dist and other parts of the compiler toolchain are written
+in Go, making bootstrapping a little more involved than in the past.
+The approach is to build the current release of Go with an earlier one.
+
+The process to install Go 1.x, for x ≥ 26, is:
+
+1. Build cmd/dist with Go 1.24.6.
+2. Using dist, build Go 1.x compiler toolchain with Go 1.24.6.
+3. Using dist, rebuild Go 1.x compiler toolchain with itself.
+4. Using dist, build Go 1.x cmd/go (as go_bootstrap) with Go 1.x compiler toolchain.
+5. Using go_bootstrap, build the remaining Go 1.x standard library and commands.
+
+Because of backward compatibility, although the steps above say Go 1.24.6,
+in practice any release ≥ Go 1.24.6 but < Go 1.x will work as the bootstrap base.
+Releases ≥ Go 1.x are very likely to work as well.
+
+See go.dev/s/go15bootstrap for more details about the original bootstrap
+and go.dev/issue/54265 for details about later bootstrap version bumps.

go/src/cmd/dist/build.go

@@ -0,0 +1,2020 @@
+// Copyright 2012 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 (
+	"bytes"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"io"
+	"io/fs"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"slices"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+)
+
+// Initialization for any invocation.
+
+// The usual variables.
+var (
+	goarch           string
+	gorootBin        string
+	gorootBinGo      string
+	gohostarch       string
+	gohostos         string
+	goos             string
+	goarm            string
+	goarm64          string
+	go386            string
+	goamd64          string
+	gomips           string
+	gomips64         string
+	goppc64          string
+	goriscv64        string
+	goroot           string
+	goextlinkenabled string
+	gogcflags        string // For running built compiler
+	goldflags        string
+	goexperiment     string
+	gofips140        string
+	workdir          string
+	tooldir          string
+	oldgoos          string
+	oldgoarch        string
+	oldgocache       string
+	exe              string
+	defaultcc        map[string]string
+	defaultcxx       map[string]string
+	defaultpkgconfig string
+	defaultldso      string
+
+	rebuildall bool
+	noOpt      bool
+	isRelease  bool
+
+	vflag int // verbosity
+)
+
+// The known architectures.
+var okgoarch = []string{
+	"386",
+	"amd64",
+	"arm",
+	"arm64",
+	"loong64",
+	"mips",
+	"mipsle",
+	"mips64",
+	"mips64le",
+	"ppc64",
+	"ppc64le",
+	"riscv64",
+	"s390x",
+	"sparc64",
+	"wasm",
+}
+
+// The known operating systems.
+var okgoos = []string{
+	"darwin",
+	"dragonfly",
+	"illumos",
+	"ios",
+	"js",
+	"wasip1",
+	"linux",
+	"android",
+	"solaris",
+	"freebsd",
+	"nacl", // keep;
+	"netbsd",
+	"openbsd",
+	"plan9",
+	"windows",
+	"aix",
+}
+
+// xinit handles initialization of the various global state, like goroot and goarch.
+func xinit() {
+	b := os.Getenv("GOROOT")
+	if b == "" {
+		fatalf("$GOROOT must be set")
+	}
+	goroot = filepath.Clean(b)
+	gorootBin = pathf("%s/bin", goroot)
+
+	// Don't run just 'go' because the build infrastructure
+	// runs cmd/dist inside go/bin often, and on Windows
+	// it will be found in the current directory and refuse to exec.
+	// All exec calls rewrite "go" into gorootBinGo.
+	gorootBinGo = pathf("%s/bin/go", goroot)
+
+	b = os.Getenv("GOOS")
+	if b == "" {
+		b = gohostos
+	}
+	goos = b
+	if slices.Index(okgoos, goos) < 0 {
+		fatalf("unknown $GOOS %s", goos)
+	}
+
+	b = os.Getenv("GOARM")
+	if b == "" {
+		b = xgetgoarm()
+	}
+	goarm = b
+
+	b = os.Getenv("GOARM64")
+	if b == "" {
+		b = "v8.0"
+	}
+	goarm64 = b
+
+	b = os.Getenv("GO386")
+	if b == "" {
+		b = "sse2"
+	}
+	go386 = b
+
+	b = os.Getenv("GOAMD64")
+	if b == "" {
+		b = "v1"
+	}
+	goamd64 = b
+
+	b = os.Getenv("GOMIPS")
+	if b == "" {
+		b = "hardfloat"
+	}
+	gomips = b
+
+	b = os.Getenv("GOMIPS64")
+	if b == "" {
+		b = "hardfloat"
+	}
+	gomips64 = b
+
+	b = os.Getenv("GOPPC64")
+	if b == "" {
+		b = "power8"
+	}
+	goppc64 = b
+
+	b = os.Getenv("GORISCV64")
+	if b == "" {
+		b = "rva20u64"
+	}
+	goriscv64 = b
+
+	b = os.Getenv("GOFIPS140")
+	if b == "" {
+		b = "off"
+	}
+	gofips140 = b
+
+	if p := pathf("%s/src/all.bash", goroot); !isfile(p) {
+		fatalf("$GOROOT is not set correctly or not exported\n"+
+			"\tGOROOT=%s\n"+
+			"\t%s does not exist", goroot, p)
+	}
+
+	b = os.Getenv("GOHOSTARCH")
+	if b != "" {
+		gohostarch = b
+	}
+	if slices.Index(okgoarch, gohostarch) < 0 {
+		fatalf("unknown $GOHOSTARCH %s", gohostarch)
+	}
+
+	b = os.Getenv("GOARCH")
+	if b == "" {
+		b = gohostarch
+	}
+	goarch = b
+	if slices.Index(okgoarch, goarch) < 0 {
+		fatalf("unknown $GOARCH %s", goarch)
+	}
+
+	b = os.Getenv("GO_EXTLINK_ENABLED")
+	if b != "" {
+		if b != "0" && b != "1" {
+			fatalf("unknown $GO_EXTLINK_ENABLED %s", b)
+		}
+		goextlinkenabled = b
+	}
+
+	goexperiment = os.Getenv("GOEXPERIMENT")
+	// TODO(mdempsky): Validate known experiments?
+
+	gogcflags = os.Getenv("BOOT_GO_GCFLAGS")
+	goldflags = os.Getenv("BOOT_GO_LDFLAGS")
+
+	defaultcc = compilerEnv("CC", "")
+	defaultcxx = compilerEnv("CXX", "")
+
+	b = os.Getenv("PKG_CONFIG")
+	if b == "" {
+		b = "pkg-config"
+	}
+	defaultpkgconfig = b
+
+	defaultldso = os.Getenv("GO_LDSO")
+
+	// For tools being invoked but also for os.ExpandEnv.
+	os.Setenv("GO386", go386)
+	os.Setenv("GOAMD64", goamd64)
+	os.Setenv("GOARCH", goarch)
+	os.Setenv("GOARM", goarm)
+	os.Setenv("GOARM64", goarm64)
+	os.Setenv("GOHOSTARCH", gohostarch)
+	os.Setenv("GOHOSTOS", gohostos)
+	os.Setenv("GOOS", goos)
+	os.Setenv("GOMIPS", gomips)
+	os.Setenv("GOMIPS64", gomips64)
+	os.Setenv("GOPPC64", goppc64)
+	os.Setenv("GORISCV64", goriscv64)
+	os.Setenv("GOROOT", goroot)
+	os.Setenv("GOFIPS140", gofips140)
+
+	// Set GOBIN to GOROOT/bin. The meaning of GOBIN has drifted over time
+	// (see https://go.dev/issue/3269, https://go.dev/cl/183058,
+	// https://go.dev/issue/31576). Since we want binaries installed by 'dist' to
+	// always go to GOROOT/bin anyway.
+	os.Setenv("GOBIN", gorootBin)
+
+	// Make the environment more predictable.
+	os.Setenv("LANG", "C")
+	os.Setenv("LANGUAGE", "en_US.UTF8")
+	os.Unsetenv("GO111MODULE")
+	os.Setenv("GOENV", "off")
+	os.Unsetenv("GOFLAGS")
+	os.Setenv("GOWORK", "off")
+
+	// Create the go.mod for building toolchain2 and toolchain3. Toolchain1 and go_bootstrap are built with
+	// a separate go.mod (with a lower required go version to allow all allowed bootstrap toolchain versions)
+	// in bootstrapBuildTools.
+	modVer := goModVersion()
+	workdir = xworkdir()
+	if err := os.WriteFile(pathf("%s/go.mod", workdir), []byte("module bootstrap\n\ngo "+modVer+"\n"), 0666); err != nil {
+		fatalf("cannot write stub go.mod: %s", err)
+	}
+	xatexit(rmworkdir)
+
+	tooldir = pathf("%s/pkg/tool/%s_%s", goroot, gohostos, gohostarch)
+
+	goversion := findgoversion()
+	isRelease = (strings.HasPrefix(goversion, "release.") || strings.HasPrefix(goversion, "go")) &&
+		!strings.Contains(goversion, "devel")
+}
+
+// compilerEnv returns a map from "goos/goarch" to the
+// compiler setting to use for that platform.
+// The entry for key "" covers any goos/goarch not explicitly set in the map.
+// For example, compilerEnv("CC", "gcc") returns the C compiler settings
+// read from $CC, defaulting to gcc.
+//
+// The result is a map because additional environment variables
+// can be set to change the compiler based on goos/goarch settings.
+// The following applies to all envNames but CC is assumed to simplify
+// the presentation.
+//
+// If no environment variables are set, we use def for all goos/goarch.
+// $CC, if set, applies to all goos/goarch but is overridden by the following.
+// $CC_FOR_TARGET, if set, applies to all goos/goarch except gohostos/gohostarch,
+// but is overridden by the following.
+// If gohostos=goos and gohostarch=goarch, then $CC_FOR_TARGET applies even for gohostos/gohostarch.
+// $CC_FOR_goos_goarch, if set, applies only to goos/goarch.
+func compilerEnv(envName, def string) map[string]string {
+	m := map[string]string{"": def}
+
+	if env := os.Getenv(envName); env != "" {
+		m[""] = env
+	}
+	if env := os.Getenv(envName + "_FOR_TARGET"); env != "" {
+		if gohostos != goos || gohostarch != goarch {
+			m[gohostos+"/"+gohostarch] = m[""]
+		}
+		m[""] = env
+	}
+
+	for _, goos := range okgoos {
+		for _, goarch := range okgoarch {
+			if env := os.Getenv(envName + "_FOR_" + goos + "_" + goarch); env != "" {
+				m[goos+"/"+goarch] = env
+			}
+		}
+	}
+
+	return m
+}
+
+// clangos lists the operating systems where we prefer clang to gcc.
+var clangos = []string{
+	"darwin", "ios", // macOS 10.9 and later require clang
+	"freebsd", // FreeBSD 10 and later do not ship gcc
+	"openbsd", // OpenBSD ships with GCC 4.2, which is now quite old.
+}
+
+// compilerEnvLookup returns the compiler settings for goos/goarch in map m.
+// kind is "CC" or "CXX".
+func compilerEnvLookup(kind string, m map[string]string, goos, goarch string) string {
+	if !needCC() {
+		return ""
+	}
+	if cc := m[goos+"/"+goarch]; cc != "" {
+		return cc
+	}
+	if cc := m[""]; cc != "" {
+		return cc
+	}
+	for _, os := range clangos {
+		if goos == os {
+			if kind == "CXX" {
+				return "clang++"
+			}
+			return "clang"
+		}
+	}
+	if kind == "CXX" {
+		return "g++"
+	}
+	return "gcc"
+}
+
+// rmworkdir deletes the work directory.
+func rmworkdir() {
+	if vflag > 1 {
+		errprintf("rm -rf %s\n", workdir)
+	}
+	xremoveall(workdir)
+}
+
+// Remove trailing spaces.
+func chomp(s string) string {
+	return strings.TrimRight(s, " \t\r\n")
+}
+
+// findgoversion determines the Go version to use in the version string.
+// It also parses any other metadata found in the version file.
+func findgoversion() string {
+	// The $GOROOT/VERSION file takes priority, for distributions
+	// without the source repo.
+	path := pathf("%s/VERSION", goroot)
+	if isfile(path) {
+		b := chomp(readfile(path))
+
+		// Starting in Go 1.21 the VERSION file starts with the
+		// version on a line by itself but then can contain other
+		// metadata about the release, one item per line.
+		if i := strings.Index(b, "\n"); i >= 0 {
+			rest := b[i+1:]
+			b = chomp(b[:i])
+			for line := range strings.SplitSeq(rest, "\n") {
+				f := strings.Fields(line)
+				if len(f) == 0 {
+					continue
+				}
+				switch f[0] {
+				default:
+					fatalf("VERSION: unexpected line: %s", line)
+				case "time":
+					if len(f) != 2 {
+						fatalf("VERSION: unexpected time line: %s", line)
+					}
+					_, err := time.Parse(time.RFC3339, f[1])
+					if err != nil {
+						fatalf("VERSION: bad time: %s", err)
+					}
+				}
+			}
+		}
+
+		// Commands such as "dist version > VERSION" will cause
+		// the shell to create an empty VERSION file and set dist's
+		// stdout to its fd. dist in turn looks at VERSION and uses
+		// its content if available, which is empty at this point.
+		// Only use the VERSION file if it is non-empty.
+		if b != "" {
+			return b
+		}
+	}
+
+	// The $GOROOT/VERSION.cache file is a cache to avoid invoking
+	// git every time we run this command. Unlike VERSION, it gets
+	// deleted by the clean command.
+	path = pathf("%s/VERSION.cache", goroot)
+	if isfile(path) {
+		return chomp(readfile(path))
+	}
+
+	// Show a nicer error message if this isn't a Git repo.
+	if !isGitRepo() {
+		fatalf("FAILED: not a Git repo; must put a VERSION file in $GOROOT")
+	}
+
+	// Otherwise, use Git.
+	//
+	// Include 1.x base version, hash, and date in the version.
+	// Make sure it includes the substring "devel", but otherwise
+	// use a format compatible with https://go.dev/doc/toolchain#name
+	// so that it's possible to use go/version.Lang, Compare and so on.
+	// See go.dev/issue/73372.
+	//
+	// Note that we lightly parse internal/goversion/goversion.go to
+	// obtain the base version. We can't just import the package,
+	// because cmd/dist is built with a bootstrap GOROOT which could
+	// be an entirely different version of Go. We assume
+	// that the file contains "const Version = <Integer>".
+	goversionSource := readfile(pathf("%s/src/internal/goversion/goversion.go", goroot))
+	m := regexp.MustCompile(`(?m)^const Version = (\d+)`).FindStringSubmatch(goversionSource)
+	if m == nil {
+		fatalf("internal/goversion/goversion.go does not contain 'const Version = ...'")
+	}
+	version := fmt.Sprintf("go1.%s-devel_", m[1])
+	version += chomp(run(goroot, CheckExit, "git", "log", "-n", "1", "--format=format:%h %cd", "HEAD"))
+
+	// Cache version.
+	writefile(version, path, 0)
+
+	return version
+}
+
+// goModVersion returns the go version declared in src/go.mod. This is the
+// go version to use in the go.mod building go_bootstrap, toolchain2, and toolchain3.
+// (toolchain1 must be built with requiredBootstrapVersion(goModVersion))
+func goModVersion() string {
+	goMod := readfile(pathf("%s/src/go.mod", goroot))
+	m := regexp.MustCompile(`(?m)^go (1.\d+)$`).FindStringSubmatch(goMod)
+	if m == nil {
+		fatalf("std go.mod does not contain go 1.X")
+	}
+	return m[1]
+}
+
+func requiredBootstrapVersion(v string) string {
+	minorstr, ok := strings.CutPrefix(v, "1.")
+	if !ok {
+		fatalf("go version %q in go.mod does not start with %q", v, "1.")
+	}
+	minor, err := strconv.Atoi(minorstr)
+	if err != nil {
+		fatalf("invalid go version minor component %q: %v", minorstr, err)
+	}
+	// Per go.dev/doc/install/source, for N >= 22, Go version 1.N will require a Go 1.M compiler,
+	// where M is N-2 rounded down to an even number. Example: Go 1.24 and 1.25 require Go 1.22.
+	requiredMinor := minor - 2 - minor%2
+	return "1." + strconv.Itoa(requiredMinor)
+}
+
+// isGitRepo reports whether the working directory is inside a Git repository.
+func isGitRepo() bool {
+	// NB: simply checking the exit code of `git rev-parse --git-dir` would
+	// suffice here, but that requires deviating from the infrastructure
+	// provided by `run`.
+	gitDir := chomp(run(goroot, 0, "git", "rev-parse", "--git-dir"))
+	if !filepath.IsAbs(gitDir) {
+		gitDir = filepath.Join(goroot, gitDir)
+	}
+	return isdir(gitDir)
+}
+
+/*
+ * Initial tree setup.
+ */
+
+// The old tools that no longer live in $GOBIN or $GOROOT/bin.
+var oldtool = []string{
+	"5a", "5c", "5g", "5l",
+	"6a", "6c", "6g", "6l",
+	"8a", "8c", "8g", "8l",
+	"9a", "9c", "9g", "9l",
+	"6cov",
+	"6nm",
+	"6prof",
+	"cgo",
+	"ebnflint",
+	"goapi",
+	"gofix",
+	"goinstall",
+	"gomake",
+	"gopack",
+	"gopprof",
+	"gotest",
+	"gotype",
+	"govet",
+	"goyacc",
+	"quietgcc",
+}
+
+// Unreleased directories (relative to $GOROOT) that should
+// not be in release branches.
+var unreleased = []string{
+	"src/cmd/newlink",
+	"src/cmd/objwriter",
+	"src/debug/goobj",
+	"src/old",
+}
+
+// setup sets up the tree for the initial build.
+func setup() {
+	// Create bin directory.
+	if p := pathf("%s/bin", goroot); !isdir(p) {
+		xmkdir(p)
+	}
+
+	// Create package directory.
+	if p := pathf("%s/pkg", goroot); !isdir(p) {
+		xmkdir(p)
+	}
+
+	goosGoarch := pathf("%s/pkg/%s_%s", goroot, gohostos, gohostarch)
+	if rebuildall {
+		xremoveall(goosGoarch)
+	}
+	xmkdirall(goosGoarch)
+	xatexit(func() {
+		if files := xreaddir(goosGoarch); len(files) == 0 {
+			xremove(goosGoarch)
+		}
+	})
+
+	if goos != gohostos || goarch != gohostarch {
+		p := pathf("%s/pkg/%s_%s", goroot, goos, goarch)
+		if rebuildall {
+			xremoveall(p)
+		}
+		xmkdirall(p)
+	}
+
+	// Create object directory.
+	// We used to use it for C objects.
+	// Now we use it for the build cache, to separate dist's cache
+	// from any other cache the user might have, and for the location
+	// to build the bootstrap versions of the standard library.
+	obj := pathf("%s/pkg/obj", goroot)
+	if !isdir(obj) {
+		xmkdir(obj)
+	}
+	xatexit(func() { xremove(obj) })
+
+	// Create build cache directory.
+	objGobuild := pathf("%s/pkg/obj/go-build", goroot)
+	if rebuildall {
+		xremoveall(objGobuild)
+	}
+	xmkdirall(objGobuild)
+	xatexit(func() { xremoveall(objGobuild) })
+
+	// Create directory for bootstrap versions of standard library .a files.
+	objGoBootstrap := pathf("%s/pkg/obj/go-bootstrap", goroot)
+	if rebuildall {
+		xremoveall(objGoBootstrap)
+	}
+	xmkdirall(objGoBootstrap)
+	xatexit(func() { xremoveall(objGoBootstrap) })
+
+	// Create tool directory.
+	// We keep it in pkg/, just like the object directory above.
+	if rebuildall {
+		xremoveall(tooldir)
+	}
+	xmkdirall(tooldir)
+
+	// Remove tool binaries from before the tool/gohostos_gohostarch
+	xremoveall(pathf("%s/bin/tool", goroot))
+
+	// Remove old pre-tool binaries.
+	for _, old := range oldtool {
+		xremove(pathf("%s/bin/%s", goroot, old))
+	}
+
+	// Special release-specific setup.
+	if isRelease {
+		// Make sure release-excluded things are excluded.
+		for _, dir := range unreleased {
+			if p := pathf("%s/%s", goroot, dir); isdir(p) {
+				fatalf("%s should not exist in release build", p)
+			}
+		}
+	}
+}
+
+/*
+ * Tool building
+ */
+
+// mustLinkExternal is a copy of internal/platform.MustLinkExternal,
+// duplicated here to avoid version skew in the MustLinkExternal function
+// during bootstrapping.
+func mustLinkExternal(goos, goarch string, cgoEnabled bool) bool {
+	if cgoEnabled {
+		switch goarch {
+		case "mips", "mipsle", "mips64", "mips64le":
+			// Internally linking cgo is incomplete on some architectures.
+			// https://golang.org/issue/14449
+			return true
+		case "ppc64":
+			// Big Endian PPC64 cgo internal linking is not implemented for aix or linux.
+			if goos == "aix" || goos == "linux" {
+				return true
+			}
+		}
+
+		switch goos {
+		case "android":
+			return true
+		case "dragonfly":
+			// It seems that on Dragonfly thread local storage is
+			// set up by the dynamic linker, so internal cgo linking
+			// doesn't work. Test case is "go test runtime/cgo".
+			return true
+		}
+	}
+
+	switch goos {
+	case "android":
+		if goarch != "arm64" {
+			return true
+		}
+	case "ios":
+		if goarch == "arm64" {
+			return true
+		}
+	}
+	return false
+}
+
+// depsuffix records the allowed suffixes for source files.
+var depsuffix = []string{
+	".s",
+	".go",
+}
+
+// gentab records how to generate some trivial files.
+// Files listed here should also be listed in ../distpack/pack.go's srcArch.Remove list.
+var gentab = []struct {
+	pkg  string // Relative to $GOROOT/src
+	file string
+	gen  func(dir, file string)
+}{
+	{"cmd/go/internal/cfg", "zdefaultcc.go", mkzdefaultcc},
+	{"internal/runtime/sys", "zversion.go", mkzversion},
+	{"time/tzdata", "zzipdata.go", mktzdata},
+}
+
+// installed maps from a dir name (as given to install) to a chan
+// closed when the dir's package is installed.
+var installed = make(map[string]chan struct{})
+var installedMu sync.Mutex
+
+func install(dir string) {
+	<-startInstall(dir)
+}
+
+func startInstall(dir string) chan struct{} {
+	installedMu.Lock()
+	ch := installed[dir]
+	if ch == nil {
+		ch = make(chan struct{})
+		installed[dir] = ch
+		go runInstall(dir, ch)
+	}
+	installedMu.Unlock()
+	return ch
+}
+
+// runInstall installs the library, package, or binary associated with pkg,
+// which is relative to $GOROOT/src.
+func runInstall(pkg string, ch chan struct{}) {
+	if pkg == "net" || pkg == "os/user" || pkg == "crypto/x509" {
+		fatalf("go_bootstrap cannot depend on cgo package %s", pkg)
+	}
+
+	defer close(ch)
+
+	if pkg == "unsafe" {
+		return
+	}
+
+	if vflag > 0 {
+		if goos != gohostos || goarch != gohostarch {
+			errprintf("%s (%s/%s)\n", pkg, goos, goarch)
+		} else {
+			errprintf("%s\n", pkg)
+		}
+	}
+
+	workdir := pathf("%s/%s", workdir, pkg)
+	xmkdirall(workdir)
+
+	var clean []string
+	defer func() {
+		for _, name := range clean {
+			xremove(name)
+		}
+	}()
+
+	// dir = full path to pkg.
+	dir := pathf("%s/src/%s", goroot, pkg)
+	name := filepath.Base(dir)
+
+	// ispkg predicts whether the package should be linked as a binary, based
+	// on the name. There should be no "main" packages in vendor, since
+	// 'go mod vendor' will only copy imported packages there.
+	ispkg := !strings.HasPrefix(pkg, "cmd/") || strings.Contains(pkg, "/internal/") || strings.Contains(pkg, "/vendor/")
+
+	// Start final link command line.
+	// Note: code below knows that link.p[targ] is the target.
+	var (
+		link      []string
+		targ      int
+		ispackcmd bool
+	)
+	if ispkg {
+		// Go library (package).
+		ispackcmd = true
+		link = []string{"pack", packagefile(pkg)}
+		targ = len(link) - 1
+		xmkdirall(filepath.Dir(link[targ]))
+	} else {
+		// Go command.
+		elem := name
+		if elem == "go" {
+			elem = "go_bootstrap"
+		}
+		link = []string{pathf("%s/link", tooldir)}
+		if goos == "android" {
+			link = append(link, "-buildmode=pie")
+		}
+		if goldflags != "" {
+			link = append(link, goldflags)
+		}
+		link = append(link, "-extld="+compilerEnvLookup("CC", defaultcc, goos, goarch))
+		link = append(link, "-L="+pathf("%s/pkg/obj/go-bootstrap/%s_%s", goroot, goos, goarch))
+		link = append(link, "-o", pathf("%s/%s%s", tooldir, elem, exe))
+		targ = len(link) - 1
+	}
+	ttarg := mtime(link[targ])
+
+	// Gather files that are sources for this target.
+	// Everything in that directory, and any target-specific
+	// additions.
+	files := xreaddir(dir)
+
+	// Remove files beginning with . or _,
+	// which are likely to be editor temporary files.
+	// This is the same heuristic build.ScanDir uses.
+	// There do exist real C files beginning with _,
+	// so limit that check to just Go files.
+	files = filter(files, func(p string) bool {
+		return !strings.HasPrefix(p, ".") && (!strings.HasPrefix(p, "_") || !strings.HasSuffix(p, ".go"))
+	})
+
+	// Add generated files for this package.
+	for _, gt := range gentab {
+		if gt.pkg == pkg {
+			files = append(files, gt.file)
+		}
+	}
+	files = uniq(files)
+
+	// Convert to absolute paths.
+	for i, p := range files {
+		if !filepath.IsAbs(p) {
+			files[i] = pathf("%s/%s", dir, p)
+		}
+	}
+
+	// Is the target up-to-date?
+	var gofiles, sfiles []string
+	stale := rebuildall
+	files = filter(files, func(p string) bool {
+		for _, suf := range depsuffix {
+			if strings.HasSuffix(p, suf) {
+				goto ok
+			}
+		}
+		return false
+	ok:
+		t := mtime(p)
+		if !t.IsZero() && !strings.HasSuffix(p, ".a") && !shouldbuild(p, pkg) {
+			return false
+		}
+		if strings.HasSuffix(p, ".go") {
+			gofiles = append(gofiles, p)
+		} else if strings.HasSuffix(p, ".s") {
+			sfiles = append(sfiles, p)
+		}
+		if t.After(ttarg) {
+			stale = true
+		}
+		return true
+	})
+
+	// If there are no files to compile, we're done.
+	if len(files) == 0 {
+		return
+	}
+
+	if !stale {
+		return
+	}
+
+	// For package runtime, copy some files into the work space.
+	if pkg == "runtime" {
+		xmkdirall(pathf("%s/pkg/include", goroot))
+		// For use by assembly and C files.
+		copyfile(pathf("%s/pkg/include/textflag.h", goroot),
+			pathf("%s/src/runtime/textflag.h", goroot), 0)
+		copyfile(pathf("%s/pkg/include/funcdata.h", goroot),
+			pathf("%s/src/runtime/funcdata.h", goroot), 0)
+		copyfile(pathf("%s/pkg/include/asm_ppc64x.h", goroot),
+			pathf("%s/src/runtime/asm_ppc64x.h", goroot), 0)
+		copyfile(pathf("%s/pkg/include/asm_amd64.h", goroot),
+			pathf("%s/src/runtime/asm_amd64.h", goroot), 0)
+		copyfile(pathf("%s/pkg/include/asm_riscv64.h", goroot),
+			pathf("%s/src/runtime/asm_riscv64.h", goroot), 0)
+	}
+
+	// Generate any missing files; regenerate existing ones.
+	for _, gt := range gentab {
+		if gt.pkg != pkg {
+			continue
+		}
+		p := pathf("%s/%s", dir, gt.file)
+		if vflag > 1 {
+			errprintf("generate %s\n", p)
+		}
+		gt.gen(dir, p)
+		// Do not add generated file to clean list.
+		// In runtime, we want to be able to
+		// build the package with the go tool,
+		// and it assumes these generated files already
+		// exist (it does not know how to build them).
+		// The 'clean' command can remove
+		// the generated files.
+	}
+
+	// Resolve imported packages to actual package paths.
+	// Make sure they're installed.
+	importMap := make(map[string]string)
+	for _, p := range gofiles {
+		for _, imp := range readimports(p) {
+			if imp == "C" {
+				fatalf("%s imports C", p)
+			}
+			importMap[imp] = resolveVendor(imp, dir)
+		}
+	}
+	sortedImports := make([]string, 0, len(importMap))
+	for imp := range importMap {
+		sortedImports = append(sortedImports, imp)
+	}
+	sort.Strings(sortedImports)
+
+	for _, dep := range importMap {
+		if dep == "C" {
+			fatalf("%s imports C", pkg)
+		}
+		startInstall(dep)
+	}
+	for _, dep := range importMap {
+		install(dep)
+	}
+
+	if goos != gohostos || goarch != gohostarch {
+		// We've generated the right files; the go command can do the build.
+		if vflag > 1 {
+			errprintf("skip build for cross-compile %s\n", pkg)
+		}
+		return
+	}
+
+	asmArgs := []string{
+		pathf("%s/asm", tooldir),
+		"-I", workdir,
+		"-I", pathf("%s/pkg/include", goroot),
+		"-D", "GOOS_" + goos,
+		"-D", "GOARCH_" + goarch,
+		"-D", "GOOS_GOARCH_" + goos + "_" + goarch,
+		"-p", pkg,
+	}
+	if goarch == "mips" || goarch == "mipsle" {
+		// Define GOMIPS_value from gomips.
+		asmArgs = append(asmArgs, "-D", "GOMIPS_"+gomips)
+	}
+	if goarch == "mips64" || goarch == "mips64le" {
+		// Define GOMIPS64_value from gomips64.
+		asmArgs = append(asmArgs, "-D", "GOMIPS64_"+gomips64)
+	}
+	if goarch == "ppc64" || goarch == "ppc64le" {
+		// We treat each powerpc version as a superset of functionality.
+		switch goppc64 {
+		case "power10":
+			asmArgs = append(asmArgs, "-D", "GOPPC64_power10")
+			fallthrough
+		case "power9":
+			asmArgs = append(asmArgs, "-D", "GOPPC64_power9")
+			fallthrough
+		default: // This should always be power8.
+			asmArgs = append(asmArgs, "-D", "GOPPC64_power8")
+		}
+	}
+	if goarch == "riscv64" {
+		// Define GORISCV64_value from goriscv64
+		asmArgs = append(asmArgs, "-D", "GORISCV64_"+goriscv64)
+	}
+	if goarch == "arm" {
+		// Define GOARM_value from goarm, which can be either a version
+		// like "6", or a version and a FP mode, like "7,hardfloat".
+		switch {
+		case strings.Contains(goarm, "7"):
+			asmArgs = append(asmArgs, "-D", "GOARM_7")
+			fallthrough
+		case strings.Contains(goarm, "6"):
+			asmArgs = append(asmArgs, "-D", "GOARM_6")
+			fallthrough
+		default:
+			asmArgs = append(asmArgs, "-D", "GOARM_5")
+		}
+	}
+	goasmh := pathf("%s/go_asm.h", workdir)
+
+	// Collect symabis from assembly code.
+	var symabis string
+	if len(sfiles) > 0 {
+		symabis = pathf("%s/symabis", workdir)
+		var wg sync.WaitGroup
+		asmabis := append(asmArgs[:len(asmArgs):len(asmArgs)], "-gensymabis", "-o", symabis)
+		asmabis = append(asmabis, sfiles...)
+		if err := os.WriteFile(goasmh, nil, 0666); err != nil {
+			fatalf("cannot write empty go_asm.h: %s", err)
+		}
+		bgrun(&wg, dir, asmabis...)
+		bgwait(&wg)
+	}
+
+	// Build an importcfg file for the compiler.
+	buf := &bytes.Buffer{}
+	for _, imp := range sortedImports {
+		if imp == "unsafe" {
+			continue
+		}
+		dep := importMap[imp]
+		if imp != dep {
+			fmt.Fprintf(buf, "importmap %s=%s\n", imp, dep)
+		}
+		fmt.Fprintf(buf, "packagefile %s=%s\n", dep, packagefile(dep))
+	}
+	importcfg := pathf("%s/importcfg", workdir)
+	if err := os.WriteFile(importcfg, buf.Bytes(), 0666); err != nil {
+		fatalf("cannot write importcfg file: %v", err)
+	}
+
+	var archive string
+	// The next loop will compile individual non-Go files.
+	// Hand the Go files to the compiler en masse.
+	// For packages containing assembly, this writes go_asm.h, which
+	// the assembly files will need.
+	pkgName := pkg
+	if strings.HasPrefix(pkg, "cmd/") && strings.Count(pkg, "/") == 1 {
+		pkgName = "main"
+	}
+	b := pathf("%s/_go_.a", workdir)
+	clean = append(clean, b)
+	if !ispackcmd {
+		link = append(link, b)
+	} else {
+		archive = b
+	}
+
+	// Compile Go code.
+	compile := []string{pathf("%s/compile", tooldir), "-std", "-pack", "-o", b, "-p", pkgName, "-importcfg", importcfg}
+	if gogcflags != "" {
+		compile = append(compile, strings.Fields(gogcflags)...)
+	}
+	if len(sfiles) > 0 {
+		compile = append(compile, "-asmhdr", goasmh)
+	}
+	if symabis != "" {
+		compile = append(compile, "-symabis", symabis)
+	}
+	if goos == "android" {
+		compile = append(compile, "-shared")
+	}
+
+	compile = append(compile, gofiles...)
+	var wg sync.WaitGroup
+	// We use bgrun and immediately wait for it instead of calling run() synchronously.
+	// This executes all jobs through the bgwork channel and allows the process
+	// to exit cleanly in case an error occurs.
+	bgrun(&wg, dir, compile...)
+	bgwait(&wg)
+
+	// Compile the files.
+	for _, p := range sfiles {
+		// Assembly file for a Go package.
+		compile := asmArgs[:len(asmArgs):len(asmArgs)]
+
+		doclean := true
+		b := pathf("%s/%s", workdir, filepath.Base(p))
+
+		// Change the last character of the output file (which was c or s).
+		b = b[:len(b)-1] + "o"
+		compile = append(compile, "-o", b, p)
+		bgrun(&wg, dir, compile...)
+
+		link = append(link, b)
+		if doclean {
+			clean = append(clean, b)
+		}
+	}
+	bgwait(&wg)
+
+	if ispackcmd {
+		xremove(link[targ])
+		dopack(link[targ], archive, link[targ+1:])
+		return
+	}
+
+	// Remove target before writing it.
+	xremove(link[targ])
+	bgrun(&wg, "", link...)
+	bgwait(&wg)
+}
+
+// packagefile returns the path to a compiled .a file for the given package
+// path. Paths may need to be resolved with resolveVendor first.
+func packagefile(pkg string) string {
+	return pathf("%s/pkg/obj/go-bootstrap/%s_%s/%s.a", goroot, goos, goarch, pkg)
+}
+
+// unixOS is the set of GOOS values matched by the "unix" build tag.
+// This is the same list as in internal/syslist/syslist.go.
+var unixOS = map[string]bool{
+	"aix":       true,
+	"android":   true,
+	"darwin":    true,
+	"dragonfly": true,
+	"freebsd":   true,
+	"hurd":      true,
+	"illumos":   true,
+	"ios":       true,
+	"linux":     true,
+	"netbsd":    true,
+	"openbsd":   true,
+	"solaris":   true,
+}
+
+// matchtag reports whether the tag matches this build.
+func matchtag(tag string) bool {
+	switch tag {
+	case "gc", "cmd_go_bootstrap", "go1.1":
+		return true
+	case "linux":
+		return goos == "linux" || goos == "android"
+	case "solaris":
+		return goos == "solaris" || goos == "illumos"
+	case "darwin":
+		return goos == "darwin" || goos == "ios"
+	case goos, goarch:
+		return true
+	case "unix":
+		return unixOS[goos]
+	default:
+		return false
+	}
+}
+
+// shouldbuild reports whether we should build this file.
+// It applies the same rules that are used with context tags
+// in package go/build, except it's less picky about the order
+// of GOOS and GOARCH.
+// We also allow the special tag cmd_go_bootstrap.
+// See ../go/bootstrap.go and package go/build.
+func shouldbuild(file, pkg string) bool {
+	// Check file name for GOOS or GOARCH.
+	name := filepath.Base(file)
+	excluded := func(list []string, ok string) bool {
+		for _, x := range list {
+			if x == ok || (ok == "android" && x == "linux") || (ok == "illumos" && x == "solaris") || (ok == "ios" && x == "darwin") {
+				continue
+			}
+			i := strings.Index(name, x)
+			if i <= 0 || name[i-1] != '_' {
+				continue
+			}
+			i += len(x)
+			if i == len(name) || name[i] == '.' || name[i] == '_' {
+				return true
+			}
+		}
+		return false
+	}
+	if excluded(okgoos, goos) || excluded(okgoarch, goarch) {
+		return false
+	}
+
+	// Omit test files.
+	if strings.Contains(name, "_test") {
+		return false
+	}
+
+	// Check file contents for //go:build lines.
+	for p := range strings.SplitSeq(readfile(file), "\n") {
+		p = strings.TrimSpace(p)
+		if p == "" {
+			continue
+		}
+		code := p
+		i := strings.Index(code, "//")
+		if i > 0 {
+			code = strings.TrimSpace(code[:i])
+		}
+		if code == "package documentation" {
+			return false
+		}
+		if code == "package main" && pkg != "cmd/go" && pkg != "cmd/cgo" {
+			return false
+		}
+		if !strings.HasPrefix(p, "//") {
+			break
+		}
+		if strings.HasPrefix(p, "//go:build ") {
+			matched, err := matchexpr(p[len("//go:build "):])
+			if err != nil {
+				errprintf("%s: %v", file, err)
+			}
+			return matched
+		}
+	}
+
+	return true
+}
+
+// copyfile copies the file src to dst, via memory (so only good for small files).
+func copyfile(dst, src string, flag int) {
+	if vflag > 1 {
+		errprintf("cp %s %s\n", src, dst)
+	}
+	writefile(readfile(src), dst, flag)
+}
+
+// dopack copies the package src to dst,
+// appending the files listed in extra.
+// The archive format is the traditional Unix ar format.
+func dopack(dst, src string, extra []string) {
+	bdst := bytes.NewBufferString(readfile(src))
+	for _, file := range extra {
+		b := readfile(file)
+		// find last path element for archive member name
+		i := strings.LastIndex(file, "/") + 1
+		j := strings.LastIndex(file, `\`) + 1
+		if i < j {
+			i = j
+		}
+		fmt.Fprintf(bdst, "%-16.16s%-12d%-6d%-6d%-8o%-10d`\n", file[i:], 0, 0, 0, 0644, len(b))
+		bdst.WriteString(b)
+		if len(b)&1 != 0 {
+			bdst.WriteByte(0)
+		}
+	}
+	writefile(bdst.String(), dst, 0)
+}
+
+func clean() {
+	generated := []byte(generatedHeader)
+
+	// Remove generated source files.
+	filepath.WalkDir(pathf("%s/src", goroot), func(path string, d fs.DirEntry, err error) error {
+		switch {
+		case err != nil:
+			// ignore
+		case d.IsDir() && (d.Name() == "vendor" || d.Name() == "testdata"):
+			return filepath.SkipDir
+		case d.IsDir() && d.Name() != "dist":
+			// Remove generated binary named for directory, but not dist out from under us.
+			exe := filepath.Join(path, d.Name())
+			if info, err := os.Stat(exe); err == nil && !info.IsDir() {
+				xremove(exe)
+			}
+			xremove(exe + ".exe")
+		case !d.IsDir() && strings.HasPrefix(d.Name(), "z"):
+			// Remove generated file, identified by marker string.
+			head := make([]byte, 512)
+			if f, err := os.Open(path); err == nil {
+				io.ReadFull(f, head)
+				f.Close()
+			}
+			if bytes.HasPrefix(head, generated) {
+				xremove(path)
+			}
+		}
+		return nil
+	})
+
+	if rebuildall {
+		// Remove object tree.
+		xremoveall(pathf("%s/pkg/obj/%s_%s", goroot, gohostos, gohostarch))
+
+		// Remove installed packages and tools.
+		xremoveall(pathf("%s/pkg/%s_%s", goroot, gohostos, gohostarch))
+		xremoveall(pathf("%s/pkg/%s_%s", goroot, goos, goarch))
+		xremoveall(pathf("%s/pkg/%s_%s_race", goroot, gohostos, gohostarch))
+		xremoveall(pathf("%s/pkg/%s_%s_race", goroot, goos, goarch))
+		xremoveall(tooldir)
+
+		// Remove cached version info.
+		xremove(pathf("%s/VERSION.cache", goroot))
+
+		// Remove distribution packages.
+		xremoveall(pathf("%s/pkg/distpack", goroot))
+	}
+}
+
+/*
+ * command implementations
+ */
+
+// The env command prints the default environment.
+func cmdenv() {
+	path := flag.Bool("p", false, "emit updated PATH")
+	plan9 := flag.Bool("9", gohostos == "plan9", "emit plan 9 syntax")
+	windows := flag.Bool("w", gohostos == "windows", "emit windows syntax")
+	xflagparse(0)
+
+	format := "%s=\"%s\";\n" // Include ; to separate variables when 'dist env' output is used with eval.
+	switch {
+	case *plan9:
+		format = "%s='%s'\n"
+	case *windows:
+		format = "set %s=%s\r\n"
+	}
+
+	xprintf(format, "GO111MODULE", "")
+	xprintf(format, "GOARCH", goarch)
+	xprintf(format, "GOBIN", gorootBin)
+	xprintf(format, "GODEBUG", os.Getenv("GODEBUG"))
+	xprintf(format, "GOENV", "off")
+	xprintf(format, "GOFLAGS", "")
+	xprintf(format, "GOHOSTARCH", gohostarch)
+	xprintf(format, "GOHOSTOS", gohostos)
+	xprintf(format, "GOOS", goos)
+	xprintf(format, "GOPROXY", os.Getenv("GOPROXY"))
+	xprintf(format, "GOROOT", goroot)
+	xprintf(format, "GOTMPDIR", os.Getenv("GOTMPDIR"))
+	xprintf(format, "GOTOOLDIR", tooldir)
+	if goarch == "arm" {
+		xprintf(format, "GOARM", goarm)
+	}
+	if goarch == "arm64" {
+		xprintf(format, "GOARM64", goarm64)
+	}
+	if goarch == "386" {
+		xprintf(format, "GO386", go386)
+	}
+	if goarch == "amd64" {
+		xprintf(format, "GOAMD64", goamd64)
+	}
+	if goarch == "mips" || goarch == "mipsle" {
+		xprintf(format, "GOMIPS", gomips)
+	}
+	if goarch == "mips64" || goarch == "mips64le" {
+		xprintf(format, "GOMIPS64", gomips64)
+	}
+	if goarch == "ppc64" || goarch == "ppc64le" {
+		xprintf(format, "GOPPC64", goppc64)
+	}
+	if goarch == "riscv64" {
+		xprintf(format, "GORISCV64", goriscv64)
+	}
+	xprintf(format, "GOWORK", "off")
+
+	if *path {
+		sep := ":"
+		if gohostos == "windows" {
+			sep = ";"
+		}
+		xprintf(format, "PATH", fmt.Sprintf("%s%s%s", gorootBin, sep, os.Getenv("PATH")))
+
+		// Also include $DIST_UNMODIFIED_PATH with the original $PATH
+		// for the internal needs of "dist banner", along with export
+		// so that it reaches the dist process. See its comment below.
+		var exportFormat string
+		if !*windows && !*plan9 {
+			exportFormat = "export " + format
+		} else {
+			exportFormat = format
+		}
+		xprintf(exportFormat, "DIST_UNMODIFIED_PATH", os.Getenv("PATH"))
+	}
+}
+
+var (
+	timeLogEnabled = os.Getenv("GOBUILDTIMELOGFILE") != ""
+	timeLogMu      sync.Mutex
+	timeLogFile    *os.File
+	timeLogStart   time.Time
+)
+
+func timelog(op, name string) {
+	if !timeLogEnabled {
+		return
+	}
+	timeLogMu.Lock()
+	defer timeLogMu.Unlock()
+	if timeLogFile == nil {
+		f, err := os.OpenFile(os.Getenv("GOBUILDTIMELOGFILE"), os.O_RDWR|os.O_APPEND, 0666)
+		if err != nil {
+			log.Fatal(err)
+		}
+		buf := make([]byte, 100)
+		n, _ := f.Read(buf)
+		s := string(buf[:n])
+		if i := strings.Index(s, "\n"); i >= 0 {
+			s = s[:i]
+		}
+		i := strings.Index(s, " start")
+		if i < 0 {
+			log.Fatalf("time log %s does not begin with start line", os.Getenv("GOBUILDTIMELOGFILE"))
+		}
+		t, err := time.Parse(time.UnixDate, s[:i])
+		if err != nil {
+			log.Fatalf("cannot parse time log line %q: %v", s, err)
+		}
+		timeLogStart = t
+		timeLogFile = f
+	}
+	t := time.Now()
+	fmt.Fprintf(timeLogFile, "%s %+.1fs %s %s\n", t.Format(time.UnixDate), t.Sub(timeLogStart).Seconds(), op, name)
+}
+
+// toolenv returns the environment to use when building commands in cmd.
+//
+// This is a function instead of a variable because the exact toolenv depends
+// on the GOOS and GOARCH, and (at least for now) those are modified in place
+// to switch between the host and target configurations when cross-compiling.
+func toolenv() []string {
+	var env []string
+	if !mustLinkExternal(goos, goarch, false) {
+		// Unless the platform requires external linking,
+		// we disable cgo to get static binaries for cmd/go and cmd/pprof,
+		// so that they work on systems without the same dynamic libraries
+		// as the original build system.
+		env = append(env, "CGO_ENABLED=0")
+	}
+	if isRelease || os.Getenv("GO_BUILDER_NAME") != "" {
+		// Add -trimpath for reproducible builds of releases.
+		// Include builders so that -trimpath is well-tested ahead of releases.
+		// Do not include local development, so that people working in the
+		// main branch for day-to-day work on the Go toolchain itself can
+		// still have full paths for stack traces for compiler crashes and the like.
+		env = append(env, "GOFLAGS=-trimpath -ldflags=-w -gcflags=cmd/...=-dwarf=false")
+	}
+	return env
+}
+
+var (
+	toolchain = []string{"cmd/asm", "cmd/cgo", "cmd/compile", "cmd/link", "cmd/preprofile"}
+
+	// Keep in sync with binExes in cmd/distpack/pack.go.
+	binExesIncludedInDistpack = []string{"cmd/go", "cmd/gofmt"}
+
+	// Keep in sync with the filter in cmd/distpack/pack.go.
+	toolsIncludedInDistpack = []string{"cmd/asm", "cmd/cgo", "cmd/compile", "cmd/cover", "cmd/fix", "cmd/link", "cmd/preprofile", "cmd/vet"}
+
+	// We could install all tools in "cmd", but is unnecessary because we will
+	// remove them in distpack, so instead install the tools that will actually
+	// be included in distpack, which is a superset of toolchain. Not installing
+	// the tools will help us test what happens when the tools aren't present.
+	toolsToInstall = slices.Concat(binExesIncludedInDistpack, toolsIncludedInDistpack)
+)
+
+// The bootstrap command runs a build from scratch,
+// stopping at having installed the go_bootstrap command.
+//
+// WARNING: This command runs after cmd/dist is built with the Go bootstrap toolchain.
+// It rebuilds and installs cmd/dist with the new toolchain, so other
+// commands (like "go tool dist test" in run.bash) can rely on bug fixes
+// made since the Go bootstrap version, but this function cannot.
+func cmdbootstrap() {
+	timelog("start", "dist bootstrap")
+	defer timelog("end", "dist bootstrap")
+
+	var debug, distpack, force, noBanner, noClean bool
+	flag.BoolVar(&rebuildall, "a", rebuildall, "rebuild all")
+	flag.BoolVar(&debug, "d", debug, "enable debugging of bootstrap process")
+	flag.BoolVar(&distpack, "distpack", distpack, "write distribution files to pkg/distpack")
+	flag.BoolVar(&force, "force", force, "build even if the port is marked as broken")
+	flag.BoolVar(&noBanner, "no-banner", noBanner, "do not print banner")
+	flag.BoolVar(&noClean, "no-clean", noClean, "print deprecation warning")
+
+	xflagparse(0)
+
+	if noClean {
+		xprintf("warning: --no-clean is deprecated and has no effect; use 'go install std cmd' instead\n")
+	}
+
+	// Don't build broken ports by default.
+	if broken[goos+"/"+goarch] && !force {
+		fatalf("build stopped because the port %s/%s is marked as broken\n\n"+
+			"Use the -force flag to build anyway.\n", goos, goarch)
+	}
+
+	// Set GOPATH to an internal directory. We shouldn't actually
+	// need to store files here, since the toolchain won't
+	// depend on modules outside of vendor directories, but if
+	// GOPATH points somewhere else (e.g., to GOROOT), the
+	// go tool may complain.
+	os.Setenv("GOPATH", pathf("%s/pkg/obj/gopath", goroot))
+
+	// Set GOPROXY=off to avoid downloading modules to the modcache in
+	// the GOPATH set above to be inside GOROOT. The modcache is read
+	// only so if we downloaded to the modcache, we'd create readonly
+	// files in GOROOT, which is undesirable. See #67463)
+	os.Setenv("GOPROXY", "off")
+
+	// Use a build cache separate from the default user one.
+	// Also one that will be wiped out during startup, so that
+	// make.bash really does start from a clean slate.
+	oldgocache = os.Getenv("GOCACHE")
+	os.Setenv("GOCACHE", pathf("%s/pkg/obj/go-build", goroot))
+
+	// Disable GOEXPERIMENT when building toolchain1 and
+	// go_bootstrap. We don't need any experiments for the
+	// bootstrap toolchain, and this lets us avoid duplicating the
+	// GOEXPERIMENT-related build logic from cmd/go here. If the
+	// bootstrap toolchain is < Go 1.17, it will ignore this
+	// anyway since GOEXPERIMENT is baked in; otherwise it will
+	// pick it up from the environment we set here. Once we're
+	// using toolchain1 with dist as the build system, we need to
+	// override this to keep the experiments assumed by the
+	// toolchain and by dist consistent. Once go_bootstrap takes
+	// over the build process, we'll set this back to the original
+	// GOEXPERIMENT.
+	os.Setenv("GOEXPERIMENT", "none")
+
+	if isdir(pathf("%s/src/pkg", goroot)) {
+		fatalf("\n\n"+
+			"The Go package sources have moved to $GOROOT/src.\n"+
+			"*** %s still exists. ***\n"+
+			"It probably contains stale files that may confuse the build.\n"+
+			"Please (check what's there and) remove it and try again.\n"+
+			"See https://golang.org/s/go14nopkg\n",
+			pathf("%s/src/pkg", goroot))
+	}
+
+	if rebuildall {
+		clean()
+	}
+
+	setup()
+
+	timelog("build", "toolchain1")
+	checkCC()
+	bootstrapBuildTools()
+
+	// Remember old content of $GOROOT/bin for comparison below.
+	oldBinFiles, err := filepath.Glob(pathf("%s/bin/*", goroot))
+	if err != nil {
+		fatalf("glob: %v", err)
+	}
+
+	// For the main bootstrap, building for host os/arch.
+	oldgoos = goos
+	oldgoarch = goarch
+	goos = gohostos
+	goarch = gohostarch
+	os.Setenv("GOHOSTARCH", gohostarch)
+	os.Setenv("GOHOSTOS", gohostos)
+	os.Setenv("GOARCH", goarch)
+	os.Setenv("GOOS", goos)
+
+	timelog("build", "go_bootstrap")
+	xprintf("Building Go bootstrap cmd/go (go_bootstrap) using Go toolchain1.\n")
+	install("runtime")     // dependency not visible in sources; also sets up textflag.h
+	install("time/tzdata") // no dependency in sources; creates generated file
+	install("cmd/go")
+	if vflag > 0 {
+		xprintf("\n")
+	}
+
+	gogcflags = os.Getenv("GO_GCFLAGS") // we were using $BOOT_GO_GCFLAGS until now
+	setNoOpt()
+	goldflags = os.Getenv("GO_LDFLAGS") // we were using $BOOT_GO_LDFLAGS until now
+	goBootstrap := pathf("%s/go_bootstrap", tooldir)
+	if debug {
+		run("", ShowOutput|CheckExit, pathf("%s/compile", tooldir), "-V=full")
+		copyfile(pathf("%s/compile1", tooldir), pathf("%s/compile", tooldir), writeExec)
+	}
+
+	// To recap, so far we have built the new toolchain
+	// (cmd/asm, cmd/cgo, cmd/compile, cmd/link, cmd/preprofile)
+	// using the Go bootstrap toolchain and go command.
+	// Then we built the new go command (as go_bootstrap)
+	// using the new toolchain and our own build logic (above).
+	//
+	//	toolchain1 = mk(new toolchain, go1.17 toolchain, go1.17 cmd/go)
+	//	go_bootstrap = mk(new cmd/go, toolchain1, cmd/dist)
+	//
+	// The toolchain1 we built earlier is built from the new sources,
+	// but because it was built using cmd/go it has no build IDs.
+	// The eventually installed toolchain needs build IDs, so we need
+	// to do another round:
+	//
+	//	toolchain2 = mk(new toolchain, toolchain1, go_bootstrap)
+	//
+	timelog("build", "toolchain2")
+	if vflag > 0 {
+		xprintf("\n")
+	}
+	xprintf("Building Go toolchain2 using go_bootstrap and Go toolchain1.\n")
+	os.Setenv("CC", compilerEnvLookup("CC", defaultcc, goos, goarch))
+	// Now that cmd/go is in charge of the build process, enable GOEXPERIMENT.
+	os.Setenv("GOEXPERIMENT", goexperiment)
+	// No need to enable PGO for toolchain2.
+	goInstall(toolenv(), goBootstrap, append([]string{"-pgo=off"}, toolchain...)...)
+	if debug {
+		run("", ShowOutput|CheckExit, pathf("%s/compile", tooldir), "-V=full")
+		copyfile(pathf("%s/compile2", tooldir), pathf("%s/compile", tooldir), writeExec)
+	}
+
+	// Toolchain2 should be semantically equivalent to toolchain1,
+	// but it was built using the newly built compiler instead of the Go bootstrap compiler,
+	// so it should at the least run faster. Also, toolchain1 had no build IDs
+	// in the binaries, while toolchain2 does. In non-release builds, the
+	// toolchain's build IDs feed into constructing the build IDs of built targets,
+	// so in non-release builds, everything now looks out-of-date due to
+	// toolchain2 having build IDs - that is, due to the go command seeing
+	// that there are new compilers. In release builds, the toolchain's reported
+	// version is used in place of the build ID, and the go command does not
+	// see that change from toolchain1 to toolchain2, so in release builds,
+	// nothing looks out of date.
+	// To keep the behavior the same in both non-release and release builds,
+	// we force-install everything here.
+	//
+	//	toolchain3 = mk(new toolchain, toolchain2, go_bootstrap)
+	//
+	timelog("build", "toolchain3")
+	if vflag > 0 {
+		xprintf("\n")
+	}
+	xprintf("Building Go toolchain3 using go_bootstrap and Go toolchain2.\n")
+	goInstall(toolenv(), goBootstrap, append([]string{"-a"}, toolchain...)...)
+	if debug {
+		run("", ShowOutput|CheckExit, pathf("%s/compile", tooldir), "-V=full")
+		copyfile(pathf("%s/compile3", tooldir), pathf("%s/compile", tooldir), writeExec)
+	}
+
+	// Now that toolchain3 has been built from scratch, its compiler and linker
+	// should have accurate build IDs suitable for caching.
+	// Now prime the build cache with the rest of the standard library for
+	// testing, and so that the user can run 'go install std cmd' to quickly
+	// iterate on local changes without waiting for a full rebuild.
+	if _, err := os.Stat(pathf("%s/VERSION", goroot)); err == nil {
+		// If we have a VERSION file, then we use the Go version
+		// instead of build IDs as a cache key, and there is no guarantee
+		// that code hasn't changed since the last time we ran a build
+		// with this exact VERSION file (especially if someone is working
+		// on a release branch). We must not fall back to the shared build cache
+		// in this case. Leave $GOCACHE alone.
+	} else {
+		os.Setenv("GOCACHE", oldgocache)
+	}
+
+	if goos == oldgoos && goarch == oldgoarch {
+		// Common case - not setting up for cross-compilation.
+		timelog("build", "toolchain")
+		if vflag > 0 {
+			xprintf("\n")
+		}
+		xprintf("Building packages and commands for %s/%s.\n", goos, goarch)
+	} else {
+		// GOOS/GOARCH does not match GOHOSTOS/GOHOSTARCH.
+		// Finish GOHOSTOS/GOHOSTARCH installation and then
+		// run GOOS/GOARCH installation.
+		timelog("build", "host toolchain")
+		if vflag > 0 {
+			xprintf("\n")
+		}
+		xprintf("Building commands for host, %s/%s.\n", goos, goarch)
+		goInstall(toolenv(), goBootstrap, toolsToInstall...)
+		checkNotStale(toolenv(), goBootstrap, toolsToInstall...)
+		checkNotStale(toolenv(), gorootBinGo, toolsToInstall...)
+
+		timelog("build", "target toolchain")
+		if vflag > 0 {
+			xprintf("\n")
+		}
+		goos = oldgoos
+		goarch = oldgoarch
+		os.Setenv("GOOS", goos)
+		os.Setenv("GOARCH", goarch)
+		os.Setenv("CC", compilerEnvLookup("CC", defaultcc, goos, goarch))
+		xprintf("Building packages and commands for target, %s/%s.\n", goos, goarch)
+	}
+	goInstall(nil, goBootstrap, "std")
+	goInstall(toolenv(), goBootstrap, toolsToInstall...)
+	checkNotStale(toolenv(), goBootstrap, toolchain...)
+	checkNotStale(nil, goBootstrap, "std")
+	checkNotStale(toolenv(), goBootstrap, toolsToInstall...)
+	checkNotStale(nil, gorootBinGo, "std")
+	checkNotStale(toolenv(), gorootBinGo, toolsToInstall...)
+	if debug {
+		run("", ShowOutput|CheckExit, pathf("%s/compile", tooldir), "-V=full")
+		checkNotStale(toolenv(), goBootstrap, toolchain...)
+		copyfile(pathf("%s/compile4", tooldir), pathf("%s/compile", tooldir), writeExec)
+	}
+
+	// Check that there are no new files in $GOROOT/bin other than
+	// go and gofmt and $GOOS_$GOARCH (target bin when cross-compiling).
+	binFiles, err := filepath.Glob(pathf("%s/bin/*", goroot))
+	if err != nil {
+		fatalf("glob: %v", err)
+	}
+
+	ok := map[string]bool{}
+	for _, f := range oldBinFiles {
+		ok[f] = true
+	}
+	for _, f := range binFiles {
+		if gohostos == "darwin" && filepath.Base(f) == ".DS_Store" {
+			continue // unfortunate but not unexpected
+		}
+		elem := strings.TrimSuffix(filepath.Base(f), ".exe")
+		if !ok[f] && elem != "go" && elem != "gofmt" && elem != goos+"_"+goarch {
+			fatalf("unexpected new file in $GOROOT/bin: %s", elem)
+		}
+	}
+
+	// Remove go_bootstrap now that we're done.
+	xremove(pathf("%s/go_bootstrap"+exe, tooldir))
+
+	if goos == "android" {
+		// Make sure the exec wrapper will sync a fresh $GOROOT to the device.
+		xremove(pathf("%s/go_android_exec-adb-sync-status", os.TempDir()))
+	}
+
+	if wrapperPath := wrapperPathFor(goos, goarch); wrapperPath != "" {
+		oldcc := os.Getenv("CC")
+		os.Setenv("GOOS", gohostos)
+		os.Setenv("GOARCH", gohostarch)
+		os.Setenv("CC", compilerEnvLookup("CC", defaultcc, gohostos, gohostarch))
+		goCmd(nil, gorootBinGo, "build", "-o", pathf("%s/go_%s_%s_exec%s", gorootBin, goos, goarch, exe), wrapperPath)
+		// Restore environment.
+		// TODO(elias.naur): support environment variables in goCmd?
+		os.Setenv("GOOS", goos)
+		os.Setenv("GOARCH", goarch)
+		os.Setenv("CC", oldcc)
+	}
+
+	if distpack {
+		xprintf("Packaging archives for %s/%s.\n", goos, goarch)
+		run("", ShowOutput|CheckExit, gorootBinGo, "tool", "distpack")
+	}
+
+	// Print trailing banner unless instructed otherwise.
+	if !noBanner {
+		banner()
+	}
+}
+
+func wrapperPathFor(goos, goarch string) string {
+	switch {
+	case goos == "android":
+		if gohostos != "android" {
+			return pathf("%s/misc/go_android_exec/main.go", goroot)
+		}
+	case goos == "ios":
+		if gohostos != "ios" {
+			return pathf("%s/misc/ios/go_ios_exec.go", goroot)
+		}
+	}
+	return ""
+}
+
+func goInstall(env []string, goBinary string, args ...string) {
+	goCmd(env, goBinary, "install", args...)
+}
+
+func appendCompilerFlags(args []string) []string {
+	if gogcflags != "" {
+		args = append(args, "-gcflags=all="+gogcflags)
+	}
+	if goldflags != "" {
+		args = append(args, "-ldflags=all="+goldflags)
+	}
+	return args
+}
+
+func goCmd(env []string, goBinary string, cmd string, args ...string) {
+	goCmd := []string{goBinary, cmd}
+	if noOpt {
+		goCmd = append(goCmd, "-tags=noopt")
+	}
+	goCmd = appendCompilerFlags(goCmd)
+	if vflag > 0 {
+		goCmd = append(goCmd, "-v")
+	}
+
+	// Force only one process at a time on vx32 emulation.
+	if gohostos == "plan9" && os.Getenv("sysname") == "vx32" {
+		goCmd = append(goCmd, "-p=1")
+	}
+
+	runEnv(workdir, ShowOutput|CheckExit, env, append(goCmd, args...)...)
+}
+
+func checkNotStale(env []string, goBinary string, targets ...string) {
+	goCmd := []string{goBinary, "list"}
+	if noOpt {
+		goCmd = append(goCmd, "-tags=noopt")
+	}
+	goCmd = appendCompilerFlags(goCmd)
+	goCmd = append(goCmd, "-f={{if .Stale}}\tSTALE {{.ImportPath}}: {{.StaleReason}}{{end}}")
+
+	out := runEnv(workdir, CheckExit, env, append(goCmd, targets...)...)
+	if strings.Contains(out, "\tSTALE ") {
+		os.Setenv("GODEBUG", "gocachehash=1")
+		for _, target := range []string{"internal/runtime/sys", "cmd/dist", "cmd/link"} {
+			if strings.Contains(out, "STALE "+target) {
+				run(workdir, ShowOutput|CheckExit, goBinary, "list", "-f={{.ImportPath}} {{.Stale}}", target)
+				break
+			}
+		}
+		fatalf("unexpected stale targets reported by %s list -gcflags=\"%s\" -ldflags=\"%s\" for %v (consider rerunning with GOMAXPROCS=1 GODEBUG=gocachehash=1):\n%s", goBinary, gogcflags, goldflags, targets, out)
+	}
+}
+
+// Cannot use go/build directly because cmd/dist for a new release
+// builds against an old release's go/build, which may be out of sync.
+// To reduce duplication, we generate the list for go/build from this.
+//
+// We list all supported platforms in this list, so that this is the
+// single point of truth for supported platforms. This list is used
+// by 'go tool dist list'.
+var cgoEnabled = map[string]bool{
+	"aix/ppc64":       true,
+	"darwin/amd64":    true,
+	"darwin/arm64":    true,
+	"dragonfly/amd64": true,
+	"freebsd/386":     true,
+	"freebsd/amd64":   true,
+	"freebsd/arm":     true,
+	"freebsd/arm64":   true,
+	"freebsd/riscv64": true,
+	"illumos/amd64":   true,
+	"linux/386":       true,
+	"linux/amd64":     true,
+	"linux/arm":       true,
+	"linux/arm64":     true,
+	"linux/loong64":   true,
+	"linux/ppc64":     false,
+	"linux/ppc64le":   true,
+	"linux/mips":      true,
+	"linux/mipsle":    true,
+	"linux/mips64":    true,
+	"linux/mips64le":  true,
+	"linux/riscv64":   true,
+	"linux/s390x":     true,
+	"linux/sparc64":   true,
+	"android/386":     true,
+	"android/amd64":   true,
+	"android/arm":     true,
+	"android/arm64":   true,
+	"ios/arm64":       true,
+	"ios/amd64":       true,
+	"js/wasm":         false,
+	"wasip1/wasm":     false,
+	"netbsd/386":      true,
+	"netbsd/amd64":    true,
+	"netbsd/arm":      true,
+	"netbsd/arm64":    true,
+	"openbsd/386":     true,
+	"openbsd/amd64":   true,
+	"openbsd/arm":     true,
+	"openbsd/arm64":   true,
+	"openbsd/mips64":  true,
+	"openbsd/ppc64":   false,
+	"openbsd/riscv64": true,
+	"plan9/386":       false,
+	"plan9/amd64":     false,
+	"plan9/arm":       false,
+	"solaris/amd64":   true,
+	"windows/386":     true,
+	"windows/amd64":   true,
+	"windows/arm64":   true,
+}
+
+// List of platforms that are marked as broken ports.
+// These require -force flag to build, and also
+// get filtered out of cgoEnabled for 'dist list'.
+// See go.dev/issue/56679.
+var broken = map[string]bool{
+	"freebsd/riscv64": true, // Broken: go.dev/issue/76475.
+	"linux/sparc64":   true, // An incomplete port. See CL 132155.
+	"openbsd/mips64":  true, // Broken: go.dev/issue/58110.
+}
+
+// List of platforms which are first class ports. See go.dev/issue/38874.
+var firstClass = map[string]bool{
+	"darwin/amd64":  true,
+	"darwin/arm64":  true,
+	"linux/386":     true,
+	"linux/amd64":   true,
+	"linux/arm":     true,
+	"linux/arm64":   true,
+	"windows/386":   true,
+	"windows/amd64": true,
+}
+
+// We only need CC if cgo is forced on, or if the platform requires external linking.
+// Otherwise the go command will automatically disable it.
+func needCC() bool {
+	return os.Getenv("CGO_ENABLED") == "1" || mustLinkExternal(gohostos, gohostarch, false)
+}
+
+func checkCC() {
+	if !needCC() {
+		return
+	}
+	cc1 := defaultcc[""]
+	if cc1 == "" {
+		cc1 = "gcc"
+		for _, os := range clangos {
+			if gohostos == os {
+				cc1 = "clang"
+				break
+			}
+		}
+	}
+	cc, err := quotedSplit(cc1)
+	if err != nil {
+		fatalf("split CC: %v", err)
+	}
+	var ccHelp = append(cc, "--help")
+
+	if output, err := exec.Command(ccHelp[0], ccHelp[1:]...).CombinedOutput(); err != nil {
+		outputHdr := ""
+		if len(output) > 0 {
+			outputHdr = "\nCommand output:\n\n"
+		}
+		fatalf("cannot invoke C compiler %q: %v\n\n"+
+			"Go needs a system C compiler for use with cgo.\n"+
+			"To set a C compiler, set CC=the-compiler.\n"+
+			"To disable cgo, set CGO_ENABLED=0.\n%s%s", cc, err, outputHdr, output)
+	}
+}
+
+func defaulttarg() string {
+	// xgetwd might return a path with symlinks fully resolved, and if
+	// there happens to be symlinks in goroot, then the hasprefix test
+	// will never succeed. Instead, we use xrealwd to get a canonical
+	// goroot/src before the comparison to avoid this problem.
+	pwd := xgetwd()
+	src := pathf("%s/src/", goroot)
+	real_src := xrealwd(src)
+	if !strings.HasPrefix(pwd, real_src) {
+		fatalf("current directory %s is not under %s", pwd, real_src)
+	}
+	pwd = pwd[len(real_src):]
+	// guard against xrealwd returning the directory without the trailing /
+	pwd = strings.TrimPrefix(pwd, "/")
+
+	return pwd
+}
+
+// Install installs the list of packages named on the command line.
+func cmdinstall() {
+	xflagparse(-1)
+
+	if flag.NArg() == 0 {
+		install(defaulttarg())
+	}
+
+	for _, arg := range flag.Args() {
+		install(arg)
+	}
+}
+
+// Clean deletes temporary objects.
+func cmdclean() {
+	xflagparse(0)
+	clean()
+}
+
+// Banner prints the 'now you've installed Go' banner.
+func cmdbanner() {
+	xflagparse(0)
+	banner()
+}
+
+func banner() {
+	if vflag > 0 {
+		xprintf("\n")
+	}
+	xprintf("---\n")
+	xprintf("Installed Go for %s/%s in %s\n", goos, goarch, goroot)
+	xprintf("Installed commands in %s\n", gorootBin)
+
+	if gohostos == "plan9" {
+		// Check that GOROOT/bin is bound before /bin.
+		pid := strings.ReplaceAll(readfile("#c/pid"), " ", "")
+		ns := fmt.Sprintf("/proc/%s/ns", pid)
+		if !strings.Contains(readfile(ns), fmt.Sprintf("bind -b %s /bin", gorootBin)) {
+			xprintf("*** You need to bind %s before /bin.\n", gorootBin)
+		}
+	} else {
+		// Check that GOROOT/bin appears in $PATH.
+		pathsep := ":"
+		if gohostos == "windows" {
+			pathsep = ";"
+		}
+		path := os.Getenv("PATH")
+		if p, ok := os.LookupEnv("DIST_UNMODIFIED_PATH"); ok {
+			// Scripts that modify $PATH and then run dist should also provide
+			// dist with an unmodified copy of $PATH via $DIST_UNMODIFIED_PATH.
+			// Use it here when determining if the user still needs to update
+			// their $PATH. See go.dev/issue/42563.
+			path = p
+		}
+		if !strings.Contains(pathsep+path+pathsep, pathsep+gorootBin+pathsep) {
+			xprintf("*** You need to add %s to your PATH.\n", gorootBin)
+		}
+	}
+}
+
+// Version prints the Go version.
+func cmdversion() {
+	xflagparse(0)
+	xprintf("%s\n", findgoversion())
+}
+
+// cmdlist lists all supported platforms.
+func cmdlist() {
+	jsonFlag := flag.Bool("json", false, "produce JSON output")
+	brokenFlag := flag.Bool("broken", false, "include broken ports")
+	xflagparse(0)
+
+	var plats []string
+	for p := range cgoEnabled {
+		if broken[p] && !*brokenFlag {
+			continue
+		}
+		plats = append(plats, p)
+	}
+	sort.Strings(plats)
+
+	if !*jsonFlag {
+		for _, p := range plats {
+			xprintf("%s\n", p)
+		}
+		return
+	}
+
+	type jsonResult struct {
+		GOOS         string
+		GOARCH       string
+		CgoSupported bool
+		FirstClass   bool
+		Broken       bool `json:",omitempty"`
+	}
+	var results []jsonResult
+	for _, p := range plats {
+		fields := strings.Split(p, "/")
+		results = append(results, jsonResult{
+			GOOS:         fields[0],
+			GOARCH:       fields[1],
+			CgoSupported: cgoEnabled[p],
+			FirstClass:   firstClass[p],
+			Broken:       broken[p],
+		})
+	}
+	out, err := json.MarshalIndent(results, "", "\t")
+	if err != nil {
+		fatalf("json marshal error: %v", err)
+	}
+	if _, err := os.Stdout.Write(out); err != nil {
+		fatalf("write failed: %v", err)
+	}
+}
+
+func setNoOpt() {
+	for gcflag := range strings.SplitSeq(gogcflags, " ") {
+		if gcflag == "-N" || gcflag == "-l" {
+			noOpt = true
+			break
+		}
+	}
+}

go/src/cmd/dist/build_test.go

@@ -0,0 +1,43 @@
+// Copyright 2023 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 (
+	"internal/platform"
+	"testing"
+)
+
+// TestMustLinkExternal verifies that the mustLinkExternal helper
+// function matches internal/platform.MustLinkExternal.
+func TestMustLinkExternal(t *testing.T) {
+	for _, goos := range okgoos {
+		for _, goarch := range okgoarch {
+			for _, cgoEnabled := range []bool{true, false} {
+				got := mustLinkExternal(goos, goarch, cgoEnabled)
+				want := platform.MustLinkExternal(goos, goarch, cgoEnabled)
+				if got != want {
+					t.Errorf("mustLinkExternal(%q, %q, %v) = %v; want %v", goos, goarch, cgoEnabled, got, want)
+				}
+			}
+		}
+	}
+}
+
+func TestRequiredBootstrapVersion(t *testing.T) {
+	testCases := map[string]string{
+		"1.22": "1.20",
+		"1.23": "1.20",
+		"1.24": "1.22",
+		"1.25": "1.22",
+		"1.26": "1.24",
+		"1.27": "1.24",
+	}
+
+	for v, want := range testCases {
+		if got := requiredBootstrapVersion(v); got != want {
+			t.Errorf("requiredBootstrapVersion(%v): got %v, want %v", v, got, want)
+		}
+	}
+}

go/src/cmd/dist/buildgo.go

@@ -0,0 +1,145 @@
+// Copyright 2012 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"
+	"path/filepath"
+	"sort"
+	"strings"
+)
+
+/*
+ * Helpers for building cmd/go and cmd/cgo.
+ */
+
+// generatedHeader is the string that all source files generated by dist start with.
+//
+// DO NOT CHANGE THIS STRING. If this string is changed then during
+//
+//	./make.bash
+//	git checkout other-rev
+//	./make.bash
+//
+// the second make.bash will not find the files generated by the first make.bash
+// and will not clean up properly.
+const generatedHeader = "// Code generated by go tool dist; DO NOT EDIT.\n\n"
+
+// writeHeader emits the standard "generated by" header for all files generated
+// by dist.
+func writeHeader(w io.Writer) {
+	fmt.Fprint(w, generatedHeader)
+}
+
+// mkzdefaultcc writes zdefaultcc.go:
+//
+//	package main
+//	const defaultCC = <defaultcc>
+//	const defaultCXX = <defaultcxx>
+//	const defaultPkgConfig = <defaultpkgconfig>
+//
+// It is invoked to write cmd/go/internal/cfg/zdefaultcc.go
+// but we also write cmd/cgo/zdefaultcc.go
+func mkzdefaultcc(dir, file string) {
+	if strings.Contains(file, filepath.FromSlash("go/internal/cfg")) {
+		var buf strings.Builder
+		writeHeader(&buf)
+		fmt.Fprintf(&buf, "package cfg\n")
+		fmt.Fprintln(&buf)
+		fmt.Fprintf(&buf, "const DefaultPkgConfig = `%s`\n", defaultpkgconfig)
+		buf.WriteString(defaultCCFunc("DefaultCC", defaultcc))
+		buf.WriteString(defaultCCFunc("DefaultCXX", defaultcxx))
+		writefile(buf.String(), file, writeSkipSame)
+		return
+	}
+
+	var buf strings.Builder
+	writeHeader(&buf)
+	fmt.Fprintf(&buf, "package main\n")
+	fmt.Fprintln(&buf)
+	fmt.Fprintf(&buf, "const defaultPkgConfig = `%s`\n", defaultpkgconfig)
+	buf.WriteString(defaultCCFunc("defaultCC", defaultcc))
+	buf.WriteString(defaultCCFunc("defaultCXX", defaultcxx))
+	writefile(buf.String(), file, writeSkipSame)
+}
+
+func defaultCCFunc(name string, defaultcc map[string]string) string {
+	var buf strings.Builder
+
+	fmt.Fprintf(&buf, "func %s(goos, goarch string) string {\n", name)
+	fmt.Fprintf(&buf, "\tswitch goos+`/`+goarch {\n")
+	var keys []string
+	for k := range defaultcc {
+		if k != "" {
+			keys = append(keys, k)
+		}
+	}
+	sort.Strings(keys)
+	for _, k := range keys {
+		fmt.Fprintf(&buf, "\tcase %s:\n\t\treturn %s\n", quote(k), quote(defaultcc[k]))
+	}
+	fmt.Fprintf(&buf, "\t}\n")
+	if cc := defaultcc[""]; cc != "" {
+		fmt.Fprintf(&buf, "\treturn %s\n", quote(cc))
+	} else {
+		clang, gcc := "clang", "gcc"
+		if strings.HasSuffix(name, "CXX") {
+			clang, gcc = "clang++", "g++"
+		}
+		fmt.Fprintf(&buf, "\tswitch goos {\n")
+		fmt.Fprintf(&buf, "\tcase ")
+		for i, os := range clangos {
+			if i > 0 {
+				fmt.Fprintf(&buf, ", ")
+			}
+			fmt.Fprintf(&buf, "%s", quote(os))
+		}
+		fmt.Fprintf(&buf, ":\n")
+		fmt.Fprintf(&buf, "\t\treturn %s\n", quote(clang))
+		fmt.Fprintf(&buf, "\t}\n")
+		fmt.Fprintf(&buf, "\treturn %s\n", quote(gcc))
+	}
+	fmt.Fprintf(&buf, "}\n")
+
+	return buf.String()
+}
+
+// mktzdata src/time/tzdata/zzipdata.go:
+//
+//	package tzdata
+//	const zipdata = "PK..."
+func mktzdata(dir, file string) {
+	zip := readfile(filepath.Join(dir, "../../../lib/time/zoneinfo.zip"))
+
+	var buf strings.Builder
+	writeHeader(&buf)
+	fmt.Fprintf(&buf, "package tzdata\n")
+	fmt.Fprintln(&buf)
+	fmt.Fprintf(&buf, "const zipdata = %s\n", quote(zip))
+
+	writefile(buf.String(), file, writeSkipSame)
+}
+
+// quote is like strconv.Quote but simpler and has output
+// that does not depend on the exact Go bootstrap version.
+func quote(s string) string {
+	const hex = "0123456789abcdef"
+	var out strings.Builder
+	out.WriteByte('"')
+	for i := 0; i < len(s); i++ {
+		c := s[i]
+		if 0x20 <= c && c <= 0x7E && c != '"' && c != '\\' {
+			out.WriteByte(c)
+		} else {
+			out.WriteByte('\\')
+			out.WriteByte('x')
+			out.WriteByte(hex[c>>4])
+			out.WriteByte(hex[c&0xf])
+		}
+	}
+	out.WriteByte('"')
+	return out.String()
+}

go/src/cmd/dist/buildruntime.go

@@ -0,0 +1,86 @@
+// Copyright 2012 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"
+	"os"
+	"strings"
+)
+
+/*
+ * Helpers for building runtime.
+ */
+
+// mkzversion writes zversion.go:
+//
+//	package sys
+//
+// (Nothing right now!)
+func mkzversion(dir, file string) {
+	var buf strings.Builder
+	writeHeader(&buf)
+	fmt.Fprintf(&buf, "package sys\n")
+	writefile(buf.String(), file, writeSkipSame)
+}
+
+// mkbuildcfg writes internal/buildcfg/zbootstrap.go:
+//
+//	package buildcfg
+//
+//	const defaultGOROOT = <goroot>
+//	const defaultGO386 = <go386>
+//	...
+//	const defaultGOOS = runtime.GOOS
+//	const defaultGOARCH = runtime.GOARCH
+//
+// The use of runtime.GOOS and runtime.GOARCH makes sure that
+// a cross-compiled compiler expects to compile for its own target
+// system. That is, if on a Mac you do:
+//
+//	GOOS=linux GOARCH=ppc64 go build cmd/compile
+//
+// the resulting compiler will default to generating linux/ppc64 object files.
+// This is more useful than having it default to generating objects for the
+// original target (in this example, a Mac).
+func mkbuildcfg(file string) {
+	var buf strings.Builder
+	writeHeader(&buf)
+	fmt.Fprintf(&buf, "package buildcfg\n")
+	fmt.Fprintln(&buf)
+	fmt.Fprintf(&buf, "import \"runtime\"\n")
+	fmt.Fprintln(&buf)
+	fmt.Fprintf(&buf, "const DefaultGO386 = `%s`\n", go386)
+	fmt.Fprintf(&buf, "const DefaultGOAMD64 = `%s`\n", goamd64)
+	fmt.Fprintf(&buf, "const DefaultGOARM = `%s`\n", goarm)
+	fmt.Fprintf(&buf, "const DefaultGOARM64 = `%s`\n", goarm64)
+	fmt.Fprintf(&buf, "const DefaultGOMIPS = `%s`\n", gomips)
+	fmt.Fprintf(&buf, "const DefaultGOMIPS64 = `%s`\n", gomips64)
+	fmt.Fprintf(&buf, "const DefaultGOPPC64 = `%s`\n", goppc64)
+	fmt.Fprintf(&buf, "const DefaultGORISCV64 = `%s`\n", goriscv64)
+	fmt.Fprintf(&buf, "const defaultGOEXPERIMENT = `%s`\n", goexperiment)
+	fmt.Fprintf(&buf, "const defaultGO_EXTLINK_ENABLED = `%s`\n", goextlinkenabled)
+	fmt.Fprintf(&buf, "const defaultGO_LDSO = `%s`\n", defaultldso)
+	fmt.Fprintf(&buf, "const version = `%s`\n", findgoversion())
+	fmt.Fprintf(&buf, "const defaultGOOS = runtime.GOOS\n")
+	fmt.Fprintf(&buf, "const defaultGOARCH = runtime.GOARCH\n")
+	fmt.Fprintf(&buf, "const DefaultGOFIPS140 = `%s`\n", gofips140)
+	fmt.Fprintf(&buf, "const DefaultCGO_ENABLED = %s\n", quote(os.Getenv("CGO_ENABLED")))
+
+	writefile(buf.String(), file, writeSkipSame)
+}
+
+// mkobjabi writes cmd/internal/objabi/zbootstrap.go:
+//
+//	package objabi
+//
+// (Nothing right now!)
+func mkobjabi(file string) {
+	var buf strings.Builder
+	writeHeader(&buf)
+	fmt.Fprintf(&buf, "package objabi\n")
+
+	writefile(buf.String(), file, writeSkipSame)
+}

go/src/cmd/dist/buildtag.go

@@ -0,0 +1,133 @@
+// Copyright 2021 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"
+	"strings"
+)
+
+// exprParser is a //go:build expression parser and evaluator.
+// The parser is a trivial precedence-based parser which is still
+// almost overkill for these very simple expressions.
+type exprParser struct {
+	x string
+	t exprToken // upcoming token
+}
+
+// val is the value type result of parsing.
+// We don't keep a parse tree, just the value of the expression.
+type val bool
+
+// exprToken describes a single token in the input.
+// Prefix operators define a prefix func that parses the
+// upcoming value. Binary operators define an infix func
+// that combines two values according to the operator.
+// In that case, the parsing loop parses the two values.
+type exprToken struct {
+	tok    string
+	prec   int
+	prefix func(*exprParser) val
+	infix  func(val, val) val
+}
+
+var exprTokens []exprToken
+
+func init() { // init to break init cycle
+	exprTokens = []exprToken{
+		{tok: "&&", prec: 1, infix: func(x, y val) val { return x && y }},
+		{tok: "||", prec: 2, infix: func(x, y val) val { return x || y }},
+		{tok: "!", prec: 3, prefix: (*exprParser).not},
+		{tok: "(", prec: 3, prefix: (*exprParser).paren},
+		{tok: ")"},
+	}
+}
+
+// matchexpr parses and evaluates the //go:build expression x.
+func matchexpr(x string) (matched bool, err error) {
+	defer func() {
+		if e := recover(); e != nil {
+			matched = false
+			err = fmt.Errorf("parsing //go:build line: %v", e)
+		}
+	}()
+
+	p := &exprParser{x: x}
+	p.next()
+	v := p.parse(0)
+	if p.t.tok != "end of expression" {
+		panic("unexpected " + p.t.tok)
+	}
+	return bool(v), nil
+}
+
+// parse parses an expression, including binary operators at precedence >= prec.
+func (p *exprParser) parse(prec int) val {
+	if p.t.prefix == nil {
+		panic("unexpected " + p.t.tok)
+	}
+	v := p.t.prefix(p)
+	for p.t.prec >= prec && p.t.infix != nil {
+		t := p.t
+		p.next()
+		v = t.infix(v, p.parse(t.prec+1))
+	}
+	return v
+}
+
+// not is the prefix parser for a ! token.
+func (p *exprParser) not() val {
+	p.next()
+	return !p.parse(100)
+}
+
+// paren is the prefix parser for a ( token.
+func (p *exprParser) paren() val {
+	p.next()
+	v := p.parse(0)
+	if p.t.tok != ")" {
+		panic("missing )")
+	}
+	p.next()
+	return v
+}
+
+// next advances the parser to the next token,
+// leaving the token in p.t.
+func (p *exprParser) next() {
+	p.x = strings.TrimSpace(p.x)
+	if p.x == "" {
+		p.t = exprToken{tok: "end of expression"}
+		return
+	}
+	for _, t := range exprTokens {
+		if strings.HasPrefix(p.x, t.tok) {
+			p.x = p.x[len(t.tok):]
+			p.t = t
+			return
+		}
+	}
+
+	i := 0
+	for i < len(p.x) && validtag(p.x[i]) {
+		i++
+	}
+	if i == 0 {
+		panic(fmt.Sprintf("syntax error near %#q", rune(p.x[i])))
+	}
+	tag := p.x[:i]
+	p.x = p.x[i:]
+	p.t = exprToken{
+		tok: "tag",
+		prefix: func(p *exprParser) val {
+			p.next()
+			return val(matchtag(tag))
+		},
+	}
+}
+
+func validtag(c byte) bool {
+	return 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z' || '0' <= c && c <= '9' || c == '.' || c == '_'
+}

go/src/cmd/dist/buildtag_test.go

@@ -0,0 +1,43 @@
+// Copyright 2021 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"
+	"reflect"
+	"testing"
+)
+
+var buildParserTests = []struct {
+	x       string
+	matched bool
+	err     error
+}{
+	{"gc", true, nil},
+	{"gccgo", false, nil},
+	{"!gc", false, nil},
+	{"gc && gccgo", false, nil},
+	{"gc || gccgo", true, nil},
+	{"gc || (gccgo && !gccgo)", true, nil},
+	{"gc && (gccgo || !gccgo)", true, nil},
+	{"!(gc && (gccgo || !gccgo))", false, nil},
+	{"gccgo || gc", true, nil},
+	{"!(!(!(gccgo || gc)))", false, nil},
+	{"compiler_bootstrap", false, nil},
+	{"cmd_go_bootstrap", true, nil},
+	{"syntax(error", false, fmt.Errorf("parsing //go:build line: unexpected (")},
+	{"(gc", false, fmt.Errorf("parsing //go:build line: missing )")},
+	{"gc gc", false, fmt.Errorf("parsing //go:build line: unexpected tag")},
+	{"(gc))", false, fmt.Errorf("parsing //go:build line: unexpected )")},
+}
+
+func TestBuildParser(t *testing.T) {
+	for _, tt := range buildParserTests {
+		matched, err := matchexpr(tt.x)
+		if matched != tt.matched || !reflect.DeepEqual(err, tt.err) {
+			t.Errorf("matchexpr(%q) = %v, %v; want %v, %v", tt.x, matched, err, tt.matched, tt.err)
+		}
+	}
+}

go/src/cmd/dist/buildtool.go

@@ -0,0 +1,408 @@
+// Copyright 2015 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.
+
+// Build toolchain using Go bootstrap version.
+//
+// The general strategy is to copy the source files we need into
+// a new GOPATH workspace, adjust import paths appropriately,
+// invoke the Go bootstrap toolchains go command to build those sources,
+// and then copy the binaries back.
+
+package main
+
+import (
+	"fmt"
+	"go/version"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+)
+
+// bootstrapDirs is a list of directories holding code that must be
+// compiled with the Go bootstrap toolchain to produce the bootstrapTargets.
+// All directories in this list are relative to and must be below $GOROOT/src.
+//
+// The list has two kinds of entries: names beginning with cmd/ with
+// no other slashes, which are commands, and other paths, which are packages
+// supporting the commands. Packages in the standard library can be listed
+// if a newer copy needs to be substituted for the Go bootstrap copy when used
+// by the command packages. Paths ending with /... automatically
+// include all packages within subdirectories as well.
+// These will be imported during bootstrap as bootstrap/name, like bootstrap/math/big.
+var bootstrapDirs = []string{
+	"cmp",
+	"cmd/asm",
+	"cmd/asm/internal/...",
+	"cmd/cgo",
+	"cmd/compile",
+	"cmd/compile/internal/...",
+	"cmd/internal/archive",
+	"cmd/internal/bio",
+	"cmd/internal/codesign",
+	"cmd/internal/dwarf",
+	"cmd/internal/edit",
+	"cmd/internal/gcprog",
+	"cmd/internal/goobj",
+	"cmd/internal/hash",
+	"cmd/internal/macho",
+	"cmd/internal/obj/...",
+	"cmd/internal/objabi",
+	"cmd/internal/par",
+	"cmd/internal/pgo",
+	"cmd/internal/pkgpath",
+	"cmd/internal/quoted",
+	"cmd/internal/src",
+	"cmd/internal/sys",
+	"cmd/internal/telemetry",
+	"cmd/internal/telemetry/counter",
+	"cmd/link",
+	"cmd/link/internal/...",
+	"compress/flate",
+	"compress/zlib",
+	"container/heap",
+	"debug/dwarf",
+	"debug/elf",
+	"debug/macho",
+	"debug/pe",
+	"go/build/constraint",
+	"go/constant",
+	"go/version",
+	"internal/abi",
+	"internal/coverage",
+	"cmd/internal/cov/covcmd",
+	"internal/bisect",
+	"internal/buildcfg",
+	"internal/exportdata",
+	"internal/goarch",
+	"internal/godebugs",
+	"internal/goexperiment",
+	"internal/goroot",
+	"internal/gover",
+	"internal/goversion",
+	// internal/lazyregexp is provided by Go 1.17, which permits it to
+	// be imported by other packages in this list, but is not provided
+	// by the Go 1.17 version of gccgo. It's on this list only to
+	// support gccgo, and can be removed if we require gccgo 14 or later.
+	"internal/lazyregexp",
+	"internal/pkgbits",
+	"internal/platform",
+	"internal/profile",
+	"internal/race",
+	"internal/runtime/gc",
+	"internal/saferio",
+	"internal/strconv",
+	"internal/syscall/unix",
+	"internal/types/errors",
+	"internal/unsafeheader",
+	"internal/xcoff",
+	"internal/zstd",
+	"math/bits",
+	"sort",
+}
+
+// File prefixes that are ignored by go/build anyway, and cause
+// problems with editor generated temporary files (#18931).
+var ignorePrefixes = []string{
+	".",
+	"_",
+	"#",
+}
+
+// File suffixes that use build tags introduced since Go 1.17.
+// These must not be copied into the bootstrap build directory.
+// Also ignore test files.
+var ignoreSuffixes = []string{
+	"_test.s",
+	"_test.go",
+	// Skip PGO profile. No need to build toolchain1 compiler
+	// with PGO. And as it is not a text file the import path
+	// rewrite will break it.
+	".pgo",
+	// Skip editor backup files.
+	"~",
+}
+
+const minBootstrap = "go1.24.6"
+
+var tryDirs = []string{
+	"sdk/" + minBootstrap,
+	minBootstrap,
+}
+
+func bootstrapBuildTools() {
+	goroot_bootstrap := os.Getenv("GOROOT_BOOTSTRAP")
+	if goroot_bootstrap == "" {
+		home := os.Getenv("HOME")
+		goroot_bootstrap = pathf("%s/go1.4", home)
+		for _, d := range tryDirs {
+			if p := pathf("%s/%s", home, d); isdir(p) {
+				goroot_bootstrap = p
+			}
+		}
+	}
+
+	// check bootstrap version.
+	ver := run(pathf("%s/bin", goroot_bootstrap), CheckExit, pathf("%s/bin/go", goroot_bootstrap), "env", "GOVERSION")
+	// go env GOVERSION output like "go1.22.6\n" or "devel go1.24-ffb3e574 Thu Aug 29 20:16:26 2024 +0000\n".
+	ver = ver[:len(ver)-1]
+	if version.Compare(ver, version.Lang(minBootstrap)) > 0 && version.Compare(ver, minBootstrap) < 0 {
+		fatalf("%s does not meet the minimum bootstrap requirement of %s or later", ver, minBootstrap)
+	}
+
+	xprintf("Building Go toolchain1 using %s.\n", goroot_bootstrap)
+
+	mkbuildcfg(pathf("%s/src/internal/buildcfg/zbootstrap.go", goroot))
+	mkobjabi(pathf("%s/src/cmd/internal/objabi/zbootstrap.go", goroot))
+
+	// Use $GOROOT/pkg/bootstrap as the bootstrap workspace root.
+	// We use a subdirectory of $GOROOT/pkg because that's the
+	// space within $GOROOT where we store all generated objects.
+	// We could use a temporary directory outside $GOROOT instead,
+	// but it is easier to debug on failure if the files are in a known location.
+	workspace := pathf("%s/pkg/bootstrap", goroot)
+	xremoveall(workspace)
+	xatexit(func() { xremoveall(workspace) })
+	base := pathf("%s/src/bootstrap", workspace)
+	xmkdirall(base)
+
+	// Copy source code into $GOROOT/pkg/bootstrap and rewrite import paths.
+	minBootstrapVers := requiredBootstrapVersion(goModVersion()) // require the minimum required go version to build this go version in the go.mod file
+	writefile("module bootstrap\ngo "+minBootstrapVers+"\n", pathf("%s/%s", base, "go.mod"), 0)
+	for _, dir := range bootstrapDirs {
+		recurse := strings.HasSuffix(dir, "/...")
+		dir = strings.TrimSuffix(dir, "/...")
+		filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
+			if err != nil {
+				fatalf("walking bootstrap dirs failed: %v: %v", path, err)
+			}
+
+			name := filepath.Base(path)
+			src := pathf("%s/src/%s", goroot, path)
+			dst := pathf("%s/%s", base, path)
+
+			if info.IsDir() {
+				if !recurse && path != dir || name == "testdata" {
+					return filepath.SkipDir
+				}
+
+				xmkdirall(dst)
+				if path == "cmd/cgo" {
+					// Write to src because we need the file both for bootstrap
+					// and for later in the main build.
+					mkzdefaultcc("", pathf("%s/zdefaultcc.go", src))
+					mkzdefaultcc("", pathf("%s/zdefaultcc.go", dst))
+				}
+				return nil
+			}
+
+			for _, pre := range ignorePrefixes {
+				if strings.HasPrefix(name, pre) {
+					return nil
+				}
+			}
+			for _, suf := range ignoreSuffixes {
+				if strings.HasSuffix(name, suf) {
+					return nil
+				}
+			}
+
+			text := bootstrapRewriteFile(src)
+			writefile(text, dst, 0)
+			return nil
+		})
+	}
+
+	// Set up environment for invoking Go bootstrap toolchains go command.
+	// GOROOT points at Go bootstrap GOROOT,
+	// GOPATH points at our bootstrap workspace,
+	// GOBIN is empty, so that binaries are installed to GOPATH/bin,
+	// and GOOS, GOHOSTOS, GOARCH, and GOHOSTOS are empty,
+	// so that Go bootstrap toolchain builds whatever kind of binary it knows how to build.
+	// Restore GOROOT, GOPATH, and GOBIN when done.
+	// Don't bother with GOOS, GOHOSTOS, GOARCH, and GOHOSTARCH,
+	// because setup will take care of those when bootstrapBuildTools returns.
+
+	defer os.Setenv("GOROOT", os.Getenv("GOROOT"))
+	os.Setenv("GOROOT", goroot_bootstrap)
+
+	defer os.Setenv("GOPATH", os.Getenv("GOPATH"))
+	os.Setenv("GOPATH", workspace)
+
+	defer os.Setenv("GOBIN", os.Getenv("GOBIN"))
+	os.Setenv("GOBIN", "")
+
+	os.Setenv("GOOS", "")
+	os.Setenv("GOHOSTOS", "")
+	os.Setenv("GOARCH", "")
+	os.Setenv("GOHOSTARCH", "")
+
+	// Run Go bootstrap to build binaries.
+	// Use the math_big_pure_go build tag to disable the assembly in math/big
+	// which may contain unsupported instructions.
+	// Use the purego build tag to disable other assembly code.
+	cmd := []string{
+		pathf("%s/bin/go", goroot_bootstrap),
+		"install",
+		"-tags=math_big_pure_go compiler_bootstrap purego",
+	}
+	if vflag > 0 {
+		cmd = append(cmd, "-v")
+	}
+	if tool := os.Getenv("GOBOOTSTRAP_TOOLEXEC"); tool != "" {
+		cmd = append(cmd, "-toolexec="+tool)
+	}
+	cmd = append(cmd, "bootstrap/cmd/...")
+	run(base, ShowOutput|CheckExit, cmd...)
+
+	// Copy binaries into tool binary directory.
+	for _, name := range bootstrapDirs {
+		if !strings.HasPrefix(name, "cmd/") {
+			continue
+		}
+		name = name[len("cmd/"):]
+		if !strings.Contains(name, "/") {
+			copyfile(pathf("%s/%s%s", tooldir, name, exe), pathf("%s/bin/%s%s", workspace, name, exe), writeExec)
+		}
+	}
+
+	if vflag > 0 {
+		xprintf("\n")
+	}
+}
+
+var ssaRewriteFileSubstring = filepath.FromSlash("src/cmd/compile/internal/ssa/rewrite")
+
+// isUnneededSSARewriteFile reports whether srcFile is a
+// src/cmd/compile/internal/ssa/rewriteARCHNAME.go file for an
+// architecture that isn't for the given GOARCH.
+//
+// When unneeded is true archCaps is the rewrite base filename without
+// the "rewrite" prefix or ".go" suffix: AMD64, 386, ARM, ARM64, etc.
+func isUnneededSSARewriteFile(srcFile, goArch string) (archCaps string, unneeded bool) {
+	if !strings.Contains(srcFile, ssaRewriteFileSubstring) {
+		return "", false
+	}
+	fileArch := strings.TrimSuffix(strings.TrimPrefix(filepath.Base(srcFile), "rewrite"), ".go")
+	if fileArch == "" {
+		return "", false
+	}
+	b := fileArch[0]
+	if b == '_' || ('a' <= b && b <= 'z') {
+		return "", false
+	}
+	archCaps = fileArch
+	fileArch = strings.ToLower(fileArch)
+	fileArch = strings.TrimSuffix(fileArch, "splitload")
+	fileArch = strings.TrimSuffix(fileArch, "latelower")
+	if fileArch == goArch {
+		return "", false
+	}
+	if fileArch == strings.TrimSuffix(goArch, "le") {
+		return "", false
+	}
+	return archCaps, true
+}
+
+func bootstrapRewriteFile(srcFile string) string {
+	// During bootstrap, generate dummy rewrite files for
+	// irrelevant architectures. We only need to build a bootstrap
+	// binary that works for the current gohostarch.
+	// This saves 6+ seconds of bootstrap.
+	if archCaps, ok := isUnneededSSARewriteFile(srcFile, gohostarch); ok {
+		return fmt.Sprintf(`%spackage ssa
+
+func rewriteValue%s(v *Value) bool { panic("unused during bootstrap") }
+func rewriteBlock%s(b *Block) bool { panic("unused during bootstrap") }
+`, generatedHeader, archCaps, archCaps)
+	}
+
+	return bootstrapFixImports(srcFile)
+}
+
+var (
+	importRE      = regexp.MustCompile(`\Aimport\s+(\.|[A-Za-z0-9_]+)?\s*"([^"]+)"\s*(//.*)?\n\z`)
+	importBlockRE = regexp.MustCompile(`\A\s*(?:(\.|[A-Za-z0-9_]+)?\s*"([^"]+)")?\s*(//.*)?\n\z`)
+)
+
+func bootstrapFixImports(srcFile string) string {
+	text := readfile(srcFile)
+	lines := strings.SplitAfter(text, "\n")
+	inBlock := false
+	inComment := false
+	for i, line := range lines {
+		if strings.HasSuffix(line, "*/\n") {
+			inComment = false
+		}
+		if strings.HasSuffix(line, "/*\n") {
+			inComment = true
+		}
+		if inComment {
+			continue
+		}
+		if strings.HasPrefix(line, "import (") {
+			inBlock = true
+			continue
+		}
+		if inBlock && strings.HasPrefix(line, ")") {
+			inBlock = false
+			continue
+		}
+
+		var m []string
+		if !inBlock {
+			if !strings.HasPrefix(line, "import ") {
+				continue
+			}
+			m = importRE.FindStringSubmatch(line)
+			if m == nil {
+				fatalf("%s:%d: invalid import declaration: %q", srcFile, i+1, line)
+			}
+		} else {
+			m = importBlockRE.FindStringSubmatch(line)
+			if m == nil {
+				fatalf("%s:%d: invalid import block line", srcFile, i+1)
+			}
+			if m[2] == "" {
+				continue
+			}
+		}
+
+		path := m[2]
+		if strings.HasPrefix(path, "cmd/") {
+			path = "bootstrap/" + path
+		} else {
+			for _, dir := range bootstrapDirs {
+				if path == dir {
+					path = "bootstrap/" + dir
+					break
+				}
+			}
+		}
+
+		// Rewrite use of internal/reflectlite to be plain reflect.
+		if path == "internal/reflectlite" {
+			lines[i] = strings.ReplaceAll(line, `"reflect"`, `reflectlite "reflect"`)
+			continue
+		}
+
+		// Otherwise, reject direct imports of internal packages,
+		// since that implies knowledge of internal details that might
+		// change from one bootstrap toolchain to the next.
+		// There are many internal packages that are listed in
+		// bootstrapDirs and made into bootstrap copies based on the
+		// current repo's source code. Those are fine; this is catching
+		// references to internal packages in the older bootstrap toolchain.
+		if strings.HasPrefix(path, "internal/") {
+			fatalf("%s:%d: bootstrap-copied source file cannot import %s", srcFile, i+1, path)
+		}
+		if path != m[2] {
+			lines[i] = strings.ReplaceAll(line, `"`+m[2]+`"`, `"`+path+`"`)
+		}
+	}
+
+	lines[0] = generatedHeader + "// This is a bootstrap copy of " + srcFile + "\n\n//line " + srcFile + ":1\n" + lines[0]
+
+	return strings.Join(lines, "")
+}

go/src/cmd/dist/doc.go

@@ -0,0 +1,21 @@
+// Copyright 2017 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.
+
+// Dist helps bootstrap, build, and test the Go distribution.
+//
+// Usage:
+//
+//	go tool dist [command]
+//
+// The commands are:
+//
+//	banner         print installation banner
+//	bootstrap      rebuild everything
+//	clean          deletes all built files
+//	env [-p]       print environment (-p: include $PATH)
+//	install [dir]  install individual directory
+//	list [-json]   list all supported platforms
+//	test [-h]      run Go test(s)
+//	version        print Go version
+package main

go/src/cmd/dist/exec.go

@@ -0,0 +1,40 @@
+// Copyright 2022 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 (
+	"os/exec"
+	"strings"
+)
+
+// setDir sets cmd.Dir to dir, and also adds PWD=dir to cmd's environment.
+func setDir(cmd *exec.Cmd, dir string) {
+	cmd.Dir = dir
+	if cmd.Env != nil {
+		// os/exec won't set PWD automatically.
+		setEnv(cmd, "PWD", dir)
+	}
+}
+
+// setEnv sets cmd.Env so that key = value.
+func setEnv(cmd *exec.Cmd, key, value string) {
+	cmd.Env = append(cmd.Environ(), key+"="+value)
+}
+
+// unsetEnv sets cmd.Env so that key is not present in the environment.
+func unsetEnv(cmd *exec.Cmd, key string) {
+	cmd.Env = cmd.Environ()
+
+	prefix := key + "="
+	newEnv := []string{}
+	for _, entry := range cmd.Env {
+		if strings.HasPrefix(entry, prefix) {
+			continue
+		}
+		newEnv = append(newEnv, entry)
+		// key may appear multiple times, so keep going.
+	}
+	cmd.Env = newEnv
+}