AbiSymKindToSymKind maps values read from object files (which are of type cmd/internal/objabi.SymKind) to values of type SymKind.
var AbiSymKindToSymKind = [...]SymKind{ Sxxx, STEXT, SRODATA, SNOPTRDATA, SDATA, SBSS, SNOPTRBSS, STLSBSS, SDWARFINFO, SDWARFRANGE, SDWARFLOC, }
ReadOnly are the symbol kinds that form read-only sections. In some cases, if they will require relocations, they are transformed into rel-ro sections using relROMap.
var ReadOnly = []SymKind{ STYPE, SSTRING, SGOSTRING, SGOFUNC, SGCBITS, SRODATA, SFUNCTAB, }
RelROMap describes the transformation of read-only symbols to rel-ro symbols.
var RelROMap = map[SymKind]SymKind{ STYPE: STYPERELRO, SSTRING: SSTRINGRELRO, SGOSTRING: SGOSTRINGRELRO, SGOFUNC: SGOFUNCRELRO, SGCBITS: SGCBITSRELRO, SRODATA: SRODATARELRO, SFUNCTAB: SFUNCTABRELRO, }
func RelocName(arch *sys.Arch, r objabi.RelocType) string
Attribute is a set of common symbol attributes.
type Attribute int32
const (
// AttrDuplicateOK marks a symbol that can be present in multiple object
// files.
AttrDuplicateOK Attribute = 1 << iota
// AttrExternal marks function symbols loaded from host object files.
AttrExternal
// AttrNoSplit marks functions that cannot split the stack; the linker
// cares because it checks that there are no call chains of nosplit
// functions that require more than StackLimit bytes (see
// lib.go:dostkcheck)
AttrNoSplit
// AttrReachable marks symbols that are transitively referenced from the
// entry points. Unreachable symbols are not written to the output.
AttrReachable
// AttrCgoExportDynamic and AttrCgoExportStatic mark symbols referenced
// by directives written by cgo (in response to //export directives in
// the source).
AttrCgoExportDynamic
AttrCgoExportStatic
// AttrSpecial marks symbols that do not have their address (i.e. Value)
// computed by the usual mechanism of data.go:dodata() &
// data.go:address().
AttrSpecial
// AttrStackCheck is used by dostkcheck to only check each NoSplit
// function's stack usage once.
AttrStackCheck
// AttrNotInSymbolTable marks symbols that are not written to the symbol table.
AttrNotInSymbolTable
// AttrOnList marks symbols that are on some list (such as the list of
// all text symbols, or one of the lists of data symbols) and is
// consulted to avoid bugs where a symbol is put on a list twice.
AttrOnList
// AttrLocal marks symbols that are only visible within the module
// (executable or shared library) being linked. Only relevant when
// dynamically linking Go code.
AttrLocal
// AttrReflectMethod marks certain methods from the reflect package that
// can be used to call arbitrary methods. If no symbol with this bit set
// is marked as reachable, more dead code elimination can be done.
AttrReflectMethod
// AttrMakeTypelink Amarks types that should be added to the typelink
// table. See typelinks.go:typelinks().
AttrMakeTypelink
// AttrShared marks symbols compiled with the -shared option.
// AttrVisibilityHidden symbols are ELF symbols with
// visibility set to STV_HIDDEN. They become local symbols in
// the final executable. Only relevant when internally linking
// on an ELF platform.
AttrVisibilityHidden
// AttrSubSymbol mostly means that the symbol appears on the Sub list of some
// other symbol. Unfortunately, it's not 100% reliable; at least, it's not set
// correctly for the .TOC. symbol in Link.dodata. Usually the Outer field of the
// symbol points to the symbol whose list it is on, but that it is not set for the
// symbols added to .windynamic in initdynimport in pe.go.
//
// TODO(mwhudson): fix the inconsistencies noticed above.
//
// Sub lists are used when loading host objects (sections from the host object
// become regular linker symbols and symbols go on the Sub list of their section)
// and for constructing the global offset table when internally linking a dynamic
// executable.
//
// TOOD(mwhudson): perhaps a better name for this is AttrNonGoSymbol.
AttrSubSymbol
// AttrContainer is set on text symbols that are present as the .Outer for some
// other symbol.
AttrContainer
)
func (a Attribute) CgoExport() bool
func (a Attribute) CgoExportDynamic() bool
func (a Attribute) CgoExportStatic() bool
func (a Attribute) Container() bool
func (a Attribute) DuplicateOK() bool
func (a Attribute) External() bool
func (a Attribute) Local() bool
func (a Attribute) MakeTypelink() bool
func (a Attribute) NoSplit() bool
func (a Attribute) NotInSymbolTable() bool
func (a Attribute) OnList() bool
func (a Attribute) Reachable() bool
func (a Attribute) ReflectMethod() bool
func (a *Attribute) Set(flag Attribute, value bool)
func (a Attribute) Shared() bool
func (a Attribute) Special() bool
func (a Attribute) StackCheck() bool
func (a Attribute) SubSymbol() bool
func (a Attribute) VisibilityHidden() bool
type Auto struct {
Asym *Symbol
Gotype *Symbol
Aoffset int32
Name int16
}
type FuncInfo struct {
Args int32
Locals int32
Autom []Auto
Pcsp Pcdata
Pcfile Pcdata
Pcline Pcdata
Pcinline Pcdata
Pcdata []Pcdata
Funcdata []*Symbol
Funcdataoff []int64
File []*Symbol
InlTree []InlinedCall
}
InlinedCall is a node in a local inlining tree (FuncInfo.InlTree).
type InlinedCall struct {
Parent int32 // index of parent in InlTree
File *Symbol // file of the inlined call
Line int32 // line number of the inlined call
Func *Symbol // function that was inlined
}
type Library struct {
Objref string
Srcref string
File string
Pkg string
Shlib string
Hash string
ImportStrings []string
Imports []*Library
Textp []*Symbol // text symbols defined in this library
DupTextSyms []*Symbol // dupok text symbols defined in this library
}
func (l Library) String() string
type Pcdata struct {
P []byte
}
Reloc is a relocation.
The typical Reloc rewrites part of a symbol at offset Off to address Sym. A Reloc is stored in a slice on the Symbol it rewrites.
Relocations are generated by the compiler as the type cmd/internal/obj.Reloc, which is encoded into the object file wire format and decoded by the linker into this type. A separate type is used to hold linker-specific state about the relocation.
Some relocations are created by cmd/link.
type Reloc struct {
Off int32 // offset to rewrite
Siz uint8 // number of bytes to rewrite, 1, 2, or 4
Done bool // set to true when relocation is complete
Variant RelocVariant // variation on Type
Type objabi.RelocType // the relocation type
Add int64 // addend
Xadd int64 // addend passed to external linker
Sym *Symbol // symbol the relocation addresses
Xsym *Symbol // symbol passed to external linker
}
RelocByOff implements sort.Interface for sorting relocations by offset.
type RelocByOff []Reloc
func (x RelocByOff) Len() int
func (x RelocByOff) Less(i, j int) bool
func (x RelocByOff) Swap(i, j int)
RelocVariant is a linker-internal variation on a relocation.
type RelocVariant uint8
const (
RV_NONE RelocVariant = iota
RV_POWER_LO
RV_POWER_HI
RV_POWER_HA
RV_POWER_DS
// RV_390_DBL is a s390x-specific relocation variant that indicates that
// the value to be placed into the relocatable field should first be
// divided by 2.
RV_390_DBL
RV_CHECK_OVERFLOW RelocVariant = 1 << 7
RV_TYPE_MASK RelocVariant = RV_CHECK_OVERFLOW - 1
)
type Section struct {
Rwx uint8
Extnum int16
Align int32
Name string
Vaddr uint64
Length uint64
Seg *Segment
Elfsect interface{} // an *ld.ElfShdr
Reloff uint64
Rellen uint64
}
type Segment struct {
Rwx uint8 // permission as usual unix bits (5 = r-x etc)
Vaddr uint64 // virtual address
Length uint64 // length in memory
Fileoff uint64 // file offset
Filelen uint64 // length on disk
Sections []*Section
}
A SymKind describes the kind of memory represented by a symbol.
type SymKind uint8
Defined SymKind values.
TODO(rsc): Give idiomatic Go names. go:generate stringer -type=SymKind
const (
Sxxx SymKind = iota
STEXT
SELFRXSECT
// Read-only sections.
STYPE
SSTRING
SGOSTRING
SGOFUNC
SGCBITS
SRODATA
SFUNCTAB
SELFROSECT
SMACHOPLT
// Read-only sections with relocations.
//
// Types STYPE-SFUNCTAB above are written to the .rodata section by default.
// When linking a shared object, some conceptually "read only" types need to
// be written to by relocations and putting them in a section called
// ".rodata" interacts poorly with the system linkers. The GNU linkers
// support this situation by arranging for sections of the name
// ".data.rel.ro.XXX" to be mprotected read only by the dynamic linker after
// relocations have applied, so when the Go linker is creating a shared
// object it checks all objects of the above types and bumps any object that
// has a relocation to it to the corresponding type below, which are then
// written to sections with appropriate magic names.
STYPERELRO
SSTRINGRELRO
SGOSTRINGRELRO
SGOFUNCRELRO
SGCBITSRELRO
SRODATARELRO
SFUNCTABRELRO
// Part of .data.rel.ro if it exists, otherwise part of .rodata.
STYPELINK
SITABLINK
SSYMTAB
SPCLNTAB
// Writable sections.
SELFSECT
SMACHO
SMACHOGOT
SWINDOWS
SELFGOT
SNOPTRDATA
SINITARR
SDATA
SBSS
SNOPTRBSS
STLSBSS
SXREF
SMACHOSYMSTR
SMACHOSYMTAB
SMACHOINDIRECTPLT
SMACHOINDIRECTGOT
SFILEPATH
SCONST
SDYNIMPORT
SHOSTOBJ
SDWARFSECT
SDWARFINFO
SDWARFRANGE
SDWARFLOC
)
func (i SymKind) String() string
Symbol is an entry in the symbol table.
type Symbol struct {
Name string
Extname string
Type SymKind
Version int16
Attr Attribute
Localentry uint8
Dynid int32
Plt int32
Got int32
Align int32
Elfsym int32
LocalElfsym int32
Value int64
Size int64
// ElfType is set for symbols read from shared libraries by ldshlibsyms. It
// is not set for symbols defined by the packages being linked or by symbols
// read by ldelf (and so is left as elf.STT_NOTYPE).
ElfType elf.SymType
Sub *Symbol
Outer *Symbol
Gotype *Symbol
Reachparent *Symbol
File string
Dynimplib string
Dynimpvers string
Sect *Section
FuncInfo *FuncInfo
Lib *Library // Package defining this symbol
// P contains the raw symbol data.
P []byte
R []Reloc
}
func SortSub(l *Symbol) *Symbol
SortSub sorts a linked-list (by Sub) of *Symbol by Value. Used for sub-symbols when loading host objects (see e.g. ldelf.go).
func (s *Symbol) AddAddr(arch *sys.Arch, t *Symbol) int64
func (s *Symbol) AddAddrPlus(arch *sys.Arch, t *Symbol, add int64) int64
func (s *Symbol) AddAddrPlus4(t *Symbol, add int64) int64
func (s *Symbol) AddBytes(bytes []byte) int64
func (s *Symbol) AddCURelativeAddrPlus(arch *sys.Arch, t *Symbol, add int64) int64
func (s *Symbol) AddPCRelPlus(arch *sys.Arch, t *Symbol, add int64) int64
func (s *Symbol) AddRel() *Reloc
func (s *Symbol) AddSize(arch *sys.Arch, t *Symbol) int64
func (s *Symbol) AddUint(arch *sys.Arch, v uint64) int64
func (s *Symbol) AddUint16(arch *sys.Arch, v uint16) int64
func (s *Symbol) AddUint32(arch *sys.Arch, v uint32) int64
func (s *Symbol) AddUint64(arch *sys.Arch, v uint64) int64
func (s *Symbol) AddUint8(v uint8) int64
func (s *Symbol) AddUintXX(arch *sys.Arch, v uint64, wid int) int64
func (s *Symbol) ElfsymForReloc() int32
func (s *Symbol) Grow(siz int64)
func (s *Symbol) Len() int64
func (s *Symbol) SetAddr(arch *sys.Arch, off int64, t *Symbol) int64
func (s *Symbol) SetAddrPlus(arch *sys.Arch, off int64, t *Symbol, add int64) int64
func (s *Symbol) SetUint(arch *sys.Arch, r int64, v uint64) int64
func (s *Symbol) SetUint32(arch *sys.Arch, r int64, v uint32) int64
func (s *Symbol) SetUint8(arch *sys.Arch, r int64, v uint8) int64
func (s *Symbol) String() string
type Symbols struct {
Allsym []*Symbol
// contains filtered or unexported fields
}
func NewSymbols() *Symbols
func (syms *Symbols) IncVersion() int
Allocate a new version (i.e. symbol namespace).
func (syms *Symbols) Lookup(name string, v int) *Symbol
Look up the symbol with the given name and version, creating the symbol if it is not found.
func (syms *Symbols) Newsym(name string, v int) *Symbol
func (syms *Symbols) ROLookup(name string, v int) *Symbol
Look up the symbol with the given name and version, returning nil if it is not found.
func (syms *Symbols) Rename(old, new string, v int)
Rename renames a symbol.