type Data struct {
Offset int64
Size int64
}
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 Func struct {
Args int64 // size in bytes of argument frame: inputs and outputs
Frame int64 // size in bytes of local variable frame
Leaf bool // function omits save of link register (ARM)
NoSplit bool // function omits stack split prologue
TopFrame bool // function is the top of the call stack
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
PCInline Data // PC → inline tree index map
PCData []Data // PC → runtime support data map
FuncData []FuncData // non-PC-specific runtime support data
File []string // paths indexed by PCFile
InlTree []InlinedCall
}
Func contains additional per-symbol information specific to functions.
type FuncData struct {
Sym SymID // symbol holding data
Offset int64 // offset into symbol for funcdata pointer
}
A FuncData is a single function-specific data value.
type InlinedCall struct {
Parent int64
File string
Line int64
Func SymID
ParentPC int64
}
An InlinedCall is a node in an InlTree. See cmd/internal/obj.InlTree for details.
type NativeReader struct {
Name string
io.ReaderAt
}
type Package struct {
ImportPath string // import path denoting this package
Imports []string // packages imported by this package
SymRefs []SymID // list of symbol names and versions referred to by this pack
Syms []*Sym // symbols defined by this package
MaxVersion int64 // maximum Version in any SymID in Syms
Arch string // architecture
Native []*NativeReader // native object data (e.g. ELF)
}
A Package is a parsed Go object file or archive defining a Go package.
func Parse(f *os.File, pkgpath string) (*Package, error)
Parse parses an object file or archive from f, assuming that its import path is pkgpath.
type Reloc struct {
// The bytes at [Offset, Offset+Size) within the containing Sym
// should be updated to refer to the address Add bytes after the start
// of the symbol Sym.
Offset int64
Size int64
Sym SymID
Add int64
// The Type records the form of address expected in the bytes
// described by the previous fields: absolute, PC-relative, and so on.
// TODO(rsc): The interpretation of Type is not exposed by this package.
Type objabi.RelocType
}
A Reloc describes a relocation applied to a memory image to refer to an address within a particular symbol.
func (r *Reloc) String(insnOffset uint64) string
type Sym struct {
SymID // symbol identifier (name and version)
Kind objabi.SymKind // kind of symbol
DupOK bool // are duplicate definitions okay?
Size int64 // 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
}
A Sym is a named symbol in an object file.
type SymID struct {
// Name is the name of a symbol.
Name string
// Version is zero for symbols with global visibility.
// Symbols with only file visibility (such as file-level static
// declarations in C) have a non-zero version distinguishing
// a symbol in one file from a symbol of the same name
// in another file
Version int64
}
A SymID - the combination of Name and Version - uniquely identifies a symbol within a package.
func (s SymID) String() string
type 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.
Name string // Name of variable.
Kind int64 // TODO(rsc): Define meaning.
Offset int64 // Frame offset. TODO(rsc): Define meaning.
Type SymID // Go type for variable.
}
A Var describes a variable in a function stack frame: a declared local variable, an input argument, or an output result.