Delete DefinedBitcode

[• rafael]

I got here while working on https://llvm.org/bugs/show_bug.cgi?id=30184.

For that bug I thought I needed to create a DefinedBitcodeCommon, but realized that we were not storing anything special for defined bitcode symbols. They are just regular defined symbols from bitcode files.

Once this is in I can fix PR30184 by just handling common symbols in a similar way.

[ruiu]

LGTM

ELF/LTO.cpp

if (GV) {
         GV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
       else
         GV->setUnnamedAddr(GlobalValue::UnnamedAddr::None);
     }
     if (Flags & BasicSymbolRef::SF_Undefined) {
       handleUndefinedAsmRefs(Sym, GV, AsmUndefinedRefs);
       continue;
     }
-    auto *B = dyn_cast<DefinedBitcode>(S->body());
-    if (!B || B->file() != &F)
+    SymbolBody *B = S->body();
+    if (B->kind() != SymbolBody::DefinedRegularKind)
+      continue;
+    if (B->File != &F)
       continue;
 
     // We collect the set of symbols we want to internalize here
     // and change the linkage after the IRMover executed, i.e. after
     // we imported the symbols and satisfied undefined references
     // to it. We can't just change linkage here because otherwise
     // the IRMover will just rename the symbol.
     if (GV && shouldInternalize(Used, S, GV))

ELF/OutputSections.cpp

SymbolTableSection<ELFT>::getOutputSection(SymbolBody *Sym) {
   case SymbolBody::SharedKind:
     if (cast<SharedSymbol<ELFT>>(Sym)->needsCopy())
       return Out<ELFT>::Bss;
     break;
   case SymbolBody::UndefinedKind:
   case SymbolBody::LazyArchiveKind:
   case SymbolBody::LazyObjectKind:
     break;
-  case SymbolBody::DefinedBitcodeKind:
-    llvm_unreachable("should have been replaced");
   }
   return nullptr;
 }
 
 template <class ELFT>
 VersionDefinitionSection<ELFT>::VersionDefinitionSection()
     : OutputSectionBase<ELFT>(".gnu.version_d", SHT_GNU_verdef, SHF_ALLOC) {
   this->Header.sh_addralign = sizeof(uint32_t);

ELF/SymbolTable.cpp

Symbol *SymbolTable<ELFT>::addBitcode(StringRef Name, uint8_t Binding,
                                       bool HasUnnamedAddr, BitcodeFile *F) {
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) =
       insert(Name, Type, StOther & 3, CanOmitFromDynSym, HasUnnamedAddr,
              /*IsUsedInRegularObj*/ false, F);
   int Cmp = compareDefinedNonCommon<ELFT>(S, WasInserted, Binding);
   if (Cmp > 0)
-    replaceBody<DefinedBitcode>(S, Name, StOther, Type, F);
+    replaceBody<DefinedRegular<ELFT>>(S, Name, StOther, Type, F);
   else if (Cmp == 0)
     reportDuplicate(S->body(), F);
   return S;
 }
 
 template <class ELFT> SymbolBody *SymbolTable<ELFT>::find(StringRef Name) {
   auto It = Symtab.find(Name);
   if (It == Symtab.end())

ELF/Symbols.h

 // The base class for real symbol classes.
 class SymbolBody {
 public:
   enum Kind {
     DefinedFirst,
     DefinedRegularKind = DefinedFirst,
     SharedKind,
     DefinedCommonKind,
-    DefinedBitcodeKind,
     DefinedSyntheticKind,
     DefinedLast = DefinedSyntheticKind,
     UndefinedKind,
     LazyArchiveKind,
     LazyObjectKind,
   };
 
   SymbolBody(Kind K) : SymbolKind(K) {}

 // The base class for any defined symbols.
 class Defined : public SymbolBody {
 public:
   Defined(Kind K, StringRef Name, uint8_t StOther, uint8_t Type);
   Defined(Kind K, uint32_t NameOffset, uint8_t StOther, uint8_t Type);
   static bool classof(const SymbolBody *S) { return S->isDefined(); }
 };
 
-// The defined symbol in LLVM bitcode files.
-class DefinedBitcode : public Defined {
-public:
-  DefinedBitcode(StringRef Name, uint8_t StOther, uint8_t Type, BitcodeFile *F);
-  static bool classof(const SymbolBody *S);
-  BitcodeFile *file() { return (BitcodeFile *)this->File; }
-};
-
 template <class ELFT> class DefinedCommon : public Defined {
 public:
   DefinedCommon(StringRef N, uint64_t Size, uint64_t Alignment, uint8_t StOther,
                 uint8_t Type, InputFile *File);
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == SymbolBody::DefinedCommonKind;
   }
if (Section)
       this->File = Section->getFile();
   }
 
   DefinedRegular(StringRef Name, uint8_t StOther)
       : Defined(SymbolBody::DefinedRegularKind, Name, StOther,
                 llvm::ELF::STT_NOTYPE),
         Value(0), Size(0), Section(NullInputSection) {}
 
+  DefinedRegular(StringRef Name, uint8_t StOther, uint8_t Type, BitcodeFile *F)
+      : Defined(SymbolBody::DefinedRegularKind, Name, StOther, Type), Value(0),
+        Size(0), Section(NullInputSection) {
+    this->File = F;
+  }
+
   static bool classof(const SymbolBody *S) {
     return S->kind() == SymbolBody::DefinedRegularKind;
   }
 
   uintX_t Value;
   uintX_t Size;
 
   // The input section this symbol belongs to. Notice that this is
struct Symbol {
   bool includeInDynsym() const;
   bool isWeak() const { return Binding == llvm::ELF::STB_WEAK; }
 
   // This field is used to store the Symbol's SymbolBody. This instantiation of
   // AlignedCharArrayUnion gives us a struct with a char array field that is
   // large and aligned enough to store any derived class of SymbolBody. We
   // assume that the size and alignment of ELF64LE symbols is sufficient for any
   // ELFT, and we verify this with the static_asserts in replaceBody.
-  llvm::AlignedCharArrayUnion<
-      DefinedBitcode, DefinedCommon<llvm::object::ELF64LE>,
+  llvm::AlignedCharArrayUnion<DefinedCommon<llvm::object::ELF64LE>,
                               DefinedRegular<llvm::object::ELF64LE>,
-      DefinedSynthetic<llvm::object::ELF64LE>, Undefined,
-      SharedSymbol<llvm::object::ELF64LE>, LazyArchive, LazyObject>
+                              DefinedSynthetic<llvm::object::ELF64LE>,
+                              Undefined, SharedSymbol<llvm::object::ELF64LE>,
+                              LazyArchive, LazyObject>
       Body;
 
   SymbolBody *body() { return reinterpret_cast<SymbolBody *>(Body.buffer); }
   const SymbolBody *body() const { return const_cast<Symbol *>(this)->body(); }
 };
 
 void printTraceSymbol(Symbol *Sym);
 

ELF/Symbols.cpp

case SymbolBody::SharedKind: {
     return Out<ELFT>::Bss->getVA() + SS.OffsetInBss;
   }
   case SymbolBody::UndefinedKind:
     return 0;
   case SymbolBody::LazyArchiveKind:
   case SymbolBody::LazyObjectKind:
     assert(Body.symbol()->IsUsedInRegularObj && "lazy symbol reached writer");
     return 0;
-  case SymbolBody::DefinedBitcodeKind:
-    llvm_unreachable("should have been replaced");
   }
   llvm_unreachable("invalid symbol kind");
 }
 
 SymbolBody::SymbolBody(Kind K, uint32_t NameOffset, uint8_t StOther,
                        uint8_t Type)
     : SymbolKind(K), NeedsCopyOrPltAddr(false), IsLocal(true),
       IsInGlobalMipsGot(false), Type(Type), StOther(StOther),

 }
 
 Defined::Defined(Kind K, StringRef Name, uint8_t StOther, uint8_t Type)
     : SymbolBody(K, Name, StOther, Type) {}
 
 Defined::Defined(Kind K, uint32_t NameOffset, uint8_t StOther, uint8_t Type)
     : SymbolBody(K, NameOffset, StOther, Type) {}
 
-DefinedBitcode::DefinedBitcode(StringRef Name, uint8_t StOther, uint8_t Type,
-                               BitcodeFile *F)
-    : Defined(DefinedBitcodeKind, Name, StOther, Type) {
-  this->File = F;
-}
-
-bool DefinedBitcode::classof(const SymbolBody *S) {
-  return S->kind() == DefinedBitcodeKind;
-}
-
 Undefined::Undefined(StringRef Name, uint8_t StOther, uint8_t Type,
                      InputFile *File)
     : SymbolBody(SymbolBody::UndefinedKind, Name, StOther, Type) {
   this->File = File;
 }
 
 Undefined::Undefined(uint32_t NameOffset, uint8_t StOther, uint8_t Type,
                      InputFile *File)