[dev.link] cmd/oldlink: decouple from goobj2 package
The new object file support in the old linker should not be used.
This is a minimal change that removes stuff from the old linker's
loader package, so that it decouples from the goobj2 package,
allowing the latter to evolve.
Keep the change local in the loader package, so most of the old
linker doesn't need to change. At this point I don't think we
want to make significant changes to the old linker.
Change-Id: I078c4cbb35dc4627c4b82f512a4aceec9b594925
Reviewed-on: https://go-review.googlesource.com/c/go/+/226800
Reviewed-by: Jeremy Faller <jeremy@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
diff --git a/src/cmd/oldlink/internal/loader/loader.go b/src/cmd/oldlink/internal/loader/loader.go
index ed533c9..8c618bf 100644
--- a/src/cmd/oldlink/internal/loader/loader.go
+++ b/src/cmd/oldlink/internal/loader/loader.go
@@ -8,14 +8,11 @@
"bytes"
"cmd/internal/bio"
"cmd/internal/dwarf"
- "cmd/internal/goobj2"
- "cmd/internal/obj"
"cmd/internal/objabi"
"cmd/internal/sys"
"cmd/oldlink/internal/sym"
"fmt"
"log"
- "os"
"sort"
"strconv"
"strings"
@@ -54,7 +51,7 @@
// extra information.
// TODO: rename to objReader once the old one is gone?
type oReader struct {
- *goobj2.Reader
+ //*goobj2.Reader
unit *sym.CompilationUnit
version int // version of static symbol
flags uint32 // read from object file
@@ -133,18 +130,8 @@
)
func NewLoader(flags uint32) *Loader {
- nbuiltin := goobj2.NBuiltin()
- return &Loader{
- start: make(map[*oReader]Sym),
- objs: []objIdx{{nil, 0, 0}},
- symsByName: [2]map[string]Sym{make(map[string]Sym), make(map[string]Sym)},
- objByPkg: make(map[string]*oReader),
- overwrite: make(map[Sym]Sym),
- itablink: make(map[Sym]struct{}),
- extStaticSyms: make(map[nameVer]Sym),
- builtinSyms: make([]Sym, nbuiltin),
- flags: flags,
- }
+ log.Fatal("-newobj in oldlink should not be used")
+ panic("unreachable")
}
// Return the start index in the global index space for a given object file.
@@ -152,66 +139,9 @@
return l.start[r]
}
-// 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
- }
- n := r.NSym() + r.NNonpkgdef()
- i := l.max + 1
- l.start[r] = i
- l.objs = append(l.objs, objIdx{r, i, i + Sym(n) - 1})
- l.max += Sym(n)
- return i
-}
-
// Add a symbol with a given index, return if it is added.
func (l *Loader) AddSym(name string, ver int, i Sym, r *oReader, dupok bool, typ sym.SymKind) bool {
- if l.extStart != 0 {
- panic("AddSym called after AddExtSym is called")
- }
- 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.
- return true
- }
- if oldi, ok := l.symsByName[ver][name]; ok {
- if dupok {
- if l.flags&FlagStrictDups != 0 {
- l.checkdup(name, i, r, oldi)
- }
- return false
- }
- oldr, li := l.toLocal(oldi)
- oldsym := goobj2.Sym{}
- oldsym.Read(oldr.Reader, oldr.SymOff(li))
- if oldsym.Dupok() {
- return false
- }
- overwrite := r.DataSize(int(i-l.startIndex(r))) != 0
- if overwrite {
- // new symbol overwrites old symbol.
- oldtyp := sym.AbiSymKindToSymKind[objabi.SymKind(oldsym.Type)]
- if !oldtyp.IsData() && r.DataSize(li) == 0 {
- log.Fatalf("duplicated definition of symbol " + name)
- }
- l.overwrite[oldi] = i
- } else {
- // old symbol overwrites new symbol.
- if typ != sym.SDATA && typ != sym.SNOPTRDATA && typ != sym.SBSS && typ != sym.SNOPTRBSS { // only allow overwriting data symbol
- log.Fatalf("duplicated definition of symbol " + name)
- }
- l.overwrite[i] = oldi
- return false
- }
- }
- l.symsByName[ver][name] = i
- return true
+ panic("unreachable")
}
// Add an external symbol (without index). Return the index of newly added
@@ -286,65 +216,6 @@
return l.objs[k-1].r, int(i - l.objs[k-1].i)
}
-// rcacheGet checks for a valid entry for 's' in the readers cache,
-// where 's' is a local PkgIdxNone ref or def, or zero if
-// the cache is empty or doesn't contain a value for 's'.
-func (or *oReader) rcacheGet(symIdx uint32) Sym {
- if len(or.rcache) > 0 {
- return or.rcache[symIdx]
- }
- return 0
-}
-
-// rcacheSet installs a new entry in the oReader's PkgNone
-// resolver cache for the specified PkgIdxNone ref or def,
-// allocating a new cache if needed.
-func (or *oReader) rcacheSet(symIdx uint32, gsym Sym) {
- if len(or.rcache) == 0 {
- or.rcache = make([]Sym, or.NNonpkgdef()+or.NNonpkgref())
- }
- or.rcache[symIdx] = gsym
-}
-
-// 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:
- if s.SymIdx != 0 {
- panic("bad sym ref")
- }
- return 0
- case goobj2.PkgIdxNone:
- // Check for cached version first
- if cached := r.rcacheGet(s.SymIdx); cached != 0 {
- return cached
- }
- // Resolve by name
- i := int(s.SymIdx) + r.NSym()
- osym := goobj2.Sym{}
- osym.Read(r.Reader, r.SymOff(i))
- name := strings.Replace(osym.Name, "\"\".", r.pkgprefix, -1)
- v := abiToVer(osym.ABI, r.version)
- gsym := l.Lookup(name, v)
- // Add to cache, then return.
- r.rcacheSet(s.SymIdx, gsym)
- return gsym
- 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.
@@ -358,61 +229,12 @@
// Returns whether i is a dup of another symbol, and i is not
// "primary", i.e. Lookup i by name will not return i.
func (l *Loader) IsDup(i Sym) bool {
- if _, ok := l.overwrite[i]; ok {
- return true
- }
- if l.IsExternal(i) {
- return false
- }
- r, li := l.toLocal(i)
- osym := goobj2.Sym{}
- osym.Read(r.Reader, r.SymOff(li))
- if !osym.Dupok() {
- return false
- }
- if osym.Name == "" {
- return false // Unnamed aux symbol cannot be dup.
- }
- if osym.ABI == goobj2.SymABIstatic {
- return false // Static symbol cannot be dup.
- }
- name := strings.Replace(osym.Name, "\"\".", r.pkgprefix, -1)
- ver := abiToVer(osym.ABI, r.version)
- return l.symsByName[ver][name] != i
+ panic("unreachable")
}
// Check that duplicate symbols have same contents.
func (l *Loader) checkdup(name string, i Sym, r *oReader, dup Sym) {
- li := int(i - l.startIndex(r))
- p := r.Data(li)
- if strings.HasPrefix(name, "go.info.") {
- p, _ = patchDWARFName1(p, r)
- }
- rdup, ldup := l.toLocal(dup)
- pdup := rdup.Data(ldup)
- if strings.HasPrefix(name, "go.info.") {
- pdup, _ = patchDWARFName1(pdup, rdup)
- }
- 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++
- }
+ panic("unreachable")
}
func (l *Loader) NStrictDupMsgs() int { return l.strictDupMsgs }
@@ -429,66 +251,32 @@
// Returns the raw (unpatched) name of the i-th symbol.
func (l *Loader) RawSymName(i Sym) string {
- if l.IsExternal(i) {
- if s := l.Syms[i]; s != nil {
- return s.Name
- }
- return ""
- }
- r, li := l.toLocal(i)
- osym := goobj2.Sym{}
- osym.Read(r.Reader, r.SymOff(li))
- return osym.Name
+ panic("unreachable")
}
// Returns the (patched) name of the i-th symbol.
func (l *Loader) SymName(i Sym) string {
- if l.IsExternal(i) {
- if s := l.Syms[i]; s != nil {
- return s.Name // external name should already be patched?
- }
- return ""
- }
- r, li := l.toLocal(i)
- osym := goobj2.Sym{}
- osym.Read(r.Reader, r.SymOff(li))
- return strings.Replace(osym.Name, "\"\".", r.pkgprefix, -1)
+ panic("unreachable")
}
// Returns the type of the i-th symbol.
func (l *Loader) SymType(i Sym) sym.SymKind {
- if l.IsExternal(i) {
- if s := l.Syms[i]; s != nil {
- return s.Type
- }
- return 0
- }
- r, li := l.toLocal(i)
- osym := goobj2.Sym{}
- osym.Read(r.Reader, r.SymOff(li))
- return sym.AbiSymKindToSymKind[objabi.SymKind(osym.Type)]
+ panic("unreachable")
}
// 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 is the only thing matters and it cannot be set by external symbol.
- return 0
- }
- r, li := l.toLocal(i)
- osym := goobj2.Sym{}
- osym.Read(r.Reader, r.SymOff(li))
- return osym.Flag
+ panic("unreachable")
}
// Returns whether the i-th symbol has ReflectMethod attribute set.
func (l *Loader) IsReflectMethod(i Sym) bool {
- return l.SymAttr(i)&goobj2.SymFlagReflectMethod != 0
+ panic("unreachable")
}
// Returns whether this is a Go type symbol.
func (l *Loader) IsGoType(i Sym) bool {
- return l.SymAttr(i)&goobj2.SymFlagGoType != 0
+ panic("unreachable")
}
// Returns whether this is a "go.itablink.*" symbol.
@@ -501,62 +289,25 @@
// Returns the symbol content of the i-th symbol. i is global index.
func (l *Loader) Data(i Sym) []byte {
- if l.IsExternal(i) {
- if s := l.Syms[i]; s != nil {
- return s.P
- }
- return nil
- }
- r, li := l.toLocal(i)
- return r.Data(li)
+ panic("unreachable")
}
// 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)
+ panic("unreachable")
}
// Returns the referred symbol of the j-th aux symbol of the i-th
// symbol.
func (l *Loader) AuxSym(i Sym, j int) Sym {
- if l.IsExternal(i) {
- return 0
- }
- r, li := l.toLocal(i)
- a := goobj2.Aux{}
- a.Read(r.Reader, r.AuxOff(li, j))
- return l.resolve(r, a.Sym)
+ panic("unreachable")
}
// ReadAuxSyms reads the aux symbol ids for the specified symbol into the
// slice passed as a parameter. If the slice capacity is not large enough, a new
// larger slice will be allocated. Final slice is returned.
func (l *Loader) ReadAuxSyms(symIdx Sym, dst []Sym) []Sym {
- if l.IsExternal(symIdx) {
- return dst[:0]
- }
- naux := l.NAux(symIdx)
- if naux == 0 {
- return dst[:0]
- }
-
- if cap(dst) < naux {
- dst = make([]Sym, naux)
- }
- dst = dst[:0]
-
- r, li := l.toLocal(symIdx)
- for i := 0; i < naux; i++ {
- a := goobj2.Aux{}
- a.Read(r.Reader, r.AuxOff(li, i))
- dst = append(dst, l.resolve(r, a.Sym))
- }
-
- return dst
+ panic("unreachable")
}
// OuterSym gets the outer symbol for host object loaded symbols.
@@ -586,147 +337,25 @@
// At method returns the j-th reloc for a global symbol.
func (relocs *Relocs) At(j int) Reloc {
- if relocs.ext != nil {
- rel := &relocs.ext.R[j]
- return Reloc{
- Off: rel.Off,
- Size: rel.Siz,
- Type: rel.Type,
- Add: rel.Add,
- Sym: relocs.l.Lookup(rel.Sym.Name, int(rel.Sym.Version)),
- }
- }
- rel := goobj2.Reloc{}
- rel.Read(relocs.r.Reader, relocs.r.RelocOff(relocs.li, j))
- target := relocs.l.resolve(relocs.r, rel.Sym)
- return Reloc{
- Off: rel.Off,
- Size: rel.Siz,
- Type: objabi.RelocType(rel.Type),
- Add: rel.Add,
- Sym: target,
- }
+ panic("unreachable")
}
// ReadAll method reads all relocations for a symbol into the
// specified slice. If the slice capacity is not large enough, a new
// larger slice will be allocated. Final slice is returned.
func (relocs *Relocs) ReadAll(dst []Reloc) []Reloc {
- if relocs.Count == 0 {
- return dst[:0]
- }
-
- if cap(dst) < relocs.Count {
- dst = make([]Reloc, relocs.Count)
- }
- dst = dst[:0]
-
- if relocs.ext != nil {
- for i := 0; i < relocs.Count; i++ {
- erel := &relocs.ext.R[i]
- rel := Reloc{
- Off: erel.Off,
- Size: erel.Siz,
- Type: erel.Type,
- Add: erel.Add,
- Sym: relocs.l.Lookup(erel.Sym.Name, int(erel.Sym.Version)),
- }
- dst = append(dst, rel)
- }
- return dst
- }
-
- off := relocs.r.RelocOff(relocs.li, 0)
- for i := 0; i < relocs.Count; i++ {
- rel := goobj2.Reloc{}
- rel.Read(relocs.r.Reader, off)
- off += uint32(rel.Size())
- target := relocs.l.resolve(relocs.r, rel.Sym)
- dst = append(dst, Reloc{
- Off: rel.Off,
- Size: rel.Siz,
- Type: objabi.RelocType(rel.Type),
- Add: rel.Add,
- Sym: target,
- })
- }
- return dst
+ panic("unreachable")
}
// Relocs returns a Relocs object for the given global sym.
func (l *Loader) Relocs(i Sym) Relocs {
- if l.IsExternal(i) {
- if s := l.Syms[i]; s != nil {
- return Relocs{Count: len(s.R), l: l, ext: s}
- }
- return Relocs{}
- }
- r, li := l.toLocal(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 {
- return Relocs{
- Count: r.NReloc(li),
- li: li,
- r: r,
- l: l,
- }
+ panic("unreachable")
}
// Preload a package: add autolibs, add symbols to the symbol table.
// Does not read symbol data yet.
func (l *Loader) Preload(arch *sys.Arch, syms *sym.Symbols, f *bio.Reader, lib *sym.Library, unit *sym.CompilationUnit, length int64, pn string, flags int) {
- 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 {
- panic("cannot read object file")
- }
- localSymVersion := syms.IncVersion()
- pkgprefix := objabi.PathToPrefix(lib.Pkg) + "."
- or := &oReader{r, unit, localSymVersion, r.Flags(), pkgprefix, nil}
-
- // Autolib
- lib.ImportStrings = append(lib.ImportStrings, r.Autolib()...)
-
- // DWARF file table
- nfile := r.NDwarfFile()
- unit.DWARFFileTable = make([]string, nfile)
- for i := range unit.DWARFFileTable {
- unit.DWARFFileTable[i] = r.DwarfFile(i)
- }
-
- istart := l.addObj(lib.Pkg, or)
-
- ndef := r.NSym()
- nnonpkgdef := r.NNonpkgdef()
- for i, n := 0, ndef+nnonpkgdef; i < n; i++ {
- osym := goobj2.Sym{}
- osym.Read(r, r.SymOff(i))
- name := strings.Replace(osym.Name, "\"\".", pkgprefix, -1)
- if name == "" {
- continue // don't add unnamed aux symbol
- }
- v := abiToVer(osym.ABI, localSymVersion)
- dupok := osym.Dupok()
- added := l.AddSym(name, v, istart+Sym(i), or, dupok, sym.AbiSymKindToSymKind[objabi.SymKind(osym.Type)])
- if added && strings.HasPrefix(name, "go.itablink.") {
- l.itablink[istart+Sym(i)] = struct{}{}
- }
- if added && 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] = istart + Sym(i)
- }
- }
- }
-
- // The caller expects us consuming all the data
- f.MustSeek(length, os.SEEK_CUR)
+ panic("unreachable")
}
// Make sure referenced symbols are added. Most of them should already be added.
@@ -738,28 +367,11 @@
}
func loadObjRefs(l *Loader, r *oReader, arch *sys.Arch, syms *sym.Symbols) {
- ndef := r.NSym() + r.NNonpkgdef()
- for i, n := 0, r.NNonpkgref(); i < n; i++ {
- osym := goobj2.Sym{}
- osym.Read(r.Reader, r.SymOff(ndef+i))
- name := strings.Replace(osym.Name, "\"\".", r.pkgprefix, -1)
- v := abiToVer(osym.ABI, r.version)
- l.AddExtSym(name, v)
- }
+ panic("unreachable")
}
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
+ panic("unreachable")
}
func preprocess(arch *sys.Arch, s *sym.Symbol) {
@@ -885,90 +497,14 @@
// 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 {
- istart := l.startIndex(r)
- nr := 0
-
- for i, n := 0, r.NSym()+r.NNonpkgdef(); i < n; i++ {
- // If it's been previously loaded in host object loading, we don't need to do it again.
- if s := l.Syms[istart+Sym(i)]; s != nil {
- // Mark symbol as reachable as it wasn't marked as such before.
- s.Attr.Set(sym.AttrReachable, l.Reachable.Has(istart+Sym(i)))
- nr += r.NReloc(i)
- continue
- }
- osym := goobj2.Sym{}
- osym.Read(r.Reader, r.SymOff(i))
- name := strings.Replace(osym.Name, "\"\".", r.pkgprefix, -1)
- if name == "" {
- continue
- }
- ver := abiToVer(osym.ABI, r.version)
- if osym.ABI != goobj2.SymABIstatic && l.symsByName[ver][name] != istart+Sym(i) {
- continue
- }
-
- t := sym.AbiSymKindToSymKind[objabi.SymKind(osym.Type)]
- 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.Reachable.Has(istart+Sym(i)) && !(t == sym.SRODATA && strings.HasPrefix(name, "type.")) && name != "runtime.addmoduledata" && name != "runtime.lastmoduledatap" {
- // No need to load unreachable symbols.
- // XXX some type symbol's content may be needed in DWARF code, but they are not marked.
- // XXX reference to runtime.addmoduledata may be generated later by the linker in plugin mode.
- continue
- }
-
- s := l.addNewSym(istart+Sym(i), syms, name, ver, r.unit, t)
- s.Attr.Set(sym.AttrReachable, l.Reachable.Has(istart+Sym(i)))
- nr += r.NReloc(i)
- }
- return nr
-}
-
-// funcInfoSym records the sym.Symbol for a function, along with a copy
-// of the corresponding goobj2.Sym and the index of its FuncInfo aux sym.
-// We use this to delay populating FuncInfo until we can batch-allocate
-// slices for their sub-objects.
-type funcInfoSym struct {
- s *sym.Symbol // sym.Symbol for a live function
- osym goobj2.Sym // object file symbol data for that function
- isym int // global symbol index of FuncInfo aux sym for func
-}
-
-// funcAllocInfo records totals/counts for all functions in an objfile;
-// used to help with bulk allocation of sym.Symbol sub-objects.
-type funcAllocInfo struct {
- symPtr uint32 // number of *sym.Symbol's needed in file slices
- inlCall uint32 // number of sym.InlinedCall's needed in inltree slices
- pcData uint32 // number of sym.Pcdata's needed in pdata slices
- fdOff uint32 // number of int64's needed in all Funcdataoff slices
+ panic("unreachable")
}
// LoadSymbol loads a single symbol by name.
// This function should only be used by the host object loaders.
// NB: This function does NOT set the symbol as reachable.
func (l *Loader) LoadSymbol(name string, version int, syms *sym.Symbols) *sym.Symbol {
- global := l.Lookup(name, version)
-
- // If we're already loaded, bail.
- if global != 0 && int(global) < len(l.Syms) && l.Syms[global] != nil {
- return l.Syms[global]
- }
-
- // Read the symbol.
- r, i := l.toLocal(global)
- istart := l.startIndex(r)
-
- osym := goobj2.Sym{}
- osym.Read(r.Reader, r.SymOff(int(i)))
- if l.symsByName[version][name] != istart+Sym(i) {
- return nil
- }
-
- return l.addNewSym(istart+Sym(i), syms, name, version, r.unit, sym.AbiSymKindToSymKind[objabi.SymKind(osym.Type)])
+ panic("unreachable")
}
// LookupOrCreate looks up a symbol by name, and creates one if not found.
@@ -1023,264 +559,7 @@
}
func loadObjFull(l *Loader, r *oReader) {
- lib := r.unit.Lib
- istart := l.startIndex(r)
-
- resolveSymRef := func(s goobj2.SymRef) *sym.Symbol {
- i := l.resolve(r, s)
- return l.Syms[i]
- }
-
- funcs := []funcInfoSym{}
- fdsyms := []*sym.Symbol{}
- var funcAllocCounts funcAllocInfo
- pcdataBase := r.PcdataBase()
- rslice := []Reloc{}
- for i, n := 0, r.NSym()+r.NNonpkgdef(); i < n; i++ {
- osym := goobj2.Sym{}
- osym.Read(r.Reader, r.SymOff(i))
- name := strings.Replace(osym.Name, "\"\".", r.pkgprefix, -1)
- if name == "" {
- continue
- }
- ver := abiToVer(osym.ABI, r.version)
- dupok := osym.Dupok()
- if dupok {
- if dupsym := l.symsByName[ver][name]; dupsym != istart+Sym(i) {
- if l.Reachable.Has(dupsym) {
- // A dupok 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.
- s := l.Syms[dupsym]
- if s.Type == sym.STEXT {
- lib.DupTextSyms = append(lib.DupTextSyms, s)
- }
- }
- continue
- }
- }
-
- s := l.Syms[istart+Sym(i)]
- if s == nil {
- continue
- }
- if s.Name != name { // Sanity check. We can remove it in the final version.
- fmt.Println("name mismatch:", lib, i, s.Name, name)
- panic("name mismatch")
- }
-
- local := osym.Local()
- makeTypelink := osym.Typelink()
- size := osym.Siz
-
- // Symbol data
- s.P = r.Data(i)
- s.Attr.Set(sym.AttrReadOnly, r.ReadOnly())
-
- // Relocs
- relocs := l.relocs(r, i)
- rslice = relocs.ReadAll(rslice)
- batch := l.relocBatch
- s.R = batch[:relocs.Count:relocs.Count]
- l.relocBatch = batch[relocs.Count:]
- for j := range s.R {
- r := rslice[j]
- rs := r.Sym
- sz := r.Size
- rt := r.Type
- if rt == objabi.R_METHODOFF {
- if l.Reachable.Has(rs) {
- rt = objabi.R_ADDROFF
- } else {
- sz = 0
- rs = 0
- }
- }
- if rt == objabi.R_WEAKADDROFF && !l.Reachable.Has(rs) {
- rs = 0
- sz = 0
- }
- if rs != 0 && l.SymType(rs) == sym.SABIALIAS {
- rsrelocs := l.Relocs(rs)
- rs = rsrelocs.At(0).Sym
- }
- s.R[j] = sym.Reloc{
- Off: r.Off,
- Siz: sz,
- Type: rt,
- Add: r.Add,
- Sym: l.Syms[rs],
- }
- }
-
- // Aux symbol info
- isym := -1
- naux := r.NAux(i)
- for j := 0; j < naux; j++ {
- a := goobj2.Aux{}
- a.Read(r.Reader, r.AuxOff(i, j))
- switch a.Type {
- case goobj2.AuxGotype:
- typ := resolveSymRef(a.Sym)
- if typ != nil {
- s.Gotype = typ
- }
- case goobj2.AuxFuncdata:
- fdsyms = append(fdsyms, resolveSymRef(a.Sym))
- case goobj2.AuxFuncInfo:
- if a.Sym.PkgIdx != goobj2.PkgIdxSelf {
- panic("funcinfo symbol not defined in current package")
- }
- isym = int(a.Sym.SymIdx)
- 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 dupok {
- s.Attr |= sym.AttrDuplicateOK
- }
- if s.Size < int64(size) {
- s.Size = int64(size)
- }
- s.Attr.Set(sym.AttrLocal, local)
- s.Attr.Set(sym.AttrMakeTypelink, makeTypelink)
-
- if s.Type == sym.SDWARFINFO {
- // For DWARF symbols, replace `"".` to actual package prefix
- // in the symbol content.
- // TODO: maybe we should do this in the compiler and get rid
- // of this.
- patchDWARFName(s, r)
- }
-
- if s.Type != sym.STEXT {
- continue
- }
-
- if isym == -1 {
- continue
- }
-
- // Record function sym and associated info for additional
- // processing in the loop below.
- fwis := funcInfoSym{s: s, isym: isym, osym: osym}
- funcs = append(funcs, fwis)
-
- // Read the goobj2.FuncInfo for this text symbol so that we can
- // collect allocation counts. We'll read it again in the loop
- // below.
- b := r.Data(isym)
- info := goobj2.FuncInfo{}
- info.Read(b)
- funcAllocCounts.symPtr += uint32(len(info.File))
- funcAllocCounts.pcData += uint32(len(info.Pcdata))
- funcAllocCounts.inlCall += uint32(len(info.InlTree))
- funcAllocCounts.fdOff += uint32(len(info.Funcdataoff))
- }
-
- // At this point we can do batch allocation of the sym.FuncInfo's,
- // along with the slices of sub-objects they use.
- fiBatch := make([]sym.FuncInfo, len(funcs))
- inlCallBatch := make([]sym.InlinedCall, funcAllocCounts.inlCall)
- symPtrBatch := make([]*sym.Symbol, funcAllocCounts.symPtr)
- pcDataBatch := make([]sym.Pcdata, funcAllocCounts.pcData)
- fdOffBatch := make([]int64, funcAllocCounts.fdOff)
-
- // Populate FuncInfo contents for func symbols.
- for fi := 0; fi < len(funcs); fi++ {
- s := funcs[fi].s
- isym := funcs[fi].isym
- osym := funcs[fi].osym
-
- s.FuncInfo = &fiBatch[0]
- fiBatch = fiBatch[1:]
-
- b := r.Data(isym)
- info := goobj2.FuncInfo{}
- info.Read(b)
-
- if osym.NoSplit() {
- s.Attr |= sym.AttrNoSplit
- }
- if osym.ReflectMethod() {
- s.Attr |= sym.AttrReflectMethod
- }
- if r.Flags()&goobj2.ObjFlagShared != 0 {
- s.Attr |= sym.AttrShared
- }
- if osym.TopFrame() {
- s.Attr |= sym.AttrTopFrame
- }
-
- pc := s.FuncInfo
-
- if len(info.Funcdataoff) != 0 {
- nfd := len(info.Funcdataoff)
- pc.Funcdata = fdsyms[:nfd:nfd]
- fdsyms = fdsyms[nfd:]
- }
-
- info.Pcdata = append(info.Pcdata, info.PcdataEnd) // for the ease of knowing where it ends
- pc.Args = int32(info.Args)
- pc.Locals = int32(info.Locals)
-
- npc := len(info.Pcdata) - 1 // -1 as we appended one above
- pc.Pcdata = pcDataBatch[:npc:npc]
- pcDataBatch = pcDataBatch[npc:]
-
- nfd := len(info.Funcdataoff)
- pc.Funcdataoff = fdOffBatch[:nfd:nfd]
- fdOffBatch = fdOffBatch[nfd:]
-
- nsp := len(info.File)
- pc.File = symPtrBatch[:nsp:nsp]
- symPtrBatch = symPtrBatch[nsp:]
-
- nic := len(info.InlTree)
- pc.InlTree = inlCallBatch[:nic:nic]
- inlCallBatch = inlCallBatch[nic:]
-
- pc.Pcsp.P = r.BytesAt(pcdataBase+info.Pcsp, int(info.Pcfile-info.Pcsp))
- pc.Pcfile.P = r.BytesAt(pcdataBase+info.Pcfile, int(info.Pcline-info.Pcfile))
- pc.Pcline.P = r.BytesAt(pcdataBase+info.Pcline, int(info.Pcinline-info.Pcline))
- pc.Pcinline.P = r.BytesAt(pcdataBase+info.Pcinline, int(info.Pcdata[0]-info.Pcinline))
- for k := range pc.Pcdata {
- pc.Pcdata[k].P = r.BytesAt(pcdataBase+info.Pcdata[k], int(info.Pcdata[k+1]-info.Pcdata[k]))
- }
- for k := range pc.Funcdataoff {
- pc.Funcdataoff[k] = int64(info.Funcdataoff[k])
- }
- for k := range pc.File {
- pc.File[k] = resolveSymRef(info.File[k])
- }
- for k := range pc.InlTree {
- inl := &info.InlTree[k]
- pc.InlTree[k] = sym.InlinedCall{
- Parent: inl.Parent,
- File: resolveSymRef(inl.File),
- Line: inl.Line,
- Func: l.SymName(l.resolve(r, inl.Func)),
- ParentPC: inl.ParentPC,
- }
- }
-
- dupok := osym.Dupok()
- if !dupok {
- if s.Attr.OnList() {
- log.Fatalf("symbol %s listed multiple times", s.Name)
- }
- s.Attr.Set(sym.AttrOnList, true)
- lib.Textp = append(lib.Textp, s)
- } else {
- // there may be a dup in another package
- // put into a temp list and add to text later
- lib.DupTextSyms = append(lib.DupTextSyms, s)
- }
- }
+ panic("unreachable")
}
var emptyPkg = []byte(`"".`)
