pclntab_test.go

Documentation: debug/gosym

		 1  // Copyright 2009 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  package gosym
		 6  
		 7  import (
		 8  	"bytes"
		 9  	"compress/gzip"
		10  	"debug/elf"
		11  	"internal/testenv"
		12  	"io"
		13  	"os"
		14  	"os/exec"
		15  	"path/filepath"
		16  	"runtime"
		17  	"strings"
		18  	"testing"
		19  )
		20  
		21  var (
		22  	pclineTempDir		string
		23  	pclinetestBinary string
		24  )
		25  
		26  func dotest(t *testing.T) {
		27  	testenv.MustHaveGoBuild(t)
		28  	// For now, only works on amd64 platforms.
		29  	if runtime.GOARCH != "amd64" {
		30  		t.Skipf("skipping on non-AMD64 system %s", runtime.GOARCH)
		31  	}
		32  	var err error
		33  	pclineTempDir, err = os.MkdirTemp("", "pclinetest")
		34  	if err != nil {
		35  		t.Fatal(err)
		36  	}
		37  	pclinetestBinary = filepath.Join(pclineTempDir, "pclinetest")
		38  	cmd := exec.Command(testenv.GoToolPath(t), "build", "-o", pclinetestBinary)
		39  	cmd.Dir = "testdata"
		40  	cmd.Env = append(os.Environ(), "GOOS=linux")
		41  	cmd.Stdout = os.Stdout
		42  	cmd.Stderr = os.Stderr
		43  	if err := cmd.Run(); err != nil {
		44  		t.Fatal(err)
		45  	}
		46  }
		47  
		48  func endtest() {
		49  	if pclineTempDir != "" {
		50  		os.RemoveAll(pclineTempDir)
		51  		pclineTempDir = ""
		52  		pclinetestBinary = ""
		53  	}
		54  }
		55  
		56  // skipIfNotELF skips the test if we are not running on an ELF system.
		57  // These tests open and examine the test binary, and use elf.Open to do so.
		58  func skipIfNotELF(t *testing.T) {
		59  	switch runtime.GOOS {
		60  	case "dragonfly", "freebsd", "linux", "netbsd", "openbsd", "solaris", "illumos":
		61  		// OK.
		62  	default:
		63  		t.Skipf("skipping on non-ELF system %s", runtime.GOOS)
		64  	}
		65  }
		66  
		67  func getTable(t *testing.T) *Table {
		68  	f, tab := crack(os.Args[0], t)
		69  	f.Close()
		70  	return tab
		71  }
		72  
		73  func crack(file string, t *testing.T) (*elf.File, *Table) {
		74  	// Open self
		75  	f, err := elf.Open(file)
		76  	if err != nil {
		77  		t.Fatal(err)
		78  	}
		79  	return parse(file, f, t)
		80  }
		81  
		82  func parse(file string, f *elf.File, t *testing.T) (*elf.File, *Table) {
		83  	s := f.Section(".gosymtab")
		84  	if s == nil {
		85  		t.Skip("no .gosymtab section")
		86  	}
		87  	symdat, err := s.Data()
		88  	if err != nil {
		89  		f.Close()
		90  		t.Fatalf("reading %s gosymtab: %v", file, err)
		91  	}
		92  	pclndat, err := f.Section(".gopclntab").Data()
		93  	if err != nil {
		94  		f.Close()
		95  		t.Fatalf("reading %s gopclntab: %v", file, err)
		96  	}
		97  
		98  	pcln := NewLineTable(pclndat, f.Section(".text").Addr)
		99  	tab, err := NewTable(symdat, pcln)
	 100  	if err != nil {
	 101  		f.Close()
	 102  		t.Fatalf("parsing %s gosymtab: %v", file, err)
	 103  	}
	 104  
	 105  	return f, tab
	 106  }
	 107  
	 108  func TestLineFromAline(t *testing.T) {
	 109  	skipIfNotELF(t)
	 110  
	 111  	tab := getTable(t)
	 112  	if tab.go12line != nil {
	 113  		// aline's don't exist in the Go 1.2 table.
	 114  		t.Skip("not relevant to Go 1.2 symbol table")
	 115  	}
	 116  
	 117  	// Find the sym package
	 118  	pkg := tab.LookupFunc("debug/gosym.TestLineFromAline").Obj
	 119  	if pkg == nil {
	 120  		t.Fatalf("nil pkg")
	 121  	}
	 122  
	 123  	// Walk every absolute line and ensure that we hit every
	 124  	// source line monotonically
	 125  	lastline := make(map[string]int)
	 126  	final := -1
	 127  	for i := 0; i < 10000; i++ {
	 128  		path, line := pkg.lineFromAline(i)
	 129  		// Check for end of object
	 130  		if path == "" {
	 131  			if final == -1 {
	 132  				final = i - 1
	 133  			}
	 134  			continue
	 135  		} else if final != -1 {
	 136  			t.Fatalf("reached end of package at absolute line %d, but absolute line %d mapped to %s:%d", final, i, path, line)
	 137  		}
	 138  		// It's okay to see files multiple times (e.g., sys.a)
	 139  		if line == 1 {
	 140  			lastline[path] = 1
	 141  			continue
	 142  		}
	 143  		// Check that the is the next line in path
	 144  		ll, ok := lastline[path]
	 145  		if !ok {
	 146  			t.Errorf("file %s starts on line %d", path, line)
	 147  		} else if line != ll+1 {
	 148  			t.Fatalf("expected next line of file %s to be %d, got %d", path, ll+1, line)
	 149  		}
	 150  		lastline[path] = line
	 151  	}
	 152  	if final == -1 {
	 153  		t.Errorf("never reached end of object")
	 154  	}
	 155  }
	 156  
	 157  func TestLineAline(t *testing.T) {
	 158  	skipIfNotELF(t)
	 159  
	 160  	tab := getTable(t)
	 161  	if tab.go12line != nil {
	 162  		// aline's don't exist in the Go 1.2 table.
	 163  		t.Skip("not relevant to Go 1.2 symbol table")
	 164  	}
	 165  
	 166  	for _, o := range tab.Files {
	 167  		// A source file can appear multiple times in a
	 168  		// object.	alineFromLine will always return alines in
	 169  		// the first file, so track which lines we've seen.
	 170  		found := make(map[string]int)
	 171  		for i := 0; i < 1000; i++ {
	 172  			path, line := o.lineFromAline(i)
	 173  			if path == "" {
	 174  				break
	 175  			}
	 176  
	 177  			// cgo files are full of 'Z' symbols, which we don't handle
	 178  			if len(path) > 4 && path[len(path)-4:] == ".cgo" {
	 179  				continue
	 180  			}
	 181  
	 182  			if minline, ok := found[path]; path != "" && ok {
	 183  				if minline >= line {
	 184  					// We've already covered this file
	 185  					continue
	 186  				}
	 187  			}
	 188  			found[path] = line
	 189  
	 190  			a, err := o.alineFromLine(path, line)
	 191  			if err != nil {
	 192  				t.Errorf("absolute line %d in object %s maps to %s:%d, but mapping that back gives error %s", i, o.Paths[0].Name, path, line, err)
	 193  			} else if a != i {
	 194  				t.Errorf("absolute line %d in object %s maps to %s:%d, which maps back to absolute line %d\n", i, o.Paths[0].Name, path, line, a)
	 195  			}
	 196  		}
	 197  	}
	 198  }
	 199  
	 200  func TestPCLine(t *testing.T) {
	 201  	if testing.Short() {
	 202  		t.Skip("skipping in -short mode")
	 203  	}
	 204  	dotest(t)
	 205  	defer endtest()
	 206  
	 207  	f, tab := crack(pclinetestBinary, t)
	 208  	defer f.Close()
	 209  	text := f.Section(".text")
	 210  	textdat, err := text.Data()
	 211  	if err != nil {
	 212  		t.Fatalf("reading .text: %v", err)
	 213  	}
	 214  
	 215  	// Test PCToLine
	 216  	sym := tab.LookupFunc("main.linefrompc")
	 217  	wantLine := 0
	 218  	for pc := sym.Entry; pc < sym.End; pc++ {
	 219  		off := pc - text.Addr // TODO(rsc): should not need off; bug in 8g
	 220  		if textdat[off] == 255 {
	 221  			break
	 222  		}
	 223  		wantLine += int(textdat[off])
	 224  		t.Logf("off is %d %#x (max %d)", off, textdat[off], sym.End-pc)
	 225  		file, line, fn := tab.PCToLine(pc)
	 226  		if fn == nil {
	 227  			t.Errorf("failed to get line of PC %#x", pc)
	 228  		} else if !strings.HasSuffix(file, "pclinetest.s") || line != wantLine || fn != sym {
	 229  			t.Errorf("PCToLine(%#x) = %s:%d (%s), want %s:%d (%s)", pc, file, line, fn.Name, "pclinetest.s", wantLine, sym.Name)
	 230  		}
	 231  	}
	 232  
	 233  	// Test LineToPC
	 234  	sym = tab.LookupFunc("main.pcfromline")
	 235  	lookupline := -1
	 236  	wantLine = 0
	 237  	off := uint64(0) // TODO(rsc): should not need off; bug in 8g
	 238  	for pc := sym.Value; pc < sym.End; pc += 2 + uint64(textdat[off]) {
	 239  		file, line, fn := tab.PCToLine(pc)
	 240  		off = pc - text.Addr
	 241  		if textdat[off] == 255 {
	 242  			break
	 243  		}
	 244  		wantLine += int(textdat[off])
	 245  		if line != wantLine {
	 246  			t.Errorf("expected line %d at PC %#x in pcfromline, got %d", wantLine, pc, line)
	 247  			off = pc + 1 - text.Addr
	 248  			continue
	 249  		}
	 250  		if lookupline == -1 {
	 251  			lookupline = line
	 252  		}
	 253  		for ; lookupline <= line; lookupline++ {
	 254  			pc2, fn2, err := tab.LineToPC(file, lookupline)
	 255  			if lookupline != line {
	 256  				// Should be nothing on this line
	 257  				if err == nil {
	 258  					t.Errorf("expected no PC at line %d, got %#x (%s)", lookupline, pc2, fn2.Name)
	 259  				}
	 260  			} else if err != nil {
	 261  				t.Errorf("failed to get PC of line %d: %s", lookupline, err)
	 262  			} else if pc != pc2 {
	 263  				t.Errorf("expected PC %#x (%s) at line %d, got PC %#x (%s)", pc, fn.Name, line, pc2, fn2.Name)
	 264  			}
	 265  		}
	 266  		off = pc + 1 - text.Addr
	 267  	}
	 268  }
	 269  
	 270  // Test that we can parse a pclntab from 1.15.
	 271  // The file was compiled in /tmp/hello.go:
	 272  // [BEGIN]
	 273  // package main
	 274  //
	 275  // func main() {
	 276  //		println("hello")
	 277  // }
	 278  // [END]
	 279  func Test115PclnParsing(t *testing.T) {
	 280  	zippedDat, err := os.ReadFile("testdata/pcln115.gz")
	 281  	if err != nil {
	 282  		t.Fatal(err)
	 283  	}
	 284  	var gzReader *gzip.Reader
	 285  	gzReader, err = gzip.NewReader(bytes.NewBuffer(zippedDat))
	 286  	if err != nil {
	 287  		t.Fatal(err)
	 288  	}
	 289  	var dat []byte
	 290  	dat, err = io.ReadAll(gzReader)
	 291  	if err != nil {
	 292  		t.Fatal(err)
	 293  	}
	 294  	const textStart = 0x1001000
	 295  	pcln := NewLineTable(dat, textStart)
	 296  	var tab *Table
	 297  	tab, err = NewTable(nil, pcln)
	 298  	if err != nil {
	 299  		t.Fatal(err)
	 300  	}
	 301  	var f *Func
	 302  	var pc uint64
	 303  	pc, f, err = tab.LineToPC("/tmp/hello.go", 3)
	 304  	if err != nil {
	 305  		t.Fatal(err)
	 306  	}
	 307  	if pcln.version != ver12 {
	 308  		t.Fatal("Expected pcln to parse as an older version")
	 309  	}
	 310  	if pc != 0x105c280 {
	 311  		t.Fatalf("expect pc = 0x105c280, got 0x%x", pc)
	 312  	}
	 313  	if f.Name != "main.main" {
	 314  		t.Fatalf("expected to parse name as main.main, got %v", f.Name)
	 315  	}
	 316  }
	 317
View as plain text