Adding upstream version 1.16.10.upstream/1.16.10upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

4 files changed, 637 insertions, 0 deletions

diff --git a/src/cmd/nm/doc.go b/src/cmd/nm/doc.go
new file mode 100644
index 0000000..b62da47
--- /dev/null
+++ b/src/cmd/nm/doc.go
@@ -0,0 +1,41 @@
+// 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.
+
+// Nm lists the symbols defined or used by an object file, archive, or executable.
+//
+// Usage:
+//	go tool nm [options] file...
+//
+// The default output prints one line per symbol, with three space-separated
+// fields giving the address (in hexadecimal), type (a character), and name of
+// the symbol. The types are:
+//
+//	T	text (code) segment symbol
+//	t	static text segment symbol
+//	R	read-only data segment symbol
+//	r	static read-only data segment symbol
+//	D	data segment symbol
+//	d	static data segment symbol
+//	B	bss segment symbol
+//	b	static bss segment symbol
+//	C	constant address
+//	U	referenced but undefined symbol
+//
+// Following established convention, the address is omitted for undefined
+// symbols (type U).
+//
+// The options control the printed output:
+//
+//	-n
+//		an alias for -sort address (numeric),
+//		for compatibility with other nm commands
+//	-size
+//		print symbol size in decimal between address and type
+//	-sort {address,name,none,size}
+//		sort output in the given order (default name)
+//		size orders from largest to smallest
+//	-type
+//		print symbol type after name
+//
+package main
diff --git a/src/cmd/nm/nm.go b/src/cmd/nm/nm.go
new file mode 100644
index 0000000..4572399
--- /dev/null
+++ b/src/cmd/nm/nm.go
@@ -0,0 +1,167 @@
+// 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"
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"sort"
+
+	"cmd/internal/objfile"
+)
+
+const helpText = `usage: go tool nm [options] file...
+  -n
+      an alias for -sort address (numeric),
+      for compatibility with other nm commands
+  -size
+      print symbol size in decimal between address and type
+  -sort {address,name,none,size}
+      sort output in the given order (default name)
+      size orders from largest to smallest
+  -type
+      print symbol type after name
+`
+
+func usage() {
+	fmt.Fprintf(os.Stderr, helpText)
+	os.Exit(2)
+}
+
+var (
+	sortOrder = flag.String("sort", "name", "")
+	printSize = flag.Bool("size", false, "")
+	printType = flag.Bool("type", false, "")
+
+	filePrefix = false
+)
+
+func init() {
+	flag.Var(nflag(0), "n", "") // alias for -sort address
+}
+
+type nflag int
+
+func (nflag) IsBoolFlag() bool {
+	return true
+}
+
+func (nflag) Set(value string) error {
+	if value == "true" {
+		*sortOrder = "address"
+	}
+	return nil
+}
+
+func (nflag) String() string {
+	if *sortOrder == "address" {
+		return "true"
+	}
+	return "false"
+}
+
+func main() {
+	log.SetFlags(0)
+	flag.Usage = usage
+	flag.Parse()
+
+	switch *sortOrder {
+	case "address", "name", "none", "size":
+		// ok
+	default:
+		fmt.Fprintf(os.Stderr, "nm: unknown sort order %q\n", *sortOrder)
+		os.Exit(2)
+	}
+
+	args := flag.Args()
+	filePrefix = len(args) > 1
+	if len(args) == 0 {
+		flag.Usage()
+	}
+
+	for _, file := range args {
+		nm(file)
+	}
+
+	os.Exit(exitCode)
+}
+
+var exitCode = 0
+
+func errorf(format string, args ...interface{}) {
+	log.Printf(format, args...)
+	exitCode = 1
+}
+
+func nm(file string) {
+	f, err := objfile.Open(file)
+	if err != nil {
+		errorf("%v", err)
+		return
+	}
+	defer f.Close()
+
+	w := bufio.NewWriter(os.Stdout)
+
+	entries := f.Entries()
+
+	var found bool
+
+	for _, e := range entries {
+		syms, err := e.Symbols()
+		if err != nil {
+			errorf("reading %s: %v", file, err)
+		}
+		if len(syms) == 0 {
+			continue
+		}
+
+		found = true
+
+		switch *sortOrder {
+		case "address":
+			sort.Slice(syms, func(i, j int) bool { return syms[i].Addr < syms[j].Addr })
+		case "name":
+			sort.Slice(syms, func(i, j int) bool { return syms[i].Name < syms[j].Name })
+		case "size":
+			sort.Slice(syms, func(i, j int) bool { return syms[i].Size > syms[j].Size })
+		}
+
+		for _, sym := range syms {
+			if len(entries) > 1 {
+				name := e.Name()
+				if name == "" {
+					fmt.Fprintf(w, "%s(%s):\t", file, "_go_.o")
+				} else {
+					fmt.Fprintf(w, "%s(%s):\t", file, name)
+				}
+			} else if filePrefix {
+				fmt.Fprintf(w, "%s:\t", file)
+			}
+			if sym.Code == 'U' {
+				fmt.Fprintf(w, "%8s", "")
+			} else {
+				fmt.Fprintf(w, "%8x", sym.Addr)
+			}
+			if *printSize {
+				fmt.Fprintf(w, " %10d", sym.Size)
+			}
+			fmt.Fprintf(w, " %c %s", sym.Code, sym.Name)
+			if *printType && sym.Type != "" {
+				fmt.Fprintf(w, " %s", sym.Type)
+			}
+			fmt.Fprintf(w, "\n")
+		}
+	}
+
+	if !found {
+		errorf("reading %s: no symbols", file)
+	}
+
+	w.Flush()
+}
diff --git a/src/cmd/nm/nm_cgo_test.go b/src/cmd/nm/nm_cgo_test.go
new file mode 100644
index 0000000..e0414e6
--- /dev/null
+++ b/src/cmd/nm/nm_cgo_test.go
@@ -0,0 +1,52 @@
+// 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.
+
+// +build cgo
+
+package main
+
+import (
+	"runtime"
+	"testing"
+)
+
+func canInternalLink() bool {
+	switch runtime.GOOS {
+	case "aix":
+		return false
+	case "dragonfly":
+		return false
+	case "freebsd":
+		switch runtime.GOARCH {
+		case "arm64":
+			return false
+		}
+	case "linux":
+		switch runtime.GOARCH {
+		case "arm64", "mips64", "mips64le", "mips", "mipsle", "ppc64", "ppc64le", "riscv64":
+			return false
+		}
+	case "openbsd":
+		switch runtime.GOARCH {
+		case "arm64":
+			return false
+		}
+	}
+	return true
+}
+
+func TestInternalLinkerCgoExec(t *testing.T) {
+	if !canInternalLink() {
+		t.Skip("skipping; internal linking is not supported")
+	}
+	testGoExec(t, true, false)
+}
+
+func TestExternalLinkerCgoExec(t *testing.T) {
+	testGoExec(t, true, true)
+}
+
+func TestCgoLib(t *testing.T) {
+	testGoLib(t, true)
+}
diff --git a/src/cmd/nm/nm_test.go b/src/cmd/nm/nm_test.go
new file mode 100644
index 0000000..0d51b07
--- /dev/null
+++ b/src/cmd/nm/nm_test.go
@@ -0,0 +1,377 @@
+// 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 (
+	"fmt"
+	"internal/obscuretestdata"
+	"internal/testenv"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"text/template"
+)
+
+var testnmpath string // path to nm command created for testing purposes
+
+// The TestMain function creates a nm command for testing purposes and
+// deletes it after the tests have been run.
+func TestMain(m *testing.M) {
+	os.Exit(testMain(m))
+}
+
+func testMain(m *testing.M) int {
+	if !testenv.HasGoBuild() {
+		return 0
+	}
+
+	tmpDir, err := os.MkdirTemp("", "TestNM")
+	if err != nil {
+		fmt.Println("TempDir failed:", err)
+		return 2
+	}
+	defer os.RemoveAll(tmpDir)
+
+	testnmpath = filepath.Join(tmpDir, "testnm.exe")
+	gotool, err := testenv.GoTool()
+	if err != nil {
+		fmt.Println("GoTool failed:", err)
+		return 2
+	}
+	out, err := exec.Command(gotool, "build", "-o", testnmpath, "cmd/nm").CombinedOutput()
+	if err != nil {
+		fmt.Printf("go build -o %v cmd/nm: %v\n%s", testnmpath, err, string(out))
+		return 2
+	}
+
+	return m.Run()
+}
+
+func TestNonGoExecs(t *testing.T) {
+	t.Parallel()
+	testfiles := []string{
+		"debug/elf/testdata/gcc-386-freebsd-exec",
+		"debug/elf/testdata/gcc-amd64-linux-exec",
+		"debug/macho/testdata/gcc-386-darwin-exec.base64",   // golang.org/issue/34986
+		"debug/macho/testdata/gcc-amd64-darwin-exec.base64", // golang.org/issue/34986
+		// "debug/pe/testdata/gcc-amd64-mingw-exec", // no symbols!
+		"debug/pe/testdata/gcc-386-mingw-exec",
+		"debug/plan9obj/testdata/amd64-plan9-exec",
+		"debug/plan9obj/testdata/386-plan9-exec",
+		"internal/xcoff/testdata/gcc-ppc64-aix-dwarf2-exec",
+	}
+	for _, f := range testfiles {
+		exepath := filepath.Join(runtime.GOROOT(), "src", f)
+		if strings.HasSuffix(f, ".base64") {
+			tf, err := obscuretestdata.DecodeToTempFile(exepath)
+			if err != nil {
+				t.Errorf("obscuretestdata.DecodeToTempFile(%s): %v", exepath, err)
+				continue
+			}
+			defer os.Remove(tf)
+			exepath = tf
+		}
+
+		cmd := exec.Command(testnmpath, exepath)
+		out, err := cmd.CombinedOutput()
+		if err != nil {
+			t.Errorf("go tool nm %v: %v\n%s", exepath, err, string(out))
+		}
+	}
+}
+
+func testGoExec(t *testing.T, iscgo, isexternallinker bool) {
+	t.Parallel()
+	tmpdir, err := os.MkdirTemp("", "TestGoExec")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmpdir)
+
+	src := filepath.Join(tmpdir, "a.go")
+	file, err := os.Create(src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = template.Must(template.New("main").Parse(testexec)).Execute(file, iscgo)
+	if e := file.Close(); err == nil {
+		err = e
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	exe := filepath.Join(tmpdir, "a.exe")
+	args := []string{"build", "-o", exe}
+	if iscgo {
+		linkmode := "internal"
+		if isexternallinker {
+			linkmode = "external"
+		}
+		args = append(args, "-ldflags", "-linkmode="+linkmode)
+	}
+	args = append(args, src)
+	out, err := exec.Command(testenv.GoToolPath(t), args...).CombinedOutput()
+	if err != nil {
+		t.Fatalf("building test executable failed: %s %s", err, out)
+	}
+
+	out, err = exec.Command(exe).CombinedOutput()
+	if err != nil {
+		t.Fatalf("running test executable failed: %s %s", err, out)
+	}
+	names := make(map[string]string)
+	for _, line := range strings.Split(string(out), "\n") {
+		if line == "" {
+			continue
+		}
+		f := strings.Split(line, "=")
+		if len(f) != 2 {
+			t.Fatalf("unexpected output line: %q", line)
+		}
+		names["main."+f[0]] = f[1]
+	}
+
+	runtimeSyms := map[string]string{
+		"runtime.text":      "T",
+		"runtime.etext":     "T",
+		"runtime.rodata":    "R",
+		"runtime.erodata":   "R",
+		"runtime.epclntab":  "R",
+		"runtime.noptrdata": "D",
+	}
+
+	if runtime.GOOS == "aix" && iscgo {
+		// pclntab is moved to .data section on AIX.
+		runtimeSyms["runtime.epclntab"] = "D"
+	}
+
+	out, err = exec.Command(testnmpath, exe).CombinedOutput()
+	if err != nil {
+		t.Fatalf("go tool nm: %v\n%s", err, string(out))
+	}
+
+	relocated := func(code string) bool {
+		if runtime.GOOS == "aix" {
+			// On AIX, .data and .bss addresses are changed by the loader.
+			// Therefore, the values returned by the exec aren't the same
+			// than the ones inside the symbol table.
+			// In case of cgo, .text symbols are also changed.
+			switch code {
+			case "T", "t", "R", "r":
+				return iscgo
+			case "D", "d", "B", "b":
+				return true
+			}
+		}
+		if runtime.GOOS == "windows" {
+			return true
+		}
+		if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
+			return true // On darwin/arm64 everything is PIE
+		}
+		return false
+	}
+
+	dups := make(map[string]bool)
+	for _, line := range strings.Split(string(out), "\n") {
+		f := strings.Fields(line)
+		if len(f) < 3 {
+			continue
+		}
+		name := f[2]
+		if addr, found := names[name]; found {
+			if want, have := addr, "0x"+f[0]; have != want {
+				if !relocated(f[1]) {
+					t.Errorf("want %s address for %s symbol, but have %s", want, name, have)
+				}
+			}
+			delete(names, name)
+		}
+		if _, found := dups[name]; found {
+			t.Errorf("duplicate name of %q is found", name)
+		}
+		if stype, found := runtimeSyms[name]; found {
+			if runtime.GOOS == "plan9" && stype == "R" {
+				// no read-only data segment symbol on Plan 9
+				stype = "D"
+			}
+			if want, have := stype, strings.ToUpper(f[1]); have != want {
+				t.Errorf("want %s type for %s symbol, but have %s", want, name, have)
+			}
+			delete(runtimeSyms, name)
+		}
+	}
+	if len(names) > 0 {
+		t.Errorf("executable is missing %v symbols", names)
+	}
+	if len(runtimeSyms) > 0 {
+		t.Errorf("executable is missing %v symbols", runtimeSyms)
+	}
+}
+
+func TestGoExec(t *testing.T) {
+	testGoExec(t, false, false)
+}
+
+func testGoLib(t *testing.T, iscgo bool) {
+	t.Parallel()
+	tmpdir, err := os.MkdirTemp("", "TestGoLib")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmpdir)
+
+	gopath := filepath.Join(tmpdir, "gopath")
+	libpath := filepath.Join(gopath, "src", "mylib")
+
+	err = os.MkdirAll(libpath, 0777)
+	if err != nil {
+		t.Fatal(err)
+	}
+	src := filepath.Join(libpath, "a.go")
+	file, err := os.Create(src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = template.Must(template.New("mylib").Parse(testlib)).Execute(file, iscgo)
+	if e := file.Close(); err == nil {
+		err = e
+	}
+	if err == nil {
+		err = os.WriteFile(filepath.Join(libpath, "go.mod"), []byte("module mylib\n"), 0666)
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	args := []string{"install", "mylib"}
+	cmd := exec.Command(testenv.GoToolPath(t), args...)
+	cmd.Dir = libpath
+	cmd.Env = append(os.Environ(), "GOPATH="+gopath)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("building test lib failed: %s %s", err, out)
+	}
+	pat := filepath.Join(gopath, "pkg", "*", "mylib.a")
+	ms, err := filepath.Glob(pat)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(ms) == 0 {
+		t.Fatalf("cannot found paths for pattern %s", pat)
+	}
+	mylib := ms[0]
+
+	out, err = exec.Command(testnmpath, mylib).CombinedOutput()
+	if err != nil {
+		t.Fatalf("go tool nm: %v\n%s", err, string(out))
+	}
+	type symType struct {
+		Type  string
+		Name  string
+		CSym  bool
+		Found bool
+	}
+	var syms = []symType{
+		{"B", "mylib.Testdata", false, false},
+		{"T", "mylib.Testfunc", false, false},
+	}
+	if iscgo {
+		syms = append(syms, symType{"B", "mylib.TestCgodata", false, false})
+		syms = append(syms, symType{"T", "mylib.TestCgofunc", false, false})
+		if runtime.GOOS == "darwin" || runtime.GOOS == "ios" || (runtime.GOOS == "windows" && runtime.GOARCH == "386") {
+			syms = append(syms, symType{"D", "_cgodata", true, false})
+			syms = append(syms, symType{"T", "_cgofunc", true, false})
+		} else if runtime.GOOS == "aix" {
+			syms = append(syms, symType{"D", "cgodata", true, false})
+			syms = append(syms, symType{"T", ".cgofunc", true, false})
+		} else {
+			syms = append(syms, symType{"D", "cgodata", true, false})
+			syms = append(syms, symType{"T", "cgofunc", true, false})
+		}
+	}
+
+	for _, line := range strings.Split(string(out), "\n") {
+		f := strings.Fields(line)
+		var typ, name string
+		var csym bool
+		if iscgo {
+			if len(f) < 4 {
+				continue
+			}
+			csym = !strings.Contains(f[0], "_go_.o")
+			typ = f[2]
+			name = f[3]
+		} else {
+			if len(f) < 3 {
+				continue
+			}
+			typ = f[1]
+			name = f[2]
+		}
+		for i := range syms {
+			sym := &syms[i]
+			if sym.Type == typ && sym.Name == name && sym.CSym == csym {
+				if sym.Found {
+					t.Fatalf("duplicate symbol %s %s", sym.Type, sym.Name)
+				}
+				sym.Found = true
+			}
+		}
+	}
+	for _, sym := range syms {
+		if !sym.Found {
+			t.Errorf("cannot found symbol %s %s", sym.Type, sym.Name)
+		}
+	}
+}
+
+func TestGoLib(t *testing.T) {
+	testGoLib(t, false)
+}
+
+const testexec = `
+package main
+
+import "fmt"
+{{if .}}import "C"
+{{end}}
+
+func main() {
+	testfunc()
+}
+
+var testdata uint32
+
+func testfunc() {
+	fmt.Printf("main=%p\n", main)
+	fmt.Printf("testfunc=%p\n", testfunc)
+	fmt.Printf("testdata=%p\n", &testdata)
+}
+`
+
+const testlib = `
+package mylib
+
+{{if .}}
+// int cgodata = 5;
+// void cgofunc(void) {}
+import "C"
+
+var TestCgodata = C.cgodata
+
+func TestCgofunc() {
+	C.cgofunc()
+}
+{{end}}
+
+var Testdata uint32
+
+func Testfunc() {}
+`