libgo/go/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
  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 }