[lld][WebAssembly] Minor refactor in preparation for SHF_STRINGS supports. NFC.

[sbc100]

Summary

A couple of small changes to match the ELF linker in preparation
for adding support string mergings.

[sbc100]

cleanup

lld/wasm/InputChunks.h

 public:
   enum Kind { DataSegment, Function, SyntheticFunction, Section };
 
   Kind kind() const { return sectionKind; }
 
   virtual uint32_t getSize() const { return data().size(); }
   virtual uint32_t getInputSize() const { return getSize(); };
 
-  virtual void writeTo(uint8_t *sectionStart) const;
+  virtual void writeTo(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;

 // 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) {}
+      : InputChunk(f, InputChunk::DataSegment), segment(seg) {
+    alignment = segment.Data.Alignment;
+  }
 
   static bool classof(const InputChunk *c) { return c->kind() == DataSegment; }
 
   void generateRelocationCode(raw_ostream &os) const;
 
-  uint32_t getAlignment() const { return segment.Data.Alignment; }
   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;
   }
   uint64_t getVA(uint64_t offset = 0) const;
 
   const OutputSegment *outputSeg = nullptr;
-  int32_t outputSegmentOffset = 0;
+  uint32_t outputSegmentOffset = 0;
+  uint32_t alignment = 0;
 
 protected:
   ArrayRef<uint8_t> data() const override { return segment.Data.Content; }
 
   const WasmSegment &segment;
 };
 
 // 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()
                        ? (*func->ExportName).str()
                        : llvm::Optional<std::string>()) {}
 
   static bool classof(const InputChunk *c) {
     return c->kind() == InputChunk::Function ||
            c->kind() == InputChunk::SyntheticFunction;
   }
 
-  void writeTo(uint8_t *sectionStart) const override;
+  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; }

lld/wasm/OutputSegment.h

 namespace wasm {
 
 class InputSegment;
 
 class OutputSegment {
 public:
   OutputSegment(StringRef n) : name(n) {}
 
-  void addInputSegment(InputSegment *inSeg, uint32_t forceAlignment = 0) {
-    uint32_t segAlign = std::max(forceAlignment, inSeg->getAlignment());
+  void addInputSegment(InputSegment *inSeg) {
+    uint32_t segAlign = inSeg->alignment;
     alignment = std::max(alignment, segAlign);
     inputSegments.push_back(inSeg);
     size = llvm::alignTo(size, 1ULL << segAlign);
     inSeg->outputSeg = this;
     inSeg->outputSegmentOffset = size;
     size += inSeg->getSize();
   }
 

lld/wasm/Writer.cpp

if (s->name == ".tdata") {
       if (!combined) {
         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) {
-        uint32_t alignment = first ? s->alignment : 0;
+        if (first)
+          inSeg->alignment = std::max(inSeg->alignment, s->alignment);
         first = false;
 #ifndef NDEBUG
         uint64_t oldVA = inSeg->getVA();
 #endif
-        combined->addInputSegment(inSeg, alignment);
+        combined->addInputSegment(inSeg);
 #ifndef NDEBUG
         uint64_t newVA = inSeg->getVA();
         assert(oldVA == newVA);
 #endif
       }
     }
   }
   if (combined) {