[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 WasmFunctionName {
   uint32_t Index;
   StringRef Name;
 };
 
 struct WasmLinkingData {
-  uint32_t DataSize;
   std::vector<WasmInitFunc> InitFunctions;
   std::vector<WasmSymbolInfo> SymbolTable;
 };
 
 enum : unsigned {
   WASM_SEC_CUSTOM = 0,   // Custom / User-defined section
   WASM_SEC_TYPE = 1,     // Function signature declarations
   WASM_SEC_IMPORT = 2,   // Import declarations

 // Kind codes used in the custom "name" section
 enum : unsigned {
   WASM_NAMES_FUNCTION = 0x1,
   WASM_NAMES_LOCAL    = 0x2,
 };
 
 // Kind codes used in the custom "linking" section
 enum : unsigned {
-  WASM_DATA_SIZE      = 0x3,
   WASM_SEGMENT_INFO   = 0x5,
   WASM_INIT_FUNCS     = 0x6,
   WASM_COMDAT_INFO    = 0x7,
   WASM_SYMBOL_TABLE   = 0x8,
 };
 
 // Kind codes used in the custom "linking" section in the WASM_COMDAT_INFO
 enum : unsigned {

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> SymbolTable;
   std::vector<SegmentInfo> SegmentInfos;
   std::vector<InitFunction> InitFunctions;
   std::vector<Comdat> Comdats;
 };
 
 struct TypeSection : Section {
   TypeSection() : Section(wasm::WASM_SEC_TYPE) {}

lib/MC/WasmObjectWriter.cpp

private:
   void writeExportSection(ArrayRef<wasm::WasmExport> Exports);
   void writeElemSection(ArrayRef<uint32_t> TableElems);
   void writeCodeSection(const MCAssembler &Asm, const MCAsmLayout &Layout,
                         ArrayRef<WasmFunction> Functions);
   void writeDataSection();
   void writeCodeRelocSection();
   void writeDataRelocSection();
   void writeLinkingMetaDataSection(
-      uint32_t DataSize, ArrayRef<wasm::WasmSymbolInfo> SymbolInfos,
+      ArrayRef<wasm::WasmSymbolInfo> SymbolInfos,
       ArrayRef<std::pair<uint16_t, uint32_t>> InitFuncs,
       const std::map<StringRef, std::vector<WasmComdatEntry>> &Comdats);
 
   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(
-    uint32_t DataSize, ArrayRef<wasm::WasmSymbolInfo> SymbolInfos,
+    ArrayRef<wasm::WasmSymbolInfo> SymbolInfos,
     ArrayRef<std::pair<uint16_t, uint32_t>> InitFuncs,
     const std::map<StringRef, std::vector<WasmComdatEntry>> &Comdats) {
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_CUSTOM, "linking");
   SectionBookkeeping SubSection;
 
   if (SymbolInfos.size() != 0) {
     startSection(SubSection, wasm::WASM_SYMBOL_TABLE);
for (const wasm::WasmSymbolInfo &Sym : SymbolInfos) {
         break;
       default:
         llvm_unreachable("unexpected kind");
       }
     }
     endSection(SubSection);
   }
 
-  if (DataSize > 0) {
-    startSection(SubSection, wasm::WASM_DATA_SIZE);
-    encodeULEB128(DataSize, getStream());
-    endSection(SubSection);
-  }
-
   if (DataSegments.size()) {
     startSection(SubSection, wasm::WASM_SEGMENT_INFO);
     encodeULEB128(DataSegments.size(), getStream());
     for (const WasmDataSegment &Segment : DataSegments) {
       writeString(Segment.Name);
       encodeULEB128(Segment.Alignment, getStream());
       encodeULEB128(Segment.Flags, getStream());
     }
void WasmObjectWriter::writeObject(MCAssembler &Asm,
   // Skip the "memory" section; we import the memory instead.
   writeGlobalSection();
   writeExportSection(Exports);
   writeElemSection(TableElems);
   writeCodeSection(Asm, Layout, Functions);
   writeDataSection();
   writeCodeRelocSection();
   writeDataRelocSection();
-  writeLinkingMetaDataSection(DataSize, SymbolInfos, InitFuncs, Comdats);
+  writeLinkingMetaDataSection(SymbolInfos, InitFuncs, Comdats);
 
   // 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) {
   return llvm::make_unique<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;
   }
 
while (Ptr < End) {
     uint8_t Type = readVarint7(Ptr);
     uint32_t Size = readVaruint32(Ptr);
     const uint8_t *SubSectionEnd = Ptr + Size;
     switch (Type) {
     case wasm::WASM_SYMBOL_TABLE:
       if (Error Err = parseLinkingSectionSymtab(Ptr, SubSectionEnd))
         return Err;
       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("SymbolTable", Section.SymbolTable);
   IO.mapOptional("SegmentInfo", Section.SegmentInfos);
   IO.mapOptional("InitFunctions", Section.InitFunctions);
   IO.mapOptional("Comdats", Section.Comdats);
 }
 
 static void sectionMapping(IO &IO, WasmYAML::CustomSection &Section) {
   commonSectionMapping(IO, Section);

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:     SymbolTable:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Kind:            DATA
 ; CHECK-NEXT:         Name:            gBd
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
 ; CHECK-NEXT:         Segment:         0
 ; CHECK-NEXT:         Size:            2
 ; 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:   29
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           8
 ; CHECK-NEXT:         Content:         ''
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
-; CHECK-NEXT:     DataSize:        8
 ; CHECK-NEXT:     SymbolTable:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Kind:            DATA
 ; CHECK-NEXT:         Name:            g0
 ; CHECK-NEXT:         Flags:           [  ]
 ; CHECK-NEXT:         Segment:         0
 ; CHECK-NEXT:         Size:            4
 ; CHECK-NEXT:       - Index:           1

test/MC/WebAssembly/comdat.ll

 ; CHECK-NEXT:      - SectionOffset:   6
 ; CHECK-NEXT:        MemoryIndex:     0
 ; CHECK-NEXT:        Offset:
 ; CHECK-NEXT:          Opcode:          I32_CONST
 ; CHECK-NEXT:          Value:           0
 ; CHECK-NEXT:        Content:         '616263'
 ; CHECK-NEXT:  - Type:            CUSTOM
 ; CHECK-NEXT:    Name:            linking
-; CHECK-NEXT:    DataSize:        3
 ; CHECK-NEXT:    SymbolTable:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Name:            funcImport
 ; CHECK-NEXT:         Flags:           [ UNDEFINED ]
 ; CHECK-NEXT:         Function:        0
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Kind:            FUNCTION

test/MC/WebAssembly/explicit-sections.ll

 ; CHECK-NEXT:       - SectionOffset:   36
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           24
 ; CHECK-NEXT:         Content:         '08000000'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
-; CHECK-NEXT:     DataSize:        28
 ; CHECK-NEXT:     SymbolTable:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Kind:            DATA
 ; CHECK-NEXT:         Name:            global0
 ; CHECK-NEXT:         Flags:           [  ]
 ; CHECK-NEXT:         Segment:         0
 ; CHECK-NEXT:         Size:            4
 ; CHECK-NEXT:       - Index:           1

test/MC/WebAssembly/global-ctor-dtor.ll

 ; CHECK-NEXT:       - SectionOffset:   6
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           0
 ; CHECK-NEXT:         Content:         '01040000'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
-; CHECK-NEXT:     DataSize:        4
 ; CHECK-NEXT:     SymbolTable:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Name:            func3
 ; CHECK-NEXT:         Flags:           [ UNDEFINED ]
 ; CHECK-NEXT:         Function:        0
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Kind:            DATA

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:     SymbolTable:      
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Kind:            DATA
 ; CHECK-NEXT:         Name:            .L.str1
 ; CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; CHECK-NEXT:         Segment:         0
 ; CHECK-NEXT:         Size:            6
 ; CHECK-NEXT:       - Index:           1

test/MC/WebAssembly/visibility.ll

 ; Function with __attribute__((visibility("hidden")))
 define hidden void @hiddenVis() #0 {
 entry:
   ret void
 }
 
 ; CHECK:        - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
-; CHECK-NEXT:     DataSize:        0
 ; CHECK-NEXT:     SymbolTable:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Name:            defaultVis
 ; CHECK-NEXT:         Flags:           [  ]
 ; CHECK-NEXT:         Function:        0
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Name:            hiddenVis
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
 ; CHECK-NEXT:         Function:        1
 ; CHECK-NEXT: ...

test/MC/WebAssembly/weak-alias.ll

 ; CHECK-NEXT:       - SectionOffset:   24
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           16
 ; CHECK-NEXT:         Content:         '01000000'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
-; CHECK-NEXT:     DataSize:        20
 ; CHECK-NEXT:     SymbolTable:      
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Name:            foo
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
 ; CHECK-NEXT:         Function:        0
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Kind:            FUNCTION

test/MC/WebAssembly/weak.ll

 ; CHECK:            - Module:          env
 ; CHECK-NEXT:         Field:           __linear_memory
 ; CHECK:            - Module:          env
 ; CHECK-NEXT:         Field:           __indirect_function_table
 
 
 ; CHECK:        - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
-; CHECK-NEXT:     DataSize:        0
 ; CHECK-NEXT:     SymbolTable:      
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Kind:            DATA
 ; CHECK-NEXT:         Name:            weak_external_data
 ; CHECK-NEXT:         Flags:           [ BINDING_WEAK, UNDEFINED ]
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Name:            weak_function
 ; CHECK-NEXT:         Flags:           [ BINDING_WEAK, VISIBILITY_HIDDEN ]
 ; CHECK-NEXT:         Function:        0
 ; CHECK-NEXT: ...

test/Object/obj2yaml.test

 ELF-AVR-NEXT:       Value:           0x0000000000800060
 
 
 WASM:      --- !WASM
 WASM-NEXT: FileHeader:
 WASM-NEXT:   Version:         0x00000001
 WASM:        - Type:            CUSTOM
 WASM-NEXT:     Name:            linking
-WASM-NEXT:     DataSize:        20
 WASM-NEXT:     SymbolTable:
 WASM-NEXT:       - Index:           0
 WASM-NEXT:         Kind:            FUNCTION
 WASM-NEXT:         Name:            puts
 WASM-NEXT:         Flags:           [ UNDEFINED ]
 WASM-NEXT:         Function:        0
 WASM-NEXT:       - Index:           1
 WASM:              Name:            SomeOtherFunction

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
     SymbolTable:
       - Index:           0
         Kind:            FUNCTION
         Name:            bar
         Flags:           [ BINDING_WEAK, UNDEFINED ]
         Function:        0
     SegmentInfo:
       - Index:       0
         Alignment:   4
         Flags:       [ ]
         Name:        mydata
       - Index:       1
         Alignment:   2
         Flags:       [ ]
         Name:        moredata
     InitFunctions:
       - Priority:      1
         Symbol:        0
 ...
 # CHECK:       - Type:            CUSTOM
 # CHECK-NEXT:    Name:            linking
-# CHECK-NEXT:    DataSize:        999
 # CHECK-NEXT:    SymbolTable:
 # CHECK-NEXT:      - Index:           0
 # CHECK-NEXT:        Kind:            FUNCTION
 # CHECK-NEXT:        Name:            bar
 # CHECK-NEXT:        Flags:           [ BINDING_WEAK, UNDEFINED ]
 # CHECK-NEXT:        Function:        0
 # CHECK-NEXT:    SegmentInfo:
 # CHECK-NEXT:      - Index:           0

test/ObjectYAML/wasm/weak_symbols.yaml

Functions:
       - Index:           0
         Locals:
         Body:            00
       - Index:           1
         Locals:
         Body:            00
   - Type:            CUSTOM
     Name:            linking
-    DataSize:        10
     SymbolTable:
       - Index:           0
         Kind:            FUNCTION
         Name:            function_export
         Flags:           [ BINDING_WEAK ]
         Function:        0
       - Index:           1
         Kind:            GLOBAL

 # 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:     SymbolTable:
 # CHECK:      - Index:           0
 # CHECK:        Kind:            FUNCTION
 # CHECK:        Name:            function_export
 # CHECK:        Flags:           [ BINDING_WEAK ]
 # CHECK:        Function:        0
 # CHECK:      - Index:           1
 # CHECK:        Kind:            GLOBAL
 # CHECK:        Name:            global_export
 # CHECK:        Flags:           [ BINDING_WEAK ]
 # CHECK:        Global:          0

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

Segments:
       - SectionOffset:   6
         MemoryIndex:     0
         Offset:
           Opcode:          I32_CONST
           Value:           0
         Content:         '616263'
   - Type:            CUSTOM
     Name:            linking
-    DataSize:        3
     SymbolTable:
        - Index:           0
          Kind:            FUNCTION
          Name:            fexport
          Flags:           [  ]
          Function:        0
        - Index:           1
          Kind:            GLOBAL

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

Imports:
         SigIndex:        0
       - Module:          env
         Field:           gimport
         Kind:            GLOBAL
         GlobalType:      I32
         GlobalMutable:   false
   - Type:            CUSTOM
     Name:            linking
-    DataSize:        3
     SymbolTable:
        - Index:           0
          Kind:            FUNCTION
          Name:            fimport
          Flags:           [ UNDEFINED ]
          Function:        0
        - Index:           1
          Kind:            GLOBAL

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

Segments:
       - SectionOffset:   6
         MemoryIndex:     0
         Offset:
           Opcode:          I32_CONST
           Value:           0
         Content:         '616263'
   - Type:            CUSTOM
     Name:            linking
-    DataSize:        3
     SymbolTable:
        - Index:           0
          Kind:            DATA
          Name:            weak_defined_data
          Flags:           [ BINDING_WEAK ]
          Segment:         0
          Size:            3
        - Index:           1

test/tools/llvm-readobj/sections.test

 WASM-NEXT:     Offset: 191
 WASM-NEXT:     Name: reloc.CODE
 WASM-NEXT:   }
 WASM-NEXT:   Section {
 WASM-NEXT:     Type: CUSTOM (0x0)
 WASM-NEXT:     Size: 72
 WASM-NEXT:     Offset: 220
 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)
             W.startLine() << F.Symbol << " (priority=" << F.Priority << ")\n";
         }
       }
       break;
     case wasm::WASM_SEC_DATA: {

tools/obj2yaml/wasm2yaml.cpp

for (const wasm::WasmSymbolInfo &Symbol : Obj.linkingData().SymbolTable) {
         break;
       case wasm::WASM_SYMBOL_TYPE_FUNCTION:
       case wasm::WASM_SYMBOL_TYPE_GLOBAL:
         Info.ElementIndex = Symbol.ElementIndex;
         break;
       }
       LinkingSec->SymbolTable.emplace_back(Info);
     }
-    LinkingSec->DataSize = Obj.linkingData().DataSize;
     for (const wasm::WasmInitFunc &Func : Obj.linkingData().InitFunctions) {
       WasmYAML::InitFunction F{Func.Priority, Func.Symbol};
       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_TABLE subsection
   if (Section.SymbolTable.size()) {
     encodeULEB128(wasm::WASM_SYMBOL_TABLE, OS);
 
     encodeULEB128(Section.SymbolTable.size(), SubSection.GetStream());
 #ifndef _NDEBUG
     uint32_t SymbolIndex = 0;
 #endif