[WebAssembly] Add data size and alignment to linking section

[sbc100]

Summary

The overal size of the data section (including BSS)
is otherwise not include in the wasm binary.

[dschuff]

lib/MC/WasmObjectWriter.cpp

887

It looks like these sections will come out of order wrt their enum values above. Should we just make data size and alignment be numbers 0 and 1?

934

Maybe we should make the min data alignment be 1? Should we have 0 or missing alignment be some default? Maybe the default should just be the min too. Or we could have the min be 4; in general I guess we'd probably want numbers to have min alignment of 4 (which we can also set in the compiler), but for strings maybe we don't care and can let it be less?

[sbc100]

• - add default alignment of 1

lib/MC/WasmObjectWriter.cpp

934

Changed the default to 1 for now. We can revisit this when I update Linking.md

include/llvm/BinaryFormat/Wasm.h

 
 struct WasmRelocation {
   uint32_t Type;   // The type of the relocation.
   int32_t Index;   // Index into function to global index space.
   uint64_t Offset; // Offset from the start of the section.
   int64_t Addend;  // A value to add to the symbol.
 };
 
+struct WasmLinkingData {
+  uint32_t DataSize;
+  uint32_t DataAlignment;
+};
+
 enum : unsigned {
   WASM_SEC_CUSTOM = 0,   // Custom / User-defined section
   WASM_SEC_TYPE = 1,     // Function signature declarations
   WASM_SEC_IMPORT = 2,   // Import declarations
   WASM_SEC_FUNCTION = 3, // Function declarations
   WASM_SEC_TABLE = 4,    // Indirect function table and other tables
   WASM_SEC_MEMORY = 5,   // Memory attributes
   WASM_SEC_GLOBAL = 6,   // Global declarations
enum class ValType {
   I32 = WASM_TYPE_I32,
   I64 = WASM_TYPE_I64,
   F32 = WASM_TYPE_F32,
   F64 = WASM_TYPE_F64,
 };
 
 // Linking metadata kinds.
 enum : unsigned {
-  WASM_STACK_POINTER = 0x1,
-  WASM_SYMBOL_INFO  = 0x2,
+  WASM_STACK_POINTER  = 0x1,
+  WASM_SYMBOL_INFO    = 0x2,
+  WASM_DATA_SIZE      = 0x3,
+  WASM_DATA_ALIGNMENT = 0x4,
 };
 
 enum : unsigned {
   WASM_SYMBOL_FLAG_WEAK = 0x1,
 };
 
 #define WASM_RELOC(name, value) name = value,
 

include/llvm/Object/Wasm.h

public:
 
   const std::vector<wasm::WasmSignature>& types() const { return Signatures; }
   const std::vector<uint32_t>& functionTypes() const { return FunctionTypes; }
   const std::vector<wasm::WasmImport>& imports() const { return Imports; }
   const std::vector<wasm::WasmTable>& tables() const { return Tables; }
   const std::vector<wasm::WasmLimits>& memories() const { return Memories; }
   const std::vector<wasm::WasmGlobal>& globals() const { return Globals; }
   const std::vector<wasm::WasmExport>& exports() const { return Exports; }
+  const wasm::WasmLinkingData& linkingData() const { return LinkingData; }
 
   uint32_t getNumberOfSymbols() const {
     return Symbols.size();
   }
 
   const std::vector<wasm::WasmElemSegment>& elements() const {
     return ElemSegments;
   }
private:
   std::vector<wasm::WasmImport> Imports;
   std::vector<wasm::WasmExport> Exports;
   std::vector<wasm::WasmElemSegment> ElemSegments;
   std::vector<wasm::WasmDataSegment> DataSegments;
   std::vector<wasm::WasmFunction> Functions;
   std::vector<WasmSymbol> Symbols;
   ArrayRef<uint8_t> CodeSection;
   uint32_t StartFunction = -1;
+  wasm::WasmLinkingData LinkingData;
 
   StringMap<uint32_t> SymbolMap;
 };
 
 } // end namespace object
 
 inline raw_ostream &operator<<(raw_ostream &OS,
                                const object::WasmSymbol &Sym) {
   Sym.print(OS);
   return OS;
 }
 
 } // end namespace llvm
 
 #endif // LLVM_OBJECT_WASM_H

include/llvm/ObjectYAML/WasmYAML.h

 struct LinkingSection : CustomSection {
   LinkingSection() : CustomSection("linking") {}
   static bool classof(const Section *S) {
     auto C = dyn_cast<CustomSection>(S);
     return C && C->Name == "linking";
   }
 
   std::vector<SymbolInfo> SymbolInfos;
+  uint32_t DataSize;
+  uint32_t DataAlignment;
 };
 
 struct TypeSection : Section {
   TypeSection() : Section(wasm::WASM_SEC_TYPE) {}
   static bool classof(const Section *S) {
     return S->Type == wasm::WASM_SEC_TYPE;
   }
 

lib/MC/WasmObjectWriter.cpp

void writeCodeSection(const MCAssembler &Asm, const MCAsmLayout &Layout,
                         const SmallVector<WasmFunction, 4> &Functions);
   uint64_t
   writeDataSection(const SmallVector<char, 0> &DataBytes);
   void writeNameSection(const SmallVector<WasmFunction, 4> &Functions,
                         const SmallVector<WasmImport, 4> &Imports,
                         uint32_t NumFuncImports);
   void writeCodeRelocSection();
   void writeDataRelocSection(uint64_t DataSectionHeaderSize);
-  void writeLinkingMetaDataSection(ArrayRef<StringRef> WeakSymbols,
+  void writeLinkingMetaDataSection(uint32_t DataSize, uint32_t DataAlignment,
+                                   ArrayRef<StringRef> WeakSymbols,
                                    bool HasStackPointer,
                                    uint32_t StackPointerGlobal);
 
   void applyRelocations(ArrayRef<WasmRelocationEntry> Relocations,
                         uint64_t ContentsOffset);
 
   void writeRelocations(ArrayRef<WasmRelocationEntry> Relocations,
                         uint64_t HeaderSize);
void WasmObjectWriter::writeDataRelocSection(uint64_t DataSectionHeaderSize) {
   encodeULEB128(DataRelocations.size(), getStream());
 
   writeRelocations(DataRelocations, DataSectionHeaderSize);
 
   endSection(Section);
 }
 
 void WasmObjectWriter::writeLinkingMetaDataSection(
-    ArrayRef<StringRef> WeakSymbols, bool HasStackPointer,
-    uint32_t StackPointerGlobal) {
-  if (!HasStackPointer && WeakSymbols.empty())
-    return;
-
+    uint32_t DataSize, uint32_t DataAlignment, ArrayRef<StringRef> WeakSymbols,
+    bool HasStackPointer, uint32_t StackPointerGlobal) {
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_CUSTOM, "linking");
   SectionBookkeeping SubSection;
 
   if (HasStackPointer) {
     startSection(SubSection, wasm::WASM_STACK_POINTER);
     encodeULEB128(StackPointerGlobal, getStream()); // id
     endSection(SubSection);
   }
 
   if (WeakSymbols.size() != 0) {
     startSection(SubSection, wasm::WASM_SYMBOL_INFO);
     encodeULEB128(WeakSymbols.size(), getStream());
     for (const StringRef Export: WeakSymbols) {
       writeString(Export);
       encodeULEB128(wasm::WASM_SYMBOL_FLAG_WEAK, getStream());
     }
     endSection(SubSection);
   }
 
+  if (DataSize > 0) {
+    startSection(SubSection, wasm::WASM_DATA_SIZE);
+    encodeULEB128(DataSize, getStream());
+    endSection(SubSection);
+
+    startSection(SubSection, wasm::WASM_DATA_ALIGNMENT);
+    encodeULEB128(DataAlignment, getStream());
+    endSection(SubSection);
+  }
+
   endSection(Section);
 }
 
 void WasmObjectWriter::writeObject(MCAssembler &Asm,
                                    const MCAsmLayout &Layout) {
   DEBUG(dbgs() << "WasmObjectWriter::writeObject\n");
   MCContext &Ctx = Asm.getContext();
   wasm::ValType PtrType = is64Bit() ? wasm::ValType::I64 : wasm::ValType::I32;
 
   // Collect information from the available symbols.
   SmallVector<WasmFunctionType, 4> FunctionTypes;
   SmallVector<WasmFunction, 4> Functions;
   SmallVector<uint32_t, 4> TableElems;
   SmallVector<WasmGlobal, 4> Globals;
   SmallVector<WasmImport, 4> Imports;
   SmallVector<WasmExport, 4> Exports;
   SmallVector<StringRef, 4> WeakSymbols;
   SmallPtrSet<const MCSymbolWasm *, 4> IsAddressTaken;
   unsigned NumFuncImports = 0;
   unsigned NumGlobalImports = 0;
   SmallVector<char, 0> DataBytes;
+  uint32_t DataAlignment = 1;
   uint32_t StackPointerGlobal = 0;
   bool HasStackPointer = false;
 
   // Populate the IsAddressTaken set.
   for (const WasmRelocationEntry &RelEntry : CodeRelocations) {
     switch (RelEntry.Type) {
     case wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB:
     case wasm::R_WEBASSEMBLY_GLOBAL_ADDR_SLEB:
if (WS.isFunction()) {
         report_fatal_error(".size expression must be evaluatable");
 
       auto &DataSection = static_cast<MCSectionWasm &>(WS.getSection());
 
       if (uint64_t(Size) != Layout.getSectionFileSize(&DataSection))
         report_fatal_error("data sections must contain at most one variable");
 
       DataBytes.resize(alignTo(DataBytes.size(), DataSection.getAlignment()));
+      DataAlignment = std::max(DataAlignment, DataSection.getAlignment());
 
       DataSection.setSectionOffset(DataBytes.size());
 
       for (const MCFragment &Frag : DataSection) {
         if (Frag.hasInstructions())
           report_fatal_error("only data supported in data sections");
 
         if (auto *Align = dyn_cast<MCAlignFragment>(&Frag)) {
void WasmObjectWriter::writeObject(MCAssembler &Asm,
   writeExportSection(Exports);
   // TODO: Start Section
   writeElemSection(TableElems);
   writeCodeSection(Asm, Layout, Functions);
   uint64_t DataSectionHeaderSize = writeDataSection(DataBytes);
   writeNameSection(Functions, Imports, NumFuncImports);
   writeCodeRelocSection();
   writeDataRelocSection(DataSectionHeaderSize);
-  writeLinkingMetaDataSection(WeakSymbols, HasStackPointer, StackPointerGlobal);
+  writeLinkingMetaDataSection(DataBytes.size(), DataAlignment, WeakSymbols, HasStackPointer, StackPointerGlobal);
 
   // TODO: Translate the .comment section to the output.
   // TODO: Translate debug sections to the output.
 }
 
 MCObjectWriter *llvm::createWasmObjectWriter(MCWasmObjectTargetWriter *MOTW,
                                              raw_pwrite_stream &OS) {
   return new WasmObjectWriter(MOTW, OS);
 }

lib/Object/WasmObjectFile.cpp

return make_error<StringError>("Zero length section",
                                    object_error::parse_failed);
   Section.Content = ArrayRef<uint8_t>(Ptr, Size);
   Ptr += Size;
   return Error::success();
 }
 
 WasmObjectFile::WasmObjectFile(MemoryBufferRef Buffer, Error &Err)
     : ObjectFile(Binary::ID_Wasm, Buffer) {
+  LinkingData.DataAlignment = 0;
+  LinkingData.DataSize = 0;
+
   ErrorAsOutParameter ErrAsOutParam(&Err);
   Header.Magic = getData().substr(0, 4);
   if (Header.Magic != StringRef("\0asm", 4)) {
     Err = make_error<StringError>("Bad magic number",
                                   object_error::parse_failed);
     return;
   }
   const uint8_t *Ptr = getPtr(4);
case wasm::WASM_SYMBOL_INFO: {
       uint32_t Count = readVaruint32(Ptr);
       while (Count--) {
         StringRef Symbol = readString(Ptr);
         DEBUG(dbgs() << "reading syminfo: " << Symbol << "\n");
         uint32_t Flags = readVaruint32(Ptr);
         auto iter = SymbolMap.find(Symbol);
         if (iter == SymbolMap.end()) {
           return make_error<GenericBinaryError>(
-              "Invalid symbol name in linking section",
+              "Invalid symbol name in linking section: " + Symbol,
               object_error::parse_failed);
         }
         uint32_t SymIndex = iter->second;
         assert(SymIndex < Symbols.size());
         Symbols[SymIndex].Flags = Flags;
         DEBUG(dbgs() << "Set symbol flags index:"
                      << SymIndex << " name:"
                      << Symbols[SymIndex].Name << " exptected:"
                      << Symbol << " flags: " << Flags << "\n");
       }
       break;
     }
+    case wasm::WASM_DATA_SIZE:
+      LinkingData.DataSize = readVaruint32(Ptr);
+      break;
+    case wasm::WASM_DATA_ALIGNMENT:
+      LinkingData.DataAlignment = readVaruint32(Ptr);
+      break;
     case wasm::WASM_STACK_POINTER:
     default:
       Ptr += Size;
       break;
     }
     if (Ptr != SubSectionEnd)
       return make_error<GenericBinaryError>(
           "Linking sub-section ended prematurely", object_error::parse_failed);

lib/ObjectYAML/WasmYAML.cpp

static void sectionMapping(IO &IO, WasmYAML::NameSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapRequired("Name", Section.Name);
   IO.mapOptional("FunctionNames", Section.FunctionNames);
 }
 
 static void sectionMapping(IO &IO, WasmYAML::LinkingSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapRequired("Name", Section.Name);
+  IO.mapRequired("DataSize", Section.DataSize);
+  IO.mapRequired("DataAlignment", Section.DataAlignment);
   IO.mapRequired("SymbolInfo", Section.SymbolInfos);
 }
 
 static void sectionMapping(IO &IO, WasmYAML::CustomSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapRequired("Name", Section.Name);
   IO.mapRequired("Payload", Section.Payload);
 }

test/MC/WebAssembly/unnamed-data.ll

 ; RUN: llc -mtriple wasm32-unknown-unknown-wasm -filetype=obj %s -o - | obj2yaml | FileCheck %s
 
 @.str1 = private unnamed_addr constant [6 x i8] c"hello\00", align 1
 @.str2 = private unnamed_addr constant [6 x i8] c"world\00", align 1
 
 @a = global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str1, i32 0, i32 0), align 8
 @b = global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str2, i32 0, i32 0), align 8
 
 
-; CHECK:   - Type:            GLOBAL
-; CHECK:     Globals:         
-; CHECK:       - Type:            I32
-; CHECK:         Mutable:         false
-; CHECK:         InitExpr:        
-; CHECK:           Opcode:          I32_CONST
-; CHECK:           Value:           0
-; CHECK:       - Type:            I32
-; CHECK:         Mutable:         false
-; CHECK:         InitExpr:        
-; CHECK:           Opcode:          I32_CONST
-; CHECK:           Value:           6
-; CHECK:       - Type:            I32
-; CHECK:         Mutable:         false
-; CHECK:         InitExpr:        
-; CHECK:           Opcode:          I32_CONST
-; CHECK:           Value:           16
-; CHECK:       - Type:            I32
-; CHECK:         Mutable:         false
-; CHECK:         InitExpr:        
-; CHECK:           Opcode:          I32_CONST
-; CHECK:           Value:           24
-; CHECK:   - Type:            EXPORT
-; CHECK:     Exports:         
-; CHECK:       - Name:            a
-; CHECK:         Kind:            GLOBAL
-; CHECK:         Index:           2
-; CHECK:       - Name:            b
-; CHECK:         Kind:            GLOBAL
-; CHECK:         Index:           3
-; CHECK:   - Type:            DATA
-; CHECK:     Relocations:     
-; CHECK:       - Type:            R_WEBASSEMBLY_GLOBAL_ADDR_I32
-; CHECK:         Index:           0
-; CHECK:         Offset:          0x00000016
-; CHECK:       - Type:            R_WEBASSEMBLY_GLOBAL_ADDR_I32
-; CHECK:         Index:           1
-; CHECK:         Offset:          0x0000001E
-; CHECK:     Segments:        
-; CHECK:       - Index:           0
-; CHECK:         Offset:          
-; CHECK:           Opcode:          I32_CONST
-; CHECK:           Value:           0
-; CHECK:         Content:         68656C6C6F00776F726C640000000000000000000000000006000000
+; CHECK:        - Type:            GLOBAL
+; CHECK-NEXT:     Globals:         
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:        
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:        
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           6
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:        
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           16
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:        
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           24
+; CHECK-NEXT:   - Type:            EXPORT
+; CHECK-NEXT:     Exports:         
+; CHECK-NEXT:       - Name:            a
+; CHECK-NEXT:         Kind:            GLOBAL
+; CHECK-NEXT:         Index:           2
+; CHECK-NEXT:       - Name:            b
+; CHECK-NEXT:         Kind:            GLOBAL
+; CHECK-NEXT:         Index:           3
+; CHECK-NEXT:   - Type:            DATA
+; CHECK-NEXT:     Relocations:     
+; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_ADDR_I32
+; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Offset:          0x00000016
+; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_ADDR_I32
+; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:         Offset:          0x0000001E
+; CHECK-NEXT:     Segments:        
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Offset:          
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:         Content:         68656C6C6F00776F726C640000000000000000000000000006000000
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            linking
+; CHECK-NEXT:     DataSize:        28
+; CHECK-NEXT:     DataAlignment:   8
+; CHECK-NEXT:     SymbolInfo:      
+; CHECK-NEXT: ...

test/MC/WebAssembly/weak-alias.ll

 
 ; CHECK:        - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:   
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            foo
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
+; CHECK-NEXT:     DataSize:        0
+; CHECK-NEXT:     DataAlignment:   0
 ; CHECK-NEXT:     SymbolInfo:      
 ; CHECK-NEXT:       - Name:            foo_alias
 ; CHECK-NEXT:         Flags:           1
 ; CHECK-NEXT: ...

test/MC/WebAssembly/weak.ll

 
 ; CHECK:        - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:   
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            weak_function
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
+; CHECK-NEXT:     DataSize:        0
+; CHECK-NEXT:     DataAlignment:   0
 ; CHECK-NEXT:     SymbolInfo:      
 ; CHECK-NEXT:       - Name:            weak_external_data
 ; CHECK-NEXT:         Flags:           1
 ; CHECK-NEXT:       - Name:            weak_function
 ; CHECK-NEXT:         Flags:           1
 ; CHECK-NEXT: ...

test/ObjectYAML/wasm/weak_symbols.yaml

 # RUN: yaml2obj %s | obj2yaml | FileCheck %s
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
+  - Type:            TYPE
+    Signatures:
+      - ReturnType:      I32
+        ParamTypes:
+  - Type:            FUNCTION
+    FunctionTypes:   [ 0, 0 ]
+  - Type:            GLOBAL
+    Globals:         
+      - Type:        I32
+        Mutable:     false
+        InitExpr:
+          Opcode:          I32_CONST
+          Value:           1
   - Type:            EXPORT
     Exports:         
       - Name:            function_export
         Kind:            FUNCTION
         Index:           1
       - Name:            global_export
         Kind:            GLOBAL
-        Index:           2
+        Index:           0
   - Type:            CUSTOM
     Name:            linking
+    DataSize:        10
+    DataAlignment:   2
     SymbolInfo:
       - Name:            function_export
         Flags:           1
       - Name:            global_export
         Flags:           1
 ...
 # CHECK: --- !WASM
 # CHECK: FileHeader:
 # CHECK:   Version:           0x00000001
 # CHECK: Sections:
 # CHECK:   - Type:            EXPORT
 # CHECK:     Exports:         
 # CHECK:       - Name:            function_export
 # CHECK:         Kind:            FUNCTION
 # CHECK:         Index:           1
 # CHECK:       - Name:            global_export
 # CHECK:         Kind:            GLOBAL
-# CHECK:         Index:           2
+# CHECK:         Index:           0
 # CHECK:   - Type:            CUSTOM
 # CHECK:     Name:            linking
+# CHECK:     DataSize:        10
+# CHECK:     DataAlignment:   2
 # CHECK:     SymbolInfo:
 # CHECK:       - Name:            function_export
 # CHECK:         Flags:           1
 # CHECK:       - Name:            global_export
 # CHECK:         Flags:           1

test/tools/llvm-nm/wasm/weak-symbols.yaml

Exports:
       - Name:            weak_global_func
         Kind:            FUNCTION
         Index:           0x00000004
       - Name:            weak_global_data
         Kind:            GLOBAL
         Index:           0x00000002
   - Type:            CUSTOM
     Name:            linking
+    DataSize:        0
+    DataAlignment:   2
     SymbolInfo:
       - Name:            weak_global_func
         Flags:           1
       - Name:            weak_global_data
         Flags:           1
       - Name:            weak_import_func
         Flags:           1
       - Name:            weak_import_data
         Flags:           1
 
 # CHECK: 00000002 W weak_global_data
 # CHECK: 00000004 W weak_global_func
 # CHECK:          w weak_import_data
 # CHECK:          w weak_import_func

tools/obj2yaml/wasm2yaml.cpp

if (WasmSec.Name == "name") {
     std::unique_ptr<WasmYAML::LinkingSection> LinkingSec = make_unique<WasmYAML::LinkingSection>();
     for (const object::SymbolRef& Sym: Obj.symbols()) {
       const object::WasmSymbol Symbol = Obj.getWasmSymbol(Sym);
       if (Symbol.Flags != 0) {
         WasmYAML::SymbolInfo Info = { Symbol.Name, Symbol.Flags };
         LinkingSec->SymbolInfos.push_back(Info);
       }
     }
+    LinkingSec->DataSize = Obj.linkingData().DataSize;
+    LinkingSec->DataAlignment = Obj.linkingData().DataAlignment;
     CustomSec = std::move(LinkingSec);
   } else {
     CustomSec = make_unique<WasmYAML::CustomSection>(WasmSec.Name);
   }
   CustomSec->Payload = yaml::BinaryRef(WasmSec.Content);
   return CustomSec;
 }
 

tools/yaml2obj/yaml2wasm.cpp

static int writeInitExpr(const wasm::WasmInitExpr &InitExpr, raw_ostream &OS) {
   default:
     errs() << "Unknown opcode in init_expr: " << InitExpr.Opcode;
     return 1;
   }
   writeUint8(OS, wasm::WASM_OPCODE_END);
   return 0;
 }
 
+class SubSectionWriter {
+  raw_ostream &OS;
+  std::string OutString;
+  raw_string_ostream StringStream;
+
+public:
+  SubSectionWriter(raw_ostream &OS) : OS(OS), StringStream(OutString) {}
+
+  void Done() {
+    StringStream.flush();
+    encodeULEB128(OutString.size(), OS);
+    OS << OutString;
+    OutString.clear();
+  }
+
+  raw_ostream& GetStream() {
+    return StringStream;
+  }
+};
+
 int WasmWriter::writeSectionContent(raw_ostream &OS, WasmYAML::LinkingSection &Section) {
   writeStringRef(Section.Name, OS);
+
+  SubSectionWriter SubSection(OS);
+
+  // DATA_SIZE subsection
+  encodeULEB128(wasm::WASM_DATA_SIZE, OS);
+  encodeULEB128(Section.DataSize, SubSection.GetStream());
+  SubSection.Done();
+
+  // DATA_ALIGNMENT subsection
+  encodeULEB128(wasm::WASM_DATA_ALIGNMENT, OS);
+  encodeULEB128(Section.DataAlignment, SubSection.GetStream());
+  SubSection.Done();
+
+  // SYMBOL_INFO subsection
   if (Section.SymbolInfos.size()) {
     encodeULEB128(wasm::WASM_SYMBOL_INFO, OS);
-    std::string OutString;
-    raw_string_ostream StringStream(OutString);
 
-    encodeULEB128(Section.SymbolInfos.size(), StringStream);
+    encodeULEB128(Section.SymbolInfos.size(), SubSection.GetStream());
     for (const WasmYAML::SymbolInfo &Info : Section.SymbolInfos) {
-      writeStringRef(Info.Name, StringStream);
-      encodeULEB128(Info.Flags, StringStream);
+      writeStringRef(Info.Name, SubSection.GetStream());
+      encodeULEB128(Info.Flags, SubSection.GetStream());
     }
 
-    StringStream.flush();
-    encodeULEB128(OutString.size(), OS);
-    OS << OutString;
+    SubSection.Done();
   }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS, WasmYAML::NameSection &Section) {
   writeStringRef(Section.Name, OS);
   if (Section.FunctionNames.size()) {
     encodeULEB128(wasm::WASM_NAMES_FUNCTION, OS);
-    std::string OutString;
-    raw_string_ostream StringStream(OutString);
 
-    encodeULEB128(Section.FunctionNames.size(), StringStream);
+    SubSectionWriter SubSection(OS);
+
+    encodeULEB128(Section.FunctionNames.size(), SubSection.GetStream());
     for (const WasmYAML::NameEntry &NameEntry : Section.FunctionNames) {
-      encodeULEB128(NameEntry.Index, StringStream);
-      writeStringRef(NameEntry.Name, StringStream);
+      encodeULEB128(NameEntry.Index, SubSection.GetStream());
+      writeStringRef(NameEntry.Name, SubSection.GetStream());
     }
 
-    StringStream.flush();
-    encodeULEB128(OutString.size(), OS);
-    OS << OutString;
+    SubSection.Done();
   }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::CustomSection &Section) {
   if (auto S = dyn_cast<WasmYAML::NameSection>(&Section)) {
     if (auto Err = writeSectionContent(OS, *S))