src/debug/dwarf/line_test.go

   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         files := [][]*LineFile{{nil, file1H, file1C}, {nil, file2C}}
  47
  48         testLineTable(t, want, files, elfData(t, "testdata/line-gcc.elf"))
  49 }
  50
  51 func TestLineELFGCCZstd(t *testing.T) {
  52         // Generated by:
  53         //   # gcc --version | head -n1
  54         //   gcc (Debian 12.2.0-10) 12.2.0
  55         //   # gcc -g -no-pie -Wl,--compress-debug-sections=zstd line*.c
  56
  57         zfile1H := &LineFile{Name: "/home/iant/go/src/debug/dwarf/testdata/line1.h"}
  58         zfile1C := &LineFile{Name: "/home/iant/go/src/debug/dwarf/testdata/line1.c"}
  59         zfile2C := &LineFile{Name: "/home/iant/go/src/debug/dwarf/testdata/line2.c"}
  60
  61         // Line table based on readelf --debug-dump=rawline,decodedline
  62         want := []LineEntry{
  63                 {Address: 0x401126, File: zfile1H, Line: 2, Column: 1, IsStmt: true},
  64                 {Address: 0x40112a, File: zfile1H, Line: 5, Column: 8, IsStmt: true},
  65                 {Address: 0x401131, File: zfile1H, Line: 5, Column: 2, IsStmt: true},
  66                 {Address: 0x401133, File: zfile1H, Line: 6, Column: 10, IsStmt: true, Discriminator: 3},
  67                 {Address: 0x40113d, File: zfile1H, Line: 5, Column: 22, IsStmt: true, Discriminator: 3},
  68                 {Address: 0x401141, File: zfile1H, Line: 5, Column: 15, IsStmt: true, Discriminator: 1},
  69                 {Address: 0x401147, File: zfile1H, Line: 7, Column: 1, IsStmt: true},
  70                 {Address: 0x40114b, File: zfile1C, Line: 6, Column: 1, IsStmt: true},
  71                 {Address: 0x40114f, File: zfile1C, Line: 7, Column: 2, IsStmt: true},
  72                 {Address: 0x401159, File: zfile1C, Line: 8, Column: 2, IsStmt: true},
  73                 {Address: 0x401168, File: zfile1C, Line: 9, Column: 1, IsStmt: true},
  74                 {Address: 0x40116a, EndSequence: true},
  75
  76                 {Address: 0x40116a, File: zfile2C, Line: 4, Column: 1, IsStmt: true},
  77                 {Address: 0x40116e, File: zfile2C, Line: 5, Column: 2, IsStmt: true},
  78                 {Address: 0x40117d, File: zfile2C, Line: 6, Column: 1, IsStmt: true},
  79                 {Address: 0x401180, EndSequence: true},
  80         }
  81         files := [][]*LineFile{
  82                 {zfile1C, zfile1H, zfile1C},
  83                 {zfile2C, zfile2C},
  84         }
  85
  86         testLineTable(t, want, files, elfData(t, "testdata/line-gcc-zstd.elf"))
  87 }
  88
  89 func TestLineGCCWindows(t *testing.T) {
  90         // Generated by:
  91         //   > gcc --version
  92         //   gcc (tdm64-1) 4.9.2
  93         //   > gcc -g -o line-gcc-win.bin line1.c C:\workdir\go\src\debug\dwarf\testdata\line2.c
  94
  95         toWindows := func(lf *LineFile) *LineFile {
  96                 lf2 := *lf
  97                 lf2.Name = strings.Replace(lf2.Name, "/home/austin/go.dev/", "C:\\workdir\\go\\", -1)
  98                 lf2.Name = strings.Replace(lf2.Name, "/", "\\", -1)
  99                 return &lf2
 100         }
 101         file1C := toWindows(file1C)
 102         file1H := toWindows(file1H)
 103         file2C := toWindows(file2C)
 104
 105         // Line table based on objdump --dwarf=rawline,decodedline
 106         want := []LineEntry{
 107                 {Address: 0x401530, File: file1H, Line: 2, IsStmt: true},
 108                 {Address: 0x401538, File: file1H, Line: 5, IsStmt: true},
 109                 {Address: 0x401541, File: file1H, Line: 6, IsStmt: true, Discriminator: 3},
 110                 {Address: 0x40154b, File: file1H, Line: 5, IsStmt: true, Discriminator: 3},
 111                 {Address: 0x40154f, File: file1H, Line: 5, IsStmt: false, Discriminator: 1},
 112                 {Address: 0x401555, File: file1H, Line: 7, IsStmt: true},
 113                 {Address: 0x40155b, File: file1C, Line: 6, IsStmt: true},
 114                 {Address: 0x401563, File: file1C, Line: 6, IsStmt: true},
 115                 {Address: 0x401568, File: file1C, Line: 7, IsStmt: true},
 116                 {Address: 0x40156d, File: file1C, Line: 8, IsStmt: true},
 117                 {Address: 0x401572, File: file1C, Line: 9, IsStmt: true},
 118                 {Address: 0x401578, EndSequence: true},
 119
 120                 {Address: 0x401580, File: file2C, Line: 4, IsStmt: true},
 121                 {Address: 0x401588, File: file2C, Line: 5, IsStmt: true},
 122                 {Address: 0x401595, File: file2C, Line: 6, IsStmt: true},
 123                 {Address: 0x40159b, EndSequence: true},
 124         }
 125         files := [][]*LineFile{{nil, file1H, file1C}, {nil, file2C}}
 126
 127         testLineTable(t, want, files, peData(t, "testdata/line-gcc-win.bin"))
 128 }
 129
 130 func TestLineELFClang(t *testing.T) {
 131         // Generated by:
 132         //   # clang --version | head -n1
 133         //   Ubuntu clang version 3.4-1ubuntu3 (tags/RELEASE_34/final) (based on LLVM 3.4)
 134         //   # clang -g -o line-clang.elf line*.
 135
 136         want := []LineEntry{
 137                 {Address: 0x400530, File: file1C, Line: 6, IsStmt: true},
 138                 {Address: 0x400534, File: file1C, Line: 7, IsStmt: true, PrologueEnd: true},
 139                 {Address: 0x400539, File: file1C, Line: 8, IsStmt: true},
 140                 {Address: 0x400545, File: file1C, Line: 9, IsStmt: true},
 141                 {Address: 0x400550, File: file1H, Line: 2, IsStmt: true},
 142                 {Address: 0x400554, File: file1H, Line: 5, IsStmt: true, PrologueEnd: true},
 143                 {Address: 0x400568, File: file1H, Line: 6, IsStmt: true},
 144                 {Address: 0x400571, File: file1H, Line: 5, IsStmt: true},
 145                 {Address: 0x400581, File: file1H, Line: 7, IsStmt: true},
 146                 {Address: 0x400583, EndSequence: true},
 147
 148                 {Address: 0x400590, File: file2C, Line: 4, IsStmt: true},
 149                 {Address: 0x4005a0, File: file2C, Line: 5, IsStmt: true, PrologueEnd: true},
 150                 {Address: 0x4005a7, File: file2C, Line: 6, IsStmt: true},
 151                 {Address: 0x4005b0, EndSequence: true},
 152         }
 153         files := [][]*LineFile{{nil, file1C, file1H}, {nil, file2C}}
 154
 155         testLineTable(t, want, files, elfData(t, "testdata/line-clang.elf"))
 156 }
 157
 158 func TestLineRnglists(t *testing.T) {
 159         // Test a newer file, generated by clang.
 160         file := &LineFile{Name: "/usr/local/google/home/iant/foo.c"}
 161         want := []LineEntry{
 162                 {Address: 0x401020, File: file, Line: 12, IsStmt: true},
 163                 {Address: 0x401020, File: file, Line: 13, Column: 12, IsStmt: true, PrologueEnd: true},
 164                 {Address: 0x401022, File: file, Line: 13, Column: 7},
 165                 {Address: 0x401024, File: file, Line: 17, Column: 1, IsStmt: true},
 166                 {Address: 0x401027, File: file, Line: 16, Column: 10, IsStmt: true},
 167                 {Address: 0x40102c, EndSequence: true},
 168                 {Address: 0x401000, File: file, Line: 2, IsStmt: true},
 169                 {Address: 0x401000, File: file, Line: 6, Column: 17, IsStmt: true, PrologueEnd: true},
 170                 {Address: 0x401002, File: file, Line: 6, Column: 3},
 171                 {Address: 0x401019, File: file, Line: 9, Column: 3, IsStmt: true},
 172                 {Address: 0x40101a, File: file, Line: 0, Column: 3},
 173                 {Address: 0x40101c, File: file, Line: 9, Column: 3},
 174                 {Address: 0x40101d, EndSequence: true},
 175         }
 176         files := [][]*LineFile{{file}}
 177
 178         testLineTable(t, want, files, elfData(t, "testdata/rnglistx.elf"))
 179 }
 180
 181 func TestLineSeek(t *testing.T) {
 182         d := elfData(t, "testdata/line-gcc.elf")
 183
 184         // Get the line table for the first CU.
 185         cu, err := d.Reader().Next()
 186         if err != nil {
 187                 t.Fatal("d.Reader().Next:", err)
 188         }
 189         lr, err := d.LineReader(cu)
 190         if err != nil {
 191                 t.Fatal("d.LineReader:", err)
 192         }
 193
 194         // Read entries forward.
 195         var line LineEntry
 196         var posTable []LineReaderPos
 197         var table []LineEntry
 198         for {
 199                 posTable = append(posTable, lr.Tell())
 200
 201                 err := lr.Next(&line)
 202                 if err != nil {
 203                         if err == io.EOF {
 204                                 break
 205                         }
 206                         t.Fatal("lr.Next:", err)
 207                 }
 208                 table = append(table, line)
 209         }
 210
 211         // Test that Reset returns to the first line.
 212         lr.Reset()
 213         if err := lr.Next(&line); err != nil {
 214                 t.Fatal("lr.Next after Reset failed:", err)
 215         } else if line != table[0] {
 216                 t.Fatal("lr.Next after Reset returned", line, "instead of", table[0])
 217         }
 218
 219         // Check that entries match when seeking backward.
 220         for i := len(posTable) - 1; i >= 0; i-- {
 221                 lr.Seek(posTable[i])
 222                 err := lr.Next(&line)
 223                 if i == len(posTable)-1 {
 224                         if err != io.EOF {
 225                                 t.Fatal("expected io.EOF after seek to end, got", err)
 226                         }
 227                 } else if err != nil {
 228                         t.Fatal("lr.Next after seek to", posTable[i], "failed:", err)
 229                 } else if line != table[i] {
 230                         t.Fatal("lr.Next after seek to", posTable[i], "returned", line, "instead of", table[i])
 231                 }
 232         }
 233
 234         // Check that seeking to a PC returns the right line.
 235         if err := lr.SeekPC(table[0].Address-1, &line); err != ErrUnknownPC {
 236                 t.Fatalf("lr.SeekPC to %#x returned %v instead of ErrUnknownPC", table[0].Address-1, err)
 237         }
 238         for i, testLine := range table {
 239                 if testLine.EndSequence {
 240                         if err := lr.SeekPC(testLine.Address, &line); err != ErrUnknownPC {
 241                                 t.Fatalf("lr.SeekPC to %#x returned %v instead of ErrUnknownPC", testLine.Address, err)
 242                         }
 243                         continue
 244                 }
 245
 246                 nextPC := table[i+1].Address
 247                 for pc := testLine.Address; pc < nextPC; pc++ {
 248                         if err := lr.SeekPC(pc, &line); err != nil {
 249                                 t.Fatalf("lr.SeekPC to %#x failed: %v", pc, err)
 250                         } else if line != testLine {
 251                                 t.Fatalf("lr.SeekPC to %#x returned %v instead of %v", pc, line, testLine)
 252                         }
 253                 }
 254         }
 255 }
 256
 257 func testLineTable(t *testing.T, want []LineEntry, files [][]*LineFile, d *Data) {
 258         // Get line table from d.
 259         var got []LineEntry
 260         dr := d.Reader()
 261         for {
 262                 ent, err := dr.Next()
 263                 if err != nil {
 264                         t.Fatal("dr.Next:", err)
 265                 } else if ent == nil {
 266                         break
 267                 }
 268
 269                 if ent.Tag != TagCompileUnit {
 270                         dr.SkipChildren()
 271                         continue
 272                 }
 273
 274                 // Ignore system compilation units (this happens in
 275                 // the Windows binary). We'll still decode the line
 276                 // table, but won't check it.
 277                 name := ent.Val(AttrName).(string)
 278                 ignore := strings.HasPrefix(name, "C:/crossdev/") || strings.HasPrefix(name, "../../")
 279
 280                 // Decode CU's line table.
 281                 lr, err := d.LineReader(ent)
 282                 if err != nil {
 283                         t.Fatal("d.LineReader:", err)
 284                 } else if lr == nil {
 285                         continue
 286                 }
 287
 288                 for {
 289                         var line LineEntry
 290                         err := lr.Next(&line)
 291                         if err != nil {
 292                                 if err == io.EOF {
 293                                         break
 294                                 }
 295                                 t.Fatal("lr.Next:", err)
 296                         }
 297                         // Ignore sources from the Windows build environment.
 298                         if ignore {
 299                                 continue
 300                         }
 301                         got = append(got, line)
 302                 }
 303
 304                 // Check file table.
 305                 if !ignore {
 306                         if !compareFiles(files[0], lr.Files()) {
 307                                 t.Log("File tables do not match. Got:")
 308                                 dumpFiles(t, lr.Files())
 309                                 t.Log("Want:")
 310                                 dumpFiles(t, files[0])
 311                                 t.Fail()
 312                         }
 313                         files = files[1:]
 314                 }
 315         }
 316
 317         // Compare line tables.
 318         if !compareLines(t, got, want) {
 319                 t.Log("Line tables do not match. Got:")
 320                 dumpLines(t, got)
 321                 t.Log("Want:")
 322                 dumpLines(t, want)
 323                 t.FailNow()
 324         }
 325 }
 326
 327 func compareFiles(a, b []*LineFile) bool {
 328         if len(a) != len(b) {
 329                 return false
 330         }
 331         for i := range a {
 332                 if a[i] == nil && b[i] == nil {
 333                         continue
 334                 }
 335                 if a[i] != nil && b[i] != nil && a[i].Name == b[i].Name {
 336                         continue
 337                 }
 338                 return false
 339         }
 340         return true
 341 }
 342
 343 func dumpFiles(t *testing.T, files []*LineFile) {
 344         for i, f := range files {
 345                 name := "<nil>"
 346                 if f != nil {
 347                         name = f.Name
 348                 }
 349                 t.Logf("  %d %s", i, name)
 350         }
 351 }
 352
 353 func compareLines(t *testing.T, a, b []LineEntry) bool {
 354         t.Helper()
 355         if len(a) != len(b) {
 356                 t.Errorf("len(a) == %d, len(b) == %d", len(a), len(b))
 357                 return false
 358         }
 359
 360         for i := range a {
 361                 al, bl := a[i], b[i]
 362                 // If both are EndSequence, then the only other valid
 363                 // field is Address. Otherwise, test equality of all
 364                 // fields.
 365                 if al.EndSequence && bl.EndSequence && al.Address == bl.Address {
 366                         continue
 367                 }
 368                 if al.File.Name != bl.File.Name {
 369                         t.Errorf("%d: name %v != name %v", i, al.File.Name, bl.File.Name)
 370                         return false
 371                 }
 372                 al.File = nil
 373                 bl.File = nil
 374                 if al != bl {
 375                         t.Errorf("%d: %#v != %#v", i, al, bl)
 376                         return false
 377                 }
 378         }
 379         return true
 380 }
 381
 382 func dumpLines(t *testing.T, lines []LineEntry) {
 383         for _, l := range lines {
 384                 t.Logf("  %+v File:%+v", l, l.File)
 385         }
 386 }
 387
 388 type joinTest struct {
 389         dirname, filename string
 390         path              string
 391 }
 392
 393 var joinTests = []joinTest{
 394         {"a", "b", "a/b"},
 395         {"a", "", "a"},
 396         {"", "b", "b"},
 397         {"/a", "b", "/a/b"},
 398         {"/a/", "b", "/a/b"},
 399
 400         {`C:\Windows\`, `System32`, `C:\Windows\System32`},
 401         {`C:\Windows\`, ``, `C:\Windows\`},
 402         {`C:\`, `Windows`, `C:\Windows`},
 403         {`C:\Windows\`, `C:System32`, `C:\Windows\System32`},
 404         {`C:\Windows`, `a/b`, `C:\Windows\a/b`},
 405         {`\\host\share\`, `foo`, `\\host\share\foo`},
 406         {`\\host\share\`, `foo\bar`, `\\host\share\foo\bar`},
 407         {`//host/share/`, `foo/bar`, `//host/share/foo/bar`},
 408
 409         // Note: the Go compiler currently emits DWARF line table paths
 410         // with '/' instead of '\' (see issues #19784, #36495). These
 411         // tests are to cover cases that might come up for Windows Go
 412         // binaries.
 413         {`c:/workdir/go/src/x`, `y.go`, `c:/workdir/go/src/x/y.go`},
 414         {`d:/some/thing/`, `b.go`, `d:/some/thing/b.go`},
 415         {`e:\blah\`, `foo.c`, `e:\blah\foo.c`},
 416
 417         // The following are "best effort". We shouldn't see relative
 418         // base directories in DWARF, but these test that pathJoin
 419         // doesn't fail miserably if it sees one.
 420         {`C:`, `a`, `C:a`},
 421         {`C:`, `a\b`, `C:a\b`},
 422         {`C:.`, `a`, `C:.\a`},
 423         {`C:a`, `b`, `C:a\b`},
 424 }
 425
 426 func TestPathJoin(t *testing.T) {
 427         for _, test := range joinTests {
 428                 got := PathJoin(test.dirname, test.filename)
 429                 if test.path != got {
 430                         t.Errorf("pathJoin(%q, %q) = %q, want %q", test.dirname, test.filename, got, test.path)
 431                 }
 432         }
 433 }
 434
 435 func TestPathLineReaderMalformed(t *testing.T) {
 436         // This test case drawn from issue #52354. What's happening
 437         // here is that the stmtList attribute in the compilation
 438         // unit is malformed (negative).
 439         var aranges, frame, pubnames, ranges, str []byte
 440         abbrev := []byte{0x10, 0x20, 0x20, 0x20, 0x21, 0x20, 0x10, 0x21, 0x61,
 441                 0x0, 0x0, 0xff, 0x20, 0xff, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 442                 0x20, 0x20, 0x20, 0x20, 0x20, 0x20}
 443         info := []byte{0x0, 0x0, 0x0, 0x9, 0x0, 0x2, 0x0, 0x0, 0x0, 0x0,
 444                 0x20, 0x10, 0x10}
 445         line := []byte{0x20}
 446         Data0, err := New(abbrev, aranges, frame, info, line, pubnames, ranges, str)
 447         if err != nil {
 448                 t.Fatalf("error unexpected: %v", err)
 449         }
 450         Reader0 := Data0.Reader()
 451         Entry0, err := Reader0.Next()
 452         if err != nil {
 453                 t.Fatalf("error unexpected: %v", err)
 454         }
 455         LineReader0, err := Data0.LineReader(Entry0)
 456         if err == nil {
 457                 t.Fatalf("expected error")
 458         }
 459         if LineReader0 != nil {
 460                 t.Fatalf("expected nil line reader")
 461         }
 462 }