[lld][WebAssembly] Refactor input chunk class hierarchy. NFC

[sbc100]

Summary

The main motivation for this refactor is to remove the subclass
relationship between the InputSegment and MergeInputSegment and
SyntenticMergedInputSegment so that we can use the merging classes for
debug sections which are not data segments.

In the process of refactoring I also remove all the virtual functions
from the class hierarchy, reusing techniques used in the ELF
linker (see lld/ELF/InputSections.h).

[sbc100]

• rebase

[sbc100]

• remove last virtual functions

[dschuff]

lld/wasm/InputChunks.h

68–69

123

Ick. I guess this is the trick you borrowed from ELF to avoid virtual functions? I guess the idea is that the subclass can mutate this directly, but the superclass can return it as const?

156

Is this still true?

230

should we rename this kind to MergedChunk?

322

why this naming scheme for body_?

[sbc100]

• feedback

[sbc100]

Thanks!

lld/wasm/InputChunks.h

123

Oops, thanks for spotting that! I don't need that here.. was cargo culted directly from ELF

156

Yes. In fact its more true now since the name here matches the ELF name now.

lld/wasm/Driver.cpp

for (const WrappedSymbol &w : wrapped)
     symtab->wrap(w.sym, w.real, w.wrap);
 }
 
 static void splitSections() {
   // splitIntoPieces needs to be called on each MergeInputSection
   // before calling finalizeContents().
   LLVM_DEBUG(llvm::dbgs() << "splitSections\n");
   parallelForEach(symtab->objectFiles, [](ObjFile *file) {
-    for (InputSegment *seg : file->segments) {
-      if (auto *s = dyn_cast<MergeInputSegment>(seg))
+    for (InputChunk *seg : file->segments) {
+      if (auto *s = dyn_cast<MergeInputChunk>(seg))
         s->splitIntoPieces();
     }
   });
 }
 
 void LinkerDriver::linkerMain(ArrayRef<const char *> argsArr) {
   WasmOptTable parser;
   opt::InputArgList args = parser.parse(argsArr.slice(1));

lld/wasm/InputChunks.h

enum Kind {
     DataSegment,
     Merge,
     MergedSegment,
     Function,
     SyntheticFunction,
     Section
   };
 
-  Kind kind() const { return sectionKind; }
+  StringRef name;
+  StringRef debugName;
+
+  StringRef getName() const { return name; }
+  StringRef getDebugName() const { return debugName; }
+  Kind kind() const { return (Kind)sectionKind; }
 
-  virtual uint32_t getSize() const { return data().size(); }
+  uint32_t getSize() const;
   virtual uint32_t getInputSize() const { return getSize(); };
 
-  virtual void writeTo(uint8_t *buf) const;
+  void writeTo(uint8_t *buf) const;
   void relocate(uint8_t *buf) const;
 
   ArrayRef<WasmRelocation> getRelocations() const { return relocations; }
   void setRelocations(ArrayRef<WasmRelocation> rs) { relocations = rs; }
 
-  uint64_t getOffset(uint64_t offset) const { return outSecOff + offset; }
-  virtual StringRef getName() const = 0;
-  virtual StringRef getDebugName() const = 0;
-  virtual uint32_t getComdat() const = 0;
+  // Translate an offset in the input section to an offset in the output
+  // section.
+  uint64_t getOffset(uint64_t offset) const;
+  // For data segments translate and offset into the input segment into
+  // and offset into the output segment
+  uint64_t getSegmentOffset(uint64_t offset) const;
+  uint64_t getVA(uint64_t offset = 0) const;
+
+  uint32_t getComdat() const { return comdat; }
   StringRef getComdatName() const;
-  virtual uint32_t getInputSectionOffset() const = 0;
+  uint32_t getInputSectionOffset() const { return inputSectionOffset; }
 
   size_t getNumRelocations() const { return relocations.size(); }
   void writeRelocations(llvm::raw_ostream &os) const;
+  void generateRelocationCode(raw_ostream &os) const;
+
+  bool isTLS() const {
+    // Older object files don't include WASM_SEG_FLAG_TLS and instead
+    // relied on the naming convention.
+    return flags & llvm::wasm::WASM_SEG_FLAG_TLS || name.startswith(".tdata") ||
+           name.startswith(".tbss");
+  }
 
   ObjFile *file;
   OutputSection *outputSec = nullptr;
+  uint32_t comdat = UINT32_MAX;
+  uint32_t inputSectionOffset = 0;
+  uint32_t alignment;
+  uint32_t flags;
+
+  // Only applies to data segments.
+  uint32_t outputSegmentOffset = 0;
+  const OutputSegment *outputSeg = nullptr;
 
   // After assignAddresses is called, this represents the offset from
   // the beginning of the output section this chunk was assigned to.
   int32_t outSecOff = 0;
 
+  uint8_t sectionKind : 3;
+
   // Signals that the section is part of the output.  The garbage collector,
   // and COMDAT handling can set a sections' Live bit.
   // If GC is disabled, all sections start out as live by default.
   unsigned live : 1;
 
   // Signals the chunk was discarded by COMDAT handling.
   unsigned discarded : 1;
 
 protected:
-  InputChunk(ObjFile *f, Kind k)
-      : file(f), live(!config->gcSections), discarded(false), sectionKind(k) {}
+  InputChunk(ObjFile *f, Kind k, StringRef name, uint32_t alignment = 0,
+             uint32_t flags = 0)
+      : name(name), file(f), alignment(alignment), flags(flags), sectionKind(k),
+        live(!config->gcSections), discarded(false) {}
   virtual ~InputChunk() = default;
-  virtual ArrayRef<uint8_t> data() const = 0;
+  ArrayRef<uint8_t> data() const { return rawData; }
   virtual uint64_t getTombstone() const { return 0; }
 
   ArrayRef<WasmRelocation> relocations;
-  Kind sectionKind;
+  mutable ArrayRef<uint8_t> rawData;
 };
 
 // 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 continuous 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, ObjFile *f)
-      : InputChunk(f, InputChunk::DataSegment), segment(seg) {
-    alignment = segment->Data.Alignment;
-    flags = segment->Data.LinkingFlags;
+      : InputChunk(f, InputChunk::DataSegment, seg->Data.Name,
+                   seg->Data.Alignment, seg->Data.LinkingFlags),
+        segment(seg) {
+    rawData = segment->Data.Content;
+    comdat = segment->Data.Comdat;
+    inputSectionOffset = segment->SectionOffset;
   }
 
-  InputSegment(uint32_t alignment, uint32_t flags)
-      : InputChunk(nullptr, InputChunk::DataSegment), alignment(alignment),
-        flags(flags) {}
+  InputSegment(StringRef name, uint32_t alignment, uint32_t flags)
+      : InputChunk(nullptr, InputChunk::DataSegment, name, alignment, flags) {}
 
-  static bool classof(const InputChunk *c) {
-    return c->kind() == DataSegment || c->kind() == Merge ||
-           c->kind() == MergedSegment;
-  }
-
-  void generateRelocationCode(raw_ostream &os) const;
-
-  StringRef getName() const override { return segment->Data.Name; }
-  StringRef getDebugName() const override { return StringRef(); }
-  uint32_t getComdat() const override { return segment->Data.Comdat; }
-  uint32_t getInputSectionOffset() const override {
-    return segment->SectionOffset;
-  }
-
-  // Translate an offset in the input section to an offset in the output
-  // section.
-  uint64_t getOffset(uint64_t offset) const;
-
-  uint64_t getVA(uint64_t offset = 0) const;
-
-  bool isTLS() const {
-    // Older object files don't include WASM_SEG_FLAG_TLS and instead
-    // relied on the naming convention.
-    return flags & llvm::wasm::WASM_SEG_FLAG_TLS ||
-           getName().startswith(".tdata") || getName().startswith(".tbss");
-  }
-
-  const OutputSegment *outputSeg = nullptr;
-  uint32_t outputSegmentOffset = 0;
-  uint32_t alignment = 0;
-  uint32_t flags = 0;
+  static bool classof(const InputChunk *c) { return c->kind() == DataSegment; }
 
 protected:
-  ArrayRef<uint8_t> data() const override { return segment->Data.Content; }
-
   const WasmSegment *segment = nullptr;
 };
 
-class SyntheticMergedDataSegment;
+class SyntheticMergedChunk;
 
 // Merge segment handling copied from lld/ELF/InputSection.h.  Keep in sync
 // where possible.
 
-// SegmentPiece represents a piece of splittable segment contents.
+// SectionPiece represents a piece of splittable segment contents.
 // We allocate a lot of these and binary search on them. This means that they
 // have to be as compact as possible, which is why we don't store the size (can
 // be found by looking at the next one).
-struct SegmentPiece {
-  SegmentPiece(size_t off, uint32_t hash, bool live)
+struct SectionPiece {
+  SectionPiece(size_t off, uint32_t hash, bool live)
       : inputOff(off), live(live || !config->gcSections), hash(hash >> 1) {}
 
   uint32_t inputOff;
   uint32_t live : 1;
   uint32_t hash : 31;
   uint64_t outputOff = 0;
 };
 
-static_assert(sizeof(SegmentPiece) == 16, "SectionPiece is too big");
+static_assert(sizeof(SectionPiece) == 16, "SectionPiece is too big");
 
 // This corresponds segments marked as WASM_SEG_FLAG_STRINGS.
-class MergeInputSegment : public InputSegment {
+class MergeInputChunk : public InputChunk {
 public:
-  MergeInputSegment(const WasmSegment *seg, ObjFile *f) : InputSegment(seg, f) {
-    sectionKind = Merge;
+  MergeInputChunk(const WasmSegment *seg, ObjFile *f)
+      : InputChunk(f, Merge, seg->Data.Name, seg->Data.Alignment,
+                   seg->Data.LinkingFlags) {
+    rawData = seg->Data.Content;
+    comdat = seg->Data.Comdat;
+    inputSectionOffset = seg->SectionOffset;
   }
 
   static bool classof(const InputChunk *s) { return s->kind() == Merge; }
   void splitIntoPieces();
 
   // Translate an offset in the input section to an offset in the parent
   // MergeSyntheticSection.
   uint64_t getParentOffset(uint64_t offset) const;
 
   // Splittable sections are handled as a sequence of data
   // rather than a single large blob of data.
-  std::vector<SegmentPiece> pieces;
+  std::vector<SectionPiece> pieces;
 
   // Returns I'th piece's data. This function is very hot when
   // string merging is enabled, so we want to inline.
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   llvm::CachedHashStringRef getData(size_t i) const {
     size_t begin = pieces[i].inputOff;
     size_t end =
         (pieces.size() - 1 == i) ? data().size() : pieces[i + 1].inputOff;
     return {toStringRef(data().slice(begin, end - begin)), pieces[i].hash};
   }
 
   // Returns the SectionPiece at a given input section offset.
-  SegmentPiece *getSegmentPiece(uint64_t offset);
-  const SegmentPiece *getSegmentPiece(uint64_t offset) const {
-    return const_cast<MergeInputSegment *>(this)->getSegmentPiece(offset);
+  SectionPiece *getSectionPiece(uint64_t offset);
+  const SectionPiece *getSectionPiece(uint64_t offset) const {
+    return const_cast<MergeInputChunk *>(this)->getSectionPiece(offset);
   }
 
-  SyntheticMergedDataSegment *parent = nullptr;
+  SyntheticMergedChunk *parent = nullptr;
 
 private:
   void splitStrings(ArrayRef<uint8_t> a);
 };
 
-// SyntheticMergedDataSegment is a class that allows us to put mergeable
+// SyntheticMergedChunk is a class that allows us to put mergeable
 // sections with different attributes in a single output sections. To do that we
-// put them into SyntheticMergedDataSegment synthetic input sections which are
+// put them into SyntheticMergedChunk synthetic input sections which are
 // attached to regular output sections.
-class SyntheticMergedDataSegment : public InputSegment {
+class SyntheticMergedChunk : public InputChunk {
 public:
-  SyntheticMergedDataSegment(StringRef name, uint32_t alignment, uint32_t flags)
-      : InputSegment(alignment, flags), name(name),
-        builder(llvm::StringTableBuilder::RAW, 1ULL << alignment) {
-    sectionKind = InputChunk::MergedSegment;
-  }
+  SyntheticMergedChunk(StringRef name, uint32_t alignment, uint32_t flags)
+      : InputChunk(nullptr, InputChunk::MergedSegment, name, alignment, flags),
+        builder(llvm::StringTableBuilder::RAW, 1ULL << alignment) {}
 
   static bool classof(const InputChunk *c) {
     return c->kind() == InputChunk::MergedSegment;
   }
 
-  uint32_t getSize() const override;
-
-  StringRef getName() const override { return name; }
-
-  uint32_t getComdat() const override { return segments[0]->getComdat(); }
-
-  void writeTo(uint8_t *buf) const override;
-
-  void addMergeSegment(MergeInputSegment *ms) {
+  void addMergeSegment(MergeInputChunk *ms) {
+    comdat = ms->getComdat();
     ms->parent = this;
     segments.push_back(ms);
   }
 
   void finalizeContents();
 
-protected:
-  std::vector<MergeInputSegment *> segments;
-  StringRef name;
   llvm::StringTableBuilder builder;
+
+protected:
+  std::vector<MergeInputChunk *> segments;
 };
 
 // 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, ObjFile *f)
-      : InputChunk(f, InputChunk::Function), signature(s), function(func),
-        exportName(func && func->ExportName.hasValue()
+      : InputChunk(f, InputChunk::Function, func->SymbolName), signature(s),
+        function(func), exportName(func && func->ExportName.hasValue()
                                        ? (*func->ExportName).str()
-                       : llvm::Optional<std::string>()) {}
+                                       : llvm::Optional<std::string>()) {
+    inputSectionOffset = function->CodeSectionOffset;
+    rawData =
+        file->codeSection->Content.slice(inputSectionOffset, function->Size);
+    debugName = function->DebugName;
+    comdat = function->Comdat;
+  }
+
+  InputFunction(StringRef name, const WasmSignature &s)
+      : InputChunk(nullptr, InputChunk::Function, name), signature(s) {}
 
   static bool classof(const InputChunk *c) {
     return c->kind() == InputChunk::Function ||
            c->kind() == InputChunk::SyntheticFunction;
   }
 
-  void writeTo(uint8_t *buf) const override;
-  StringRef getName() const override { return function->SymbolName; }
-  StringRef getDebugName() const override { return function->DebugName; }
   llvm::Optional<StringRef> getExportName() const {
     return exportName.hasValue() ? llvm::Optional<StringRef>(*exportName)
                                  : llvm::Optional<StringRef>();
   }
   void setExportName(std::string exportName) { this->exportName = exportName; }
-  uint32_t getComdat() const override { return function->Comdat; }
   uint32_t getFunctionInputOffset() const { return getInputSectionOffset(); }
   uint32_t getFunctionCodeOffset() const { return function->CodeOffset; }
-  uint32_t getSize() const override {
-    if (config->compressRelocations && file) {
-      assert(compressedSize);
-      return compressedSize;
-    }
-    return data().size();
-  }
   uint32_t getInputSize() const override { return function->Size; }
   uint32_t getFunctionIndex() const { return functionIndex.getValue(); }
   bool hasFunctionIndex() const { return functionIndex.hasValue(); }
   void setFunctionIndex(uint32_t index);
-  uint32_t getInputSectionOffset() const override {
-    return function->CodeSectionOffset;
-  }
   uint32_t getTableIndex() const { return tableIndex.getValue(); }
   bool hasTableIndex() const { return tableIndex.hasValue(); }
   void setTableIndex(uint32_t index);
+  void writeCompressed(uint8_t *buf) const;
 
   // The size of a given input function can depend on the values of the
   // LEB relocations within it.  This finalizeContents method is called after
   // all the symbol values have be calculated but before getSize() is ever
   // called.
   void calculateSize();
 
   const WasmSignature &signature;
 
-protected:
-  ArrayRef<uint8_t> data() const override {
-    assert(!config->compressRelocations);
-    return file->codeSection->Content.slice(getInputSectionOffset(),
-                                            function->Size);
+  uint32_t getCompressedSize() const {
+    assert(compressedSize);
+    return compressedSize;
   }
 
+protected:
   const WasmFunction *function;
   llvm::Optional<std::string> exportName;
   llvm::Optional<uint32_t> functionIndex;
   llvm::Optional<uint32_t> tableIndex;
   uint32_t compressedFuncSize = 0;
   uint32_t compressedSize = 0;
 };
 
 class SyntheticFunction : public InputFunction {
 public:
   SyntheticFunction(const WasmSignature &s, StringRef name,
                     StringRef debugName = {})
-      : InputFunction(s, nullptr, nullptr), name(name), debugName(debugName) {
+      : InputFunction(name, s) {
     sectionKind = InputChunk::SyntheticFunction;
+    this->debugName = debugName;
   }
 
   static bool classof(const InputChunk *c) {
     return c->kind() == InputChunk::SyntheticFunction;
   }
 
-  StringRef getName() const override { return name; }
-  StringRef getDebugName() const override { return debugName; }
-  uint32_t getComdat() const override { return UINT32_MAX; }
-
-  void setBody(ArrayRef<uint8_t> body_) { body = body_; }
-
-protected:
-  ArrayRef<uint8_t> data() const override { return body; }
-
-  StringRef name;
-  StringRef debugName;
-  ArrayRef<uint8_t> body;
+  void setBody(ArrayRef<uint8_t> body_) { rawData = body_; }
 };
 
 // Represents a single Wasm Section within an input file.
 class InputSection : public InputChunk {
 public:
   InputSection(const WasmSection &s, ObjFile *f)
-      : InputChunk(f, InputChunk::Section), section(s), tombstoneValue(getTombstoneForSection(s.Name)) {
+      : InputChunk(f, InputChunk::Section, s.Name), section(s),
+        tombstoneValue(getTombstoneForSection(s.Name)) {
     assert(section.Type == llvm::wasm::WASM_SEC_CUSTOM);
+    comdat = section.Comdat;
+    rawData = section.Content;
   }
 
-  StringRef getName() const override { return section.Name; }
-  StringRef getDebugName() const override { return StringRef(); }
-  uint32_t getComdat() const override { return section.Comdat; }
-
 protected:
-  ArrayRef<uint8_t> data() const override { return section.Content; }
-
-  // Offset within the input section.  This is only zero since this chunk
-  // type represents an entire input section, not part of one.
-  uint32_t getInputSectionOffset() const override { return 0; }
   uint64_t getTombstone() const override { return tombstoneValue; }
   static uint64_t getTombstoneForSection(StringRef name);
 
   const WasmSection &section;
   const uint64_t tombstoneValue;
 };
 
 } // namespace wasm
 
 std::string toString(const wasm::InputChunk *);
 StringRef relocTypeToString(uint8_t relocType);
 
 } // namespace lld
 
 #endif // LLD_WASM_INPUT_CHUNKS_H

lld/wasm/InputChunks.cpp

 namespace wasm {
 StringRef InputChunk::getComdatName() const {
   uint32_t index = getComdat();
   if (index == UINT32_MAX)
     return StringRef();
   return file->getWasmObj()->linkingData().Comdats[index];
 }
 
+uint32_t InputChunk::getSize() const {
+  if (const auto *ms = dyn_cast<SyntheticMergedChunk>(this))
+    return ms->builder.getSize();
+
+  if (const auto *f = dyn_cast<InputFunction>(this)) {
+    if (config->compressRelocations && f->file) {
+      return f->getCompressedSize();
+    }
+  }
+
+  return data().size();
+}
+
 // Copy this input chunk to an mmap'ed output file and apply relocations.
 void InputChunk::writeTo(uint8_t *buf) const {
+  if (const auto *f = dyn_cast<InputFunction>(this)) {
+    if (file && config->compressRelocations)
+      return f->writeCompressed(buf);
+  } else if (const auto *ms = dyn_cast<SyntheticMergedChunk>(this)) {
+    ms->builder.write(buf + outSecOff);
+    // Apply relocations
+    ms->relocate(buf + outSecOff);
+    return;
+  }
+
   // Copy contents
   memcpy(buf + outSecOff, data().data(), data().size());
 
   // Apply relocations
   relocate(buf + outSecOff);
 }
 
 void InputChunk::relocate(uint8_t *buf) const {
void InputFunction::calculateSize() {
   compressedSize = compressedFuncSize + encodeULEB128(compressedFuncSize, buf);
 
   LLVM_DEBUG(dbgs() << "  calculateSize orig: " << function->Size << "\n");
   LLVM_DEBUG(dbgs() << "  calculateSize  new: " << compressedSize << "\n");
 }
 
 // Override the default writeTo method so that we can (optionally) write the
 // compressed version of the function.
-void InputFunction::writeTo(uint8_t *buf) const {
-  if (!file || !config->compressRelocations)
-    return InputChunk::writeTo(buf);
-
+void InputFunction::writeCompressed(uint8_t *buf) const {
   buf += outSecOff;
   uint8_t *orig = buf;
   (void)orig;
 
   const uint8_t *secStart = file->codeSection->Content.data();
   const uint8_t *funcStart = secStart + getInputSectionOffset();
   const uint8_t *end = funcStart + function->Size;
   auto tombstone = getTombstone();
void InputFunction::writeCompressed(uint8_t *buf) const {
   }
 
   unsigned chunkSize = end - lastRelocEnd;
   LLVM_DEBUG(dbgs() << "  write final chunk: " << chunkSize << "\n");
   memcpy(buf, lastRelocEnd, chunkSize);
   LLVM_DEBUG(dbgs() << "  total: " << (buf + chunkSize - orig) << "\n");
 }
 
-uint64_t InputSegment::getOffset(uint64_t offset) const {
-  if (const MergeInputSegment *ms = dyn_cast<MergeInputSegment>(this)) {
-    LLVM_DEBUG(dbgs() << "getOffset(merged): " << getName() << "\n");
+uint64_t InputChunk::getOffset(uint64_t offset) const {
+  return outSecOff + offset;
+}
+
+uint64_t InputChunk::getSegmentOffset(uint64_t offset) const {
+  if (const auto *ms = dyn_cast<MergeInputChunk>(this)) {
+    LLVM_DEBUG(dbgs() << "getSegmentOffset(merged): " << getName() << "\n");
     LLVM_DEBUG(dbgs() << "offset: " << offset << "\n");
     LLVM_DEBUG(dbgs() << "parentOffset: " << ms->getParentOffset(offset)
                       << "\n");
     assert(ms->parent);
-    return ms->parent->getOffset(ms->getParentOffset(offset));
+    return ms->parent->getSegmentOffset(ms->getParentOffset(offset));
   }
   return outputSegmentOffset + offset;
 }
 
-uint64_t InputSegment::getVA(uint64_t offset) const {
-  return (outputSeg ? outputSeg->startVA : 0) + getOffset(offset);
+uint64_t InputChunk::getVA(uint64_t offset) const {
+  return (outputSeg ? outputSeg->startVA : 0) + getSegmentOffset(offset);
 }
 
 // Generate code to apply relocations to the data section at runtime.
 // This is only called when generating shared libaries (PIC) where address are
 // not known at static link time.
-void InputSegment::generateRelocationCode(raw_ostream &os) const {
+void InputChunk::generateRelocationCode(raw_ostream &os) const {
   LLVM_DEBUG(dbgs() << "generating runtime relocations: " << getName()
                     << " count=" << relocations.size() << "\n");
 
   unsigned opcode_ptr_const = config->is64.getValueOr(false)
                                   ? WASM_OPCODE_I64_CONST
                                   : WASM_OPCODE_I32_CONST;
   unsigned opcode_ptr_add = config->is64.getValueOr(false)
                                 ? WASM_OPCODE_I64_ADD
for (const WasmRelocation &rel : relocations) {
     writeU8(os, opcode_reloc_store, "I32_STORE");
     writeUleb128(os, 2, "align");
     writeUleb128(os, 0, "offset");
   }
 }
 
 // Split WASM_SEG_FLAG_STRINGS section. Such a section is a sequence of
 // null-terminated strings.
-void MergeInputSegment::splitStrings(ArrayRef<uint8_t> data) {
+void MergeInputChunk::splitStrings(ArrayRef<uint8_t> data) {
   LLVM_DEBUG(llvm::dbgs() << "splitStrings\n");
   size_t off = 0;
   StringRef s = toStringRef(data);
 
   while (!s.empty()) {
     size_t end = s.find(0);
     if (end == StringRef::npos)
       fatal(toString(this) + ": string is not null terminated");
     size_t size = end + 1;
 
     pieces.emplace_back(off, xxHash64(s.substr(0, size)), true);
     s = s.substr(size);
     off += size;
   }
 }
 
 // This function is called after we obtain a complete list of input sections
 // that need to be linked. This is responsible to split section contents
 // into small chunks for further processing.
 //
 // Note that this function is called from parallelForEach. This must be
 // thread-safe (i.e. no memory allocation from the pools).
-void MergeInputSegment::splitIntoPieces() {
+void MergeInputChunk::splitIntoPieces() {
   assert(pieces.empty());
   // As of now we only support WASM_SEG_FLAG_STRINGS but in the future we
   // could add other types of splitting (see ELF's splitIntoPieces).
-  assert(segment->Data.LinkingFlags & WASM_SEG_FLAG_STRINGS);
+  assert(flags & WASM_SEG_FLAG_STRINGS);
   splitStrings(data());
 }
 
-SegmentPiece *MergeInputSegment::getSegmentPiece(uint64_t offset) {
+SectionPiece *MergeInputChunk::getSectionPiece(uint64_t offset) {
   if (this->data().size() <= offset)
     fatal(toString(this) + ": offset is outside the section");
 
   // If Offset is not at beginning of a section piece, it is not in the map.
   // In that case we need to  do a binary search of the original section piece
   // vector.
   auto it = partition_point(
-      pieces, [=](SegmentPiece p) { return p.inputOff <= offset; });
+      pieces, [=](SectionPiece p) { return p.inputOff <= offset; });
   return &it[-1];
 }
 
 // Returns the offset in an output section for a given input offset.
 // Because contents of a mergeable section is not contiguous in output,
 // it is not just an addition to a base output offset.
-uint64_t MergeInputSegment::getParentOffset(uint64_t offset) const {
+uint64_t MergeInputChunk::getParentOffset(uint64_t offset) const {
   // If Offset is not at beginning of a section piece, it is not in the map.
   // In that case we need to search from the original section piece vector.
-  const SegmentPiece *piece = getSegmentPiece(offset);
+  const SectionPiece *piece = getSectionPiece(offset);
   uint64_t addend = offset - piece->inputOff;
   return piece->outputOff + addend;
 }
 
-uint32_t SyntheticMergedDataSegment::getSize() const {
-  return builder.getSize();
-}
-
-void SyntheticMergedDataSegment::writeTo(uint8_t *buf) const {
-  builder.write(buf + outSecOff);
-
-  // Apply relocations
-  relocate(buf + outSecOff);
-}
-
-void SyntheticMergedDataSegment::finalizeContents() {
+void SyntheticMergedChunk::finalizeContents() {
   // Add all string pieces to the string table builder to create section
   // contents.
-  for (MergeInputSegment *sec : segments)
+  for (MergeInputChunk *sec : segments)
     for (size_t i = 0, e = sec->pieces.size(); i != e; ++i)
       if (sec->pieces[i].live)
         builder.add(sec->getData(i));
 
   // Fix the string table content. After this, the contents will never change.
   builder.finalize();
 
   // finalize() fixed tail-optimized strings, so we can now get
   // offsets of strings. Get an offset for each string and save it
   // to a corresponding SectionPiece for easy access.
-  for (MergeInputSegment *sec : segments)
+  for (MergeInputChunk *sec : segments)
     for (size_t i = 0, e = sec->pieces.size(); i != e; ++i)
       if (sec->pieces[i].live)
         sec->pieces[i].outputOff = builder.getOffset(sec->getData(i));
 }
 
 uint64_t InputSection::getTombstoneForSection(StringRef name) {
   // When a function is not live we need to update relocations referring to it.
   // If they occur in DWARF debug symbols, we want to change the pc of the

lld/wasm/InputFiles.h

public:
 
   // Maps input type indices to output type indices
   std::vector<uint32_t> typeMap;
   std::vector<bool> typeIsUsed;
   // Maps function indices to table indices
   std::vector<uint32_t> tableEntries;
   std::vector<uint32_t> tableEntriesRel;
   std::vector<bool> keptComdats;
-  std::vector<InputSegment *> segments;
+  std::vector<InputChunk *> segments;
   std::vector<InputFunction *> functions;
   std::vector<InputGlobal *> globals;
   std::vector<InputEvent *> events;
   std::vector<InputTable *> tables;
   std::vector<InputSection *> customSections;
   llvm::DenseMap<uint32_t, InputSection *> customSectionsByIndex;
 
   Symbol *getSymbol(uint32_t index) const { return symbols[index]; }

lld/wasm/InputFiles.cpp

void ObjFile::parse(bool ignoreComdats) {
   }
 
   typeMap.resize(getWasmObj()->types().size());
   typeIsUsed.resize(getWasmObj()->types().size(), false);
 
 
   // Populate `Segments`.
   for (const WasmSegment &s : wasmObj->dataSegments()) {
-    InputSegment *seg;
+    InputChunk *seg;
     if (shouldMerge(s)) {
-      seg = make<MergeInputSegment>(&s, this);
+      seg = make<MergeInputChunk>(&s, this);
     } else
       seg = make<InputSegment>(&s, this);
     seg->discarded = isExcludedByComdat(seg);
 
     segments.emplace_back(seg);
   }
   setRelocs(segments, dataSection);
 
InputFunction *func =
         functions[sym.Info.ElementIndex - wasmObj->getNumImportedFunctions()];
     if (sym.isBindingLocal())
       return make<DefinedFunction>(name, flags, this, func);
     if (func->discarded)
       return nullptr;
     return symtab->addDefinedFunction(name, flags, this, func);
   }
   case WASM_SYMBOL_TYPE_DATA: {
-    InputSegment *seg = segments[sym.Info.DataRef.Segment];
+    InputChunk *seg = segments[sym.Info.DataRef.Segment];
     auto offset = sym.Info.DataRef.Offset;
     auto size = sym.Info.DataRef.Size;
     if (sym.isBindingLocal())
       return make<DefinedData>(name, flags, this, seg, offset, size);
     if (seg->discarded)
       return nullptr;
     return symtab->addDefinedData(name, flags, this, seg, offset, size);
   }

lld/wasm/OutputSections.cpp

for (OutputSegment *segment : segments) {
     writeUleb128(os, segment->size, "segment size");
     os.flush();
 
     segment->sectionOffset = bodySize;
     bodySize += segment->header.size() + segment->size;
     log("Data segment: size=" + Twine(segment->size) + ", startVA=" +
         Twine::utohexstr(segment->startVA) + ", name=" + segment->name);
 
-    for (InputSegment *inputSeg : segment->inputSegments) {
+    for (InputChunk *inputSeg : segment->inputSegments) {
       inputSeg->outputSec = this;
       inputSeg->outSecOff = segment->sectionOffset + segment->header.size() +
                             inputSeg->outputSegmentOffset;
     }
   }
 
   createHeader(bodySize);
 }

lld/wasm/OutputSegment.h

 namespace wasm {
 
 class InputSegment;
 
 class OutputSegment {
 public:
   OutputSegment(StringRef n) : name(n) {}
 
-  void addInputSegment(InputSegment *inSeg);
+  void addInputSegment(InputChunk *inSeg);
   void finalizeInputSegments();
 
   bool isTLS() const { return name == ".tdata"; }
 
   StringRef name;
   bool isBss = false;
   uint32_t index = 0;
   uint32_t linkingFlags = 0;
   uint32_t initFlags = 0;
   uint32_t sectionOffset = 0;
   uint32_t alignment = 0;
   uint64_t startVA = 0;
-  std::vector<InputSegment *> inputSegments;
+  std::vector<InputChunk *> inputSegments;
 
   // Sum of the size of the all the input segments
   uint32_t size = 0;
 
   // Segment header
   std::string header;
 };
 
 } // namespace wasm
 } // namespace lld
 
 #endif // LLD_WASM_OUTPUT_SEGMENT_H

lld/wasm/OutputSegment.cpp

 
 using namespace llvm;
 using namespace llvm::wasm;
 
 namespace lld {
 
 namespace wasm {
 
-void OutputSegment::addInputSegment(InputSegment *inSeg) {
+void OutputSegment::addInputSegment(InputChunk *inSeg) {
   alignment = std::max(alignment, inSeg->alignment);
   inputSegments.push_back(inSeg);
   size = llvm::alignTo(size, 1ULL << inSeg->alignment);
   LLVM_DEBUG(dbgs() << "addInputSegment: " << inSeg->getName()
                     << " oname=" << name << " size=" << inSeg->getSize()
                     << " align=" << inSeg->alignment << " at:" << size << "\n");
   inSeg->outputSeg = this;
   inSeg->outputSegmentOffset = size;
   size += inSeg->getSize();
 }
 
 // This function scans over the input segments.
 //
-// It removes MergeInputSegments from the input section array and adds
+// It removes MergeInputChunks from the input section array and adds
 // new synthetic sections at the location of the first input section
 // that it replaces. It then finalizes each synthetic section in order
 // to compute an output offset for each piece of each input section.
 void OutputSegment::finalizeInputSegments() {
   LLVM_DEBUG(llvm::dbgs() << "finalizeInputSegments: " << name << "\n");
-  std::vector<SyntheticMergedDataSegment *> mergedSegments;
-  std::vector<InputSegment *> newSegments;
-  for (InputSegment *s : inputSegments) {
-    MergeInputSegment *ms = dyn_cast<MergeInputSegment>(s);
+  std::vector<SyntheticMergedChunk *> mergedSegments;
+  std::vector<InputChunk *> newSegments;
+  for (InputChunk *s : inputSegments) {
+    MergeInputChunk *ms = dyn_cast<MergeInputChunk>(s);
     if (!ms) {
       newSegments.push_back(s);
       continue;
     }
 
     // A segment should not make it here unless its alive
     assert(ms->live);
 
-    auto i =
-        llvm::find_if(mergedSegments, [=](SyntheticMergedDataSegment *seg) {
-          return seg->flags == ms->flags && seg->alignment == ms->alignment;
-        });
+    auto i = llvm::find_if(mergedSegments, [=](SyntheticMergedChunk *seg) {
     if (i == mergedSegments.end()) {
       LLVM_DEBUG(llvm::dbgs() << "new merge section: " << name
                               << " alignment=" << ms->alignment << "\n");
-      SyntheticMergedDataSegment *syn =
-          make<SyntheticMergedDataSegment>(name, ms->alignment, ms->flags);
+      SyntheticMergedChunk *syn =
+          make<SyntheticMergedChunk>(name, ms->alignment, ms->flags);
       syn->outputSeg = this;
       mergedSegments.push_back(syn);
       i = std::prev(mergedSegments.end());
       newSegments.push_back(syn);
     } else {
       LLVM_DEBUG(llvm::dbgs() << "adding to merge section: " << name << "\n");
     }
     (*i)->addMergeSegment(ms);
   }
 
   for (auto *ms : mergedSegments)
     ms->finalizeContents();
 
   inputSegments = newSegments;
   size = 0;
-  for (InputSegment *seg : inputSegments) {
+  for (InputChunk *seg : inputSegments) {
     size = llvm::alignTo(size, 1ULL << seg->alignment);
     LLVM_DEBUG(llvm::dbgs() << "outputSegmentOffset set: " << seg->getName()
                             << " -> " << size << "\n");
     seg->outputSegmentOffset = size;
     size += seg->getSize();
   }
 }
 
 } // namespace wasm
 } // namespace lld

lld/wasm/SymbolTable.h

public:
 
   void replace(StringRef name, Symbol* sym);
 
   void trace(StringRef name);
 
   Symbol *addDefinedFunction(StringRef name, uint32_t flags, InputFile *file,
                              InputFunction *function);
   Symbol *addDefinedData(StringRef name, uint32_t flags, InputFile *file,
-                         InputSegment *segment, uint64_t address,
-                         uint64_t size);
+                         InputChunk *segment, uint64_t address, uint64_t size);
   Symbol *addDefinedGlobal(StringRef name, uint32_t flags, InputFile *file,
                            InputGlobal *g);
   Symbol *addDefinedEvent(StringRef name, uint32_t flags, InputFile *file,
                           InputEvent *e);
   Symbol *addDefinedTable(StringRef name, uint32_t flags, InputFile *file,
                           InputTable *t);
 
   Symbol *addUndefinedFunction(StringRef name,

lld/wasm/SymbolTable.cpp

Symbol *SymbolTable::addDefinedFunction(StringRef name, uint32_t flags,
   // Existing function with matching signature.
   if (shouldReplace(s, file, flags))
     replaceSym(s);
 
   return s;
 }
 
 Symbol *SymbolTable::addDefinedData(StringRef name, uint32_t flags,
-                                    InputFile *file, InputSegment *segment,
+                                    InputFile *file, InputChunk *segment,
                                     uint64_t address, uint64_t size) {
   LLVM_DEBUG(dbgs() << "addDefinedData:" << name << " addr:" << address
                     << "\n");
   Symbol *s;
   bool wasInserted;
   std::tie(s, wasInserted) = insert(name, file);
 
   auto replaceSym = [&]() {

lld/wasm/Symbols.h

 protected:
   DataSymbol(StringRef name, Kind k, uint32_t flags, InputFile *f)
       : Symbol(name, k, flags, f) {}
 };
 
 class DefinedData : public DataSymbol {
 public:
   // Constructor for regular data symbols originating from input files.
-  DefinedData(StringRef name, uint32_t flags, InputFile *f,
-              InputSegment *segment, uint64_t value, uint64_t size)
+  DefinedData(StringRef name, uint32_t flags, InputFile *f, InputChunk *segment,
+              uint64_t value, uint64_t size)
       : DataSymbol(name, DefinedDataKind, flags, f), segment(segment),
         value(value), size(size) {}
 
   // Constructor for linker synthetic data symbols.
   DefinedData(StringRef name, uint32_t flags)
       : DataSymbol(name, DefinedDataKind, flags, nullptr) {}
 
   static bool classof(const Symbol *s) { return s->kind() == DefinedDataKind; }
 
   // Returns the output virtual address of a defined data symbol.
   uint64_t getVA() const;
   void setVA(uint64_t va);
 
   // Returns the offset of a defined data symbol within its OutputSegment.
   uint64_t getOutputSegmentOffset() const;
   uint64_t getOutputSegmentIndex() const;
   uint64_t getSize() const { return size; }
 
-  InputSegment *segment = nullptr;
+  InputChunk *segment = nullptr;
   uint64_t value = 0;
 
 protected:
   uint64_t size = 0;
 };
 
 class UndefinedData : public DataSymbol {
 public:

lld/wasm/Symbols.cpp

if (auto *e = dyn_cast<DefinedEvent>(this))
     e->event->live = true;
   if (auto *t = dyn_cast<DefinedTable>(this))
     t->table->live = true;
   if (InputChunk *c = getChunk()) {
     // Usually, a whole chunk is marked as live or dead, but in mergeable
     // (splittable) sections, each piece of data has independent liveness bit.
     // So we explicitly tell it which offset is in use.
     if (auto *d = dyn_cast<DefinedData>(this)) {
-      if (auto *ms = dyn_cast<MergeInputSegment>(c)) {
-        ms->getSegmentPiece(d->value)->live = true;
+      if (auto *ms = dyn_cast<MergeInputChunk>(c)) {
+        ms->getSectionPiece(d->value)->live = true;
       }
     }
     c->live = true;
   }
 }
 
 uint32_t Symbol::getOutputSymbolIndex() const {
   assert(outputSymbolIndex != INVALID_INDEX);

 void DefinedData::setVA(uint64_t value_) {
   LLVM_DEBUG(dbgs() << "setVA " << name << " -> " << value_ << "\n");
   assert(!segment);
   value = value_;
 }
 
 uint64_t DefinedData::getOutputSegmentOffset() const {
   LLVM_DEBUG(dbgs() << "getOutputSegmentOffset: " << getName() << "\n");
-  return segment->getOffset(value);
+  return segment->getSegmentOffset(value);
 }
 
 uint64_t DefinedData::getOutputSegmentIndex() const {
   LLVM_DEBUG(dbgs() << "getOutputSegmentIndex: " << getName() << "\n");
   return segment->outputSeg->index;
 }
 
 uint32_t GlobalSymbol::getGlobalIndex() const {

lld/wasm/SyntheticSections.cpp

if (!comdat.empty())
           ComdatEntry{WASM_COMDAT_FUNCTION, f->getFunctionIndex()});
   }
   for (uint32_t i = 0; i < dataSegments.size(); ++i) {
     const auto &inputSegments = dataSegments[i]->inputSegments;
     if (inputSegments.empty())
       continue;
     StringRef comdat = inputSegments[0]->getComdatName();
 #ifndef NDEBUG
-    for (const InputSegment *isec : inputSegments)
+    for (const InputChunk *isec : inputSegments)
       assert(isec->getComdatName() == comdat);
 #endif
     if (!comdat.empty())
       comdats[comdat].emplace_back(ComdatEntry{WASM_COMDAT_DATA, i});
   }
 
   if (!comdats.empty()) {
     SubSection sub(WASM_COMDAT_INFO);

lld/wasm/Writer.cpp

for (auto &feature : file->getWasmObj()->getTargetFeatures()) {
         break;
       default:
         error("Unrecognized feature policy prefix " +
               std::to_string(feature.Prefix));
       }
     }
 
     // Find TLS data segments
-    auto isTLS = [](InputSegment *segment) {
+    auto isTLS = [](InputChunk *segment) {
       return segment->live && segment->isTLS();
     };
     tlsUsed = tlsUsed ||
               std::any_of(file->segments.begin(), file->segments.end(), isTLS);
   }
 
   if (inferFeatures)
     for (const auto &key : used.keys())
void Writer::assignIndexes() {
 
   for (InputTable *table : symtab->syntheticTables)
     out.tableSec->addTable(table);
 
   out.globalSec->assignIndexes();
   out.tableSec->assignIndexes();
 }
 
-static StringRef getOutputDataSegmentName(const InputSegment &seg) {
+static StringRef getOutputDataSegmentName(const InputChunk &seg) {
   // We always merge .tbss and .tdata into a single TLS segment so all TLS
   // symbols are be relative to single __tls_base.
   if (seg.isTLS())
     return ".tdata";
   StringRef name = seg.getName();
   if (!config->mergeDataSegments)
     return name;
   if (name.startswith(".text."))
OutputSegment *Writer::createOutputSegment(StringRef name) {
   if (!config->importMemory && !config->relocatable && name.startswith(".bss"))
     s->isBss = true;
   segments.push_back(s);
   return s;
 }
 
 void Writer::createOutputSegments() {
   for (ObjFile *file : symtab->objectFiles) {
-    for (InputSegment *segment : file->segments) {
+    for (InputChunk *segment : file->segments) {
       if (!segment->live)
         continue;
       StringRef name = getOutputDataSegmentName(*segment);
       OutputSegment *s = nullptr;
       // When running in relocatable mode we can't merge segments that are part
       // of comdat groups since the ultimate linker needs to be able exclude or
       // include them individually.
       if (config->relocatable && !segment->getComdatName().empty()) {
if (s->isTLS()) {
       if (!combined) {
         LLVM_DEBUG(dbgs() << "created combined output segment: .data\n");
         combined = make<OutputSegment>(".data");
         combined->startVA = s->startVA;
         if (config->sharedMemory)
           combined->initFlags = WASM_DATA_SEGMENT_IS_PASSIVE;
       }
       bool first = true;
-      for (InputSegment *inSeg : s->inputSegments) {
+      for (InputChunk *inSeg : s->inputSegments) {
         if (first)
           inSeg->alignment = std::max(inSeg->alignment, s->alignment);
         first = false;
 #ifndef NDEBUG
         uint64_t oldVA = inSeg->getVA();
 #endif
         combined->addInputSegment(inSeg);
 #ifndef NDEBUG

 void Writer::createApplyDataRelocationsFunction() {
   LLVM_DEBUG(dbgs() << "createApplyDataRelocationsFunction\n");
   // First write the body's contents to a string.
   std::string bodyContent;
   {
     raw_string_ostream os(bodyContent);
     writeUleb128(os, 0, "num locals");
     for (const OutputSegment *seg : segments)
-      for (const InputSegment *inSeg : seg->inputSegments)
+      for (const InputChunk *inSeg : seg->inputSegments)
         inSeg->generateRelocationCode(os);
 
     writeU8(os, WASM_OPCODE_END, "END");
   }
 
   createFunction(WasmSym::applyDataRelocs, bodyContent);
 }