[lld][WebAssembly] Initialize bss segments using memory.fill

[sbc100]

Summary

Previously we were relying on the dynamic loader to take care of this
but it simple and correct for us to do it here instead.

Now we initialize bss segments as part of __wasm_init_memory at the
same time we initialize passive segments.

In addition, we extend the us of __wasm_init_memory outside of shared
memory situations. Specifically, it is now used to initialize bss
segments any time the memory is imported (but only when the bulk
memory features is available).

[tlively]

Code LGTM, thanks!

lld/test/wasm/shared-memory-bss.s

62

I think it would be clearer to place these comments before the arguments to the memory.init and memory.fill instructions rather than immediately before the instructions themselves. Also, it would be helpful if you could insert similar comments for the other parts of the code to split it into more easily digestible pieces.

lld/wasm/Writer.cpp

969

[sbc100]

Actually I think we can use the memory.fill instruction in general.. since it might be available.

[tlively]

Oh yeah, I guess we could only do this if bulk memory is enabled.

[sbc100]

• avoid bulk memory opterations when feature not available

[sbc100]

• cleaner diff

[sbc100]

In D112667#3091990, @tlively wrote:

Oh yeah, I guess we could only do this if bulk memory is enabled.

I think this works in all configurations now:

1. imported memory + bulk-memory feature: memory.init
2. imported memory - bulk-memory feature: include bss just like normal data
3. Non-imported memory: elide bss completely

[tlively]

lld/wasm/Writer.cpp

549

There are still a bunch of other feature checks in the previous function. Would it make sense to break them out as well?

[sbc100]

lld/wasm/Writer.cpp

549

Yes, I was thinking the same... or maybe try to give this function a better name? or move these checks into calculateImports/calculateExports?

[sbc100]

• rename function and add comment

lld/wasm/Writer.cpp

549

I renamed this function and added a comment.

lld/test/wasm/data-segments.ll

 ; NOPIC-DIS-NEXT:      [[PTR]].const   1040
 ; PIC-DIS-NEXT:        [[PTR]].const   16
 ; PIC-DIS-NEXT:        global.get      1
 ; PIC-DIS-NEXT:        [[PTR]].add
 
 ; DIS-NEXT:            i32.const       0
 ; DIS-NEXT:            i32.const       20
 ; DIS-NEXT:            memory.init     1, 0
+; NOPIC-DIS-NEXT:      [[PTR]].const   1060
+; PIC-DIS-NEXT:        [[PTR]].const   36
+; PIC-DIS-NEXT:        global.get      1
+; PIC-DIS-NEXT:        [[PTR]].add
+; DIS-NEXT:            i32.const       0
+; DIS-NEXT:            i32.const       10000
+; DIS-NEXT:            memory.fill     0
 
 ; NOPIC-DIS-NEXT:      [[PTR]].const   11060
 ; PIC-DIS-NEXT:        local.get       0
 
 ; DIS-NEXT:            i32.const       2
 ; DIS-NEXT:            i32.atomic.store        0
 
 ; NOPIC-DIS-NEXT:      [[PTR]].const   11060

lld/test/wasm/shared-memory-bss.s

+# RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
+# RUN: wasm-ld --experimental-pic -shared --shared-memory -o %t.so %t.o
+# RUN: llvm-objdump -d --no-show-raw-insn --no-leading-addr %t.so | FileCheck %s
+# RUN: obj2yaml %t.so | FileCheck %s --check-prefix=YAML
+
+.section  .bss.foo,"",@
+.globl  foo
+.p2align  2
+foo:
+  .int32  0
+  .size foo, 4
+
+.section  .data.bar,"",@
+.globl  bar
+.p2align  2
+bar:
+  .int32  42
+  .size bar, 4
+
+.section  .custom_section.target_features,"",@
+  .int8 2
+  .int8 43
+  .int8 7
+  .ascii  "atomics"
+  .int8 43
+  .int8 11
+  .ascii  "bulk-memory"
+
+# Verify that there is only a single data segment and no bss
+# in the binary:
+
+#      YAML:  - Type:            DATA{{$}}
+# YAML-NEXT:    Segments:
+# YAML-NEXT:      - SectionOffset:   3
+# YAML-NEXT:        InitFlags:       1
+# YAML-NEXT:        Content:         2A000000
+# YAML-NEXT:  - Type:            CUSTOM
+
+# CHECK:      <__wasm_init_memory>:
+# CHECK-NEXT:    .local i32
+# CHECK-NEXT:            global.get      0
+# CHECK-NEXT:            i32.const       8
+# CHECK-NEXT:            i32.add
+# CHECK-NEXT:            local.set       0
+# CHECK-NEXT:            block
+# CHECK-NEXT:            block
+# CHECK-NEXT:            block
+# CHECK-NEXT:            local.get       0
+# CHECK-NEXT:            i32.const       0
+# CHECK-NEXT:            i32.const       1
+# CHECK-NEXT:            i32.atomic.rmw.cmpxchg  0
+# CHECK-NEXT:            br_table        {0, 1, 2}       # 1: down to label1
+# CHECK-NEXT:                                            # 2: down to label0
+# CHECK-NEXT:            end
+
+# Regular data gets initialized with memory.init
+
+# CHECK-NEXT:            i32.const       0
+# CHECK-NEXT:            global.get      0
+# CHECK-NEXT:            i32.add
+# CHECK-NEXT:            i32.const       0
+# CHECK-NEXT:            i32.const       4
+# CHECK-NEXT:            memory.init     0, 0
+
+# BSS gets initialized with memory.fill
+
+# CHECK-NEXT:            i32.const       4
+# CHECK-NEXT:            global.get      0
+# CHECK-NEXT:            i32.add
+# CHECK-NEXT:            i32.const       0
+# CHECK-NEXT:            i32.const       4
+# CHECK-NEXT:            memory.fill     0

lld/test/wasm/tls.s

 # CHECK:      - Type:            GLOBAL
 # __stack_pointer
 # CHECK-NEXT:   Globals:
 # CHECK-NEXT:     - Index:           0
 # CHECK-NEXT:       Type:            I32
 # CHECK-NEXT:       Mutable:         true
 # CHECK-NEXT:       InitExpr:
 # CHECK-NEXT:         Opcode:          I32_CONST
-# CHECK-NEXT:         Value:           66576
+# CHECK-NEXT:         Value:           66592
 
 # __tls_base
 # CHECK-NEXT:     - Index:           1
 # CHECK-NEXT:       Type:            I32
 # CHECK-NEXT:       Mutable:         true
 # CHECK-NEXT:       InitExpr:
 # CHECK-NEXT:         Opcode:          I32_CONST
 # CHECK-NEXT:         Value:           0

lld/wasm/Config.h

struct Configuration {
   // requires it to be allocated to table number 0.
   bool legacyFunctionTable = false;
 
   // The table offset at which to place function addresses.  We reserve zero
   // for the null function pointer.  This gets set to 1 for executables and 0
   // for shared libraries (since they always added to a dynamic offset at
   // runtime).
   uint32_t tableBase = 0;
+
+  // Will be set to true if bss data segments should be emitted. In most cases
+  // this is not necessary.
+  bool emitBssSegments = false;
 };
 
 // The only instance of Configuration struct.
 extern Configuration *config;
 
 } // namespace wasm
 } // namespace lld
 
 #endif

lld/wasm/OutputSections.cpp

 
 void CodeSection::writeRelocations(raw_ostream &os) const {
   for (const InputChunk *c : functions)
     c->writeRelocations(os);
 }
 
 void DataSection::finalizeContents() {
   raw_string_ostream os(dataSectionHeader);
-  unsigned segmentCount =
-      std::count_if(segments.begin(), segments.end(),
-                    [](OutputSegment *segment) { return !segment->isBss; });
-
+  unsigned segmentCount = std::count_if(
+      segments.begin(), segments.end(),
+      [](OutputSegment *segment) { return segment->requiredInBinary(); });
 #ifndef NDEBUG
   unsigned activeCount = std::count_if(
       segments.begin(), segments.end(), [](OutputSegment *segment) {
         return (segment->initFlags & WASM_DATA_SEGMENT_IS_PASSIVE) == 0;
       });
 #endif
 
   assert((config->sharedMemory || !config->isPic || activeCount <= 1) &&
          "output segments should have been combined by now");
 
   writeUleb128(os, segmentCount, "data segment count");
   os.flush();
   bodySize = dataSectionHeader.size();
 
   for (OutputSegment *segment : segments) {
-    if (segment->isBss)
+    if (!segment->requiredInBinary())
       continue;
     raw_string_ostream os(segment->header);
     writeUleb128(os, segment->initFlags, "init flags");
     if (segment->initFlags & WASM_DATA_SEGMENT_HAS_MEMINDEX)
       writeUleb128(os, 0, "memory index");
     if ((segment->initFlags & WASM_DATA_SEGMENT_IS_PASSIVE) == 0) {
       WasmInitExpr initExpr;
       if (config->isPic) {
void DataSection::writeTo(uint8_t *buf) {
   // Write section header
   memcpy(buf, header.data(), header.size());
   buf += header.size();
 
   // Write data section headers
   memcpy(buf, dataSectionHeader.data(), dataSectionHeader.size());
 
   for (const OutputSegment *segment : segments) {
-    if (segment->isBss)
+    if (!segment->requiredInBinary())
       continue;
     // Write data segment header
     uint8_t *segStart = buf + segment->sectionOffset;
     memcpy(segStart, segment->header.data(), segment->header.size());
 
     // Write segment data payload
     for (const InputChunk *chunk : segment->inputSegments)
       chunk->writeTo(buf);

 void DataSection::writeRelocations(raw_ostream &os) const {
   for (const OutputSegment *seg : segments)
     for (const InputChunk *c : seg->inputSegments)
       c->writeRelocations(os);
 }
 
 bool DataSection::isNeeded() const {
   for (const OutputSegment *seg : segments)
-    if (!seg->isBss)
+    if (seg->requiredInBinary())
       return true;
   return false;
 }
 
 // Lots of duplication here with OutputSegment::finalizeInputSegments
 void CustomSection::finalizeInputSections() {
   SyntheticMergedChunk *mergedSection = nullptr;
   std::vector<InputChunk *> newSections;

lld/wasm/OutputSegment.h

 class InputSegment;
 
 class OutputSegment {
 public:
   OutputSegment(StringRef n) : name(n) {}
 
   void addInputSegment(InputChunk *inSeg);
   void finalizeInputSegments();
+  // In most circumstances BSS segments don't need to be written
+  // to the output binary.  However if the memory is imported, and
+  // we can't use memory.fill during startup (due to lack of bulk
+  // memory feature) then we include BSS segments verbatim.
+  bool requiredInBinary() const { return !isBss || config->emitBssSegments; }
 
   bool isTLS() const { return name == ".tdata"; }
 
   StringRef name;
   bool isBss = false;
   uint32_t index = 0;
   uint32_t linkingFlags = 0;
   uint32_t initFlags = 0;

lld/wasm/SyntheticSections.cpp

for (const FunctionSymbol *sym : indirectFunctions) {
     assert(sym->getTableIndex() == tableIndex);
     writeUleb128(os, sym->getFunctionIndex(), "function index");
     ++tableIndex;
   }
 }
 
 DataCountSection::DataCountSection(ArrayRef<OutputSegment *> segments)
     : SyntheticSection(llvm::wasm::WASM_SEC_DATACOUNT),
-      numSegments(std::count_if(
-          segments.begin(), segments.end(),
-          [](OutputSegment *const segment) { return !segment->isBss; })) {}
+      numSegments(std::count_if(segments.begin(), segments.end(),
+                                [](OutputSegment *const segment) {
+                                  return segment->requiredInBinary();
+                                })) {}
 
 void DataCountSection::writeBody() {
   writeUleb128(bodyOutputStream, numSegments, "data count");
 }
 
 bool DataCountSection::isNeeded() const {
   return numSegments && config->sharedMemory;
 }
unsigned NameSection::numNamedGlobals() const {
   numNames += out.globalSec->internalGotSymbols.size();
   return numNames;
 }
 
 unsigned NameSection::numNamedDataSegments() const {
   unsigned numNames = 0;
 
   for (const OutputSegment *s : segments)
-    if (!s->name.empty() && !s->isBss)
+    if (!s->name.empty() && s->requiredInBinary())
       ++numNames;
 
   return numNames;
 }
 
 // Create the custom "name" section containing debug symbol names.
 void NameSection::writeBody() {
   unsigned count = numNamedFunctions();
void NameSection::writeBody() {
   }
 
   count = numNamedDataSegments();
   if (count) {
     SubSection sub(WASM_NAMES_DATA_SEGMENT);
     writeUleb128(sub.os, count, "name count");
 
     for (OutputSegment *s : segments) {
-      if (!s->name.empty() && !s->isBss) {
+      if (!s->name.empty() && s->requiredInBinary()) {
         writeUleb128(sub.os, s->index, "global index");
         writeStr(sub.os, s->name, "segment name");
       }
     }
 
     sub.writeTo(bodyOutputStream);
   }
 }

lld/wasm/Writer.cpp

private:
   void createInitTLSFunction();
   void createCommandExportWrappers();
   void createCommandExportWrapper(uint32_t functionIndex, DefinedFunction *f);
 
   void assignIndexes();
   void populateSymtab();
   void populateProducers();
   void populateTargetFeatures();
+  // populateTargetFeatures happens early on so some checks are delayed
+  // until imports and exports are finalized.  There are run unstead
+  // in checkImportExportTargetFeatures
+  void checkImportExportTargetFeatures();
   void calculateInitFunctions();
   void calculateImports();
   void calculateExports();
   void calculateCustomSections();
   void calculateTypes();
   void createOutputSegments();
   OutputSegment *createOutputSegment(StringRef name);
   void combineOutputSegments();
void Writer::populateTargetFeatures() {
 
   if (inferFeatures)
     for (const auto &key : used.keys())
       allowed.insert(std::string(key));
 
   if (!config->checkFeatures)
     return;
 
-  if (!config->relocatable && allowed.count("mutable-globals") == 0) {
-    for (const Symbol *sym : out.importSec->importedSymbols) {
-      if (auto *global = dyn_cast<GlobalSymbol>(sym)) {
-        if (global->getGlobalType()->Mutable) {
-          error(Twine("mutable global imported but 'mutable-globals' feature "
-                      "not present in inputs: `") +
-                toString(*sym) + "`. Use --no-check-features to suppress.");
-        }
-      }
-    }
-    for (const Symbol *sym : out.exportSec->exportedSymbols) {
-      if (isa<GlobalSymbol>(sym)) {
-        error(Twine("mutable global exported but 'mutable-globals' feature "
-                    "not present in inputs: `") +
-              toString(*sym) + "`. Use --no-check-features to suppress.");
-      }
-    }
-  }
-
   if (config->sharedMemory) {
     if (disallowed.count("shared-mem"))
       error("--shared-memory is disallowed by " + disallowed["shared-mem"] +
             " because it was not compiled with 'atomics' or 'bulk-memory' "
             "features.");
 
     for (auto feature : {"atomics", "bulk-memory"})
       if (!allowed.count(feature))
for (ObjFile *file : symtab->objectFiles) {
     }
     for (const auto &feature : required.keys()) {
       if (!objectFeatures.count(std::string(feature)))
         error(Twine("Missing target feature '") + feature + "' in " + fileName +
               ", required by " + required[feature] +
               ". Use --no-check-features to suppress.");
     }
   }
+
+  // Normally we don't include bss segments in the binary.  In particular if
+  // memory is not being imported then we can assume its zero initialized.
+  // In the case the memory is imported, we and we can use the memory.fill
+  // instrction than we can also avoid inluding the segments.
+  if (config->importMemory && !allowed.count("bulk-memory"))
+    config->emitBssSegments = true;
+}
+
+void Writer::checkImportExportTargetFeatures() {
+  if (config->relocatable || !config->checkFeatures)
+    return;
+
+  if (out.targetFeaturesSec->features.count("mutable-globals") == 0) {
+    for (const Symbol *sym : out.importSec->importedSymbols) {
+      if (auto *global = dyn_cast<GlobalSymbol>(sym)) {
+        if (global->getGlobalType()->Mutable) {
+          error(Twine("mutable global imported but 'mutable-globals' feature "
+                      "not present in inputs: `") +
+                toString(*sym) + "`. Use --no-check-features to suppress.");
+        }
+      }
+    }
+    for (const Symbol *sym : out.exportSec->exportedSymbols) {
+      if (isa<GlobalSymbol>(sym)) {
+        error(Twine("mutable global exported but 'mutable-globals' feature "
+                    "not present in inputs: `") +
+              toString(*sym) + "`. Use --no-check-features to suppress.");
+      }
+    }
+  }
 }
 
 static bool shouldImport(Symbol *sym) {
   // We don't generate imports for data symbols. They however can be imported
   // as GOT entries.
   if (isa<DataSymbol>(sym))
     return false;
   if (!sym->isLive())
static StringRef getOutputDataSegmentName(const InputChunk &seg) {
   return name;
 }
 
 OutputSegment *Writer::createOutputSegment(StringRef name) {
   LLVM_DEBUG(dbgs() << "new segment: " << name << "\n");
   OutputSegment *s = make<OutputSegment>(name);
   if (config->sharedMemory)
     s->initFlags = WASM_DATA_SEGMENT_IS_PASSIVE;
-  // Exported memories are guaranteed to be zero-initialized, so no need
-  // to emit data segments for bss sections.
-  // TODO: consider initializing bss sections with memory.fill
-  // instructions when memory is imported and bulk-memory is available.
-  if (!config->importMemory && !config->relocatable && name.startswith(".bss"))
+  if (!config->relocatable && name.startswith(".bss"))
     s->isBss = true;
   segments.push_back(s);
   return s;
 }
 
 void Writer::createOutputSegments() {
   for (ObjFile *file : symtab->objectFiles) {
     for (InputChunk *segment : file->segments) {
std::string functionBody;
     writeUleb128(os, bodyContent.size(), "function size");
     os << bodyContent;
   }
   ArrayRef<uint8_t> body = arrayRefFromStringRef(saver.save(functionBody));
   cast<SyntheticFunction>(func->function)->setBody(body);
 }
 
 bool Writer::needsPassiveInitialization(const OutputSegment *segment) {
-  return segment->initFlags & WASM_DATA_SEGMENT_IS_PASSIVE &&
-         !segment->isTLS() && !segment->isBss;
+  // TLS segments are initialized separately
+  if (segment->isTLS())
+    return false;
+  // If bulk memory features is supported then we can perform bss initialization
+  // (via memory.fill) during `__wasm_init_memory`.
+  if (config->importMemory && !segment->requiredInBinary())
+    return true;
+  return segment->initFlags & WASM_DATA_SEGMENT_IS_PASSIVE;
 }
 
 bool Writer::hasPassiveInitializedSegments() {
   return llvm::any_of(segments, [this](const OutputSegment *s) {
     return this->needsPassiveInitialization(s);
   });
 }
 
 void Writer::createSyntheticInitFunctions() {
   if (config->relocatable)
     return;
 
   static WasmSignature nullSignature = {{}, {}};
 
   // Passive segments are used to avoid memory being reinitialized on each
   // thread's instantiation. These passive segments are initialized and
   // dropped in __wasm_init_memory, which is registered as the start function
-  if (config->sharedMemory && hasPassiveInitializedSegments()) {
+  // We also initialize bss segments (using memory.fill) as part of this
+  // function.
+  if (hasPassiveInitializedSegments()) {
     WasmSym::initMemory = symtab->addSyntheticFunction(
         "__wasm_init_memory", WASM_SYMBOL_VISIBILITY_HIDDEN,
         make<SyntheticFunction>(nullSignature, "__wasm_init_memory"));
     WasmSym::initMemory->markLive();
   }
 
   if (config->isPic) {
     // For PIC code we create synthetic functions that apply relocations.
WasmSym::startFunction = symtab->addSyntheticFunction(
         make<SyntheticFunction>(nullSignature, "__wasm_start"));
     WasmSym::startFunction->markLive();
   }
 }
 
 void Writer::createInitMemoryFunction() {
   LLVM_DEBUG(dbgs() << "createInitMemoryFunction\n");
   assert(WasmSym::initMemory);
-  assert(WasmSym::initMemoryFlag);
   assert(hasPassiveInitializedSegments());
-  uint64_t flagAddress = WasmSym::initMemoryFlag->getVA();
+  uint64_t flagAddress;
+  if (config->sharedMemory) {
+    assert(WasmSym::initMemoryFlag);
+    flagAddress = WasmSym::initMemoryFlag->getVA();
+  }
   bool is64 = config->is64.getValueOr(false);
   std::string bodyContent;
   {
     raw_string_ostream os(bodyContent);
     // Initialize memory in a thread-safe manner. The thread that successfully
     // increments the flag from 0 to 1 is is responsible for performing the
     // memory initialization. Other threads go sleep on the flag until the
     // first thread finishing initializing memory, increments the flag to 2,
std::string bodyContent;
     // )
     //
     // When we are building with PIC, calculate the flag location using:
     //
     //    (global.get $__memory_base)
     //    (i32.const $__init_memory_flag)
     //    (i32.const 1)
 
+    auto writeGetFlagAddress = [&]() {
+      if (config->isPic) {
+        writeU8(os, WASM_OPCODE_LOCAL_GET, "local.get");
+        writeUleb128(os, 0, "local 0");
+      } else {
+        writePtrConst(os, flagAddress, is64, "flag address");
+      }
+    };
+
+    if (config->sharedMemory) {
       // With PIC code we cache the flag address in local 0
       if (config->isPic) {
         writeUleb128(os, 1, "num local decls");
         writeUleb128(os, 1, "local count");
         writeU8(os, is64 ? WASM_TYPE_I64 : WASM_TYPE_I32, "address type");
         writeU8(os, WASM_OPCODE_GLOBAL_GET, "GLOBAL_GET");
         writeUleb128(os, WasmSym::memoryBase->getGlobalIndex(), "memory_base");
         writePtrConst(os, flagAddress, is64, "flag address");
         writeU8(os, is64 ? WASM_OPCODE_I64_ADD : WASM_OPCODE_I32_ADD, "add");
         writeU8(os, WASM_OPCODE_LOCAL_SET, "local.set");
         writeUleb128(os, 0, "local 0");
       } else {
         writeUleb128(os, 0, "num locals");
       }
 
-    auto writeGetFlagAddress = [&]() {
-      if (config->isPic) {
-        writeU8(os, WASM_OPCODE_LOCAL_GET, "local.get");
-        writeUleb128(os, 0, "local 0");
-      } else {
-        writePtrConst(os, flagAddress, is64, "flag address");
-      }
-    };
-
       // Set up destination blocks
       writeU8(os, WASM_OPCODE_BLOCK, "block $drop");
       writeU8(os, WASM_TYPE_NORESULT, "block type");
       writeU8(os, WASM_OPCODE_BLOCK, "block $wait");
       writeU8(os, WASM_TYPE_NORESULT, "block type");
       writeU8(os, WASM_OPCODE_BLOCK, "block $init");
       writeU8(os, WASM_TYPE_NORESULT, "block type");
 
       // Atomically check whether we win the race.
       writeGetFlagAddress();
       writeI32Const(os, 0, "expected flag value");
       writeI32Const(os, 1, "new flag value");
       writeU8(os, WASM_OPCODE_ATOMICS_PREFIX, "atomics prefix");
       writeUleb128(os, WASM_OPCODE_I32_RMW_CMPXCHG, "i32.atomic.rmw.cmpxchg");
       writeMemArg(os, 2, 0);
 
       // Based on the value, decide what to do next.
       writeU8(os, WASM_OPCODE_BR_TABLE, "br_table");
       writeUleb128(os, 2, "label vector length");
       writeUleb128(os, 0, "label $init");
       writeUleb128(os, 1, "label $wait");
       writeUleb128(os, 2, "default label $drop");
 
       // Initialize passive data segments
       writeU8(os, WASM_OPCODE_END, "end $init");
+    } else {
+      writeUleb128(os, 0, "num local decls");
+    }
+
     for (const OutputSegment *s : segments) {
       if (needsPassiveInitialization(s)) {
-        // destination address
+        // For passive BSS segments we can simple issue a memory.fill(0).
+        // For non-BSS segments we do a memory.init.  Both these
+        // instructions take as thier first argument the destination
+        // address.
         writePtrConst(os, s->startVA, is64, "destination address");
         if (config->isPic) {
           writeU8(os, WASM_OPCODE_GLOBAL_GET, "GLOBAL_GET");
           writeUleb128(os, WasmSym::memoryBase->getGlobalIndex(),
                        "memory_base");
           writeU8(os, is64 ? WASM_OPCODE_I64_ADD : WASM_OPCODE_I32_ADD,
                   "i32.add");
         }
-        // source segment offset
-        writeI32Const(os, 0, "segment offset");
-        // memory region size
+        if (s->isBss) {
+          writeI32Const(os, 0, "fill value");
+          writeI32Const(os, s->size, "memory region size");
+          writeU8(os, WASM_OPCODE_MISC_PREFIX, "bulk-memory prefix");
+          writeUleb128(os, WASM_OPCODE_MEMORY_FILL, "memory.fill");
+          writeU8(os, 0, "memory index immediate");
+        } else {
+          writeI32Const(os, 0, "source segment offset");
           writeI32Const(os, s->size, "memory region size");
-        // memory.init instruction
           writeU8(os, WASM_OPCODE_MISC_PREFIX, "bulk-memory prefix");
           writeUleb128(os, WASM_OPCODE_MEMORY_INIT, "memory.init");
           writeUleb128(os, s->index, "segment index immediate");
           writeU8(os, 0, "memory index immediate");
         }
       }
+    }
 
+    if (config->sharedMemory) {
       // Set flag to 2 to mark end of initialization
       writeGetFlagAddress();
       writeI32Const(os, 2, "flag value");
       writeU8(os, WASM_OPCODE_ATOMICS_PREFIX, "atomics prefix");
       writeUleb128(os, WASM_OPCODE_I32_ATOMIC_STORE, "i32.atomic.store");
       writeMemArg(os, 2, 0);
 
       // Notify any waiters that memory initialization is complete
       writeGetFlagAddress();
       writeI32Const(os, -1, "number of waiters");
       writeU8(os, WASM_OPCODE_ATOMICS_PREFIX, "atomics prefix");
       writeUleb128(os, WASM_OPCODE_ATOMIC_NOTIFY, "atomic.notify");
       writeMemArg(os, 2, 0);
       writeU8(os, WASM_OPCODE_DROP, "drop");
 
       // Branch to drop the segments
       writeU8(os, WASM_OPCODE_BR, "br");
       writeUleb128(os, 1, "label $drop");
 
       // Wait for the winning thread to initialize memory
       writeU8(os, WASM_OPCODE_END, "end $wait");
       writeGetFlagAddress();
       writeI32Const(os, 1, "expected flag value");
       writeI64Const(os, -1, "timeout");
 
       writeU8(os, WASM_OPCODE_ATOMICS_PREFIX, "atomics prefix");
       writeUleb128(os, WASM_OPCODE_I32_ATOMIC_WAIT, "i32.atomic.wait");
       writeMemArg(os, 2, 0);
       writeU8(os, WASM_OPCODE_DROP, "drop");
 
       // Unconditionally drop passive data segments
       writeU8(os, WASM_OPCODE_END, "end $drop");
+    }
+
     for (const OutputSegment *s : segments) {
-      if (needsPassiveInitialization(s)) {
+      if (needsPassiveInitialization(s) && !s->isBss) {
         // data.drop instruction
         writeU8(os, WASM_OPCODE_MISC_PREFIX, "bulk-memory prefix");
         writeUleb128(os, WASM_OPCODE_DATA_DROP, "data.drop");
         writeUleb128(os, s->index, "segment index immediate");
       }
     }
 
     // End the function
void Writer::run() {
   log("-- populateProducers");
   populateProducers();
   log("-- calculateImports");
   calculateImports();
   log("-- scanRelocations");
   scanRelocations();
   log("-- finalizeIndirectFunctionTable");
   finalizeIndirectFunctionTable();
+  log("-- populateTargetFeatures");
+  populateTargetFeatures();
   log("-- createSyntheticInitFunctions");
   createSyntheticInitFunctions();
   log("-- assignIndexes");
   assignIndexes();
   log("-- calculateInitFunctions");
   calculateInitFunctions();
 
   if (!config->relocatable) {
void Writer::run() {
   log("-- calculateTypes");
   calculateTypes();
   log("-- calculateExports");
   calculateExports();
   log("-- calculateCustomSections");
   calculateCustomSections();
   log("-- populateSymtab");
   populateSymtab();
-  log("-- populateTargetFeatures");
-  populateTargetFeatures();
+  log("-- checkImportExportTargetFeatures");
+  checkImportExportTargetFeatures();
   log("-- addSections");
   addSections();
 
   if (errorHandler().verbose) {
     log("Defined Functions: " + Twine(out.functionSec->inputFunctions.size()));
     log("Defined Globals  : " + Twine(out.globalSec->numGlobals()));
     log("Defined Tags     : " + Twine(out.tagSec->inputTags.size()));
     log("Defined Tables   : " + Twine(out.tableSec->inputTables.size()));

llvm/include/llvm/BinaryFormat/Wasm.h

 enum : unsigned {
   WASM_OPCODE_BLOCK = 0x02,
   WASM_OPCODE_BR = 0x0c,
   WASM_OPCODE_BR_TABLE = 0x0e,
   WASM_OPCODE_RETURN = 0x0f,
   WASM_OPCODE_DROP = 0x1a,
   WASM_OPCODE_MISC_PREFIX = 0xfc,
   WASM_OPCODE_MEMORY_INIT = 0x08,
+  WASM_OPCODE_MEMORY_FILL = 0x0b,
   WASM_OPCODE_DATA_DROP = 0x09,
   WASM_OPCODE_ATOMICS_PREFIX = 0xfe,
   WASM_OPCODE_ATOMIC_NOTIFY = 0x00,
   WASM_OPCODE_I32_ATOMIC_WAIT = 0x01,
   WASM_OPCODE_I32_ATOMIC_STORE = 0x17,
   WASM_OPCODE_I32_RMW_CMPXCHG = 0x48,
 };