dwtest/dwloc_test.go - debug - Git at Google

 // 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 dwtest_test

 // This file contains a set of DWARF variable location generation
 // tests that are intended to compliment the existing linker DWARF
 // tests. The tests make use of a harness / utility program
 // "dwdumploc" that is built during test setup and then
 // invoked (fork+exec) in testpoints. We do things this way (as
 // opposed to just incorporating all of the source code from
 // testdata/dwdumploc.go into this file) so that the dumper code can
 // import packages from Delve without needing to vendor everything
 // into the Go distribution itself.
 //
 // Notes on GOARCH/GOOS support: this test is guarded to execute only
 // on arch/os combinations supported by Delve (see the testpoint
 // below); as Delve evolves we may need to update accordingly.
 //
 // This test requires network support (the harness build has to
 // download packages), so only runs in "long" test mode at the moment,
 // and since we don't currently have longtest builders for every
 // arch/os pair that Delve supports (ex: no linux/arm64 longtest
 // builder, Issue #49649), this is something to keep in mind when
 // running trybots etc.
 //

 import (
 	"bytes"
 	"flag"
 	"fmt"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"runtime"
 	"strings"
 	"testing"

 	"golang.org/x/debug/internal/testenv"
 )

 var preserveTemp = flag.Bool("keep", false, "keep tmpdir files for debugging")

 // copyFilesForHarness copies various files into the build dir for the
 // harness, including the main package, go.mod, and a copy of the
 // dwtest package (the latter is why we are doing an explicit copy as
 // opposed to just building directly from sources in testdata).
 // Return value is the path to a build directory for the harness
 // build.
 func copyFilesForHarness(t *testing.T, dir string) string {
 	mkdir := func(d string) {
 		if err := os.Mkdir(d, 0777); err != nil {
 			t.Fatalf("mkdir failed: %v", err)
 		}
 	}
 	cp := func(from, to string) {
 		var payload []byte
 		payload, err := os.ReadFile(from)
 		if err != nil {
 			t.Fatalf("os.ReadFile failed: %v", err)
 		}
 		if err = os.WriteFile(to, payload, 0644); err != nil {
 			t.Fatalf("os.WriteFile failed: %v", err)
 		}
 	}
 	join := filepath.Join
 	bd := join(dir, "build")
 	bdt := join(bd, "dwtest")
 	mkdir(bd)
 	mkdir(bdt)
 	cp(join("testdata", "dwdumploc.go"), join(bd, "main.go"))
 	cp(join("testdata", "go.mod.txt"), join(bd, "go.mod"))
 	cp(join("testdata", "go.sum.txt"), join(bd, "go.sum"))
 	cp("dwtest.go", join(bdt, "dwtest.go"))
 	return bd
 }

 // buildHarness builds the helper program "dwdumploc.exe"
 // and a companion executable "dwdumploc.noopt.exe", built
 // with "-gcflags=all=-l -N".
 func buildHarness(t *testing.T, dir string) (string, string) {

 	// Copy source files into build dir.
 	bd := copyFilesForHarness(t, dir)

 	// Run builds.
 	harnessPath := filepath.Join(dir, "dumpdwloc.exe")
 	cmd := exec.Command(testenv.GoToolPath(t), "build", "-o", harnessPath)
 	cmd.Dir = bd
 	if b, err := cmd.CombinedOutput(); err != nil {
 		t.Fatalf("build failed (%v): %s", err, b)
 	}

 	nooptHarnessPath := filepath.Join(dir, "dumpdwloc.exe")
 	cmd = exec.Command(testenv.GoToolPath(t), "build", "-gcflags=all=-l -N", "-o", nooptHarnessPath)
 	cmd.Dir = bd
 	if b, err := cmd.CombinedOutput(); err != nil {
 		t.Fatalf("build failed (%v): %s", err, b)
 	}
 	return harnessPath, nooptHarnessPath
 }

 // runHarness runs our previously built harness exec on a Go binary
 // 'exePath' for function 'fcn' and returns the results. Stderr from
 // the harness is printed to test stderr. Note: to debug the harness,
 // try adding "-v=2" to the exec.Command below.
 func runHarness(t *testing.T, harnessPath string, exePath string, fcn string) string {
 	cmd := exec.Command(harnessPath, "-m", exePath, "-f", fcn)
 	var b bytes.Buffer
 	cmd.Stderr = os.Stderr
 	cmd.Stdout = &b
 	if err := cmd.Run(); err != nil {
 		t.Fatalf("running 'harness -m %s -f %s': %v", exePath, fcn, err)
 	}
 	return strings.TrimSpace(string(b.Bytes()))
 }

 // gobuild is a helper to build a Go program from source code,
 // so that we can inspect selected bits of DWARF in the resulting binary.
 // Return value is binary path.
 func gobuild(t *testing.T, sourceCode string, pname string, dir string) string {
 	spath := filepath.Join(dir, pname+".go")
 	if err := os.WriteFile(spath, []byte(sourceCode), 0644); err != nil {
 		t.Fatalf("write to %s failed: %s", spath, err)
 	}
 	epath := filepath.Join(dir, pname+".exe")

 	// A note on this build: Delve currently has problems digesting
 	// PIE binaries on Windows; until this can be straightened out,
 	// default to "exe" buildmode.
 	cmd := exec.Command(testenv.GoToolPath(t), "build", "-buildmode=exe", "-o", epath, spath)
 	if b, err := cmd.CombinedOutput(); err != nil {
 		t.Logf("%% build output: %s\n", b)
 		t.Fatalf("build failed: %s", err)
 	}
 	return epath
 }

 const programSourceCode = `
 package main

 import "context"

 var G int

 //go:noinline
 func another(x int) {
 	println(G)
 }

 //go:noinline
 func docall(f func()) {
 	f()
 }

 //go:noinline
 func Issue47354(s string) {
 	docall(func() {
 		println("s is", s)
 	})
 	G++
 	another(int(s[0]))
 }

 type DB int
 type driverConn int
 type Result interface {
 	Foo()
 }

 //go:noinline
 func (db *DB) Issue46845(ctx context.Context, dc *driverConn, release func(error), query string, args []interface{}) (res Result, err error) {
 	defer func() {
 		release(err)
         println(len(args))
 	}()
 	return nil, nil
 }

 func main() {
 	Issue47354("poo")
 	var d DB
 	d.Issue46845(context.Background(), nil, func(error) {}, "foo", nil)
 }

 `

 func testIssue47354(t *testing.T, harnessPath string, ppath string) {
 	expected := map[string]string{
 		"amd64": "1: in-param \"s\" loc=\"{ [0: S=8 RAX] [1: S=8 RBX] }\"",
 		"arm64": "1: in-param \"s\" loc=\"{ [0: S=8 R0] [1: S=8 R1] }\"",
 	}
 	fname := "Issue47354"
 	got := runHarness(t, harnessPath, ppath, "main."+fname)
 	want := expected[runtime.GOARCH]
 	if got != want {
 		t.Errorf("failed Issue47354 arch %s:\ngot: %q\nwant: %q",
 			runtime.GOARCH, got, want)
 	}
 }

 func testIssue46845(t *testing.T, harnessPath string, ppath string) {

 	// NB: note the "addr=0x1000" for the stack-based parameter "args"
 	// below. This is not an accurate stack location, it's just an
 	// artifact of the way we call into Delve.
 	expected := map[string]string{
 		"amd64": `
 1: in-param "db" loc="{ [0: S=0 RAX] }"
 2: in-param "ctx" loc="{ [0: S=8 RBX] [1: S=8 RCX] }"
 3: in-param "dc" loc="{ [0: S=0 RDI] }"
 4: in-param "release" loc="{ [0: S=0 RSI] }"
 5: in-param "query" loc="{ [0: S=8 R8] [1: S=8 R9] }"
 6: in-param "args" loc="{ [0: S=8 addr=0x1000] [1: S=8 addr=0x1008] [2: S=8 addr=0x1010] }"
 7: out-param "res" loc="<not available>"
 8: out-param "err" loc="<not available>"
 `,
 		"arm64": `
 1: in-param "db" loc="{ [0: S=0 R0] }"
 2: in-param "ctx" loc="{ [0: S=8 R1] [1: S=8 R2] }"
 3: in-param "dc" loc="{ [0: S=0 R3] }"
 4: in-param "release" loc="{ [0: S=0 R4] }"
 5: in-param "query" loc="{ [0: S=8 R5] [1: S=8 R6] }"
 6: in-param "args" loc="{ [0: S=8 R7] [1: S=8 R8] [2: S=8 R9] }"
 7: out-param "res" loc="<not available>"
 8: out-param "err" loc="<not available>"
 `,
 	}
 	fname := "(*DB).Issue46845"
 	got := runHarness(t, harnessPath, ppath, "main."+fname)
 	want := strings.TrimSpace(expected[runtime.GOARCH])
 	if got != want {
 		t.Errorf("failed Issue47354 arch %s:\ngot: %s\nwant: %s",
 			runtime.GOARCH, got, want)
 	}
 }

 // testRuntimeThrow verifies that we have well-formed DWARF for the
 // single input parameter of 'runtime.throw'. This function is
 // particularly important to handle correctly, since it is
 // special-cased by Delve. The code below checks that things are ok
 // both for the regular optimized case and the "-gcflags=all=-l -N"
 // case, which Delve users are often selecting.
 func testRuntimeThrow(t *testing.T, harnessPath, nooptHarnessPath, ppath string) {
 	expected := map[string]string{
 		"amd64": "1: in-param \"s\" loc=\"{ [0: S=8 RAX] [1: S=8 RBX] }\"",
 		"arm64": "1: in-param \"s\" loc=\"{ [0: S=8 R0] [1: S=8 R1] }\"",
 	}
 	fname := "runtime.throw"
 	harnesses := []string{harnessPath, nooptHarnessPath}
 	for _, harness := range harnesses {
 		got := runHarness(t, harness, ppath, fname)
 		want := expected[runtime.GOARCH]
 		if got != want {
 			t.Errorf("failed RuntimeThrow arch %s, harness %s:\ngot: %q\nwant: %q", runtime.GOARCH, harness, got, want)
 		}
 	}
 }

 func TestDwarfVariableLocations(t *testing.T) {
 	testenv.NeedsGo1Point(t, 18)
 	testenv.MustHaveGoBuild(t)
 	testenv.MustHaveExternalNetwork(t)

 	// A note on the guard below:
 	// - Delve doesn't officially support darwin/arm64, but I've run
 	//   this test by hand on darwin/arm64 and it seems to work, so
 	//   it is included for the moment
 	// - the harness code currently only supports amd64 + arm64. If more
 	//   archs are added (ex: 386) the harness will need to be updated.
 	pair := runtime.GOOS + "/" + runtime.GOARCH
 	switch pair {
 	case "linux/amd64", "linux/arm64", "windows/amd64",
 		"darwin/amd64", "darwin/arm64":
 	default:
 		t.Skipf("unsupported OS/ARCH pair %s (this tests supports only OS values supported by Delve", pair)
 	}

 	tdir := t.TempDir()
 	if *preserveTemp {
 		if td, err := os.MkdirTemp("", "dwloctest"); err != nil {
 			t.Fatal(err)
 		} else {
 			tdir = td
 			fmt.Fprintf(os.Stderr, "** preserving tmpdir %s\n", td)
 		}
 	}

 	// Build test harness.
 	harnessPath, nooptHarnessPath := buildHarness(t, tdir)

 	// Build program to inspect. NB: we're building at default (with
 	// optimization); it might also be worth doing a "-l -N" build
 	// to verify the location expressions in that case.
 	ppath := gobuild(t, programSourceCode, "prog", tdir)

 	// Sub-tests for each function we want to inspect.
 	t.Run("Issue47354", func(t *testing.T) {
 		t.Parallel()
 		testIssue47354(t, harnessPath, ppath)
 	})
 	t.Run("Issue46845", func(t *testing.T) {
 		t.Parallel()
 		testIssue46845(t, harnessPath, ppath)
 	})
 	t.Run("RuntimeThrow", func(t *testing.T) {
 		t.Parallel()
 		testRuntimeThrow(t, harnessPath, nooptHarnessPath, ppath)
 	})
 }
	// 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 dwtest_test

	// This file contains a set of DWARF variable location generation
	// tests that are intended to compliment the existing linker DWARF
	// tests. The tests make use of a harness / utility program
	// "dwdumploc" that is built during test setup and then
	// invoked (fork+exec) in testpoints. We do things this way (as
	// opposed to just incorporating all of the source code from
	// testdata/dwdumploc.go into this file) so that the dumper code can
	// import packages from Delve without needing to vendor everything
	// into the Go distribution itself.
	//
	// Notes on GOARCH/GOOS support: this test is guarded to execute only
	// on arch/os combinations supported by Delve (see the testpoint
	// below); as Delve evolves we may need to update accordingly.
	//
	// This test requires network support (the harness build has to
	// download packages), so only runs in "long" test mode at the moment,
	// and since we don't currently have longtest builders for every
	// arch/os pair that Delve supports (ex: no linux/arm64 longtest
	// builder, Issue #49649), this is something to keep in mind when
	// running trybots etc.
	//

	import (
	"bytes"
	"flag"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"runtime"
	"strings"
	"testing"

	"golang.org/x/debug/internal/testenv"
	)

	var preserveTemp = flag.Bool("keep", false, "keep tmpdir files for debugging")

	// copyFilesForHarness copies various files into the build dir for the
	// harness, including the main package, go.mod, and a copy of the
	// dwtest package (the latter is why we are doing an explicit copy as
	// opposed to just building directly from sources in testdata).
	// Return value is the path to a build directory for the harness
	// build.
	func copyFilesForHarness(t *testing.T, dir string) string {
	mkdir := func(d string) {
	if err := os.Mkdir(d, 0777); err != nil {
	t.Fatalf("mkdir failed: %v", err)
	}
	}
	cp := func(from, to string) {
	var payload []byte
	payload, err := os.ReadFile(from)
	if err != nil {
	t.Fatalf("os.ReadFile failed: %v", err)
	}
	if err = os.WriteFile(to, payload, 0644); err != nil {
	t.Fatalf("os.WriteFile failed: %v", err)
	}
	}
	join := filepath.Join
	bd := join(dir, "build")
	bdt := join(bd, "dwtest")
	mkdir(bd)
	mkdir(bdt)
	cp(join("testdata", "dwdumploc.go"), join(bd, "main.go"))
	cp(join("testdata", "go.mod.txt"), join(bd, "go.mod"))
	cp(join("testdata", "go.sum.txt"), join(bd, "go.sum"))
	cp("dwtest.go", join(bdt, "dwtest.go"))
	return bd
	}

	// buildHarness builds the helper program "dwdumploc.exe"
	// and a companion executable "dwdumploc.noopt.exe", built
	// with "-gcflags=all=-l -N".
	func buildHarness(t *testing.T, dir string) (string, string) {

	// Copy source files into build dir.
	bd := copyFilesForHarness(t, dir)

	// Run builds.
	harnessPath := filepath.Join(dir, "dumpdwloc.exe")
	cmd := exec.Command(testenv.GoToolPath(t), "build", "-o", harnessPath)
	cmd.Dir = bd
	if b, err := cmd.CombinedOutput(); err != nil {
	t.Fatalf("build failed (%v): %s", err, b)
	}

	nooptHarnessPath := filepath.Join(dir, "dumpdwloc.exe")
	cmd = exec.Command(testenv.GoToolPath(t), "build", "-gcflags=all=-l -N", "-o", nooptHarnessPath)
	cmd.Dir = bd
	if b, err := cmd.CombinedOutput(); err != nil {
	t.Fatalf("build failed (%v): %s", err, b)
	}
	return harnessPath, nooptHarnessPath
	}

	// runHarness runs our previously built harness exec on a Go binary
	// 'exePath' for function 'fcn' and returns the results. Stderr from
	// the harness is printed to test stderr. Note: to debug the harness,
	// try adding "-v=2" to the exec.Command below.
	func runHarness(t *testing.T, harnessPath string, exePath string, fcn string) string {
	cmd := exec.Command(harnessPath, "-m", exePath, "-f", fcn)
	var b bytes.Buffer
	cmd.Stderr = os.Stderr
	cmd.Stdout = &b
	if err := cmd.Run(); err != nil {
	t.Fatalf("running 'harness -m %s -f %s': %v", exePath, fcn, err)
	}
	return strings.TrimSpace(string(b.Bytes()))
	}

	// gobuild is a helper to build a Go program from source code,
	// so that we can inspect selected bits of DWARF in the resulting binary.
	// Return value is binary path.
	func gobuild(t *testing.T, sourceCode string, pname string, dir string) string {
	spath := filepath.Join(dir, pname+".go")
	if err := os.WriteFile(spath, []byte(sourceCode), 0644); err != nil {
	t.Fatalf("write to %s failed: %s", spath, err)
	}
	epath := filepath.Join(dir, pname+".exe")

	// A note on this build: Delve currently has problems digesting
	// PIE binaries on Windows; until this can be straightened out,
	// default to "exe" buildmode.
	cmd := exec.Command(testenv.GoToolPath(t), "build", "-buildmode=exe", "-o", epath, spath)
	if b, err := cmd.CombinedOutput(); err != nil {
	t.Logf("%% build output: %s\n", b)
	t.Fatalf("build failed: %s", err)
	}
	return epath
	}

	const programSourceCode = `
	package main

	import "context"

	var G int

	//go:noinline
	func another(x int) {
	println(G)
	}

	//go:noinline
	func docall(f func()) {
	f()
	}

	//go:noinline
	func Issue47354(s string) {
	docall(func() {
	println("s is", s)
	})
	G++
	another(int(s[0]))
	}

	type DB int
	type driverConn int
	type Result interface {
	Foo()
	}

	//go:noinline
	func (db DB) Issue46845(ctx context.Context, dc driverConn, release func(error), query string, args []interface{}) (res Result, err error) {
	defer func() {
	release(err)
	println(len(args))
	}()
	return nil, nil
	}

	func main() {
	Issue47354("poo")
	var d DB
	d.Issue46845(context.Background(), nil, func(error) {}, "foo", nil)
	}

	`

	func testIssue47354(t *testing.T, harnessPath string, ppath string) {
	expected := map[string]string{
	"amd64": "1: in-param \"s\" loc=\"{ [0: S=8 RAX] [1: S=8 RBX] }\"",
	"arm64": "1: in-param \"s\" loc=\"{ [0: S=8 R0] [1: S=8 R1] }\"",
	}
	fname := "Issue47354"
	got := runHarness(t, harnessPath, ppath, "main."+fname)
	want := expected[runtime.GOARCH]
	if got != want {
	t.Errorf("failed Issue47354 arch %s:\ngot: %q\nwant: %q",
	runtime.GOARCH, got, want)
	}
	}

	func testIssue46845(t *testing.T, harnessPath string, ppath string) {

	// NB: note the "addr=0x1000" for the stack-based parameter "args"
	// below. This is not an accurate stack location, it's just an
	// artifact of the way we call into Delve.
	expected := map[string]string{
	"amd64": `
	1: in-param "db" loc="{ [0: S=0 RAX] }"
	2: in-param "ctx" loc="{ [0: S=8 RBX] [1: S=8 RCX] }"
	3: in-param "dc" loc="{ [0: S=0 RDI] }"
	4: in-param "release" loc="{ [0: S=0 RSI] }"
	5: in-param "query" loc="{ [0: S=8 R8] [1: S=8 R9] }"
	6: in-param "args" loc="{ [0: S=8 addr=0x1000] [1: S=8 addr=0x1008] [2: S=8 addr=0x1010] }"
	7: out-param "res" loc="<not available>"
	8: out-param "err" loc="<not available>"
	`,
	"arm64": `
	1: in-param "db" loc="{ [0: S=0 R0] }"
	2: in-param "ctx" loc="{ [0: S=8 R1] [1: S=8 R2] }"
	3: in-param "dc" loc="{ [0: S=0 R3] }"
	4: in-param "release" loc="{ [0: S=0 R4] }"
	5: in-param "query" loc="{ [0: S=8 R5] [1: S=8 R6] }"
	6: in-param "args" loc="{ [0: S=8 R7] [1: S=8 R8] [2: S=8 R9] }"
	7: out-param "res" loc="<not available>"
	8: out-param "err" loc="<not available>"
	`,
	}
	fname := "(*DB).Issue46845"
	got := runHarness(t, harnessPath, ppath, "main."+fname)
	want := strings.TrimSpace(expected[runtime.GOARCH])
	if got != want {
	t.Errorf("failed Issue47354 arch %s:\ngot: %s\nwant: %s",
	runtime.GOARCH, got, want)
	}
	}

	// testRuntimeThrow verifies that we have well-formed DWARF for the
	// single input parameter of 'runtime.throw'. This function is
	// particularly important to handle correctly, since it is
	// special-cased by Delve. The code below checks that things are ok
	// both for the regular optimized case and the "-gcflags=all=-l -N"
	// case, which Delve users are often selecting.
	func testRuntimeThrow(t *testing.T, harnessPath, nooptHarnessPath, ppath string) {
	expected := map[string]string{
	"amd64": "1: in-param \"s\" loc=\"{ [0: S=8 RAX] [1: S=8 RBX] }\"",
	"arm64": "1: in-param \"s\" loc=\"{ [0: S=8 R0] [1: S=8 R1] }\"",
	}
	fname := "runtime.throw"
	harnesses := []string{harnessPath, nooptHarnessPath}
	for _, harness := range harnesses {
	got := runHarness(t, harness, ppath, fname)
	want := expected[runtime.GOARCH]
	if got != want {
	t.Errorf("failed RuntimeThrow arch %s, harness %s:\ngot: %q\nwant: %q", runtime.GOARCH, harness, got, want)
	}
	}
	}

	func TestDwarfVariableLocations(t *testing.T) {
	testenv.NeedsGo1Point(t, 18)
	testenv.MustHaveGoBuild(t)
	testenv.MustHaveExternalNetwork(t)

	// A note on the guard below:
	// - Delve doesn't officially support darwin/arm64, but I've run
	// this test by hand on darwin/arm64 and it seems to work, so
	// it is included for the moment
	// - the harness code currently only supports amd64 + arm64. If more
	// archs are added (ex: 386) the harness will need to be updated.
	pair := runtime.GOOS + "/" + runtime.GOARCH
	switch pair {
	case "linux/amd64", "linux/arm64", "windows/amd64",
	"darwin/amd64", "darwin/arm64":
	default:
	t.Skipf("unsupported OS/ARCH pair %s (this tests supports only OS values supported by Delve", pair)
	}

	tdir := t.TempDir()
	if *preserveTemp {
	if td, err := os.MkdirTemp("", "dwloctest"); err != nil {
	t.Fatal(err)
	} else {
	tdir = td
	fmt.Fprintf(os.Stderr, "** preserving tmpdir %s\n", td)
	}
	}

	// Build test harness.
	harnessPath, nooptHarnessPath := buildHarness(t, tdir)

	// Build program to inspect. NB: we're building at default (with
	// optimization); it might also be worth doing a "-l -N" build
	// to verify the location expressions in that case.
	ppath := gobuild(t, programSourceCode, "prog", tdir)

	// Sub-tests for each function we want to inspect.
	t.Run("Issue47354", func(t *testing.T) {
	t.Parallel()
	testIssue47354(t, harnessPath, ppath)
	})
	t.Run("Issue46845", func(t *testing.T) {
	t.Parallel()
	testIssue46845(t, harnessPath, ppath)
	})
	t.Run("RuntimeThrow", func(t *testing.T) {
	t.Parallel()
	testRuntimeThrow(t, harnessPath, nooptHarnessPath, ppath)
	})
	}