entry_test.go

Documentation: debug/dwarf

		 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 dwarf_test
		 6  
		 7  import (
		 8  	. "debug/dwarf"
		 9  	"encoding/binary"
		10  	"path/filepath"
		11  	"reflect"
		12  	"testing"
		13  )
		14  
		15  func TestSplit(t *testing.T) {
		16  	// debug/dwarf doesn't (currently) support split DWARF, but
		17  	// the attributes that pointed to the split DWARF used to
		18  	// cause loading the DWARF data to fail entirely (issue
		19  	// #12592). Test that we can at least read the DWARF data.
		20  	d := elfData(t, "testdata/split.elf")
		21  	r := d.Reader()
		22  	e, err := r.Next()
		23  	if err != nil {
		24  		t.Fatal(err)
		25  	}
		26  	if e.Tag != TagCompileUnit {
		27  		t.Fatalf("bad tag: have %s, want %s", e.Tag, TagCompileUnit)
		28  	}
		29  	// Check that we were able to parse the unknown section offset
		30  	// field, even if we can't figure out its DWARF class.
		31  	const AttrGNUAddrBase Attr = 0x2133
		32  	f := e.AttrField(AttrGNUAddrBase)
		33  	if _, ok := f.Val.(int64); !ok {
		34  		t.Fatalf("bad attribute value type: have %T, want int64", f.Val)
		35  	}
		36  	if f.Class != ClassUnknown {
		37  		t.Fatalf("bad class: have %s, want %s", f.Class, ClassUnknown)
		38  	}
		39  }
		40  
		41  // wantRange maps from a PC to the ranges of the compilation unit
		42  // containing that PC.
		43  type wantRange struct {
		44  	pc		 uint64
		45  	ranges [][2]uint64
		46  }
		47  
		48  func TestReaderSeek(t *testing.T) {
		49  	want := []wantRange{
		50  		{0x40059d, [][2]uint64{{0x40059d, 0x400601}}},
		51  		{0x400600, [][2]uint64{{0x40059d, 0x400601}}},
		52  		{0x400601, [][2]uint64{{0x400601, 0x400611}}},
		53  		{0x4005f0, [][2]uint64{{0x40059d, 0x400601}}}, // loop test
		54  		{0x10, nil},
		55  		{0x400611, nil},
		56  	}
		57  	testRanges(t, "testdata/line-gcc.elf", want)
		58  
		59  	want = []wantRange{
		60  		{0x401122, [][2]uint64{{0x401122, 0x401166}}},
		61  		{0x401165, [][2]uint64{{0x401122, 0x401166}}},
		62  		{0x401166, [][2]uint64{{0x401166, 0x401179}}},
		63  	}
		64  	testRanges(t, "testdata/line-gcc-dwarf5.elf", want)
		65  
		66  	want = []wantRange{
		67  		{0x401130, [][2]uint64{{0x401130, 0x40117e}}},
		68  		{0x40117d, [][2]uint64{{0x401130, 0x40117e}}},
		69  		{0x40117e, nil},
		70  	}
		71  	testRanges(t, "testdata/line-clang-dwarf5.elf", want)
		72  }
		73  
		74  func TestRangesSection(t *testing.T) {
		75  	want := []wantRange{
		76  		{0x400500, [][2]uint64{{0x400500, 0x400549}, {0x400400, 0x400408}}},
		77  		{0x400400, [][2]uint64{{0x400500, 0x400549}, {0x400400, 0x400408}}},
		78  		{0x400548, [][2]uint64{{0x400500, 0x400549}, {0x400400, 0x400408}}},
		79  		{0x400407, [][2]uint64{{0x400500, 0x400549}, {0x400400, 0x400408}}},
		80  		{0x400408, nil},
		81  		{0x400449, nil},
		82  		{0x4003ff, nil},
		83  	}
		84  	testRanges(t, "testdata/ranges.elf", want)
		85  }
		86  
		87  func TestRangesRnglistx(t *testing.T) {
		88  	want := []wantRange{
		89  		{0x401000, [][2]uint64{{0x401020, 0x40102c}, {0x401000, 0x40101d}}},
		90  		{0x40101c, [][2]uint64{{0x401020, 0x40102c}, {0x401000, 0x40101d}}},
		91  		{0x40101d, nil},
		92  		{0x40101f, nil},
		93  		{0x401020, [][2]uint64{{0x401020, 0x40102c}, {0x401000, 0x40101d}}},
		94  		{0x40102b, [][2]uint64{{0x401020, 0x40102c}, {0x401000, 0x40101d}}},
		95  		{0x40102c, nil},
		96  	}
		97  	testRanges(t, "testdata/rnglistx.elf", want)
		98  }
		99  
	 100  func testRanges(t *testing.T, name string, want []wantRange) {
	 101  	d := elfData(t, name)
	 102  	r := d.Reader()
	 103  	for _, w := range want {
	 104  		entry, err := r.SeekPC(w.pc)
	 105  		if err != nil {
	 106  			if w.ranges != nil {
	 107  				t.Errorf("%s: missing Entry for %#x", name, w.pc)
	 108  			}
	 109  			if err != ErrUnknownPC {
	 110  				t.Errorf("%s: expected ErrUnknownPC for %#x, got %v", name, w.pc, err)
	 111  			}
	 112  			continue
	 113  		}
	 114  
	 115  		ranges, err := d.Ranges(entry)
	 116  		if err != nil {
	 117  			t.Errorf("%s: %v", name, err)
	 118  			continue
	 119  		}
	 120  		if !reflect.DeepEqual(ranges, w.ranges) {
	 121  			t.Errorf("%s: for %#x got %x, expected %x", name, w.pc, ranges, w.ranges)
	 122  		}
	 123  	}
	 124  }
	 125  
	 126  func TestReaderRanges(t *testing.T) {
	 127  	type subprograms []struct {
	 128  		name	 string
	 129  		ranges [][2]uint64
	 130  	}
	 131  	tests := []struct {
	 132  		filename		string
	 133  		subprograms subprograms
	 134  	}{
	 135  		{
	 136  			"testdata/line-gcc.elf",
	 137  			subprograms{
	 138  				{"f1", [][2]uint64{{0x40059d, 0x4005e7}}},
	 139  				{"main", [][2]uint64{{0x4005e7, 0x400601}}},
	 140  				{"f2", [][2]uint64{{0x400601, 0x400611}}},
	 141  			},
	 142  		},
	 143  		{
	 144  			"testdata/line-gcc-dwarf5.elf",
	 145  			subprograms{
	 146  				{"main", [][2]uint64{{0x401147, 0x401166}}},
	 147  				{"f1", [][2]uint64{{0x401122, 0x401147}}},
	 148  				{"f2", [][2]uint64{{0x401166, 0x401179}}},
	 149  			},
	 150  		},
	 151  		{
	 152  			"testdata/line-clang-dwarf5.elf",
	 153  			subprograms{
	 154  				{"main", [][2]uint64{{0x401130, 0x401144}}},
	 155  				{"f1", [][2]uint64{{0x401150, 0x40117e}}},
	 156  				{"f2", [][2]uint64{{0x401180, 0x401197}}},
	 157  			},
	 158  		},
	 159  	}
	 160  
	 161  	for _, test := range tests {
	 162  		d := elfData(t, test.filename)
	 163  		subprograms := test.subprograms
	 164  
	 165  		r := d.Reader()
	 166  		i := 0
	 167  		for entry, err := r.Next(); entry != nil && err == nil; entry, err = r.Next() {
	 168  			if entry.Tag != TagSubprogram {
	 169  				continue
	 170  			}
	 171  
	 172  			if i > len(subprograms) {
	 173  				t.Fatalf("%s: too many subprograms (expected at most %d)", test.filename, i)
	 174  			}
	 175  
	 176  			if got := entry.Val(AttrName).(string); got != subprograms[i].name {
	 177  				t.Errorf("%s: subprogram %d name is %s, expected %s", test.filename, i, got, subprograms[i].name)
	 178  			}
	 179  			ranges, err := d.Ranges(entry)
	 180  			if err != nil {
	 181  				t.Errorf("%s: subprogram %d: %v", test.filename, i, err)
	 182  				continue
	 183  			}
	 184  			if !reflect.DeepEqual(ranges, subprograms[i].ranges) {
	 185  				t.Errorf("%s: subprogram %d ranges are %x, expected %x", test.filename, i, ranges, subprograms[i].ranges)
	 186  			}
	 187  			i++
	 188  		}
	 189  
	 190  		if i < len(subprograms) {
	 191  			t.Errorf("%s: saw only %d subprograms, expected %d", test.filename, i, len(subprograms))
	 192  		}
	 193  	}
	 194  }
	 195  
	 196  func Test64Bit(t *testing.T) {
	 197  	// I don't know how to generate a 64-bit DWARF debug
	 198  	// compilation unit except by using XCOFF, so this is
	 199  	// hand-written.
	 200  	tests := []struct {
	 201  		name			string
	 202  		info			[]byte
	 203  		addrSize	int
	 204  		byteOrder binary.ByteOrder
	 205  	}{
	 206  		{
	 207  			"32-bit little",
	 208  			[]byte{0x30, 0, 0, 0, // comp unit length
	 209  				4, 0, // DWARF version 4
	 210  				0, 0, 0, 0, // abbrev offset
	 211  				8, // address size
	 212  				0,
	 213  				0, 0, 0, 0, 0, 0, 0, 0,
	 214  				0, 0, 0, 0, 0, 0, 0, 0,
	 215  				0, 0, 0, 0, 0, 0, 0, 0,
	 216  				0, 0, 0, 0, 0, 0, 0, 0,
	 217  				0, 0, 0, 0, 0, 0, 0, 0,
	 218  			},
	 219  			8, binary.LittleEndian,
	 220  		},
	 221  		{
	 222  			"64-bit little",
	 223  			[]byte{0xff, 0xff, 0xff, 0xff, // 64-bit DWARF
	 224  				0x30, 0, 0, 0, 0, 0, 0, 0, // comp unit length
	 225  				4, 0, // DWARF version 4
	 226  				0, 0, 0, 0, 0, 0, 0, 0, // abbrev offset
	 227  				8, // address size
	 228  				0, 0, 0, 0, 0,
	 229  				0, 0, 0, 0, 0, 0, 0, 0,
	 230  				0, 0, 0, 0, 0, 0, 0, 0,
	 231  				0, 0, 0, 0, 0, 0, 0, 0,
	 232  				0, 0, 0, 0, 0, 0, 0, 0,
	 233  			},
	 234  			8, binary.LittleEndian,
	 235  		},
	 236  		{
	 237  			"64-bit big",
	 238  			[]byte{0xff, 0xff, 0xff, 0xff, // 64-bit DWARF
	 239  				0, 0, 0, 0, 0, 0, 0, 0x30, // comp unit length
	 240  				0, 4, // DWARF version 4
	 241  				0, 0, 0, 0, 0, 0, 0, 0, // abbrev offset
	 242  				8, // address size
	 243  				0, 0, 0, 0, 0,
	 244  				0, 0, 0, 0, 0, 0, 0, 0,
	 245  				0, 0, 0, 0, 0, 0, 0, 0,
	 246  				0, 0, 0, 0, 0, 0, 0, 0,
	 247  				0, 0, 0, 0, 0, 0, 0, 0,
	 248  			},
	 249  			8, binary.BigEndian,
	 250  		},
	 251  	}
	 252  
	 253  	for _, test := range tests {
	 254  		data, err := New(nil, nil, nil, test.info, nil, nil, nil, nil)
	 255  		if err != nil {
	 256  			t.Errorf("%s: %v", test.name, err)
	 257  		}
	 258  
	 259  		r := data.Reader()
	 260  		if r.AddressSize() != test.addrSize {
	 261  			t.Errorf("%s: got address size %d, want %d", test.name, r.AddressSize(), test.addrSize)
	 262  		}
	 263  		if r.ByteOrder() != test.byteOrder {
	 264  			t.Errorf("%s: got byte order %s, want %s", test.name, r.ByteOrder(), test.byteOrder)
	 265  		}
	 266  	}
	 267  }
	 268  
	 269  func TestUnitIteration(t *testing.T) {
	 270  	// Iterate over all ELF test files we have and ensure that
	 271  	// we get the same set of compilation units skipping (method 0)
	 272  	// and not skipping (method 1) CU children.
	 273  	files, err := filepath.Glob(filepath.Join("testdata", "*.elf"))
	 274  	if err != nil {
	 275  		t.Fatal(err)
	 276  	}
	 277  	for _, file := range files {
	 278  		t.Run(file, func(t *testing.T) {
	 279  			d := elfData(t, file)
	 280  			var units [2][]interface{}
	 281  			for method := range units {
	 282  				for r := d.Reader(); ; {
	 283  					ent, err := r.Next()
	 284  					if err != nil {
	 285  						t.Fatal(err)
	 286  					}
	 287  					if ent == nil {
	 288  						break
	 289  					}
	 290  					if ent.Tag == TagCompileUnit {
	 291  						units[method] = append(units[method], ent.Val(AttrName))
	 292  					}
	 293  					if method == 0 {
	 294  						if ent.Tag != TagCompileUnit {
	 295  							t.Fatalf("found unexpected tag %v on top level", ent.Tag)
	 296  						}
	 297  						r.SkipChildren()
	 298  					}
	 299  				}
	 300  			}
	 301  			t.Logf("skipping CUs:		 %v", units[0])
	 302  			t.Logf("not-skipping CUs: %v", units[1])
	 303  			if !reflect.DeepEqual(units[0], units[1]) {
	 304  				t.Fatal("set of CUs differ")
	 305  			}
	 306  		})
	 307  	}
	 308  }
	 309
View as plain text