[WebAssembly] Move relocation handling to InputChunks.cpp. NFC

[sbc100]

Summary

Teach each input chunk how to write itself and apply its
own relocations.

[sbc100]

• more more reloc code

[ncw]

Looks fine, it's just moving some code around (to a better place).

I've nearly finished with my patch for the 'aliased symbol index' problem, which will modify this same bit of code to tweak the relocation handling. That's not a problem, I'll try to open the review for it quickly so I'm not rebasing it for too long!

lld/trunk/wasm/InputChunks.h

 namespace lld {
 namespace wasm {
 
 class ObjFile;
 class OutputSegment;
 
 class InputChunk {
 public:
-  InputChunk(const ObjFile &F) : File(F) {}
-  virtual ~InputChunk() = default;
+  virtual uint32_t getSize() const = 0;
+
   void copyRelocations(const WasmSection &Section);
 
+  void writeTo(uint8_t *SectionStart) const;
+
+  void setOutputOffset(uint32_t Offset) {
+    OutputOffset = Offset;
+    calcRelocations();
+  }
+
+  uint32_t getOutputOffset() const { return OutputOffset; }
+
+  std::vector<OutputRelocation> OutRelocations;
+
+protected:
+  InputChunk(const ObjFile &F) : File(F) {}
+  virtual ~InputChunk() = default;
+  void calcRelocations();
   virtual const uint8_t *getData() const = 0;
-  virtual uint32_t getSize() const = 0;
   virtual uint32_t getInputSectionOffset() const = 0;
 
-  int32_t OutputOffset = 0;
   std::vector<WasmRelocation> Relocations;
-  std::vector<OutputRelocation> OutRelocations;
+  int32_t OutputOffset = 0;
   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;
+    OutputSegmentOffset = 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; }
 
+  int32_t OutputSegmentOffset = 0;
+
 protected:
+  uint32_t getInputSectionOffset() const override {
+    return Segment.SectionOffset;
+  }
   const WasmSegment &Segment;
   const OutputSegment *OutputSeg = nullptr;
 };
 
 // Represents a single wasm function within and input file.  These are
 // combined to create the final output CODE section.
 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;
+    return File.CodeSection->Content.data() + getInputSectionOffset();
   }
-  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:
+  uint32_t getInputSectionOffset() const override {
+    return Function.CodeSectionOffset;
+  }
   const WasmFunction &Function;
   llvm::Optional<uint32_t> OutputIndex;
 };
 
 } // namespace wasm
 } // namespace lld
 
 #endif // LLD_WASM_INPUT_CHUNKS_H

lld/trunk/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 "InputChunks.h"
+#include "Config.h"
 #include "OutputSegment.h"
+#include "lld/Common/ErrorHandler.h"
 #include "lld/Common/LLVM.h"
+#include "llvm/Support/LEB128.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
+using namespace llvm::wasm;
+using namespace lld;
 using namespace lld::wasm;
 
 uint32_t InputSegment::translateVA(uint32_t Address) const {
   assert(Address >= startVA() && Address < endVA());
-  int32_t Delta = OutputSeg->StartVA + OutputOffset - startVA();
+  int32_t Delta = OutputSeg->StartVA + OutputSegmentOffset - 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);
 }
+
+static void applyRelocation(uint8_t *Buf, const OutputRelocation &Reloc) {
+  DEBUG(dbgs() << "write reloc: type=" << Reloc.Reloc.Type
+               << " index=" << Reloc.Reloc.Index << " value=" << Reloc.Value
+               << " offset=" << Reloc.Reloc.Offset << "\n");
+  Buf += Reloc.Reloc.Offset;
+  int64_t ExistingValue;
+  switch (Reloc.Reloc.Type) {
+  case R_WEBASSEMBLY_TYPE_INDEX_LEB:
+  case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
+    ExistingValue = decodeULEB128(Buf);
+    if (ExistingValue != Reloc.Reloc.Index) {
+      DEBUG(dbgs() << "existing value: " << decodeULEB128(Buf) << "\n");
+      assert(decodeULEB128(Buf) == Reloc.Reloc.Index);
+    }
+    LLVM_FALLTHROUGH;
+  case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
+  case R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
+    encodeULEB128(Reloc.Value, Buf, 5);
+    break;
+  case R_WEBASSEMBLY_TABLE_INDEX_SLEB:
+    ExistingValue = decodeSLEB128(Buf);
+    if (ExistingValue != Reloc.Reloc.Index) {
+      DEBUG(dbgs() << "existing value: " << decodeSLEB128(Buf) << "\n");
+      assert(decodeSLEB128(Buf) == Reloc.Reloc.Index);
+    }
+    LLVM_FALLTHROUGH;
+  case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
+    encodeSLEB128(static_cast<int32_t>(Reloc.Value), Buf, 5);
+    break;
+  case R_WEBASSEMBLY_TABLE_INDEX_I32:
+  case R_WEBASSEMBLY_MEMORY_ADDR_I32:
+    support::endian::write32<support::little>(Buf, Reloc.Value);
+    break;
+  default:
+    llvm_unreachable("unknown relocation type");
+  }
+}
+
+static void applyRelocations(uint8_t *Buf, ArrayRef<OutputRelocation> Relocs) {
+  if (!Relocs.size())
+    return;
+  log("applyRelocations: count=" + Twine(Relocs.size()));
+  for (const OutputRelocation &Reloc : Relocs)
+    applyRelocation(Buf, Reloc);
+}
+
+void InputChunk::writeTo(uint8_t *SectionStart) const {
+  memcpy(SectionStart + getOutputOffset(), getData(), getSize());
+  applyRelocations(SectionStart, OutRelocations);
+}
+
+// Populate OutRelocations based on the input relocations and offset within the
+// output section.  Calculates the updated index and offset for each relocation
+// as well as the value to write out in the final binary.
+void InputChunk::calcRelocations() {
+  int32_t Off = getOutputOffset() - getInputSectionOffset();
+  log("calcRelocations: " + File.getName() + " offset=" + Twine(Off));
+  for (const WasmRelocation &Reloc : Relocations) {
+    OutputRelocation NewReloc;
+    NewReloc.Reloc = Reloc;
+    assert(Reloc.Offset + Off > 0);
+    NewReloc.Reloc.Offset += Off;
+    DEBUG(dbgs() << "reloc: type=" << Reloc.Type << " index=" << Reloc.Index
+                 << " offset=" << Reloc.Offset
+                 << " newOffset=" << NewReloc.Reloc.Offset << "\n");
+
+    if (Config->EmitRelocs)
+      NewReloc.NewIndex = File.calcNewIndex(Reloc);
+
+    switch (Reloc.Type) {
+    case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
+    case R_WEBASSEMBLY_MEMORY_ADDR_I32:
+    case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
+      NewReloc.Value = File.getRelocatedAddress(Reloc.Index) + Reloc.Addend;
+      break;
+    default:
+      NewReloc.Value = File.calcNewIndex(Reloc);
+      break;
+    }
+
+    OutRelocations.emplace_back(NewReloc);
+  }
+}

lld/trunk/wasm/InputFiles.h

 #include <vector>
 
 using llvm::object::Archive;
 using llvm::object::WasmObjectFile;
 using llvm::object::WasmSection;
 using llvm::object::WasmSymbol;
 using llvm::wasm::WasmImport;
 using llvm::wasm::WasmSignature;
+using llvm::wasm::WasmRelocation;
 
 namespace lld {
 namespace wasm {
 
 class InputFunction;
 class InputSegment;
 
 class InputFile {
public:
 
   void parse() override;
 
   // Returns the underlying wasm file.
   const WasmObjectFile *getWasmObj() const { return WasmObj.get(); }
 
   void dumpInfo() const;
 
-  uint32_t relocateTypeIndex(uint32_t Original) const;
   uint32_t relocateFunctionIndex(uint32_t Original) const;
-  uint32_t relocateGlobalIndex(uint32_t Original) const;
-  uint32_t relocateTableIndex(uint32_t Original) const;
   uint32_t getRelocatedAddress(uint32_t Index) const;
+  uint32_t calcNewIndex(const WasmRelocation &Reloc) const;
 
   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:
+  uint32_t relocateTypeIndex(uint32_t Original) const;
+  uint32_t relocateGlobalIndex(uint32_t Original) const;
+  uint32_t relocateTableIndex(uint32_t Original) const;
+
   Symbol *createDefined(const WasmSymbol &Sym, Symbol::Kind Kind,
                         const InputSegment *Segment = nullptr,
                         InputFunction *Function = nullptr,
                         uint32_t Address = UINT32_MAX);
   Symbol *createUndefined(const WasmSymbol &Sym, Symbol::Kind Kind,
                           const WasmSignature *Signature = nullptr);
   void initializeSymbols();
   InputSegment *getSegment(const WasmSymbol &WasmSym) const;

lld/trunk/wasm/InputFiles.cpp

 uint32_t ObjFile::relocateGlobalIndex(uint32_t Original) const {
   Symbol *Sym = GlobalSymbols[Original];
   uint32_t Index = Sym->hasOutputIndex() ? Sym->getOutputIndex() : 0;
   DEBUG(dbgs() << "relocateGlobalIndex: " << toString(*Sym) << ": " << Original
                << " -> " << Index << "\n");
   return Index;
 }
 
+// Relocations contain an index into the function, global or table index
+// space of the input file.  This function takes a relocation and returns the
+// relocated index (i.e. translates from the input index space to the output
+// index space).
+uint32_t ObjFile::calcNewIndex(const WasmRelocation &Reloc) const {
+  switch (Reloc.Type) {
+  case R_WEBASSEMBLY_TYPE_INDEX_LEB:
+    return relocateTypeIndex(Reloc.Index);
+  case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
+    return relocateFunctionIndex(Reloc.Index);
+  case R_WEBASSEMBLY_TABLE_INDEX_I32:
+  case R_WEBASSEMBLY_TABLE_INDEX_SLEB:
+    return relocateTableIndex(Reloc.Index);
+  case R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
+  case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
+  case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
+  case R_WEBASSEMBLY_MEMORY_ADDR_I32:
+    return relocateGlobalIndex(Reloc.Index);
+  default:
+    llvm_unreachable("unknown relocation type");
+  }
+}
+
 void ObjFile::parse() {
   // Parse a memory buffer as a wasm file.
   DEBUG(dbgs() << "Parsing object: " << toString(this) << "\n");
   std::unique_ptr<Binary> Bin = CHECK(createBinary(MB), toString(this));
 
   auto *Obj = dyn_cast<WasmObjectFile>(Bin.get());
   if (!Obj)
     fatal(toString(this) + ": not a wasm file");

lld/trunk/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 "InputChunks.h"
 #include "InputFiles.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"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;
 using namespace lld;
 using namespace lld::wasm;
 
-enum class RelocEncoding {
-  Uleb128,
-  Sleb128,
-  I32,
-};
-
 static StringRef sectionTypeToString(uint32_t SectionType) {
   switch (SectionType) {
   case WASM_SEC_CUSTOM:
     return "CUSTOM";
   case WASM_SEC_TYPE:
     return "TYPE";
   case WASM_SEC_IMPORT:
     return "IMPORT";

 
 std::string lld::toString(const OutputSection &Section) {
   std::string rtn = Section.getSectionName();
   if (!Section.Name.empty())
     rtn += "(" + Section.Name + ")";
   return rtn;
 }
 
-static void applyRelocation(uint8_t *Buf, const OutputRelocation &Reloc) {
-  DEBUG(dbgs() << "write reloc: type=" << Reloc.Reloc.Type
-               << " index=" << Reloc.Reloc.Index << " value=" << Reloc.Value
-               << " offset=" << Reloc.Reloc.Offset << "\n");
-  Buf += Reloc.Reloc.Offset;
-  int64_t ExistingValue;
-  switch (Reloc.Reloc.Type) {
-  case R_WEBASSEMBLY_TYPE_INDEX_LEB:
-  case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
-    ExistingValue = decodeULEB128(Buf);
-    if (ExistingValue != Reloc.Reloc.Index) {
-      DEBUG(dbgs() << "existing value: " << decodeULEB128(Buf) << "\n");
-      assert(decodeULEB128(Buf) == Reloc.Reloc.Index);
-    }
-    LLVM_FALLTHROUGH;
-  case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
-  case R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
-    encodeULEB128(Reloc.Value, Buf, 5);
-    break;
-  case R_WEBASSEMBLY_TABLE_INDEX_SLEB:
-    ExistingValue = decodeSLEB128(Buf);
-    if (ExistingValue != Reloc.Reloc.Index) {
-      DEBUG(dbgs() << "existing value: " << decodeSLEB128(Buf) << "\n");
-      assert(decodeSLEB128(Buf) == Reloc.Reloc.Index);
-    }
-    LLVM_FALLTHROUGH;
-  case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
-    encodeSLEB128(static_cast<int32_t>(Reloc.Value), Buf, 5);
-    break;
-  case R_WEBASSEMBLY_TABLE_INDEX_I32:
-  case R_WEBASSEMBLY_MEMORY_ADDR_I32:
-    support::endian::write32<support::little>(Buf, Reloc.Value);
-    break;
-  default:
-    llvm_unreachable("unknown relocation type");
-  }
-}
-
-static void applyRelocations(uint8_t *Buf, ArrayRef<OutputRelocation> Relocs) {
-  if (!Relocs.size())
-    return;
-  log("applyRelocations: count=" + Twine(Relocs.size()));
-  for (const OutputRelocation &Reloc : Relocs)
-    applyRelocation(Buf, Reloc);
-}
-
-// Relocations contain an index into the function, global or table index
-// space of the input file.  This function takes a relocation and returns the
-// relocated index (i.e. translates from the input index space to the output
-// index space).
-static uint32_t calcNewIndex(const ObjFile &File, const WasmRelocation &Reloc) {
-  switch (Reloc.Type) {
-  case R_WEBASSEMBLY_TYPE_INDEX_LEB:
-    return File.relocateTypeIndex(Reloc.Index);
-  case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
-    return File.relocateFunctionIndex(Reloc.Index);
-  case R_WEBASSEMBLY_TABLE_INDEX_I32:
-  case R_WEBASSEMBLY_TABLE_INDEX_SLEB:
-    return File.relocateTableIndex(Reloc.Index);
-  case R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
-  case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
-  case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
-  case R_WEBASSEMBLY_MEMORY_ADDR_I32:
-    return File.relocateGlobalIndex(Reloc.Index);
-  default:
-    llvm_unreachable("unknown relocation type");
-  }
-}
-
-// Take a vector of relocations from an input file and create output
-// relocations based on them. Calculates the updated index and offset for
-// each relocation as well as the value to write out in the final binary.
-static void calcRelocations(const ObjFile &File,
-                            ArrayRef<WasmRelocation> Relocs,
-                            std::vector<OutputRelocation> &OutputRelocs,
-                            int32_t OutputOffset) {
-  log("calcRelocations: " + File.getName() + " offset=" + Twine(OutputOffset));
-  for (const WasmRelocation &Reloc : Relocs) {
-    OutputRelocation NewReloc;
-    NewReloc.Reloc = Reloc;
-    assert(Reloc.Offset + OutputOffset > 0);
-    NewReloc.Reloc.Offset += OutputOffset;
-    DEBUG(dbgs() << "reloc: type=" << Reloc.Type << " index=" << Reloc.Index
-                 << " offset=" << Reloc.Offset
-                 << " newOffset=" << NewReloc.Reloc.Offset << "\n");
-
-    if (Config->EmitRelocs)
-      NewReloc.NewIndex = calcNewIndex(File, Reloc);
-
-    switch (Reloc.Type) {
-    case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
-    case R_WEBASSEMBLY_MEMORY_ADDR_I32:
-    case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
-      NewReloc.Value = File.getRelocatedAddress(Reloc.Index) + Reloc.Addend;
-      break;
-    default:
-      NewReloc.Value = calcNewIndex(File, Reloc);
-      break;
-    }
-
-    OutputRelocs.emplace_back(NewReloc);
-  }
-}
-
 std::string OutputSection::getSectionName() const {
   return sectionTypeToString(Type);
 }
 
 std::string SubSection::getSectionName() const {
   return std::string("subsection <type=") + std::to_string(Type) + ">";
 }
 
CodeSection::CodeSection(ArrayRef<InputFunction *> Functions)
   assert(Functions.size() > 0);
 
   raw_string_ostream OS(CodeSectionHeader);
   writeUleb128(OS, Functions.size(), "function count");
   OS.flush();
   BodySize = CodeSectionHeader.size();
 
   for (InputChunk *Func : Functions) {
-    Func->OutputOffset = BodySize;
-    calcRelocations(Func->File, Func->Relocations, Func->OutRelocations,
-                    Func->OutputOffset - Func->getInputSectionOffset());
+    Func->setOutputOffset(BodySize);
     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](InputChunk *Func) {
-    memcpy(ContentsStart + Func->OutputOffset, Func->getData(),
-           Func->getSize());
-    applyRelocations(ContentsStart, Func->OutRelocations);
+  parallelForEach(Functions, [ContentsStart](const InputChunk *Chunk) {
+    Chunk->writeTo(ContentsStart);
   });
 }
 
 uint32_t CodeSection::numRelocations() const {
   uint32_t Count = 0;
   for (const InputChunk *Func : Functions)
     Count += Func->OutRelocations.size();
   return Count;
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();
+    BodySize += Segment->Header.size() + Segment->Size;
     log("Data segment: size=" + Twine(Segment->Size));
-    for (InputChunk *InputSeg : Segment->InputSegments) {
-      uint32_t OutputOffset = Segment->getSectionOffset() +
-                              Segment->Header.size() + InputSeg->OutputOffset;
-      calcRelocations(InputSeg->File, InputSeg->Relocations,
-                      InputSeg->OutRelocations,
-                      OutputOffset - InputSeg->getInputSectionOffset());
-    }
-    BodySize += Segment->Size;
+    for (InputSegment *InputSeg : Segment->InputSegments)
+      InputSeg->setOutputOffset(Segment->getSectionOffset() +
+                                Segment->Header.size() +
+                                InputSeg->OutputSegmentOffset);
   }
 
   createHeader(BodySize);
 }
 
 void DataSection::writeTo(uint8_t *Buf) {
   log("writing " + toString(*this) + " size=" + Twine(getSize()) +
       " body=" + Twine(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 InputChunk *Input : Segment->InputSegments) {
-      memcpy(SegStart + Segment->Header.size() + Input->OutputOffset,
-             Input->getData(), Input->getSize());
-      applyRelocations(ContentsStart, Input->OutRelocations);
-    }
+    for (const InputChunk *Chunk : Segment->InputSegments)
+      Chunk->writeTo(ContentsStart);
   });
 }
 
 uint32_t DataSection::numRelocations() const {
   uint32_t Count = 0;
   for (const OutputSegment *Seg : Segments)
     for (const InputChunk *InputSeg : Seg->InputSegments)
       Count += InputSeg->OutRelocations.size();