[WebAssembly] Convert to new "dylink.0" section format

[sbc100]

Summary

This format is based on sub-sections (like the "linking" and "name"
sections) and is therefore easier to extend going forward.

spec change: https://github.com/WebAssembly/tool-conventions/pull/170
binaryen change: https://github.com/WebAssembly/binaryen/pull/4141
wabt change: https://github.com/WebAssembly/wabt/pull/1707
emscripten change: https://github.com/emscripten-core/emscripten/pull/15019

[sbc100]

• remove unused line

[sbc100]

• remove unused line

[dschuff]

llvm/tools/obj2yaml/wasm2yaml.cpp

54

So wasm2yaml will accept either name. Does work because the parsing goes through lib/Object, which knows how to handle the legacy section format?

[sbc100]

llvm/tools/obj2yaml/wasm2yaml.cpp

54

Yes version are supported for now. And yes lib/Object hides the differences and exposes the same struct whichever version is used.

[sbc100]

• rebase

[sbc100]

Landing TBR so we can start testing with this in emscripten ASAP. Will modify or revert as needed.

[RKSimon]

llvm/lib/Object/WasmObjectFile.cpp

391

@sbc100 This is being reported as dead code by coverity - please can you take a look?

[sbc100]

llvm/lib/Object/WasmObjectFile.cpp

391

Thanks for pointing that out: https://reviews.llvm.org/D110717

lld/test/wasm/pie.ll

define void @_start() {
   call void @external_func()
   ret void
 }
 
 declare void @external_func()
 
 ;      CHECK: Sections:
 ; CHECK-NEXT:   - Type:            CUSTOM
-; CHECK-NEXT:     Name:            dylink
+; CHECK-NEXT:     Name:            dylink.0
 ; CHECK-NEXT:     MemorySize:      16
 ; CHECK-NEXT:     MemoryAlignment: 2
 ; CHECK-NEXT:     TableSize:       1
 ; CHECK-NEXT:     TableAlignment:  0
 ; CHECK-NEXT:     Needed:          []
 
 ; CHECK:        - Type:            IMPORT
 ; CHECK-NEXT:     Imports:

lld/test/wasm/shared-needed.s

 data:
  .p2align 2
  .int32 0
  .size data,4
 
 
 # SO1:      Sections:
 # SO1-NEXT:   - Type:            CUSTOM
-# SO1-NEXT:     Name:            dylink
+# SO1-NEXT:     Name:            dylink.0
 # SO1-NEXT:     MemorySize:      4
 # SO1-NEXT:     MemoryAlignment: 2
 # SO1-NEXT:     TableSize:       0
 # SO1-NEXT:     TableAlignment:  0
 # SO1-NEXT:     Needed:          []
 # SO1-NEXT:   - Type:            TYPE
 
 # SO2:      Sections:
 # SO2-NEXT:   - Type:            CUSTOM
-# SO2-NEXT:     Name:            dylink
+# SO2-NEXT:     Name:            dylink.0
 # SO2-NEXT:     MemorySize:      0
 # SO2-NEXT:     MemoryAlignment: 0
 # SO2-NEXT:     TableSize:       0
 # SO2-NEXT:     TableAlignment:  0
 # SO2-NEXT:     Needed:
 # SO2-NEXT:       - shared-needed.s.tmp1.so
 # SO2-NEXT:   - Type:            TYPE

lld/test/wasm/shared.s

 .int8 43
 .int8 15
 .ascii "mutable-globals"
 
 # check for dylink section at start
 
 # CHECK:      Sections:
 # CHECK-NEXT:   - Type:            CUSTOM
-# CHECK-NEXT:     Name:            dylink
+# CHECK-NEXT:     Name:            dylink.0
 # CHECK-NEXT:     MemorySize:      24
 # CHECK-NEXT:     MemoryAlignment: 2
 # CHECK-NEXT:     TableSize:       2
 # CHECK-NEXT:     TableAlignment:  0
 # CHECK-NEXT:     Needed:          []
 # CHECK-NEXT:   - Type:            TYPE
 
 # check for import of __table_base and __memory_base globals

lld/test/wasm/shared64.s

 .int8 43
 .int8 15
 .ascii "mutable-globals"
 
 # check for dylink section at start
 
 # CHECK:      Sections:
 # CHECK-NEXT:   - Type:            CUSTOM
-# CHECK-NEXT:     Name:            dylink
+# CHECK-NEXT:     Name:            dylink.0
 # CHECK-NEXT:     MemorySize:      36
 # CHECK-NEXT:     MemoryAlignment: 2
 # CHECK-NEXT:     TableSize:       2
 # CHECK-NEXT:     TableAlignment:  0
 # CHECK-NEXT:     Needed:          []
 # CHECK-NEXT:   - Type:            TYPE
 
 # check for import of __table_base and __memory_base globals

lld/wasm/SyntheticSections.h

 };
 
 // Create the custom "dylink" section containing information for the dynamic
 // linker.
 // See
 // https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md
 class DylinkSection : public SyntheticSection {
 public:
-  DylinkSection() : SyntheticSection(llvm::wasm::WASM_SEC_CUSTOM, "dylink") {}
+  DylinkSection() : SyntheticSection(llvm::wasm::WASM_SEC_CUSTOM, "dylink.0") {}
   bool isNeeded() const override { return config->isPic; }
   void writeBody() override;
 
   uint32_t memAlign = 0;
   uint32_t memSize = 0;
 };
 
 class TypeSection : public SyntheticSection {

lld/wasm/SyntheticSections.cpp

public:
   raw_string_ostream os{body};
 };
 
 } // namespace
 
 void DylinkSection::writeBody() {
   raw_ostream &os = bodyOutputStream;
 
-  writeUleb128(os, memSize, "MemSize");
-  writeUleb128(os, memAlign, "MemAlign");
-  writeUleb128(os, out.elemSec->numEntries(), "TableSize");
-  writeUleb128(os, 0, "TableAlign");
-  writeUleb128(os, symtab->sharedFiles.size(), "Needed");
+  {
+    SubSection sub(WASM_DYLINK_MEM_INFO);
+    writeUleb128(sub.os, memSize, "MemSize");
+    writeUleb128(sub.os, memAlign, "MemAlign");
+    writeUleb128(sub.os, out.elemSec->numEntries(), "TableSize");
+    writeUleb128(sub.os, 0, "TableAlign");
+    sub.writeTo(os);
+  }
+
+  if (symtab->sharedFiles.size()) {
+    SubSection sub(WASM_DYLINK_NEEDED);
+    writeUleb128(sub.os, symtab->sharedFiles.size(), "Needed");
     for (auto *so : symtab->sharedFiles)
-    writeStr(os, llvm::sys::path::filename(so->getName()), "so name");
+      writeStr(sub.os, llvm::sys::path::filename(so->getName()), "so name");
+    sub.writeTo(os);
+  }
 }
 
 uint32_t TypeSection::registerType(const WasmSignature &sig) {
   auto pair = typeIndices.insert(std::make_pair(sig, types.size()));
   if (pair.second) {
     LLVM_DEBUG(llvm::dbgs() << "type " << toString(sig) << "\n");
     types.push_back(&sig);
   }

llvm/include/llvm/BinaryFormat/Wasm.h

 // Kind codes used in the custom "linking" section
 enum : unsigned {
   WASM_SEGMENT_INFO = 0x5,
   WASM_INIT_FUNCS = 0x6,
   WASM_COMDAT_INFO = 0x7,
   WASM_SYMBOL_TABLE = 0x8,
 };
 
+// Kind codes used in the custom "dylink" section
+enum : unsigned {
+  WASM_DYLINK_MEM_INFO = 0x1,
+  WASM_DYLINK_NEEDED = 0x2,
+};
+
 // Kind codes used in the custom "linking" section in the WASM_COMDAT_INFO
 enum : unsigned {
   WASM_COMDAT_DATA = 0x0,
   WASM_COMDAT_FUNCTION = 0x1,
   // GLOBAL, TAG, and TABLE are in here but LLVM doesn't use them yet.
   WASM_COMDAT_SECTION = 0x5,
 };
 

llvm/include/llvm/Object/Wasm.h

private:
   Error parseStartSection(ReadContext &Ctx);
   Error parseElemSection(ReadContext &Ctx);
   Error parseCodeSection(ReadContext &Ctx);
   Error parseDataSection(ReadContext &Ctx);
   Error parseDataCountSection(ReadContext &Ctx);
 
   // Custom section types
   Error parseDylinkSection(ReadContext &Ctx);
+  Error parseDylink0Section(ReadContext &Ctx);
   Error parseNameSection(ReadContext &Ctx);
   Error parseLinkingSection(ReadContext &Ctx);
   Error parseLinkingSectionSymtab(ReadContext &Ctx);
   Error parseLinkingSectionComdat(ReadContext &Ctx);
   Error parseProducersSection(ReadContext &Ctx);
   Error parseTargetFeaturesSection(ReadContext &Ctx);
   Error parseRelocSection(StringRef Name, ReadContext &Ctx);
 

llvm/include/llvm/ObjectYAML/WasmYAML.h

static bool classof(const Section *S) {
     return S->Type == wasm::WASM_SEC_CUSTOM;
   }
 
   StringRef Name;
   yaml::BinaryRef Payload;
 };
 
 struct DylinkSection : CustomSection {
-  DylinkSection() : CustomSection("dylink") {}
+  DylinkSection() : CustomSection("dylink.0") {}
 
   static bool classof(const Section *S) {
     auto C = dyn_cast<CustomSection>(S);
-    return C && C->Name == "dylink";
+    return C && C->Name == "dylink.0";
   }
 
   uint32_t MemorySize;
   uint32_t MemoryAlignment;
   uint32_t TableSize;
   uint32_t TableAlignment;
   std::vector<StringRef> Needed;
 };

llvm/lib/Object/WasmObjectFile.cpp

case wasm::WASM_SEC_DATACOUNT:
     return parseDataCountSection(Ctx);
   default:
     return make_error<GenericBinaryError>(
         "invalid section type: " + Twine(Sec.Type), object_error::parse_failed);
   }
 }
 
 Error WasmObjectFile::parseDylinkSection(ReadContext &Ctx) {
-  // See https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md
+  // Legacy "dylink" section support.
+  // See parseDylink0Section for the current "dylink.0" section parsing.
   HasDylinkSection = true;
   DylinkInfo.MemorySize = readVaruint32(Ctx);
   DylinkInfo.MemoryAlignment = readVaruint32(Ctx);
   DylinkInfo.TableSize = readVaruint32(Ctx);
   DylinkInfo.TableAlignment = readVaruint32(Ctx);
   uint32_t Count = readVaruint32(Ctx);
   while (Count--) {
     DylinkInfo.Needed.push_back(readString(Ctx));
   }
+
   if (Ctx.Ptr != Ctx.End)
     return make_error<GenericBinaryError>("dylink section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
+Error WasmObjectFile::parseDylink0Section(ReadContext &Ctx) {
+  // See
+  // https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md
+  HasDylinkSection = true;
+
+  const uint8_t *OrigEnd = Ctx.End;
+  while (Ctx.Ptr < OrigEnd) {
+    Ctx.End = OrigEnd;
+    uint8_t Type = readUint8(Ctx);
+    uint32_t Size = readVaruint32(Ctx);
+    LLVM_DEBUG(dbgs() << "readSubsection type=" << int(Type) << " size=" << Size
+                      << "\n");
+    Ctx.End = Ctx.Ptr + Size;
+    uint32_t Count;
+    switch (Type) {
+    case wasm::WASM_DYLINK_MEM_INFO:
+      DylinkInfo.MemorySize = readVaruint32(Ctx);
+      DylinkInfo.MemoryAlignment = readVaruint32(Ctx);
+      DylinkInfo.TableSize = readVaruint32(Ctx);
+      DylinkInfo.TableAlignment = readVaruint32(Ctx);
+      break;
+    case wasm::WASM_DYLINK_NEEDED:
+      Count = readVaruint32(Ctx);
+      while (Count--) {
+        DylinkInfo.Needed.push_back(readString(Ctx));
+      }
+      break;
+    default:
+      return make_error<GenericBinaryError>("unknown dylink.0 sub-section",
+                                            object_error::parse_failed);
+      Ctx.Ptr += Size;
+      break;
+    }
+    if (Ctx.Ptr != Ctx.End) {
+      return make_error<GenericBinaryError>(
+          "dylink.0 sub-section ended prematurely", object_error::parse_failed);
+    }
+  }
+
+  if (Ctx.Ptr != Ctx.End)
+    return make_error<GenericBinaryError>("dylink.0 section ended prematurely",
+                                          object_error::parse_failed);
+  return Error::success();
+}
+
 Error WasmObjectFile::parseNameSection(ReadContext &Ctx) {
   llvm::DenseSet<uint64_t> SeenFunctions;
   llvm::DenseSet<uint64_t> SeenGlobals;
   llvm::DenseSet<uint64_t> SeenSegments;
   if (FunctionTypes.size() && !SeenCodeSection) {
     return make_error<GenericBinaryError>("names must come after code section",
                                           object_error::parse_failed);
   }
return make_error<GenericBinaryError>("reloc section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseCustomSection(WasmSection &Sec, ReadContext &Ctx) {
   if (Sec.Name == "dylink") {
     if (Error Err = parseDylinkSection(Ctx))
       return Err;
+  } else if (Sec.Name == "dylink.0") {
+    if (Error Err = parseDylink0Section(Ctx))
+      return Err;
   } else if (Sec.Name == "name") {
     if (Error Err = parseNameSection(Ctx))
       return Err;
   } else if (Sec.Name == "linking") {
     if (Error Err = parseLinkingSection(Ctx))
       return Err;
   } else if (Sec.Name == "producers") {
     if (Error Err = parseProducersSection(Ctx))

 }
 
 int WasmSectionOrderChecker::getSectionOrder(unsigned ID,
                                              StringRef CustomSectionName) {
   switch (ID) {
   case wasm::WASM_SEC_CUSTOM:
     return StringSwitch<unsigned>(CustomSectionName)
         .Case("dylink", WASM_SEC_ORDER_DYLINK)
+        .Case("dylink.0", WASM_SEC_ORDER_DYLINK)
         .Case("linking", WASM_SEC_ORDER_LINKING)
         .StartsWith("reloc.", WASM_SEC_ORDER_RELOC)
         .Case("name", WASM_SEC_ORDER_NAME)
         .Case("producers", WASM_SEC_ORDER_PRODUCERS)
         .Case("target_features", WASM_SEC_ORDER_TARGET_FEATURES)
         .Default(WASM_SEC_ORDER_NONE);
   case wasm::WASM_SEC_TYPE:
     return WASM_SEC_ORDER_TYPE;

llvm/lib/ObjectYAML/WasmEmitter.cpp

default:
     return;
   }
   writeUint8(OS, wasm::WASM_OPCODE_END);
 }
 
 void WasmWriter::writeSectionContent(raw_ostream &OS,
                                      WasmYAML::DylinkSection &Section) {
   writeStringRef(Section.Name, OS);
-  encodeULEB128(Section.MemorySize, OS);
-  encodeULEB128(Section.MemoryAlignment, OS);
-  encodeULEB128(Section.TableSize, OS);
-  encodeULEB128(Section.TableAlignment, OS);
-  encodeULEB128(Section.Needed.size(), OS);
+
+  writeUint8(OS, wasm::WASM_DYLINK_MEM_INFO);
+  SubSectionWriter SubSection(OS);
+  raw_ostream &SubOS = SubSection.getStream();
+  encodeULEB128(Section.MemorySize, SubOS);
+  encodeULEB128(Section.MemoryAlignment, SubOS);
+  encodeULEB128(Section.TableSize, SubOS);
+  encodeULEB128(Section.TableAlignment, SubOS);
+  SubSection.done();
+
+  if (Section.Needed.size()) {
+    writeUint8(OS, wasm::WASM_DYLINK_NEEDED);
+    raw_ostream &SubOS = SubSection.getStream();
+    encodeULEB128(Section.Needed.size(), SubOS);
     for (StringRef Needed : Section.Needed)
-    writeStringRef(Needed, OS);
+      writeStringRef(Needed, SubOS);
+    SubSection.done();
+  }
 }
 
 void WasmWriter::writeSectionContent(raw_ostream &OS,
                                      WasmYAML::LinkingSection &Section) {
   writeStringRef(Section.Name, OS);
   encodeULEB128(Section.Version, OS);
 
   SubSectionWriter SubSection(OS);

llvm/lib/ObjectYAML/WasmYAML.cpp

void MappingTraits<std::unique_ptr<WasmYAML::Section>>::mapping(
   case wasm::WASM_SEC_CUSTOM: {
     StringRef SectionName;
     if (IO.outputting()) {
       auto CustomSection = cast<WasmYAML::CustomSection>(Section.get());
       SectionName = CustomSection->Name;
     } else {
       IO.mapRequired("Name", SectionName);
     }
-    if (SectionName == "dylink") {
+    if (SectionName == "dylink" || SectionName == "dylink.0") {
       if (!IO.outputting())
         Section.reset(new WasmYAML::DylinkSection());
       sectionMapping(IO, *cast<WasmYAML::DylinkSection>(Section.get()));
     } else if (SectionName == "linking") {
       if (!IO.outputting())
         Section.reset(new WasmYAML::LinkingSection());
       sectionMapping(IO, *cast<WasmYAML::LinkingSection>(Section.get()));
     } else if (SectionName == "name") {

llvm/test/ObjectYAML/wasm/dylink_section.yaml

 # RUN: yaml2obj %s | obj2yaml | FileCheck %s
 --- !WASM
 FileHeader:
   Version:         0x00000001
 
 Sections:
   - Type:            CUSTOM
-    Name:            dylink
+    Name:            dylink.0
     MemorySize:      4
     MemoryAlignment: 2
     TableSize:       1
     TableAlignment:  0
     Needed:          [ libfoo.so, libbar.so ]
 ...
 # CHECK: --- !WASM
 # CHECK: FileHeader:
 # CHECK:   Version:           0x1
 # CHECK: Sections:
 # CHECK:   - Type:            CUSTOM
-# CHECK:     Name:            dylink
+# CHECK:     Name:            dylink.0
 # CHECK:     MemorySize:      4
 # CHECK:     MemoryAlignment: 2
 # CHECK:     TableSize:       1
 # CHECK:     TableAlignment:  0
 # CHECK:     Needed:
 # CHECK:       - libfoo.so
 # CHECK:       - libbar.so
 # CHECK: ...

llvm/tools/obj2yaml/wasm2yaml.cpp

static WasmYAML::Table makeTable(uint32_t Index,
   T.ElemType = Type.ElemType;
   T.TableLimits = makeLimits(Type.Limits);
   return T;
 }
 
 std::unique_ptr<WasmYAML::CustomSection>
 WasmDumper::dumpCustomSection(const WasmSection &WasmSec) {
   std::unique_ptr<WasmYAML::CustomSection> CustomSec;
-  if (WasmSec.Name == "dylink") {
+  if (WasmSec.Name == "dylink" || WasmSec.Name == "dylink.0") {
     std::unique_ptr<WasmYAML::DylinkSection> DylinkSec =
         std::make_unique<WasmYAML::DylinkSection>();
     const wasm::WasmDylinkInfo& Info = Obj.dylinkInfo();
     DylinkSec->MemorySize = Info.MemorySize;
     DylinkSec->MemoryAlignment = Info.MemoryAlignment;
     DylinkSec->TableSize = Info.TableSize;
     DylinkSec->TableAlignment = Info.TableAlignment;
     DylinkSec->Needed = Info.Needed;