go: github.com/golang/go/src/cmd/internal/goobj Index | Files

package goobj

import "github.com/golang/go/src/cmd/internal/goobj"

Package goobj implements reading of Go object files and archives.

TODO(rsc): Decide where this package should live. (golang.org/issue/6932) TODO(rsc): Decide the appropriate integer types for various fields.

Index

Package Files

read.go readnew.go

type Data Uses

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 Uses

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 Uses

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 Uses

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 Uses

type NativeReader struct {
    Name string
    io.ReaderAt
}

type Package Uses

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)
    DWARFFileList []string        // List of files for the DWARF .debug_lines section
}

A Package is a parsed Go object file or archive defining a Go package.

func Parse Uses

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 Uses

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 (*Reloc) String Uses

func (r *Reloc) String(insnOffset uint64) string

type Sym Uses

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 Uses

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 (SymID) String Uses

func (s SymID) String() string

type Var Uses

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.

Package goobj imports 10 packages (graph) and is imported by 1 packages. Updated 2019-11-08. Refresh now. Tools for package owners.

The go get command cannot install this package because of the following issues: