Rename SymbolBody -> Symbol

Now that we have only SymbolBody as the symbol class. So, "SymbolBody"
is a bit strange name now. This is a mechanical change generated by

  perl -i -pe s/SymbolBody/Symbol/g $(git grep -l SymbolBody lld/ELF lld/COFF)

nd clang-format-diff.

Differential Revision: https://reviews.llvm.org/D39459

llvm-svn: 317370

Author: rui314

lld/COFF/Chunks.cpp

@@ -251,7 +251,7 @@ void SectionChunk::writeTo(uint8_t *Buf) const {
     // Get the output section of the symbol for this relocation.  The output
     // section is needed to compute SECREL and SECTION relocations used in debug
     // info.
-    SymbolBody *Body = File->getSymbolBody(Rel.SymbolTableIndex);
+    Symbol *Body = File->getSymbol(Rel.SymbolTableIndex);
     Defined *Sym = cast<Defined>(Body);
     Chunk *C = Sym->getChunk();
     OutputSection *OS = C ? C->getOutputSection() : nullptr;
@@ -328,7 +328,7 @@ void SectionChunk::getBaserels(std::vector<Baserel> *Res) {
     uint8_t Ty = getBaserelType(Rel);
     if (Ty == IMAGE_REL_BASED_ABSOLUTE)
       continue;
-    SymbolBody *Body = File->getSymbolBody(Rel.SymbolTableIndex);
+    Symbol *Body = File->getSymbol(Rel.SymbolTableIndex);
     if (isa<DefinedAbsolute>(Body))
       continue;
     Res->emplace_back(RVA + Rel.VirtualAddress, Ty);

lld/COFF/Chunks.h

@@ -35,7 +35,7 @@ class DefinedImportData;
 class DefinedRegular;
 class ObjFile;
 class OutputSection;
-class SymbolBody;
+class Symbol;
 
 // Mask for section types (code, data, bss, disacardable, etc.)
 // and permissions (writable, readable or executable).
@@ -117,7 +117,7 @@ class SectionChunk final : public Chunk {
 public:
   class symbol_iterator : public llvm::iterator_adaptor_base<
                               symbol_iterator, const coff_relocation *,
-                              std::random_access_iterator_tag, SymbolBody *> {
+                              std::random_access_iterator_tag, Symbol *> {
     friend SectionChunk;
 
     ObjFile *File;
@@ -128,9 +128,7 @@ class SectionChunk final : public Chunk {
   public:
     symbol_iterator() = default;
 
-    SymbolBody *operator*() const {
-      return File->getSymbolBody(I->SymbolTableIndex);
-    }
+    Symbol *operator*() const { return File->getSymbol(I->SymbolTableIndex); }
   };
 
   SectionChunk(ObjFile *File, const coff_section *Header);

lld/COFF/Config.h

@@ -27,7 +27,7 @@ using llvm::StringRef;
 class DefinedAbsolute;
 class DefinedRelative;
 class StringChunk;
-class SymbolBody;
+class Symbol;
 
 // Short aliases.
 static const auto AMD64 = llvm::COFF::IMAGE_FILE_MACHINE_AMD64;
@@ -39,7 +39,7 @@ static const auto I386 = llvm::COFF::IMAGE_FILE_MACHINE_I386;
 struct Export {
   StringRef Name;       // N in /export:N or /export:E=N
   StringRef ExtName;    // E in /export:E=N
-  SymbolBody *Sym = nullptr;
+  Symbol *Sym = nullptr;
   uint16_t Ordinal = 0;
   bool Noname = false;
   bool Data = false;
@@ -79,7 +79,7 @@ struct Configuration {
   llvm::COFF::MachineTypes Machine = IMAGE_FILE_MACHINE_UNKNOWN;
   bool Verbose = false;
   WindowsSubsystem Subsystem = llvm::COFF::IMAGE_SUBSYSTEM_UNKNOWN;
-  SymbolBody *Entry = nullptr;
+  Symbol *Entry = nullptr;
   bool NoEntry = false;
   std::string OutputFile;
   std::string ImportName;
@@ -94,7 +94,7 @@ struct Configuration {
   std::vector<llvm::StringRef> Argv;
 
   // Symbols in this set are considered as live by the garbage collector.
-  std::set<SymbolBody *> GCRoot;
+  std::set<Symbol *> GCRoot;
 
   std::set<StringRef> NoDefaultLibs;
   bool NoDefaultLibAll = false;
@@ -105,13 +105,13 @@ struct Configuration {
   std::vector<Export> Exports;
   std::set<std::string> DelayLoads;
   std::map<std::string, int> DLLOrder;
-  SymbolBody *DelayLoadHelper = nullptr;
+  Symbol *DelayLoadHelper = nullptr;
 
   bool SaveTemps = false;
 
   // Used for SafeSEH.
-  SymbolBody *SEHTable = nullptr;
-  SymbolBody *SEHCount = nullptr;
+  Symbol *SEHTable = nullptr;
+  Symbol *SEHCount = nullptr;
 
   // Used for /opt:lldlto=N
   unsigned LTOOptLevel = 2;

lld/COFF/Driver.cpp

@@ -353,8 +353,8 @@ void LinkerDriver::addLibSearchPaths() {
   }
 }
 
-SymbolBody *LinkerDriver::addUndefined(StringRef Name) {
-  SymbolBody *B = Symtab->addUndefined(Name);
+Symbol *LinkerDriver::addUndefined(StringRef Name) {
+  Symbol *B = Symtab->addUndefined(Name);
   Config->GCRoot.insert(B);
   return B;
 }
@@ -1181,7 +1181,7 @@ void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
     for (auto Pair : Config->AlternateNames) {
       StringRef From = Pair.first;
       StringRef To = Pair.second;
-      SymbolBody *Sym = Symtab->find(From);
+      Symbol *Sym = Symtab->find(From);
       if (!Sym)
         continue;
       if (auto *U = dyn_cast<Undefined>(Sym))
@@ -1237,7 +1237,7 @@ void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
                       Args.hasArg(OPT_export_all_symbols))) {
     AutoExporter Exporter;
 
-    Symtab->forEachSymbol([=](SymbolBody *S) {
+    Symtab->forEachSymbol([=](Symbol *S) {
       auto *Def = dyn_cast<Defined>(S);
       if (!Exporter.shouldExport(Def))
         return;
@@ -1268,7 +1268,7 @@ void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
     StringRef Name = Pair.first;
     uint32_t Alignment = Pair.second;
 
-    SymbolBody *Sym = Symtab->find(Name);
+    Symbol *Sym = Symtab->find(Name);
     if (!Sym) {
       warn("/aligncomm symbol " + Name + " not found");
       continue;

lld/COFF/Driver.h

@@ -96,7 +96,7 @@ class LinkerDriver {
   std::set<std::string> VisitedFiles;
   std::set<std::string> VisitedLibs;
 
-  SymbolBody *addUndefined(StringRef Sym);
+  Symbol *addUndefined(StringRef Sym);
   StringRef mangle(StringRef Sym);
 
   // Windows specific -- "main" is not the only main function in Windows.

lld/COFF/DriverUtils.cpp

@@ -574,7 +574,7 @@ void fixupExports() {
   }
 
   for (Export &E : Config->Exports) {
-    SymbolBody *Sym = E.Sym;
+    Symbol *Sym = E.Sym;
     if (!E.ForwardTo.empty() || !Sym) {
       E.SymbolName = E.Name;
     } else {

lld/COFF/ICF.cpp

@@ -119,8 +119,8 @@ bool ICF::equalsConstant(const SectionChunk *A, const SectionChunk *B) {
         R1.VirtualAddress != R2.VirtualAddress) {
       return false;
     }
-    SymbolBody *B1 = A->File->getSymbolBody(R1.SymbolTableIndex);
-    SymbolBody *B2 = B->File->getSymbolBody(R2.SymbolTableIndex);
+    Symbol *B1 = A->File->getSymbol(R1.SymbolTableIndex);
+    Symbol *B2 = B->File->getSymbol(R2.SymbolTableIndex);
     if (B1 == B2)
       return true;
     if (auto *D1 = dyn_cast<DefinedRegular>(B1))
@@ -143,8 +143,8 @@ bool ICF::equalsConstant(const SectionChunk *A, const SectionChunk *B) {
 bool ICF::equalsVariable(const SectionChunk *A, const SectionChunk *B) {
   // Compare relocations.
   auto Eq = [&](const coff_relocation &R1, const coff_relocation &R2) {
-    SymbolBody *B1 = A->File->getSymbolBody(R1.SymbolTableIndex);
-    SymbolBody *B2 = B->File->getSymbolBody(R2.SymbolTableIndex);
+    Symbol *B1 = A->File->getSymbol(R1.SymbolTableIndex);
+    Symbol *B2 = B->File->getSymbol(R2.SymbolTableIndex);
     if (B1 == B2)
       return true;
     if (auto *D1 = dyn_cast<DefinedRegular>(B1))

lld/COFF/InputFiles.cpp

@@ -51,7 +51,7 @@ std::vector<BitcodeFile *> BitcodeFile::Instances;
 /// If Source is Undefined and has no weak alias set, makes it a weak
 /// alias to Target.
 static void checkAndSetWeakAlias(SymbolTable *Symtab, InputFile *F,
-                                 SymbolBody *Source, SymbolBody *Target) {
+                                 Symbol *Source, Symbol *Target) {
   if (auto *U = dyn_cast<Undefined>(Source)) {
     if (U->WeakAlias && U->WeakAlias != Target)
       Symtab->reportDuplicate(Source, F);
@@ -175,7 +175,7 @@ void ObjFile::initializeSymbols() {
   SymbolBodies.reserve(NumSymbols);
   SparseSymbolBodies.resize(NumSymbols);
 
-  SmallVector<std::pair<SymbolBody *, uint32_t>, 8> WeakAliases;
+  SmallVector<std::pair<Symbol *, uint32_t>, 8> WeakAliases;
   int32_t LastSectionNumber = 0;
 
   for (uint32_t I = 0; I < NumSymbols; ++I) {
@@ -186,7 +186,7 @@ void ObjFile::initializeSymbols() {
       AuxP = check(COFFObj->getSymbol(I + 1)).getRawPtr();
     bool IsFirst = (LastSectionNumber != Sym.getSectionNumber());
 
-    SymbolBody *Body = nullptr;
+    Symbol *Body = nullptr;
     if (Sym.isUndefined()) {
       Body = createUndefined(Sym);
     } else if (Sym.isWeakExternal()) {
@@ -206,26 +206,26 @@ void ObjFile::initializeSymbols() {
   }
 
   for (auto &KV : WeakAliases) {
-    SymbolBody *Sym = KV.first;
+    Symbol *Sym = KV.first;
     uint32_t Idx = KV.second;
     checkAndSetWeakAlias(Symtab, this, Sym, SparseSymbolBodies[Idx]);
   }
 }
 
-SymbolBody *ObjFile::createUndefined(COFFSymbolRef Sym) {
+Symbol *ObjFile::createUndefined(COFFSymbolRef Sym) {
   StringRef Name;
   COFFObj->getSymbolName(Sym, Name);
   return Symtab->addUndefined(Name, this, Sym.isWeakExternal());
 }
 
-SymbolBody *ObjFile::createDefined(COFFSymbolRef Sym, const void *AuxP,
-                                   bool IsFirst) {
+Symbol *ObjFile::createDefined(COFFSymbolRef Sym, const void *AuxP,
+                               bool IsFirst) {
   StringRef Name;
   if (Sym.isCommon()) {
     auto *C = make<CommonChunk>(Sym);
     Chunks.push_back(C);
     COFFObj->getSymbolName(Sym, Name);
-    SymbolBody *S =
+    Symbol *S =
         Symtab->addCommon(this, Name, Sym.getValue(), Sym.getGeneric(), C);
     return S;
   }
@@ -280,7 +280,7 @@ SymbolBody *ObjFile::createDefined(COFFSymbolRef Sym, const void *AuxP,
   DefinedRegular *B;
   if (Sym.isExternal()) {
     COFFObj->getSymbolName(Sym, Name);
-    SymbolBody *S =
+    Symbol *S =
         Symtab->addRegular(this, Name, SC->isCOMDAT(), Sym.getGeneric(), SC);
     B = cast<DefinedRegular>(S);
   } else
@@ -368,7 +368,7 @@ void BitcodeFile::parse() {
       MB.getBuffer(), Saver.save(ParentName + MB.getBufferIdentifier()))));
   for (const lto::InputFile::Symbol &ObjSym : Obj->symbols()) {
     StringRef SymName = Saver.save(ObjSym.getName());
-    SymbolBody *Sym;
+    Symbol *Sym;
     if (ObjSym.isUndefined()) {
       Sym = Symtab->addUndefined(SymName, this, false);
     } else if (ObjSym.isCommon()) {
@@ -377,7 +377,7 @@ void BitcodeFile::parse() {
       // Weak external.
       Sym = Symtab->addUndefined(SymName, this, true);
       std::string Fallback = ObjSym.getCOFFWeakExternalFallback();
-      SymbolBody *Alias = Symtab->addUndefined(Saver.save(Fallback));
+      Symbol *Alias = Symtab->addUndefined(Saver.save(Fallback));
       checkAndSetWeakAlias(Symtab, this, Sym, Alias);
     } else {
       bool IsCOMDAT = ObjSym.getComdatIndex() != -1;

lld/COFF/InputFiles.h

@@ -47,7 +47,7 @@ class DefinedImportData;
 class DefinedImportThunk;
 class Lazy;
 class SectionChunk;
-class SymbolBody;
+class Symbol;
 class Undefined;
 
 // The root class of input files.
@@ -110,11 +110,11 @@ class ObjFile : public InputFile {
   MachineTypes getMachineType() override;
   std::vector<Chunk *> &getChunks() { return Chunks; }
   std::vector<SectionChunk *> &getDebugChunks() { return DebugChunks; }
-  std::vector<SymbolBody *> &getSymbols() { return SymbolBodies; }
+  std::vector<Symbol *> &getSymbols() { return SymbolBodies; }
 
-  // Returns a SymbolBody object for the SymbolIndex'th symbol in the
+  // Returns a Symbol object for the SymbolIndex'th symbol in the
   // underlying object file.
-  SymbolBody *getSymbolBody(uint32_t SymbolIndex) {
+  Symbol *getSymbol(uint32_t SymbolIndex) {
     return SparseSymbolBodies[SymbolIndex];
   }
 
@@ -129,7 +129,7 @@ class ObjFile : public InputFile {
 
   // The list of safe exception handlers listed in .sxdata section.
   // COFF-specific and x86-only.
-  std::set<SymbolBody *> SEHandlers;
+  std::set<Symbol *> SEHandlers;
 
   // Pointer to the PDB module descriptor builder. Various debug info records
   // will reference object files by "module index", which is here. Things like
@@ -142,8 +142,8 @@ class ObjFile : public InputFile {
   void initializeSymbols();
   void initializeSEH();
 
-  SymbolBody *createDefined(COFFSymbolRef Sym, const void *Aux, bool IsFirst);
-  SymbolBody *createUndefined(COFFSymbolRef Sym);
+  Symbol *createDefined(COFFSymbolRef Sym, const void *Aux, bool IsFirst);
+  Symbol *createUndefined(COFFSymbolRef Sym);
 
   std::unique_ptr<COFFObjectFile> COFFObj;
   const coff_section *SXData = nullptr;
@@ -163,13 +163,13 @@ class ObjFile : public InputFile {
   std::vector<Chunk *> SparseChunks;
 
   // List of all symbols referenced or defined by this file.
-  std::vector<SymbolBody *> SymbolBodies;
+  std::vector<Symbol *> SymbolBodies;
 
   // This vector contains the same symbols as SymbolBodies, but they
-  // are indexed such that you can get a SymbolBody by symbol
+  // 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<SymbolBody *> SparseSymbolBodies;
+  std::vector<Symbol *> SparseSymbolBodies;
 };
 
 // This type represents import library members that contain DLL names
@@ -210,15 +210,15 @@ class BitcodeFile : public InputFile {
 public:
   explicit BitcodeFile(MemoryBufferRef M) : InputFile(BitcodeKind, M) {}
   static bool classof(const InputFile *F) { return F->kind() == BitcodeKind; }
-  std::vector<SymbolBody *> &getSymbols() { return SymbolBodies; }
+  std::vector<Symbol *> &getSymbols() { return SymbolBodies; }
   MachineTypes getMachineType() override;
   static std::vector<BitcodeFile *> Instances;
   std::unique_ptr<llvm::lto::InputFile> Obj;
 
 private:
   void parse() override;
 
-  std::vector<SymbolBody *> SymbolBodies;
+  std::vector<Symbol *> SymbolBodies;
 };
 } // namespace coff
 

lld/COFF/LTO.cpp

@@ -88,17 +88,17 @@ BitcodeCompiler::BitcodeCompiler() : LTOObj(createLTO()) {}
 
 BitcodeCompiler::~BitcodeCompiler() = default;
 
-static void undefine(SymbolBody *S) { replaceBody<Undefined>(S, S->getName()); }
+static void undefine(Symbol *S) { replaceBody<Undefined>(S, S->getName()); }
 
 void BitcodeCompiler::add(BitcodeFile &F) {
   lto::InputFile &Obj = *F.Obj;
   unsigned SymNum = 0;
-  std::vector<SymbolBody *> SymBodies = F.getSymbols();
+  std::vector<Symbol *> SymBodies = F.getSymbols();
   std::vector<lto::SymbolResolution> Resols(SymBodies.size());
 
   // Provide a resolution to the LTO API for each symbol.
   for (const lto::InputFile::Symbol &ObjSym : Obj.symbols()) {
-    SymbolBody *Sym = SymBodies[SymNum];
+    Symbol *Sym = SymBodies[SymNum];
     lto::SymbolResolution &R = Resols[SymNum];
     ++SymNum;