gosym

type DecodingError ¶

type DecodingError struct {
	// contains filtered or unexported fields
}

DecodingError represents an error during the decoding of the symbol table.

func (e *DecodingError) Error() string

type Func ¶

type Func struct {
	Entry uint64
	*Sym
	End       uint64
	Params    []*Sym // nil for Go 1.3 and later binaries
	Locals    []*Sym // nil for Go 1.3 and later binaries
	FrameSize int
	LineTable *LineTable
	Obj       *Obj
}

A Func collects information about a single function.

type LineTable ¶

type LineTable struct {
	Data []byte
	PC   uint64
	Line int
	// contains filtered or unexported fields
}

A LineTable is a data structure mapping program counters to line numbers.

In Go 1.1 and earlier, each function (represented by a Func) had its own LineTable, and the line number corresponded to a numbering of all source lines in the program, across all files. That absolute line number would then have to be converted separately to a file name and line number within the file.

In Go 1.2, the format of the data changed so that there is a single LineTable for the entire program, shared by all Funcs, and there are no absolute line numbers, just line numbers within specific files.

For the most part, LineTable's methods should be treated as an internal detail of the package; callers should use the methods on Table instead.

func NewLineTable(data []byte, text uint64) *LineTable

func (t *LineTable) LineToPC(line int, maxpc uint64) uint64

func (t *LineTable) PCToLine(pc uint64) int

type Obj ¶

type Obj struct {
	// Funcs is a list of functions in the Obj.
	Funcs []Func

	// In Go 1.1 and earlier, Paths is a list of symbols corresponding
	// to the source file names that produced the Obj.
	// In Go 1.2, Paths is nil.
	// Use the keys of Table.Files to obtain a list of source files.
	Paths []Sym // meta
}

An Obj represents a collection of functions in a symbol table.

The exact method of division of a binary into separate Objs is an internal detail of the symbol table format.

In early versions of Go each source file became a different Obj.

In Go 1 and Go 1.1, each package produced one Obj for all Go sources and one Obj per C source file.

In Go 1.2, there is a single Obj for the entire program.

type Sym ¶

type Sym struct {
	Value  uint64
	Type   byte
	Name   string
	GoType uint64
	// If this symbol is a function symbol, the corresponding Func
	Func *Func
	// contains filtered or unexported fields
}

A Sym represents a single symbol table entry.

func (s *Sym) BaseName() string

func (s *Sym) PackageName() string

func (s *Sym) ReceiverName() string

func (s *Sym) Static() bool

type Table ¶

type Table struct {
	Syms  []Sym // nil for Go 1.3 and later binaries
	Funcs []Func
	Files map[string]*Obj // for Go 1.2 and later all files map to one Obj
	Objs  []Obj           // for Go 1.2 and later only one Obj in slice
	// contains filtered or unexported fields
}

Table represents a Go symbol table. It stores all of the symbols decoded from the program and provides methods to translate between symbols, names, and addresses.

func NewTable(symtab []byte, pcln *LineTable) (*Table, error)

func (t *Table) LineToPC(file string, line int) (pc uint64, fn *Func, err error)

func (t *Table) LookupFunc(name string) *Func

func (t *Table) LookupSym(name string) *Sym

func (t *Table) PCToFunc(pc uint64) *Func

func (t *Table) PCToLine(pc uint64) (file string, line int, fn *Func)

func (t *Table) SymByAddr(addr uint64) *Sym

type UnknownFileError ¶

type UnknownFileError string

UnknownFileError represents a failure to find the specific file in the symbol table.

func (e UnknownFileError) Error() string

type UnknownLineError ¶

type UnknownLineError struct {
	File string
	Line int
}

UnknownLineError represents a failure to map a line to a program counter, either because the line is beyond the bounds of the file or because there is no code on the given line.

func (e *UnknownLineError) Error() string