cmd/link: pclntab generation

R=iant
CC=golang-codereviews
https://golang.org/cl/53820043

src/cmd/link/pclntab_test.go

+// Copyright 2014 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"bytes"
+	"debug/goobj"
+	"fmt"
+	"math/rand"
+	"sort"
+	"strings"
+	"testing"
+)
+
+// Test of pcln table encoding.
+// testdata/genpcln.go generates an assembly file with
+// pseudorandom values for the data that pclntab stores.
+// This test recomputes the same pseudorandom stream
+// and checks that the final linked binary uses those values
+// as well.
+func TestPclntab(t *testing.T) {
+	p := &Prog{
+		GOOS:        "darwin",
+		GOARCH:      "amd64",
+		Error:       func(s string) { t.Error(s) },
+		StartSym:    "start",
+		omitRuntime: true,
+	}
+	var buf bytes.Buffer
+	p.link(&buf, "testdata/pclntab.6")
+	if p.NumError > 0 {
+		return
+	}
+
+	// The algorithm for computing values here must match
+	// the one in testdata/genpcln.go.
+	for f := 0; f < 3; f++ {
+		file := "input"
+		line := 1
+		rnd := rand.New(rand.NewSource(int64(f)))
+		args := rnd.Intn(100) * 8
+		frame := 32 + rnd.Intn(32)/8*8
+		size := 200 + rnd.Intn(100)*8
+
+		name := fmt.Sprintf("func%d", f)
+		r, off, fargs, fframe, ok := findFunc(t, p, name)
+		if !ok {
+			continue // error already printed
+		}
+		if fargs != args {
+			t.Errorf("%s: args=%d, want %d", name, fargs, args)
+		}
+		if fframe != frame+8 {
+			t.Errorf("%s: frame=%d, want %d", name, fframe, frame+8)
+		}
+
+		// Check FUNCDATA 1.
+		fdata, ok := loadFuncdata(t, r, name, off, 1)
+		if ok {
+			fsym := p.Syms[goobj.SymID{Name: fmt.Sprintf("funcdata%d", f)}]
+			if fsym == nil {
+				t.Errorf("funcdata%d is missing in binary", f)
+			} else if fdata != fsym.Addr {
+				t.Errorf("%s: funcdata 1 = %#x, want %#x", name, fdata, fsym.Addr)
+			}
+		}
+
+		// Walk code checking pcdata values.
+		spadj := 0
+		pcdata1 := -1
+		pcdata2 := -1
+
+		checkPCSP(t, r, name, off, 0, 0)
+		checkPCData(t, r, name, off, 0, 0, -1)
+		checkPCData(t, r, name, off, 0, 1, -1)
+		checkPCData(t, r, name, off, 0, 2, -1)
+
+		firstpc := 4
+		for i := 0; i < size; i++ {
+			pc := firstpc + i // skip SP adjustment to allocate frame
+			if i >= 0x100 && t.Failed() {
+				break
+			}
+			// Possible SP adjustment.
+			checkPCSP(t, r, name, off, pc, frame+spadj)
+			if rnd.Intn(100) == 0 {
+				checkPCFileLine(t, r, name, off, pc, file, line)
+				checkPCData(t, r, name, off, pc, 1, pcdata1)
+				checkPCData(t, r, name, off, pc, 2, pcdata2)
+				i += 1
+				pc = firstpc + i
+				checkPCFileLine(t, r, name, off, pc-1, file, line)
+				checkPCData(t, r, name, off, pc-1, 1, pcdata1)
+				checkPCData(t, r, name, off, pc-1, 2, pcdata2)
+				checkPCSP(t, r, name, off, pc-1, frame+spadj)
+
+				if spadj <= -32 || spadj < 32 && rnd.Intn(2) == 0 {
+					spadj += 8
+				} else {
+					spadj -= 8
+				}
+				checkPCSP(t, r, name, off, pc, frame+spadj)
+			}
+
+			// Possible PCFile change.
+			if rnd.Intn(100) == 0 {
+				file = fmt.Sprintf("file%d.s", rnd.Intn(10))
+				line = rnd.Intn(100) + 1
+			}
+
+			// Possible PCLine change.
+			if rnd.Intn(10) == 0 {
+				line = rnd.Intn(1000) + 1
+			}
+
+			// Possible PCData $1 change.
+			if rnd.Intn(100) == 0 {
+				pcdata1 = rnd.Intn(1000)
+			}
+
+			// Possible PCData $2 change.
+			if rnd.Intn(100) == 0 {
+				pcdata2 = rnd.Intn(1000)
+			}
+
+			if i == 0 {
+				checkPCFileLine(t, r, name, off, 0, file, line)
+				checkPCFileLine(t, r, name, off, pc-1, file, line)
+			}
+			checkPCFileLine(t, r, name, off, pc, file, line)
+			checkPCData(t, r, name, off, pc, 1, pcdata1)
+			checkPCData(t, r, name, off, pc, 2, pcdata2)
+		}
+	}
+}
+
+// findFunc finds the function information in the pclntab of p
+// for the function with the given name.
+// It returns a symbol reader for pclntab, the offset of the function information
+// within that symbol, and the args and frame values read out of the information.
+func findFunc(t *testing.T, p *Prog, name string) (r *SymReader, off, args, frame int, ok bool) {
+	tabsym := p.Syms[goobj.SymID{Name: "pclntab"}]
+	if tabsym == nil {
+		t.Errorf("pclntab is missing in binary")
+		return
+	}
+
+	r = new(SymReader)
+	r.Init(p, tabsym)
+
+	// pclntab must with 8-byte header
+	if r.Uint32(0) != 0xfffffffb || r.Uint8(4) != 0 || r.Uint8(5) != 0 || r.Uint8(6) != uint8(p.pcquantum) || r.Uint8(7) != uint8(p.ptrsize) {
+		t.Errorf("pclntab has incorrect header %.8x", r.data[:8])
+		return
+	}
+
+	sym := p.Syms[goobj.SymID{Name: name}]
+	if sym == nil {
+		t.Errorf("%s is missing in the binary", name)
+		return
+	}
+
+	// index is nfunc addr0 off0 addr1 off1 ... addr_nfunc (sentinel)
+	nfunc := int(r.Addr(8))
+	i := sort.Search(nfunc, func(i int) bool {
+		return r.Addr(8+p.ptrsize*(1+2*i)) >= sym.Addr
+	})
+	if entry := r.Addr(8 + p.ptrsize*(1+2*i)); entry != sym.Addr {
+		indexTab := make([]Addr, 2*nfunc+1)
+		for j := range indexTab {
+			indexTab[j] = r.Addr(8 + p.ptrsize*(1+j))
+		}
+		t.Errorf("pclntab is missing entry for %s (%#x): %#x", name, sym.Addr, indexTab)
+		return
+	}
+
+	off = int(r.Addr(8 + p.ptrsize*(1+2*i+1)))
+
+	// func description at off is
+	//	entry addr
+	//	nameoff uint32
+	//	args uint32
+	//	frame uint32
+	//	pcspoff uint32
+	//	pcfileoff uint32
+	//	pclineoff uint32
+	//	npcdata uint32
+	//	nfuncdata uint32
+	//	pcdata npcdata*uint32
+	//	funcdata nfuncdata*addr
+	//
+	if entry := r.Addr(off); entry != sym.Addr {
+		t.Errorf("pclntab inconsistent: entry for %s addr=%#x has entry=%#x", name, sym.Addr, entry)
+		return
+	}
+	nameoff := int(r.Uint32(off + p.ptrsize))
+	args = int(r.Uint32(off + p.ptrsize + 1*4))
+	frame = int(r.Uint32(off + p.ptrsize + 2*4))
+
+	fname := r.String(nameoff)
+	if fname != name {
+		t.Errorf("pclntab inconsistent: entry for %s addr=%#x has name %q", name, sym.Addr, fname)
+	}
+
+	ok = true // off, args, frame are usable
+	return
+}
+
+// loadFuncdata returns the funcdata #fnum value
+// loaded from the function information for name.
+func loadFuncdata(t *testing.T, r *SymReader, name string, off int, fnum int) (Addr, bool) {
+	npcdata := int(r.Uint32(off + r.p.ptrsize + 6*4))
+	nfuncdata := int(r.Uint32(off + r.p.ptrsize + 7*4))
+	if fnum >= nfuncdata {
+		t.Errorf("pclntab(%s): no funcdata %d (only < %d)", name, fnum, nfuncdata)
+		return 0, false
+	}
+	fdataoff := off + r.p.ptrsize + (8+npcdata)*4 + fnum*r.p.ptrsize
+	fdataoff += fdataoff & 4
+	return r.Addr(fdataoff), true
+}
+
+// checkPCSP checks that the PCSP table in the function information at off
+// lists spadj as the sp delta for pc.
+func checkPCSP(t *testing.T, r *SymReader, name string, off, pc, spadj int) {
+	pcoff := r.Uint32(off + r.p.ptrsize + 3*4)
+	pcval, ok := readPCData(t, r, name, "PCSP", pcoff, pc)
+	if !ok {
+		return
+	}
+	if pcval != spadj {
+		t.Errorf("pclntab(%s): at pc=+%#x, pcsp=%d, want %d", name, pc, pcval, spadj)
+	}
+}
+
+// checkPCSP checks that the PCFile and PCLine tables in the function information at off
+// list file, line as the file name and line number for pc.
+func checkPCFileLine(t *testing.T, r *SymReader, name string, off, pc int, file string, line int) {
+	pcfileoff := r.Uint32(off + r.p.ptrsize + 4*4)
+	pclineoff := r.Uint32(off + r.p.ptrsize + 5*4)
+	pcfilenum, ok1 := readPCData(t, r, name, "PCFile", pcfileoff, pc)
+	pcline, ok2 := readPCData(t, r, name, "PCLine", pclineoff, pc)
+	if !ok1 || !ok2 {
+		return
+	}
+	nfunc := int(r.Addr(8))
+	filetaboff := r.Uint32(8 + r.p.ptrsize*2*(nfunc+1))
+	nfile := int(r.Uint32(int(filetaboff)))
+	if pcfilenum <= 0 || pcfilenum >= nfile {
+		t.Errorf("pclntab(%s): at pc=+%#x, filenum=%d (invalid; nfile=%d)", name, pc, pcfilenum, nfile)
+	}
+	pcfile := r.String(int(r.Uint32(int(filetaboff) + pcfilenum*4)))
+	if !strings.HasSuffix(pcfile, file) {
+		t.Errorf("pclntab(%s): at pc=+%#x, file=%q, want %q", name, pc, pcfile, file)
+	}
+	if pcline != line {
+		t.Errorf("pclntab(%s): at pc=+%#x, line=%d, want %d", name, pc, pcline, line)
+	}
+}
+
+// checkPCData checks that the PCData#pnum table in the function information at off
+// list val as the value for pc.
+func checkPCData(t *testing.T, r *SymReader, name string, off, pc, pnum, val int) {
+	pcoff := r.Uint32(off + r.p.ptrsize + (8+pnum)*4)
+	pcval, ok := readPCData(t, r, name, fmt.Sprintf("PCData#%d", pnum), pcoff, pc)
+	if !ok {
+		return
+	}
+	if pcval != val {
+		t.Errorf("pclntab(%s): at pc=+%#x, pcdata#%d=%d, want %d", name, pc, pnum, pcval, val)
+	}
+}
+
+// readPCData reads the PCData table offset off
+// to obtain and return the value associated with pc.
+func readPCData(t *testing.T, r *SymReader, name, pcdataname string, pcoff uint32, pc int) (int, bool) {
+	var it PCIter
+	for it.Init(r.p, r.data[pcoff:]); !it.Done; it.Next() {
+		if it.PC <= uint32(pc) && uint32(pc) < it.NextPC {
+			return int(it.Value), true
+		}
+	}
+	if it.Corrupt {
+		t.Errorf("pclntab(%s): %s: corrupt pcdata table", name, pcdataname)
+	}
+	return 0, false
+}
+
+// A SymReader provides typed access to the data for a symbol.
+type SymReader struct {
+	p    *Prog
+	data []byte
+}
+
+func (r *SymReader) Init(p *Prog, sym *Sym) {
+	seg := sym.Section.Segment
+	off := sym.Addr - seg.VirtAddr
+	data := seg.Data[off : off+Addr(sym.Size)]
+	r.p = p
+	r.data = data
+}
+
+func (r *SymReader) Uint8(off int) uint8 {
+	return r.data[off]
+}
+
+func (r *SymReader) Uint16(off int) uint16 {
+	return r.p.byteorder.Uint16(r.data[off:])
+}
+
+func (r *SymReader) Uint32(off int) uint32 {
+	return r.p.byteorder.Uint32(r.data[off:])
+}
+
+func (r *SymReader) Uint64(off int) uint64 {
+	return r.p.byteorder.Uint64(r.data[off:])
+}
+
+func (r *SymReader) Addr(off int) Addr {
+	if r.p.ptrsize == 4 {
+		return Addr(r.Uint32(off))
+	}
+	return Addr(r.Uint64(off))
+}
+
+func (r *SymReader) String(off int) string {
+	end := off
+	for r.data[end] != '\x00' {
+		end++
+	}
+	return string(r.data[off:end])
+}

src/cmd/link/prog.go

@@ -66,6 +66,7 @@ type Prog struct {
 type arch struct {
 	byteorder binary.ByteOrder
 	ptrsize   int
+	pcquantum int
 }
 
 // A formatter takes care of the details of generating a particular
@@ -214,5 +215,6 @@ var arches = map[string]arch{
 	"amd64": {
 		byteorder: binary.LittleEndian,
 		ptrsize:   8,
+		pcquantum: 1,
 	},
 }

src/cmd/link/runtime.go

@@ -7,5 +7,22 @@
 
 package main
 
+import "debug/goobj"
+
 func (p *Prog) runtime() {
+	p.pclntab()
+
+	// TODO: Implement garbage collection data.
+	p.addSym(&Sym{
+		Sym: &goobj.Sym{
+			SymID: goobj.SymID{Name: "gcdata"},
+			Kind:  goobj.SRODATA,
+		},
+	})
+	p.addSym(&Sym{
+		Sym: &goobj.Sym{
+			SymID: goobj.SymID{Name: "gcbss"},
+			Kind:  goobj.SRODATA,
+		},
+	})
 }

src/cmd/link/testdata/Makefile

+all: hello.6 pclntab.6
+
+hello.6: hello.s
+	go tool 6a hello.s
+
+pclntab.6: pclntab.s
+	go tool 6a pclntab.s
+
+pclntab.s: genpcln.go
+	go run genpcln.go >pclntab.s

src/cmd/link/testdata/genpcln.go

+// Copyright 2014 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This program generates a .s file using a pseudorandom
+// value stream for the runtime function data.
+// The pclntab test checks that the linked copy
+// still has the same pseudorandom value stream.
+
+package main
+
+import (
+	"fmt"
+	"math/rand"
+)
+
+func main() {
+	fmt.Printf("// generated by genpcln.go; do not edit\n\n")
+	for f := 0; f < 3; f++ {
+		r := rand.New(rand.NewSource(int64(f)))
+		file := "input"
+		line := 1
+		args := r.Intn(100) * 8
+		frame := 32 + r.Intn(32)/8*8
+		fmt.Printf("#line %d %q\n", line, file)
+		fmt.Printf("TEXT func%d(SB),7,$%d-%d\n", f, frame, args)
+		fmt.Printf("\tFUNCDATA $1, funcdata%d(SB)\n", f)
+		fmt.Printf("#line %d %q\n", line, file)
+		size := 200 + r.Intn(100)*8
+		spadj := 0
+		flushed := 0
+		firstpc := 4
+		flush := func(i int) {
+			for i-flushed >= 10 {
+				fmt.Printf("#line %d %q\n", line, file)
+				fmt.Printf("/*%#04x*/\tMOVQ $0x123456789, AX\n", firstpc+flushed)
+				flushed += 10
+			}
+			for i-flushed >= 5 {
+				fmt.Printf("#line %d %q\n", line, file)
+				fmt.Printf("/*%#04x*/\tMOVL $0x1234567, AX\n", firstpc+flushed)
+				flushed += 5
+			}
+			for i-flushed > 0 {
+				fmt.Printf("#line %d %q\n", line, file)
+				fmt.Printf("/*%#04x*/\tBYTE $0\n", firstpc+flushed)
+				flushed++
+			}
+		}
+		for i := 0; i < size; i++ {
+			// Possible SP adjustment.
+			if r.Intn(100) == 0 {
+				flush(i)
+				fmt.Printf("#line %d %q\n", line, file)
+				if spadj <= -32 || spadj < 32 && r.Intn(2) == 0 {
+					spadj += 8
+					fmt.Printf("/*%#04x*/\tPUSHQ AX\n", firstpc+i)
+				} else {
+					spadj -= 8
+					fmt.Printf("/*%#04x*/\tPOPQ AX\n", firstpc+i)
+				}
+				i += 1
+				flushed = i
+			}
+
+			// Possible PCFile change.
+			if r.Intn(100) == 0 {
+				flush(i)
+				file = fmt.Sprintf("file%d.s", r.Intn(10))
+				line = r.Intn(100) + 1
+			}
+
+			// Possible PCLine change.
+			if r.Intn(10) == 0 {
+				flush(i)
+				line = r.Intn(1000) + 1
+			}
+
+			// Possible PCData $1 change.
+			if r.Intn(100) == 0 {
+				flush(i)
+				fmt.Printf("/*%6s*/\tPCDATA $1, $%d\n", "", r.Intn(1000))
+			}
+
+			// Possible PCData $2 change.
+			if r.Intn(100) == 0 {
+				flush(i)
+				fmt.Printf("/*%6s*/\tPCDATA $2, $%d\n", "", r.Intn(1000))
+			}
+		}
+		flush(size)
+		for spadj < 0 {
+			fmt.Printf("\tPUSHQ AX\n")
+			spadj += 8
+		}
+		for spadj > 0 {
+			fmt.Printf("\tPOPQ AX\n")
+			spadj -= 8
+		}
+		fmt.Printf("\tRET\n")
+
+		fmt.Printf("\n")
+		fmt.Printf("GLOBL funcdata%d(SB), $16\n", f)
+	}
+
+	fmt.Printf("\nTEXT start(SB),7,$0\n")
+	for f := 0; f < 3; f++ {
+		fmt.Printf("\tCALL func%d(SB)\n", f)
+	}
+	fmt.Printf("\tMOVQ $pclntab(SB), AX\n")
+	fmt.Printf("\n\tRET\n")
+}

src/cmd/link/testdata/link.hello.darwin.amd64

 00000000  cf fa ed fe 07 00 00 01  03 00 00 00 02 00 00 00  |................|
-00000010  04 00 00 00 30 02 00 00  01 00 00 00 00 00 00 00  |....0...........|
+00000010  04 00 00 00 d0 02 00 00  01 00 00 00 00 00 00 00  |................|
 00000020  19 00 00 00 48 00 00 00  5f 5f 50 41 47 45 5a 45  |....H...__PAGEZE|
 00000030  52 4f 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |RO..............|
 00000040  00 10 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 *
-00000060  00 00 00 00 00 00 00 00  19 00 00 00 98 00 00 00  |................|
+00000060  00 00 00 00 00 00 00 00  19 00 00 00 38 01 00 00  |............8...|
 00000070  5f 5f 54 45 58 54 00 00  00 00 00 00 00 00 00 00  |__TEXT..........|
-00000080  00 10 00 00 00 00 00 00  20 10 00 00 00 00 00 00  |........ .......|
-00000090  00 00 00 00 00 00 00 00  20 10 00 00 00 00 00 00  |........ .......|
-000000a0  07 00 00 00 05 00 00 00  01 00 00 00 00 00 00 00  |................|
+00000080  00 10 00 00 00 00 00 00  d6 10 00 00 00 00 00 00  |................|
+00000090  00 00 00 00 00 00 00 00  d6 10 00 00 00 00 00 00  |................|
+000000a0  07 00 00 00 05 00 00 00  03 00 00 00 00 00 00 00  |................|
 000000b0  5f 5f 74 65 78 74 00 00  00 00 00 00 00 00 00 00  |__text..........|
 000000c0  5f 5f 54 45 58 54 00 00  00 00 00 00 00 00 00 00  |__TEXT..........|
 000000d0  00 20 00 00 00 00 00 00  20 00 00 00 00 00 00 00  |. ...... .......|
 000000e0  00 10 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 000000f0  00 04 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
-00000100  19 00 00 00 98 00 00 00  5f 5f 44 41 54 41 00 00  |........__DATA..|
-00000110  00 00 00 00 00 00 00 00  00 30 00 00 00 00 00 00  |.........0......|
-00000120  0c 00 00 00 00 00 00 00  00 20 00 00 00 00 00 00  |......... ......|
-00000130  0c 00 00 00 00 00 00 00  03 00 00 00 03 00 00 00  |................|
-00000140  01 00 00 00 00 00 00 00  5f 5f 64 61 74 61 00 00  |........__data..|
-00000150  00 00 00 00 00 00 00 00  5f 5f 44 41 54 41 00 00  |........__DATA..|
-00000160  00 00 00 00 00 00 00 00  00 30 00 00 00 00 00 00  |.........0......|
-00000170  0c 00 00 00 00 00 00 00  00 20 00 00 00 00 00 00  |......... ......|
+00000100  5f 5f 72 6f 64 61 74 61  00 00 00 00 00 00 00 00  |__rodata........|
+00000110  5f 5f 54 45 58 54 00 00  00 00 00 00 00 00 00 00  |__TEXT..........|
+00000120  20 20 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |  ..............|
+00000130  20 10 00 00 00 00 00 00  00 00 00 00 00 00 00 00  | ...............|
 *
-00000190  00 00 00 00 00 00 00 00  05 00 00 00 b8 00 00 00  |................|
-000001a0  04 00 00 00 2a 00 00 00  00 00 00 00 00 00 00 00  |....*...........|
+00000150  5f 5f 66 75 6e 63 74 61  62 00 00 00 00 00 00 00  |__functab.......|
+00000160  5f 5f 54 45 58 54 00 00  00 00 00 00 00 00 00 00  |__TEXT..........|
+00000170  20 20 00 00 00 00 00 00  b6 00 00 00 00 00 00 00  |  ..............|
+00000180  20 10 00 00 00 00 00 00  00 00 00 00 00 00 00 00  | ...............|
 *
-00000220  00 00 00 00 00 00 00 00  00 20 00 00 00 00 00 00  |......... ......|
+000001a0  19 00 00 00 98 00 00 00  5f 5f 44 41 54 41 00 00  |........__DATA..|
+000001b0  00 00 00 00 00 00 00 00  00 30 00 00 00 00 00 00  |.........0......|
+000001c0  0c 00 00 00 00 00 00 00  00 20 00 00 00 00 00 00  |......... ......|
+000001d0  0c 00 00 00 00 00 00 00  03 00 00 00 03 00 00 00  |................|
+000001e0  01 00 00 00 00 00 00 00  5f 5f 64 61 74 61 00 00  |........__data..|
+000001f0  00 00 00 00 00 00 00 00  5f 5f 44 41 54 41 00 00  |........__DATA..|
+00000200  00 00 00 00 00 00 00 00  00 30 00 00 00 00 00 00  |.........0......|
+00000210  0c 00 00 00 00 00 00 00  00 20 00 00 00 00 00 00  |......... ......|
+*
+00000230  00 00 00 00 00 00 00 00  05 00 00 00 b8 00 00 00  |................|
+00000240  04 00 00 00 2a 00 00 00  00 00 00 00 00 00 00 00  |....*...........|
+*
+000002c0  00 00 00 00 00 00 00 00  00 20 00 00 00 00 00 00  |......... ......|
 *
 00001000  bf 01 00 00 00 be 00 30  00 00 ba 0c 00 00 00 b8  |.......0........|
 00001010  04 00 00 02 0f 05 31 ff  b8 01 00 00 02 0f 05 c3  |......1.........|
+00001020  fb ff ff ff 00 00 01 08  01 00 00 00 00 00 00 00  |................|
+00001030  00 20 00 00 00 00 00 00  30 00 00 00 00 00 00 00  |. ......0.......|
+00001040  20 20 00 00 00 00 00 00  80 00 00 00 00 00 00 00  |  ..............|
+00001050  00 20 00 00 00 00 00 00  58 00 00 00 00 00 00 80  |. ......X.......|
+00001060  08 00 00 00 60 00 00 00  63 00 00 00 66 00 00 00  |....`...c...f...|
+00001070  00 00 00 00 00 00 00 00  5f 72 74 30 5f 67 6f 00  |........_rt0_go.|
+00001080  02 20 00 04 20 00 06 05  02 05 02 05 02 05 02 02  |. .. ...........|
+00001090  02 02 02 05 02 02 02 01  00 00 00 00 00 00 00 00  |................|
+000010a0  02 00 00 00 88 00 00 00  2f 55 73 65 72 73 2f 72  |......../Users/r|
+000010b0  73 63 2f 72 73 63 67 6f  2f 73 72 63 2f 63 6d 64  |sc/rscgo/src/cmd|
+000010c0  2f 6c 64 32 2f 74 65 73  74 64 61 74 61 2f 68 65  |/ld2/testdata/he|
+000010d0  6c 6c 6f 2e 73 00 00 00  00 00 00 00 00 00 00 00  |llo.s...........|
 *
 00002000  68 65 6c 6c 6f 20 77 6f  72 6c 64 0a              |hello world.|
 0000200c