[WebAssembly] Emit the DataCount section when bulk memory is enabled

[tlively]

Summary

The DataCount section is necessary for the bulk memory operations
memory.init and data.drop to validate, but it is not recognized by
engines that do not support bulk memory, so emit the section only if
bulk-memory is enabled.

[sbc100]

lld/wasm/OutputSections.h

93

Can you not just use SyntheticSection directly? It looks like thats what we do for most other sections.

[tlively]

• Switch to using SyntheticSection

[tlively]

lld/wasm/OutputSections.h

93

Good call. Much simpler that way.

[tlively]

ping, I think this should be ready to go.

lld/test/wasm/data-segment-merging.ll

 target triple = "wasm32-unknown-unknown"
 
 @a = hidden global [6 x i8] c"hello\00", align 1
 @b = hidden global [8 x i8] c"goodbye\00", align 1
 @c = hidden global [9 x i8] c"whatever\00", align 1
 @d = hidden global i32 42, align 4
 
 @e = private constant [9 x i8] c"constant\00", align 1
 @f = private constant i8 43, align 4
 
 ; RUN: llc -filetype=obj %s -o %t.data-segment-merging.o
 
 ; RUN: wasm-ld -no-gc-sections --no-entry -o %t.merged.wasm %t.data-segment-merging.o
 ; RUN: obj2yaml %t.merged.wasm | FileCheck %s --check-prefix=MERGE
+
+; MERGE-NOT:                  DATACOUNT
 ; MERGE:   - Type:            DATA
 ; MERGE:     Segments:
 ; MERGE:        Content:         68656C6C6F00676F6F6462796500776861746576657200002A000000
 ; MERGE:        Content:         636F6E7374616E74000000002B
 ; MERGE-NOT:    Content:
 
 ; RUN: wasm-ld -no-gc-sections --no-entry --no-merge-data-segments -o %t.separate.wasm %t.data-segment-merging.o
 ; RUN: obj2yaml %t.separate.wasm | FileCheck %s --check-prefix=SEPARATE
+
+; SEPARATE-NOT:                  DATACOUNT
 ; SEPARATE:   - Type:            DATA
 ; SEPARATE:     Segments:
 ; SEPARATE:        Content:         68656C6C6F00
 ; SEPARATE:        Content:         676F6F6462796500
 ; SEPARATE:        Content:         '776861746576657200'
 ; SEPARATE:        Content:         2A000000
 ; SEPARATE:        Content:         636F6E7374616E7400
 ; SEPARATE:        Content:         2B
 ; SEPARATE-NOT:    Content:
+
+; RUN: llc -filetype=obj %s -mattr=+bulk-memory -o %t.data-segment-merging.bulk-memory.o
+; RUN: wasm-ld -no-gc-sections --no-entry -o %t.merged.bulk-memory.wasm %t.data-segment-merging.bulk-memory.o
+; RUN: obj2yaml %t.merged.bulk-memory.wasm | FileCheck %s --check-prefix=BULK-MEMORY
+
+; BULK-MEMORY:   - Type:            DATACOUNT
+; BULK-MEMORY:     Count:           2
+; BULK-MEMORY:   - Type:            DATA
+; BULK-MEMORY:     Segments:
+; BULK-MEMORY:        Content:         68656C6C6F00676F6F6462796500776861746576657200002A000000
+; BULK-MEMORY:        Content:         636F6E7374616E74000000002B
+; BULK-MEMORY-NOT:    Content:

lld/wasm/OutputSections.h

public:
   raw_ostream &getStream() { return BodyOutputStream; }
 
   std::string Body;
 
 protected:
   llvm::raw_string_ostream BodyOutputStream;
 };
 
+class DataCountSection : public OutputSection {
+public:
+  explicit DataCountSection(size_t Count);
+  size_t getSize() const override { return Header.size() + Contents.size(); }
+  void writeTo(uint8_t *Buf) override;
+
+protected:
+  std::string Contents;
+};
+
 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

static StringRef sectionTypeToString(uint32_t SectionType) {
   case WASM_SEC_START:
     return "START";
   case WASM_SEC_ELEM:
     return "ELEM";
   case WASM_SEC_CODE:
     return "CODE";
   case WASM_SEC_DATA:
     return "DATA";
+  case WASM_SEC_DATACOUNT:
+    return "DATACOUNT";
   default:
     fatal("invalid section type");
   }
 }
 
 // Returns a string, e.g. "FUNCTION(.text)".
 std::string lld::toString(const OutputSection &Sec) {
   if (!Sec.Name.empty())
void OutputSection::createHeader(size_t BodySize) {
   debugWrite(OS.tell(), "section type [" + getSectionName() + "]");
   encodeULEB128(Type, OS);
   writeUleb128(OS, BodySize, "section size");
   OS.flush();
   log("createHeader: " + toString(*this) + " body=" + Twine(BodySize) +
       " total=" + Twine(getSize()));
 }
 
+DataCountSection::DataCountSection(size_t Count)
+    : OutputSection(WASM_SEC_DATACOUNT) {
+  raw_string_ostream OS(Contents);
+  writeUleb128(OS, Count, "segment count");
+  OS.flush();
+  createHeader(Contents.size());
+}
+
+void DataCountSection::writeTo(uint8_t *Buf) {
+  log("writing " + toString(*this));
+  log(" size=" + Twine(getSize()));
+  log(" headersize=" + Twine(Header.size()));
+  log(" contentsize=" + Twine(Contents.size()));
+  Buf += Offset;
+
+  // Write section Header
+  memcpy(Buf, Header.data(), Header.size());
+  Buf += Header.size();
+
+  // Write data count section contents
+  memcpy(Buf, Contents.data(), Contents.size());
+}
+
 CodeSection::CodeSection(ArrayRef<InputFunction *> Functions)
     : OutputSection(WASM_SEC_CODE), Functions(Functions) {
   assert(Functions.size() > 0);
 
   raw_string_ostream OS(CodeSectionHeader);
   writeUleb128(OS, Functions.size(), "function count");
   OS.flush();
   BodySize = CodeSectionHeader.size();

lld/wasm/Writer.cpp

private:
   void createFunctionSection();
   void createTableSection();
   void createGlobalSection();
   void createEventSection();
   void createExportSection();
   void createImportSection();
   void createMemorySection();
   void createElemSection();
+  void createDataCountSection();
   void createCodeSection();
   void createDataSection();
   void createCustomSections();
 
   // Custom sections
   void createDylinkSection();
   void createRelocSections();
   void createLinkingSection();
void Writer::createElemSection() {
   uint32_t TableIndex = TableBase;
   for (const FunctionSymbol *Sym : IndirectFunctions) {
     assert(Sym->getTableIndex() == TableIndex);
     writeUleb128(OS, Sym->getFunctionIndex(), "function index");
     ++TableIndex;
   }
 }
 
+void Writer::createDataCountSection() {
+  if (!Segments.size() || !TargetFeatures.count("bulk-memory"))
+    return;
+  log("createDataCountSection");
+
+  auto Section = make<DataCountSection>(Segments.size());
+  OutputSections.push_back(Section);
+}
+
 void Writer::createCodeSection() {
   if (InputFunctions.empty())
     return;
 
   log("createCodeSection");
 
   auto Section = make<CodeSection>(InputFunctions);
   OutputSections.push_back(Section);
void Writer::createSections() {
   createImportSection();
   createFunctionSection();
   createTableSection();
   createMemorySection();
   createGlobalSection();
   createEventSection();
   createExportSection();
   createElemSection();
+  createDataCountSection();
   createCodeSection();
   createDataSection();
   createCustomSections();
 
   // Custom sections
   if (Config->Relocatable) {
     createLinkingSection();
     createRelocSections();