From: Cherry Zhang Date: Wed, 26 Feb 2020 05:58:29 +0000 (-0500) Subject: [dev.link] cmd/link: remove sym.Symbols lookup map X-Git-Tag: go1.15beta1~679^2~106 X-Git-Url: http://www.git.cypherpunks.su/?a=commitdiff_plain;h=5ee515fd8ced40265bd98b1b5d16100f831929f1;p=gostls13.git [dev.link] cmd/link: remove sym.Symbols lookup map Let the loader provide lookup functionalities. Change-Id: I7d90166d12e6e6fd30e75cbda5d3097e93f9af1e Reviewed-on: https://go-review.googlesource.com/c/go/+/221137 Run-TryBot: Cherry Zhang TryBot-Result: Gobot Gobot Reviewed-by: Jeremy Faller Reviewed-by: Than McIntosh --- diff --git a/src/cmd/link/internal/loader/loader.go b/src/cmd/link/internal/loader/loader.go index bf7e314977..56d13db805 100644 --- a/src/cmd/link/internal/loader/loader.go +++ b/src/cmd/link/internal/loader/loader.go @@ -259,7 +259,7 @@ func NewLoader(flags uint32, elfsetstring elfsetstringFunc) *Loader { objs: []objIdx{{}}, // reserve index 0 for nil symbol objSyms: []objSym{{}}, // reserve index 0 for nil symbol extReader: &oReader{}, - symsByName: [2]map[string]Sym{make(map[string]Sym), make(map[string]Sym)}, + symsByName: [2]map[string]Sym{make(map[string]Sym, 100000), make(map[string]Sym, 50000)}, // preallocate ~2MB for ABI0 and ~1MB for ABI1 symbols objByPkg: make(map[string]*oReader), outer: make(map[Sym]Sym), sub: make(map[Sym]Sym), @@ -1817,11 +1817,7 @@ func (l *Loader) ExtractSymbols(syms *sym.Symbols, rp map[*sym.Symbol]*sym.Symbo if s == nil { continue } - if s.Name != "" && s.Version >= 0 { - syms.Add(s) - } else { - syms.Allsym = append(syms.Allsym, s) - } + syms.Allsym = append(syms.Allsym, s) // XXX still add to Allsym for now, as there are code looping through Allsym if s.Version < 0 { s.Version = int16(anonVerReplacement) } @@ -1833,6 +1829,52 @@ func (l *Loader) ExtractSymbols(syms *sym.Symbols, rp map[*sym.Symbol]*sym.Symbo } rp[l.Syms[i]] = l.Syms[s] } + + // Provide lookup functions for sym.Symbols. + syms.Lookup = func(name string, ver int) *sym.Symbol { + i := l.LookupOrCreateSym(name, ver) + if s := l.Syms[i]; s != nil { + return s + } + s := l.allocSym(name, ver) + l.installSym(i, s) + syms.Allsym = append(syms.Allsym, s) // XXX see above + return s + } + syms.ROLookup = func(name string, ver int) *sym.Symbol { + i := l.Lookup(name, ver) + return l.Syms[i] + } + syms.Rename = func(old, new string, ver int) { + // annoying... maybe there is a better way to do this + if ver >= 2 { + panic("cannot rename static symbol") + } + i := l.Lookup(old, ver) + s := l.Syms[i] + s.Name = new + if s.Extname() == old { + s.SetExtname(new) + } + delete(l.symsByName[ver], old) + + // This mirrors the old code. But I'm not sure if the logic of + // handling dup in the old code actually works, or necessary. + dupi := l.symsByName[ver][new] + dup := l.Syms[dupi] + if dup == nil { + l.symsByName[ver][new] = i + } else { + if s.Type == 0 { + dup.Attr |= s.Attr + *s = *dup + } else if dup.Type == 0 { + s.Attr |= dup.Attr + *dup = *s + l.symsByName[ver][new] = i + } + } + } } // allocSym allocates a new symbol backing. diff --git a/src/cmd/link/internal/sym/symbols.go b/src/cmd/link/internal/sym/symbols.go index d52211ed2b..e64779da9c 100644 --- a/src/cmd/link/internal/sym/symbols.go +++ b/src/cmd/link/internal/sym/symbols.go @@ -31,100 +31,34 @@ package sym type Symbols struct { - symbolBatch []Symbol - // Symbol lookup based on name and indexed by version. - hash []map[string]*Symbol + versions int Allsym []*Symbol -} - -func NewSymbols() *Symbols { - hash := make([]map[string]*Symbol, SymVerStatic) - // Preallocate about 2mb for hash of non static symbols - hash[0] = make(map[string]*Symbol, 100000) - // And another 1mb for internal ABI text symbols. - hash[SymVerABIInternal] = make(map[string]*Symbol, 50000) - return &Symbols{ - hash: hash, - Allsym: make([]*Symbol, 0, 100000), - } -} -func (syms *Symbols) Newsym(name string, v int) *Symbol { - batch := syms.symbolBatch - if len(batch) == 0 { - batch = make([]Symbol, 1000) - } - s := &batch[0] - syms.symbolBatch = batch[1:] + // Provided by the loader - s.Dynid = -1 - s.Name = name - s.Version = int16(v) - syms.Allsym = append(syms.Allsym, s) + // Look up the symbol with the given name and version, creating the + // symbol if it is not found. + Lookup func(name string, v int) *Symbol - return s -} + // Look up the symbol with the given name and version, returning nil + // if it is not found. + ROLookup func(name string, v int) *Symbol -// Look up the symbol with the given name and version, creating the -// symbol if it is not found. -func (syms *Symbols) Lookup(name string, v int) *Symbol { - m := syms.hash[v] - s := m[name] - if s != nil { - return s - } - s = syms.Newsym(name, v) - m[name] = s - return s + // Rename renames a symbol. + Rename func(old, new string, v int) } -// Look up the symbol with the given name and version, returning nil -// if it is not found. -func (syms *Symbols) ROLookup(name string, v int) *Symbol { - return syms.hash[v][name] -} - -// Add an existing symbol to the symbol table. -func (syms *Symbols) Add(s *Symbol) { - name := s.Name - v := int(s.Version) - m := syms.hash[v] - if _, ok := m[name]; ok { - panic(name + " already added") +func NewSymbols() *Symbols { + return &Symbols{ + versions: SymVerStatic, + Allsym: make([]*Symbol, 0, 100000), } - m[name] = s - syms.Allsym = append(syms.Allsym, s) } // Allocate a new version (i.e. symbol namespace). func (syms *Symbols) IncVersion() int { - syms.hash = append(syms.hash, make(map[string]*Symbol)) - return len(syms.hash) - 1 -} - -// Rename renames a symbol. -func (syms *Symbols) Rename(old, new string, v int) { - s := syms.hash[v][old] - oldExtName := s.Extname() - s.Name = new - if oldExtName == old { - s.SetExtname(new) - } - delete(syms.hash[v], old) - - dup := syms.hash[v][new] - if dup == nil { - syms.hash[v][new] = s - } else { - if s.Type == 0 { - dup.Attr |= s.Attr - *s = *dup - } else if dup.Type == 0 { - s.Attr |= dup.Attr - *dup = *s - syms.hash[v][new] = s - } - } + syms.versions++ + return syms.versions - 1 }