Remove SymbolTable::addBitcode as it is redundant.

[ruiu]

Summary

Remove SymbolTable::addBitcode as it is redundant.

[grimar]

LGTM.

lld/ELF/InputFiles.cpp

if (ObjSym.isCommon()) {
     CommonSymbol New(&F, Name, Binding, Visibility, STT_OBJECT,
                      ObjSym.getCommonAlignment(), ObjSym.getCommonSize());
     return Symtab->addCommon(&New);
   }
 
   Defined New(&F, Name, Binding, Visibility, Type, 0, 0, nullptr);
   if (CanOmitFromDynSym)
     New.ExportDynamic = false;
-  return Symtab->addBitcode(&New);
+  return Symtab->addDefined(&New);
 }
 
 template <class ELFT>
 void BitcodeFile::parse(DenseSet<CachedHashStringRef> &ComdatGroups) {
   std::vector<bool> KeptComdats;
   for (StringRef S : Obj->getComdatTable())
     KeptComdats.push_back(ComdatGroups.insert(CachedHashStringRef(S)).second);
 

lld/ELF/SymbolTable.h

 // is one add* function per symbol type.
 class SymbolTable {
 public:
   template <class ELFT> void addCombinedLTOObject();
   void wrap(Symbol *Sym, Symbol *Real, Symbol *Wrap);
 
   ArrayRef<Symbol *> getSymbols() const { return SymVector; }
 
-  Symbol *addUndefined(Undefined *New);
-  Symbol *addDefined(Defined *New);
-  void addShared(SharedSymbol *New);
-  void addLazyArchive(LazyArchive *New);
-  void addLazyObject(LazyObject *New);
-  Symbol *addBitcode(Defined *New);
   Symbol *addCommon(CommonSymbol *New);
+  Symbol *addDefined(Defined *New);
+  Symbol *addLazyArchive(LazyArchive *New);
+  Symbol *addLazyObject(LazyObject *New);
+  Symbol *addShared(SharedSymbol *New);
+  Symbol *addUndefined(Undefined *New);
 
   Symbol *insert(Symbol *New);
   void mergeProperties(Symbol *Old, Symbol *New);
 
   void fetchLazy(Symbol *Sym);
 
   void scanVersionScript();
 
   Symbol *find(StringRef Name);
 
   void trace(StringRef Name);
 
   void handleDynamicList();
 
   // Set of .so files to not link the same shared object file more than once.
   llvm::DenseMap<StringRef, SharedFile *> SoNames;
 
 private:
-  template <class LazyT> void addLazy(LazyT *New);
+  template <class LazyT> Symbol *addLazy(LazyT *New);
 
   std::vector<Symbol *> findByVersion(SymbolVersion Ver);
   std::vector<Symbol *> findAllByVersion(SymbolVersion Ver);
 
   llvm::StringMap<std::vector<Symbol *>> &getDemangledSyms();
   void handleAnonymousVersion();
   void assignExactVersion(SymbolVersion Ver, uint16_t VersionId,
                           StringRef VersionName);

lld/ELF/SymbolTable.cpp

Symbol *SymbolTable::addDefined(Defined *New) {
   else if (Cmp == 0)
     reportDuplicate(Old, New->File,
                     dyn_cast_or_null<InputSectionBase>(New->Section),
                     New->Value);
 
   return Old;
 }
 
-void SymbolTable::addShared(SharedSymbol *New) {
+Symbol *SymbolTable::addShared(SharedSymbol *New) {
   Symbol *Old = insert(New);
   mergeProperties(Old, New);
 
   // Make sure we preempt DSO symbols with default visibility.
   if (New->Visibility == STV_DEFAULT)
     Old->ExportDynamic = true;
 
   if (Old->isPlaceholder()) {
     replaceSymbol(Old, New);
-    return;
+    return Old;
   }
 
   if (Old->Visibility == STV_DEFAULT && (Old->isUndefined() || Old->isLazy())) {
     // An undefined symbol with non default visibility must be satisfied
     // in the same DSO.
     uint8_t Binding = Old->Binding;
     replaceSymbol(Old, New);
     Old->Binding = Binding;
   }
-}
-
-Symbol *SymbolTable::addBitcode(Defined *New) {
-  Symbol *Old = insert(New);
-  mergeProperties(Old, New);
-
-  if (Old->isPlaceholder()) {
-    replaceSymbol(Old, New);
-    return Old;
-  }
-
-  int Cmp = compare(Old, New);
-  if (Cmp > 0)
-    replaceSymbol(Old, New);
-  else if (Cmp == 0)
-    reportDuplicate(Old, New->File, nullptr, 0);
   return Old;
 }
 
 Symbol *SymbolTable::find(StringRef Name) {
   auto It = SymMap.find(CachedHashStringRef(Name));
   if (It == SymMap.end())
     return nullptr;
   if (It->second == -1)
     return nullptr;
   return SymVector[It->second];
 }
 
-template <class LazyT> void SymbolTable::addLazy(LazyT *New) {
+template <class LazyT> Symbol *SymbolTable::addLazy(LazyT *New) {
   Symbol *Old = insert(New);
   mergeProperties(Old, New);
 
   if (Old->isPlaceholder()) {
     replaceSymbol(Old, New);
-    return;
+    return Old;
   }
 
   if (!Old->isUndefined())
-    return;
+    return Old;
 
   // An undefined weak will not fetch archive members. See comment on Lazy in
   // Symbols.h for the details.
   if (Old->isWeak()) {
     uint8_t Type = Old->Type;
     replaceSymbol(Old, New);
     Old->Type = Type;
     Old->Binding = STB_WEAK;
-    return;
+    return Old;
   }
 
   if (InputFile *F = New->fetch())
     parseFile(F);
+  return Old;
 }
 
-void SymbolTable::addLazyArchive(LazyArchive *New) { addLazy(New); }
+Symbol *SymbolTable::addLazyArchive(LazyArchive *New) { return addLazy(New); }
 
-void SymbolTable::addLazyObject(LazyObject *New) { addLazy(New); }
+Symbol *SymbolTable::addLazyObject(LazyObject *New) { return addLazy(New); }
 
 void SymbolTable::fetchLazy(Symbol *Sym) {
   if (auto *S = dyn_cast<LazyArchive>(Sym)) {
     if (InputFile *File = S->fetch())
       parseFile(File);
     return;
   }