Home | History | Annotate | Download | only in dwarf 
      1 // Copyright 2015 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 dwarf_test
      6 
      7 import (
      8 	. "debug/dwarf"
      9 	"io"
     10 	"strings"
     11 	"testing"
     12 )
     13 
     14 var (
     15 	file1C = &LineFile{Name: "/home/austin/go.dev/src/debug/dwarf/testdata/line1.c"}
     16 	file1H = &LineFile{Name: "/home/austin/go.dev/src/debug/dwarf/testdata/line1.h"}
     17 	file2C = &LineFile{Name: "/home/austin/go.dev/src/debug/dwarf/testdata/line2.c"}
     18 )
     19 
     20 func TestLineELFGCC(t *testing.T) {
     21 	// Generated by:
     22 	//   # gcc --version | head -n1
     23 	//   gcc (Ubuntu 4.8.2-19ubuntu1) 4.8.2
     24 	//   # gcc -g -o line-gcc.elf line*.c
     25 
     26 	// Line table based on readelf --debug-dump=rawline,decodedline
     27 	want := []LineEntry{
     28 		{Address: 0x40059d, File: file1H, Line: 2, IsStmt: true},
     29 		{Address: 0x4005a5, File: file1H, Line: 2, IsStmt: true},
     30 		{Address: 0x4005b4, File: file1H, Line: 5, IsStmt: true},
     31 		{Address: 0x4005bd, File: file1H, Line: 6, IsStmt: true, Discriminator: 2},
     32 		{Address: 0x4005c7, File: file1H, Line: 5, IsStmt: true, Discriminator: 2},
     33 		{Address: 0x4005cb, File: file1H, Line: 5, IsStmt: false, Discriminator: 1},
     34 		{Address: 0x4005d1, File: file1H, Line: 7, IsStmt: true},
     35 		{Address: 0x4005e7, File: file1C, Line: 6, IsStmt: true},
     36 		{Address: 0x4005eb, File: file1C, Line: 7, IsStmt: true},
     37 		{Address: 0x4005f5, File: file1C, Line: 8, IsStmt: true},
     38 		{Address: 0x4005ff, File: file1C, Line: 9, IsStmt: true},
     39 		{Address: 0x400601, EndSequence: true},
     40 
     41 		{Address: 0x400601, File: file2C, Line: 4, IsStmt: true},
     42 		{Address: 0x400605, File: file2C, Line: 5, IsStmt: true},
     43 		{Address: 0x40060f, File: file2C, Line: 6, IsStmt: true},
     44 		{Address: 0x400611, EndSequence: true},
     45 	}
     46 
     47 	testLineTable(t, want, elfData(t, "testdata/line-gcc.elf"))
     48 }
     49 
     50 func TestLineGCCWindows(t *testing.T) {
     51 	// Generated by:
     52 	//   > gcc --version
     53 	//   gcc (tdm64-1) 4.9.2
     54 	//   > gcc -g -o line-gcc-win.bin line1.c C:\workdir\go\src\debug\dwarf\testdata\line2.c
     55 
     56 	toWindows := func(lf *LineFile) *LineFile {
     57 		lf2 := *lf
     58 		lf2.Name = strings.Replace(lf2.Name, "/home/austin/go.dev/", "C:\\workdir\\go\\", -1)
     59 		lf2.Name = strings.Replace(lf2.Name, "/", "\\", -1)
     60 		return &lf2
     61 	}
     62 	file1C := toWindows(file1C)
     63 	file1H := toWindows(file1H)
     64 	file2C := toWindows(file2C)
     65 
     66 	// Line table based on objdump --dwarf=rawline,decodedline
     67 	want := []LineEntry{
     68 		{Address: 0x401530, File: file1H, Line: 2, IsStmt: true},
     69 		{Address: 0x401538, File: file1H, Line: 5, IsStmt: true},
     70 		{Address: 0x401541, File: file1H, Line: 6, IsStmt: true, Discriminator: 3},
     71 		{Address: 0x40154b, File: file1H, Line: 5, IsStmt: true, Discriminator: 3},
     72 		{Address: 0x40154f, File: file1H, Line: 5, IsStmt: false, Discriminator: 1},
     73 		{Address: 0x401555, File: file1H, Line: 7, IsStmt: true},
     74 		{Address: 0x40155b, File: file1C, Line: 6, IsStmt: true},
     75 		{Address: 0x401563, File: file1C, Line: 6, IsStmt: true},
     76 		{Address: 0x401568, File: file1C, Line: 7, IsStmt: true},
     77 		{Address: 0x40156d, File: file1C, Line: 8, IsStmt: true},
     78 		{Address: 0x401572, File: file1C, Line: 9, IsStmt: true},
     79 		{Address: 0x401578, EndSequence: true},
     80 
     81 		{Address: 0x401580, File: file2C, Line: 4, IsStmt: true},
     82 		{Address: 0x401588, File: file2C, Line: 5, IsStmt: true},
     83 		{Address: 0x401595, File: file2C, Line: 6, IsStmt: true},
     84 		{Address: 0x40159b, EndSequence: true},
     85 	}
     86 
     87 	testLineTable(t, want, peData(t, "testdata/line-gcc-win.bin"))
     88 }
     89 
     90 func TestLineELFClang(t *testing.T) {
     91 	// Generated by:
     92 	//   # clang --version | head -n1
     93 	//   Ubuntu clang version 3.4-1ubuntu3 (tags/RELEASE_34/final) (based on LLVM 3.4)
     94 	//   # clang -g -o line-clang.elf line*.
     95 
     96 	want := []LineEntry{
     97 		{Address: 0x400530, File: file1C, Line: 6, IsStmt: true},
     98 		{Address: 0x400534, File: file1C, Line: 7, IsStmt: true, PrologueEnd: true},
     99 		{Address: 0x400539, File: file1C, Line: 8, IsStmt: true},
    100 		{Address: 0x400545, File: file1C, Line: 9, IsStmt: true},
    101 		{Address: 0x400550, File: file1H, Line: 2, IsStmt: true},
    102 		{Address: 0x400554, File: file1H, Line: 5, IsStmt: true, PrologueEnd: true},
    103 		{Address: 0x400568, File: file1H, Line: 6, IsStmt: true},
    104 		{Address: 0x400571, File: file1H, Line: 5, IsStmt: true},
    105 		{Address: 0x400581, File: file1H, Line: 7, IsStmt: true},
    106 		{Address: 0x400583, EndSequence: true},
    107 
    108 		{Address: 0x400590, File: file2C, Line: 4, IsStmt: true},
    109 		{Address: 0x4005a0, File: file2C, Line: 5, IsStmt: true, PrologueEnd: true},
    110 		{Address: 0x4005a7, File: file2C, Line: 6, IsStmt: true},
    111 		{Address: 0x4005b0, EndSequence: true},
    112 	}
    113 
    114 	testLineTable(t, want, elfData(t, "testdata/line-clang.elf"))
    115 }
    116 
    117 func TestLineSeek(t *testing.T) {
    118 	d := elfData(t, "testdata/line-gcc.elf")
    119 
    120 	// Get the line table for the first CU.
    121 	cu, err := d.Reader().Next()
    122 	if err != nil {
    123 		t.Fatal("d.Reader().Next:", err)
    124 	}
    125 	lr, err := d.LineReader(cu)
    126 	if err != nil {
    127 		t.Fatal("d.LineReader:", err)
    128 	}
    129 
    130 	// Read entries forward.
    131 	var line LineEntry
    132 	var posTable []LineReaderPos
    133 	var table []LineEntry
    134 	for {
    135 		posTable = append(posTable, lr.Tell())
    136 
    137 		err := lr.Next(&line)
    138 		if err != nil {
    139 			if err == io.EOF {
    140 				break
    141 			}
    142 			t.Fatal("lr.Next:", err)
    143 		}
    144 		table = append(table, line)
    145 	}
    146 
    147 	// Test that Reset returns to the first line.
    148 	lr.Reset()
    149 	if err := lr.Next(&line); err != nil {
    150 		t.Fatal("lr.Next after Reset failed:", err)
    151 	} else if line != table[0] {
    152 		t.Fatal("lr.Next after Reset returned", line, "instead of", table[0])
    153 	}
    154 
    155 	// Check that entries match when seeking backward.
    156 	for i := len(posTable) - 1; i >= 0; i-- {
    157 		lr.Seek(posTable[i])
    158 		err := lr.Next(&line)
    159 		if i == len(posTable)-1 {
    160 			if err != io.EOF {
    161 				t.Fatal("expected io.EOF after seek to end, got", err)
    162 			}
    163 		} else if err != nil {
    164 			t.Fatal("lr.Next after seek to", posTable[i], "failed:", err)
    165 		} else if line != table[i] {
    166 			t.Fatal("lr.Next after seek to", posTable[i], "returned", line, "instead of", table[i])
    167 		}
    168 	}
    169 
    170 	// Check that seeking to a PC returns the right line.
    171 	if err := lr.SeekPC(table[0].Address-1, &line); err != ErrUnknownPC {
    172 		t.Fatalf("lr.SeekPC to %#x returned %v instead of ErrUnknownPC", table[0].Address-1, err)
    173 	}
    174 	for i, testLine := range table {
    175 		if testLine.EndSequence {
    176 			if err := lr.SeekPC(testLine.Address, &line); err != ErrUnknownPC {
    177 				t.Fatalf("lr.SeekPC to %#x returned %v instead of ErrUnknownPC", testLine.Address, err)
    178 			}
    179 			continue
    180 		}
    181 
    182 		nextPC := table[i+1].Address
    183 		for pc := testLine.Address; pc < nextPC; pc++ {
    184 			if err := lr.SeekPC(pc, &line); err != nil {
    185 				t.Fatalf("lr.SeekPC to %#x failed: %v", pc, err)
    186 			} else if line != testLine {
    187 				t.Fatalf("lr.SeekPC to %#x returned %v instead of %v", pc, line, testLine)
    188 			}
    189 		}
    190 	}
    191 }
    192 
    193 func testLineTable(t *testing.T, want []LineEntry, d *Data) {
    194 	// Get line table from d.
    195 	var got []LineEntry
    196 	dr := d.Reader()
    197 	for {
    198 		ent, err := dr.Next()
    199 		if err != nil {
    200 			t.Fatal("dr.Next:", err)
    201 		} else if ent == nil {
    202 			break
    203 		}
    204 
    205 		if ent.Tag != TagCompileUnit {
    206 			dr.SkipChildren()
    207 			continue
    208 		}
    209 
    210 		// Decode CU's line table.
    211 		lr, err := d.LineReader(ent)
    212 		if err != nil {
    213 			t.Fatal("d.LineReader:", err)
    214 		} else if lr == nil {
    215 			continue
    216 		}
    217 
    218 		for {
    219 			var line LineEntry
    220 			err := lr.Next(&line)
    221 			if err != nil {
    222 				if err == io.EOF {
    223 					break
    224 				}
    225 				t.Fatal("lr.Next:", err)
    226 			}
    227 			// Ignore sources from the Windows build environment.
    228 			if strings.HasPrefix(line.File.Name, "C:\\crossdev\\") ||
    229 				strings.HasPrefix(line.File.Name, "C:/crossdev/") {
    230 				continue
    231 			}
    232 			got = append(got, line)
    233 		}
    234 	}
    235 
    236 	// Compare line tables.
    237 	if !compareLines(got, want) {
    238 		t.Log("Line tables do not match. Got:")
    239 		dumpLines(t, got)
    240 		t.Log("Want:")
    241 		dumpLines(t, want)
    242 		t.FailNow()
    243 	}
    244 }
    245 
    246 func compareLines(a, b []LineEntry) bool {
    247 	if len(a) != len(b) {
    248 		return false
    249 	}
    250 
    251 	for i := range a {
    252 		al, bl := a[i], b[i]
    253 		// If both are EndSequence, then the only other valid
    254 		// field is Address. Otherwise, test equality of all
    255 		// fields.
    256 		if al.EndSequence && bl.EndSequence && al.Address == bl.Address {
    257 			continue
    258 		}
    259 		if al.File.Name != bl.File.Name {
    260 			return false
    261 		}
    262 		al.File = nil
    263 		bl.File = nil
    264 		if al != bl {
    265 			return false
    266 		}
    267 	}
    268 	return true
    269 }
    270 
    271 func dumpLines(t *testing.T, lines []LineEntry) {
    272 	for _, l := range lines {
    273 		t.Logf("  %+v File:%+v", l, l.File)
    274 	}
    275 }
    276 
    277 type joinTest struct {
    278 	dirname, filename string
    279 	path              string
    280 }
    281 
    282 var joinTests = []joinTest{
    283 	{"a", "b", "a/b"},
    284 	{"a", "", "a"},
    285 	{"", "b", "b"},
    286 	{"/a", "b", "/a/b"},
    287 	{"/a/", "b", "/a/b"},
    288 
    289 	{`C:\Windows\`, `System32`, `C:\Windows\System32`},
    290 	{`C:\Windows\`, ``, `C:\Windows\`},
    291 	{`C:\`, `Windows`, `C:\Windows`},
    292 	{`C:\Windows\`, `C:System32`, `C:\Windows\System32`},
    293 	{`C:\Windows`, `a/b`, `C:\Windows\a/b`},
    294 	{`\\host\share\`, `foo`, `\\host\share\foo`},
    295 	{`\\host\share\`, `foo\bar`, `\\host\share\foo\bar`},
    296 	{`//host/share/`, `foo/bar`, `//host/share/foo/bar`},
    297 
    298 	// The following are "best effort". We shouldn't see relative
    299 	// base directories in DWARF, but these test that pathJoin
    300 	// doesn't fail miserably if it sees one.
    301 	{`C:`, `a`, `C:a`},
    302 	{`C:`, `a\b`, `C:a\b`},
    303 	{`C:.`, `a`, `C:.\a`},
    304 	{`C:a`, `b`, `C:a\b`},
    305 }
    306 
    307 func TestPathJoin(t *testing.T) {
    308 	for _, test := range joinTests {
    309 		got := PathJoin(test.dirname, test.filename)
    310 		if test.path != got {
    311 			t.Errorf("pathJoin(%q, %q) = %q, want %q", test.dirname, test.filename, got, test.path)
    312 		}
    313 	}
    314 }
    315