[WebAssembly] Do not use inheritance to define SubSection.

[ruiu]

Summary

SubSection inherited from SyntheticSection, and SyntheticSection inherits
from OutputSection, so SubSection was an OutputSection. But that's wrong
because SubSection is not actually a WebAssembly output section.
It shares some functionalities with OutputSection, but overall it's very
different.

This patch removes that inheritance.

[sbc100]

lld/wasm/Writer.cpp

398

This file doesn't use the "lld::wasm" namespace explicitly when calling these writer functions.

[ruiu]

lld/wasm/Writer.cpp

398

Yes, but without this namespace specifier, this function would call itself because it's name is also writeStr

[ruiu]

• removed the fowarding member functions.

lld/wasm/OutputSections.h

public:
   raw_ostream &getStream() { return BodyOutputStream; }
 
   std::string Body;
 
 protected:
   raw_string_ostream BodyOutputStream;
 };
 
-// Some synthetic sections (e.g. "name" and "linking") have subsections.
-// Just like the synthetic sections themselves these need to be created before
-// they can be written out (since they are preceded by their length). This
-// class is used to create subsections and then write them into the stream
-// of the parent section.
-class SubSection : public SyntheticSection {
-public:
-  explicit SubSection(uint32_t Type) : SyntheticSection(Type) {}
-
-  std::string getSectionName() const;
-
-  void writeStr(StringRef Str, StringRef Msg);
-  void writeUleb128(uint32_t Number, StringRef Msg);
-
-  void writeToStream(raw_ostream &OS) {
-    OS.write(Header.data(), Header.size());
-    OS.write(Body.data(), Body.size());
-  }
-};
-
 class CodeSection : public OutputSection {
 public:
   explicit CodeSection(ArrayRef<InputFunction *> Functions);
   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;
 

lld/wasm/OutputSections.cpp

if (!Section.Name.empty())
     rtn += "(" + Section.Name + ")";
   return rtn;
 }
 
 std::string OutputSection::getSectionName() const {
   return sectionTypeToString(Type);
 }
 
-std::string SubSection::getSectionName() const {
-  return std::string("subsection <type=") + std::to_string(Type) + ">";
-}
-
-void SubSection::writeStr(StringRef Str, StringRef Msg) {
-  lld::wasm::writeStr(BodyOutputStream, Str, Msg);
-}
-
-void SubSection::writeUleb128(uint32_t Number, StringRef Msg) {
-  lld::wasm::writeUleb128(BodyOutputStream, Number, Msg);
-}
-
 void OutputSection::createHeader(size_t BodySize) {
   raw_string_ostream OS(Header);
   debugWrite(OS.tell(), "section type [" + Twine(getSectionName()) + "]");
   encodeULEB128(Type, OS);
   writeUleb128(OS, BodySize, "section size");
   OS.flush();
   log("createHeader: " + toString(*this) + " body=" + Twine(BodySize) +
       " total=" + Twine(getSize()));

lld/wasm/Writer.cpp

if (Sym->isWeak())
     Flags |= WASM_SYMBOL_BINDING_WEAK;
   if (Sym->isHidden())
     Flags |= WASM_SYMBOL_VISIBILITY_HIDDEN;
   if (Sym->isUndefined())
     Flags |= WASM_SYMBOL_UNDEFINED;
   return Flags;
 }
 
+// Some synthetic sections (e.g. "name" and "linking") have subsections.
+// Just like the synthetic sections themselves these need to be created before
+// they can be written out (since they are preceded by their length). This
+// class is used to create subsections and then write them into the stream
+// of the parent section.
+class SubSection {
+public:
+  explicit SubSection(uint32_t Type) : Type(Type) {}
+
+  void writeStr(StringRef Str, StringRef Msg) {
+    lld::wasm::writeStr(OS, Str, Msg);
+  }
+
+  void writeUleb128(uint32_t Num, StringRef Msg) {
+    lld::wasm::writeUleb128(OS, Num, Msg);
+  }
+
+  void writeTo(raw_ostream &To) {
+    OS.flush();
+    lld::wasm::writeUleb128(To, Type, "subsection type");
+    lld::wasm::writeUleb128(To, Body.size(), "subsection size");
+    To.write(Body.data(), Body.size());
+  }
+
+private:
+  uint32_t Type;
+  std::string Body;
+  raw_string_ostream OS{Body};
+};
+
 // Create the custom "linking" section containing linker metadata.
 // This is only created when relocatable output is requested.
 void Writer::createLinkingSection() {
   SyntheticSection *Section =
       createSyntheticSection(WASM_SEC_CUSTOM, "linking");
   raw_ostream &OS = Section->getStream();
 
   SubSection DataSizeSubSection(WASM_DATA_SIZE);
   DataSizeSubSection.writeUleb128(DataSize, "data size");
-  DataSizeSubSection.finalizeContents();
-  DataSizeSubSection.writeToStream(OS);
+  DataSizeSubSection.writeTo(OS);
 
   if (!Config->Relocatable)
     return;
 
   if (!SymtabEntries.empty()) {
     SubSection Sub(WASM_SYMBOL_TABLE);
     Sub.writeUleb128(SymtabEntries.size(), "num symbols");
 
for (const Symbol *Sym : SymtabEntries) {
           Sub.writeUleb128(DataSym->getOutputSegmentIndex(), "index");
           Sub.writeUleb128(DataSym->getOutputSegmentOffset(), "data offset");
           Sub.writeUleb128(DataSym->getSize(), "data size");
         }
         break;
       }
     }
 
-    Sub.finalizeContents();
-    Sub.writeToStream(OS);
+    Sub.writeTo(OS);
   }
 
   if (Segments.size()) {
     SubSection Sub(WASM_SEGMENT_INFO);
     Sub.writeUleb128(Segments.size(), "num data segments");
     for (const OutputSegment *S : Segments) {
       Sub.writeStr(S->Name, "segment name");
       Sub.writeUleb128(S->Alignment, "alignment");
       Sub.writeUleb128(0, "flags");
     }
-    Sub.finalizeContents();
-    Sub.writeToStream(OS);
+    Sub.writeTo(OS);
   }
 
   if (!InitFunctions.empty()) {
     SubSection Sub(WASM_INIT_FUNCS);
     Sub.writeUleb128(InitFunctions.size(), "num init functions");
     for (const WasmInitEntry &F : InitFunctions) {
       Sub.writeUleb128(F.Priority, "priority");
       Sub.writeUleb128(F.Sym->getOutputSymbolIndex(), "function index");
     }
-    Sub.finalizeContents();
-    Sub.writeToStream(OS);
+    Sub.writeTo(OS);
   }
 
   struct ComdatEntry { unsigned Kind; uint32_t Index; };
   std::map<StringRef,std::vector<ComdatEntry>> Comdats;
 
   for (const InputFunction *F : InputFunctions) {
     StringRef Comdat = F->getComdat();
     if (!Comdat.empty())
for (const auto &C : Comdats) {
       Sub.writeStr(C.first, "comdat name");
       Sub.writeUleb128(0, "comdat flags"); // flags for future use
       Sub.writeUleb128(C.second.size(), "num entries");
       for (const ComdatEntry &Entry : C.second) {
         Sub.writeUleb128(Entry.Kind, "entry kind");
         Sub.writeUleb128(Entry.Index, "entry index");
       }
     }
-    Sub.finalizeContents();
-    Sub.writeToStream(OS);
+    Sub.writeTo(OS);
   }
 }
 
 // Create the custom "name" section containing debug symbol names.
 void Writer::createNameSection() {
   unsigned NumNames = NumImportedFunctions;
   for (const InputFunction *F : InputFunctions)
     if (!F->getName().empty())
void Writer::createNameSection() {
   }
   for (const InputFunction *F : InputFunctions) {
     if (!F->getName().empty()) {
       Sub.writeUleb128(F->getOutputIndex(), "func index");
       Sub.writeStr(F->getName(), "symbol name");
     }
   }
 
-  Sub.finalizeContents();
-  Sub.writeToStream(Section->getStream());
+  Sub.writeTo(Section->getStream());
 }
 
 void Writer::writeHeader() {
   memcpy(Buffer->getBufferStart(), Header.data(), Header.size());
 }
 
 void Writer::writeSections() {
   uint8_t *Buf = Buffer->getBufferStart();