1 files changed, 347 insertions, 0 deletions
diff --git a/src/cmd/objdump/objdump_test.go b/src/cmd/objdump/objdump_test.go
new file mode 100644
index 0000000..1748e13
--- /dev/null
+++ b/src/cmd/objdump/objdump_test.go
@@ -0,0 +1,347 @@
+// 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 (
+	"crypto/md5"
+	"flag"
+	"fmt"
+	"go/build"
+	"internal/testenv"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+var tmp, exe string // populated by buildObjdump
+
+func TestMain(m *testing.M) {
+	if !testenv.HasGoBuild() {
+		return
+	}
+
+	var exitcode int
+	if err := buildObjdump(); err == nil {
+		exitcode = m.Run()
+	} else {
+		fmt.Println(err)
+		exitcode = 1
+	}
+	os.RemoveAll(tmp)
+	os.Exit(exitcode)
+}
+
+func buildObjdump() error {
+	var err error
+	tmp, err = os.MkdirTemp("", "TestObjDump")
+	if err != nil {
+		return fmt.Errorf("TempDir failed: %v", err)
+	}
+
+	exe = filepath.Join(tmp, "testobjdump.exe")
+	gotool, err := testenv.GoTool()
+	if err != nil {
+		return err
+	}
+	out, err := exec.Command(gotool, "build", "-o", exe, "cmd/objdump").CombinedOutput()
+	if err != nil {
+		os.RemoveAll(tmp)
+		return fmt.Errorf("go build -o %v cmd/objdump: %v\n%s", exe, err, string(out))
+	}
+
+	return nil
+}
+
+var x86Need = []string{ // for both 386 and AMD64
+	"JMP main.main(SB)",
+	"CALL main.Println(SB)",
+	"RET",
+}
+
+var amd64GnuNeed = []string{
+	"movq",
+	"callq",
+	"cmpb",
+}
+
+var i386GnuNeed = []string{
+	"mov",
+	"call",
+	"cmp",
+}
+
+var armNeed = []string{
+	"B main.main(SB)",
+	"BL main.Println(SB)",
+	"RET",
+}
+
+var arm64Need = []string{
+	"JMP main.main(SB)",
+	"CALL main.Println(SB)",
+	"RET",
+}
+
+var armGnuNeed = []string{ // for both ARM and AMR64
+	"ldr",
+	"bl",
+	"cmp",
+}
+
+var ppcNeed = []string{
+	"BR main.main(SB)",
+	"CALL main.Println(SB)",
+	"RET",
+}
+
+var ppcGnuNeed = []string{
+	"mflr",
+	"lbz",
+	"cmpw",
+}
+
+func mustHaveDisasm(t *testing.T) {
+	switch runtime.GOARCH {
+	case "mips", "mipsle", "mips64", "mips64le":
+		t.Skipf("skipping on %s, issue 12559", runtime.GOARCH)
+	case "riscv64":
+		t.Skipf("skipping on %s, issue 36738", runtime.GOARCH)
+	case "s390x":
+		t.Skipf("skipping on %s, issue 15255", runtime.GOARCH)
+	}
+}
+
+var target = flag.String("target", "", "test disassembly of `goos/goarch` binary")
+
+// objdump is fully cross platform: it can handle binaries
+// from any known operating system and architecture.
+// We could in principle add binaries to testdata and check
+// all the supported systems during this test. However, the
+// binaries would be about 1 MB each, and we don't want to
+// add that much junk to the hg repository. Instead, build a
+// binary for the current system (only) and test that objdump
+// can handle that one.
+
+func testDisasm(t *testing.T, srcfname string, printCode bool, printGnuAsm bool, flags ...string) {
+	mustHaveDisasm(t)
+	goarch := runtime.GOARCH
+	if *target != "" {
+		f := strings.Split(*target, "/")
+		if len(f) != 2 {
+			t.Fatalf("-target argument must be goos/goarch")
+		}
+		defer os.Setenv("GOOS", os.Getenv("GOOS"))
+		defer os.Setenv("GOARCH", os.Getenv("GOARCH"))
+		os.Setenv("GOOS", f[0])
+		os.Setenv("GOARCH", f[1])
+		goarch = f[1]
+	}
+
+	hash := md5.Sum([]byte(fmt.Sprintf("%v-%v-%v-%v", srcfname, flags, printCode, printGnuAsm)))
+	hello := filepath.Join(tmp, fmt.Sprintf("hello-%x.exe", hash))
+	args := []string{"build", "-o", hello}
+	args = append(args, flags...)
+	args = append(args, srcfname)
+	cmd := exec.Command(testenv.GoToolPath(t), args...)
+	// "Bad line" bug #36683 is sensitive to being run in the source directory.
+	cmd.Dir = "testdata"
+	// Ensure that the source file location embedded in the binary matches our
+	// actual current GOROOT, instead of GOROOT_FINAL if set.
+	cmd.Env = append(os.Environ(), "GOROOT_FINAL=")
+	t.Logf("Running %v", cmd.Args)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("go build %s: %v\n%s", srcfname, err, out)
+	}
+	need := []string{
+		"TEXT main.main(SB)",
+	}
+
+	if printCode {
+		need = append(need, `	Println("hello, world")`)
+	} else {
+		need = append(need, srcfname+":6")
+	}
+
+	switch goarch {
+	case "amd64", "386":
+		need = append(need, x86Need...)
+	case "arm":
+		need = append(need, armNeed...)
+	case "arm64":
+		need = append(need, arm64Need...)
+	case "ppc64", "ppc64le":
+		need = append(need, ppcNeed...)
+	}
+
+	if printGnuAsm {
+		switch goarch {
+		case "amd64":
+			need = append(need, amd64GnuNeed...)
+		case "386":
+			need = append(need, i386GnuNeed...)
+		case "arm", "arm64":
+			need = append(need, armGnuNeed...)
+		case "ppc64", "ppc64le":
+			need = append(need, ppcGnuNeed...)
+		}
+	}
+	args = []string{
+		"-s", "main.main",
+		hello,
+	}
+
+	if printCode {
+		args = append([]string{"-S"}, args...)
+	}
+
+	if printGnuAsm {
+		args = append([]string{"-gnu"}, args...)
+	}
+	cmd = exec.Command(exe, args...)
+	cmd.Dir = "testdata" // "Bad line" bug #36683 is sensitive to being run in the source directory
+	out, err = cmd.CombinedOutput()
+	t.Logf("Running %v", cmd.Args)
+
+	if err != nil {
+		exename := srcfname[:len(srcfname)-len(filepath.Ext(srcfname))] + ".exe"
+		t.Fatalf("objdump %q: %v\n%s", exename, err, out)
+	}
+
+	text := string(out)
+	ok := true
+	for _, s := range need {
+		if !strings.Contains(text, s) {
+			t.Errorf("disassembly missing '%s'", s)
+			ok = false
+		}
+	}
+	if goarch == "386" {
+		if strings.Contains(text, "(IP)") {
+			t.Errorf("disassembly contains PC-Relative addressing on 386")
+			ok = false
+		}
+	}
+
+	if !ok {
+		t.Logf("full disassembly:\n%s", text)
+	}
+}
+
+func testGoAndCgoDisasm(t *testing.T, printCode bool, printGnuAsm bool) {
+	t.Parallel()
+	testDisasm(t, "fmthello.go", printCode, printGnuAsm)
+	if build.Default.CgoEnabled {
+		testDisasm(t, "fmthellocgo.go", printCode, printGnuAsm)
+	}
+}
+
+func TestDisasm(t *testing.T) {
+	testGoAndCgoDisasm(t, false, false)
+}
+
+func TestDisasmCode(t *testing.T) {
+	testGoAndCgoDisasm(t, true, false)
+}
+
+func TestDisasmGnuAsm(t *testing.T) {
+	testGoAndCgoDisasm(t, false, true)
+}
+
+func TestDisasmExtld(t *testing.T) {
+	testenv.MustHaveCGO(t)
+	switch runtime.GOOS {
+	case "plan9", "windows":
+		t.Skipf("skipping on %s", runtime.GOOS)
+	}
+	t.Parallel()
+	testDisasm(t, "fmthello.go", false, false, "-ldflags=-linkmode=external")
+}
+
+func TestDisasmGoobj(t *testing.T) {
+	mustHaveDisasm(t)
+
+	hello := filepath.Join(tmp, "hello.o")
+	args := []string{"tool", "compile", "-o", hello}
+	args = append(args, "testdata/fmthello.go")
+	out, err := exec.Command(testenv.GoToolPath(t), args...).CombinedOutput()
+	if err != nil {
+		t.Fatalf("go tool compile fmthello.go: %v\n%s", err, out)
+	}
+	need := []string{
+		"main(SB)",
+		"fmthello.go:6",
+	}
+
+	args = []string{
+		"-s", "main",
+		hello,
+	}
+
+	out, err = exec.Command(exe, args...).CombinedOutput()
+	if err != nil {
+		t.Fatalf("objdump fmthello.o: %v\n%s", err, out)
+	}
+
+	text := string(out)
+	ok := true
+	for _, s := range need {
+		if !strings.Contains(text, s) {
+			t.Errorf("disassembly missing '%s'", s)
+			ok = false
+		}
+	}
+	if runtime.GOARCH == "386" {
+		if strings.Contains(text, "(IP)") {
+			t.Errorf("disassembly contains PC-Relative addressing on 386")
+			ok = false
+		}
+	}
+	if !ok {
+		t.Logf("full disassembly:\n%s", text)
+	}
+}
+
+func TestGoobjFileNumber(t *testing.T) {
+	// Test that file table in Go object file is parsed correctly.
+	testenv.MustHaveGoBuild(t)
+	mustHaveDisasm(t)
+
+	t.Parallel()
+
+	tmpdir, err := os.MkdirTemp("", "TestGoobjFileNumber")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmpdir)
+
+	obj := filepath.Join(tmpdir, "p.a")
+	cmd := exec.Command(testenv.GoToolPath(t), "build", "-o", obj)
+	cmd.Dir = filepath.Join("testdata/testfilenum")
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("build failed: %v\n%s", err, out)
+	}
+
+	cmd = exec.Command(exe, obj)
+	out, err = cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("objdump failed: %v\n%s", err, out)
+	}
+
+	text := string(out)
+	for _, s := range []string{"a.go", "b.go", "c.go"} {
+		if !strings.Contains(text, s) {
+			t.Errorf("output missing '%s'", s)
+		}
+	}
+
+	if t.Failed() {
+		t.Logf("output:\n%s", text)
+	}
+}