+// DO NOT EDIT. Generated by code.google.com/p/rsc/cmd/bundle
+// bundle -p main -x goobj_ debug/goobj
+
+/* read.go */
+
// Copyright 2013 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.
// TODO(rsc): Decide where this package should live. (golang.org/issue/6932)
// TODO(rsc): Decide the appropriate integer types for various fields.
// TODO(rsc): Write tests. (File format still up in the air a little.)
-package goobj
+
+package main
import (
"bufio"
)
// A SymKind describes the kind of memory represented by a symbol.
-type SymKind int
+type goobj_SymKind int
// This list is taken from include/link.h.
// TODO(rsc): Give idiomatic Go names.
// TODO(rsc): Reduce the number of symbol types in the object files.
const (
- _ SymKind = iota
+ _ goobj_SymKind = iota
// readonly, executable
- STEXT
- SELFRXSECT
+ goobj_STEXT
+ goobj_SELFRXSECT
// readonly, non-executable
- STYPE
- SSTRING
- SGOSTRING
- SGOFUNC
- SRODATA
- SFUNCTAB
- STYPELINK
- SSYMTAB // TODO: move to unmapped section
- SPCLNTAB
- SELFROSECT
+ goobj_STYPE
+ goobj_SSTRING
+ goobj_SGOSTRING
+ goobj_SGOFUNC
+ goobj_SRODATA
+ goobj_SFUNCTAB
+ goobj_STYPELINK
+ goobj_SSYMTAB // TODO: move to unmapped section
+ goobj_SPCLNTAB
+ goobj_SELFROSECT
// writable, non-executable
- SMACHOPLT
- SELFSECT
- SMACHO // Mach-O __nl_symbol_ptr
- SMACHOGOT
- SNOPTRDATA
- SINITARR
- SDATA
- SWINDOWS
- SBSS
- SNOPTRBSS
- STLSBSS
+ goobj_SMACHOPLT
+ goobj_SELFSECT
+ goobj_SMACHO // Mach-O __nl_symbol_ptr
+ goobj_SMACHOGOT
+ goobj_SNOPTRDATA
+ goobj_SINITARR
+ goobj_SDATA
+ goobj_SWINDOWS
+ goobj_SBSS
+ goobj_SNOPTRBSS
+ goobj_STLSBSS
// not mapped
- SXREF
- SMACHOSYMSTR
- SMACHOSYMTAB
- SMACHOINDIRECTPLT
- SMACHOINDIRECTGOT
- SFILE
- SFILEPATH
- SCONST
- SDYNIMPORT
- SHOSTOBJ
+ goobj_SXREF
+ goobj_SMACHOSYMSTR
+ goobj_SMACHOSYMTAB
+ goobj_SMACHOINDIRECTPLT
+ goobj_SMACHOINDIRECTGOT
+ goobj_SFILE
+ goobj_SFILEPATH
+ goobj_SCONST
+ goobj_SDYNIMPORT
+ goobj_SHOSTOBJ
)
-var symKindStrings = []string{
- SBSS: "SBSS",
- SCONST: "SCONST",
- SDATA: "SDATA",
- SDYNIMPORT: "SDYNIMPORT",
- SELFROSECT: "SELFROSECT",
- SELFRXSECT: "SELFRXSECT",
- SELFSECT: "SELFSECT",
- SFILE: "SFILE",
- SFILEPATH: "SFILEPATH",
- SFUNCTAB: "SFUNCTAB",
- SGOFUNC: "SGOFUNC",
- SGOSTRING: "SGOSTRING",
- SHOSTOBJ: "SHOSTOBJ",
- SINITARR: "SINITARR",
- SMACHO: "SMACHO",
- SMACHOGOT: "SMACHOGOT",
- SMACHOINDIRECTGOT: "SMACHOINDIRECTGOT",
- SMACHOINDIRECTPLT: "SMACHOINDIRECTPLT",
- SMACHOPLT: "SMACHOPLT",
- SMACHOSYMSTR: "SMACHOSYMSTR",
- SMACHOSYMTAB: "SMACHOSYMTAB",
- SNOPTRBSS: "SNOPTRBSS",
- SNOPTRDATA: "SNOPTRDATA",
- SPCLNTAB: "SPCLNTAB",
- SRODATA: "SRODATA",
- SSTRING: "SSTRING",
- SSYMTAB: "SSYMTAB",
- STEXT: "STEXT",
- STLSBSS: "STLSBSS",
- STYPE: "STYPE",
- STYPELINK: "STYPELINK",
- SWINDOWS: "SWINDOWS",
- SXREF: "SXREF",
+var goobj_symKindStrings = []string{
+ goobj_SBSS: "SBSS",
+ goobj_SCONST: "SCONST",
+ goobj_SDATA: "SDATA",
+ goobj_SDYNIMPORT: "SDYNIMPORT",
+ goobj_SELFROSECT: "SELFROSECT",
+ goobj_SELFRXSECT: "SELFRXSECT",
+ goobj_SELFSECT: "SELFSECT",
+ goobj_SFILE: "SFILE",
+ goobj_SFILEPATH: "SFILEPATH",
+ goobj_SFUNCTAB: "SFUNCTAB",
+ goobj_SGOFUNC: "SGOFUNC",
+ goobj_SGOSTRING: "SGOSTRING",
+ goobj_SHOSTOBJ: "SHOSTOBJ",
+ goobj_SINITARR: "SINITARR",
+ goobj_SMACHO: "SMACHO",
+ goobj_SMACHOGOT: "SMACHOGOT",
+ goobj_SMACHOINDIRECTGOT: "SMACHOINDIRECTGOT",
+ goobj_SMACHOINDIRECTPLT: "SMACHOINDIRECTPLT",
+ goobj_SMACHOPLT: "SMACHOPLT",
+ goobj_SMACHOSYMSTR: "SMACHOSYMSTR",
+ goobj_SMACHOSYMTAB: "SMACHOSYMTAB",
+ goobj_SNOPTRBSS: "SNOPTRBSS",
+ goobj_SNOPTRDATA: "SNOPTRDATA",
+ goobj_SPCLNTAB: "SPCLNTAB",
+ goobj_SRODATA: "SRODATA",
+ goobj_SSTRING: "SSTRING",
+ goobj_SSYMTAB: "SSYMTAB",
+ goobj_STEXT: "STEXT",
+ goobj_STLSBSS: "STLSBSS",
+ goobj_STYPE: "STYPE",
+ goobj_STYPELINK: "STYPELINK",
+ goobj_SWINDOWS: "SWINDOWS",
+ goobj_SXREF: "SXREF",
}
-func (k SymKind) String() string {
- if k < 0 || int(k) >= len(symKindStrings) {
+func (k goobj_SymKind) String() string {
+ if k < 0 || int(k) >= len(goobj_symKindStrings) {
return fmt.Sprintf("SymKind(%d)", k)
}
- return symKindStrings[k]
+ return goobj_symKindStrings[k]
}
// A Sym is a named symbol in an object file.
-type Sym struct {
- SymID // symbol identifier (name and version)
- Kind SymKind // kind of symbol
- DupOK bool // are duplicate definitions okay?
- Size int // size of corresponding data
- Type SymID // symbol for Go type information
- Data Data // memory image of symbol
- Reloc []Reloc // relocations to apply to Data
- Func *Func // additional data for functions
+type goobj_Sym struct {
+ goobj_SymID // symbol identifier (name and version)
+ Kind goobj_SymKind // kind of symbol
+ DupOK bool // are duplicate definitions okay?
+ Size int // size of corresponding data
+ Type goobj_SymID // symbol for Go type information
+ Data goobj_Data // memory image of symbol
+ Reloc []goobj_Reloc // relocations to apply to Data
+ Func *goobj_Func // additional data for functions
}
// A SymID - the combination of Name and Version - uniquely identifies
// a symbol within a package.
-type SymID struct {
+type goobj_SymID struct {
// Name is the name of a symbol.
Name string
Version int
}
-func (s SymID) String() string {
+func (s goobj_SymID) String() string {
if s.Version == 0 {
return s.Name
}
// A Data is a reference to data stored in an object file.
// It records the offset and size of the data, so that a client can
// read the data only if necessary.
-type Data struct {
+type goobj_Data struct {
Offset int64
Size int64
}
// A Reloc describes a relocation applied to a memory image to refer
// to an address within a particular symbol.
-type Reloc struct {
+type goobj_Reloc struct {
// The bytes at [Offset, Offset+Size) within the memory image
// should be updated to refer to the address Add bytes after the start
// of the symbol Sym.
Offset int
Size int
- Sym SymID
+ Sym goobj_SymID
Add int
// The Type records the form of address expected in the bytes
// A Var describes a variable in a function stack frame: a declared
// local variable, an input argument, or an output result.
-type Var struct {
+type goobj_Var struct {
// The combination of Name, Kind, and Offset uniquely
// identifies a variable in a function stack frame.
// Using fewer of these - in particular, using only Name - does not.
Kind int // TODO(rsc): Define meaning.
Offset int // Frame offset. TODO(rsc): Define meaning.
- Type SymID // Go type for variable.
+ Type goobj_SymID // Go type for variable.
}
// Func contains additional per-symbol information specific to functions.
-type Func struct {
- Args int // size in bytes of argument frame: inputs and outputs
- Frame int // size in bytes of local variable frame
- Leaf bool // function omits save of link register (ARM)
- NoSplit bool // function omits stack split prologue
- Var []Var // detail about local variables
- PCSP Data // PC → SP offset map
- PCFile Data // PC → file number map (index into File)
- PCLine Data // PC → line number map
- PCData []Data // PC → runtime support data map
- FuncData []FuncData // non-PC-specific runtime support data
- File []string // paths indexed by PCFile
+type goobj_Func struct {
+ Args int // size in bytes of argument frame: inputs and outputs
+ Frame int // size in bytes of local variable frame
+ Leaf bool // function omits save of link register (ARM)
+ NoSplit bool // function omits stack split prologue
+ Var []goobj_Var // detail about local variables
+ PCSP goobj_Data // PC → SP offset map
+ PCFile goobj_Data // PC → file number map (index into File)
+ PCLine goobj_Data // PC → line number map
+ PCData []goobj_Data // PC → runtime support data map
+ FuncData []goobj_FuncData // non-PC-specific runtime support data
+ File []string // paths indexed by PCFile
}
// TODO: Add PCData []byte and PCDataIter (similar to liblink).
// A FuncData is a single function-specific data value.
-type FuncData struct {
- Sym SymID // symbol holding data
- Offset int64 // offset into symbol for funcdata pointer
+type goobj_FuncData struct {
+ Sym goobj_SymID // symbol holding data
+ Offset int64 // offset into symbol for funcdata pointer
}
// A Package is a parsed Go object file or archive defining a Go package.
-type Package struct {
- ImportPath string // import path denoting this package
- Imports []string // packages imported by this package
- Syms []*Sym // symbols defined by this package
- MaxVersion int // maximum Version in any SymID in Syms
+type goobj_Package struct {
+ ImportPath string // import path denoting this package
+ Imports []string // packages imported by this package
+ Syms []*goobj_Sym // symbols defined by this package
+ MaxVersion int // maximum Version in any SymID in Syms
}
var (
- archiveHeader = []byte("!<arch>\n")
- archiveMagic = []byte("`\n")
- goobjHeader = []byte("go objec") // truncated to size of archiveHeader
+
goobj_archiveHeader = []byte("!<arch>\n")
+ goobj_archiveMagic = []byte("`\n")
+ goobj_goobjHeader = []byte("go objec") // truncated to size of archiveHeader
- errCorruptArchive = errors.New("corrupt archive")
- errTruncatedArchive = errors.New("truncated archive")
- errNotArchive = errors.New("unrecognized archive format")
+ goobj_errCorruptArchive = errors.New("corrupt archive")
+ goobj_errTruncatedArchive = errors.New("truncated archive")
+ goobj_errNotArchive = errors.New("unrecognized archive format")
- errCorruptObject = errors.New("corrupt object file")
- errTruncatedObject = errors.New("truncated object file")
- errNotObject = errors.New("unrecognized object file format")
+ goobj_errCorruptObject = errors.New("corrupt object file")
+ goobj_errTruncatedObject = errors.New("truncated object file")
+ goobj_errNotObject = errors.New("unrecognized object file format")
)
// An objReader is an object file reader.
-type objReader struct {
- p *Package
+type goobj_objReader struct {
+ p *goobj_Package
b *bufio.Reader
f io.ReadSeeker
err error
//
// See ../../../cmd/ld/lib.c:/^pathtoprefix and
// ../../../cmd/gc/subr.c:/^pathtoprefix.
-func importPathToPrefix(s string) string {
+func goobj_importPathToPrefix(s string) string {
// find index of last slash, if any, or else -1.
// used for determining whether an index is after the last slash.
slash := strings.LastIndex(s, "/")
}
// init initializes r to read package p from f.
-func (r *objReader) init(f io.ReadSeeker, p *Package) {
+func (r *goobj_objReader) init(f io.ReadSeeker, p *goobj_Package) {
r.f = f
r.p = p
r.offset, _ = f.Seek(0, 1)
r.limit, _ = f.Seek(0, 2)
f.Seek(r.offset, 0)
r.b = bufio.NewReader(f)
- r.pkgprefix = importPathToPrefix(p.ImportPath) + "."
+ r.pkgprefix = goobj_importPathToPrefix(p.ImportPath) + "."
}
// error records that an error occurred.
// It returns only the first error, so that an error
// caused by an earlier error does not discard information
// about the earlier error.
-func (r *objReader) error(err error) error {
+func (r *goobj_objReader) error(err error) error {
if r.err == nil {
if err == io.EOF {
err = io.ErrUnexpectedEOF
// A sequence of 0 bytes will eventually terminate any
// parsing state in the object file. In particular, it ends the
// reading of a varint.
-func (r *objReader) readByte() byte {
+func (r *goobj_objReader) readByte() byte {
if r.err != nil {
return 0
}
// If an error occurs, read returns the error but also
// records it, so it is safe for callers to ignore the result
// as long as delaying the report is not a problem.
-func (r *objReader) readFull(b []byte) error {
+func (r *goobj_objReader) readFull(b []byte) error {
if r.err != nil {
return r.err
}
}
// readInt reads a zigzag varint from the input file.
-func (r *objReader) readInt() int {
+func (r *goobj_objReader) readInt() int {
var u uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
- r.error(errCorruptObject)
+ r.error(goobj_errCorruptObject)
return 0
}
c := r.readByte()
v := int64(u>>1) ^ (int64(u) << 63 >> 63)
if int64(int(v)) != v {
- r.error(errCorruptObject) // TODO
+ r.error(goobj_errCorruptObject) // TODO
return 0
}
return int(v)
}
// readString reads a length-delimited string from the input file.
-func (r *objReader) readString() string {
+func (r *goobj_objReader) readString() string {
n := r.readInt()
buf := make([]byte, n)
r.readFull(buf)
}
// readSymID reads a SymID from the input file.
-func (r *objReader) readSymID() SymID {
+func (r *goobj_objReader) readSymID() goobj_SymID {
name, vers := r.readString(), r.readInt()
// In a symbol name in an object file, "". denotes the
vers = r.p.MaxVersion
}
- return SymID{name, vers}
+ return goobj_SymID{name, vers}
}
// readData reads a data reference from the input file.
-func (r *objReader) readData() Data {
+func (r *goobj_objReader) readData() goobj_Data {
n := r.readInt()
- d := Data{Offset: r.offset, Size: int64(n)}
+ d := goobj_Data{Offset: r.offset, Size: int64(n)}
r.skip(int64(n))
return d
}
// skip skips n bytes in the input.
-func (r *objReader) skip(n int64) {
+func (r *goobj_objReader) skip(n int64) {
if n < 0 {
r.error(fmt.Errorf("debug/goobj: internal error: misuse of skip"))
}
// Parse parses an object file or archive from r,
// assuming that its import path is pkgpath.
-func Parse(r io.ReadSeeker, pkgpath string) (*Package, error) {
+func goobj_Parse(r io.ReadSeeker, pkgpath string) (*goobj_Package, error) {
if pkgpath == "" {
pkgpath = `""`
}
- p := new(Package)
+ p := new(goobj_Package)
p.ImportPath = pkgpath
- var rd objReader
+ var rd goobj_objReader
rd.init(r, p)
err := rd.readFull(rd.tmp[:8])
if err != nil {
switch {
default:
- return nil, errNotObject
+ return nil, goobj_errNotObject
- case bytes.Equal(rd.tmp[:8], archiveHeader):
+ case bytes.Equal(rd.tmp[:8], goobj_archiveHeader):
if err := rd.parseArchive(); err != nil {
return nil, err
}
- case bytes.Equal(rd.tmp[:8], goobjHeader):
- if err := rd.parseObject(goobjHeader); err != nil {
+ case bytes.Equal(rd.tmp[:8], goobj_goobjHeader):
+ if err := rd.parseObject(goobj_goobjHeader); err != nil {
return nil, err
}
}
// trimSpace removes trailing spaces from b and returns the corresponding string.
// This effectively parses the form used in archive headers.
-func trimSpace(b []byte) string {
+func goobj_trimSpace(b []byte) string {
return string(bytes.TrimRight(b, " "))
}
// TODO(rsc): Need to skip non-Go object files.
// TODO(rsc): Maybe record table of contents in r.p so that
// linker can avoid having code to parse archives too.
-func (r *objReader) parseArchive() error {
+func (r *goobj_objReader) parseArchive() error {
for r.offset < r.limit {
if err := r.readFull(r.tmp[:60]); err != nil {
return err
// The file data that follows is padded to an even number of bytes:
// if size is odd, an extra padding byte is inserted betw the next header.
if len(data) < 60 {
- return errTruncatedArchive
+ return goobj_errTruncatedArchive
}
- if !bytes.Equal(data[58:60], archiveMagic) {
- return errCorruptArchive
+ if !bytes.Equal(data[58:60], goobj_archiveMagic) {
+ return goobj_errCorruptArchive
}
- name := trimSpace(data[0:16])
- size, err := strconv.ParseInt(trimSpace(data[48:58]), 10, 64)
+ name := goobj_trimSpace(data[0:16])
+ size, err := strconv.ParseInt(goobj_trimSpace(data[48:58]), 10, 64)
if err != nil {
- return errCorruptArchive
+ return goobj_errCorruptArchive
}
data = data[60:]
fsize := size + size&1
if fsize < 0 || fsize < size {
- return errCorruptArchive
+ return goobj_errCorruptArchive
}
switch name {
case "__.SYMDEF", "__.GOSYMDEF", "__.PKGDEF":
// and then the part we want to parse begins.
// The format of that part is defined in a comment at the top
// of src/liblink/objfile.c.
-func (r *objReader) parseObject(prefix []byte) error {
+func (r *goobj_objReader) parseObject(prefix []byte) error {
// TODO(rsc): Maybe use prefix and the initial input to
// record the header line from the file, which would
// give the architecture and other version information.
for {
c1, c2, c3 = c2, c3, r.readByte()
if c3 == 0 { // NUL or EOF, either is bad
- return errCorruptObject
+ return goobj_errCorruptObject
}
if c1 == '\n' && c2 == '!' && c3 == '\n' {
break
r.readFull(r.tmp[:8])
if !bytes.Equal(r.tmp[:8], []byte("\x00\x00go13ld")) {
- return r.error(errCorruptObject)
+ return r.error(goobj_errCorruptObject)
}
b := r.readByte()
if b != 1 {
- return r.error(errCorruptObject)
+ return r.error(goobj_errCorruptObject)
}
// Direct package dependencies.
for {
if b := r.readByte(); b != 0xfe {
if b != 0xff {
- return r.error(errCorruptObject)
+ return r.error(goobj_errCorruptObject)
}
break
}
typ := r.readInt()
- s := &Sym{SymID: r.readSymID()}
+ s := &goobj_Sym{goobj_SymID: r.readSymID()}
r.p.Syms = append(r.p.Syms, s)
- s.Kind = SymKind(typ)
+ s.Kind = goobj_SymKind(typ)
s.DupOK = r.readInt() != 0
s.Size = r.readInt()
s.Type = r.readSymID()
s.Data = r.readData()
- s.Reloc = make([]Reloc, r.readInt())
+ s.Reloc = make([]goobj_Reloc, r.readInt())
for i := range s.Reloc {
rel := &s.Reloc[i]
rel.Offset = r.readInt()
r.readSymID() // Xsym - ignored
}
- if s.Kind == STEXT {
- f := new(Func)
+ if s.Kind == goobj_STEXT {
+ f := new(goobj_Func)
s.Func = f
f.Args = r.readInt()
f.Frame = r.readInt()
f.Leaf = r.readInt() != 0
f.NoSplit = r.readInt() != 0
- f.Var = make([]Var, r.readInt())
+ f.Var = make([]goobj_Var, r.readInt())
for i := range f.Var {
v := &f.Var[i]
v.Name = r.readSymID().Name
f.PCSP = r.readData()
f.PCFile = r.readData()
f.PCLine = r.readData()
- f.PCData = make([]Data, r.readInt())
+ f.PCData = make([]goobj_Data, r.readInt())
for i := range f.PCData {
f.PCData[i] = r.readData()
}
- f.FuncData = make([]FuncData, r.readInt())
+ f.FuncData = make([]goobj_FuncData, r.readInt())
for i := range f.FuncData {
f.FuncData[i].Sym = r.readSymID()
}
r.readFull(r.tmp[:7])
if !bytes.Equal(r.tmp[:7], []byte("\xffgo13ld")) {
- return r.error(errCorruptObject)
+ return r.error(goobj_errCorruptObject)
}
return nil