1 files changed, 21 insertions, 85 deletions

diff --git a/src/cmd/link/internal/sym/symbols.go b/src/cmd/link/internal/sym/symbols.go
index e772496534..d36be11ee8 100644
--- a/src/cmd/link/internal/sym/symbols.go
+++ b/src/cmd/link/internal/sym/symbols.go
@@ -31,105 +31,41 @@
 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),
-	}
-}
+	// Provided by the loader
 
-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:]
+	// 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
 
-	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, returning nil
+	// if it is not found.
+	ROLookup func(name string, v int) *Symbol
 
-	return s
+	// Create a symbol with the given name and version. The new symbol
+	// is not added to the lookup table and is not dedup'd with existing
+	// symbols (if any).
+	Newsym 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
-}
-
-// 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
 }
 
 // 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
+	syms.versions++
+	return syms.versions - 1
 }
 
-// Rename renames a symbol.
-func (syms *Symbols) Rename(old, new string, v int, reachparent map[*Symbol]*Symbol) {
-	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
-			if s.Attr.Reachable() && reachparent != nil {
-				reachparent[dup] = reachparent[s]
-			}
-			*s = *dup
-		} else if dup.Type == 0 {
-			s.Attr |= dup.Attr
-			if dup.Attr.Reachable() && reachparent != nil {
-				reachparent[s] = reachparent[dup]
-			}
-			*dup = *s
-			syms.hash[v][new] = s
-		}
-	}
+// returns the maximum version number
+func (syms *Symbols) MaxVersion() int {
+	return syms.versions
 }