[WebAssembly] Add InputChunk as common base class for InputSegment and InputFunction. NFC.

[sbc100]

• clang format

[sbc100]

• rebase

[ncw]

On another note, if you're in the mood for merging things, could you merge your chain of refactorings (D41315, D41419, etc)? Then other dependent changes like D41390 and Comdat can be unblocked.

These refactoring changes are nice, and shuffle the existing code around into a more workable form.

[sbc100]

• rebase

[sbc100]

• typo

wasm/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Options.td)
 tablegen(LLVM Options.inc -gen-opt-parser-defs)
 add_public_tablegen_target(WasmOptionsTableGen)
 
 add_lld_library(lldWasm
   Driver.cpp
+  InputChunks.cpp
   InputFiles.cpp
-  InputSegment.cpp
   OutputSections.cpp
   SymbolTable.cpp
   Symbols.cpp
   Writer.cpp
   WriterUtils.cpp
 
   LINK_COMPONENTS
   ${LLVM_TARGETS_TO_BUILD}

wasm/InputChunks.h

+//===- InputChunks.h --------------------------------------------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// An input chunk represents an indivisible blocks of code or data from an input
+// file.  i.e. a single wasm data segment or a single wasm function.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_WASM_INPUT_CHUNKS_H
+#define LLD_WASM_INPUT_CHUNKS_H
+
+#include "WriterUtils.h"
+#include "InputFiles.h"
+#include "lld/Common/ErrorHandler.h"
+#include "llvm/Object/Wasm.h"
+
+using llvm::object::WasmSegment;
+using llvm::wasm::WasmFunction;
+using llvm::wasm::WasmRelocation;
+using llvm::wasm::WasmSignature;
+using llvm::object::WasmSection;
+
+namespace lld {
+namespace wasm {
+
+class ObjFile;
+class OutputSegment;
+
+class InputChunk {
+public:
+  InputChunk(const ObjFile &F) : File(F) {}
+  virtual ~InputChunk() = default;
+  void copyRelocations(const WasmSection &Section);
+
+  virtual const uint8_t* getData() const = 0;
+  virtual uint32_t getSize() const = 0;
+  virtual uint32_t getInputSectionOffset() const = 0;
+
+  int32_t OutputOffset = 0;
+  int32_t InputOffset = 0;
+  std::vector<WasmRelocation> Relocations;
+  std::vector<OutputRelocation> OutRelocations;
+  const ObjFile &File;
+};
+
+// Represents a WebAssembly data segment which can be included as part of
+// an output data segments.  Note that in WebAssembly, unlike ELF and other
+// formats, used the term "data segment" to refer to the continous regions of
+// memory that make on the data section. See:
+// https://webassembly.github.io/spec/syntax/modules.html#syntax-data
+//
+// For example, by default, clang will produce a separate data section for
+// each global variable.
+class InputSegment : public InputChunk {
+public:
+  InputSegment(const WasmSegment &Seg, const ObjFile &F)
+      : InputChunk(F), Segment(Seg) {}
+
+  // Translate an offset in the input segment to an offset in the output
+  // segment.
+  uint32_t translateVA(uint32_t Address) const;
+
+  const OutputSegment *getOutputSegment() const { return OutputSeg; }
+
+  void setOutputSegment(const OutputSegment *Segment, uint32_t Offset) {
+    OutputSeg = Segment;
+    OutputOffset = Offset;
+  }
+
+  const uint8_t* getData() const override { return Segment.Data.Content.data(); }
+  uint32_t getSize() const override { return Segment.Data.Content.size(); }
+  uint32_t getInputSectionOffset() const override { return Segment.SectionOffset; }
+  uint32_t getAlignment() const { return Segment.Data.Alignment; }
+  uint32_t startVA() const { return Segment.Data.Offset.Value.Int32; }
+  uint32_t endVA() const { return startVA() + getSize(); }
+  StringRef getName() const { return Segment.Data.Name; }
+
+protected:
+  const WasmSegment &Segment;
+  const OutputSegment *OutputSeg = nullptr;
+};
+
+class InputFunction : public InputChunk {
+public:
+  InputFunction(const WasmSignature &S, const WasmFunction &Func,
+                const ObjFile &F)
+      : InputChunk(F), Signature(S), Function(Func) {
+  }
+
+  uint32_t getSize() const override { return Function.Size; }
+  const uint8_t *getData() const override {
+    return File.CodeSection->Content.data() + Function.CodeSectionOffset;
+  }
+  uint32_t getInputSectionOffset() const override {
+    return Function.CodeSectionOffset;
+  };
+
+  uint32_t getOutputIndex() const { return OutputIndex.getValue(); };
+  bool hasOutputIndex() const { return OutputIndex.hasValue(); };
+  void setOutputIndex(uint32_t Index) {
+    assert(!hasOutputIndex());
+    OutputIndex = Index;
+  };
+
+  const WasmSignature &Signature;
+
+protected:
+  const WasmFunction &Function;
+  llvm::Optional<uint32_t> OutputIndex;
+};
+
+} // namespace wasm
+} // namespace lld
+
+#endif // LLD_WASM_INPUT_CHUNKS_H

wasm/InputChunks.cpp

 //===- InputSegment.cpp ---------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "InputSegment.h"
+#include "InputChunks.h"
 #include "OutputSegment.h"
 #include "lld/Common/LLVM.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace lld::wasm;
 
 uint32_t InputSegment::translateVA(uint32_t Address) const {
   assert(Address >= startVA() && Address < endVA());
-  int32_t Delta = OutputSeg->StartVA + OutputSegmentOffset - startVA();
+  int32_t Delta = OutputSeg->StartVA + OutputOffset - startVA();
   DEBUG(dbgs() << "translateVA: " << getName() << " Delta=" << Delta
                << " Address=" << Address << "\n");
   return Address + Delta;
 }
+
+void InputChunk::copyRelocations(const WasmSection &Section) {
+  size_t Start = getInputSectionOffset();
+  size_t Size = getSize();
+  for (const WasmRelocation &R : Section.Relocations)
+    if (R.Offset >= Start && R.Offset < Start + Size)
+      Relocations.push_back(R);
+}

wasm/InputFiles.h

public:
   uint32_t relocateGlobalIndex(uint32_t Original) const;
   uint32_t relocateTableIndex(uint32_t Original) const;
   uint32_t getRelocatedAddress(uint32_t Index) const;
 
   size_t getNumFunctionImports() const { return NumFunctionImports; }
   size_t getNumGlobalImports() const { return NumGlobalImports; }
 
   const WasmSection *CodeSection = nullptr;
+  const WasmSection *DataSection = nullptr;
 
   std::vector<uint32_t> TypeMap;
   std::vector<InputSegment *> Segments;
   std::vector<InputFunction *> Functions;
 
   ArrayRef<Symbol *> getSymbols() { return Symbols; }
   ArrayRef<Symbol *> getTableSymbols() { return TableSymbols; }
 
private:
   std::vector<Symbol *> FunctionSymbols;
 
   // List of all global symbols indexed by the global index space
   std::vector<Symbol *> GlobalSymbols;
 
   // List of all indirect symbols indexed by table index space.
   std::vector<Symbol *> TableSymbols;
 
-  const WasmSection *DataSection = nullptr;
   uint32_t NumGlobalImports = 0;
   uint32_t NumFunctionImports = 0;
   std::unique_ptr<WasmObjectFile> WasmObj;
 };
 
 // Opens a given file.
 llvm::Optional<MemoryBufferRef> readFile(StringRef Path);
 
 } // namespace wasm
 
 std::string toString(const wasm::InputFile *File);
 
 } // namespace lld
 
 #endif

wasm/InputFiles.cpp

 //===- InputFiles.cpp -----------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "InputFiles.h"
 
 #include "Config.h"
-#include "InputFunction.h"
-#include "InputSegment.h"
+#include "InputChunks.h"
 #include "SymbolTable.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/Wasm.h"
 #include "llvm/Support/raw_ostream.h"
 
 #define DEBUG_TYPE "lld"
if (Address >= Segment->startVA() && Address < Segment->endVA()) {
 
       return Segment;
     }
   }
   error("symbol not found in any segment: " + WasmSym.Name);
   return nullptr;
 }
 
-static void copyRelocationsRange(std::vector<WasmRelocation> &To,
-                                 ArrayRef<WasmRelocation> From, size_t Start,
-                                 size_t Size) {
-  for (const WasmRelocation &R : From)
-    if (R.Offset >= Start && R.Offset < Start + Size)
-      To.push_back(R);
-}
-
 // Get the signature for a given function symbol, either by looking
 // it up in function sections (for defined functions), of the imports section
 // (for imported functions).
 const WasmSignature *ObjFile::getFunctionSig(const WasmSymbol &Sym) const {
   DEBUG(dbgs() << "getFunctionSig: " << Sym.Name << "\n");
   uint32_t FunctionType;
   if (Sym.ElementIndex < NumFunctionImports) {
     const WasmImport &Import = WasmObj->imports()[Sym.ImportIndex];
for (const WasmImport &Import : WasmObj->imports()) {
     }
   }
 
   FunctionSymbols.resize(NumFunctionImports + WasmObj->functions().size());
   GlobalSymbols.resize(NumGlobalImports + WasmObj->globals().size());
 
   for (const WasmSegment &S : WasmObj->dataSegments()) {
     InputSegment *Seg = make<InputSegment>(S, *this);
-    copyRelocationsRange(Seg->Relocations, DataSection->Relocations,
-                         Seg->getInputSectionOffset(), Seg->getSize());
+    Seg->copyRelocations(*DataSection);
     Segments.emplace_back(Seg);
   }
 
   ArrayRef<WasmFunction> Funcs = WasmObj->functions();
   ArrayRef<uint32_t> FuncTypes = WasmObj->functionTypes();
   ArrayRef<WasmSignature> Types = WasmObj->types();
   for (size_t I = 0; I < Funcs.size(); ++I) {
     const WasmFunction &Func = Funcs[I];
     const WasmSignature &Sig = Types[FuncTypes[I]];
-    InputFunction *Function = make<InputFunction>(Sig, Func, *this);
-    copyRelocationsRange(Function->Relocations, CodeSection->Relocations,
-                         Func.CodeSectionOffset, Func.Size);
-    Functions.emplace_back(Function);
+    InputFunction *F = make<InputFunction>(Sig, Func, *this);
+    F->copyRelocations(*CodeSection);
+    Functions.emplace_back(F);
   }
 
   // Populate `FunctionSymbols` and `GlobalSymbols` based on the WasmSymbols
   // in the object
   for (const SymbolRef &Sym : WasmObj->symbols()) {
     const WasmSymbol &WasmSym = WasmObj->getWasmSymbol(Sym.getRawDataRefImpl());
     Symbol *S;
     switch (WasmSym.Type) {

wasm/InputFunction.h

-//===- InpuFunction.h -------------------------------------------*- C++ -*-===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// Represents a WebAssembly function in an input file which could also be
-// assigned a function index in the output.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLD_WASM_INPUT_FUNCTION_H
-#define LLD_WASM_INPUT_FUNCTION_H
-
-#include "WriterUtils.h"
-#include "llvm/Object/Wasm.h"
-
-using llvm::wasm::WasmRelocation;
-using llvm::wasm::WasmFunction;
-
-namespace lld {
-namespace wasm {
-
-class ObjFile;
-
-class InputFunction {
-public:
-  InputFunction(const WasmSignature &S, const WasmFunction &Func,
-                const ObjFile &F)
-      : Signature(S), Function(Func), File(F) {}
-
-  uint32_t getSize() const { return 0; }
-  uint32_t getOutputIndex() const { return OutputIndex.getValue(); };
-  bool hasOutputIndex() const { return OutputIndex.hasValue(); };
-
-  void setOutputIndex(uint32_t Index) {
-    assert(!hasOutputIndex());
-    OutputIndex = Index;
-  };
-
-  const WasmSignature &Signature;
-  const WasmFunction &Function;
-  int32_t OutputOffset = 0;
-  std::vector<WasmRelocation> Relocations;
-  std::vector<OutputRelocation> OutRelocations;
-  const ObjFile &File;
-
-protected:
-  llvm::Optional<uint32_t> OutputIndex;
-};
-
-} // namespace wasm
-} // namespace lld
-
-#endif // LLD_WASM_INPUT_FUNCTION_H

wasm/InputSegment.h

-//===- InputSegment.h -------------------------------------------*- C++ -*-===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// Represents a WebAssembly data segment which can be included as part of
-// an output data segments.  Note that in WebAssembly, unlike ELF and other
-// formats, used the term "data segment" to refer to the continous regions of
-// memory that make on the data section. See:
-// https://webassembly.github.io/spec/syntax/modules.html#syntax-data
-//
-// For example, by default, clang will produce a separate data section for
-// each global variable.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLD_WASM_INPUT_SEGMENT_H
-#define LLD_WASM_INPUT_SEGMENT_H
-
-#include "WriterUtils.h"
-#include "lld/Common/ErrorHandler.h"
-#include "llvm/Object/Wasm.h"
-
-using llvm::object::WasmSegment;
-using llvm::wasm::WasmRelocation;
-
-namespace lld {
-namespace wasm {
-
-class ObjFile;
-class OutputSegment;
-
-class InputSegment {
-public:
-  InputSegment(const WasmSegment &Seg, const ObjFile &F)
-      : Segment(Seg), File(F) {}
-
-  // Translate an offset in the input segment to an offset in the output
-  // segment.
-  uint32_t translateVA(uint32_t Address) const;
-
-  const OutputSegment *getOutputSegment() const { return OutputSeg; }
-
-  uint32_t getOutputSegmentOffset() const { return OutputSegmentOffset; }
-
-  uint32_t getInputSectionOffset() const { return Segment.SectionOffset; }
-
-  void setOutputSegment(const OutputSegment *Segment, uint32_t Offset) {
-    OutputSeg = Segment;
-    OutputSegmentOffset = Offset;
-  }
-
-  uint32_t getSize() const { return Segment.Data.Content.size(); }
-  uint32_t getAlignment() const { return Segment.Data.Alignment; }
-  uint32_t startVA() const { return Segment.Data.Offset.Value.Int32; }
-  uint32_t endVA() const { return startVA() + getSize(); }
-  StringRef getName() const { return Segment.Data.Name; }
-
-  const WasmSegment &Segment;
-  const ObjFile &File;
-  std::vector<WasmRelocation> Relocations;
-  std::vector<OutputRelocation> OutRelocations;
-
-protected:
-  const OutputSegment *OutputSeg = nullptr;
-  uint32_t OutputSegmentOffset = 0;
-};
-
-} // namespace wasm
-} // namespace lld
-
-#endif // LLD_WASM_INPUT_SEGMENT_H

wasm/OutputSections.h

 //===- OutputSections.h -----------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_WASM_OUTPUT_SECTIONS_H
 #define LLD_WASM_OUTPUT_SECTIONS_H
 
-#include "InputSegment.h"
+#include "InputChunks.h"
 #include "WriterUtils.h"
 #include "lld/Common/ErrorHandler.h"
 #include "llvm/ADT/DenseMap.h"
 
 using llvm::raw_ostream;
 using llvm::raw_string_ostream;
 
 namespace lld {
 
 namespace wasm {
 class OutputSection;
 }
 std::string toString(wasm::OutputSection *Section);
 
 namespace wasm {
 
 class OutputSegment;
-class InputFunction;
 
 class OutputSection {
 public:
   OutputSection(uint32_t Type, std::string Name = "")
       : Type(Type), Name(Name) {}
 
   virtual ~OutputSection() = default;
 

wasm/OutputSections.cpp

 //===- OutputSections.cpp -------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "OutputSections.h"
 
 #include "Config.h"
 #include "InputFiles.h"
-#include "InputFunction.h"
+#include "InputChunks.h"
 #include "OutputSegment.h"
 #include "SymbolTable.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Threads.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/LEB128.h"
 
CodeSection::CodeSection(ArrayRef<InputFunction *> Functions)
     : OutputSection(WASM_SEC_CODE), Functions(Functions) {
   assert(Functions.size() > 0);
 
   raw_string_ostream OS(CodeSectionHeader);
   writeUleb128(OS, Functions.size(), "function count");
   OS.flush();
   BodySize = CodeSectionHeader.size();
 
-  for (InputFunction *Func : Functions) {
+  for (InputChunk *Func : Functions) {
     Func->OutputOffset = BodySize;
     calcRelocations(Func->File, Func->Relocations, Func->OutRelocations,
-                    Func->OutputOffset - Func->Function.CodeSectionOffset);
-    BodySize += Func->Function.Size;
+                    Func->OutputOffset - Func->getInputSectionOffset());
+    BodySize += Func->getSize();
   }
 
   createHeader(BodySize);
 }
 
 void CodeSection::writeTo(uint8_t *Buf) {
   log("writing " + toString(this));
   log(" size=" + Twine(getSize()));
   log(" headersize=" + Twine(Header.size()));
   log(" codeheadersize=" + Twine(CodeSectionHeader.size()));
   Buf += Offset;
 
   // Write section header
   memcpy(Buf, Header.data(), Header.size());
   Buf += Header.size();
 
   uint8_t *ContentsStart = Buf;
 
   // Write code section headers
   memcpy(Buf, CodeSectionHeader.data(), CodeSectionHeader.size());
   Buf += CodeSectionHeader.size();
 
   // Write code section bodies
-  parallelForEach(Functions, [ContentsStart](InputFunction *Func) {
-    ArrayRef<uint8_t> Content(Func->File.CodeSection->Content);
-    memcpy(ContentsStart + Func->OutputOffset,
-           Content.data() + Func->Function.CodeSectionOffset,
-           Func->Function.Size);
+  parallelForEach(Functions, [ContentsStart](InputChunk *Func) {
+    memcpy(ContentsStart + Func->OutputOffset, Func->getData(),
+           Func->getSize());
     applyRelocations(ContentsStart, Func->OutRelocations);
   });
 }
 
 uint32_t CodeSection::numRelocations() const {
   uint32_t Count = 0;
-  for (const InputFunction *Func : Functions)
+  for (const InputChunk *Func : Functions)
     Count += Func->OutRelocations.size();
   return Count;
 }
 
 void CodeSection::writeRelocations(raw_ostream &OS) const {
-  for (const InputFunction *Func : Functions)
+  for (const InputChunk *Func : Functions)
     for (const OutputRelocation &Reloc : Func->OutRelocations)
       writeReloc(OS, Reloc);
 }
 
 DataSection::DataSection(ArrayRef<OutputSegment *> Segments)
     : OutputSection(WASM_SEC_DATA), Segments(Segments) {
   raw_string_ostream OS(DataSectionHeader);
 
   writeUleb128(OS, Segments.size(), "data segment count");
   OS.flush();
   BodySize = DataSectionHeader.size();
 
   for (OutputSegment *Segment : Segments) {
     raw_string_ostream OS(Segment->Header);
     writeUleb128(OS, 0, "memory index");
     writeUleb128(OS, WASM_OPCODE_I32_CONST, "opcode:i32const");
     writeSleb128(OS, Segment->StartVA, "memory offset");
     writeUleb128(OS, WASM_OPCODE_END, "opcode:end");
     writeUleb128(OS, Segment->Size, "segment size");
     OS.flush();
     Segment->setSectionOffset(BodySize);
     BodySize += Segment->Header.size();
     log("Data segment: size=" + Twine(Segment->Size));
-    for (InputSegment *InputSeg : Segment->InputSegments) {
+    for (InputChunk *InputSeg : Segment->InputSegments) {
       uint32_t InputOffset = InputSeg->getInputSectionOffset();
       uint32_t OutputOffset = Segment->getSectionOffset() +
                               Segment->Header.size() +
-                              InputSeg->getOutputSegmentOffset();
+                              InputSeg->OutputOffset;
       calcRelocations(InputSeg->File, InputSeg->Relocations,
                       InputSeg->OutRelocations, OutputOffset - InputOffset);
     }
     BodySize += Segment->Size;
   }
 
   createHeader(BodySize);
 }
void DataSection::writeTo(uint8_t *Buf) {
   memcpy(Buf, DataSectionHeader.data(), DataSectionHeader.size());
 
   parallelForEach(Segments, [ContentsStart](const OutputSegment *Segment) {
     // Write data segment header
     uint8_t *SegStart = ContentsStart + Segment->getSectionOffset();
     memcpy(SegStart, Segment->Header.data(), Segment->Header.size());
 
     // Write segment data payload
-    for (const InputSegment *Input : Segment->InputSegments) {
-      ArrayRef<uint8_t> Content(Input->Segment.Data.Content);
-      memcpy(SegStart + Segment->Header.size() +
-                 Input->getOutputSegmentOffset(),
-             Content.data(), Content.size());
+    for (const InputChunk *Input : Segment->InputSegments) {
+      memcpy(SegStart + Segment->Header.size() + Input->OutputOffset,
+             Input->getData(), Input->getSize());
       applyRelocations(ContentsStart, Input->OutRelocations);
     }
   });
 }
 
 uint32_t DataSection::numRelocations() const {
   uint32_t Count = 0;
   for (const OutputSegment *Seg : Segments)
-    for (const InputSegment *InputSeg : Seg->InputSegments)
+    for (const InputChunk *InputSeg : Seg->InputSegments)
       Count += InputSeg->OutRelocations.size();
   return Count;
 }
 
 void DataSection::writeRelocations(raw_ostream &OS) const {
   for (const OutputSegment *Seg : Segments)
-    for (const InputSegment *InputSeg : Seg->InputSegments)
+    for (const InputChunk *InputSeg : Seg->InputSegments)
       for (const OutputRelocation &Reloc : InputSeg->OutRelocations)
         writeReloc(OS, Reloc);
 }

wasm/OutputSegment.h

 //===- OutputSegment.h ------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_WASM_OUTPUT_SEGMENT_H
 #define LLD_WASM_OUTPUT_SEGMENT_H
 
-#include "InputSegment.h"
+#include "InputChunks.h"
 #include "lld/Common/ErrorHandler.h"
 #include "llvm/Object/Wasm.h"
 
 namespace lld {
 namespace wasm {
 
 class InputSegment;
 

wasm/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 "SymbolTable.h"
 
 #include "Config.h"
-#include "InputFunction.h"
+#include "InputChunks.h"
 #include "WriterUtils.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 
 #include <unordered_set>
 
 #define DEBUG_TYPE "lld"
 

wasm/Symbols.cpp

 //===- Symbols.cpp --------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Symbols.h"
 
 #include "Config.h"
 #include "InputFiles.h"
-#include "InputFunction.h"
-#include "InputSegment.h"
+#include "InputChunks.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Strings.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace lld;
 using namespace lld::wasm;

wasm/Writer.cpp

 //===- Writer.cpp ---------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Writer.h"
 
 #include "Config.h"
-#include "InputFunction.h"
+#include "InputChunks.h"
 #include "OutputSections.h"
 #include "OutputSegment.h"
 #include "SymbolTable.h"
 #include "WriterUtils.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Threads.h"
 #include "llvm/Support/FileOutputBuffer.h"