mirror of
https://github.com/golang/go.git
synced 2025-05-14 20:04:39 +00:00
e77639f3a4
Sort DynidSyms to ensure a deterministic build. Fix Solaris build. Change-Id: I6c01cb3dec5e46b3d881e720e3c2079643b5c7c7 Reviewed-on: https://go-review.googlesource.com/c/go/+/230277 Run-TryBot: Cherry Zhang <cherryyz@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Than McIntosh <thanm@google.com> Reviewed-by: Jeremy Faller <jeremy@golang.org>
2871 lines
83 KiB
Go
2871 lines
83 KiB
Go
// Copyright 2019 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.
|
|
|
|
package loader
|
|
|
|
import (
|
|
"bytes"
|
|
"cmd/internal/bio"
|
|
"cmd/internal/goobj2"
|
|
"cmd/internal/obj"
|
|
"cmd/internal/objabi"
|
|
"cmd/internal/sys"
|
|
"cmd/link/internal/sym"
|
|
"debug/elf"
|
|
"fmt"
|
|
"log"
|
|
"math/bits"
|
|
"os"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
var _ = fmt.Print
|
|
|
|
// Sym encapsulates a global symbol index, used to identify a specific
|
|
// Go symbol. The 0-valued Sym is corresponds to an invalid symbol.
|
|
type Sym int
|
|
|
|
// Relocs encapsulates the set of relocations on a given symbol; an
|
|
// instance of this type is returned by the Loader Relocs() method.
|
|
type Relocs struct {
|
|
rs []goobj2.Reloc
|
|
|
|
li int // local index of symbol whose relocs we're examining
|
|
r *oReader // object reader for containing package
|
|
l *Loader // loader
|
|
}
|
|
|
|
// Reloc contains the payload for a specific relocation.
|
|
// TODO: replace this with sym.Reloc, once we change the
|
|
// relocation target from "*sym.Symbol" to "loader.Sym" in sym.Reloc.
|
|
type Reloc struct {
|
|
Off int32 // offset to rewrite
|
|
Size uint8 // number of bytes to rewrite: 0, 1, 2, or 4
|
|
Type objabi.RelocType // the relocation type
|
|
Add int64 // addend
|
|
Sym Sym // global index of symbol the reloc addresses
|
|
}
|
|
|
|
// Reloc2 holds a "handle" to access a relocation record from an
|
|
// object file.
|
|
type Reloc2 struct {
|
|
*goobj2.Reloc
|
|
r *oReader
|
|
l *Loader
|
|
|
|
// External reloc types may not fit into a uint8 which the Go object file uses.
|
|
// Store it here, instead of in the byte of goobj2.Reloc2.
|
|
// For Go symbols this will always be zero.
|
|
// goobj2.Reloc2.Type() + typ is always the right type, for both Go and external
|
|
// symbols.
|
|
typ objabi.RelocType
|
|
}
|
|
|
|
func (rel Reloc2) Type() objabi.RelocType { return objabi.RelocType(rel.Reloc.Type()) + rel.typ }
|
|
func (rel Reloc2) Sym() Sym { return rel.l.resolve(rel.r, rel.Reloc.Sym()) }
|
|
func (rel Reloc2) SetSym(s Sym) { rel.Reloc.SetSym(goobj2.SymRef{PkgIdx: 0, SymIdx: uint32(s)}) }
|
|
|
|
func (rel Reloc2) SetType(t objabi.RelocType) {
|
|
if t != objabi.RelocType(uint8(t)) {
|
|
panic("SetType: type doesn't fit into Reloc2")
|
|
}
|
|
rel.Reloc.SetType(uint8(t))
|
|
if rel.typ != 0 {
|
|
// should use SymbolBuilder.SetRelocType
|
|
panic("wrong method to set reloc type")
|
|
}
|
|
}
|
|
|
|
// Aux2 holds a "handle" to access an aux symbol record from an
|
|
// object file.
|
|
type Aux2 struct {
|
|
*goobj2.Aux
|
|
r *oReader
|
|
l *Loader
|
|
}
|
|
|
|
func (a Aux2) Sym() Sym { return a.l.resolve(a.r, a.Aux.Sym()) }
|
|
|
|
// oReader is a wrapper type of obj.Reader, along with some
|
|
// extra information.
|
|
// TODO: rename to objReader once the old one is gone?
|
|
type oReader struct {
|
|
*goobj2.Reader
|
|
unit *sym.CompilationUnit
|
|
version int // version of static symbol
|
|
flags uint32 // read from object file
|
|
pkgprefix string
|
|
syms []Sym // Sym's global index, indexed by local index
|
|
ndef int // cache goobj2.Reader.NSym()
|
|
objidx uint32 // index of this reader in the objs slice
|
|
}
|
|
|
|
type objIdx struct {
|
|
r *oReader
|
|
i Sym // start index
|
|
}
|
|
|
|
// objSym represents a symbol in an object file. It is a tuple of
|
|
// the object and the symbol's local index.
|
|
// For external symbols, r is l.extReader, s is its index into the
|
|
// payload array.
|
|
// {nil, 0} represents the nil symbol.
|
|
type objSym struct {
|
|
r *oReader
|
|
s int // local index
|
|
}
|
|
|
|
type nameVer struct {
|
|
name string
|
|
v int
|
|
}
|
|
|
|
type Bitmap []uint32
|
|
|
|
// set the i-th bit.
|
|
func (bm Bitmap) Set(i Sym) {
|
|
n, r := uint(i)/32, uint(i)%32
|
|
bm[n] |= 1 << r
|
|
}
|
|
|
|
// unset the i-th bit.
|
|
func (bm Bitmap) Unset(i Sym) {
|
|
n, r := uint(i)/32, uint(i)%32
|
|
bm[n] &^= (1 << r)
|
|
}
|
|
|
|
// whether the i-th bit is set.
|
|
func (bm Bitmap) Has(i Sym) bool {
|
|
n, r := uint(i)/32, uint(i)%32
|
|
return bm[n]&(1<<r) != 0
|
|
}
|
|
|
|
// return current length of bitmap in bits.
|
|
func (bm Bitmap) Len() int {
|
|
return len(bm) * 32
|
|
}
|
|
func MakeBitmap(n int) Bitmap {
|
|
return make(Bitmap, (n+31)/32)
|
|
}
|
|
|
|
// growBitmap insures that the specified bitmap has enough capacity,
|
|
// reallocating (doubling the size) if needed.
|
|
func growBitmap(reqLen int, b Bitmap) Bitmap {
|
|
curLen := b.Len()
|
|
if reqLen > curLen {
|
|
b = append(b, MakeBitmap(reqLen+1-curLen)...)
|
|
}
|
|
return b
|
|
}
|
|
|
|
// A Loader loads new object files and resolves indexed symbol references.
|
|
//
|
|
// Notes on the layout of global symbol index space:
|
|
//
|
|
// - Go object files are read before host object files; each Go object
|
|
// read adds its defined package symbols to the global index space.
|
|
// Nonpackage symbols are not yet added.
|
|
//
|
|
// - In loader.LoadNonpkgSyms, add non-package defined symbols and
|
|
// references in all object files to the global index space.
|
|
//
|
|
// - Host object file loading happens; the host object loader does a
|
|
// name/version lookup for each symbol it finds; this can wind up
|
|
// extending the external symbol index space range. The host object
|
|
// loader stores symbol payloads in loader.payloads using SymbolBuilder.
|
|
//
|
|
// - For now, in loader.LoadFull we convert all symbols (Go + external)
|
|
// to sym.Symbols.
|
|
//
|
|
// - At some point (when the wayfront is pushed through all of the
|
|
// linker), all external symbols will be payload-based, and we can
|
|
// get rid of the loader.Syms array.
|
|
//
|
|
// - Each symbol gets a unique global index. For duplicated and
|
|
// overwriting/overwritten symbols, the second (or later) appearance
|
|
// of the symbol gets the same global index as the first appearance.
|
|
type Loader struct {
|
|
start map[*oReader]Sym // map from object file to its start index
|
|
objs []objIdx // sorted by start index (i.e. objIdx.i)
|
|
extStart Sym // from this index on, the symbols are externally defined
|
|
builtinSyms []Sym // global index of builtin symbols
|
|
|
|
objSyms []objSym // global index mapping to local index
|
|
|
|
symsByName [2]map[string]Sym // map symbol name to index, two maps are for ABI0 and ABIInternal
|
|
extStaticSyms map[nameVer]Sym // externally defined static symbols, keyed by name
|
|
|
|
extReader *oReader // a dummy oReader, for external symbols
|
|
payloadBatch []extSymPayload
|
|
payloads []*extSymPayload // contents of linker-materialized external syms
|
|
values []int64 // symbol values, indexed by global sym index
|
|
|
|
sects []*sym.Section // sections
|
|
symSects []uint16 // symbol's section, index to sects array
|
|
|
|
itablink map[Sym]struct{} // itablink[j] defined if j is go.itablink.*
|
|
|
|
objByPkg map[string]*oReader // map package path to its Go object reader
|
|
|
|
Syms []*sym.Symbol // indexed symbols. XXX we still make sym.Symbol for now.
|
|
symBatch []sym.Symbol // batch of symbols.
|
|
|
|
anonVersion int // most recently assigned ext static sym pseudo-version
|
|
|
|
// Bitmaps and other side structures used to store data used to store
|
|
// symbol flags/attributes; these are to be accessed via the
|
|
// corresponding loader "AttrXXX" and "SetAttrXXX" methods. Please
|
|
// visit the comments on these methods for more details on the
|
|
// semantics / interpretation of the specific flags or attribute.
|
|
attrReachable Bitmap // reachable symbols, indexed by global index
|
|
attrOnList Bitmap // "on list" symbols, indexed by global index
|
|
attrLocal Bitmap // "local" symbols, indexed by global index
|
|
attrNotInSymbolTable Bitmap // "not in symtab" symbols, indexed by glob idx
|
|
attrVisibilityHidden Bitmap // hidden symbols, indexed by ext sym index
|
|
attrDuplicateOK Bitmap // dupOK symbols, indexed by ext sym index
|
|
attrShared Bitmap // shared symbols, indexed by ext sym index
|
|
attrExternal Bitmap // external symbols, indexed by ext sym index
|
|
|
|
attrReadOnly map[Sym]bool // readonly data for this sym
|
|
attrTopFrame map[Sym]struct{} // top frame symbols
|
|
attrSpecial map[Sym]struct{} // "special" frame symbols
|
|
attrCgoExportDynamic map[Sym]struct{} // "cgo_export_dynamic" symbols
|
|
attrCgoExportStatic map[Sym]struct{} // "cgo_export_static" symbols
|
|
|
|
// Outer and Sub relations for symbols.
|
|
// TODO: figure out whether it's more efficient to just have these
|
|
// as fields on extSymPayload (note that this won't be a viable
|
|
// strategy if somewhere in the linker we set sub/outer for a
|
|
// non-external sym).
|
|
outer map[Sym]Sym
|
|
sub map[Sym]Sym
|
|
|
|
align map[Sym]int32 // stores alignment for symbols
|
|
|
|
dynimplib map[Sym]string // stores Dynimplib symbol attribute
|
|
dynimpvers map[Sym]string // stores Dynimpvers symbol attribute
|
|
localentry map[Sym]uint8 // stores Localentry symbol attribute
|
|
extname map[Sym]string // stores Extname symbol attribute
|
|
elfType map[Sym]elf.SymType // stores elf type symbol property
|
|
symPkg map[Sym]string // stores package for symbol, or library for shlib-derived syms
|
|
plt map[Sym]int32 // stores dynimport for pe objects
|
|
got map[Sym]int32 // stores got for pe objects
|
|
dynid map[Sym]int32 // stores Dynid for symbol
|
|
|
|
relocVariant map[relocId]sym.RelocVariant // stores variant relocs
|
|
|
|
// Used to implement field tracking; created during deadcode if
|
|
// field tracking is enabled. Reachparent[K] contains the index of
|
|
// the symbol that triggered the marking of symbol K as live.
|
|
Reachparent []Sym
|
|
|
|
relocBatch []sym.Reloc // for bulk allocation of relocations
|
|
|
|
flags uint32
|
|
|
|
strictDupMsgs int // number of strict-dup warning/errors, when FlagStrictDups is enabled
|
|
|
|
elfsetstring elfsetstringFunc
|
|
|
|
errorReporter *ErrorReporter
|
|
|
|
SymLookup func(name string, ver int) *sym.Symbol
|
|
}
|
|
|
|
const (
|
|
pkgDef = iota
|
|
nonPkgDef
|
|
nonPkgRef
|
|
)
|
|
|
|
type elfsetstringFunc func(s *sym.Symbol, str string, off int)
|
|
|
|
// extSymPayload holds the payload (data + relocations) for linker-synthesized
|
|
// external symbols (note that symbol value is stored in a separate slice).
|
|
type extSymPayload struct {
|
|
name string // TODO: would this be better as offset into str table?
|
|
size int64
|
|
ver int
|
|
kind sym.SymKind
|
|
objidx uint32 // index of original object if sym made by cloneToExternal
|
|
gotype Sym // Gotype (0 if not present)
|
|
relocs []goobj2.Reloc
|
|
reltypes []objabi.RelocType // relocation types
|
|
data []byte
|
|
auxs []goobj2.Aux
|
|
}
|
|
|
|
const (
|
|
// Loader.flags
|
|
FlagStrictDups = 1 << iota
|
|
)
|
|
|
|
func NewLoader(flags uint32, elfsetstring elfsetstringFunc, reporter *ErrorReporter) *Loader {
|
|
nbuiltin := goobj2.NBuiltin()
|
|
ldr := &Loader{
|
|
start: make(map[*oReader]Sym),
|
|
objs: []objIdx{{}}, // reserve index 0 for nil symbol
|
|
objSyms: []objSym{{}}, // reserve index 0 for nil symbol
|
|
extReader: &oReader{},
|
|
symsByName: [2]map[string]Sym{make(map[string]Sym, 100000), make(map[string]Sym, 50000)}, // preallocate ~2MB for ABI0 and ~1MB for ABI1 symbols
|
|
objByPkg: make(map[string]*oReader),
|
|
outer: make(map[Sym]Sym),
|
|
sub: make(map[Sym]Sym),
|
|
align: make(map[Sym]int32),
|
|
dynimplib: make(map[Sym]string),
|
|
dynimpvers: make(map[Sym]string),
|
|
localentry: make(map[Sym]uint8),
|
|
extname: make(map[Sym]string),
|
|
attrReadOnly: make(map[Sym]bool),
|
|
elfType: make(map[Sym]elf.SymType),
|
|
symPkg: make(map[Sym]string),
|
|
plt: make(map[Sym]int32),
|
|
got: make(map[Sym]int32),
|
|
dynid: make(map[Sym]int32),
|
|
attrTopFrame: make(map[Sym]struct{}),
|
|
attrSpecial: make(map[Sym]struct{}),
|
|
attrCgoExportDynamic: make(map[Sym]struct{}),
|
|
attrCgoExportStatic: make(map[Sym]struct{}),
|
|
itablink: make(map[Sym]struct{}),
|
|
extStaticSyms: make(map[nameVer]Sym),
|
|
builtinSyms: make([]Sym, nbuiltin),
|
|
flags: flags,
|
|
elfsetstring: elfsetstring,
|
|
errorReporter: reporter,
|
|
sects: []*sym.Section{nil}, // reserve index 0 for nil section
|
|
}
|
|
reporter.ldr = ldr
|
|
return ldr
|
|
}
|
|
|
|
// Add object file r, return the start index.
|
|
func (l *Loader) addObj(pkg string, r *oReader) Sym {
|
|
if _, ok := l.start[r]; ok {
|
|
panic("already added")
|
|
}
|
|
pkg = objabi.PathToPrefix(pkg) // the object file contains escaped package path
|
|
if _, ok := l.objByPkg[pkg]; !ok {
|
|
l.objByPkg[pkg] = r
|
|
}
|
|
i := Sym(len(l.objSyms))
|
|
l.start[r] = i
|
|
l.objs = append(l.objs, objIdx{r, i})
|
|
return i
|
|
}
|
|
|
|
// Add a symbol from an object file, return the global index and whether it is added.
|
|
// If the symbol already exist, it returns the index of that symbol.
|
|
func (l *Loader) AddSym(name string, ver int, r *oReader, li int, kind int, dupok bool, typ sym.SymKind) (Sym, bool) {
|
|
if l.extStart != 0 {
|
|
panic("AddSym called after external symbol is created")
|
|
}
|
|
i := Sym(len(l.objSyms))
|
|
addToGlobal := func() {
|
|
l.objSyms = append(l.objSyms, objSym{r, li})
|
|
}
|
|
if name == "" {
|
|
addToGlobal()
|
|
return i, true // unnamed aux symbol
|
|
}
|
|
if ver == r.version {
|
|
// Static symbol. Add its global index but don't
|
|
// add to name lookup table, as it cannot be
|
|
// referenced by name.
|
|
addToGlobal()
|
|
return i, true
|
|
}
|
|
if kind == pkgDef {
|
|
// Defined package symbols cannot be dup to each other.
|
|
// We load all the package symbols first, so we don't need
|
|
// to check dup here.
|
|
// We still add it to the lookup table, as it may still be
|
|
// referenced by name (e.g. through linkname).
|
|
l.symsByName[ver][name] = i
|
|
addToGlobal()
|
|
return i, true
|
|
}
|
|
|
|
// Non-package (named) symbol. Check if it already exists.
|
|
oldi, existed := l.symsByName[ver][name]
|
|
if !existed {
|
|
l.symsByName[ver][name] = i
|
|
addToGlobal()
|
|
return i, true
|
|
}
|
|
// symbol already exists
|
|
if dupok {
|
|
if l.flags&FlagStrictDups != 0 {
|
|
l.checkdup(name, r, li, oldi)
|
|
}
|
|
return oldi, false
|
|
}
|
|
oldr, oldli := l.toLocal(oldi)
|
|
oldsym := oldr.Sym(oldli)
|
|
if oldsym.Dupok() {
|
|
return oldi, false
|
|
}
|
|
overwrite := r.DataSize(li) != 0
|
|
if overwrite {
|
|
// new symbol overwrites old symbol.
|
|
oldtyp := sym.AbiSymKindToSymKind[objabi.SymKind(oldsym.Type())]
|
|
if !(oldtyp.IsData() && oldr.DataSize(oldli) == 0) {
|
|
log.Fatalf("duplicated definition of symbol " + name)
|
|
}
|
|
l.objSyms[oldi] = objSym{r, li}
|
|
} else {
|
|
// old symbol overwrites new symbol.
|
|
if !typ.IsData() { // only allow overwriting data symbol
|
|
log.Fatalf("duplicated definition of symbol " + name)
|
|
}
|
|
}
|
|
return oldi, true
|
|
}
|
|
|
|
// newExtSym creates a new external sym with the specified
|
|
// name/version.
|
|
func (l *Loader) newExtSym(name string, ver int) Sym {
|
|
i := Sym(len(l.objSyms))
|
|
if l.extStart == 0 {
|
|
l.extStart = i
|
|
}
|
|
l.growSyms(int(i))
|
|
pi := l.newPayload(name, ver)
|
|
l.objSyms = append(l.objSyms, objSym{l.extReader, int(pi)})
|
|
l.extReader.syms = append(l.extReader.syms, i)
|
|
return i
|
|
}
|
|
|
|
// LookupOrCreateSym looks up the symbol with the specified name/version,
|
|
// returning its Sym index if found. If the lookup fails, a new external
|
|
// Sym will be created, entered into the lookup tables, and returned.
|
|
func (l *Loader) LookupOrCreateSym(name string, ver int) Sym {
|
|
i := l.Lookup(name, ver)
|
|
if i != 0 {
|
|
return i
|
|
}
|
|
i = l.newExtSym(name, ver)
|
|
static := ver >= sym.SymVerStatic || ver < 0
|
|
if static {
|
|
l.extStaticSyms[nameVer{name, ver}] = i
|
|
} else {
|
|
l.symsByName[ver][name] = i
|
|
}
|
|
return i
|
|
}
|
|
|
|
func (l *Loader) IsExternal(i Sym) bool {
|
|
r, _ := l.toLocal(i)
|
|
return l.isExtReader(r)
|
|
}
|
|
|
|
func (l *Loader) isExtReader(r *oReader) bool {
|
|
return r == l.extReader
|
|
}
|
|
|
|
// For external symbol, return its index in the payloads array.
|
|
// XXX result is actually not a global index. We (ab)use the Sym type
|
|
// so we don't need conversion for accessing bitmaps.
|
|
func (l *Loader) extIndex(i Sym) Sym {
|
|
_, li := l.toLocal(i)
|
|
return Sym(li)
|
|
}
|
|
|
|
// Get a new payload for external symbol, return its index in
|
|
// the payloads array.
|
|
func (l *Loader) newPayload(name string, ver int) int {
|
|
pi := len(l.payloads)
|
|
pp := l.allocPayload()
|
|
pp.name = name
|
|
pp.ver = ver
|
|
l.payloads = append(l.payloads, pp)
|
|
l.growExtAttrBitmaps()
|
|
return pi
|
|
}
|
|
|
|
// getPayload returns a pointer to the extSymPayload struct for an
|
|
// external symbol if the symbol has a payload. Will panic if the
|
|
// symbol in question is bogus (zero or not an external sym).
|
|
func (l *Loader) getPayload(i Sym) *extSymPayload {
|
|
if !l.IsExternal(i) {
|
|
panic(fmt.Sprintf("bogus symbol index %d in getPayload", i))
|
|
}
|
|
pi := l.extIndex(i)
|
|
return l.payloads[pi]
|
|
}
|
|
|
|
// allocPayload allocates a new payload.
|
|
func (l *Loader) allocPayload() *extSymPayload {
|
|
batch := l.payloadBatch
|
|
if len(batch) == 0 {
|
|
batch = make([]extSymPayload, 1000)
|
|
}
|
|
p := &batch[0]
|
|
l.payloadBatch = batch[1:]
|
|
return p
|
|
}
|
|
|
|
func (ms *extSymPayload) Grow(siz int64) {
|
|
if int64(int(siz)) != siz {
|
|
log.Fatalf("symgrow size %d too long", siz)
|
|
}
|
|
if int64(len(ms.data)) >= siz {
|
|
return
|
|
}
|
|
if cap(ms.data) < int(siz) {
|
|
cl := len(ms.data)
|
|
ms.data = append(ms.data, make([]byte, int(siz)+1-cl)...)
|
|
ms.data = ms.data[0:cl]
|
|
}
|
|
ms.data = ms.data[:siz]
|
|
}
|
|
|
|
// Ensure Syms slice has enough space.
|
|
func (l *Loader) growSyms(i int) {
|
|
n := len(l.Syms)
|
|
if n > i {
|
|
return
|
|
}
|
|
l.Syms = append(l.Syms, make([]*sym.Symbol, i+1-n)...)
|
|
l.growValues(int(i) + 1)
|
|
l.growAttrBitmaps(int(i) + 1)
|
|
}
|
|
|
|
// Convert a local index to a global index.
|
|
func (l *Loader) toGlobal(r *oReader, i int) Sym {
|
|
return r.syms[i]
|
|
}
|
|
|
|
// Convert a global index to a local index.
|
|
func (l *Loader) toLocal(i Sym) (*oReader, int) {
|
|
return l.objSyms[i].r, int(l.objSyms[i].s)
|
|
}
|
|
|
|
// Resolve a local symbol reference. Return global index.
|
|
func (l *Loader) resolve(r *oReader, s goobj2.SymRef) Sym {
|
|
var rr *oReader
|
|
switch p := s.PkgIdx; p {
|
|
case goobj2.PkgIdxInvalid:
|
|
// {0, X} with non-zero X is never a valid sym reference from a Go object.
|
|
// We steal this space for symbol references from external objects.
|
|
// In this case, X is just the global index.
|
|
if l.isExtReader(r) {
|
|
return Sym(s.SymIdx)
|
|
}
|
|
if s.SymIdx != 0 {
|
|
panic("bad sym ref")
|
|
}
|
|
return 0
|
|
case goobj2.PkgIdxNone:
|
|
i := int(s.SymIdx) + r.ndef
|
|
return r.syms[i]
|
|
case goobj2.PkgIdxBuiltin:
|
|
return l.builtinSyms[s.SymIdx]
|
|
case goobj2.PkgIdxSelf:
|
|
rr = r
|
|
default:
|
|
pkg := r.Pkg(int(p))
|
|
var ok bool
|
|
rr, ok = l.objByPkg[pkg]
|
|
if !ok {
|
|
log.Fatalf("reference of nonexisted package %s, from %v", pkg, r.unit.Lib)
|
|
}
|
|
}
|
|
return l.toGlobal(rr, int(s.SymIdx))
|
|
}
|
|
|
|
// Look up a symbol by name, return global index, or 0 if not found.
|
|
// This is more like Syms.ROLookup than Lookup -- it doesn't create
|
|
// new symbol.
|
|
func (l *Loader) Lookup(name string, ver int) Sym {
|
|
if ver >= sym.SymVerStatic || ver < 0 {
|
|
return l.extStaticSyms[nameVer{name, ver}]
|
|
}
|
|
return l.symsByName[ver][name]
|
|
}
|
|
|
|
// Check that duplicate symbols have same contents.
|
|
func (l *Loader) checkdup(name string, r *oReader, li int, dup Sym) {
|
|
p := r.Data(li)
|
|
rdup, ldup := l.toLocal(dup)
|
|
pdup := rdup.Data(ldup)
|
|
if bytes.Equal(p, pdup) {
|
|
return
|
|
}
|
|
reason := "same length but different contents"
|
|
if len(p) != len(pdup) {
|
|
reason = fmt.Sprintf("new length %d != old length %d", len(p), len(pdup))
|
|
}
|
|
fmt.Fprintf(os.Stderr, "cmd/link: while reading object for '%v': duplicate symbol '%s', previous def at '%v', with mismatched payload: %s\n", r.unit.Lib, name, rdup.unit.Lib, reason)
|
|
|
|
// For the moment, whitelist DWARF subprogram DIEs for
|
|
// auto-generated wrapper functions. What seems to happen
|
|
// here is that we get different line numbers on formal
|
|
// params; I am guessing that the pos is being inherited
|
|
// from the spot where the wrapper is needed.
|
|
whitelist := strings.HasPrefix(name, "go.info.go.interface") ||
|
|
strings.HasPrefix(name, "go.info.go.builtin") ||
|
|
strings.HasPrefix(name, "go.debuglines")
|
|
if !whitelist {
|
|
l.strictDupMsgs++
|
|
}
|
|
}
|
|
|
|
func (l *Loader) NStrictDupMsgs() int { return l.strictDupMsgs }
|
|
|
|
// Number of total symbols.
|
|
func (l *Loader) NSym() int {
|
|
return len(l.objSyms)
|
|
}
|
|
|
|
// Number of defined Go symbols.
|
|
func (l *Loader) NDef() int {
|
|
return int(l.extStart)
|
|
}
|
|
|
|
// Returns the raw (unpatched) name of the i-th symbol.
|
|
func (l *Loader) RawSymName(i Sym) string {
|
|
if l.IsExternal(i) {
|
|
pp := l.getPayload(i)
|
|
return pp.name
|
|
}
|
|
r, li := l.toLocal(i)
|
|
return r.Sym(li).Name(r.Reader)
|
|
}
|
|
|
|
// Returns the (patched) name of the i-th symbol.
|
|
func (l *Loader) SymName(i Sym) string {
|
|
if l.IsExternal(i) {
|
|
pp := l.getPayload(i)
|
|
return pp.name
|
|
}
|
|
r, li := l.toLocal(i)
|
|
return strings.Replace(r.Sym(li).Name(r.Reader), "\"\".", r.pkgprefix, -1)
|
|
}
|
|
|
|
// Returns the version of the i-th symbol.
|
|
func (l *Loader) SymVersion(i Sym) int {
|
|
if l.IsExternal(i) {
|
|
pp := l.getPayload(i)
|
|
return pp.ver
|
|
}
|
|
r, li := l.toLocal(i)
|
|
return int(abiToVer(r.Sym(li).ABI(), r.version))
|
|
}
|
|
|
|
// Returns the type of the i-th symbol.
|
|
func (l *Loader) SymType(i Sym) sym.SymKind {
|
|
if l.IsExternal(i) {
|
|
pp := l.getPayload(i)
|
|
if pp != nil {
|
|
return pp.kind
|
|
}
|
|
return 0
|
|
}
|
|
r, li := l.toLocal(i)
|
|
return sym.AbiSymKindToSymKind[objabi.SymKind(r.Sym(li).Type())]
|
|
}
|
|
|
|
// Returns the attributes of the i-th symbol.
|
|
func (l *Loader) SymAttr(i Sym) uint8 {
|
|
if l.IsExternal(i) {
|
|
// TODO: do something? External symbols have different representation of attributes.
|
|
// For now, ReflectMethod, NoSplit, GoType, and Typelink are used and they cannot be
|
|
// set by external symbol.
|
|
return 0
|
|
}
|
|
r, li := l.toLocal(i)
|
|
return r.Sym(li).Flag()
|
|
}
|
|
|
|
// Returns the size of the i-th symbol.
|
|
func (l *Loader) SymSize(i Sym) int64 {
|
|
if l.IsExternal(i) {
|
|
pp := l.getPayload(i)
|
|
return pp.size
|
|
}
|
|
r, li := l.toLocal(i)
|
|
return int64(r.Sym(li).Siz())
|
|
}
|
|
|
|
// AttrReachable returns true for symbols that are transitively
|
|
// referenced from the entry points. Unreachable symbols are not
|
|
// written to the output.
|
|
func (l *Loader) AttrReachable(i Sym) bool {
|
|
return l.attrReachable.Has(i)
|
|
}
|
|
|
|
// SetAttrReachable sets the reachability property for a symbol (see
|
|
// AttrReachable).
|
|
func (l *Loader) SetAttrReachable(i Sym, v bool) {
|
|
if v {
|
|
l.attrReachable.Set(i)
|
|
} else {
|
|
l.attrReachable.Unset(i)
|
|
}
|
|
}
|
|
|
|
// AttrOnList returns true for 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.
|
|
func (l *Loader) AttrOnList(i Sym) bool {
|
|
return l.attrOnList.Has(i)
|
|
}
|
|
|
|
// SetAttrOnList sets the "on list" property for a symbol (see
|
|
// AttrOnList).
|
|
func (l *Loader) SetAttrOnList(i Sym, v bool) {
|
|
if v {
|
|
l.attrOnList.Set(i)
|
|
} else {
|
|
l.attrOnList.Unset(i)
|
|
}
|
|
}
|
|
|
|
// AttrLocal returns true for symbols that are only visible within the
|
|
// module (executable or shared library) being linked. This attribute
|
|
// is applied to thunks and certain other linker-generated symbols.
|
|
func (l *Loader) AttrLocal(i Sym) bool {
|
|
return l.attrLocal.Has(i)
|
|
}
|
|
|
|
// SetAttrLocal the "local" property for a symbol (see AttrLocal above).
|
|
func (l *Loader) SetAttrLocal(i Sym, v bool) {
|
|
if v {
|
|
l.attrLocal.Set(i)
|
|
} else {
|
|
l.attrLocal.Unset(i)
|
|
}
|
|
}
|
|
|
|
// AttrNotInSymbolTable returns true for symbols that should not be
|
|
// added to the symbol table of the final generated load module.
|
|
func (l *Loader) AttrNotInSymbolTable(i Sym) bool {
|
|
return l.attrNotInSymbolTable.Has(i)
|
|
}
|
|
|
|
// SetAttrNotInSymbolTable the "not in symtab" property for a symbol
|
|
// (see AttrNotInSymbolTable above).
|
|
func (l *Loader) SetAttrNotInSymbolTable(i Sym, v bool) {
|
|
if v {
|
|
l.attrNotInSymbolTable.Set(i)
|
|
} else {
|
|
l.attrNotInSymbolTable.Unset(i)
|
|
}
|
|
}
|
|
|
|
// AttrVisibilityHidden symbols returns true for 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.
|
|
func (l *Loader) AttrVisibilityHidden(i Sym) bool {
|
|
if !l.IsExternal(i) {
|
|
return false
|
|
}
|
|
return l.attrVisibilityHidden.Has(l.extIndex(i))
|
|
}
|
|
|
|
// SetAttrVisibilityHidden sets the "hidden visibility" property for a
|
|
// symbol (see AttrVisibilityHidden).
|
|
func (l *Loader) SetAttrVisibilityHidden(i Sym, v bool) {
|
|
if !l.IsExternal(i) {
|
|
panic("tried to set visibility attr on non-external symbol")
|
|
}
|
|
if v {
|
|
l.attrVisibilityHidden.Set(l.extIndex(i))
|
|
} else {
|
|
l.attrVisibilityHidden.Unset(l.extIndex(i))
|
|
}
|
|
}
|
|
|
|
// AttrDuplicateOK returns true for a symbol that can be present in
|
|
// multiple object files.
|
|
func (l *Loader) AttrDuplicateOK(i Sym) bool {
|
|
if !l.IsExternal(i) {
|
|
// TODO: if this path winds up being taken frequently, it
|
|
// might make more sense to copy the flag value out of the object
|
|
// into a larger bitmap during preload.
|
|
r, li := l.toLocal(i)
|
|
return r.Sym(li).Dupok()
|
|
}
|
|
return l.attrDuplicateOK.Has(l.extIndex(i))
|
|
}
|
|
|
|
// SetAttrDuplicateOK sets the "duplicate OK" property for an external
|
|
// symbol (see AttrDuplicateOK).
|
|
func (l *Loader) SetAttrDuplicateOK(i Sym, v bool) {
|
|
if !l.IsExternal(i) {
|
|
panic("tried to set dupok attr on non-external symbol")
|
|
}
|
|
if v {
|
|
l.attrDuplicateOK.Set(l.extIndex(i))
|
|
} else {
|
|
l.attrDuplicateOK.Unset(l.extIndex(i))
|
|
}
|
|
}
|
|
|
|
// AttrShared returns true for symbols compiled with the -shared option.
|
|
func (l *Loader) AttrShared(i Sym) bool {
|
|
if !l.IsExternal(i) {
|
|
// TODO: if this path winds up being taken frequently, it
|
|
// might make more sense to copy the flag value out of the
|
|
// object into a larger bitmap during preload.
|
|
r, _ := l.toLocal(i)
|
|
return (r.Flags() & goobj2.ObjFlagShared) != 0
|
|
}
|
|
return l.attrShared.Has(l.extIndex(i))
|
|
}
|
|
|
|
// SetAttrShared sets the "shared" property for an external
|
|
// symbol (see AttrShared).
|
|
func (l *Loader) SetAttrShared(i Sym, v bool) {
|
|
if !l.IsExternal(i) {
|
|
panic(fmt.Sprintf("tried to set shared attr on non-external symbol %d %s", i, l.SymName(i)))
|
|
}
|
|
if v {
|
|
l.attrShared.Set(l.extIndex(i))
|
|
} else {
|
|
l.attrShared.Unset(l.extIndex(i))
|
|
}
|
|
}
|
|
|
|
// AttrExternal returns true for function symbols loaded from host
|
|
// object files.
|
|
func (l *Loader) AttrExternal(i Sym) bool {
|
|
if !l.IsExternal(i) {
|
|
return false
|
|
}
|
|
return l.attrExternal.Has(l.extIndex(i))
|
|
}
|
|
|
|
// SetAttrExternal sets the "external" property for an host object
|
|
// symbol (see AttrExternal).
|
|
func (l *Loader) SetAttrExternal(i Sym, v bool) {
|
|
if !l.IsExternal(i) {
|
|
panic(fmt.Sprintf("tried to set external attr on non-external symbol %q", l.RawSymName(i)))
|
|
}
|
|
if v {
|
|
l.attrExternal.Set(l.extIndex(i))
|
|
} else {
|
|
l.attrExternal.Unset(l.extIndex(i))
|
|
}
|
|
}
|
|
|
|
// AttrTopFrame returns true for a function symbol that is an entry
|
|
// point, meaning that unwinders should stop when they hit this
|
|
// function.
|
|
func (l *Loader) AttrTopFrame(i Sym) bool {
|
|
_, ok := l.attrTopFrame[i]
|
|
return ok
|
|
}
|
|
|
|
// SetAttrTopFrame sets the "top frame" property for a symbol (see
|
|
// AttrTopFrame).
|
|
func (l *Loader) SetAttrTopFrame(i Sym, v bool) {
|
|
if v {
|
|
l.attrTopFrame[i] = struct{}{}
|
|
} else {
|
|
delete(l.attrTopFrame, i)
|
|
}
|
|
}
|
|
|
|
// AttrSpecial returns true for a symbols that do not have their
|
|
// address (i.e. Value) computed by the usual mechanism of
|
|
// data.go:dodata() & data.go:address().
|
|
func (l *Loader) AttrSpecial(i Sym) bool {
|
|
_, ok := l.attrSpecial[i]
|
|
return ok
|
|
}
|
|
|
|
// SetAttrSpecial sets the "special" property for a symbol (see
|
|
// AttrSpecial).
|
|
func (l *Loader) SetAttrSpecial(i Sym, v bool) {
|
|
if v {
|
|
l.attrSpecial[i] = struct{}{}
|
|
} else {
|
|
delete(l.attrSpecial, i)
|
|
}
|
|
}
|
|
|
|
// AttrCgoExportDynamic returns true for a symbol that has been
|
|
// specially marked via the "cgo_export_dynamic" compiler directive
|
|
// written by cgo (in response to //export directives in the source).
|
|
func (l *Loader) AttrCgoExportDynamic(i Sym) bool {
|
|
_, ok := l.attrCgoExportDynamic[i]
|
|
return ok
|
|
}
|
|
|
|
// SetAttrCgoExportDynamic sets the "cgo_export_dynamic" for a symbol
|
|
// (see AttrCgoExportDynamic).
|
|
func (l *Loader) SetAttrCgoExportDynamic(i Sym, v bool) {
|
|
if v {
|
|
l.attrCgoExportDynamic[i] = struct{}{}
|
|
} else {
|
|
delete(l.attrCgoExportDynamic, i)
|
|
}
|
|
}
|
|
|
|
// AttrCgoExportStatic returns true for a symbol that has been
|
|
// specially marked via the "cgo_export_static" directive
|
|
// written by cgo.
|
|
func (l *Loader) AttrCgoExportStatic(i Sym) bool {
|
|
_, ok := l.attrCgoExportStatic[i]
|
|
return ok
|
|
}
|
|
|
|
// SetAttrCgoExportStatic sets the "cgo_export_static" for a symbol
|
|
// (see AttrCgoExportStatic).
|
|
func (l *Loader) SetAttrCgoExportStatic(i Sym, v bool) {
|
|
if v {
|
|
l.attrCgoExportStatic[i] = struct{}{}
|
|
} else {
|
|
delete(l.attrCgoExportStatic, i)
|
|
}
|
|
}
|
|
|
|
func (l *Loader) AttrCgoExport(i Sym) bool {
|
|
return l.AttrCgoExportDynamic(i) || l.AttrCgoExportStatic(i)
|
|
}
|
|
|
|
// AttrReadOnly returns true for a symbol whose underlying data
|
|
// is stored via a read-only mmap.
|
|
func (l *Loader) AttrReadOnly(i Sym) bool {
|
|
if v, ok := l.attrReadOnly[i]; ok {
|
|
return v
|
|
}
|
|
if l.IsExternal(i) {
|
|
pp := l.getPayload(i)
|
|
if pp.objidx != 0 {
|
|
return l.objs[pp.objidx].r.ReadOnly()
|
|
}
|
|
return false
|
|
}
|
|
r, _ := l.toLocal(i)
|
|
return r.ReadOnly()
|
|
}
|
|
|
|
// SetAttrReadOnly sets the "data is read only" property for a symbol
|
|
// (see AttrReadOnly).
|
|
func (l *Loader) SetAttrReadOnly(i Sym, v bool) {
|
|
l.attrReadOnly[i] = v
|
|
}
|
|
|
|
// AttrSubSymbol returns true for symbols that are listed as a
|
|
// sub-symbol of some other outer symbol. The sub/outer mechanism is
|
|
// 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.
|
|
//
|
|
// Note that in later stages of the linker, we set Outer(S) to some
|
|
// container symbol C, but don't set Sub(C). Thus we have two
|
|
// distinct scenarios:
|
|
//
|
|
// - Outer symbol covers the address ranges of its sub-symbols.
|
|
// Outer.Sub is set in this case.
|
|
// - Outer symbol doesn't conver the address ranges. It is zero-sized
|
|
// and doesn't have sub-symbols. In the case, the inner symbol is
|
|
// not actually a "SubSymbol". (Tricky!)
|
|
//
|
|
// This method returns TRUE only for sub-symbols in the first scenario.
|
|
//
|
|
// FIXME: would be better to do away with this and have a better way
|
|
// to represent container symbols.
|
|
|
|
func (l *Loader) AttrSubSymbol(i Sym) bool {
|
|
// we don't explicitly store this attribute any more -- return
|
|
// a value based on the sub-symbol setting.
|
|
o := l.OuterSym(i)
|
|
if o == 0 {
|
|
return false
|
|
}
|
|
return l.SubSym(o) != 0
|
|
}
|
|
|
|
// Note that we don't have a 'SetAttrSubSymbol' method in the loader;
|
|
// clients should instead use the PrependSub method to establish
|
|
// outer/sub relationships for host object symbols.
|
|
|
|
// Returns whether the i-th symbol has ReflectMethod attribute set.
|
|
func (l *Loader) IsReflectMethod(i Sym) bool {
|
|
return l.SymAttr(i)&goobj2.SymFlagReflectMethod != 0
|
|
}
|
|
|
|
// Returns whether the i-th symbol is nosplit.
|
|
func (l *Loader) IsNoSplit(i Sym) bool {
|
|
return l.SymAttr(i)&goobj2.SymFlagNoSplit != 0
|
|
}
|
|
|
|
// Returns whether this is a Go type symbol.
|
|
func (l *Loader) IsGoType(i Sym) bool {
|
|
return l.SymAttr(i)&goobj2.SymFlagGoType != 0
|
|
}
|
|
|
|
// Returns whether this symbol should be included in typelink.
|
|
func (l *Loader) IsTypelink(i Sym) bool {
|
|
return l.SymAttr(i)&goobj2.SymFlagTypelink != 0
|
|
}
|
|
|
|
// Returns whether this is a "go.itablink.*" symbol.
|
|
func (l *Loader) IsItabLink(i Sym) bool {
|
|
if _, ok := l.itablink[i]; ok {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
// growValues grows the slice used to store symbol values.
|
|
func (l *Loader) growValues(reqLen int) {
|
|
curLen := len(l.values)
|
|
if reqLen > curLen {
|
|
l.values = append(l.values, make([]int64, reqLen+1-curLen)...)
|
|
}
|
|
}
|
|
|
|
// SymValue returns the value of the i-th symbol. i is global index.
|
|
func (l *Loader) SymValue(i Sym) int64 {
|
|
return l.values[i]
|
|
}
|
|
|
|
// SetSymValue sets the value of the i-th symbol. i is global index.
|
|
func (l *Loader) SetSymValue(i Sym, val int64) {
|
|
l.values[i] = val
|
|
}
|
|
|
|
// Returns the symbol content of the i-th symbol. i is global index.
|
|
func (l *Loader) Data(i Sym) []byte {
|
|
if l.IsExternal(i) {
|
|
pp := l.getPayload(i)
|
|
if pp != nil {
|
|
return pp.data
|
|
}
|
|
return nil
|
|
}
|
|
r, li := l.toLocal(i)
|
|
return r.Data(li)
|
|
}
|
|
|
|
// SymAlign returns the alignment for a symbol.
|
|
func (l *Loader) SymAlign(i Sym) int32 {
|
|
// If an alignment has been recorded, return that.
|
|
if align, ok := l.align[i]; ok {
|
|
return align
|
|
}
|
|
// TODO: would it make sense to return an arch-specific
|
|
// alignment depending on section type? E.g. STEXT => 32,
|
|
// SDATA => 1, etc?
|
|
return 0
|
|
}
|
|
|
|
// SetSymAlign sets the alignment for a symbol.
|
|
func (l *Loader) SetSymAlign(i Sym, align int32) {
|
|
// reject bad synbols
|
|
if i >= Sym(len(l.objSyms)) || i == 0 {
|
|
panic("bad symbol index in SetSymAlign")
|
|
}
|
|
// Reject nonsense alignments.
|
|
// TODO: do we need this?
|
|
if align < 0 {
|
|
panic("bad alignment value")
|
|
}
|
|
if align == 0 {
|
|
delete(l.align, i)
|
|
} else {
|
|
// Alignment should be a power of 2.
|
|
if bits.OnesCount32(uint32(align)) != 1 {
|
|
panic("bad alignment value")
|
|
}
|
|
l.align[i] = align
|
|
}
|
|
}
|
|
|
|
// SymValue returns the section of the i-th symbol. i is global index.
|
|
func (l *Loader) SymSect(i Sym) *sym.Section {
|
|
if int(i) >= len(l.symSects) {
|
|
// symSects is extended lazily -- it the sym in question is
|
|
// outside the range of the existing slice, then we assume its
|
|
// section has not yet been set.
|
|
return nil
|
|
}
|
|
return l.sects[l.symSects[i]]
|
|
}
|
|
|
|
// SetSymValue sets the section of the i-th symbol. i is global index.
|
|
func (l *Loader) SetSymSect(i Sym, sect *sym.Section) {
|
|
if int(i) >= len(l.symSects) {
|
|
l.symSects = append(l.symSects, make([]uint16, l.NSym()-len(l.symSects))...)
|
|
}
|
|
l.symSects[i] = sect.Index
|
|
}
|
|
|
|
// growSects grows the slice used to store symbol sections.
|
|
func (l *Loader) growSects(reqLen int) {
|
|
curLen := len(l.symSects)
|
|
if reqLen > curLen {
|
|
l.symSects = append(l.symSects, make([]uint16, reqLen+1-curLen)...)
|
|
}
|
|
}
|
|
|
|
// NewSection creates a new (output) section.
|
|
func (l *Loader) NewSection() *sym.Section {
|
|
sect := new(sym.Section)
|
|
idx := len(l.sects)
|
|
if idx != int(uint16(idx)) {
|
|
panic("too many sections created")
|
|
}
|
|
sect.Index = uint16(idx)
|
|
l.sects = append(l.sects, sect)
|
|
return sect
|
|
}
|
|
|
|
// SymDynImplib returns the "dynimplib" attribute for the specified
|
|
// symbol, making up a portion of the info for a symbol specified
|
|
// on a "cgo_import_dynamic" compiler directive.
|
|
func (l *Loader) SymDynimplib(i Sym) string {
|
|
return l.dynimplib[i]
|
|
}
|
|
|
|
// SetSymDynimplib sets the "dynimplib" attribute for a symbol.
|
|
func (l *Loader) SetSymDynimplib(i Sym, value string) {
|
|
// reject bad symbols
|
|
if i >= Sym(len(l.objSyms)) || i == 0 {
|
|
panic("bad symbol index in SetDynimplib")
|
|
}
|
|
if value == "" {
|
|
delete(l.dynimplib, i)
|
|
} else {
|
|
l.dynimplib[i] = value
|
|
}
|
|
}
|
|
|
|
// SymDynimpvers returns the "dynimpvers" attribute for the specified
|
|
// symbol, making up a portion of the info for a symbol specified
|
|
// on a "cgo_import_dynamic" compiler directive.
|
|
func (l *Loader) SymDynimpvers(i Sym) string {
|
|
return l.dynimpvers[i]
|
|
}
|
|
|
|
// SetSymDynimpvers sets the "dynimpvers" attribute for a symbol.
|
|
func (l *Loader) SetSymDynimpvers(i Sym, value string) {
|
|
// reject bad symbols
|
|
if i >= Sym(len(l.objSyms)) || i == 0 {
|
|
panic("bad symbol index in SetDynimpvers")
|
|
}
|
|
if value == "" {
|
|
delete(l.dynimpvers, i)
|
|
} else {
|
|
l.dynimpvers[i] = value
|
|
}
|
|
}
|
|
|
|
// SymExtname returns the "extname" value for the specified
|
|
// symbol.
|
|
func (l *Loader) SymExtname(i Sym) string {
|
|
if s, ok := l.extname[i]; ok {
|
|
return s
|
|
}
|
|
return l.SymName(i)
|
|
}
|
|
|
|
// SetSymExtname sets the "extname" attribute for a symbol.
|
|
func (l *Loader) SetSymExtname(i Sym, value string) {
|
|
// reject bad symbols
|
|
if i >= Sym(len(l.objSyms)) || i == 0 {
|
|
panic("bad symbol index in SetExtname")
|
|
}
|
|
if value == "" {
|
|
delete(l.extname, i)
|
|
} else {
|
|
l.extname[i] = value
|
|
}
|
|
}
|
|
|
|
// SymElfType returns the previously recorded ELF type for a symbol
|
|
// (used only 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).
|
|
func (l *Loader) SymElfType(i Sym) elf.SymType {
|
|
if et, ok := l.elfType[i]; ok {
|
|
return et
|
|
}
|
|
return elf.STT_NOTYPE
|
|
}
|
|
|
|
// SetSymElfType sets the elf type attribute for a symbol.
|
|
func (l *Loader) SetSymElfType(i Sym, et elf.SymType) {
|
|
// reject bad symbols
|
|
if i >= Sym(len(l.objSyms)) || i == 0 {
|
|
panic("bad symbol index in SetSymElfType")
|
|
}
|
|
if et == elf.STT_NOTYPE {
|
|
delete(l.elfType, i)
|
|
} else {
|
|
l.elfType[i] = et
|
|
}
|
|
}
|
|
|
|
// SymPlt returns the plt value for pe symbols.
|
|
func (l *Loader) SymPlt(s Sym) int32 {
|
|
if v, ok := l.plt[s]; ok {
|
|
return v
|
|
}
|
|
return -1
|
|
}
|
|
|
|
// SetPlt sets the plt value for pe symbols.
|
|
func (l *Loader) SetPlt(i Sym, v int32) {
|
|
if i >= Sym(len(l.objSyms)) || i == 0 {
|
|
panic("bad symbol for SetPlt")
|
|
}
|
|
if v == -1 {
|
|
delete(l.plt, i)
|
|
} else {
|
|
l.plt[i] = v
|
|
}
|
|
}
|
|
|
|
// SymGot returns the got value for pe symbols.
|
|
func (l *Loader) SymGot(s Sym) int32 {
|
|
if v, ok := l.got[s]; ok {
|
|
return v
|
|
}
|
|
return -1
|
|
}
|
|
|
|
// SetGot sets the got value for pe symbols.
|
|
func (l *Loader) SetGot(i Sym, v int32) {
|
|
if i >= Sym(len(l.objSyms)) || i == 0 {
|
|
panic("bad symbol for SetGot")
|
|
}
|
|
if v == -1 {
|
|
delete(l.got, i)
|
|
} else {
|
|
l.got[i] = v
|
|
}
|
|
}
|
|
|
|
// SymDynid returns the "dynid" property for the specified symbol.
|
|
func (l *Loader) SymDynid(i Sym) int32 {
|
|
if s, ok := l.dynid[i]; ok {
|
|
return s
|
|
}
|
|
return -1
|
|
}
|
|
|
|
// SetSymDynid sets the "dynid" property for a symbol.
|
|
func (l *Loader) SetSymDynid(i Sym, val int32) {
|
|
// reject bad symbols
|
|
if i >= Sym(len(l.objSyms)) || i == 0 {
|
|
panic("bad symbol index in SetSymDynid")
|
|
}
|
|
if val == -1 {
|
|
delete(l.dynid, i)
|
|
} else {
|
|
l.dynid[i] = val
|
|
}
|
|
}
|
|
|
|
// DynIdSyms returns the set of symbols for which dynID is set to an
|
|
// interesting (non-default) value. This is expected to be a fairly
|
|
// small set.
|
|
func (l *Loader) DynidSyms() []Sym {
|
|
sl := make([]Sym, 0, len(l.dynid))
|
|
for s := range l.dynid {
|
|
sl = append(sl, s)
|
|
}
|
|
sort.Slice(sl, func(i, j int) bool { return sl[i] < sl[j] })
|
|
return sl
|
|
}
|
|
|
|
// SymGoType returns the 'Gotype' property for a given symbol (set by
|
|
// the Go compiler for variable symbols). This version relies on
|
|
// reading aux symbols for the target sym -- it could be that a faster
|
|
// approach would be to check for gotype during preload and copy the
|
|
// results in to a map (might want to try this at some point and see
|
|
// if it helps speed things up).
|
|
func (l *Loader) SymGoType(i Sym) Sym {
|
|
if l.IsExternal(i) {
|
|
pp := l.getPayload(i)
|
|
return pp.gotype
|
|
}
|
|
r, li := l.toLocal(i)
|
|
auxs := r.Auxs(li)
|
|
for j := range auxs {
|
|
a := &auxs[j]
|
|
switch a.Type() {
|
|
case goobj2.AuxGotype:
|
|
return l.resolve(r, a.Sym())
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// SymUnit returns the compilation unit for a given symbol (which will
|
|
// typically be nil for external or linker-manufactured symbols).
|
|
func (l *Loader) SymUnit(i Sym) *sym.CompilationUnit {
|
|
if l.IsExternal(i) {
|
|
pp := l.getPayload(i)
|
|
if pp.objidx != 0 {
|
|
r := l.objs[pp.objidx].r
|
|
return r.unit
|
|
}
|
|
return nil
|
|
}
|
|
r, _ := l.toLocal(i)
|
|
return r.unit
|
|
}
|
|
|
|
// SymPkg returns the package where the symbol came from (for
|
|
// regular compiler-generated Go symbols), but in the case of
|
|
// building with "-linkshared" (when a symbol is read from a
|
|
// shared library), will hold the library name.
|
|
// NOTE: this correspondes to sym.Symbol.File field.
|
|
func (l *Loader) SymPkg(i Sym) string {
|
|
if f, ok := l.symPkg[i]; ok {
|
|
return f
|
|
}
|
|
if l.IsExternal(i) {
|
|
pp := l.getPayload(i)
|
|
if pp.objidx != 0 {
|
|
r := l.objs[pp.objidx].r
|
|
return r.unit.Lib.Pkg
|
|
}
|
|
return ""
|
|
}
|
|
r, _ := l.toLocal(i)
|
|
return r.unit.Lib.Pkg
|
|
}
|
|
|
|
// SetSymPkg sets the package/library for a symbol. This is
|
|
// needed mainly for external symbols, specifically those imported
|
|
// from shared libraries.
|
|
func (l *Loader) SetSymPkg(i Sym, pkg string) {
|
|
// reject bad symbols
|
|
if i >= Sym(len(l.objSyms)) || i == 0 {
|
|
panic("bad symbol index in SetSymPkg")
|
|
}
|
|
l.symPkg[i] = pkg
|
|
}
|
|
|
|
// SymLocalentry returns the "local entry" value for the specified
|
|
// symbol.
|
|
func (l *Loader) SymLocalentry(i Sym) uint8 {
|
|
return l.localentry[i]
|
|
}
|
|
|
|
// SetSymLocalentry sets the "local entry" attribute for a symbol.
|
|
func (l *Loader) SetSymLocalentry(i Sym, value uint8) {
|
|
// reject bad symbols
|
|
if i >= Sym(len(l.objSyms)) || i == 0 {
|
|
panic("bad symbol index in SetSymLocalentry")
|
|
}
|
|
if value == 0 {
|
|
delete(l.localentry, i)
|
|
} else {
|
|
l.localentry[i] = value
|
|
}
|
|
}
|
|
|
|
// Returns the number of aux symbols given a global index.
|
|
func (l *Loader) NAux(i Sym) int {
|
|
if l.IsExternal(i) {
|
|
return 0
|
|
}
|
|
r, li := l.toLocal(i)
|
|
return r.NAux(li)
|
|
}
|
|
|
|
// Returns the "handle" to the j-th aux symbol of the i-th symbol.
|
|
func (l *Loader) Aux2(i Sym, j int) Aux2 {
|
|
if l.IsExternal(i) {
|
|
return Aux2{}
|
|
}
|
|
r, li := l.toLocal(i)
|
|
if j >= r.NAux(li) {
|
|
return Aux2{}
|
|
}
|
|
return Aux2{r.Aux(li, j), r, l}
|
|
}
|
|
|
|
// GetFuncDwarfAuxSyms collects and returns the auxiliary DWARF
|
|
// symbols associated with a given function symbol. Prior to the
|
|
// introduction of the loader, this was done purely using name
|
|
// lookups, e.f. for function with name XYZ we would then look up
|
|
// go.info.XYZ, etc.
|
|
// FIXME: once all of dwarfgen is converted over to the loader,
|
|
// it would save some space to make these aux symbols nameless.
|
|
func (l *Loader) GetFuncDwarfAuxSyms(fnSymIdx Sym) (auxDwarfInfo, auxDwarfLoc, auxDwarfRanges, auxDwarfLines Sym) {
|
|
if l.SymType(fnSymIdx) != sym.STEXT {
|
|
log.Fatalf("error: non-function sym %d/%s t=%s passed to GetFuncDwarfAuxSyms", fnSymIdx, l.SymName(fnSymIdx), l.SymType(fnSymIdx).String())
|
|
}
|
|
if l.IsExternal(fnSymIdx) {
|
|
// Current expectation is that any external function will
|
|
// not have auxsyms.
|
|
return
|
|
}
|
|
r, li := l.toLocal(fnSymIdx)
|
|
auxs := r.Auxs(li)
|
|
for i := range auxs {
|
|
a := &auxs[i]
|
|
switch a.Type() {
|
|
case goobj2.AuxDwarfInfo:
|
|
auxDwarfInfo = l.resolve(r, a.Sym())
|
|
if l.SymType(auxDwarfInfo) != sym.SDWARFINFO {
|
|
panic("aux dwarf info sym with wrong type")
|
|
}
|
|
case goobj2.AuxDwarfLoc:
|
|
auxDwarfLoc = l.resolve(r, a.Sym())
|
|
if l.SymType(auxDwarfLoc) != sym.SDWARFLOC {
|
|
panic("aux dwarf loc sym with wrong type")
|
|
}
|
|
case goobj2.AuxDwarfRanges:
|
|
auxDwarfRanges = l.resolve(r, a.Sym())
|
|
if l.SymType(auxDwarfRanges) != sym.SDWARFRANGE {
|
|
panic("aux dwarf ranges sym with wrong type")
|
|
}
|
|
case goobj2.AuxDwarfLines:
|
|
auxDwarfLines = l.resolve(r, a.Sym())
|
|
if l.SymType(auxDwarfLines) != sym.SDWARFLINES {
|
|
panic("aux dwarf lines sym with wrong type")
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// PrependSub prepends 'sub' onto the sub list for outer symbol 'outer'.
|
|
// Will panic if 'sub' already has an outer sym or sub sym.
|
|
// FIXME: should this be instead a method on SymbolBuilder?
|
|
func (l *Loader) PrependSub(outer Sym, sub Sym) {
|
|
// NB: this presupposes that an outer sym can't be a sub symbol of
|
|
// some other outer-outer sym (I'm assuming this is true, but I
|
|
// haven't tested exhaustively).
|
|
if l.OuterSym(outer) != 0 {
|
|
panic("outer has outer itself")
|
|
}
|
|
if l.SubSym(sub) != 0 {
|
|
panic("sub set for subsym")
|
|
}
|
|
if l.OuterSym(sub) != 0 {
|
|
panic("outer already set for subsym")
|
|
}
|
|
l.sub[sub] = l.sub[outer]
|
|
l.sub[outer] = sub
|
|
l.outer[sub] = outer
|
|
}
|
|
|
|
// OuterSym gets the outer symbol for host object loaded symbols.
|
|
func (l *Loader) OuterSym(i Sym) Sym {
|
|
// FIXME: add check for isExternal?
|
|
return l.outer[i]
|
|
}
|
|
|
|
// SubSym gets the subsymbol for host object loaded symbols.
|
|
func (l *Loader) SubSym(i Sym) Sym {
|
|
// NB: note -- no check for l.isExternal(), since I am pretty sure
|
|
// that later phases in the linker set subsym for "type." syms
|
|
return l.sub[i]
|
|
}
|
|
|
|
// SetOuterSym sets the outer symbol of i to o (without setting
|
|
// sub symbols).
|
|
func (l *Loader) SetOuterSym(i Sym, o Sym) {
|
|
if o != 0 {
|
|
l.outer[i] = o
|
|
} else {
|
|
delete(l.outer, i)
|
|
}
|
|
}
|
|
|
|
// Initialize Reachable bitmap and its siblings for running deadcode pass.
|
|
func (l *Loader) InitReachable() {
|
|
l.growAttrBitmaps(l.NSym() + 1)
|
|
}
|
|
|
|
type symWithVal struct {
|
|
s Sym
|
|
v int64
|
|
}
|
|
type bySymValue []symWithVal
|
|
|
|
func (s bySymValue) Len() int { return len(s) }
|
|
func (s bySymValue) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
|
|
func (s bySymValue) Less(i, j int) bool { return s[i].v < s[j].v }
|
|
|
|
// SortSub walks through the sub-symbols for 's' and sorts them
|
|
// in place by increasing value. Return value is the new
|
|
// sub symbol for the specified outer symbol.
|
|
func (l *Loader) SortSub(s Sym) Sym {
|
|
|
|
if s == 0 || l.sub[s] == 0 {
|
|
return s
|
|
}
|
|
|
|
// Sort symbols using a slice first. Use a stable sort on the off
|
|
// chance that there's more than once symbol with the same value,
|
|
// so as to preserve reproducible builds.
|
|
sl := []symWithVal{}
|
|
for ss := l.sub[s]; ss != 0; ss = l.sub[ss] {
|
|
sl = append(sl, symWithVal{s: ss, v: l.SymValue(ss)})
|
|
}
|
|
sort.Stable(bySymValue(sl))
|
|
|
|
// Then apply any changes needed to the sub map.
|
|
ns := Sym(0)
|
|
for i := len(sl) - 1; i >= 0; i-- {
|
|
s := sl[i].s
|
|
l.sub[s] = ns
|
|
ns = s
|
|
}
|
|
|
|
// Update sub for outer symbol, then return
|
|
l.sub[s] = sl[0].s
|
|
return sl[0].s
|
|
}
|
|
|
|
// Insure that reachable bitmap and its siblings have enough size.
|
|
func (l *Loader) growAttrBitmaps(reqLen int) {
|
|
if reqLen > l.attrReachable.Len() {
|
|
// These are indexed by global symbol
|
|
l.attrReachable = growBitmap(reqLen, l.attrReachable)
|
|
l.attrOnList = growBitmap(reqLen, l.attrOnList)
|
|
l.attrLocal = growBitmap(reqLen, l.attrLocal)
|
|
l.attrNotInSymbolTable = growBitmap(reqLen, l.attrNotInSymbolTable)
|
|
}
|
|
l.growExtAttrBitmaps()
|
|
}
|
|
|
|
func (l *Loader) growExtAttrBitmaps() {
|
|
// These are indexed by external symbol index (e.g. l.extIndex(i))
|
|
extReqLen := len(l.payloads)
|
|
if extReqLen > l.attrVisibilityHidden.Len() {
|
|
l.attrVisibilityHidden = growBitmap(extReqLen, l.attrVisibilityHidden)
|
|
l.attrDuplicateOK = growBitmap(extReqLen, l.attrDuplicateOK)
|
|
l.attrShared = growBitmap(extReqLen, l.attrShared)
|
|
l.attrExternal = growBitmap(extReqLen, l.attrExternal)
|
|
}
|
|
}
|
|
|
|
func (relocs *Relocs) Count() int { return len(relocs.rs) }
|
|
|
|
// At2 returns the j-th reloc for a global symbol.
|
|
func (relocs *Relocs) At2(j int) Reloc2 {
|
|
if relocs.l.isExtReader(relocs.r) {
|
|
pp := relocs.l.payloads[relocs.li]
|
|
return Reloc2{&relocs.rs[j], relocs.r, relocs.l, pp.reltypes[j]}
|
|
}
|
|
return Reloc2{&relocs.rs[j], relocs.r, relocs.l, 0}
|
|
}
|
|
|
|
// Relocs returns a Relocs object for the given global sym.
|
|
func (l *Loader) Relocs(i Sym) Relocs {
|
|
r, li := l.toLocal(i)
|
|
if r == nil {
|
|
panic(fmt.Sprintf("trying to get oreader for invalid sym %d\n\n", i))
|
|
}
|
|
return l.relocs(r, li)
|
|
}
|
|
|
|
// Relocs returns a Relocs object given a local sym index and reader.
|
|
func (l *Loader) relocs(r *oReader, li int) Relocs {
|
|
var rs []goobj2.Reloc
|
|
if l.isExtReader(r) {
|
|
pp := l.payloads[li]
|
|
rs = pp.relocs
|
|
} else {
|
|
rs = r.Relocs(li)
|
|
}
|
|
return Relocs{
|
|
rs: rs,
|
|
li: li,
|
|
r: r,
|
|
l: l,
|
|
}
|
|
}
|
|
|
|
// RelocByOff implements sort.Interface for sorting relocations by offset.
|
|
|
|
type RelocByOff []Reloc
|
|
|
|
func (x RelocByOff) Len() int { return len(x) }
|
|
func (x RelocByOff) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
|
|
func (x RelocByOff) Less(i, j int) bool { return x[i].Off < x[j].Off }
|
|
|
|
// FuncInfo provides hooks to access goobj2.FuncInfo in the objects.
|
|
type FuncInfo struct {
|
|
l *Loader
|
|
r *oReader
|
|
data []byte
|
|
auxs []goobj2.Aux
|
|
lengths goobj2.FuncInfoLengths
|
|
}
|
|
|
|
func (fi *FuncInfo) Valid() bool { return fi.r != nil }
|
|
|
|
func (fi *FuncInfo) Args() int {
|
|
return int((*goobj2.FuncInfo)(nil).ReadArgs(fi.data))
|
|
}
|
|
|
|
func (fi *FuncInfo) Locals() int {
|
|
return int((*goobj2.FuncInfo)(nil).ReadLocals(fi.data))
|
|
}
|
|
|
|
func (fi *FuncInfo) Pcsp() []byte {
|
|
pcsp, end := (*goobj2.FuncInfo)(nil).ReadPcsp(fi.data)
|
|
return fi.r.BytesAt(fi.r.PcdataBase()+pcsp, int(end-pcsp))
|
|
}
|
|
|
|
func (fi *FuncInfo) Pcfile() []byte {
|
|
pcf, end := (*goobj2.FuncInfo)(nil).ReadPcfile(fi.data)
|
|
return fi.r.BytesAt(fi.r.PcdataBase()+pcf, int(end-pcf))
|
|
}
|
|
|
|
func (fi *FuncInfo) Pcline() []byte {
|
|
pcln, end := (*goobj2.FuncInfo)(nil).ReadPcline(fi.data)
|
|
return fi.r.BytesAt(fi.r.PcdataBase()+pcln, int(end-pcln))
|
|
}
|
|
|
|
// Preload has to be called prior to invoking the various methods
|
|
// below related to pcdata, funcdataoff, files, and inltree nodes.
|
|
func (fi *FuncInfo) Preload() {
|
|
fi.lengths = (*goobj2.FuncInfo)(nil).ReadFuncInfoLengths(fi.data)
|
|
}
|
|
|
|
func (fi *FuncInfo) Pcinline() []byte {
|
|
if !fi.lengths.Initialized {
|
|
panic("need to call Preload first")
|
|
}
|
|
pcinl, end := (*goobj2.FuncInfo)(nil).ReadPcinline(fi.data, fi.lengths.PcdataOff)
|
|
return fi.r.BytesAt(fi.r.PcdataBase()+pcinl, int(end-pcinl))
|
|
}
|
|
|
|
func (fi *FuncInfo) NumPcdata() uint32 {
|
|
if !fi.lengths.Initialized {
|
|
panic("need to call Preload first")
|
|
}
|
|
return fi.lengths.NumPcdata
|
|
}
|
|
|
|
func (fi *FuncInfo) Pcdata(k int) []byte {
|
|
if !fi.lengths.Initialized {
|
|
panic("need to call Preload first")
|
|
}
|
|
pcdat, end := (*goobj2.FuncInfo)(nil).ReadPcdata(fi.data, fi.lengths.PcdataOff, uint32(k))
|
|
return fi.r.BytesAt(fi.r.PcdataBase()+pcdat, int(end-pcdat))
|
|
}
|
|
|
|
func (fi *FuncInfo) NumFuncdataoff() uint32 {
|
|
if !fi.lengths.Initialized {
|
|
panic("need to call Preload first")
|
|
}
|
|
return fi.lengths.NumFuncdataoff
|
|
}
|
|
|
|
func (fi *FuncInfo) Funcdataoff(k int) int64 {
|
|
if !fi.lengths.Initialized {
|
|
panic("need to call Preload first")
|
|
}
|
|
return (*goobj2.FuncInfo)(nil).ReadFuncdataoff(fi.data, fi.lengths.FuncdataoffOff, uint32(k))
|
|
}
|
|
|
|
func (fi *FuncInfo) Funcdata(syms []Sym) []Sym {
|
|
if !fi.lengths.Initialized {
|
|
panic("need to call Preload first")
|
|
}
|
|
if int(fi.lengths.NumFuncdataoff) > cap(syms) {
|
|
syms = make([]Sym, 0, fi.lengths.NumFuncdataoff)
|
|
} else {
|
|
syms = syms[:0]
|
|
}
|
|
for j := range fi.auxs {
|
|
a := &fi.auxs[j]
|
|
if a.Type() == goobj2.AuxFuncdata {
|
|
syms = append(syms, fi.l.resolve(fi.r, a.Sym()))
|
|
}
|
|
}
|
|
return syms
|
|
}
|
|
|
|
func (fi *FuncInfo) NumFile() uint32 {
|
|
if !fi.lengths.Initialized {
|
|
panic("need to call Preload first")
|
|
}
|
|
return fi.lengths.NumFile
|
|
}
|
|
|
|
func (fi *FuncInfo) File(k int) Sym {
|
|
if !fi.lengths.Initialized {
|
|
panic("need to call Preload first")
|
|
}
|
|
sr := (*goobj2.FuncInfo)(nil).ReadFile(fi.data, fi.lengths.FileOff, uint32(k))
|
|
return fi.l.resolve(fi.r, sr)
|
|
}
|
|
|
|
type InlTreeNode struct {
|
|
Parent int32
|
|
File Sym
|
|
Line int32
|
|
Func Sym
|
|
ParentPC int32
|
|
}
|
|
|
|
func (fi *FuncInfo) NumInlTree() uint32 {
|
|
if !fi.lengths.Initialized {
|
|
panic("need to call Preload first")
|
|
}
|
|
return fi.lengths.NumInlTree
|
|
}
|
|
|
|
func (fi *FuncInfo) InlTree(k int) InlTreeNode {
|
|
if !fi.lengths.Initialized {
|
|
panic("need to call Preload first")
|
|
}
|
|
node := (*goobj2.FuncInfo)(nil).ReadInlTree(fi.data, fi.lengths.InlTreeOff, uint32(k))
|
|
return InlTreeNode{
|
|
Parent: node.Parent,
|
|
File: fi.l.resolve(fi.r, node.File),
|
|
Line: node.Line,
|
|
Func: fi.l.resolve(fi.r, node.Func),
|
|
ParentPC: node.ParentPC,
|
|
}
|
|
}
|
|
|
|
func (l *Loader) FuncInfo(i Sym) FuncInfo {
|
|
var r *oReader
|
|
var auxs []goobj2.Aux
|
|
if l.IsExternal(i) {
|
|
pp := l.getPayload(i)
|
|
if pp.objidx == 0 {
|
|
return FuncInfo{}
|
|
}
|
|
r = l.objs[pp.objidx].r
|
|
auxs = pp.auxs
|
|
} else {
|
|
var li int
|
|
r, li = l.toLocal(i)
|
|
auxs = r.Auxs(li)
|
|
}
|
|
for j := range auxs {
|
|
a := &auxs[j]
|
|
if a.Type() == goobj2.AuxFuncInfo {
|
|
b := r.Data(int(a.Sym().SymIdx))
|
|
return FuncInfo{l, r, b, auxs, goobj2.FuncInfoLengths{}}
|
|
}
|
|
}
|
|
return FuncInfo{}
|
|
}
|
|
|
|
// Preload a package: add autolibs, add defined package symbols to the symbol table.
|
|
// Does not add non-package symbols yet, which will be done in LoadNonpkgSyms.
|
|
// Does not read symbol data.
|
|
// Returns the fingerprint of the object.
|
|
func (l *Loader) Preload(syms *sym.Symbols, f *bio.Reader, lib *sym.Library, unit *sym.CompilationUnit, length int64) goobj2.FingerprintType {
|
|
roObject, readonly, err := f.Slice(uint64(length))
|
|
if err != nil {
|
|
log.Fatal("cannot read object file:", err)
|
|
}
|
|
r := goobj2.NewReaderFromBytes(roObject, readonly)
|
|
if r == nil {
|
|
if len(roObject) >= 8 && bytes.Equal(roObject[:8], []byte("\x00go114ld")) {
|
|
log.Fatalf("found object file %s in old format, but -go115newobj is true\nset -go115newobj consistently in all -gcflags, -asmflags, and -ldflags", f.File().Name())
|
|
}
|
|
panic("cannot read object file")
|
|
}
|
|
localSymVersion := syms.IncVersion()
|
|
pkgprefix := objabi.PathToPrefix(lib.Pkg) + "."
|
|
ndef := r.NSym()
|
|
nnonpkgdef := r.NNonpkgdef()
|
|
or := &oReader{r, unit, localSymVersion, r.Flags(), pkgprefix, make([]Sym, ndef+nnonpkgdef+r.NNonpkgref()), ndef, uint32(len(l.objs))}
|
|
|
|
// Autolib
|
|
lib.Autolib = append(lib.Autolib, r.Autolib()...)
|
|
|
|
// DWARF file table
|
|
nfile := r.NDwarfFile()
|
|
unit.DWARFFileTable = make([]string, nfile)
|
|
for i := range unit.DWARFFileTable {
|
|
unit.DWARFFileTable[i] = r.DwarfFile(i)
|
|
}
|
|
|
|
l.addObj(lib.Pkg, or)
|
|
l.preloadSyms(or, pkgDef)
|
|
|
|
// The caller expects us consuming all the data
|
|
f.MustSeek(length, os.SEEK_CUR)
|
|
|
|
return r.Fingerprint()
|
|
}
|
|
|
|
// Preload symbols of given kind from an object.
|
|
func (l *Loader) preloadSyms(r *oReader, kind int) {
|
|
ndef := r.NSym()
|
|
nnonpkgdef := r.NNonpkgdef()
|
|
var start, end int
|
|
switch kind {
|
|
case pkgDef:
|
|
start = 0
|
|
end = ndef
|
|
case nonPkgDef:
|
|
start = ndef
|
|
end = ndef + nnonpkgdef
|
|
default:
|
|
panic("preloadSyms: bad kind")
|
|
}
|
|
l.growSyms(len(l.objSyms) + end - start)
|
|
l.growAttrBitmaps(len(l.objSyms) + end - start)
|
|
for i := start; i < end; i++ {
|
|
osym := r.Sym(i)
|
|
name := strings.Replace(osym.Name(r.Reader), "\"\".", r.pkgprefix, -1)
|
|
v := abiToVer(osym.ABI(), r.version)
|
|
dupok := osym.Dupok()
|
|
gi, added := l.AddSym(name, v, r, i, kind, dupok, sym.AbiSymKindToSymKind[objabi.SymKind(osym.Type())])
|
|
r.syms[i] = gi
|
|
if !added {
|
|
continue
|
|
}
|
|
if osym.TopFrame() {
|
|
l.SetAttrTopFrame(gi, true)
|
|
}
|
|
if osym.Local() {
|
|
l.SetAttrLocal(gi, true)
|
|
}
|
|
if strings.HasPrefix(name, "go.itablink.") {
|
|
l.itablink[gi] = struct{}{}
|
|
}
|
|
if strings.HasPrefix(name, "runtime.") {
|
|
if bi := goobj2.BuiltinIdx(name, v); bi != -1 {
|
|
// This is a definition of a builtin symbol. Record where it is.
|
|
l.builtinSyms[bi] = gi
|
|
}
|
|
}
|
|
if strings.HasPrefix(name, "go.string.") ||
|
|
strings.HasPrefix(name, "gclocals·") ||
|
|
strings.HasPrefix(name, "runtime.gcbits.") {
|
|
l.SetAttrNotInSymbolTable(gi, true)
|
|
}
|
|
if a := osym.Align(); a != 0 {
|
|
l.SetSymAlign(gi, int32(a))
|
|
}
|
|
}
|
|
}
|
|
|
|
// Add non-package symbols and references to external symbols (which are always
|
|
// named).
|
|
func (l *Loader) LoadNonpkgSyms(arch *sys.Arch) {
|
|
for _, o := range l.objs[1:] {
|
|
l.preloadSyms(o.r, nonPkgDef)
|
|
}
|
|
for _, o := range l.objs[1:] {
|
|
loadObjRefs(l, o.r, arch)
|
|
}
|
|
}
|
|
|
|
func loadObjRefs(l *Loader, r *oReader, arch *sys.Arch) {
|
|
ndef := r.NSym() + r.NNonpkgdef()
|
|
for i, n := 0, r.NNonpkgref(); i < n; i++ {
|
|
osym := r.Sym(ndef + i)
|
|
name := strings.Replace(osym.Name(r.Reader), "\"\".", r.pkgprefix, -1)
|
|
v := abiToVer(osym.ABI(), r.version)
|
|
r.syms[ndef+i] = l.LookupOrCreateSym(name, v)
|
|
gi := r.syms[ndef+i]
|
|
if osym.Local() {
|
|
l.SetAttrLocal(gi, true)
|
|
}
|
|
l.preprocess(arch, gi, name)
|
|
}
|
|
}
|
|
|
|
func abiToVer(abi uint16, localSymVersion int) int {
|
|
var v int
|
|
if abi == goobj2.SymABIstatic {
|
|
// Static
|
|
v = localSymVersion
|
|
} else if abiver := sym.ABIToVersion(obj.ABI(abi)); abiver != -1 {
|
|
// Note that data symbols are "ABI0", which maps to version 0.
|
|
v = abiver
|
|
} else {
|
|
log.Fatalf("invalid symbol ABI: %d", abi)
|
|
}
|
|
return v
|
|
}
|
|
|
|
// preprocess looks for integer/floating point constant symbols whose
|
|
// content is encoded into the symbol name, and promotes them into
|
|
// real symbols with RODATA type and a payload that matches the
|
|
// encoded content.
|
|
func (l *Loader) preprocess(arch *sys.Arch, s Sym, name string) {
|
|
if name != "" && name[0] == '$' && len(name) > 5 && l.SymType(s) == 0 && len(l.Data(s)) == 0 {
|
|
x, err := strconv.ParseUint(name[5:], 16, 64)
|
|
if err != nil {
|
|
log.Panicf("failed to parse $-symbol %s: %v", name, err)
|
|
}
|
|
su := l.MakeSymbolUpdater(s)
|
|
su.SetType(sym.SRODATA)
|
|
su.SetLocal(true)
|
|
switch name[:5] {
|
|
case "$f32.":
|
|
if uint64(uint32(x)) != x {
|
|
log.Panicf("$-symbol %s too large: %d", name, x)
|
|
}
|
|
su.AddUint32(arch, uint32(x))
|
|
case "$f64.", "$i64.":
|
|
su.AddUint64(arch, x)
|
|
default:
|
|
log.Panicf("unrecognized $-symbol: %s", name)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Load full contents.
|
|
func (l *Loader) LoadFull(arch *sys.Arch, syms *sym.Symbols) {
|
|
// create all Symbols first.
|
|
l.growSyms(l.NSym())
|
|
l.growSects(l.NSym())
|
|
|
|
nr := 0 // total number of sym.Reloc's we'll need
|
|
for _, o := range l.objs[1:] {
|
|
nr += loadObjSyms(l, syms, o.r)
|
|
}
|
|
|
|
// Make a first pass through the external symbols, making
|
|
// sure that each external symbol has a non-nil entry in
|
|
// l.Syms (note that relocations and symbol content will
|
|
// be copied in a later loop).
|
|
toConvert := make([]Sym, 0, len(l.payloads))
|
|
for _, i := range l.extReader.syms {
|
|
sname := l.RawSymName(i)
|
|
if !l.attrReachable.Has(i) {
|
|
continue
|
|
}
|
|
pp := l.getPayload(i)
|
|
nr += len(pp.relocs)
|
|
// create and install the sym.Symbol here so that l.Syms will
|
|
// be fully populated when we do relocation processing and
|
|
// outer/sub processing below. Note that once we do this,
|
|
// we'll need to get at the payload for a symbol with direct
|
|
// reference to l.payloads[] as opposed to calling l.getPayload().
|
|
s := l.allocSym(sname, 0)
|
|
l.installSym(i, s)
|
|
toConvert = append(toConvert, i)
|
|
}
|
|
|
|
// allocate a single large slab of relocations for all live symbols
|
|
l.relocBatch = make([]sym.Reloc, nr)
|
|
|
|
// convert payload-based external symbols into sym.Symbol-based
|
|
for _, i := range toConvert {
|
|
|
|
// Copy kind/size/value etc.
|
|
pp := l.payloads[l.extIndex(i)]
|
|
s := l.Syms[i]
|
|
s.Version = int16(pp.ver)
|
|
s.Type = pp.kind
|
|
s.Size = pp.size
|
|
if pp.gotype != 0 {
|
|
s.Gotype = l.Syms[pp.gotype]
|
|
}
|
|
if f, ok := l.symPkg[i]; ok {
|
|
s.File = f
|
|
} else if pp.objidx != 0 {
|
|
s.File = l.objs[pp.objidx].r.unit.Lib.Pkg
|
|
}
|
|
|
|
// Copy relocations
|
|
batch := l.relocBatch
|
|
s.R = batch[:len(pp.relocs):len(pp.relocs)]
|
|
l.relocBatch = batch[len(pp.relocs):]
|
|
relocs := l.Relocs(i)
|
|
l.convertRelocations(i, &relocs, s, false)
|
|
|
|
// Copy data
|
|
s.P = pp.data
|
|
|
|
// Transfer over attributes.
|
|
l.migrateAttributes(i, s)
|
|
}
|
|
|
|
// load contents of defined symbols
|
|
for _, o := range l.objs[1:] {
|
|
loadObjFull(l, o.r)
|
|
}
|
|
|
|
// Note: resolution of ABI aliases is now also handled in
|
|
// loader.convertRelocations, so once the host object loaders move
|
|
// completely to loader.Sym, we can remove the code below.
|
|
|
|
// Resolve ABI aliases for external symbols. This is only
|
|
// needed for internal cgo linking.
|
|
for _, i := range l.extReader.syms {
|
|
if s := l.Syms[i]; s != nil && s.Attr.Reachable() {
|
|
for ri := range s.R {
|
|
r := &s.R[ri]
|
|
if r.Sym != nil && r.Sym.Type == sym.SABIALIAS {
|
|
r.Sym = r.Sym.R[0].Sym
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ResolveABIAlias given a symbol returns the ABI alias target of that
|
|
// symbol. If the sym in question is not an alias, the sym itself is
|
|
// returned.
|
|
func (l *Loader) ResolveABIAlias(s Sym) Sym {
|
|
if l.SymType(s) != sym.SABIALIAS {
|
|
return s
|
|
}
|
|
relocs := l.Relocs(s)
|
|
target := relocs.At2(0).Sym()
|
|
if l.SymType(target) == sym.SABIALIAS {
|
|
panic(fmt.Sprintf("ABI alias %s references another ABI alias %s", l.SymName(s), l.SymName(target)))
|
|
}
|
|
return target
|
|
}
|
|
|
|
// PropagateSymbolChangesBackToLoader is a temporary shim function
|
|
// that copies over a given sym.Symbol into the equivalent representation
|
|
// in the loader world. The intent is to enable converting a given
|
|
// linker phase/pass from dealing with sym.Symbol's to a modernized
|
|
// pass that works with loader.Sym, in cases where the "loader.Sym
|
|
// wavefront" has not yet reached the pass in question. For such work
|
|
// the recipe is to first call PropagateSymbolChangesBackToLoader(),
|
|
// then exexute the pass working with the loader, then call
|
|
// PropagateLoaderChangesToSymbols to copy the changes made by the
|
|
// pass back to the sym.Symbol world.
|
|
func (l *Loader) PropagateSymbolChangesBackToLoader() {
|
|
|
|
// For the moment we only copy symbol values, and we don't touch
|
|
// any new sym.Symbols created since loadlibfull() was run. This
|
|
// seems to be what's needed for DWARF gen.
|
|
for i := Sym(1); i < Sym(len(l.objSyms)); i++ {
|
|
s := l.Syms[i]
|
|
if s != nil {
|
|
if s.Value != l.SymValue(i) {
|
|
l.SetSymValue(i, s.Value)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// PropagateLoaderChangesToSymbols is a temporary shim function that
|
|
// takes a list of loader.Sym symbols and works to copy their contents
|
|
// and attributes over to a corresponding sym.Symbol. The parameter
|
|
// anonVerReplacement specifies a version number for any new anonymous
|
|
// symbols encountered on the list, when creating sym.Symbols for them
|
|
// (or zero if we don't expect to encounter any new anon symbols). See
|
|
// the PropagateSymbolChangesBackToLoader header comment for more
|
|
// info.
|
|
//
|
|
// WARNING: this function is brittle and depends heavily on loader
|
|
// implementation. A key problem with doing this is that as things
|
|
// stand at the moment, some sym.Symbol contents/attributes are
|
|
// populated only when converting from loader.Sym to sym.Symbol in
|
|
// loadlibfull, meaning we may wipe out some information when copying
|
|
// back.
|
|
|
|
func (l *Loader) PropagateLoaderChangesToSymbols(toconvert []Sym, anonVerReplacement int) []*sym.Symbol {
|
|
|
|
result := []*sym.Symbol{}
|
|
relocfixup := []Sym{}
|
|
|
|
// Note: this loop needs to allow for the possibility that we may
|
|
// see "new" symbols on the 'toconvert' list that come from object
|
|
// files (for example, DWARF location lists), as opposed to just
|
|
// newly manufactured symbols (ex: DWARF section symbols such as
|
|
// ".debug_info"). This means that we have to be careful not to
|
|
// stomp on sym.Symbol attributes/content that was set up in
|
|
// in loadlibfull().
|
|
|
|
// Also note that in order for the relocation fixup to work, we
|
|
// have to do this in two passes -- one pass to create the symbols,
|
|
// and then a second fix up the relocations once all necessary
|
|
// sym.Symbols are created.
|
|
|
|
// First pass, symbol creation and symbol data fixup.
|
|
for _, cand := range toconvert {
|
|
|
|
sn := l.SymName(cand)
|
|
sv := l.SymVersion(cand)
|
|
st := l.SymType(cand)
|
|
if sv < 0 {
|
|
if anonVerReplacement == 0 {
|
|
panic("expected valid anon version replacement")
|
|
}
|
|
sv = anonVerReplacement
|
|
}
|
|
|
|
s := l.Syms[cand]
|
|
|
|
isnew := false
|
|
if sn == "" {
|
|
// Don't install anonymous symbols in the lookup tab.
|
|
if s == nil {
|
|
s = l.allocSym(sn, sv)
|
|
l.installSym(cand, s)
|
|
}
|
|
isnew = true
|
|
} else {
|
|
if s != nil {
|
|
// Already have a symbol for this -- it must be
|
|
// something that was previously processed by
|
|
// loadObjFull. Note that the symbol in question may
|
|
// or may not be in the name lookup map.
|
|
} else {
|
|
isnew = true
|
|
s = l.SymLookup(sn, sv)
|
|
}
|
|
}
|
|
result = append(result, s)
|
|
|
|
// Always copy these from new to old.
|
|
s.Value = l.SymValue(cand)
|
|
s.Type = st
|
|
|
|
// If the data for a symbol has increased in size, make sure
|
|
// we bring the new content across.
|
|
relfix := isnew
|
|
if isnew || len(l.Data(cand)) > len(s.P) {
|
|
s.P = l.Data(cand)
|
|
s.Size = int64(len(s.P))
|
|
relfix = true
|
|
}
|
|
|
|
// For 'new' symbols, copy other content (such as Gotype,
|
|
// sym file, relocations, etc).
|
|
if isnew {
|
|
if gt := l.SymGoType(cand); gt != 0 {
|
|
s.Gotype = l.Syms[gt]
|
|
}
|
|
if f, ok := l.symPkg[cand]; ok {
|
|
s.File = f
|
|
} else {
|
|
r, _ := l.toLocal(cand)
|
|
if r != nil && r != l.extReader {
|
|
s.File = l.SymPkg(cand)
|
|
}
|
|
}
|
|
}
|
|
|
|
if relfix {
|
|
relocfixup = append(relocfixup, cand)
|
|
}
|
|
|
|
// If new symbol, call a helper to migrate attributes.
|
|
// Otherwise touch only not-in-symbol-table, since there are
|
|
// some attrs that are only set up at the point where we
|
|
// convert loader.Sym to sym.Symbol.
|
|
if isnew {
|
|
l.migrateAttributes(cand, s)
|
|
} else {
|
|
if l.AttrNotInSymbolTable(cand) {
|
|
s.Attr.Set(sym.AttrNotInSymbolTable, true)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Second pass to fix up relocations.
|
|
for _, cand := range relocfixup {
|
|
s := l.Syms[cand]
|
|
relocs := l.Relocs(cand)
|
|
if len(s.R) != relocs.Count() {
|
|
s.R = make([]sym.Reloc, relocs.Count())
|
|
}
|
|
l.convertRelocations(cand, &relocs, s, true)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
// ExtractSymbols grabs the symbols out of the loader for work that hasn't been
|
|
// ported to the new symbol type.
|
|
func (l *Loader) ExtractSymbols(syms *sym.Symbols) {
|
|
// Add symbols to the ctxt.Syms lookup table. This explicitly skips things
|
|
// created via loader.Create (marked with versions less than zero), since
|
|
// if we tried to add these we'd wind up with collisions. We do, however,
|
|
// add these symbols to the list of global symbols so that other future
|
|
// steps (like pclntab generation) can find these symbols if neceassary.
|
|
// Along the way, update the version from the negative anon version to
|
|
// something larger than sym.SymVerStatic (needed so that
|
|
// sym.symbol.IsFileLocal() works properly).
|
|
anonVerReplacement := syms.IncVersion()
|
|
for _, s := range l.Syms {
|
|
if s == nil {
|
|
continue
|
|
}
|
|
syms.Allsym = append(syms.Allsym, s) // XXX still add to Allsym for now, as there are code looping through Allsym
|
|
if s.Version < 0 {
|
|
s.Version = int16(anonVerReplacement)
|
|
}
|
|
}
|
|
|
|
// Provide lookup functions for sym.Symbols.
|
|
l.SymLookup = func(name string, ver int) *sym.Symbol {
|
|
i := l.LookupOrCreateSym(name, ver)
|
|
if s := l.Syms[i]; s != nil {
|
|
return s
|
|
}
|
|
s := l.allocSym(name, ver)
|
|
l.installSym(i, s)
|
|
syms.Allsym = append(syms.Allsym, s) // XXX see above
|
|
return s
|
|
}
|
|
syms.Lookup = l.SymLookup
|
|
syms.ROLookup = func(name string, ver int) *sym.Symbol {
|
|
i := l.Lookup(name, ver)
|
|
return l.Syms[i]
|
|
}
|
|
syms.Newsym = func(name string, ver int) *sym.Symbol {
|
|
i := l.newExtSym(name, ver)
|
|
s := l.allocSym(name, ver)
|
|
l.installSym(i, s)
|
|
syms.Allsym = append(syms.Allsym, s) // XXX see above
|
|
return s
|
|
}
|
|
}
|
|
|
|
// allocSym allocates a new symbol backing.
|
|
func (l *Loader) allocSym(name string, version int) *sym.Symbol {
|
|
batch := l.symBatch
|
|
if len(batch) == 0 {
|
|
batch = make([]sym.Symbol, 1000)
|
|
}
|
|
s := &batch[0]
|
|
l.symBatch = batch[1:]
|
|
|
|
s.Dynid = -1
|
|
s.Name = name
|
|
s.Version = int16(version)
|
|
|
|
return s
|
|
}
|
|
|
|
// installSym sets the underlying sym.Symbol for the specified sym index.
|
|
func (l *Loader) installSym(i Sym, s *sym.Symbol) {
|
|
if s == nil {
|
|
panic("installSym nil symbol")
|
|
}
|
|
if l.Syms[i] != nil {
|
|
panic("sym already present in installSym")
|
|
}
|
|
l.Syms[i] = s
|
|
}
|
|
|
|
// addNewSym adds a new sym.Symbol to the i-th index in the list of symbols.
|
|
func (l *Loader) addNewSym(i Sym, name string, ver int, unit *sym.CompilationUnit, t sym.SymKind) *sym.Symbol {
|
|
s := l.allocSym(name, ver)
|
|
if s.Type != 0 && s.Type != sym.SXREF {
|
|
fmt.Println("symbol already processed:", unit.Lib, i, s)
|
|
panic("symbol already processed")
|
|
}
|
|
if t == sym.SBSS && (s.Type == sym.SRODATA || s.Type == sym.SNOPTRBSS) {
|
|
t = s.Type
|
|
}
|
|
s.Type = t
|
|
s.Unit = unit
|
|
l.growSyms(int(i))
|
|
l.installSym(i, s)
|
|
return s
|
|
}
|
|
|
|
// TopLevelSym tests a symbol (by name and kind) to determine whether
|
|
// the symbol first class sym (participating in the link) or is an
|
|
// anonymous aux or sub-symbol containing some sub-part or payload of
|
|
// another symbol.
|
|
func (l *Loader) TopLevelSym(s Sym) bool {
|
|
return topLevelSym(l.RawSymName(s), l.SymType(s))
|
|
}
|
|
|
|
// topLevelSym tests a symbol name and kind to determine whether
|
|
// the symbol first class sym (participating in the link) or is an
|
|
// anonymous aux or sub-symbol containing some sub-part or payload of
|
|
// another symbol.
|
|
func topLevelSym(sname string, skind sym.SymKind) bool {
|
|
if sname != "" {
|
|
return true
|
|
}
|
|
switch skind {
|
|
case sym.SDWARFINFO, sym.SDWARFRANGE, sym.SDWARFLOC, sym.SDWARFLINES, sym.SGOFUNC:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
// loadObjSyms creates sym.Symbol objects for the live Syms in the
|
|
// object corresponding to object reader "r". Return value is the
|
|
// number of sym.Reloc entries required for all the new symbols.
|
|
func loadObjSyms(l *Loader, syms *sym.Symbols, r *oReader) int {
|
|
nr := 0
|
|
for i, n := 0, r.NSym()+r.NNonpkgdef(); i < n; i++ {
|
|
gi := r.syms[i]
|
|
if r2, i2 := l.toLocal(gi); r2 != r || i2 != i {
|
|
continue // come from a different object
|
|
}
|
|
osym := r.Sym(i)
|
|
name := strings.Replace(osym.Name(r.Reader), "\"\".", r.pkgprefix, -1)
|
|
t := sym.AbiSymKindToSymKind[objabi.SymKind(osym.Type())]
|
|
|
|
// Skip non-dwarf anonymous symbols (e.g. funcdata),
|
|
// since they will never be turned into sym.Symbols.
|
|
if !topLevelSym(name, t) {
|
|
continue
|
|
}
|
|
ver := abiToVer(osym.ABI(), r.version)
|
|
if t == sym.SXREF {
|
|
log.Fatalf("bad sxref")
|
|
}
|
|
if t == 0 {
|
|
log.Fatalf("missing type for %s in %s", name, r.unit.Lib)
|
|
}
|
|
if !l.attrReachable.Has(gi) && name != "runtime.addmoduledata" && name != "runtime.lastmoduledatap" {
|
|
// No need to load unreachable symbols.
|
|
// XXX reference to runtime.addmoduledata may be generated later by the linker in plugin mode.
|
|
continue
|
|
}
|
|
|
|
l.addNewSym(gi, name, ver, r.unit, t)
|
|
nr += r.NReloc(i)
|
|
}
|
|
return nr
|
|
}
|
|
|
|
// cloneToExternal takes the existing object file symbol (symIdx)
|
|
// and creates a new external symbol payload that is a clone with
|
|
// respect to name, version, type, relocations, etc. The idea here
|
|
// is that if the linker decides it wants to update the contents of
|
|
// a symbol originally discovered as part of an object file, it's
|
|
// easier to do this if we make the updates to an external symbol
|
|
// payload.
|
|
// XXX maybe rename? makeExtPayload?
|
|
func (l *Loader) cloneToExternal(symIdx Sym) {
|
|
if l.IsExternal(symIdx) {
|
|
panic("sym is already external, no need for clone")
|
|
}
|
|
l.growSyms(int(symIdx))
|
|
|
|
// Read the particulars from object.
|
|
r, li := l.toLocal(symIdx)
|
|
osym := r.Sym(li)
|
|
sname := strings.Replace(osym.Name(r.Reader), "\"\".", r.pkgprefix, -1)
|
|
sver := abiToVer(osym.ABI(), r.version)
|
|
skind := sym.AbiSymKindToSymKind[objabi.SymKind(osym.Type())]
|
|
|
|
// Create new symbol, update version and kind.
|
|
pi := l.newPayload(sname, sver)
|
|
pp := l.payloads[pi]
|
|
pp.kind = skind
|
|
pp.ver = sver
|
|
pp.size = int64(osym.Siz())
|
|
pp.objidx = r.objidx
|
|
|
|
// If this is a def, then copy the guts. We expect this case
|
|
// to be very rare (one case it may come up is with -X).
|
|
if li < (r.NSym() + r.NNonpkgdef()) {
|
|
|
|
// Copy relocations
|
|
relocs := l.Relocs(symIdx)
|
|
pp.relocs = make([]goobj2.Reloc, relocs.Count())
|
|
pp.reltypes = make([]objabi.RelocType, relocs.Count())
|
|
for i := range pp.relocs {
|
|
// Copy the relocs slice.
|
|
// Convert local reference to global reference.
|
|
rel := relocs.At2(i)
|
|
pp.relocs[i].Set(rel.Off(), rel.Siz(), 0, rel.Add(), goobj2.SymRef{PkgIdx: 0, SymIdx: uint32(rel.Sym())})
|
|
pp.reltypes[i] = rel.Type()
|
|
}
|
|
|
|
// Copy data
|
|
pp.data = r.Data(li)
|
|
}
|
|
|
|
// If we're overriding a data symbol, collect the associated
|
|
// Gotype, so as to propagate it to the new symbol.
|
|
auxs := r.Auxs(li)
|
|
pp.auxs = auxs
|
|
loop:
|
|
for j := range auxs {
|
|
a := &auxs[j]
|
|
switch a.Type() {
|
|
case goobj2.AuxGotype:
|
|
pp.gotype = l.resolve(r, a.Sym())
|
|
break loop
|
|
default:
|
|
// nothing to do
|
|
}
|
|
}
|
|
|
|
// Install new payload to global index space.
|
|
// (This needs to happen at the end, as the accessors above
|
|
// need to access the old symbol content.)
|
|
l.objSyms[symIdx] = objSym{l.extReader, pi}
|
|
l.extReader.syms = append(l.extReader.syms, symIdx)
|
|
}
|
|
|
|
// Copy the payload of symbol src to dst. Both src and dst must be external
|
|
// symbols.
|
|
// The intended use case is that when building/linking against a shared library,
|
|
// where we do symbol name mangling, the Go object file may have reference to
|
|
// the original symbol name whereas the shared library provides a symbol with
|
|
// the mangled name. When we do mangling, we copy payload of mangled to original.
|
|
func (l *Loader) CopySym(src, dst Sym) {
|
|
if !l.IsExternal(dst) {
|
|
panic("dst is not external") //l.newExtSym(l.SymName(dst), l.SymVersion(dst))
|
|
}
|
|
if !l.IsExternal(src) {
|
|
panic("src is not external") //l.cloneToExternal(src)
|
|
}
|
|
l.payloads[l.extIndex(dst)] = l.payloads[l.extIndex(src)]
|
|
l.SetSymPkg(dst, l.SymPkg(src))
|
|
// TODO: other attributes?
|
|
}
|
|
|
|
// CopyAttributes copies over all of the attributes of symbol 'src' to
|
|
// symbol 'dst'.
|
|
func (l *Loader) CopyAttributes(src Sym, dst Sym) {
|
|
l.SetAttrReachable(dst, l.AttrReachable(src))
|
|
l.SetAttrOnList(dst, l.AttrOnList(src))
|
|
l.SetAttrLocal(dst, l.AttrLocal(src))
|
|
l.SetAttrNotInSymbolTable(dst, l.AttrNotInSymbolTable(src))
|
|
if l.IsExternal(dst) {
|
|
l.SetAttrVisibilityHidden(dst, l.AttrVisibilityHidden(src))
|
|
l.SetAttrDuplicateOK(dst, l.AttrDuplicateOK(src))
|
|
l.SetAttrShared(dst, l.AttrShared(src))
|
|
l.SetAttrExternal(dst, l.AttrExternal(src))
|
|
} else {
|
|
// Some attributes are modifiable only for external symbols.
|
|
// In such cases, don't try to transfer over the attribute
|
|
// from the source even if there is a clash. This comes up
|
|
// when copying attributes from a dupOK ABI wrapper symbol to
|
|
// the real target symbol (which may not be marked dupOK).
|
|
}
|
|
l.SetAttrTopFrame(dst, l.AttrTopFrame(src))
|
|
l.SetAttrSpecial(dst, l.AttrSpecial(src))
|
|
l.SetAttrCgoExportDynamic(dst, l.AttrCgoExportDynamic(src))
|
|
l.SetAttrCgoExportStatic(dst, l.AttrCgoExportStatic(src))
|
|
l.SetAttrReadOnly(dst, l.AttrReadOnly(src))
|
|
}
|
|
|
|
// migrateAttributes copies over all of the attributes of symbol 'src' to
|
|
// sym.Symbol 'dst'.
|
|
func (l *Loader) migrateAttributes(src Sym, dst *sym.Symbol) {
|
|
dst.Value = l.SymValue(src)
|
|
dst.Align = l.SymAlign(src)
|
|
dst.Sect = l.SymSect(src)
|
|
|
|
dst.Attr.Set(sym.AttrReachable, l.AttrReachable(src))
|
|
dst.Attr.Set(sym.AttrOnList, l.AttrOnList(src))
|
|
dst.Attr.Set(sym.AttrLocal, l.AttrLocal(src))
|
|
dst.Attr.Set(sym.AttrNotInSymbolTable, l.AttrNotInSymbolTable(src))
|
|
dst.Attr.Set(sym.AttrNoSplit, l.IsNoSplit(src))
|
|
dst.Attr.Set(sym.AttrVisibilityHidden, l.AttrVisibilityHidden(src))
|
|
dst.Attr.Set(sym.AttrDuplicateOK, l.AttrDuplicateOK(src))
|
|
dst.Attr.Set(sym.AttrShared, l.AttrShared(src))
|
|
dst.Attr.Set(sym.AttrExternal, l.AttrExternal(src))
|
|
dst.Attr.Set(sym.AttrTopFrame, l.AttrTopFrame(src))
|
|
dst.Attr.Set(sym.AttrSpecial, l.AttrSpecial(src))
|
|
dst.Attr.Set(sym.AttrCgoExportDynamic, l.AttrCgoExportDynamic(src))
|
|
dst.Attr.Set(sym.AttrCgoExportStatic, l.AttrCgoExportStatic(src))
|
|
dst.Attr.Set(sym.AttrReadOnly, l.AttrReadOnly(src))
|
|
|
|
// Convert outer/sub relationships
|
|
if outer, ok := l.outer[src]; ok {
|
|
dst.Outer = l.Syms[outer]
|
|
}
|
|
if sub, ok := l.sub[src]; ok {
|
|
dst.Sub = l.Syms[sub]
|
|
}
|
|
|
|
// Set sub-symbol attribute. See the comment on the AttrSubSymbol
|
|
// method for more on this, there is some tricky stuff here.
|
|
dst.Attr.Set(sym.AttrSubSymbol, l.outer[src] != 0 && l.sub[l.outer[src]] != 0)
|
|
|
|
// Copy over dynimplib, dynimpvers, extname.
|
|
if name, ok := l.extname[src]; ok {
|
|
dst.SetExtname(name)
|
|
}
|
|
if l.SymDynimplib(src) != "" {
|
|
dst.SetDynimplib(l.SymDynimplib(src))
|
|
}
|
|
if l.SymDynimpvers(src) != "" {
|
|
dst.SetDynimpvers(l.SymDynimpvers(src))
|
|
}
|
|
|
|
// Copy ELF type if set.
|
|
if et, ok := l.elfType[src]; ok {
|
|
dst.SetElfType(et)
|
|
}
|
|
|
|
// Copy pe objects values if set.
|
|
if plt, ok := l.plt[src]; ok {
|
|
dst.SetPlt(plt)
|
|
}
|
|
if got, ok := l.got[src]; ok {
|
|
dst.SetGot(got)
|
|
}
|
|
|
|
// Copy dynid
|
|
if dynid, ok := l.dynid[src]; ok {
|
|
dst.Dynid = dynid
|
|
}
|
|
}
|
|
|
|
// CreateExtSym creates a new external symbol with the specified name
|
|
// without adding it to any lookup tables, returning a Sym index for it.
|
|
func (l *Loader) CreateExtSym(name string, ver int) Sym {
|
|
return l.newExtSym(name, ver)
|
|
}
|
|
|
|
// CreateStaticSym creates a new static symbol with the specified name
|
|
// without adding it to any lookup tables, returning a Sym index for it.
|
|
func (l *Loader) CreateStaticSym(name string) Sym {
|
|
// Assign a new unique negative version -- this is to mark the
|
|
// symbol so that it can be skipped when ExtractSymbols is adding
|
|
// ext syms to the sym.Symbols hash.
|
|
l.anonVersion--
|
|
return l.newExtSym(name, l.anonVersion)
|
|
}
|
|
|
|
func loadObjFull(l *Loader, r *oReader) {
|
|
resolveSymRef := func(s goobj2.SymRef) *sym.Symbol {
|
|
i := l.resolve(r, s)
|
|
return l.Syms[i]
|
|
}
|
|
|
|
for i, n := 0, r.NSym()+r.NNonpkgdef(); i < n; i++ {
|
|
// A symbol may be a dup or overwritten. In this case, its
|
|
// content will actually be provided by a different object
|
|
// (to which its global index points). Skip those symbols.
|
|
gi := l.toGlobal(r, i)
|
|
if r2, i2 := l.toLocal(gi); r2 != r || i2 != i {
|
|
continue
|
|
}
|
|
s := l.Syms[gi]
|
|
if s == nil {
|
|
continue
|
|
}
|
|
|
|
l.migrateAttributes(gi, s)
|
|
// Be careful not to overwrite attributes set by the linker.
|
|
// Don't use the attributes from the object file.
|
|
|
|
osym := r.Sym(i)
|
|
size := osym.Siz()
|
|
|
|
// Symbol data
|
|
s.P = r.Data(i)
|
|
s.Attr.Set(sym.AttrReadOnly, r.ReadOnly())
|
|
|
|
// Relocs
|
|
relocs := l.relocs(r, i)
|
|
batch := l.relocBatch
|
|
s.R = batch[:relocs.Count():relocs.Count()]
|
|
l.relocBatch = batch[relocs.Count():]
|
|
l.convertRelocations(gi, &relocs, s, false)
|
|
|
|
// Aux symbol info
|
|
auxs := r.Auxs(i)
|
|
for j := range auxs {
|
|
a := &auxs[j]
|
|
switch a.Type() {
|
|
case goobj2.AuxGotype:
|
|
typ := resolveSymRef(a.Sym())
|
|
if typ != nil {
|
|
s.Gotype = typ
|
|
}
|
|
case goobj2.AuxFuncInfo, goobj2.AuxFuncdata:
|
|
// already handled
|
|
case goobj2.AuxDwarfInfo, goobj2.AuxDwarfLoc, goobj2.AuxDwarfRanges, goobj2.AuxDwarfLines:
|
|
// ignored for now
|
|
default:
|
|
panic("unknown aux type")
|
|
}
|
|
}
|
|
|
|
s.File = r.pkgprefix[:len(r.pkgprefix)-1]
|
|
if s.Size < int64(size) {
|
|
s.Size = int64(size)
|
|
}
|
|
}
|
|
}
|
|
|
|
// convertRelocations takes a vector of loader.Reloc relocations and
|
|
// translates them into an equivalent set of sym.Reloc relocations on
|
|
// the symbol "dst", performing fixups along the way for ABI aliases,
|
|
// etc. It is assumed that the caller has pre-allocated the dst symbol
|
|
// relocations slice. If 'strict' is set, then this method will
|
|
// panic if it finds a relocation targeting a nil symbol.
|
|
func (l *Loader) convertRelocations(symIdx Sym, src *Relocs, dst *sym.Symbol, strict bool) {
|
|
for j := range dst.R {
|
|
r := src.At2(j)
|
|
rs := r.Sym()
|
|
sz := r.Siz()
|
|
rt := r.Type()
|
|
if rt == objabi.R_METHODOFF {
|
|
if l.attrReachable.Has(rs) {
|
|
rt = objabi.R_ADDROFF
|
|
} else {
|
|
sz = 0
|
|
rs = 0
|
|
}
|
|
}
|
|
if rt == objabi.R_WEAKADDROFF && !l.attrReachable.Has(rs) {
|
|
rs = 0
|
|
sz = 0
|
|
}
|
|
if rs != 0 && l.Syms[rs] != nil && l.Syms[rs].Type == sym.SABIALIAS {
|
|
rsrelocs := l.Relocs(rs)
|
|
rs = rsrelocs.At2(0).Sym()
|
|
}
|
|
if strict && rs != 0 && l.Syms[rs] == nil && rt != objabi.R_USETYPE {
|
|
panic("nil reloc target in convertRelocations")
|
|
}
|
|
dst.R[j] = sym.Reloc{
|
|
Off: r.Off(),
|
|
Siz: sz,
|
|
Type: rt,
|
|
Add: r.Add(),
|
|
Sym: l.Syms[rs],
|
|
}
|
|
if rv := l.RelocVariant(symIdx, j); rv != 0 {
|
|
dst.R[j].InitExt()
|
|
dst.R[j].Variant = rv
|
|
}
|
|
}
|
|
}
|
|
|
|
// relocId is essentially a <S,R> tuple identifying the Rth
|
|
// relocation of symbol S.
|
|
type relocId struct {
|
|
sym Sym
|
|
ridx int
|
|
}
|
|
|
|
// SetRelocVariant sets the 'variant' property of a relocation on
|
|
// some specific symbol.
|
|
func (l *Loader) SetRelocVariant(s Sym, ri int, v sym.RelocVariant) {
|
|
// sanity check
|
|
if relocs := l.Relocs(s); ri >= relocs.Count() {
|
|
panic("invalid relocation ID")
|
|
}
|
|
if l.relocVariant == nil {
|
|
l.relocVariant = make(map[relocId]sym.RelocVariant)
|
|
}
|
|
if v != 0 {
|
|
l.relocVariant[relocId{s, ri}] = v
|
|
} else {
|
|
delete(l.relocVariant, relocId{s, ri})
|
|
}
|
|
}
|
|
|
|
// RelocVariant returns the 'variant' property of a relocation on
|
|
// some specific symbol.
|
|
func (l *Loader) RelocVariant(s Sym, ri int) sym.RelocVariant {
|
|
return l.relocVariant[relocId{s, ri}]
|
|
}
|
|
|
|
// UndefinedRelocTargets iterates through the global symbol index
|
|
// space, looking for symbols with relocations targeting undefined
|
|
// references. The linker's loadlib method uses this to determine if
|
|
// there are unresolved references to functions in system libraries
|
|
// (for example, libgcc.a), presumably due to CGO code. Return
|
|
// value is a list of loader.Sym's corresponding to the undefined
|
|
// cross-refs. The "limit" param controls the maximum number of
|
|
// results returned; if "limit" is -1, then all undefs are returned.
|
|
func (l *Loader) UndefinedRelocTargets(limit int) []Sym {
|
|
result := []Sym{}
|
|
for si := Sym(1); si < Sym(len(l.objSyms)); si++ {
|
|
relocs := l.Relocs(si)
|
|
for ri := 0; ri < relocs.Count(); ri++ {
|
|
r := relocs.At2(ri)
|
|
rs := r.Sym()
|
|
if rs != 0 && l.SymType(rs) == sym.SXREF && l.RawSymName(rs) != ".got" {
|
|
result = append(result, rs)
|
|
if limit != -1 && len(result) >= limit {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
// AssignTextSymbolOrder populates the Textp2 slices within each
|
|
// library and compilation unit, insuring that packages are laid down
|
|
// in dependency order (internal first, then everything else). Return value
|
|
// is a slice of all text syms.
|
|
func (l *Loader) AssignTextSymbolOrder(libs []*sym.Library, intlibs []bool, extsyms []Sym) []Sym {
|
|
|
|
// Library Textp2 lists should be empty at this point.
|
|
for _, lib := range libs {
|
|
if len(lib.Textp2) != 0 {
|
|
panic("expected empty Textp2 slice for library")
|
|
}
|
|
if len(lib.DupTextSyms2) != 0 {
|
|
panic("expected empty DupTextSyms2 slice for library")
|
|
}
|
|
}
|
|
|
|
// Used to record which dupok symbol we've assigned to a unit.
|
|
// Can't use the onlist attribute here because it will need to
|
|
// clear for the later assignment of the sym.Symbol to a unit.
|
|
// NB: we can convert to using onList once we no longer have to
|
|
// call the regular addToTextp.
|
|
assignedToUnit := MakeBitmap(l.NSym() + 1)
|
|
|
|
// Start off textp2 with reachable external syms.
|
|
textp2 := []Sym{}
|
|
for _, sym := range extsyms {
|
|
if !l.attrReachable.Has(sym) {
|
|
continue
|
|
}
|
|
textp2 = append(textp2, sym)
|
|
}
|
|
|
|
// Walk through all text symbols from Go object files and append
|
|
// them to their corresponding library's textp2 list.
|
|
for _, o := range l.objs[1:] {
|
|
r := o.r
|
|
lib := r.unit.Lib
|
|
for i, n := 0, r.NSym()+r.NNonpkgdef(); i < n; i++ {
|
|
gi := l.toGlobal(r, i)
|
|
if !l.attrReachable.Has(gi) {
|
|
continue
|
|
}
|
|
osym := r.Sym(i)
|
|
st := sym.AbiSymKindToSymKind[objabi.SymKind(osym.Type())]
|
|
if st != sym.STEXT {
|
|
continue
|
|
}
|
|
dupok := osym.Dupok()
|
|
if r2, i2 := l.toLocal(gi); r2 != r || i2 != i {
|
|
// A dupok text symbol is resolved to another package.
|
|
// We still need to record its presence in the current
|
|
// package, as the trampoline pass expects packages
|
|
// are laid out in dependency order.
|
|
lib.DupTextSyms2 = append(lib.DupTextSyms2, sym.LoaderSym(gi))
|
|
continue // symbol in different object
|
|
}
|
|
if dupok {
|
|
lib.DupTextSyms2 = append(lib.DupTextSyms2, sym.LoaderSym(gi))
|
|
continue
|
|
}
|
|
|
|
lib.Textp2 = append(lib.Textp2, sym.LoaderSym(gi))
|
|
}
|
|
}
|
|
|
|
// Now assemble global textp, and assign text symbols to units.
|
|
for _, doInternal := range [2]bool{true, false} {
|
|
for idx, lib := range libs {
|
|
if intlibs[idx] != doInternal {
|
|
continue
|
|
}
|
|
lists := [2][]sym.LoaderSym{lib.Textp2, lib.DupTextSyms2}
|
|
for i, list := range lists {
|
|
for _, s := range list {
|
|
sym := Sym(s)
|
|
if l.attrReachable.Has(sym) && !assignedToUnit.Has(sym) {
|
|
textp2 = append(textp2, sym)
|
|
unit := l.SymUnit(sym)
|
|
if unit != nil {
|
|
unit.Textp2 = append(unit.Textp2, s)
|
|
assignedToUnit.Set(sym)
|
|
}
|
|
// Dupok symbols may be defined in multiple packages; the
|
|
// associated package for a dupok sym is chosen sort of
|
|
// arbitrarily (the first containing package that the linker
|
|
// loads). Canonicalizes its Pkg to the package with which
|
|
// it will be laid down in text.
|
|
if i == 1 /* DupTextSyms2 */ && l.SymPkg(sym) != lib.Pkg {
|
|
l.SetSymPkg(sym, lib.Pkg)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
lib.Textp2 = nil
|
|
lib.DupTextSyms2 = nil
|
|
}
|
|
}
|
|
|
|
return textp2
|
|
}
|
|
|
|
// ErrorReporter is a helper class for reporting errors.
|
|
type ErrorReporter struct {
|
|
ldr *Loader
|
|
AfterErrorAction func()
|
|
}
|
|
|
|
// Errorf method logs an error message.
|
|
//
|
|
// After each error, the error actions function will be invoked; this
|
|
// will either terminate the link immediately (if -h option given)
|
|
// or it will keep a count and exit if more than 20 errors have been printed.
|
|
//
|
|
// Logging an error means that on exit cmd/link will delete any
|
|
// output file and return a non-zero error code.
|
|
//
|
|
func (reporter *ErrorReporter) Errorf(s Sym, format string, args ...interface{}) {
|
|
if s != 0 && reporter.ldr.SymName(s) != "" {
|
|
format = reporter.ldr.SymName(s) + ": " + format
|
|
} else {
|
|
format = fmt.Sprintf("sym %d: %s", s, format)
|
|
}
|
|
format += "\n"
|
|
fmt.Fprintf(os.Stderr, format, args...)
|
|
reporter.AfterErrorAction()
|
|
}
|
|
|
|
// GetErrorReporter returns the loader's associated error reporter.
|
|
func (l *Loader) GetErrorReporter() *ErrorReporter {
|
|
return l.errorReporter
|
|
}
|
|
|
|
// Errorf method logs an error message. See ErrorReporter.Errorf for details.
|
|
func (l *Loader) Errorf(s Sym, format string, args ...interface{}) {
|
|
l.errorReporter.Errorf(s, format, args...)
|
|
}
|
|
|
|
// For debugging.
|
|
func (l *Loader) Dump() {
|
|
fmt.Println("objs")
|
|
for _, obj := range l.objs {
|
|
if obj.r != nil {
|
|
fmt.Println(obj.i, obj.r.unit.Lib)
|
|
}
|
|
}
|
|
fmt.Println("extStart:", l.extStart)
|
|
fmt.Println("Nsyms:", len(l.objSyms))
|
|
fmt.Println("syms")
|
|
for i := Sym(1); i < Sym(len(l.objSyms)); i++ {
|
|
pi := interface{}("")
|
|
if l.IsExternal(i) {
|
|
pi = fmt.Sprintf("<ext %d>", l.extIndex(i))
|
|
}
|
|
var s *sym.Symbol
|
|
if int(i) < len(l.Syms) {
|
|
s = l.Syms[i]
|
|
}
|
|
if s != nil {
|
|
fmt.Println(i, s, s.Type, pi)
|
|
} else {
|
|
fmt.Println(i, l.SymName(i), "<not loaded>", pi)
|
|
}
|
|
}
|
|
fmt.Println("symsByName")
|
|
for name, i := range l.symsByName[0] {
|
|
fmt.Println(i, name, 0)
|
|
}
|
|
for name, i := range l.symsByName[1] {
|
|
fmt.Println(i, name, 1)
|
|
}
|
|
fmt.Println("payloads:")
|
|
for i := range l.payloads {
|
|
pp := l.payloads[i]
|
|
fmt.Println(i, pp.name, pp.ver, pp.kind)
|
|
}
|
|
}
|