Stowage/go
2
0
Fork 0
mirror of https://github.com/golang/go.git synced 2025-12-08 06:10:04 +00:00
Code Issues Projects Releases Packages Wiki Activity

[dev.link] cmd/link: create sym.Symbols after deadcode in newobj mode

Browse source 
With the new object files, now we can run the deadcode pass on
indices instead of Symbol structs, so we can delay creating
Symbols after the deadcode pass. Then we only need to create
reachable symbols.

Not create Symbols in LoadNew and LoadRefs, and recombine
LoadReloc into LoadFull.

Split loadcgo into two parts: the first finds root symbols, the
second create Symbols and sets attributes. The first runs before
the deadcode pass, while the second runs after.

TODO: currently there are still symbols that are not marked
reachable but still used. This includes DWARF symbols, file
symbols, and type symbols that are referenced by DWARF symbols.
We still need to create them (conservatively).

Change-Id: I695779c9312be9d49ab1683957ac3e72e1f65a1e
Reviewed-on: https://go-review.googlesource.com/c/go/+/199643
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
This commit is contained in:
Cherry Zhang 2019-10-04 22:05:41 -04:00
parent 90fe9c7c5c
commit cab29ebd84
6 changed files with 217 additions and 238 deletions
Download patch file Download diff file Expand all files Collapse all files

221
src/cmd/link/internal/objfile/objfile2.go
View file

@ -94,6 +94,7 @@ type Loader struct {
objs []objIdx // sorted by start index (i.e. objIdx.i)
max Sym // current max index
extStart Sym // from this index on, the symbols are externally defined
extSyms []nameVer // externally defined symbols
symsByName map[nameVer]Sym // map symbol name to index
@ -110,7 +111,6 @@ func NewLoader() *Loader {
objs: []objIdx{{nil, 0}},
symsByName: make(map[nameVer]Sym),
objByPkg: make(map[string]*oReader),
Syms: []*sym.Symbol{nil},
}
}
@ -165,6 +165,7 @@ func (l *Loader) AddExtSym(name string, ver int) Sym {
if l.extStart == 0 {
l.extStart = i
}
l.extSyms = append(l.extSyms, nv)
return i
}
@ -379,9 +380,6 @@ func LoadNew(l *Loader, arch *sys.Arch, syms *sym.Symbols, f *bio.Reader, lib *s
ndef := r.NSym()
nnonpkgdef := r.NNonpkgdef()
// XXX add all symbols for now
l.Syms = append(l.Syms, make([]*sym.Symbol, ndef+nnonpkgdef)...)
for i, n := 0, ndef+nnonpkgdef; i < n; i++ {
osym := goobj2.Sym{}
osym.Read(r, r.SymOff(i))
@ -391,11 +389,7 @@ func LoadNew(l *Loader, arch *sys.Arch, syms *sym.Symbols, f *bio.Reader, lib *s
}
v := abiToVer(osym.ABI, localSymVersion)
dupok := osym.Flag&goobj2.SymFlagDupok != 0
if l.AddSym(name, v, istart+Sym(i), dupok) {
s := syms.Newsym(name, v)
preprocess(arch, s) // TODO: put this at a better place
l.Syms[istart+Sym(i)] = s
}
l.AddSym(name, v, istart+Sym(i), dupok)
}
// The caller expects us consuming all the data
@ -411,22 +405,13 @@ func LoadRefs(l *Loader, arch *sys.Arch, syms *sym.Symbols) {
}
func loadObjRefs(l *Loader, r *oReader, arch *sys.Arch, syms *sym.Symbols) {
lib := r.unit.Lib
pkgprefix := objabi.PathToPrefix(lib.Pkg) + "."
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, "\"\".", pkgprefix, -1)
name := strings.Replace(osym.Name, "\"\".", r.pkgprefix, -1)
v := abiToVer(osym.ABI, r.version)
if ii := l.AddExtSym(name, v); ii != 0 {
s := syms.Newsym(name, v)
preprocess(arch, s) // TODO: put this at a better place
if ii != Sym(len(l.Syms)) {
panic("AddExtSym returned bad index")
}
l.Syms = append(l.Syms, s)
}
l.AddExtSym(name, v)
}
}
@ -463,45 +448,47 @@ func preprocess(arch *sys.Arch, s *sym.Symbol) {
default:
log.Panicf("unrecognized $-symbol: %s", s.Name)
}
s.Attr.Set(sym.AttrReachable, false)
}
}
// Load relocations for building the dependency graph in deadcode pass.
// For now, we load symbol types, relocations, gotype, and the contents
// of type symbols, which are needed in deadcode.
func LoadReloc(l *Loader) {
// Load full contents.
func LoadFull(l *Loader, arch *sys.Arch, syms *sym.Symbols) {
// create all Symbols first.
l.Syms = make([]*sym.Symbol, l.NSym())
for _, o := range l.objs[1:] {
loadObjReloc(l, o.r)
loadObjSyms(l, syms, o.r)
}
// external symbols
for i := l.extStart; i <= l.max; i++ {
nv := l.extSyms[i-l.extStart]
if l.Reachable.Has(i) || strings.HasPrefix(nv.name, "go.info.") || strings.HasPrefix(nv.name, "gofile..") { // XXX some go.info and file symbols are used but not marked
s := syms.Newsym(nv.name, nv.v)
preprocess(arch, s)
s.Attr.Set(sym.AttrReachable, true)
l.Syms[i] = s
}
}
// load contents of defined symbols
for _, o := range l.objs[1:] {
loadObjFull(l, o.r)
}
}
func loadObjReloc(l *Loader, r *oReader) {
func loadObjSyms(l *Loader, syms *sym.Symbols, r *oReader) {
lib := r.unit.Lib
pkgprefix := objabi.PathToPrefix(lib.Pkg) + "."
istart := l.StartIndex(r)
resolveSymRef := func(s goobj2.SymRef) *sym.Symbol {
i := l.Resolve(r, s)
return l.Syms[i]
}
for i, n := 0, r.NSym()+r.NNonpkgdef(); i < n; i++ {
s := l.Syms[istart+Sym(i)]
if s == nil || s.Name == "" {
continue
}
osym := goobj2.Sym{}
osym.Read(r.Reader, r.SymOff(i))
name := strings.Replace(osym.Name, "\"\".", pkgprefix, -1)
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")
name := strings.Replace(osym.Name, "\"\".", r.pkgprefix, -1)
if name == "" {
continue
}
if s.Type != 0 && s.Type != sym.SXREF {
// We've already seen this symbol, it likely came from a host object.
ver := abiToVer(osym.ABI, r.version)
if l.symsByName[nameVer{name, ver}] != istart+Sym(i) {
continue
}
@ -510,19 +497,63 @@ func loadObjReloc(l *Loader, r *oReader) {
log.Fatalf("bad sxref")
}
if t == 0 {
log.Fatalf("missing type for %s in %s", s.Name, lib)
log.Fatalf("missing type for %s in %s", name, lib)
}
if !s.Attr.Reachable() && (t < sym.SDWARFSECT || t > sym.SDWARFLINES) && !(t == sym.SRODATA && strings.HasPrefix(name, "type.")) {
if !l.Reachable.Has(istart+Sym(i)) && (t < sym.SDWARFSECT || t > sym.SDWARFLINES) && !(t == sym.SRODATA && strings.HasPrefix(name, "type.")) && name != "runtime.addmoduledata" && name != "runtime.lastmoduledatap" {
// No need to load unreachable symbols.
// XXX DWARF symbols may be used but are not marked reachable.
// XXX 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 := syms.Newsym(name, ver)
if s.Type != 0 && s.Type != sym.SXREF {
fmt.Println("symbol already processed:", lib, i, s)
panic("symbol already processed")
}
if t == sym.SBSS && (s.Type == sym.SRODATA || s.Type == sym.SNOPTRBSS) {
t = s.Type
}
s.Type = t
s.Unit = r.unit
s.Attr.Set(sym.AttrReachable, l.Reachable.Has(istart+Sym(i)))
l.Syms[istart+Sym(i)] = s
}
}
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]
}
pcdataBase := r.PcdataBase()
for i, n := 0, r.NSym()+r.NNonpkgdef(); i < n; i++ {
s := l.Syms[istart+Sym(i)]
if s == nil || s.Name == "" {
continue
}
osym := goobj2.Sym{}
osym.Read(r.Reader, r.SymOff(i))
name := strings.Replace(osym.Name, "\"\".", r.pkgprefix, -1)
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")
}
dupok := osym.Flag&goobj2.SymFlagDupok != 0
local := osym.Flag&goobj2.SymFlagLocal != 0
makeTypelink := osym.Flag&goobj2.SymFlagTypelink != 0
size := osym.Siz
// Symbol data
s.P = r.Data(i)
s.Attr.Set(sym.AttrReadOnly, r.ReadOnly())
// Relocs
relocs := l.relocs(r, i)
@ -557,7 +588,8 @@ func loadObjReloc(l *Loader, r *oReader) {
}
}
// Aux symbol
// Aux symbol info
isym := -1
naux := r.NAux(i)
for j := 0; j < naux; j++ {
a := goobj2.Aux{}
@ -575,85 +607,6 @@ func loadObjReloc(l *Loader, r *oReader) {
s.FuncInfo = pc
}
pc.Funcdata = append(pc.Funcdata, resolveSymRef(a.Sym))
}
}
if s.Type == sym.STEXT {
dupok := osym.Flag&goobj2.SymFlagDupok != 0
if !dupok {
if s.Attr.OnList() {
log.Fatalf("symbol %s listed multiple times", s.Name)
}
s.Attr |= sym.AttrOnList
lib.Textp = append(lib.Textp, s)
} else {
// there may ba a dup in another package
// put into a temp list and add to text later
lib.DupTextSyms = append(lib.DupTextSyms, s)
}
}
}
}
// Load full contents.
// TODO: For now, some contents are already load in LoadReloc. Maybe
// we should combine LoadReloc back into this, once we rewrite deadcode
// pass to use index directly.
func LoadFull(l *Loader) {
for _, o := range l.objs[1:] {
loadObjFull(l, o.r)
}
}
func loadObjFull(l *Loader, r *oReader) {
lib := r.unit.Lib
pkgprefix := objabi.PathToPrefix(lib.Pkg) + "."
istart := l.StartIndex(r)
resolveSymRef := func(s goobj2.SymRef) *sym.Symbol {
i := l.Resolve(r, s)
return l.Syms[i]
}
pcdataBase := r.PcdataBase()
for i, n := 0, r.NSym()+r.NNonpkgdef(); i < n; i++ {
s := l.Syms[istart+Sym(i)]
if s == nil || s.Name == "" {
continue
}
if !s.Attr.Reachable() && (s.Type < sym.SDWARFSECT || s.Type > sym.SDWARFLINES) && !(s.Type == sym.SRODATA && strings.HasPrefix(s.Name, "type.")) {
// No need to load unreachable symbols.
// XXX DWARF symbols may be used but are not marked reachable.
// XXX type symbol's content may be needed in DWARF code, but they are not marked.
continue
}
osym := goobj2.Sym{}
osym.Read(r.Reader, r.SymOff(i))
name := strings.Replace(osym.Name, "\"\".", pkgprefix, -1)
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")
}
dupok := osym.Flag&goobj2.SymFlagDupok != 0
local := osym.Flag&goobj2.SymFlagLocal != 0
makeTypelink := osym.Flag&goobj2.SymFlagTypelink != 0
size := osym.Siz
// Symbol data
s.P = r.Data(i)
s.Attr.Set(sym.AttrReadOnly, r.ReadOnly())
// 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, goobj2.AuxFuncdata:
// already loaded
case goobj2.AuxFuncInfo:
if a.Sym.PkgIdx != goobj2.PkgIdxSelf {
panic("funcinfo symbol not defined in current package")
@ -664,7 +617,7 @@ func loadObjFull(l *Loader, r *oReader) {
}
}
s.File = pkgprefix[:len(pkgprefix)-1]
s.File = r.pkgprefix[:len(r.pkgprefix)-1]
if dupok {
s.Attr |= sym.AttrDuplicateOK
}
@ -731,6 +684,18 @@ func loadObjFull(l *Loader, r *oReader) {
for k := range pc.File {
pc.File[k] = resolveSymRef(info.File[k])
}
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 ba a dup in another package
// put into a temp list and add to text later
lib.DupTextSyms = append(lib.DupTextSyms, s)
}
}
}