COFF: Remove the SymbolBodies vector, and rename SparseSymbolBodies to Symbols.

[pcc]

• Update comment

[ruiu]

LGTM

lld/COFF/InputFiles.h

 class ObjFile : public InputFile {
 public:
   explicit ObjFile(MemoryBufferRef M) : InputFile(ObjectKind, M) {}
   static bool classof(const InputFile *F) { return F->kind() == ObjectKind; }
   void parse() override;
   MachineTypes getMachineType() override;
   std::vector<Chunk *> &getChunks() { return Chunks; }
   std::vector<SectionChunk *> &getDebugChunks() { return DebugChunks; }
-  std::vector<Symbol *> &getSymbols() { return SymbolBodies; }
+  std::vector<Symbol *> &getSymbols() { return Symbols; }
 
   // Returns a Symbol object for the SymbolIndex'th symbol in the
   // underlying object file.
   Symbol *getSymbol(uint32_t SymbolIndex) {
-    return SparseSymbolBodies[SymbolIndex];
+    return Symbols[SymbolIndex];
   }
 
   // Returns the underying COFF file.
   COFFObjectFile *getCOFFObj() { return COFFObj.get(); }
 
   static std::vector<ObjFile *> Instances;
 
   // True if this object file is compatible with SEH.
private:
 
   // This vector contains the same chunks as Chunks, but they are
   // indexed such that you can get a SectionChunk by section index.
   // Nonexistent section indices are filled with null pointers.
   // (Because section number is 1-based, the first slot is always a
   // null pointer.)
   std::vector<SectionChunk *> SparseChunks;
 
-  // List of all symbols referenced or defined by this file.
-  std::vector<Symbol *> SymbolBodies;
-
-  // This vector contains the same symbols as SymbolBodies, but they
-  // are indexed such that you can get a Symbol by symbol
+  // This vector contains a list of all symbols defined or referenced by this
+  // file. They are indexed such that you can get a Symbol by symbol
   // index. Nonexistent indices (which are occupied by auxiliary
   // symbols in the real symbol table) are filled with null pointers.
-  std::vector<Symbol *> SparseSymbolBodies;
+  std::vector<Symbol *> Symbols;
 };
 
 // This type represents import library members that contain DLL names
 // and symbols exported from the DLLs. See Microsoft PE/COFF spec. 7
 // for details about the format.
 class ImportFile : public InputFile {
 public:
   explicit ImportFile(MemoryBufferRef M)

lld/COFF/InputFiles.cpp

else
       Chunks.push_back(C);
 
     SparseChunks[I] = C;
   }
 }
 
 void ObjFile::initializeSymbols() {
   uint32_t NumSymbols = COFFObj->getNumberOfSymbols();
-  SymbolBodies.reserve(NumSymbols);
-  SparseSymbolBodies.resize(NumSymbols);
+  Symbols.resize(NumSymbols);
 
   SmallVector<std::pair<Symbol *, uint32_t>, 8> WeakAliases;
   int32_t LastSectionNumber = 0;
 
   for (uint32_t I = 0; I < NumSymbols; ++I) {
     COFFSymbolRef COFFSym = check(COFFObj->getSymbol(I));
 
     const void *AuxP = nullptr;
     if (COFFSym.getNumberOfAuxSymbols())
       AuxP = check(COFFObj->getSymbol(I + 1)).getRawPtr();
     bool IsFirst = (LastSectionNumber != COFFSym.getSectionNumber());
 
     Symbol *Sym = nullptr;
     if (COFFSym.isUndefined()) {
       Sym = createUndefined(COFFSym);
     } else if (COFFSym.isWeakExternal()) {
       Sym = createUndefined(COFFSym);
       uint32_t TagIndex =
           static_cast<const coff_aux_weak_external *>(AuxP)->TagIndex;
       WeakAliases.emplace_back(Sym, TagIndex);
     } else {
       Sym = createDefined(COFFSym, AuxP, IsFirst);
     }
-    if (Sym) {
-      SymbolBodies.push_back(Sym);
-      SparseSymbolBodies[I] = Sym;
-    }
+    Symbols[I] = Sym;
     I += COFFSym.getNumberOfAuxSymbols();
     LastSectionNumber = COFFSym.getSectionNumber();
   }
 
   for (auto &KV : WeakAliases) {
     Symbol *Sym = KV.first;
     uint32_t Idx = KV.second;
-    checkAndSetWeakAlias(Symtab, this, Sym, SparseSymbolBodies[Idx]);
+    checkAndSetWeakAlias(Symtab, this, Sym, Symbols[Idx]);
   }
 }
 
 Symbol *ObjFile::createUndefined(COFFSymbolRef Sym) {
   StringRef Name;
   COFFObj->getSymbolName(Sym, Name);
   return Symtab->addUndefined(Name, this, Sym.isWeakExternal());
 }
if (!SEHCompat || !SXData)
     return;
   ArrayRef<uint8_t> A;
   COFFObj->getSectionContents(SXData, A);
   if (A.size() % 4 != 0)
     fatal(".sxdata must be an array of symbol table indices");
   auto *I = reinterpret_cast<const ulittle32_t *>(A.data());
   auto *E = reinterpret_cast<const ulittle32_t *>(A.data() + A.size());
   for (; I != E; ++I)
-    SEHandlers.insert(SparseSymbolBodies[*I]);
+    SEHandlers.insert(Symbols[*I]);
 }
 
 MachineTypes ObjFile::getMachineType() {
   if (COFFObj)
     return static_cast<MachineTypes>(COFFObj->getMachine());
   return IMAGE_FILE_MACHINE_UNKNOWN;
 }
 

lld/COFF/MapFile.cpp

 
 static std::string indent(int Depth) { return std::string(Depth * 8, ' '); }
 
 // Returns a list of all symbols that we want to print out.
 static std::vector<DefinedRegular *> getSymbols() {
   std::vector<DefinedRegular *> V;
   for (ObjFile *File : ObjFile::Instances)
     for (Symbol *B : File->getSymbols())
-      if (auto *Sym = dyn_cast<DefinedRegular>(B))
+      if (auto *Sym = dyn_cast_or_null<DefinedRegular>(B))
         if (Sym && !Sym->getCOFFSymbol().isSectionDefinition())
           V.push_back(Sym);
   return V;
 }
 
 // Returns a map from sections to their symbols.
 static SymbolMapTy getSectionSyms(ArrayRef<DefinedRegular *> Syms) {
   SymbolMapTy Ret;

lld/COFF/SymbolTable.cpp

if (Undefs.empty())
     return;
 
   for (Symbol *B : Config->GCRoot)
     if (Undefs.count(B))
       errorOrWarn("<root>: undefined symbol: " + B->getName());
 
   for (ObjFile *File : ObjFile::Instances)
     for (Symbol *Sym : File->getSymbols())
-      if (Undefs.count(Sym))
+      if (Sym && Undefs.count(Sym))
         errorOrWarn(toString(File) + ": undefined symbol: " + Sym->getName());
 }
 
 std::pair<Symbol *, bool> SymbolTable::insert(StringRef Name) {
   Symbol *&Sym = Symtab[CachedHashStringRef(Name)];
   if (Sym)
     return {Sym, false};
   Sym = (Symbol *)make<SymbolUnion>();