1 // Copyright 2019 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
14 "cmd/link/internal/sym"
28 // Sym encapsulates a global symbol index, used to identify a specific
29 // Go symbol. The 0-valued Sym is corresponds to an invalid symbol.
32 // Relocs encapsulates the set of relocations on a given symbol; an
33 // instance of this type is returned by the Loader Relocs() method.
37 li uint32 // local index of symbol whose relocs we're examining
38 r *oReader // object reader for containing package
42 // ExtReloc contains the payload for an external relocation.
43 type ExtReloc struct {
50 // Reloc holds a "handle" to access a relocation record from an
58 func (rel Reloc) Type() objabi.RelocType { return objabi.RelocType(rel.Reloc.Type()) &^ objabi.R_WEAK }
59 func (rel Reloc) Weak() bool { return objabi.RelocType(rel.Reloc.Type())&objabi.R_WEAK != 0 }
60 func (rel Reloc) SetType(t objabi.RelocType) { rel.Reloc.SetType(uint16(t)) }
61 func (rel Reloc) Sym() Sym { return rel.l.resolve(rel.r, rel.Reloc.Sym()) }
62 func (rel Reloc) SetSym(s Sym) { rel.Reloc.SetSym(goobj.SymRef{PkgIdx: 0, SymIdx: uint32(s)}) }
63 func (rel Reloc) IsMarker() bool { return rel.Siz() == 0 }
65 // Aux holds a "handle" to access an aux symbol record from an
73 func (a Aux) Sym() Sym { return a.l.resolve(a.r, a.Aux.Sym()) }
75 // oReader is a wrapper type of obj.Reader, along with some
79 unit *sym.CompilationUnit
80 version int // version of static symbol
82 syms []Sym // Sym's global index, indexed by local index
83 pkg []uint32 // indices of referenced package by PkgIdx (index into loader.objs array)
84 ndef int // cache goobj.Reader.NSym()
85 nhashed64def int // cache goobj.Reader.NHashed64Def()
86 nhasheddef int // cache goobj.Reader.NHashedDef()
87 objidx uint32 // index of this reader in the objs slice
90 // Total number of defined symbols (package symbols, hashed symbols, and
91 // non-package symbols).
92 func (r *oReader) NAlldef() int { return r.ndef + r.nhashed64def + r.nhasheddef + r.NNonpkgdef() }
99 // objSym represents a symbol in an object file. It is a tuple of
100 // the object and the symbol's local index.
101 // For external symbols, objidx is the index of l.extReader (extObj),
102 // s is its index into the payload array.
103 // {0, 0} represents the nil symbol.
105 objidx uint32 // index of the object (in l.objs array)
106 s uint32 // local index
109 type nameVer struct {
117 func (bm Bitmap) Set(i Sym) {
118 n, r := uint(i)/32, uint(i)%32
122 // unset the i-th bit.
123 func (bm Bitmap) Unset(i Sym) {
124 n, r := uint(i)/32, uint(i)%32
128 // whether the i-th bit is set.
129 func (bm Bitmap) Has(i Sym) bool {
130 n, r := uint(i)/32, uint(i)%32
131 return bm[n]&(1<<r) != 0
134 // return current length of bitmap in bits.
135 func (bm Bitmap) Len() int {
139 // return the number of bits set.
140 func (bm Bitmap) Count() int {
142 for _, x := range bm {
143 s += bits.OnesCount32(x)
148 func MakeBitmap(n int) Bitmap {
149 return make(Bitmap, (n+31)/32)
152 // growBitmap insures that the specified bitmap has enough capacity,
153 // reallocating (doubling the size) if needed.
154 func growBitmap(reqLen int, b Bitmap) Bitmap {
157 b = append(b, MakeBitmap(reqLen+1-curLen)...)
162 type symAndSize struct {
167 // A Loader loads new object files and resolves indexed symbol references.
169 // Notes on the layout of global symbol index space:
171 // - Go object files are read before host object files; each Go object
172 // read adds its defined package symbols to the global index space.
173 // Nonpackage symbols are not yet added.
175 // - In loader.LoadNonpkgSyms, add non-package defined symbols and
176 // references in all object files to the global index space.
178 // - Host object file loading happens; the host object loader does a
179 // name/version lookup for each symbol it finds; this can wind up
180 // extending the external symbol index space range. The host object
181 // loader stores symbol payloads in loader.payloads using SymbolBuilder.
183 // - Each symbol gets a unique global index. For duplicated and
184 // overwriting/overwritten symbols, the second (or later) appearance
185 // of the symbol gets the same global index as the first appearance.
187 start map[*oReader]Sym // map from object file to its start index
188 objs []objIdx // sorted by start index (i.e. objIdx.i)
189 extStart Sym // from this index on, the symbols are externally defined
190 builtinSyms []Sym // global index of builtin symbols
192 objSyms []objSym // global index mapping to local index
194 symsByName [2]map[string]Sym // map symbol name to index, two maps are for ABI0 and ABIInternal
195 extStaticSyms map[nameVer]Sym // externally defined static symbols, keyed by name
197 extReader *oReader // a dummy oReader, for external symbols
198 payloadBatch []extSymPayload
199 payloads []*extSymPayload // contents of linker-materialized external syms
200 values []int64 // symbol values, indexed by global sym index
202 sects []*sym.Section // sections
203 symSects []uint16 // symbol's section, index to sects array
205 align []uint8 // symbol 2^N alignment, indexed by global index
207 deferReturnTramp map[Sym]bool // whether the symbol is a trampoline of a deferreturn call
209 objByPkg map[string]uint32 // map package path to the index of its Go object reader
211 anonVersion int // most recently assigned ext static sym pseudo-version
213 // Bitmaps and other side structures used to store data used to store
214 // symbol flags/attributes; these are to be accessed via the
215 // corresponding loader "AttrXXX" and "SetAttrXXX" methods. Please
216 // visit the comments on these methods for more details on the
217 // semantics / interpretation of the specific flags or attribute.
218 attrReachable Bitmap // reachable symbols, indexed by global index
219 attrOnList Bitmap // "on list" symbols, indexed by global index
220 attrLocal Bitmap // "local" symbols, indexed by global index
221 attrNotInSymbolTable Bitmap // "not in symtab" symbols, indexed by global idx
222 attrUsedInIface Bitmap // "used in interface" symbols, indexed by global idx
223 attrSpecial Bitmap // "special" frame symbols, indexed by global idx
224 attrVisibilityHidden Bitmap // hidden symbols, indexed by ext sym index
225 attrDuplicateOK Bitmap // dupOK symbols, indexed by ext sym index
226 attrShared Bitmap // shared symbols, indexed by ext sym index
227 attrExternal Bitmap // external symbols, indexed by ext sym index
228 generatedSyms Bitmap // symbols that generate their content, indexed by ext sym idx
230 attrReadOnly map[Sym]bool // readonly data for this sym
231 attrCgoExportDynamic map[Sym]struct{} // "cgo_export_dynamic" symbols
232 attrCgoExportStatic map[Sym]struct{} // "cgo_export_static" symbols
234 // Outer and Sub relations for symbols.
235 outer []Sym // indexed by global index
238 dynimplib map[Sym]string // stores Dynimplib symbol attribute
239 dynimpvers map[Sym]string // stores Dynimpvers symbol attribute
240 localentry map[Sym]uint8 // stores Localentry symbol attribute
241 extname map[Sym]string // stores Extname symbol attribute
242 elfType map[Sym]elf.SymType // stores elf type symbol property
243 elfSym map[Sym]int32 // stores elf sym symbol property
244 localElfSym map[Sym]int32 // stores "local" elf sym symbol property
245 symPkg map[Sym]string // stores package for symbol, or library for shlib-derived syms
246 plt map[Sym]int32 // stores dynimport for pe objects
247 got map[Sym]int32 // stores got for pe objects
248 dynid map[Sym]int32 // stores Dynid for symbol
250 relocVariant map[relocId]sym.RelocVariant // stores variant relocs
252 // Used to implement field tracking; created during deadcode if
253 // field tracking is enabled. Reachparent[K] contains the index of
254 // the symbol that triggered the marking of symbol K as live.
257 // CgoExports records cgo-exported symbols by SymName.
258 CgoExports map[string]Sym
262 strictDupMsgs int // number of strict-dup warning/errors, when FlagStrictDups is enabled
264 elfsetstring elfsetstringFunc
266 errorReporter *ErrorReporter
268 npkgsyms int // number of package symbols, for accounting
269 nhashedsyms int // number of hashed symbols, for accounting
287 type elfsetstringFunc func(str string, off int)
289 // extSymPayload holds the payload (data + relocations) for linker-synthesized
290 // external symbols (note that symbol value is stored in a separate slice).
291 type extSymPayload struct {
292 name string // TODO: would this be better as offset into str table?
296 objidx uint32 // index of original object if sym made by cloneToExternal
304 FlagStrictDups = 1 << iota
307 func NewLoader(flags uint32, elfsetstring elfsetstringFunc, reporter *ErrorReporter) *Loader {
308 nbuiltin := goobj.NBuiltin()
309 extReader := &oReader{objidx: extObj}
311 start: make(map[*oReader]Sym),
312 objs: []objIdx{{}, {extReader, 0}}, // reserve index 0 for nil symbol, 1 for external symbols
313 objSyms: make([]objSym, 1, 1), // This will get overwritten later.
314 extReader: extReader,
315 symsByName: [2]map[string]Sym{make(map[string]Sym, 80000), make(map[string]Sym, 50000)}, // preallocate ~2MB for ABI0 and ~1MB for ABI1 symbols
316 objByPkg: make(map[string]uint32),
317 sub: make(map[Sym]Sym),
318 dynimplib: make(map[Sym]string),
319 dynimpvers: make(map[Sym]string),
320 localentry: make(map[Sym]uint8),
321 extname: make(map[Sym]string),
322 attrReadOnly: make(map[Sym]bool),
323 elfType: make(map[Sym]elf.SymType),
324 elfSym: make(map[Sym]int32),
325 localElfSym: make(map[Sym]int32),
326 symPkg: make(map[Sym]string),
327 plt: make(map[Sym]int32),
328 got: make(map[Sym]int32),
329 dynid: make(map[Sym]int32),
330 attrCgoExportDynamic: make(map[Sym]struct{}),
331 attrCgoExportStatic: make(map[Sym]struct{}),
332 deferReturnTramp: make(map[Sym]bool),
333 extStaticSyms: make(map[nameVer]Sym),
334 builtinSyms: make([]Sym, nbuiltin),
336 elfsetstring: elfsetstring,
337 errorReporter: reporter,
338 sects: []*sym.Section{nil}, // reserve index 0 for nil section
344 // Add object file r, return the start index.
345 func (l *Loader) addObj(pkg string, r *oReader) Sym {
346 if _, ok := l.start[r]; ok {
347 panic("already added")
349 pkg = objabi.PathToPrefix(pkg) // the object file contains escaped package path
350 if _, ok := l.objByPkg[pkg]; !ok {
351 l.objByPkg[pkg] = r.objidx
353 i := Sym(len(l.objSyms))
355 l.objs = append(l.objs, objIdx{r, i})
359 // Add a symbol from an object file, return the global index.
360 // If the symbol already exist, it returns the index of that symbol.
361 func (st *loadState) addSym(name string, ver int, r *oReader, li uint32, kind int, osym *goobj.Sym) Sym {
364 panic("addSym called after external symbol is created")
366 i := Sym(len(l.objSyms))
367 if int(i) != len(l.objSyms) { // overflow
368 panic("too many symbols")
370 addToGlobal := func() {
371 l.objSyms = append(l.objSyms, objSym{r.objidx, li})
373 if name == "" && kind != hashed64Def && kind != hashedDef {
375 return i // unnamed aux symbol
377 if ver == r.version {
378 // Static symbol. Add its global index but don't
379 // add to name lookup table, as it cannot be
380 // referenced by name.
386 // Defined package symbols cannot be dup to each other.
387 // We load all the package symbols first, so we don't need
388 // to check dup here.
389 // We still add it to the lookup table, as it may still be
390 // referenced by name (e.g. through linkname).
391 l.symsByName[ver][name] = i
394 case hashed64Def, hashedDef:
395 // Hashed (content-addressable) symbol. Check the hash
396 // but don't add to name lookup table, as they are not
397 // referenced by name. Also no need to do overwriting
398 // check, as same hash indicates same content.
399 var checkHash func() (symAndSize, bool)
400 var addToHashMap func(symAndSize)
401 var h64 uint64 // only used for hashed64Def
402 var h *goobj.HashType // only used for hashedDef
403 if kind == hashed64Def {
404 checkHash = func() (symAndSize, bool) {
405 h64 = r.Hash64(li - uint32(r.ndef))
406 s, existed := st.hashed64Syms[h64]
409 addToHashMap = func(ss symAndSize) { st.hashed64Syms[h64] = ss }
411 checkHash = func() (symAndSize, bool) {
412 h = r.Hash(li - uint32(r.ndef+r.nhashed64def))
413 s, existed := st.hashedSyms[*h]
416 addToHashMap = func(ss symAndSize) { st.hashedSyms[*h] = ss }
419 if s, existed := checkHash(); existed {
420 // The content hash is built from symbol data and relocations. In the
421 // object file, the symbol data may not always contain trailing zeros,
422 // e.g. for [5]int{1,2,3} and [100]int{1,2,3}, the data is same
423 // (although the size is different).
424 // Also, for short symbols, the content hash is the identity function of
425 // the 8 bytes, and trailing zeros doesn't change the hash value, e.g.
426 // hash("A") == hash("A\0\0\0").
427 // So when two symbols have the same hash, we need to use the one with
430 // New symbol has larger size, use the new one. Rewrite the index mapping.
431 l.objSyms[s.sym] = objSym{r.objidx, li}
432 addToHashMap(symAndSize{s.sym, siz})
436 addToHashMap(symAndSize{i, siz})
441 // Non-package (named) symbol. Check if it already exists.
442 oldi, existed := l.symsByName[ver][name]
444 l.symsByName[ver][name] = i
448 // symbol already exists
450 if l.flags&FlagStrictDups != 0 {
451 l.checkdup(name, r, li, oldi)
453 // Fix for issue #47185 -- given two dupok symbols with
454 // different sizes, favor symbol with larger size. See
455 // also issue #46653.
456 szdup := l.SymSize(oldi)
457 sz := int64(r.Sym(li).Siz())
459 // new symbol overwrites old symbol.
460 l.objSyms[oldi] = objSym{r.objidx, li}
464 oldr, oldli := l.toLocal(oldi)
465 oldsym := oldr.Sym(oldli)
469 overwrite := r.DataSize(li) != 0
471 // new symbol overwrites old symbol.
472 oldtyp := sym.AbiSymKindToSymKind[objabi.SymKind(oldsym.Type())]
473 if !(oldtyp.IsData() && oldr.DataSize(oldli) == 0) {
474 log.Fatalf("duplicated definition of symbol %s, from %s and %s", name, r.unit.Lib.Pkg, oldr.unit.Lib.Pkg)
476 l.objSyms[oldi] = objSym{r.objidx, li}
478 // old symbol overwrites new symbol.
479 typ := sym.AbiSymKindToSymKind[objabi.SymKind(oldsym.Type())]
480 if !typ.IsData() { // only allow overwriting data symbol
481 log.Fatalf("duplicated definition of symbol %s, from %s and %s", name, r.unit.Lib.Pkg, oldr.unit.Lib.Pkg)
487 // newExtSym creates a new external sym with the specified
489 func (l *Loader) newExtSym(name string, ver int) Sym {
490 i := Sym(len(l.objSyms))
491 if int(i) != len(l.objSyms) { // overflow
492 panic("too many symbols")
497 l.growValues(int(i) + 1)
498 l.growOuter(int(i) + 1)
499 l.growAttrBitmaps(int(i) + 1)
500 pi := l.newPayload(name, ver)
501 l.objSyms = append(l.objSyms, objSym{l.extReader.objidx, uint32(pi)})
502 l.extReader.syms = append(l.extReader.syms, i)
506 // LookupOrCreateSym looks up the symbol with the specified name/version,
507 // returning its Sym index if found. If the lookup fails, a new external
508 // Sym will be created, entered into the lookup tables, and returned.
509 func (l *Loader) LookupOrCreateSym(name string, ver int) Sym {
510 i := l.Lookup(name, ver)
514 i = l.newExtSym(name, ver)
515 static := ver >= sym.SymVerStatic || ver < 0
517 l.extStaticSyms[nameVer{name, ver}] = i
519 l.symsByName[ver][name] = i
524 // AddCgoExport records a cgo-exported symbol in l.CgoExports.
525 // This table is used to identify the correct Go symbol ABI to use
526 // to resolve references from host objects (which don't have ABIs).
527 func (l *Loader) AddCgoExport(s Sym) {
528 if l.CgoExports == nil {
529 l.CgoExports = make(map[string]Sym)
531 l.CgoExports[l.SymName(s)] = s
534 // LookupOrCreateCgoExport is like LookupOrCreateSym, but if ver
535 // indicates a global symbol, it uses the CgoExport table to determine
536 // the appropriate symbol version (ABI) to use. ver must be either 0
537 // or a static symbol version.
538 func (l *Loader) LookupOrCreateCgoExport(name string, ver int) Sym {
539 if ver >= sym.SymVerStatic {
540 return l.LookupOrCreateSym(name, ver)
543 panic("ver must be 0 or a static version")
545 // Look for a cgo-exported symbol from Go.
546 if s, ok := l.CgoExports[name]; ok {
549 // Otherwise, this must just be a symbol in the host object.
550 // Create a version 0 symbol for it.
551 return l.LookupOrCreateSym(name, 0)
554 func (l *Loader) IsExternal(i Sym) bool {
556 return l.isExtReader(r)
559 func (l *Loader) isExtReader(r *oReader) bool {
560 return r == l.extReader
563 // For external symbol, return its index in the payloads array.
564 // XXX result is actually not a global index. We (ab)use the Sym type
565 // so we don't need conversion for accessing bitmaps.
566 func (l *Loader) extIndex(i Sym) Sym {
567 _, li := l.toLocal(i)
571 // Get a new payload for external symbol, return its index in
572 // the payloads array.
573 func (l *Loader) newPayload(name string, ver int) int {
574 pi := len(l.payloads)
575 pp := l.allocPayload()
578 l.payloads = append(l.payloads, pp)
579 l.growExtAttrBitmaps()
583 // getPayload returns a pointer to the extSymPayload struct for an
584 // external symbol if the symbol has a payload. Will panic if the
585 // symbol in question is bogus (zero or not an external sym).
586 func (l *Loader) getPayload(i Sym) *extSymPayload {
587 if !l.IsExternal(i) {
588 panic(fmt.Sprintf("bogus symbol index %d in getPayload", i))
591 return l.payloads[pi]
594 // allocPayload allocates a new payload.
595 func (l *Loader) allocPayload() *extSymPayload {
596 batch := l.payloadBatch
598 batch = make([]extSymPayload, 1000)
601 l.payloadBatch = batch[1:]
605 func (ms *extSymPayload) Grow(siz int64) {
606 if int64(int(siz)) != siz {
607 log.Fatalf("symgrow size %d too long", siz)
609 if int64(len(ms.data)) >= siz {
612 if cap(ms.data) < int(siz) {
614 ms.data = append(ms.data, make([]byte, int(siz)+1-cl)...)
615 ms.data = ms.data[0:cl]
617 ms.data = ms.data[:siz]
620 // Convert a local index to a global index.
621 func (l *Loader) toGlobal(r *oReader, i uint32) Sym {
625 // Convert a global index to a local index.
626 func (l *Loader) toLocal(i Sym) (*oReader, uint32) {
627 return l.objs[l.objSyms[i].objidx].r, l.objSyms[i].s
630 // Resolve a local symbol reference. Return global index.
631 func (l *Loader) resolve(r *oReader, s goobj.SymRef) Sym {
633 switch p := s.PkgIdx; p {
634 case goobj.PkgIdxInvalid:
635 // {0, X} with non-zero X is never a valid sym reference from a Go object.
636 // We steal this space for symbol references from external objects.
637 // In this case, X is just the global index.
638 if l.isExtReader(r) {
645 case goobj.PkgIdxHashed64:
646 i := int(s.SymIdx) + r.ndef
648 case goobj.PkgIdxHashed:
649 i := int(s.SymIdx) + r.ndef + r.nhashed64def
651 case goobj.PkgIdxNone:
652 i := int(s.SymIdx) + r.ndef + r.nhashed64def + r.nhasheddef
654 case goobj.PkgIdxBuiltin:
655 if bi := l.builtinSyms[s.SymIdx]; bi != 0 {
658 l.reportMissingBuiltin(int(s.SymIdx), r.unit.Lib.Pkg)
660 case goobj.PkgIdxSelf:
663 rr = l.objs[r.pkg[p]].r
665 return l.toGlobal(rr, s.SymIdx)
668 // reportMissingBuiltin issues an error in the case where we have a
669 // relocation against a runtime builtin whose definition is not found
670 // when the runtime package is built. The canonical example is
671 // "runtime.racefuncenter" -- currently if you do something like
673 // go build -gcflags=-race myprogram.go
675 // the compiler will insert calls to the builtin runtime.racefuncenter,
676 // but the version of the runtime used for linkage won't actually contain
677 // definitions of that symbol. See issue #42396 for details.
679 // As currently implemented, this is a fatal error. This has drawbacks
680 // in that if there are multiple missing builtins, the error will only
681 // cite the first one. On the plus side, terminating the link here has
682 // advantages in that we won't run the risk of panics or crashes later
683 // on in the linker due to R_CALL relocations with 0-valued target
685 func (l *Loader) reportMissingBuiltin(bsym int, reflib string) {
686 bname, _ := goobj.BuiltinName(bsym)
687 log.Fatalf("reference to undefined builtin %q from package %q",
691 // Look up a symbol by name, return global index, or 0 if not found.
692 // This is more like Syms.ROLookup than Lookup -- it doesn't create
694 func (l *Loader) Lookup(name string, ver int) Sym {
695 if ver >= sym.SymVerStatic || ver < 0 {
696 return l.extStaticSyms[nameVer{name, ver}]
698 return l.symsByName[ver][name]
701 // Check that duplicate symbols have same contents.
702 func (l *Loader) checkdup(name string, r *oReader, li uint32, dup Sym) {
704 rdup, ldup := l.toLocal(dup)
705 pdup := rdup.Data(ldup)
706 reason := "same length but different contents"
707 if len(p) != len(pdup) {
708 reason = fmt.Sprintf("new length %d != old length %d", len(p), len(pdup))
709 } else if bytes.Equal(p, pdup) {
710 // For BSS symbols, we need to check size as well, see issue 46653.
711 szdup := l.SymSize(dup)
712 sz := int64(r.Sym(li).Siz())
716 reason = fmt.Sprintf("different sizes: new size %d != old size %d",
719 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)
721 // For the moment, allow DWARF subprogram DIEs for
722 // auto-generated wrapper functions. What seems to happen
723 // here is that we get different line numbers on formal
724 // params; I am guessing that the pos is being inherited
725 // from the spot where the wrapper is needed.
726 allowed := strings.HasPrefix(name, "go:info.go.interface") ||
727 strings.HasPrefix(name, "go:info.go.builtin") ||
728 strings.HasPrefix(name, "go:debuglines")
734 func (l *Loader) NStrictDupMsgs() int { return l.strictDupMsgs }
736 // Number of total symbols.
737 func (l *Loader) NSym() int {
738 return len(l.objSyms)
741 // Number of defined Go symbols.
742 func (l *Loader) NDef() int {
743 return int(l.extStart)
746 // Number of reachable symbols.
747 func (l *Loader) NReachableSym() int {
748 return l.attrReachable.Count()
751 // Returns the name of the i-th symbol.
752 func (l *Loader) SymName(i Sym) string {
754 pp := l.getPayload(i)
757 r, li := l.toLocal(i)
761 return r.Sym(li).Name(r.Reader)
764 // Returns the version of the i-th symbol.
765 func (l *Loader) SymVersion(i Sym) int {
767 pp := l.getPayload(i)
770 r, li := l.toLocal(i)
771 return int(abiToVer(r.Sym(li).ABI(), r.version))
774 func (l *Loader) IsFileLocal(i Sym) bool {
775 return l.SymVersion(i) >= sym.SymVerStatic
778 // IsFromAssembly returns true if this symbol is derived from an
779 // object file generated by the Go assembler.
780 func (l *Loader) IsFromAssembly(i Sym) bool {
785 return r.FromAssembly()
788 // Returns the type of the i-th symbol.
789 func (l *Loader) SymType(i Sym) sym.SymKind {
791 pp := l.getPayload(i)
797 r, li := l.toLocal(i)
798 return sym.AbiSymKindToSymKind[objabi.SymKind(r.Sym(li).Type())]
801 // Returns the attributes of the i-th symbol.
802 func (l *Loader) SymAttr(i Sym) uint8 {
804 // TODO: do something? External symbols have different representation of attributes.
805 // For now, ReflectMethod, NoSplit, GoType, and Typelink are used and they cannot be
806 // set by external symbol.
809 r, li := l.toLocal(i)
810 return r.Sym(li).Flag()
813 // Returns the size of the i-th symbol.
814 func (l *Loader) SymSize(i Sym) int64 {
816 pp := l.getPayload(i)
819 r, li := l.toLocal(i)
820 return int64(r.Sym(li).Siz())
823 // AttrReachable returns true for symbols that are transitively
824 // referenced from the entry points. Unreachable symbols are not
825 // written to the output.
826 func (l *Loader) AttrReachable(i Sym) bool {
827 return l.attrReachable.Has(i)
830 // SetAttrReachable sets the reachability property for a symbol (see
832 func (l *Loader) SetAttrReachable(i Sym, v bool) {
834 l.attrReachable.Set(i)
836 l.attrReachable.Unset(i)
840 // AttrOnList returns true for symbols that are on some list (such as
841 // the list of all text symbols, or one of the lists of data symbols)
842 // and is consulted to avoid bugs where a symbol is put on a list
844 func (l *Loader) AttrOnList(i Sym) bool {
845 return l.attrOnList.Has(i)
848 // SetAttrOnList sets the "on list" property for a symbol (see
850 func (l *Loader) SetAttrOnList(i Sym, v bool) {
854 l.attrOnList.Unset(i)
858 // AttrLocal returns true for symbols that are only visible within the
859 // module (executable or shared library) being linked. This attribute
860 // is applied to thunks and certain other linker-generated symbols.
861 func (l *Loader) AttrLocal(i Sym) bool {
862 return l.attrLocal.Has(i)
865 // SetAttrLocal the "local" property for a symbol (see AttrLocal above).
866 func (l *Loader) SetAttrLocal(i Sym, v bool) {
874 // AttrUsedInIface returns true for a type symbol that is used in
876 func (l *Loader) AttrUsedInIface(i Sym) bool {
877 return l.attrUsedInIface.Has(i)
880 func (l *Loader) SetAttrUsedInIface(i Sym, v bool) {
882 l.attrUsedInIface.Set(i)
884 l.attrUsedInIface.Unset(i)
888 // SymAddr checks that a symbol is reachable, and returns its value.
889 func (l *Loader) SymAddr(i Sym) int64 {
890 if !l.AttrReachable(i) {
891 panic("unreachable symbol in symaddr")
896 // AttrNotInSymbolTable returns true for symbols that should not be
897 // added to the symbol table of the final generated load module.
898 func (l *Loader) AttrNotInSymbolTable(i Sym) bool {
899 return l.attrNotInSymbolTable.Has(i)
902 // SetAttrNotInSymbolTable the "not in symtab" property for a symbol
903 // (see AttrNotInSymbolTable above).
904 func (l *Loader) SetAttrNotInSymbolTable(i Sym, v bool) {
906 l.attrNotInSymbolTable.Set(i)
908 l.attrNotInSymbolTable.Unset(i)
912 // AttrVisibilityHidden symbols returns true for ELF symbols with
913 // visibility set to STV_HIDDEN. They become local symbols in
914 // the final executable. Only relevant when internally linking
915 // on an ELF platform.
916 func (l *Loader) AttrVisibilityHidden(i Sym) bool {
917 if !l.IsExternal(i) {
920 return l.attrVisibilityHidden.Has(l.extIndex(i))
923 // SetAttrVisibilityHidden sets the "hidden visibility" property for a
924 // symbol (see AttrVisibilityHidden).
925 func (l *Loader) SetAttrVisibilityHidden(i Sym, v bool) {
926 if !l.IsExternal(i) {
927 panic("tried to set visibility attr on non-external symbol")
930 l.attrVisibilityHidden.Set(l.extIndex(i))
932 l.attrVisibilityHidden.Unset(l.extIndex(i))
936 // AttrDuplicateOK returns true for a symbol that can be present in
937 // multiple object files.
938 func (l *Loader) AttrDuplicateOK(i Sym) bool {
939 if !l.IsExternal(i) {
940 // TODO: if this path winds up being taken frequently, it
941 // might make more sense to copy the flag value out of the object
942 // into a larger bitmap during preload.
943 r, li := l.toLocal(i)
944 return r.Sym(li).Dupok()
946 return l.attrDuplicateOK.Has(l.extIndex(i))
949 // SetAttrDuplicateOK sets the "duplicate OK" property for an external
950 // symbol (see AttrDuplicateOK).
951 func (l *Loader) SetAttrDuplicateOK(i Sym, v bool) {
952 if !l.IsExternal(i) {
953 panic("tried to set dupok attr on non-external symbol")
956 l.attrDuplicateOK.Set(l.extIndex(i))
958 l.attrDuplicateOK.Unset(l.extIndex(i))
962 // AttrShared returns true for symbols compiled with the -shared option.
963 func (l *Loader) AttrShared(i Sym) bool {
964 if !l.IsExternal(i) {
965 // TODO: if this path winds up being taken frequently, it
966 // might make more sense to copy the flag value out of the
967 // object into a larger bitmap during preload.
971 return l.attrShared.Has(l.extIndex(i))
974 // SetAttrShared sets the "shared" property for an external
975 // symbol (see AttrShared).
976 func (l *Loader) SetAttrShared(i Sym, v bool) {
977 if !l.IsExternal(i) {
978 panic(fmt.Sprintf("tried to set shared attr on non-external symbol %d %s", i, l.SymName(i)))
981 l.attrShared.Set(l.extIndex(i))
983 l.attrShared.Unset(l.extIndex(i))
987 // AttrExternal returns true for function symbols loaded from host
989 func (l *Loader) AttrExternal(i Sym) bool {
990 if !l.IsExternal(i) {
993 return l.attrExternal.Has(l.extIndex(i))
996 // SetAttrExternal sets the "external" property for an host object
997 // symbol (see AttrExternal).
998 func (l *Loader) SetAttrExternal(i Sym, v bool) {
999 if !l.IsExternal(i) {
1000 panic(fmt.Sprintf("tried to set external attr on non-external symbol %q", l.SymName(i)))
1003 l.attrExternal.Set(l.extIndex(i))
1005 l.attrExternal.Unset(l.extIndex(i))
1009 // AttrSpecial returns true for a symbols that do not have their
1010 // address (i.e. Value) computed by the usual mechanism of
1011 // data.go:dodata() & data.go:address().
1012 func (l *Loader) AttrSpecial(i Sym) bool {
1013 return l.attrSpecial.Has(i)
1016 // SetAttrSpecial sets the "special" property for a symbol (see
1018 func (l *Loader) SetAttrSpecial(i Sym, v bool) {
1020 l.attrSpecial.Set(i)
1022 l.attrSpecial.Unset(i)
1026 // AttrCgoExportDynamic returns true for a symbol that has been
1027 // specially marked via the "cgo_export_dynamic" compiler directive
1028 // written by cgo (in response to //export directives in the source).
1029 func (l *Loader) AttrCgoExportDynamic(i Sym) bool {
1030 _, ok := l.attrCgoExportDynamic[i]
1034 // SetAttrCgoExportDynamic sets the "cgo_export_dynamic" for a symbol
1035 // (see AttrCgoExportDynamic).
1036 func (l *Loader) SetAttrCgoExportDynamic(i Sym, v bool) {
1038 l.attrCgoExportDynamic[i] = struct{}{}
1040 delete(l.attrCgoExportDynamic, i)
1044 // ForAllAttrCgoExportDynamic calls f for every symbol that has been
1045 // marked with the "cgo_export_dynamic" compiler directive.
1046 func (l *Loader) ForAllCgoExportDynamic(f func(Sym)) {
1047 for s := range l.attrCgoExportDynamic {
1052 // AttrCgoExportStatic returns true for a symbol that has been
1053 // specially marked via the "cgo_export_static" directive
1055 func (l *Loader) AttrCgoExportStatic(i Sym) bool {
1056 _, ok := l.attrCgoExportStatic[i]
1060 // SetAttrCgoExportStatic sets the "cgo_export_static" for a symbol
1061 // (see AttrCgoExportStatic).
1062 func (l *Loader) SetAttrCgoExportStatic(i Sym, v bool) {
1064 l.attrCgoExportStatic[i] = struct{}{}
1066 delete(l.attrCgoExportStatic, i)
1070 // IsGeneratedSym returns true if a symbol's been previously marked as a
1071 // generator symbol through the SetIsGeneratedSym. The functions for generator
1072 // symbols are kept in the Link context.
1073 func (l *Loader) IsGeneratedSym(i Sym) bool {
1074 if !l.IsExternal(i) {
1077 return l.generatedSyms.Has(l.extIndex(i))
1080 // SetIsGeneratedSym marks symbols as generated symbols. Data shouldn't be
1081 // stored in generated symbols, and a function is registered and called for
1082 // each of these symbols.
1083 func (l *Loader) SetIsGeneratedSym(i Sym, v bool) {
1084 if !l.IsExternal(i) {
1085 panic("only external symbols can be generated")
1088 l.generatedSyms.Set(l.extIndex(i))
1090 l.generatedSyms.Unset(l.extIndex(i))
1094 func (l *Loader) AttrCgoExport(i Sym) bool {
1095 return l.AttrCgoExportDynamic(i) || l.AttrCgoExportStatic(i)
1098 // AttrReadOnly returns true for a symbol whose underlying data
1099 // is stored via a read-only mmap.
1100 func (l *Loader) AttrReadOnly(i Sym) bool {
1101 if v, ok := l.attrReadOnly[i]; ok {
1104 if l.IsExternal(i) {
1105 pp := l.getPayload(i)
1107 return l.objs[pp.objidx].r.ReadOnly()
1111 r, _ := l.toLocal(i)
1115 // SetAttrReadOnly sets the "data is read only" property for a symbol
1116 // (see AttrReadOnly).
1117 func (l *Loader) SetAttrReadOnly(i Sym, v bool) {
1118 l.attrReadOnly[i] = v
1121 // AttrSubSymbol returns true for symbols that are listed as a
1122 // sub-symbol of some other outer symbol. The sub/outer mechanism is
1123 // used when loading host objects (sections from the host object
1124 // become regular linker symbols and symbols go on the Sub list of
1125 // their section) and for constructing the global offset table when
1126 // internally linking a dynamic executable.
1128 // Note that in later stages of the linker, we set Outer(S) to some
1129 // container symbol C, but don't set Sub(C). Thus we have two
1130 // distinct scenarios:
1132 // - Outer symbol covers the address ranges of its sub-symbols.
1133 // Outer.Sub is set in this case.
1134 // - Outer symbol doesn't conver the address ranges. It is zero-sized
1135 // and doesn't have sub-symbols. In the case, the inner symbol is
1136 // not actually a "SubSymbol". (Tricky!)
1138 // This method returns TRUE only for sub-symbols in the first scenario.
1140 // FIXME: would be better to do away with this and have a better way
1141 // to represent container symbols.
1143 func (l *Loader) AttrSubSymbol(i Sym) bool {
1144 // we don't explicitly store this attribute any more -- return
1145 // a value based on the sub-symbol setting.
1150 return l.SubSym(o) != 0
1153 // Note that we don't have a 'SetAttrSubSymbol' method in the loader;
1154 // clients should instead use the AddInteriorSym method to establish
1155 // containment relationships for host object symbols.
1157 // Returns whether the i-th symbol has ReflectMethod attribute set.
1158 func (l *Loader) IsReflectMethod(i Sym) bool {
1159 return l.SymAttr(i)&goobj.SymFlagReflectMethod != 0
1162 // Returns whether the i-th symbol is nosplit.
1163 func (l *Loader) IsNoSplit(i Sym) bool {
1164 return l.SymAttr(i)&goobj.SymFlagNoSplit != 0
1167 // Returns whether this is a Go type symbol.
1168 func (l *Loader) IsGoType(i Sym) bool {
1169 return l.SymAttr(i)&goobj.SymFlagGoType != 0
1172 // Returns whether this symbol should be included in typelink.
1173 func (l *Loader) IsTypelink(i Sym) bool {
1174 return l.SymAttr(i)&goobj.SymFlagTypelink != 0
1177 // Returns whether this symbol is an itab symbol.
1178 func (l *Loader) IsItab(i Sym) bool {
1179 if l.IsExternal(i) {
1182 r, li := l.toLocal(i)
1183 return r.Sym(li).IsItab()
1186 // Returns whether this symbol is a dictionary symbol.
1187 func (l *Loader) IsDict(i Sym) bool {
1188 if l.IsExternal(i) {
1191 r, li := l.toLocal(i)
1192 return r.Sym(li).IsDict()
1195 // Returns whether this symbol is a compiler-generated package init func.
1196 func (l *Loader) IsPkgInit(i Sym) bool {
1197 if l.IsExternal(i) {
1200 r, li := l.toLocal(i)
1201 return r.Sym(li).IsPkgInit()
1204 // Return whether this is a trampoline of a deferreturn call.
1205 func (l *Loader) IsDeferReturnTramp(i Sym) bool {
1206 return l.deferReturnTramp[i]
1209 // Set that i is a trampoline of a deferreturn call.
1210 func (l *Loader) SetIsDeferReturnTramp(i Sym, v bool) {
1211 l.deferReturnTramp[i] = v
1214 // growValues grows the slice used to store symbol values.
1215 func (l *Loader) growValues(reqLen int) {
1216 curLen := len(l.values)
1217 if reqLen > curLen {
1218 l.values = append(l.values, make([]int64, reqLen+1-curLen)...)
1222 // SymValue returns the value of the i-th symbol. i is global index.
1223 func (l *Loader) SymValue(i Sym) int64 {
1227 // SetSymValue sets the value of the i-th symbol. i is global index.
1228 func (l *Loader) SetSymValue(i Sym, val int64) {
1232 // AddToSymValue adds to the value of the i-th symbol. i is the global index.
1233 func (l *Loader) AddToSymValue(i Sym, val int64) {
1237 // Returns the symbol content of the i-th symbol. i is global index.
1238 func (l *Loader) Data(i Sym) []byte {
1239 if l.IsExternal(i) {
1240 pp := l.getPayload(i)
1246 r, li := l.toLocal(i)
1250 // FreeData clears the symbol data of an external symbol, allowing the memory
1251 // to be freed earlier. No-op for non-external symbols.
1252 // i is global index.
1253 func (l *Loader) FreeData(i Sym) {
1254 if l.IsExternal(i) {
1255 pp := l.getPayload(i)
1262 // SymAlign returns the alignment for a symbol.
1263 func (l *Loader) SymAlign(i Sym) int32 {
1264 if int(i) >= len(l.align) {
1265 // align is extended lazily -- it the sym in question is
1266 // outside the range of the existing slice, then we assume its
1267 // alignment has not yet been set.
1270 // TODO: would it make sense to return an arch-specific
1271 // alignment depending on section type? E.g. STEXT => 32,
1277 return int32(1 << (abits - 1))
1280 // SetSymAlign sets the alignment for a symbol.
1281 func (l *Loader) SetSymAlign(i Sym, align int32) {
1282 // Reject nonsense alignments.
1283 if align < 0 || align&(align-1) != 0 {
1284 panic("bad alignment value")
1286 if int(i) >= len(l.align) {
1287 l.align = append(l.align, make([]uint8, l.NSym()-len(l.align))...)
1292 l.align[i] = uint8(bits.Len32(uint32(align)))
1295 // SymSect returns the section of the i-th symbol. i is global index.
1296 func (l *Loader) SymSect(i Sym) *sym.Section {
1297 if int(i) >= len(l.symSects) {
1298 // symSects is extended lazily -- it the sym in question is
1299 // outside the range of the existing slice, then we assume its
1300 // section has not yet been set.
1303 return l.sects[l.symSects[i]]
1306 // SetSymSect sets the section of the i-th symbol. i is global index.
1307 func (l *Loader) SetSymSect(i Sym, sect *sym.Section) {
1308 if int(i) >= len(l.symSects) {
1309 l.symSects = append(l.symSects, make([]uint16, l.NSym()-len(l.symSects))...)
1311 l.symSects[i] = sect.Index
1314 // growSects grows the slice used to store symbol sections.
1315 func (l *Loader) growSects(reqLen int) {
1316 curLen := len(l.symSects)
1317 if reqLen > curLen {
1318 l.symSects = append(l.symSects, make([]uint16, reqLen+1-curLen)...)
1322 // NewSection creates a new (output) section.
1323 func (l *Loader) NewSection() *sym.Section {
1324 sect := new(sym.Section)
1326 if idx != int(uint16(idx)) {
1327 panic("too many sections created")
1329 sect.Index = uint16(idx)
1330 l.sects = append(l.sects, sect)
1334 // SymDynimplib returns the "dynimplib" attribute for the specified
1335 // symbol, making up a portion of the info for a symbol specified
1336 // on a "cgo_import_dynamic" compiler directive.
1337 func (l *Loader) SymDynimplib(i Sym) string {
1338 return l.dynimplib[i]
1341 // SetSymDynimplib sets the "dynimplib" attribute for a symbol.
1342 func (l *Loader) SetSymDynimplib(i Sym, value string) {
1343 // reject bad symbols
1344 if i >= Sym(len(l.objSyms)) || i == 0 {
1345 panic("bad symbol index in SetDynimplib")
1348 delete(l.dynimplib, i)
1350 l.dynimplib[i] = value
1354 // SymDynimpvers returns the "dynimpvers" attribute for the specified
1355 // symbol, making up a portion of the info for a symbol specified
1356 // on a "cgo_import_dynamic" compiler directive.
1357 func (l *Loader) SymDynimpvers(i Sym) string {
1358 return l.dynimpvers[i]
1361 // SetSymDynimpvers sets the "dynimpvers" attribute for a symbol.
1362 func (l *Loader) SetSymDynimpvers(i Sym, value string) {
1363 // reject bad symbols
1364 if i >= Sym(len(l.objSyms)) || i == 0 {
1365 panic("bad symbol index in SetDynimpvers")
1368 delete(l.dynimpvers, i)
1370 l.dynimpvers[i] = value
1374 // SymExtname returns the "extname" value for the specified
1376 func (l *Loader) SymExtname(i Sym) string {
1377 if s, ok := l.extname[i]; ok {
1383 // SetSymExtname sets the "extname" attribute for a symbol.
1384 func (l *Loader) SetSymExtname(i Sym, value string) {
1385 // reject bad symbols
1386 if i >= Sym(len(l.objSyms)) || i == 0 {
1387 panic("bad symbol index in SetExtname")
1390 delete(l.extname, i)
1392 l.extname[i] = value
1396 // SymElfType returns the previously recorded ELF type for a symbol
1397 // (used only for symbols read from shared libraries by ldshlibsyms).
1398 // It is not set for symbols defined by the packages being linked or
1399 // by symbols read by ldelf (and so is left as elf.STT_NOTYPE).
1400 func (l *Loader) SymElfType(i Sym) elf.SymType {
1401 if et, ok := l.elfType[i]; ok {
1404 return elf.STT_NOTYPE
1407 // SetSymElfType sets the elf type attribute for a symbol.
1408 func (l *Loader) SetSymElfType(i Sym, et elf.SymType) {
1409 // reject bad symbols
1410 if i >= Sym(len(l.objSyms)) || i == 0 {
1411 panic("bad symbol index in SetSymElfType")
1413 if et == elf.STT_NOTYPE {
1414 delete(l.elfType, i)
1420 // SymElfSym returns the ELF symbol index for a given loader
1421 // symbol, assigned during ELF symtab generation.
1422 func (l *Loader) SymElfSym(i Sym) int32 {
1426 // SetSymElfSym sets the elf symbol index for a symbol.
1427 func (l *Loader) SetSymElfSym(i Sym, es int32) {
1429 panic("bad sym index")
1438 // SymLocalElfSym returns the "local" ELF symbol index for a given loader
1439 // symbol, assigned during ELF symtab generation.
1440 func (l *Loader) SymLocalElfSym(i Sym) int32 {
1441 return l.localElfSym[i]
1444 // SetSymLocalElfSym sets the "local" elf symbol index for a symbol.
1445 func (l *Loader) SetSymLocalElfSym(i Sym, es int32) {
1447 panic("bad sym index")
1450 delete(l.localElfSym, i)
1452 l.localElfSym[i] = es
1456 // SymPlt returns the PLT offset of symbol s.
1457 func (l *Loader) SymPlt(s Sym) int32 {
1458 if v, ok := l.plt[s]; ok {
1464 // SetPlt sets the PLT offset of symbol i.
1465 func (l *Loader) SetPlt(i Sym, v int32) {
1466 if i >= Sym(len(l.objSyms)) || i == 0 {
1467 panic("bad symbol for SetPlt")
1476 // SymGot returns the GOT offset of symbol s.
1477 func (l *Loader) SymGot(s Sym) int32 {
1478 if v, ok := l.got[s]; ok {
1484 // SetGot sets the GOT offset of symbol i.
1485 func (l *Loader) SetGot(i Sym, v int32) {
1486 if i >= Sym(len(l.objSyms)) || i == 0 {
1487 panic("bad symbol for SetGot")
1496 // SymDynid returns the "dynid" property for the specified symbol.
1497 func (l *Loader) SymDynid(i Sym) int32 {
1498 if s, ok := l.dynid[i]; ok {
1504 // SetSymDynid sets the "dynid" property for a symbol.
1505 func (l *Loader) SetSymDynid(i Sym, val int32) {
1506 // reject bad symbols
1507 if i >= Sym(len(l.objSyms)) || i == 0 {
1508 panic("bad symbol index in SetSymDynid")
1517 // DynidSyms returns the set of symbols for which dynID is set to an
1518 // interesting (non-default) value. This is expected to be a fairly
1520 func (l *Loader) DynidSyms() []Sym {
1521 sl := make([]Sym, 0, len(l.dynid))
1522 for s := range l.dynid {
1525 sort.Slice(sl, func(i, j int) bool { return sl[i] < sl[j] })
1529 // SymGoType returns the 'Gotype' property for a given symbol (set by
1530 // the Go compiler for variable symbols). This version relies on
1531 // reading aux symbols for the target sym -- it could be that a faster
1532 // approach would be to check for gotype during preload and copy the
1533 // results in to a map (might want to try this at some point and see
1534 // if it helps speed things up).
1535 func (l *Loader) SymGoType(i Sym) Sym { return l.aux1(i, goobj.AuxGotype) }
1537 // SymUnit returns the compilation unit for a given symbol (which will
1538 // typically be nil for external or linker-manufactured symbols).
1539 func (l *Loader) SymUnit(i Sym) *sym.CompilationUnit {
1540 if l.IsExternal(i) {
1541 pp := l.getPayload(i)
1543 r := l.objs[pp.objidx].r
1548 r, _ := l.toLocal(i)
1552 // SymPkg returns the package where the symbol came from (for
1553 // regular compiler-generated Go symbols), but in the case of
1554 // building with "-linkshared" (when a symbol is read from a
1555 // shared library), will hold the library name.
1556 // NOTE: this corresponds to sym.Symbol.File field.
1557 func (l *Loader) SymPkg(i Sym) string {
1558 if f, ok := l.symPkg[i]; ok {
1561 if l.IsExternal(i) {
1562 pp := l.getPayload(i)
1564 r := l.objs[pp.objidx].r
1565 return r.unit.Lib.Pkg
1569 r, _ := l.toLocal(i)
1570 return r.unit.Lib.Pkg
1573 // SetSymPkg sets the package/library for a symbol. This is
1574 // needed mainly for external symbols, specifically those imported
1575 // from shared libraries.
1576 func (l *Loader) SetSymPkg(i Sym, pkg string) {
1577 // reject bad symbols
1578 if i >= Sym(len(l.objSyms)) || i == 0 {
1579 panic("bad symbol index in SetSymPkg")
1584 // SymLocalentry returns an offset in bytes of the "local entry" of a symbol.
1585 func (l *Loader) SymLocalentry(i Sym) uint8 {
1586 return l.localentry[i]
1589 // SetSymLocalentry sets the "local entry" offset attribute for a symbol.
1590 func (l *Loader) SetSymLocalentry(i Sym, value uint8) {
1591 // reject bad symbols
1592 if i >= Sym(len(l.objSyms)) || i == 0 {
1593 panic("bad symbol index in SetSymLocalentry")
1596 delete(l.localentry, i)
1598 l.localentry[i] = value
1602 // Returns the number of aux symbols given a global index.
1603 func (l *Loader) NAux(i Sym) int {
1604 if l.IsExternal(i) {
1607 r, li := l.toLocal(i)
1611 // Returns the "handle" to the j-th aux symbol of the i-th symbol.
1612 func (l *Loader) Aux(i Sym, j int) Aux {
1613 if l.IsExternal(i) {
1616 r, li := l.toLocal(i)
1617 if j >= r.NAux(li) {
1620 return Aux{r.Aux(li, j), r, l}
1623 // WasmImportSym returns the auxiliary WebAssembly import symbol associated with
1624 // a given function symbol. The aux sym only exists for Go function stubs that
1625 // have been annotated with the //go:wasmimport directive. The aux sym
1626 // contains the information necessary for the linker to add a WebAssembly
1627 // import statement.
1628 // (https://webassembly.github.io/spec/core/syntax/modules.html#imports)
1629 func (l *Loader) WasmImportSym(fnSymIdx Sym) (Sym, bool) {
1630 if l.SymType(fnSymIdx) != sym.STEXT {
1631 log.Fatalf("error: non-function sym %d/%s t=%s passed to WasmImportSym", fnSymIdx, l.SymName(fnSymIdx), l.SymType(fnSymIdx).String())
1633 r, li := l.toLocal(fnSymIdx)
1635 for i := range auxs {
1638 case goobj.AuxWasmImport:
1639 return l.resolve(r, a.Sym()), true
1646 // GetFuncDwarfAuxSyms collects and returns the auxiliary DWARF
1647 // symbols associated with a given function symbol. Prior to the
1648 // introduction of the loader, this was done purely using name
1649 // lookups, e.f. for function with name XYZ we would then look up
1650 // go.info.XYZ, etc.
1651 func (l *Loader) GetFuncDwarfAuxSyms(fnSymIdx Sym) (auxDwarfInfo, auxDwarfLoc, auxDwarfRanges, auxDwarfLines Sym) {
1652 if l.SymType(fnSymIdx) != sym.STEXT {
1653 log.Fatalf("error: non-function sym %d/%s t=%s passed to GetFuncDwarfAuxSyms", fnSymIdx, l.SymName(fnSymIdx), l.SymType(fnSymIdx).String())
1655 r, auxs := l.auxs(fnSymIdx)
1657 for i := range auxs {
1660 case goobj.AuxDwarfInfo:
1661 auxDwarfInfo = l.resolve(r, a.Sym())
1662 if l.SymType(auxDwarfInfo) != sym.SDWARFFCN {
1663 panic("aux dwarf info sym with wrong type")
1665 case goobj.AuxDwarfLoc:
1666 auxDwarfLoc = l.resolve(r, a.Sym())
1667 if l.SymType(auxDwarfLoc) != sym.SDWARFLOC {
1668 panic("aux dwarf loc sym with wrong type")
1670 case goobj.AuxDwarfRanges:
1671 auxDwarfRanges = l.resolve(r, a.Sym())
1672 if l.SymType(auxDwarfRanges) != sym.SDWARFRANGE {
1673 panic("aux dwarf ranges sym with wrong type")
1675 case goobj.AuxDwarfLines:
1676 auxDwarfLines = l.resolve(r, a.Sym())
1677 if l.SymType(auxDwarfLines) != sym.SDWARFLINES {
1678 panic("aux dwarf lines sym with wrong type")
1685 // AddInteriorSym sets up 'interior' as an interior symbol of
1686 // container/payload symbol 'container'. An interior symbol does not
1687 // itself have data, but gives a name to a subrange of the data in its
1688 // container symbol. The container itself may or may not have a name.
1689 // This method is intended primarily for use in the host object
1690 // loaders, to capture the semantics of symbols and sections in an
1691 // object file. When reading a host object file, we'll typically
1692 // encounter a static section symbol (ex: ".text") containing content
1693 // for a collection of functions, then a series of ELF (or macho, etc)
1694 // symbol table entries each of which points into a sub-section
1695 // (offset and length) of its corresponding container symbol. Within
1696 // the go linker we create a loader.Sym for the container (which is
1697 // expected to have the actual content/payload) and then a set of
1698 // interior loader.Sym's that point into a portion of the container.
1699 func (l *Loader) AddInteriorSym(container Sym, interior Sym) {
1700 // Container symbols are expected to have content/data.
1701 // NB: this restriction may turn out to be too strict (it's possible
1702 // to imagine a zero-sized container with an interior symbol pointing
1703 // into it); it's ok to relax or remove it if we counter an
1704 // oddball host object that triggers this.
1705 if l.SymSize(container) == 0 && len(l.Data(container)) == 0 {
1706 panic("unexpected empty container symbol")
1708 // The interior symbols for a container are not expected to have
1709 // content/data or relocations.
1710 if len(l.Data(interior)) != 0 {
1711 panic("unexpected non-empty interior symbol")
1713 // Interior symbol is expected to be in the symbol table.
1714 if l.AttrNotInSymbolTable(interior) {
1715 panic("interior symbol must be in symtab")
1717 // Only a single level of containment is allowed.
1718 if l.OuterSym(container) != 0 {
1719 panic("outer has outer itself")
1721 // Interior sym should not already have a sibling.
1722 if l.SubSym(interior) != 0 {
1723 panic("sub set for subsym")
1725 // Interior sym should not already point at a container.
1726 if l.OuterSym(interior) != 0 {
1727 panic("outer already set for subsym")
1729 l.sub[interior] = l.sub[container]
1730 l.sub[container] = interior
1731 l.outer[interior] = container
1734 // OuterSym gets the outer/container symbol.
1735 func (l *Loader) OuterSym(i Sym) Sym {
1739 // SubSym gets the subsymbol for host object loaded symbols.
1740 func (l *Loader) SubSym(i Sym) Sym {
1744 // growOuter grows the slice used to store outer symbol.
1745 func (l *Loader) growOuter(reqLen int) {
1746 curLen := len(l.outer)
1747 if reqLen > curLen {
1748 l.outer = append(l.outer, make([]Sym, reqLen-curLen)...)
1752 // SetCarrierSym declares that 'c' is the carrier or container symbol
1753 // for 's'. Carrier symbols are used in the linker to as a container
1754 // for a collection of sub-symbols where the content of the
1755 // sub-symbols is effectively concatenated to form the content of the
1756 // carrier. The carrier is given a name in the output symbol table
1757 // while the sub-symbol names are not. For example, the Go compiler
1758 // emits named string symbols (type SGOSTRING) when compiling a
1759 // package; after being deduplicated, these symbols are collected into
1760 // a single unit by assigning them a new carrier symbol named
1761 // "go:string.*" (which appears in the final symbol table for the
1762 // output load module).
1763 func (l *Loader) SetCarrierSym(s Sym, c Sym) {
1765 panic("invalid carrier in SetCarrierSym")
1768 panic("invalid sub-symbol in SetCarrierSym")
1770 // Carrier symbols are not expected to have content/data. It is
1771 // ok for them to have non-zero size (to allow for use of generator
1773 if len(l.Data(c)) != 0 {
1774 panic("unexpected non-empty carrier symbol")
1777 // relocsym's foldSubSymbolOffset requires that we only
1778 // have a single level of containment-- enforce here.
1779 if l.outer[c] != 0 {
1780 panic("invalid nested carrier sym")
1784 // Initialize Reachable bitmap and its siblings for running deadcode pass.
1785 func (l *Loader) InitReachable() {
1786 l.growAttrBitmaps(l.NSym() + 1)
1789 type symWithVal struct {
1793 type bySymValue []symWithVal
1795 func (s bySymValue) Len() int { return len(s) }
1796 func (s bySymValue) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
1797 func (s bySymValue) Less(i, j int) bool { return s[i].v < s[j].v }
1799 // SortSub walks through the sub-symbols for 's' and sorts them
1800 // in place by increasing value. Return value is the new
1801 // sub symbol for the specified outer symbol.
1802 func (l *Loader) SortSub(s Sym) Sym {
1804 if s == 0 || l.sub[s] == 0 {
1808 // Sort symbols using a slice first. Use a stable sort on the off
1809 // chance that there's more than once symbol with the same value,
1810 // so as to preserve reproducible builds.
1811 sl := []symWithVal{}
1812 for ss := l.sub[s]; ss != 0; ss = l.sub[ss] {
1813 sl = append(sl, symWithVal{s: ss, v: l.SymValue(ss)})
1815 sort.Stable(bySymValue(sl))
1817 // Then apply any changes needed to the sub map.
1819 for i := len(sl) - 1; i >= 0; i-- {
1825 // Update sub for outer symbol, then return
1830 // SortSyms sorts a list of symbols by their value.
1831 func (l *Loader) SortSyms(ss []Sym) {
1832 sort.SliceStable(ss, func(i, j int) bool { return l.SymValue(ss[i]) < l.SymValue(ss[j]) })
1835 // Insure that reachable bitmap and its siblings have enough size.
1836 func (l *Loader) growAttrBitmaps(reqLen int) {
1837 if reqLen > l.attrReachable.Len() {
1838 // These are indexed by global symbol
1839 l.attrReachable = growBitmap(reqLen, l.attrReachable)
1840 l.attrOnList = growBitmap(reqLen, l.attrOnList)
1841 l.attrLocal = growBitmap(reqLen, l.attrLocal)
1842 l.attrNotInSymbolTable = growBitmap(reqLen, l.attrNotInSymbolTable)
1843 l.attrUsedInIface = growBitmap(reqLen, l.attrUsedInIface)
1844 l.attrSpecial = growBitmap(reqLen, l.attrSpecial)
1846 l.growExtAttrBitmaps()
1849 func (l *Loader) growExtAttrBitmaps() {
1850 // These are indexed by external symbol index (e.g. l.extIndex(i))
1851 extReqLen := len(l.payloads)
1852 if extReqLen > l.attrVisibilityHidden.Len() {
1853 l.attrVisibilityHidden = growBitmap(extReqLen, l.attrVisibilityHidden)
1854 l.attrDuplicateOK = growBitmap(extReqLen, l.attrDuplicateOK)
1855 l.attrShared = growBitmap(extReqLen, l.attrShared)
1856 l.attrExternal = growBitmap(extReqLen, l.attrExternal)
1857 l.generatedSyms = growBitmap(extReqLen, l.generatedSyms)
1861 func (relocs *Relocs) Count() int { return len(relocs.rs) }
1863 // At returns the j-th reloc for a global symbol.
1864 func (relocs *Relocs) At(j int) Reloc {
1865 if relocs.l.isExtReader(relocs.r) {
1866 return Reloc{&relocs.rs[j], relocs.r, relocs.l}
1868 return Reloc{&relocs.rs[j], relocs.r, relocs.l}
1871 // Relocs returns a Relocs object for the given global sym.
1872 func (l *Loader) Relocs(i Sym) Relocs {
1873 r, li := l.toLocal(i)
1875 panic(fmt.Sprintf("trying to get oreader for invalid sym %d\n\n", i))
1877 return l.relocs(r, li)
1880 // relocs returns a Relocs object given a local sym index and reader.
1881 func (l *Loader) relocs(r *oReader, li uint32) Relocs {
1882 var rs []goobj.Reloc
1883 if l.isExtReader(r) {
1884 pp := l.payloads[li]
1897 func (l *Loader) auxs(i Sym) (*oReader, []goobj.Aux) {
1898 if l.IsExternal(i) {
1899 pp := l.getPayload(i)
1900 return l.objs[pp.objidx].r, pp.auxs
1902 r, li := l.toLocal(i)
1903 return r, r.Auxs(li)
1907 // Returns a specific aux symbol of type t for symbol i.
1908 func (l *Loader) aux1(i Sym, t uint8) Sym {
1909 r, auxs := l.auxs(i)
1910 for j := range auxs {
1913 return l.resolve(r, a.Sym())
1919 func (l *Loader) Pcsp(i Sym) Sym { return l.aux1(i, goobj.AuxPcsp) }
1921 // Returns all aux symbols of per-PC data for symbol i.
1922 // tmp is a scratch space for the pcdata slice.
1923 func (l *Loader) PcdataAuxs(i Sym, tmp []Sym) (pcsp, pcfile, pcline, pcinline Sym, pcdata []Sym) {
1925 r, auxs := l.auxs(i)
1926 for j := range auxs {
1930 pcsp = l.resolve(r, a.Sym())
1931 case goobj.AuxPcline:
1932 pcline = l.resolve(r, a.Sym())
1933 case goobj.AuxPcfile:
1934 pcfile = l.resolve(r, a.Sym())
1935 case goobj.AuxPcinline:
1936 pcinline = l.resolve(r, a.Sym())
1937 case goobj.AuxPcdata:
1938 pcdata = append(pcdata, l.resolve(r, a.Sym()))
1944 // Returns the number of pcdata for symbol i.
1945 func (l *Loader) NumPcdata(i Sym) int {
1947 _, auxs := l.auxs(i)
1948 for j := range auxs {
1950 if a.Type() == goobj.AuxPcdata {
1957 // Returns all funcdata symbols of symbol i.
1958 // tmp is a scratch space.
1959 func (l *Loader) Funcdata(i Sym, tmp []Sym) []Sym {
1961 r, auxs := l.auxs(i)
1962 for j := range auxs {
1964 if a.Type() == goobj.AuxFuncdata {
1965 fd = append(fd, l.resolve(r, a.Sym()))
1971 // Returns the number of funcdata for symbol i.
1972 func (l *Loader) NumFuncdata(i Sym) int {
1974 _, auxs := l.auxs(i)
1975 for j := range auxs {
1977 if a.Type() == goobj.AuxFuncdata {
1984 // FuncInfo provides hooks to access goobj.FuncInfo in the objects.
1985 type FuncInfo struct {
1989 lengths goobj.FuncInfoLengths
1992 func (fi *FuncInfo) Valid() bool { return fi.r != nil }
1994 func (fi *FuncInfo) Args() int {
1995 return int((*goobj.FuncInfo)(nil).ReadArgs(fi.data))
1998 func (fi *FuncInfo) Locals() int {
1999 return int((*goobj.FuncInfo)(nil).ReadLocals(fi.data))
2002 func (fi *FuncInfo) FuncID() abi.FuncID {
2003 return (*goobj.FuncInfo)(nil).ReadFuncID(fi.data)
2006 func (fi *FuncInfo) FuncFlag() abi.FuncFlag {
2007 return (*goobj.FuncInfo)(nil).ReadFuncFlag(fi.data)
2010 func (fi *FuncInfo) StartLine() int32 {
2011 return (*goobj.FuncInfo)(nil).ReadStartLine(fi.data)
2014 // Preload has to be called prior to invoking the various methods
2015 // below related to pcdata, funcdataoff, files, and inltree nodes.
2016 func (fi *FuncInfo) Preload() {
2017 fi.lengths = (*goobj.FuncInfo)(nil).ReadFuncInfoLengths(fi.data)
2020 func (fi *FuncInfo) NumFile() uint32 {
2021 if !fi.lengths.Initialized {
2022 panic("need to call Preload first")
2024 return fi.lengths.NumFile
2027 func (fi *FuncInfo) File(k int) goobj.CUFileIndex {
2028 if !fi.lengths.Initialized {
2029 panic("need to call Preload first")
2031 return (*goobj.FuncInfo)(nil).ReadFile(fi.data, fi.lengths.FileOff, uint32(k))
2034 // TopFrame returns true if the function associated with this FuncInfo
2035 // is an entry point, meaning that unwinders should stop when they hit
2037 func (fi *FuncInfo) TopFrame() bool {
2038 return (fi.FuncFlag() & abi.FuncFlagTopFrame) != 0
2041 type InlTreeNode struct {
2043 File goobj.CUFileIndex
2049 func (fi *FuncInfo) NumInlTree() uint32 {
2050 if !fi.lengths.Initialized {
2051 panic("need to call Preload first")
2053 return fi.lengths.NumInlTree
2056 func (fi *FuncInfo) InlTree(k int) InlTreeNode {
2057 if !fi.lengths.Initialized {
2058 panic("need to call Preload first")
2060 node := (*goobj.FuncInfo)(nil).ReadInlTree(fi.data, fi.lengths.InlTreeOff, uint32(k))
2062 Parent: node.Parent,
2065 Func: fi.l.resolve(fi.r, node.Func),
2066 ParentPC: node.ParentPC,
2070 func (l *Loader) FuncInfo(i Sym) FuncInfo {
2071 r, auxs := l.auxs(i)
2072 for j := range auxs {
2074 if a.Type() == goobj.AuxFuncInfo {
2075 b := r.Data(a.Sym().SymIdx)
2076 return FuncInfo{l, r, b, goobj.FuncInfoLengths{}}
2082 // Preload a package: adds autolib.
2083 // Does not add defined package or non-packaged symbols to the symbol table.
2084 // These are done in LoadSyms.
2085 // Does not read symbol data.
2086 // Returns the fingerprint of the object.
2087 func (l *Loader) Preload(localSymVersion int, f *bio.Reader, lib *sym.Library, unit *sym.CompilationUnit, length int64) goobj.FingerprintType {
2088 roObject, readonly, err := f.Slice(uint64(length)) // TODO: no need to map blocks that are for tools only (e.g. RefName)
2090 log.Fatal("cannot read object file:", err)
2092 r := goobj.NewReaderFromBytes(roObject, readonly)
2094 if len(roObject) >= 8 && bytes.Equal(roObject[:8], []byte("\x00go114ld")) {
2095 log.Fatalf("found object file %s in old format", f.File().Name())
2097 panic("cannot read object file")
2099 pkgprefix := objabi.PathToPrefix(lib.Pkg) + "."
2101 nhashed64def := r.NHashed64def()
2102 nhasheddef := r.NHasheddef()
2106 version: localSymVersion,
2107 pkgprefix: pkgprefix,
2108 syms: make([]Sym, ndef+nhashed64def+nhasheddef+r.NNonpkgdef()+r.NNonpkgref()),
2110 nhasheddef: nhasheddef,
2111 nhashed64def: nhashed64def,
2112 objidx: uint32(len(l.objs)),
2116 log.Fatalf("link: unlinkable object (from package %s) - compiler requires -p flag", lib.Pkg)
2120 lib.Autolib = append(lib.Autolib, r.Autolib()...)
2124 unit.FileTable = make([]string, nfile)
2125 for i := range unit.FileTable {
2126 unit.FileTable[i] = r.File(i)
2129 l.addObj(lib.Pkg, or)
2131 // The caller expects us consuming all the data
2132 f.MustSeek(length, io.SeekCurrent)
2134 return r.Fingerprint()
2137 // Holds the loader along with temporary states for loading symbols.
2138 type loadState struct {
2140 hashed64Syms map[uint64]symAndSize // short hashed (content-addressable) symbols, keyed by content hash
2141 hashedSyms map[goobj.HashType]symAndSize // hashed (content-addressable) symbols, keyed by content hash
2144 // Preload symbols of given kind from an object.
2145 func (st *loadState) preloadSyms(r *oReader, kind int) {
2147 var start, end uint32
2151 end = uint32(r.ndef)
2153 start = uint32(r.ndef)
2154 end = uint32(r.ndef + r.nhashed64def)
2156 start = uint32(r.ndef + r.nhashed64def)
2157 end = uint32(r.ndef + r.nhashed64def + r.nhasheddef)
2159 start = uint32(r.ndef + r.nhashed64def + r.nhasheddef)
2160 end = uint32(r.ndef + r.nhashed64def + r.nhasheddef + r.NNonpkgdef())
2162 panic("preloadSyms: bad kind")
2164 l.growAttrBitmaps(len(l.objSyms) + int(end-start))
2165 loadingRuntimePkg := r.unit.Lib.Pkg == "runtime"
2166 for i := start; i < end; i++ {
2170 if kind != hashed64Def && kind != hashedDef { // we don't need the name, etc. for hashed symbols
2171 name = osym.Name(r.Reader)
2172 v = abiToVer(osym.ABI(), r.version)
2174 gi := st.addSym(name, v, r, i, kind, osym)
2177 l.SetAttrLocal(gi, true)
2179 if osym.UsedInIface() {
2180 l.SetAttrUsedInIface(gi, true)
2182 if strings.HasPrefix(name, "runtime.") ||
2183 (loadingRuntimePkg && strings.HasPrefix(name, "type:")) {
2184 if bi := goobj.BuiltinIdx(name, int(osym.ABI())); bi != -1 {
2185 // This is a definition of a builtin symbol. Record where it is.
2186 l.builtinSyms[bi] = gi
2189 if a := int32(osym.Align()); a != 0 && a > l.SymAlign(gi) {
2190 l.SetSymAlign(gi, a)
2195 // Add syms, hashed (content-addressable) symbols, non-package symbols, and
2196 // references to external symbols (which are always named).
2197 func (l *Loader) LoadSyms(arch *sys.Arch) {
2198 // Allocate space for symbols, making a guess as to how much space we need.
2199 // This function was determined empirically by looking at the cmd/compile on
2200 // Darwin, and picking factors for hashed and hashed64 syms.
2201 var symSize, hashedSize, hashed64Size int
2202 for _, o := range l.objs[goObjStart:] {
2203 symSize += o.r.ndef + o.r.nhasheddef/2 + o.r.nhashed64def/2 + o.r.NNonpkgdef()
2204 hashedSize += o.r.nhasheddef / 2
2205 hashed64Size += o.r.nhashed64def / 2
2207 // Index 0 is invalid for symbols.
2208 l.objSyms = make([]objSym, 1, symSize)
2212 hashed64Syms: make(map[uint64]symAndSize, hashed64Size),
2213 hashedSyms: make(map[goobj.HashType]symAndSize, hashedSize),
2216 for _, o := range l.objs[goObjStart:] {
2217 st.preloadSyms(o.r, pkgDef)
2219 l.npkgsyms = l.NSym()
2220 for _, o := range l.objs[goObjStart:] {
2221 st.preloadSyms(o.r, hashed64Def)
2222 st.preloadSyms(o.r, hashedDef)
2223 st.preloadSyms(o.r, nonPkgDef)
2225 l.nhashedsyms = len(st.hashed64Syms) + len(st.hashedSyms)
2226 for _, o := range l.objs[goObjStart:] {
2227 loadObjRefs(l, o.r, arch)
2229 l.values = make([]int64, l.NSym(), l.NSym()+1000) // +1000 make some room for external symbols
2230 l.outer = make([]Sym, l.NSym(), l.NSym()+1000)
2233 func loadObjRefs(l *Loader, r *oReader, arch *sys.Arch) {
2234 // load non-package refs
2235 ndef := uint32(r.NAlldef())
2236 for i, n := uint32(0), uint32(r.NNonpkgref()); i < n; i++ {
2237 osym := r.Sym(ndef + i)
2238 name := osym.Name(r.Reader)
2239 v := abiToVer(osym.ABI(), r.version)
2240 r.syms[ndef+i] = l.LookupOrCreateSym(name, v)
2241 gi := r.syms[ndef+i]
2243 l.SetAttrLocal(gi, true)
2245 if osym.UsedInIface() {
2246 l.SetAttrUsedInIface(gi, true)
2250 // referenced packages
2252 r.pkg = make([]uint32, npkg)
2253 for i := 1; i < npkg; i++ { // PkgIdx 0 is a dummy invalid package
2255 objidx, ok := l.objByPkg[pkg]
2257 log.Fatalf("%v: reference to nonexistent package %s", r.unit.Lib, pkg)
2262 // load flags of package refs
2263 for i, n := 0, r.NRefFlags(); i < n; i++ {
2265 gi := l.resolve(r, rf.Sym())
2266 if rf.Flag2()&goobj.SymFlagUsedInIface != 0 {
2267 l.SetAttrUsedInIface(gi, true)
2272 func abiToVer(abi uint16, localSymVersion int) int {
2274 if abi == goobj.SymABIstatic {
2277 } else if abiver := sym.ABIToVersion(obj.ABI(abi)); abiver != -1 {
2278 // Note that data symbols are "ABI0", which maps to version 0.
2281 log.Fatalf("invalid symbol ABI: %d", abi)
2286 // TopLevelSym tests a symbol (by name and kind) to determine whether
2287 // the symbol first class sym (participating in the link) or is an
2288 // anonymous aux or sub-symbol containing some sub-part or payload of
2290 func (l *Loader) TopLevelSym(s Sym) bool {
2291 return topLevelSym(l.SymName(s), l.SymType(s))
2294 // topLevelSym tests a symbol name and kind to determine whether
2295 // the symbol first class sym (participating in the link) or is an
2296 // anonymous aux or sub-symbol containing some sub-part or payload of
2298 func topLevelSym(sname string, skind sym.SymKind) bool {
2303 case sym.SDWARFFCN, sym.SDWARFABSFCN, sym.SDWARFTYPE, sym.SDWARFCONST, sym.SDWARFCUINFO, sym.SDWARFRANGE, sym.SDWARFLOC, sym.SDWARFLINES, sym.SGOFUNC:
2310 // cloneToExternal takes the existing object file symbol (symIdx)
2311 // and creates a new external symbol payload that is a clone with
2312 // respect to name, version, type, relocations, etc. The idea here
2313 // is that if the linker decides it wants to update the contents of
2314 // a symbol originally discovered as part of an object file, it's
2315 // easier to do this if we make the updates to an external symbol
2317 func (l *Loader) cloneToExternal(symIdx Sym) {
2318 if l.IsExternal(symIdx) {
2319 panic("sym is already external, no need for clone")
2322 // Read the particulars from object.
2323 r, li := l.toLocal(symIdx)
2325 sname := osym.Name(r.Reader)
2326 sver := abiToVer(osym.ABI(), r.version)
2327 skind := sym.AbiSymKindToSymKind[objabi.SymKind(osym.Type())]
2329 // Create new symbol, update version and kind.
2330 pi := l.newPayload(sname, sver)
2331 pp := l.payloads[pi]
2334 pp.size = int64(osym.Siz())
2335 pp.objidx = r.objidx
2337 // If this is a def, then copy the guts. We expect this case
2338 // to be very rare (one case it may come up is with -X).
2339 if li < uint32(r.NAlldef()) {
2342 relocs := l.Relocs(symIdx)
2343 pp.relocs = make([]goobj.Reloc, relocs.Count())
2344 for i := range pp.relocs {
2345 // Copy the relocs slice.
2346 // Convert local reference to global reference.
2348 pp.relocs[i].Set(rel.Off(), rel.Siz(), uint16(rel.Type()), rel.Add(), goobj.SymRef{PkgIdx: 0, SymIdx: uint32(rel.Sym())})
2352 pp.data = r.Data(li)
2355 // If we're overriding a data symbol, collect the associated
2356 // Gotype, so as to propagate it to the new symbol.
2360 // Install new payload to global index space.
2361 // (This needs to happen at the end, as the accessors above
2362 // need to access the old symbol content.)
2363 l.objSyms[symIdx] = objSym{l.extReader.objidx, uint32(pi)}
2364 l.extReader.syms = append(l.extReader.syms, symIdx)
2366 // Some attributes were encoded in the object file. Copy them over.
2367 l.SetAttrDuplicateOK(symIdx, r.Sym(li).Dupok())
2368 l.SetAttrShared(symIdx, r.Shared())
2371 // Copy the payload of symbol src to dst. Both src and dst must be external
2373 // The intended use case is that when building/linking against a shared library,
2374 // where we do symbol name mangling, the Go object file may have reference to
2375 // the original symbol name whereas the shared library provides a symbol with
2376 // the mangled name. When we do mangling, we copy payload of mangled to original.
2377 func (l *Loader) CopySym(src, dst Sym) {
2378 if !l.IsExternal(dst) {
2379 panic("dst is not external") //l.newExtSym(l.SymName(dst), l.SymVersion(dst))
2381 if !l.IsExternal(src) {
2382 panic("src is not external") //l.cloneToExternal(src)
2384 l.payloads[l.extIndex(dst)] = l.payloads[l.extIndex(src)]
2385 l.SetSymPkg(dst, l.SymPkg(src))
2386 // TODO: other attributes?
2389 // CreateExtSym creates a new external symbol with the specified name
2390 // without adding it to any lookup tables, returning a Sym index for it.
2391 func (l *Loader) CreateExtSym(name string, ver int) Sym {
2392 return l.newExtSym(name, ver)
2395 // CreateStaticSym creates a new static symbol with the specified name
2396 // without adding it to any lookup tables, returning a Sym index for it.
2397 func (l *Loader) CreateStaticSym(name string) Sym {
2398 // Assign a new unique negative version -- this is to mark the
2399 // symbol so that it is not included in the name lookup table.
2401 return l.newExtSym(name, l.anonVersion)
2404 func (l *Loader) FreeSym(i Sym) {
2405 if l.IsExternal(i) {
2406 pp := l.getPayload(i)
2407 *pp = extSymPayload{}
2411 // relocId is essentially a <S,R> tuple identifying the Rth
2412 // relocation of symbol S.
2413 type relocId struct {
2418 // SetRelocVariant sets the 'variant' property of a relocation on
2419 // some specific symbol.
2420 func (l *Loader) SetRelocVariant(s Sym, ri int, v sym.RelocVariant) {
2422 if relocs := l.Relocs(s); ri >= relocs.Count() {
2423 panic("invalid relocation ID")
2425 if l.relocVariant == nil {
2426 l.relocVariant = make(map[relocId]sym.RelocVariant)
2429 l.relocVariant[relocId{s, ri}] = v
2431 delete(l.relocVariant, relocId{s, ri})
2435 // RelocVariant returns the 'variant' property of a relocation on
2436 // some specific symbol.
2437 func (l *Loader) RelocVariant(s Sym, ri int) sym.RelocVariant {
2438 return l.relocVariant[relocId{s, ri}]
2441 // UndefinedRelocTargets iterates through the global symbol index
2442 // space, looking for symbols with relocations targeting undefined
2443 // references. The linker's loadlib method uses this to determine if
2444 // there are unresolved references to functions in system libraries
2445 // (for example, libgcc.a), presumably due to CGO code. Return value
2446 // is a pair of lists of loader.Sym's. First list corresponds to the
2447 // corresponding to the undefined symbols themselves, the second list
2448 // is the symbol that is making a reference to the undef. The "limit"
2449 // param controls the maximum number of results returned; if "limit"
2450 // is -1, then all undefs are returned.
2451 func (l *Loader) UndefinedRelocTargets(limit int) ([]Sym, []Sym) {
2452 result, fromr := []Sym{}, []Sym{}
2454 for si := Sym(1); si < Sym(len(l.objSyms)); si++ {
2455 relocs := l.Relocs(si)
2456 for ri := 0; ri < relocs.Count(); ri++ {
2459 if rs != 0 && l.SymType(rs) == sym.SXREF && l.SymName(rs) != ".got" {
2460 result = append(result, rs)
2461 fromr = append(fromr, si)
2462 if limit != -1 && len(result) >= limit {
2468 return result, fromr
2471 // AssignTextSymbolOrder populates the Textp slices within each
2472 // library and compilation unit, insuring that packages are laid down
2473 // in dependency order (internal first, then everything else). Return value
2474 // is a slice of all text syms.
2475 func (l *Loader) AssignTextSymbolOrder(libs []*sym.Library, intlibs []bool, extsyms []Sym) []Sym {
2477 // Library Textp lists should be empty at this point.
2478 for _, lib := range libs {
2479 if len(lib.Textp) != 0 {
2480 panic("expected empty Textp slice for library")
2482 if len(lib.DupTextSyms) != 0 {
2483 panic("expected empty DupTextSyms slice for library")
2487 // Used to record which dupok symbol we've assigned to a unit.
2488 // Can't use the onlist attribute here because it will need to
2489 // clear for the later assignment of the sym.Symbol to a unit.
2490 // NB: we can convert to using onList once we no longer have to
2491 // call the regular addToTextp.
2492 assignedToUnit := MakeBitmap(l.NSym() + 1)
2494 // Start off textp with reachable external syms.
2496 for _, sym := range extsyms {
2497 if !l.attrReachable.Has(sym) {
2500 textp = append(textp, sym)
2503 // Walk through all text symbols from Go object files and append
2504 // them to their corresponding library's textp list.
2505 for _, o := range l.objs[goObjStart:] {
2508 for i, n := uint32(0), uint32(r.NAlldef()); i < n; i++ {
2509 gi := l.toGlobal(r, i)
2510 if !l.attrReachable.Has(gi) {
2514 st := sym.AbiSymKindToSymKind[objabi.SymKind(osym.Type())]
2515 if st != sym.STEXT {
2518 dupok := osym.Dupok()
2519 if r2, i2 := l.toLocal(gi); r2 != r || i2 != i {
2520 // A dupok text symbol is resolved to another package.
2521 // We still need to record its presence in the current
2522 // package, as the trampoline pass expects packages
2523 // are laid out in dependency order.
2524 lib.DupTextSyms = append(lib.DupTextSyms, sym.LoaderSym(gi))
2525 continue // symbol in different object
2528 lib.DupTextSyms = append(lib.DupTextSyms, sym.LoaderSym(gi))
2532 lib.Textp = append(lib.Textp, sym.LoaderSym(gi))
2536 // Now assemble global textp, and assign text symbols to units.
2537 for _, doInternal := range [2]bool{true, false} {
2538 for idx, lib := range libs {
2539 if intlibs[idx] != doInternal {
2542 lists := [2][]sym.LoaderSym{lib.Textp, lib.DupTextSyms}
2543 for i, list := range lists {
2544 for _, s := range list {
2546 if !assignedToUnit.Has(sym) {
2547 textp = append(textp, sym)
2548 unit := l.SymUnit(sym)
2550 unit.Textp = append(unit.Textp, s)
2551 assignedToUnit.Set(sym)
2553 // Dupok symbols may be defined in multiple packages; the
2554 // associated package for a dupok sym is chosen sort of
2555 // arbitrarily (the first containing package that the linker
2556 // loads). Canonicalizes its Pkg to the package with which
2557 // it will be laid down in text.
2558 if i == 1 /* DupTextSyms2 */ && l.SymPkg(sym) != lib.Pkg {
2559 l.SetSymPkg(sym, lib.Pkg)
2565 lib.DupTextSyms = nil
2572 // ErrorReporter is a helper class for reporting errors.
2573 type ErrorReporter struct {
2575 AfterErrorAction func()
2578 // Errorf method logs an error message.
2580 // After each error, the error actions function will be invoked; this
2581 // will either terminate the link immediately (if -h option given)
2582 // or it will keep a count and exit if more than 20 errors have been printed.
2584 // Logging an error means that on exit cmd/link will delete any
2585 // output file and return a non-zero error code.
2586 func (reporter *ErrorReporter) Errorf(s Sym, format string, args ...interface{}) {
2587 if s != 0 && reporter.ldr.SymName(s) != "" {
2588 // Note: Replace is needed here because symbol names might have % in them,
2589 // due to the use of LinkString for names of instantiating types.
2590 format = strings.Replace(reporter.ldr.SymName(s), "%", "%%", -1) + ": " + format
2592 format = fmt.Sprintf("sym %d: %s", s, format)
2595 fmt.Fprintf(os.Stderr, format, args...)
2596 reporter.AfterErrorAction()
2599 // GetErrorReporter returns the loader's associated error reporter.
2600 func (l *Loader) GetErrorReporter() *ErrorReporter {
2601 return l.errorReporter
2604 // Errorf method logs an error message. See ErrorReporter.Errorf for details.
2605 func (l *Loader) Errorf(s Sym, format string, args ...interface{}) {
2606 l.errorReporter.Errorf(s, format, args...)
2609 // Symbol statistics.
2610 func (l *Loader) Stat() string {
2611 s := fmt.Sprintf("%d symbols, %d reachable\n", l.NSym(), l.NReachableSym())
2612 s += fmt.Sprintf("\t%d package symbols, %d hashed symbols, %d non-package symbols, %d external symbols\n",
2613 l.npkgsyms, l.nhashedsyms, int(l.extStart)-l.npkgsyms-l.nhashedsyms, l.NSym()-int(l.extStart))
2618 func (l *Loader) Dump() {
2620 for _, obj := range l.objs[goObjStart:] {
2622 fmt.Println(obj.i, obj.r.unit.Lib)
2625 fmt.Println("extStart:", l.extStart)
2626 fmt.Println("Nsyms:", len(l.objSyms))
2628 for i := Sym(1); i < Sym(len(l.objSyms)); i++ {
2630 if l.IsExternal(i) {
2631 pi = fmt.Sprintf("<ext %d>", l.extIndex(i))
2634 if l.SymSect(i) != nil {
2635 sect = l.SymSect(i).Name
2637 fmt.Printf("%v %v %v %v %x %v\n", i, l.SymName(i), l.SymType(i), pi, l.SymValue(i), sect)
2639 fmt.Println("symsByName")
2640 for name, i := range l.symsByName[0] {
2641 fmt.Println(i, name, 0)
2643 for name, i := range l.symsByName[1] {
2644 fmt.Println(i, name, 1)
2646 fmt.Println("payloads:")
2647 for i := range l.payloads {
2649 fmt.Println(i, pp.name, pp.ver, pp.kind)