[opt] Hoist the call throuh SymbolBody::getReplacement out of the inline method to get a SymbolBody and into the callers, and kill now dead includes.

[chandlerc]

Summary

This removes the need to have the SymbolBody definition when we're
defining the inline method and makes it a better inline method. That was
the only reason for a lot of header includes here. Removing these and
using forward declarations actually uncovers a bunch of cross-header
dependencies that I've fixed while I'm here, and will allow me to
introduce some *important* inline code into Chunks.h that requires the
definition of ObjectFile.

No functionality changed at this point.

[ruiu]

LGTM

COFF/InputFiles.h

13–14

Ah, you already did this. :)

COFF/Chunks.cpp

if (!hasData())
     return;
   // Copy section contents from source object file to output file.
   ArrayRef<uint8_t> A = getContents();
   memcpy(Buf + FileOff, A.data(), A.size());
 
   // Apply relocations.
   for (const coff_relocation &Rel : Relocs) {
     uint8_t *Off = Buf + FileOff + Rel.VirtualAddress;
-    SymbolBody *Body = File->getSymbolBody(Rel.SymbolTableIndex);
+    SymbolBody *Body =
+        File->getSymbolBody(Rel.SymbolTableIndex)->getReplacement();
     uint64_t S = cast<Defined>(Body)->getRVA();
     uint64_t P = RVA + Rel.VirtualAddress;
     switch (Rel.Type) {
     case IMAGE_REL_AMD64_ADDR32:   add32(Off, S + Config->ImageBase); break;
     case IMAGE_REL_AMD64_ADDR64:   add64(Off, S + Config->ImageBase); break;
     case IMAGE_REL_AMD64_ADDR32NB: add32(Off, S); break;
     case IMAGE_REL_AMD64_REL32:    add32(Off, S - P - 4); break;
     case IMAGE_REL_AMD64_REL32_1:  add32(Off, S - P - 5); break;

 }
 
 void SectionChunk::mark() {
   assert(!Live);
   Live = true;
 
   // Mark all symbols listed in the relocation table for this section.
   for (const coff_relocation &Rel : Relocs) {
-    SymbolBody *B = File->getSymbolBody(Rel.SymbolTableIndex);
+    SymbolBody *B = File->getSymbolBody(Rel.SymbolTableIndex)->getReplacement();
     if (auto *D = dyn_cast<DefinedRegular>(B))
       D->markLive();
   }
 
   // Mark associative sections if any.
   for (Chunk *C : AssocChildren)
     if (auto *SC = dyn_cast<SectionChunk>(C))
       SC->markLive();

 // Only called when base relocation is enabled.
 void SectionChunk::getBaserels(std::vector<uint32_t> *Res, Defined *ImageBase) {
   for (const coff_relocation &Rel : Relocs) {
     // ADDR64 relocations contain absolute addresses.
     // Symbol __ImageBase is special -- it's an absolute symbol, but its
     // address never changes even if image is relocated.
     if (Rel.Type != IMAGE_REL_AMD64_ADDR64)
       continue;
-    SymbolBody *Body = File->getSymbolBody(Rel.SymbolTableIndex);
+    SymbolBody *Body =
+        File->getSymbolBody(Rel.SymbolTableIndex)->getReplacement();
     if (Body == ImageBase)
       continue;
     Res->push_back(RVA + Rel.VirtualAddress);
   }
 }
 
 bool SectionChunk::hasData() const {
   return !(Header->Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA);
if (getContents() != X->getContents())
     return false;
 
   // Compare relocations
   auto Eq = [&](const coff_relocation &R1, const coff_relocation &R2) {
     if (R1.Type != R2.Type)
       return false;
     if (R1.VirtualAddress != R2.VirtualAddress)
       return false;
-    SymbolBody *B1 = File->getSymbolBody(R1.SymbolTableIndex);
-    SymbolBody *B2 = X->File->getSymbolBody(R2.SymbolTableIndex);
+    SymbolBody *B1 = File->getSymbolBody(R1.SymbolTableIndex)->getReplacement();
+    SymbolBody *B2 =
+        X->File->getSymbolBody(R2.SymbolTableIndex)->getReplacement();
     auto *D1 = dyn_cast<DefinedRegular>(B1);
     auto *D2 = dyn_cast<DefinedRegular>(B2);
     if (D1 && D2 && D1->getChunk() == D2->getChunk())
       return true;
     return B1 == B2;
   };
   return std::equal(Relocs.begin(), Relocs.end(), X->Relocs.begin(), Eq);
 }

COFF/InputFiles.h

 //===- InputFiles.h -------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COFF_INPUT_FILES_H
 #define LLD_COFF_INPUT_FILES_H
 
-#include "Chunks.h"
-#include "Symbols.h"
 #include "lld/Core/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/LTO/LTOModule.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/StringSaver.h"
 #include <memory>
 #include <set>
 #include <vector>
 
 namespace lld {
 namespace coff {
 
 using llvm::LTOModule;
 using llvm::object::Archive;
 using llvm::object::COFFObjectFile;
+using llvm::object::COFFSymbolRef;
+
+class Chunk;
+class SymbolBody;
 
 // The root class of input files.
 class InputFile {
 public:
   enum Kind { ArchiveKind, ObjectKind, ImportKind, BitcodeKind };
   Kind kind() const { return FileKind; }
   virtual ~InputFile() {}
 
public:
   static bool classof(const InputFile *F) { return F->kind() == ObjectKind; }
   std::error_code parse() override;
   std::vector<Chunk *> &getChunks() { return Chunks; }
   std::vector<SymbolBody *> &getSymbols() override { return SymbolBodies; }
 
   // Returns a SymbolBody object for the SymbolIndex'th symbol in the
   // underlying object file.
   SymbolBody *getSymbolBody(uint32_t SymbolIndex) {
-    return SparseSymbolBodies[SymbolIndex]->getReplacement();
+    return SparseSymbolBodies[SymbolIndex];
   }
 
   // Returns the underying COFF file.
   COFFObjectFile *getCOFFObj() { return COFFObj.get(); }
 
 private:
   std::error_code initializeChunks();
   std::error_code initializeSymbols();

COFF/SymbolTable.h

 
 namespace llvm {
 struct LTOCodeGenerator;
 }
 
 namespace lld {
 namespace coff {
 
+class Chunk;
+struct Symbol;
+class SymbolBody;
+class Lazy;
+
 // SymbolTable is a bucket of all known symbols, including defined,
 // undefined, or lazy symbols (the last one is symbols in archive
 // files whose archive members are not yet loaded).
 //
 // We put all symbols of all files to a SymbolTable, and the
 // SymbolTable selects the "best" symbols if there are name
 // conflicts. For example, obviously, a defined symbol is better than
 // an undefined symbol. Or, if there's a conflict between a lazy and a

COFF/SymbolTable.cpp

 //===- SymbolTable.cpp ----------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Config.h"
 #include "Driver.h"
 #include "Error.h"
 #include "SymbolTable.h"
+#include "Symbols.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/LTO/LTOCodeGenerator.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 namespace lld {