[WebAssembly] Move code and data sectiion generation to finalizeContent. NFC.

[sbc100]

Summary

Previously these sections were being generated during their
constructors. This moves the work to finalizeContent, and also does
the same for the relocation sections because their contents depends
on the final layout too.

This change is smaller part of a larger refactor to how we deal
with synthetic sections: https://reviews.llvm.org/D61811

[sbc100]

• remove isNeeded

[sbc100]

• reduce diff

[sbc100]

• whitespace

[ruiu]

LGTM

lld/trunk/wasm/OutputSections.h

72 ↗

(On Diff #199906)

Could you add a comment as to what this function is supposed to do? E.g.

writeBody writes section contents to Body string. You need to call this function before fixing section layout because otherwise section size is not known.

lld/wasm/OutputSections.h

public:
   StringRef getSectionName() const;
   void setOffset(size_t NewOffset) {
     log("setOffset: " + toString(*this) + ": " + Twine(NewOffset));
     Offset = NewOffset;
   }
   void createHeader(size_t BodySize);
   virtual size_t getSize() const = 0;
   virtual void writeTo(uint8_t *Buf) = 0;
-  virtual void finalizeContents() {}
+  virtual void finalizeContents() = 0;
   virtual uint32_t numRelocations() const { return 0; }
   virtual void writeRelocations(raw_ostream &OS) const {}
 
   std::string Header;
   uint32_t Type;
   std::string Name;
 
 protected:
void writeTo(uint8_t *Buf) override {
     assert(Offset);
     log("writing " + toString(*this));
     memcpy(Buf + Offset, Header.data(), Header.size());
     memcpy(Buf + Offset + Header.size(), Body.data(), Body.size());
   }
 
   size_t getSize() const override { return Header.size() + Body.size(); }
 
+  virtual void writeBody() {}
+
   void finalizeContents() override {
+    writeBody();
     BodyOutputStream.flush();
     createHeader(Body.size());
   }
 
   raw_ostream &getStream() { return BodyOutputStream; }
 
   std::string Body;
 
 protected:
   llvm::raw_string_ostream BodyOutputStream;
 };
 
 class CodeSection : public OutputSection {
 public:
-  explicit CodeSection(ArrayRef<InputFunction *> Functions);
-  size_t getSize() const override { return Header.size() + BodySize; }
+  explicit CodeSection(ArrayRef<InputFunction *> Functions)
+      : OutputSection(llvm::wasm::WASM_SEC_CODE), Functions(Functions) {}
+
+  size_t getSize() const override { assert(BodySize); return Header.size() + BodySize; }
   void writeTo(uint8_t *Buf) override;
   uint32_t numRelocations() const override;
   void writeRelocations(raw_ostream &OS) const override;
+  void finalizeContents() override;
 
 protected:
   ArrayRef<InputFunction *> Functions;
   std::string CodeSectionHeader;
   size_t BodySize = 0;
 };
 
 class DataSection : public OutputSection {
 public:
-  explicit DataSection(ArrayRef<OutputSegment *> Segments);
+  explicit DataSection(ArrayRef<OutputSegment *> Segments)
+      : OutputSection(llvm::wasm::WASM_SEC_DATA), Segments(Segments) {}
+
   size_t getSize() const override { return Header.size() + BodySize; }
   void writeTo(uint8_t *Buf) override;
   uint32_t numRelocations() const override;
   void writeRelocations(raw_ostream &OS) const override;
+  void finalizeContents() override;
 
 protected:
   ArrayRef<OutputSegment *> Segments;
   std::string DataSectionHeader;
   size_t BodySize = 0;
 };
 
 // Represents a custom section in the output file.  Wasm custom sections are
 // used for storing user-defined metadata.  Unlike the core sections types
 // they are identified by their string name.
 // The linker combines custom sections that have the same name by simply
 // concatenating them.
 // Note that some custom sections such as "name" and "linking" are handled
 // separately and are instead synthesized by the linker.
 class CustomSection : public OutputSection {
 public:
-  CustomSection(std::string Name, ArrayRef<InputSection *> InputSections);
+  CustomSection(std::string Name, ArrayRef<InputSection *> InputSections)
+      : OutputSection(llvm::wasm::WASM_SEC_CUSTOM, Name),
+        InputSections(InputSections) {}
   size_t getSize() const override {
     return Header.size() + NameData.size() + PayloadSize;
   }
   void writeTo(uint8_t *Buf) override;
   uint32_t numRelocations() const override;
   void writeRelocations(raw_ostream &OS) const override;
+  void finalizeContents() override;
 
 protected:
-  size_t PayloadSize;
+  size_t PayloadSize = 0;
   ArrayRef<InputSection *> InputSections;
   std::string NameData;
 };
 
+class RelocSection : public SyntheticSection {
+public:
+  RelocSection(StringRef Name, OutputSection *Sec, uint32_t SectionIndex)
+      : SyntheticSection(llvm::wasm::WASM_SEC_CUSTOM, Name), Sec(Sec),
+        SectionIndex(SectionIndex) {}
+  void writeBody() override;
+
+protected:
+  OutputSection* Sec;
+  uint32_t SectionIndex;
+};
+
+
 } // namespace wasm
 } // namespace lld
 
 #endif // LLD_WASM_OUTPUT_SECTIONS_H

lld/wasm/OutputSections.cpp

void OutputSection::createHeader(size_t BodySize) {
   debugWrite(OS.tell(), "section type [" + getSectionName() + "]");
   encodeULEB128(Type, OS);
   writeUleb128(OS, BodySize, "section size");
   OS.flush();
   log("createHeader: " + toString(*this) + " body=" + Twine(BodySize) +
       " total=" + Twine(getSize()));
 }
 
-CodeSection::CodeSection(ArrayRef<InputFunction *> Functions)
-    : OutputSection(WASM_SEC_CODE), Functions(Functions) {
-  assert(Functions.size() > 0);
-
+void CodeSection::finalizeContents() {
   raw_string_ostream OS(CodeSectionHeader);
   writeUleb128(OS, Functions.size(), "function count");
   OS.flush();
   BodySize = CodeSectionHeader.size();
 
   for (InputFunction *Func : Functions) {
     Func->OutputOffset = BodySize;
     Func->calculateSize();
uint32_t CodeSection::numRelocations() const {
   return Count;
 }
 
 void CodeSection::writeRelocations(raw_ostream &OS) const {
   for (const InputChunk *C : Functions)
     C->writeRelocations(OS);
 }
 
-DataSection::DataSection(ArrayRef<OutputSegment *> Segments)
-    : OutputSection(WASM_SEC_DATA), Segments(Segments) {
+void DataSection::finalizeContents() {
   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);

 }
 
 void DataSection::writeRelocations(raw_ostream &OS) const {
   for (const OutputSegment *Seg : Segments)
     for (const InputChunk *C : Seg->InputSegments)
       C->writeRelocations(OS);
 }
 
-CustomSection::CustomSection(std::string Name,
-                             ArrayRef<InputSection *> InputSections)
-    : OutputSection(WASM_SEC_CUSTOM, Name), PayloadSize(0),
-      InputSections(InputSections) {
+void CustomSection::finalizeContents() {
   raw_string_ostream OS(NameData);
   encodeULEB128(Name.size(), OS);
   OS << Name;
   OS.flush();
 
   for (InputSection *Section : InputSections) {
     Section->OutputOffset = PayloadSize;
     PayloadSize += Section->getSize();
for (const InputSection *InputSect : InputSections)
     Count += InputSect->NumRelocations();
   return Count;
 }
 
 void CustomSection::writeRelocations(raw_ostream &OS) const {
   for (const InputSection *S : InputSections)
     S->writeRelocations(OS);
 }
+
+void RelocSection::writeBody() {
+  writeUleb128(BodyOutputStream, SectionIndex, "reloc section");
+  writeUleb128(BodyOutputStream, Sec->numRelocations(), "reloc count");
+  Sec->writeRelocations(BodyOutputStream);
+}

lld/wasm/Writer.cpp

for (size_t I = 0; I < OrigSize; I++) {
     else if (OSec->Type == WASM_SEC_CODE)
       Name = "reloc.CODE";
     else if (OSec->Type == WASM_SEC_CUSTOM)
       Name = Saver.save("reloc." + OSec->Name);
     else
       llvm_unreachable(
           "relocations only supported for code, data, or custom sections");
 
-    SyntheticSection *Section = createSyntheticSection(WASM_SEC_CUSTOM, Name);
-    raw_ostream &OS = Section->getStream();
-    writeUleb128(OS, I, "reloc section");
-    writeUleb128(OS, Count, "reloc count");
-    OSec->writeRelocations(OS);
+    OutputSections.push_back(make<RelocSection>(Name, OSec, I));
   }
 }
 
 static uint32_t getWasmFlags(const Symbol *Sym) {
   uint32_t Flags = 0;
   if (Sym->isLocal())
     Flags |= WASM_SYMBOL_BINDING_LOCAL;
   if (Sym->isWeak())