[WebAssembly] Remove DataSize from linking metadata section

[sbc100]

Summary

We no longer need DataDize in the object format. Its was originally intended to
handle BSS, but that plan is now to use segment metadata to enable BSS
segments.

[sbc100]

• update tests

[sbc100]

• rebase

[ncw]

Not much that could go wrong here, fine.

include/llvm/BinaryFormat/Wasm.h

 };
 
 struct WasmInitFunc {
   uint32_t Priority;
   uint32_t FunctionIndex;
 };
 
 struct WasmLinkingData {
-  uint32_t DataSize;
   std::vector<WasmInitFunc> InitFunctions;
 };
 
 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
enum class ValType {
   I64 = WASM_TYPE_I64,
   F32 = WASM_TYPE_F32,
   F64 = WASM_TYPE_F64,
 };
 
 // Linking metadata kinds.
 enum : unsigned {
   WASM_SYMBOL_INFO    = 0x2,
-  WASM_DATA_SIZE      = 0x3,
   WASM_SEGMENT_INFO   = 0x5,
   WASM_INIT_FUNCS     = 0x6,
 };
 
 const unsigned WASM_SYMBOL_BINDING_MASK       = 0x3;
 const unsigned WASM_SYMBOL_VISIBILITY_MASK    = 0x4;
 
 const unsigned WASM_SYMBOL_BINDING_GLOBAL     = 0x0;

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";
   }
 
-  uint32_t DataSize;
   std::vector<SymbolInfo> SymbolInfos;
   std::vector<SegmentInfo> SegmentInfos;
   std::vector<InitFunction> InitFunctions;
 };
 
 struct TypeSection : Section {
   TypeSection() : Section(wasm::WASM_SEC_TYPE) {}
 

lib/MC/WasmObjectWriter.cpp

void writeCodeSection(const MCAssembler &Asm, const MCAsmLayout &Layout,
                         ArrayRef<WasmFunction> Functions);
   void writeDataSection(ArrayRef<WasmDataSegment> Segments);
   void writeNameSection(ArrayRef<WasmFunction> Functions,
                         ArrayRef<WasmImport> Imports,
                         uint32_t NumFuncImports);
   void writeCodeRelocSection();
   void writeDataRelocSection();
   void writeLinkingMetaDataSection(
-      ArrayRef<WasmDataSegment> Segments, uint32_t DataSize,
+      ArrayRef<WasmDataSegment> Segments,
       const SmallVector<std::pair<StringRef, uint32_t>, 4> &SymbolFlags,
       const SmallVector<std::pair<uint16_t, uint32_t>, 2> &InitFuncs);
 
   uint32_t getProvisionalValue(const WasmRelocationEntry &RelEntry);
   void applyRelocations(ArrayRef<WasmRelocationEntry> Relocations,
                         uint64_t ContentsOffset);
 
   void writeRelocations(ArrayRef<WasmRelocationEntry> Relocations);
void WasmObjectWriter::writeDataRelocSection() {
   encodeULEB128(DataRelocations.size(), getStream());
 
   writeRelocations(DataRelocations);
 
   endSection(Section);
 }
 
 void WasmObjectWriter::writeLinkingMetaDataSection(
-    ArrayRef<WasmDataSegment> Segments, uint32_t DataSize,
+    ArrayRef<WasmDataSegment> Segments,
     const SmallVector<std::pair<StringRef, uint32_t>, 4> &SymbolFlags,
     const SmallVector<std::pair<uint16_t, uint32_t>, 2> &InitFuncs) {
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_CUSTOM, "linking");
   SectionBookkeeping SubSection;
 
   if (SymbolFlags.size() != 0) {
     startSection(SubSection, wasm::WASM_SYMBOL_INFO);
     encodeULEB128(SymbolFlags.size(), getStream());
     for (auto Pair: SymbolFlags) {
       writeString(Pair.first);
       encodeULEB128(Pair.second, getStream());
     }
     endSection(SubSection);
   }
 
-  if (DataSize > 0) {
-    startSection(SubSection, wasm::WASM_DATA_SIZE);
-    encodeULEB128(DataSize, getStream());
-    endSection(SubSection);
-  }
-
   if (Segments.size()) {
     startSection(SubSection, wasm::WASM_SEGMENT_INFO);
     encodeULEB128(Segments.size(), getStream());
     for (const WasmDataSegment &Segment : Segments) {
       writeString(Segment.Name);
       encodeULEB128(Segment.Alignment, getStream());
       encodeULEB128(Segment.Flags, getStream());
     }
void WasmObjectWriter::writeObject(MCAssembler &Asm,
   writeGlobalSection();
   writeExportSection(Exports);
   writeElemSection(TableElems);
   writeCodeSection(Asm, Layout, Functions);
   writeDataSection(DataSegments);
   writeNameSection(Functions, Imports, NumFuncImports);
   writeCodeRelocSection();
   writeDataRelocSection();
-  writeLinkingMetaDataSection(DataSegments, DataSize, SymbolFlags,
-                              InitFuncs);
+  writeLinkingMetaDataSection(DataSegments, SymbolFlags, InitFuncs);
 
   // TODO: Translate the .comment section to the output.
   // TODO: Translate debug sections to the output.
 }
 
 std::unique_ptr<MCObjectWriter>
 llvm::createWasmObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW,
                              raw_pwrite_stream &OS) {
   // FIXME: Can't use make_unique<WasmObjectWriter>(...) as WasmObjectWriter's
   //        destructor is private. Is that necessary?
   return std::unique_ptr<MCObjectWriter>(
       new WasmObjectWriter(std::move(MOTW), OS));
 }

lib/Object/WasmObjectFile.cpp

return make_error<StringError>("Section too large",
                                    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.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;
   }
 
case wasm::WASM_SYMBOL_INFO: {
         Symbols[SymIndex].Flags = Flags;
         DEBUG(dbgs() << "Set symbol flags index:"
                      << SymIndex << " name:"
                      << Symbols[SymIndex].Name << " expected:"
                      << Symbol << " flags: " << Flags << "\n");
       }
       break;
     }
-    case wasm::WASM_DATA_SIZE:
-      LinkingData.DataSize = readVaruint32(Ptr);
-      break;
     case wasm::WASM_SEGMENT_INFO: {
       uint32_t Count = readVaruint32(Ptr);
       if (Count > DataSegments.size())
         return make_error<GenericBinaryError>("Too many segment names",
                                               object_error::parse_failed);
       for (uint32_t i = 0; i < Count; i++) {
         DataSegments[i].Data.Name = readString(Ptr);
         DataSegments[i].Data.Alignment = readVaruint32(Ptr);

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.mapOptional("SymbolInfo", Section.SymbolInfos);
   IO.mapOptional("SegmentInfo", Section.SegmentInfos);
   IO.mapOptional("InitFunctions", Section.InitFunctions);
 }
 
 static void sectionMapping(IO &IO, WasmYAML::CustomSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapRequired("Name", Section.Name);

test/MC/WebAssembly/array-fill.ll

 ; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s
 ; PR33624
 
 source_filename = "ws.c"
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown-wasm"
 
 %struct.bd = type { i8 }
 
 @gBd = hidden global [2 x %struct.bd] [%struct.bd { i8 1 }, %struct.bd { i8 2 }], align 1
 
 ; CHECK:        - Type:            DATA
 ; CHECK:              Content:         '0102'
 
 ; CHECK:        - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
-; CHECK-NEXT:     DataSize:        2
 ; CHECK-NEXT:     SymbolInfo:      
 ; CHECK-NEXT:       - Name:            gBd
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
 ; CHECK-NEXT:     SegmentInfo:    
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            .data
 ; CHECK-NEXT:         Alignment:       1
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT: ...

test/MC/WebAssembly/bss.ll

 ; CHECK-NEXT:       - SectionOffset:  30 
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           9
 ; CHECK-NEXT:         Content:         '00'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
-; CHECK-NEXT:     DataSize:        10
 ; CHECK-NEXT:     SegmentInfo:    
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            .bss.g0
 ; CHECK-NEXT:         Alignment:       4
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            .bss.g1
 ; CHECK-NEXT:         Alignment:       4

test/MC/WebAssembly/explicit-sections.ll

 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           24
 ; CHECK-NEXT:         Content:         '08000000'
 
 ; CHECK:        - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
-; CHECK-NEXT:     DataSize:        28
 ; CHECK-NEXT:     SegmentInfo:    
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            .data.global0
 ; CHECK-NEXT:         Alignment:       8
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            .sec1
 ; CHECK-NEXT:         Alignment:       8
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            .sec2
 ; CHECK-NEXT:         Alignment:       8
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT: ...

test/MC/WebAssembly/init-fini-array.ll

 ; CHECK-NEXT:       - Index:           6
 ; CHECK-NEXT:         Name:            .Lregister_call_dtors.42
 ; CHECK-NEXT:       - Index:           7
 ; CHECK-NEXT:         Name:            .Lcall_dtors
 ; CHECK-NEXT:       - Index:           8
 ; CHECK-NEXT:         Name:            .Lregister_call_dtors
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
-; CHECK-NEXT:     DataSize:        4
 ; CHECK-NEXT:     SymbolInfo:      
 ; CHECK-NEXT:       - Name:            __dso_handle
 ; CHECK-NEXT:         Flags:           [ BINDING_WEAK, VISIBILITY_HIDDEN ]
 ; CHECK-NEXT:       - Name:            .Lcall_dtors.42
 ; CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; CHECK-NEXT:       - Name:            .Lregister_call_dtors.42
 ; CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; CHECK-NEXT:       - Name:            .Lcall_dtors

test/MC/WebAssembly/unnamed-data.ll

 ; CHECK-NEXT:       - SectionOffset:   37
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           24
 ; CHECK-NEXT:         Content:         '06000000'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
-; CHECK-NEXT:     DataSize:        28
 ; CHECK-NEXT:     SymbolInfo:      
 ; CHECK-NEXT:       - Name:            .L.str1
 ; CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; CHECK-NEXT:       - Name:            .L.str2
 ; CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; CHECK-NEXT:     SegmentInfo:    
 ; CHECK-NEXT:       - Index:       0
 ; CHECK-NEXT:         Name:        .rodata..L.str1

test/MC/WebAssembly/visibility.ll

 entry:
   ret void
 }
 
 ; CHECK:        - Type:            CUSTOM
 
 ; CHECK:        - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
-; CHECK-NEXT:     DataSize:        0
 ; CHECK-NEXT:     SymbolInfo:
 ; CHECK-NEXT:       - Name:            hiddenVis
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
 ; CHECK-NEXT: ...

test/MC/WebAssembly/weak-alias.ll

 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:   
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            call_alias
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            foo
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
-; CHECK-NEXT:     DataSize:        12
 ; CHECK-NEXT:     SymbolInfo:      
 ; CHECK-NEXT:       - Name:            call_alias
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
 ; CHECK-NEXT:       - Name:            foo
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
 ; CHECK-NEXT:       - Name:            foo_alias
 ; CHECK-NEXT:         Flags:           [ BINDING_WEAK, VISIBILITY_HIDDEN ]
 ; CHECK-NEXT:       - Name:            bar_alias

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:     SymbolInfo:      
 ; CHECK-NEXT:       - Name:            weak_external_data
 ; CHECK-NEXT:         Flags:           [ BINDING_WEAK ]
 ; CHECK-NEXT:       - Name:            weak_function
 ; CHECK-NEXT:         Flags:           [ BINDING_WEAK, VISIBILITY_HIDDEN ]
 ; CHECK-NEXT: ...

test/ObjectYAML/wasm/linking_section.yaml

Segments:
         Content:         '10001000'
       - MemoryIndex:      0
         Offset:
           Opcode:          I32_CONST
           Value:           8
         Content:         '11110000'
   - Type:            CUSTOM
     Name:            linking
-    DataSize:        999
     SymbolInfo:
       - Name:            bar
         Flags:           [ BINDING_WEAK ]
     SegmentInfo:
       - Index:       0
         Alignment:   4
         Flags:       [ ]
         Name:        mydata
       - Index:       1
         Alignment:   2
         Flags:       [ ]
         Name:        moredata
     InitFunctions:
       - Priority:      1
         FunctionIndex: 0
 ...
 # CHECK:       - Type:            CUSTOM
 # CHECK-NEXT:    Name:            linking
-# CHECK-NEXT:    DataSize:        999
 # CHECK-NEXT:    SymbolInfo:
 # CHECK-NEXT:      - Name:            bar
 # CHECK-NEXT:        Flags:           [ BINDING_WEAK ]
 # CHECK-NEXT:    SegmentInfo:
 # CHECK-NEXT:      - Index:           0
 # CHECK-NEXT:        Name:            mydata
 # CHECK-NEXT:        Alignment:       4
 # CHECK-NEXT:        Flags:           [ ]
 # CHECK-NEXT:      - Index:           1
 # CHECK-NEXT:        Name:            moredata
 # CHECK-NEXT:        Alignment:       2
 # CHECK-NEXT:        Flags:           [ ]
 # CHECK-NEXT:    InitFunctions:
 # CHECK-NEXT:       - Priority:       1
 # CHECK-NEXT:         FunctionIndex:  0
 # CHECK-NEXT: ...

test/ObjectYAML/wasm/weak_symbols.yaml

Exports:
       - Name:            function_export
         Kind:            FUNCTION
         Index:           1
       - Name:            global_export
         Kind:            GLOBAL
         Index:           0
   - Type:            CUSTOM
     Name:            linking
-    DataSize:        10
     SymbolInfo:
       - Name:            function_export
         Flags:           [ BINDING_WEAK ]
       - Name:            global_export
         Flags:           [ BINDING_WEAK ]
 ...
 # 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:           0
 # CHECK:   - Type:            CUSTOM
 # CHECK:     Name:            linking
-# CHECK:     DataSize:        10
 # CHECK:     SymbolInfo:
 # CHECK:       - Name:            function_export
 # CHECK:         Flags:           [ BINDING_WEAK ]
 # CHECK:       - Name:            global_export
 # CHECK:         Flags:           [ BINDING_WEAK ]

test/tools/llvm-nm/wasm/exports.yaml

Exports:
       - Name:            foo
         Kind:            FUNCTION
         Index:           0x00000004
       - Name:            bar
         Kind:            GLOBAL
         Index:           0x00000003
   - Type:            CUSTOM
     Name:            "linking"
-    DataSize:        0
 
 # CHECK:      00000400 D bar
 # CHECK-NEXT:          U fimport
 # CHECK-NEXT: 00000004 T foo
 # CHECK-NEXT:          U gimport

test/tools/llvm-nm/wasm/imports.yaml

Imports:
         SigIndex:        0
       - Module:          env
         Field:           bar
         Kind:            GLOBAL
         GlobalType:      I32
         GlobalMutable:   false
   - Type:            CUSTOM
     Name:            "linking"
-    DataSize:        0
 
 # CHECK:    U bar
 # CHECK:    U foo

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

Exports:
       - Name:            weak_global_func
         Kind:            FUNCTION
         Index:           0x00000004
       - Name:            weak_global_data
         Kind:            GLOBAL
         Index:           0x00000003
   - Type:            CUSTOM
     Name:            linking
-    DataSize:        0
     SymbolInfo:
       - Name:            weak_global_func
         Flags:           [ BINDING_WEAK ]
       - Name:            weak_global_data
         Flags:           [ BINDING_WEAK ]
       - Name:            weak_import_func
         Flags:           [ BINDING_WEAK ]
       - Name:            weak_import_data
         Flags:           [ BINDING_WEAK ]
 
 # CHECK: 00000400 W weak_global_data
 # CHECK: 00000004 W weak_global_func
 # CHECK:          w weak_import_data
 # CHECK:          w weak_import_func

test/tools/llvm-readobj/sections.test

 WASM-NEXT:     Offset: 228
 WASM-NEXT:     Name: reloc.CODE
 WASM-NEXT:   }
 WASM-NEXT:   Section {
 WASM-NEXT:     Type: CUSTOM (0x0)
 WASM-NEXT:     Size: 22
 WASM-NEXT:     Offset: 257
 WASM-NEXT:     Name: linking
-WASM-NEXT:     DataSize: 13
 WASM-NEXT:   }
 WASM-NEXT: ]

tools/llvm-readobj/WasmDumper.cpp

for (const SectionRef &Section : Obj->sections()) {
     W.printEnum("Type", WasmSec.Type, makeArrayRef(WasmSectionTypes));
     W.printNumber("Size", static_cast<uint64_t>(WasmSec.Content.size()));
     W.printNumber("Offset", WasmSec.Offset);
     switch (WasmSec.Type) {
     case wasm::WASM_SEC_CUSTOM:
       W.printString("Name", WasmSec.Name);
       if (WasmSec.Name == "linking") {
         const wasm::WasmLinkingData &LinkingData = Obj->linkingData();
-        W.printNumber("DataSize", LinkingData.DataSize);
+        if (!LinkingData.InitFunctions.empty()) {
+          ListScope Group(W, "InitFunctions");
+          for (const wasm::WasmInitFunc &F: LinkingData.InitFunctions)
+            outs() << "  " << F.FunctionIndex << " [" << F.Priority << "]\n";
+        }
       }
       break;
     case wasm::WASM_SEC_DATA: {
       ListScope Group(W, "Segments");
       for (const WasmSegment &Segment : Obj->dataSegments()) {
         const wasm::WasmDataSegment& Seg = Segment.Data;
         DictScope Group(W, "Segment");
         if (!Seg.Name.empty())

tools/obj2yaml/wasm2yaml.cpp

if (WasmSec.Name == "name") {
     }
     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.emplace_back(Info);
       }
     }
-    LinkingSec->DataSize = Obj.linkingData().DataSize;
     for (const wasm::WasmInitFunc &Func : Obj.linkingData().InitFunctions) {
       WasmYAML::InitFunction F{Func.Priority, Func.FunctionIndex};
       LinkingSec->InitFunctions.emplace_back(F);
     }
     CustomSec = std::move(LinkingSec);
   } else {
     CustomSec = make_unique<WasmYAML::CustomSection>(WasmSec.Name);
   }

tools/yaml2obj/yaml2wasm.cpp

public:
   }
 };
 
 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();
-
   // SYMBOL_INFO subsection
   if (Section.SymbolInfos.size()) {
     encodeULEB128(wasm::WASM_SYMBOL_INFO, OS);
 
     encodeULEB128(Section.SymbolInfos.size(), SubSection.GetStream());
     for (const WasmYAML::SymbolInfo &Info : Section.SymbolInfos) {
       writeStringRef(Info.Name, SubSection.GetStream());
       encodeULEB128(Info.Flags, SubSection.GetStream());