blob: 268c4c41db6cd50fa8f15b4cd6eb88e9feb6f28a [file] [log] [blame]
// 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 ssa_test
import (
"bufio"
"bytes"
"flag"
"fmt"
"internal/testenv"
"os"
"path/filepath"
"reflect"
"regexp"
"runtime"
"sort"
"strconv"
"strings"
"testing"
)
// Matches lines in genssa output that are marked "isstmt", and the parenthesized plus-prefixed line number is a submatch
var asmLine *regexp.Regexp = regexp.MustCompile(`^\s[vb]\d+\s+\d+\s\(\+(\d+)\)`)
// this matches e.g. ` v123456789 000007 (+9876654310) MOVUPS X15, ""..autotmp_2-32(SP)`
// Matches lines in genssa output that describe an inlined file.
// Note it expects an unadventurous choice of basename.
var sepRE = regexp.QuoteMeta(string(filepath.Separator))
var inlineLine *regexp.Regexp = regexp.MustCompile(`^#\s.*` + sepRE + `[-\w]+\.go:(\d+)`)
// this matches e.g. # /pa/inline-dumpxxxx.go:6
var testGoArchFlag = flag.String("arch", "", "run test for specified architecture")
func testGoArch() string {
if *testGoArchFlag == "" {
return runtime.GOARCH
}
return *testGoArchFlag
}
func hasRegisterABI() bool {
switch testGoArch() {
case "amd64", "arm64", "ppc64", "ppc64le", "riscv":
return true
}
return false
}
func unixOnly(t *testing.T) {
if runtime.GOOS != "linux" && runtime.GOOS != "darwin" { // in particular, it could be windows.
t.Skip("this test depends on creating a file with a wonky name, only works for sure on Linux and Darwin")
}
}
// testDebugLinesDefault removes the first wanted statement on architectures that are not (yet) register ABI.
func testDebugLinesDefault(t *testing.T, gcflags, file, function string, wantStmts []int, ignoreRepeats bool) {
unixOnly(t)
if !hasRegisterABI() {
wantStmts = wantStmts[1:]
}
testDebugLines(t, gcflags, file, function, wantStmts, ignoreRepeats)
}
func TestDebugLinesSayHi(t *testing.T) {
// This test is potentially fragile, the goal is that debugging should step properly through "sayhi"
// If the blocks are reordered in a way that changes the statement order but execution flows correctly,
// then rearrange the expected numbers. Register abi and not-register-abi also have different sequences,
// at least for now.
testDebugLinesDefault(t, "-N -l", "sayhi.go", "sayhi", []int{8, 9, 10, 11}, false)
}
func TestDebugLinesPushback(t *testing.T) {
unixOnly(t)
switch testGoArch() {
default:
t.Skip("skipped for many architectures")
case "arm64", "amd64": // register ABI
fn := "(*List[go.shape.int_0]).PushBack"
if true /* was buildcfg.Experiment.Unified */ {
// Unified mangles differently
fn = "(*List[go.shape.int]).PushBack"
}
testDebugLines(t, "-N -l", "pushback.go", fn, []int{17, 18, 19, 20, 21, 22, 24}, true)
}
}
func TestDebugLinesConvert(t *testing.T) {
unixOnly(t)
switch testGoArch() {
default:
t.Skip("skipped for many architectures")
case "arm64", "amd64": // register ABI
fn := "G[go.shape.int_0]"
if true /* was buildcfg.Experiment.Unified */ {
// Unified mangles differently
fn = "G[go.shape.int]"
}
testDebugLines(t, "-N -l", "convertline.go", fn, []int{9, 10, 11}, true)
}
}
func TestInlineLines(t *testing.T) {
if runtime.GOARCH != "amd64" && *testGoArchFlag == "" {
// As of september 2021, works for everything except mips64, but still potentially fragile
t.Skip("only runs for amd64 unless -arch explicitly supplied")
}
want := [][]int{{3}, {3}, {4, 10}, {4, 10, 16}, {4, 10}, {4, 11, 16}, {4, 11}, {4}, {5, 10}, {5, 10, 16}, {5, 10}, {5, 11, 16}, {5, 11}, {5}}
testInlineStack(t, "inline-dump.go", "f", want)
}
func TestDebugLines_53456(t *testing.T) {
testDebugLinesDefault(t, "-N -l", "b53456.go", "(*T).Inc", []int{15, 16, 17, 18}, true)
}
func compileAndDump(t *testing.T, file, function, moreGCFlags string) []byte {
testenv.MustHaveGoBuild(t)
tmpdir, err := os.MkdirTemp("", "debug_lines_test")
if err != nil {
panic(fmt.Sprintf("Problem creating TempDir, error %v", err))
}
if testing.Verbose() {
fmt.Printf("Preserving temporary directory %s\n", tmpdir)
} else {
defer os.RemoveAll(tmpdir)
}
source, err := filepath.Abs(filepath.Join("testdata", file))
if err != nil {
panic(fmt.Sprintf("Could not get abspath of testdata directory and file, %v", err))
}
cmd := testenv.Command(t, testenv.GoToolPath(t), "build", "-o", "foo.o", "-gcflags=-d=ssa/genssa/dump="+function+" "+moreGCFlags, source)
cmd.Dir = tmpdir
cmd.Env = replaceEnv(cmd.Env, "GOSSADIR", tmpdir)
testGoos := "linux" // default to linux
if testGoArch() == "wasm" {
testGoos = "js"
}
cmd.Env = replaceEnv(cmd.Env, "GOOS", testGoos)
cmd.Env = replaceEnv(cmd.Env, "GOARCH", testGoArch())
if testing.Verbose() {
fmt.Printf("About to run %s\n", asCommandLine("", cmd))
}
var stdout, stderr strings.Builder
cmd.Stdout = &stdout
cmd.Stderr = &stderr
if err := cmd.Run(); err != nil {
t.Fatalf("error running cmd %s: %v\nstdout:\n%sstderr:\n%s\n", asCommandLine("", cmd), err, stdout.String(), stderr.String())
}
if s := stderr.String(); s != "" {
t.Fatalf("Wanted empty stderr, instead got:\n%s\n", s)
}
dumpFile := filepath.Join(tmpdir, function+"_01__genssa.dump")
dumpBytes, err := os.ReadFile(dumpFile)
if err != nil {
t.Fatalf("Could not read dump file %s, err=%v", dumpFile, err)
}
return dumpBytes
}
func sortInlineStacks(x [][]int) {
sort.Slice(x, func(i, j int) bool {
if len(x[i]) != len(x[j]) {
return len(x[i]) < len(x[j])
}
for k := range x[i] {
if x[i][k] != x[j][k] {
return x[i][k] < x[j][k]
}
}
return false
})
}
// testInlineStack ensures that inlining is described properly in the comments in the dump file
func testInlineStack(t *testing.T, file, function string, wantStacks [][]int) {
// this is an inlining reporting test, not an optimization test. -N makes it less fragile
dumpBytes := compileAndDump(t, file, function, "-N")
dump := bufio.NewScanner(bytes.NewReader(dumpBytes))
dumpLineNum := 0
var gotStmts []int
var gotStacks [][]int
for dump.Scan() {
line := dump.Text()
dumpLineNum++
matches := inlineLine.FindStringSubmatch(line)
if len(matches) == 2 {
stmt, err := strconv.ParseInt(matches[1], 10, 32)
if err != nil {
t.Fatalf("Expected to parse a line number but saw %s instead on dump line #%d, error %v", matches[1], dumpLineNum, err)
}
if testing.Verbose() {
fmt.Printf("Saw stmt# %d for submatch '%s' on dump line #%d = '%s'\n", stmt, matches[1], dumpLineNum, line)
}
gotStmts = append(gotStmts, int(stmt))
} else if len(gotStmts) > 0 {
gotStacks = append(gotStacks, gotStmts)
gotStmts = nil
}
}
if len(gotStmts) > 0 {
gotStacks = append(gotStacks, gotStmts)
gotStmts = nil
}
sortInlineStacks(gotStacks)
sortInlineStacks(wantStacks)
if !reflect.DeepEqual(wantStacks, gotStacks) {
t.Errorf("wanted inlines %+v but got %+v\n%s", wantStacks, gotStacks, dumpBytes)
}
}
// testDebugLines compiles testdata/<file> with flags -N -l and -d=ssa/genssa/dump=<function>
// then verifies that the statement-marked lines in that file are the same as those in wantStmts
// These files must all be short because this is super-fragile.
// "go build" is run in a temporary directory that is normally deleted, unless -test.v
func testDebugLines(t *testing.T, gcflags, file, function string, wantStmts []int, ignoreRepeats bool) {
dumpBytes := compileAndDump(t, file, function, gcflags)
dump := bufio.NewScanner(bytes.NewReader(dumpBytes))
var gotStmts []int
dumpLineNum := 0
for dump.Scan() {
line := dump.Text()
dumpLineNum++
matches := asmLine.FindStringSubmatch(line)
if len(matches) == 2 {
stmt, err := strconv.ParseInt(matches[1], 10, 32)
if err != nil {
t.Fatalf("Expected to parse a line number but saw %s instead on dump line #%d, error %v", matches[1], dumpLineNum, err)
}
if testing.Verbose() {
fmt.Printf("Saw stmt# %d for submatch '%s' on dump line #%d = '%s'\n", stmt, matches[1], dumpLineNum, line)
}
gotStmts = append(gotStmts, int(stmt))
}
}
if ignoreRepeats { // remove repeats from gotStmts
newGotStmts := []int{gotStmts[0]}
for _, x := range gotStmts {
if x != newGotStmts[len(newGotStmts)-1] {
newGotStmts = append(newGotStmts, x)
}
}
if !reflect.DeepEqual(wantStmts, newGotStmts) {
t.Errorf("wanted stmts %v but got %v (with repeats still in: %v)", wantStmts, newGotStmts, gotStmts)
}
} else {
if !reflect.DeepEqual(wantStmts, gotStmts) {
t.Errorf("wanted stmts %v but got %v", wantStmts, gotStmts)
}
}
}