[lld][WebAssembly] Delay creation of internal __wasm_memory_init function

[sbc100]

Summary

This also allows for its creation to be conditional so it is
completely elided when not needed.

[sbc100]

revert part

[tlively]

"not completely elided" => "completely elided" in the description.

lld/wasm/SyntheticSections.h

241–242

It looks like this argument is no longer used.

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

 ; PASSIVE-MERGE-NEXT:        InitFlags:       1
 ; PASSIVE-MERGE-NEXT:        Content:         68656C6C6F00676F6F6462796500776861746576657200002A000000
 ; PASSIVE-MERGE-NEXT:  - Type:            CUSTOM
 ; PASSIVE-MERGE-NEXT:    Name:            name
 ; PASSIVE-MERGE-NEXT:    FunctionNames:
 ; PASSIVE-MERGE-NEXT:      - Index:           0
 ; PASSIVE-MERGE-NEXT:        Name:            __wasm_call_ctors
 ; PASSIVE-MERGE-NEXT:      - Index:           1
-; PASSIVE-MERGE-NEXT:        Name:            __wasm_init_memory
-; PASSIVE-MERGE-NEXT:      - Index:           2
 ; PASSIVE-MERGE-NEXT:        Name:            __wasm_init_tls
+; PASSIVE-MERGE-NEXT:      - Index:           2
+; PASSIVE-MERGE-NEXT:        Name:            __wasm_init_memory
 
 ; RUN: wasm-ld -no-gc-sections --no-entry --shared-memory --max-memory=131072 -no-merge-data-segments -o %t.separate.passive.wasm %t.passive.o
 ; RUN: obj2yaml %t.separate.passive.wasm | FileCheck %s --check-prefix=PASSIVE-SEPARATE
 ; RUN: wasm-ld -mwasm64 -no-gc-sections --no-entry --shared-memory --max-memory=131072 -no-merge-data-segments -o %t.separate.passive64.wasm %t.passive64.o
 ; RUN: obj2yaml %t.separate.passive64.wasm | FileCheck %s --check-prefix=PASSIVE-SEPARATE
 
 ; PASSIVE-SEPARATE-LABEL: - Type:            DATACOUNT
 ; PASSIVE-SEPARATE-NEXT:    Count:           6

 ; PASSIVE-SEPARATE-NEXT:        InitFlags:       1
 ; PASSIVE-SEPARATE-NEXT:        Content:         2A000000
 ; PASSIVE-SEPARATE-NEXT:    - Type:            CUSTOM
 ; PASSIVE-SEPARATE-NEXT:      Name:            name
 ; PASSIVE-SEPARATE-NEXT:      FunctionNames:
 ; PASSIVE-SEPARATE-NEXT:        - Index:           0
 ; PASSIVE-SEPARATE-NEXT:          Name:            __wasm_call_ctors
 ; PASSIVE-SEPARATE-NEXT:        - Index:           1
-; PASSIVE-SEPARATE-NEXT:          Name:            __wasm_init_memory
-; PASSIVE-SEPARATE-NEXT:        - Index:           2
 ; PASSIVE-SEPARATE-NEXT:          Name:            __wasm_init_tls
+; PASSIVE-SEPARATE-NEXT:        - Index:           2
+; PASSIVE-SEPARATE-NEXT:          Name:            __wasm_init_memory

lld/test/wasm/data-segments.ll

 ; ACTIVE-NEXT:        Content:         68656C6C6F00676F6F646279650000002A000000
 ; ACTIVE-NEXT:  - Type:            CUSTOM
 ; ACTIVE-NEXT:    Name:            name
 ; ACTIVE-NEXT:    FunctionNames:
 ; ACTIVE-NEXT:      - Index:           0
 ; ACTIVE-NEXT:        Name:            __wasm_call_ctors
 
 ; PASSIVE-LABEL: - Type:            START
-; PASSIVE-NEXT:    StartFunction:   1
+; PASSIVE-NEXT:    StartFunction:   2
 ; PASSIVE-LABEL: - Type:            DATACOUNT
 ; PASSIVE-NEXT:    Count:           2
 ; PASSIVE-LABEL: - Type:            CODE
 ; PASSIVE-NEXT:    Functions:
 ; PASSIVE-NEXT:      - Index:           0
 ; PASSIVE-NEXT:        Locals:          []
 ; PASSIVE-NEXT:        Body:            0B
 ; PASSIVE-NEXT:      - Index:           1
 ; PASSIVE-NEXT:        Locals:          []
-; PASSIVE32-NEXT:        Body:            41B4D60041004101FE480200044041B4D6004101427FFE0102001A054180084100410DFC08000041900841004114FC08010041B4D6004102FE17020041B4D600417FFE0002001A0BFC0900FC09010B
-; PASSIVE64-NEXT:        Body:            42B4D60041004101FE480200044042B4D6004101427FFE0102001A054280084100410DFC08000042900841004114FC08010042B4D6004102FE17020042B4D600417FFE0002001A0BFC0900FC09010B
-
-; PASSIVE-NEXT:  - Index:           2
-; PASSIVE-NEXT:    Locals:          []
-; PASSIVE-NEXT:    Body:            0B
+; PASSIVE-NEXT:        Body:            0B
+; PASSIVE-NEXT:      - Index:           2
+; PASSIVE-NEXT:        Locals:          []
+; PASSIVE32-NEXT:        Body:            41B4D60041004101FE480200044041B4D6004101427FFE0102001A054180084100410DFC08000041900841004114FC08010041B4D6004102FE17020041B4D600417FFE0002001A0BFC0900FC09010B
+; PASSIVE64-NEXT:        Body:            42B4D60041004101FE480200044042B4D6004101427FFE0102001A054280084100410DFC08000042900841004114FC08010042B4D6004102FE17020042B4D600417FFE0002001A0BFC0900FC09010B
 ; PASSIVE-NEXT:  - Type:            DATA
 ; PASSIVE-NEXT:    Segments:
 ; PASSIVE-NEXT:      - SectionOffset:   3
 ; PASSIVE-NEXT:        InitFlags:       1
 ; PASSIVE-NEXT:        Content:         636F6E7374616E74000000002B
 ; PASSIVE-NEXT:      - SectionOffset:   18
 ; PASSIVE-NEXT:        InitFlags:       1
 ; PASSIVE-NEXT:        Content:         68656C6C6F00676F6F646279650000002A000000
 ; PASSIVE-NEXT:  - Type:            CUSTOM
 ; PASSIVE-NEXT:    Name:            name
 ; PASSIVE-NEXT:    FunctionNames:
 ; PASSIVE-NEXT:      - Index:           0
 ; PASSIVE-NEXT:        Name:            __wasm_call_ctors
 ; PASSIVE-NEXT:      - Index:           1
-; PASSIVE-NEXT:        Name:            __wasm_init_memory
-; PASSIVE-NEXT:      - Index:           2
 ; PASSIVE-NEXT:        Name:            __wasm_init_tls
+; PASSIVE-NEXT:      - Index:           2
+; PASSIVE-NEXT:        Name:            __wasm_init_memory
 
 ;      PASSIVE-PIC:  - Type:            START
-; PASSIVE-PIC-NEXT:    StartFunction:   2
+; PASSIVE-PIC-NEXT:    StartFunction:   3
 ; PASSIVE-PIC-NEXT:  - Type:            DATACOUNT
 ; PASSIVE-PIC-NEXT:    Count:           1
 ; PASSIVE-PIC-NEXT:  - Type:            CODE
 ; PASSIVE-PIC-NEXT:    Functions:
 ; PASSIVE-PIC-NEXT:      - Index:           0
 ; PASSIVE-PIC-NEXT:        Locals:          []
 ; PASSIVE-PIC-NEXT:        Body:            10010B
 ; PASSIVE-PIC-NEXT:      - Index:           1
 ; PASSIVE-PIC-NEXT:        Locals:          []
 ; PASSIVE-PIC-NEXT:        Body:            0B
 ; PASSIVE-PIC-NEXT:      - Index:           2
+; PASSIVE-PIC-NEXT:        Locals:          []
+; PASSIVE-PIC-NEXT:        Body:            0B
+; PASSIVE-PIC-NEXT:      - Index:           3
 ; PASSIVE-PIC-NEXT:        Locals:
 ; PASSIVE32-PIC-NEXT:          - Type:            I32
 ; PASSIVE64-PIC-NEXT:          - Type:            I64
 ; PASSIVE-PIC-NEXT:            Count:           1
 ; PASSIVE32-PIC-NEXT:        Body:            230141B4CE006A2100200041004101FE480200044020004101427FFE0102001A05410023016A410041B1CE00FC08000020004102FE1702002000417FFE0002001A0BFC09000B
 ; PASSIVE64-PIC-NEXT:        Body:            230142B4CE006A2100200041004101FE480200044020004101427FFE0102001A05420023016A410041B1CE00FC08000020004102FE1702002000417FFE0002001A0BFC09000B
-; PASSIVE-PIC-NEXT:      - Index:           3
-; PASSIVE-PIC-NEXT:        Locals:          []
-; PASSIVE-PIC-NEXT:        Body:            0B
 ; PASSIVE-PIC-NEXT:  - Type:            DATA
 ; PASSIVE-PIC-NEXT:    Segments:
 ; PASSIVE-PIC-NEXT:      - SectionOffset:   4
 ; PASSIVE-PIC-NEXT:        InitFlags:       1
 
 ;      PASSIVE-PIC:  - Type:            CUSTOM
 ; PASSIVE-PIC-NEXT:    Name:            name
 ; PASSIVE-PIC-NEXT:    FunctionNames:
 ; PASSIVE-PIC-NEXT:      - Index:           0
 ; PASSIVE-PIC-NEXT:        Name:            __wasm_call_ctors
 ; PASSIVE-PIC-NEXT:      - Index:           1
 ; PASSIVE-PIC-NEXT:        Name:            __wasm_apply_relocs
 ; PASSIVE-PIC-NEXT:      - Index:           2
-; PASSIVE-PIC-NEXT:        Name:            __wasm_init_memory
-; PASSIVE-PIC-NEXT:      - Index:           3
 ; PASSIVE-PIC-NEXT:        Name:            __wasm_init_tls
+; PASSIVE-PIC-NEXT:      - Index:           3
+; PASSIVE-PIC-NEXT:        Name:            __wasm_init_memory

lld/test/wasm/no-tls.s

 # CHECK-NEXT:    Globals:
 
 # __stack_pointer
 # 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:           66560
 
 # __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/test/wasm/tls.s

 
 # CHECK:      - Type:            GLOBAL
 # 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:           66592
+# CHECK-NEXT:         Value:           66576
 
 # __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

 # CHECK-NEXT:       Mutable:         false
 # CHECK-NEXT:       InitExpr:
 # CHECK-NEXT:         Opcode:          I32_CONST
 # CHECK-NEXT:         Value:           4
 
 
 # CHECK:      - Type:            CODE
 # CHECK-NEXT:   Functions:
-# Skip __wasm_call_ctors and __wasm_init_memory
-# CHECK:          - Index:           2
+# Skip __wasm_call_ctors
+# CHECK:          - Index:           1
 # CHECK-NEXT:       Locals:          []
 # CHECK-NEXT:       Body:            2000240120004100410CFC0800000B
 
 # Expected body of __wasm_init_tls:
 #   local.get 0
 #   global.set  1
 #   local.get 0
 #   i32.const 0
 #   i32.const 12
 #   memory.init 1, 0
 #   end
 
-# CHECK-NEXT:     - Index:           3
+# CHECK-NEXT:     - Index:           2
 # CHECK-NEXT:       Locals:          []
 # CHECK-NEXT:       Body:            2381808080004180808080006A0B
 
 # Expected body of tls1_addr:
 #   global.get 1
 #   i32.const 0
 #   i32.add
 #   end
 
-# CHECK-NEXT:     - Index:           4
+# CHECK-NEXT:     - Index:           3
 # CHECK-NEXT:       Locals:          []
 # CHECK-NEXT:       Body:            2381808080004184808080006A0B
 
 # Expected body of tls2_addr:
 #   global.get 1
 #   i32.const 4
 #   i32.add
 #   end
 
-# CHECK-NEXT:     - Index:           5
+# CHECK-NEXT:     - Index:           4
 # CHECK-NEXT:       Locals:          []
 # CHECK-NEXT:       Body:            2381808080004188808080006A0B
 
 # Expected body of tls3_addr:
 #   global.get 1
 #   i32.const 4
 #   i32.add
 #   end
 
-# CHECK-NEXT:     - Index:           6
+# CHECK-NEXT:     - Index:           5
 # CHECK-NEXT:       Locals:          []
 # CHECK-NEXT:       Body:            2383808080000B
 
 # Expected body of tls_align:
 #   global.get 3
 #   end

lld/wasm/Driver.cpp

if (config->isPic) {
     WasmSym::tableBase->markLive();
   } else {
     // For non-PIC code
     WasmSym::stackPointer = createGlobalVariable("__stack_pointer", true);
     WasmSym::stackPointer->markLive();
   }
 
   if (config->sharedMemory) {
-    // 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
-    WasmSym::initMemory = symtab->addSyntheticFunction(
-        "__wasm_init_memory", WASM_SYMBOL_VISIBILITY_HIDDEN,
-        make<SyntheticFunction>(nullSignature, "__wasm_init_memory"));
-    WasmSym::initMemoryFlag = symtab->addSyntheticDataSymbol(
-        "__wasm_init_memory_flag", WASM_SYMBOL_VISIBILITY_HIDDEN);
-    assert(WasmSym::initMemoryFlag);
     WasmSym::tlsBase = createGlobalVariable("__tls_base", true);
     WasmSym::tlsSize = createGlobalVariable("__tls_size", false);
     WasmSym::tlsAlign = createGlobalVariable("__tls_align", false);
     WasmSym::initTLS = symtab->addSyntheticFunction(
         "__wasm_init_tls", WASM_SYMBOL_VISIBILITY_HIDDEN,
         make<SyntheticFunction>(
             config->is64.getValueOr(false) ? i64ArgSignature : i32ArgSignature,
             "__wasm_init_tls"));

lld/wasm/MarkLive.cpp

if (sym->isNoStrip() || sym->isExported())
       enqueue(sym);
 
   if (WasmSym::callDtors)
     enqueue(WasmSym::callDtors);
 
   if (WasmSym::applyRelocs)
     enqueue(WasmSym::applyRelocs);
 
-  if (WasmSym::initMemory)
-    enqueue(WasmSym::initMemory);
-
   // Enqueue constructors in objects explicitly live from the command-line.
   for (const ObjFile *obj : symtab->objectFiles)
     if (obj->isLive())
       enqueueInitFunctions(obj);
 
   mark();
 
   // If we have any non-discarded init functions, mark `__wasm_call_ctors` as

lld/wasm/SyntheticSections.h

public:
   bool isNeeded() const override { return exports.size() > 0; }
   void writeBody() override;
 
   std::vector<llvm::wasm::WasmExport> exports;
   std::vector<const Symbol *> exportedSymbols;
 };
 
 class StartSection : public SyntheticSection {
 public:
-  StartSection(bool hasInitializedSegments)
-      : SyntheticSection(llvm::wasm::WASM_SEC_START),
-        hasInitializedSegments(hasInitializedSegments) {}
+  StartSection() : SyntheticSection(llvm::wasm::WASM_SEC_START) {}
   bool isNeeded() const override;
   void writeBody() override;
-
-protected:
-  bool hasInitializedSegments;
 };
 
 class ElemSection : public SyntheticSection {
 public:
   ElemSection()
       : SyntheticSection(llvm::wasm::WASM_SEC_ELEM) {}
   bool isNeeded() const override { return indirectFunctions.size() > 0; };
   void writeBody() override;

lld/wasm/Writer.cpp

public:
   void run();
 
 private:
   void openFile();
 
   bool needsPassiveInitialization(const OutputSegment *segment);
   bool hasPassiveInitializedSegments();
 
+  void createSyntheticInitFunctions();
   void createInitMemoryFunction();
   void createApplyRelocationsFunction();
   void createCallCtorsFunction();
   void createInitTLSFunction();
   void createCommandExportWrappers();
   void createCommandExportWrapper(uint32_t functionIndex, DefinedFunction *f);
 
   void assignIndexes();

 
 bool Writer::hasPassiveInitializedSegments() {
   return std::find_if(segments.begin(), segments.end(),
                       [this](const OutputSegment *s) {
                         return this->needsPassiveInitialization(s);
                       }) != segments.end();
 }
 
+void Writer::createSyntheticInitFunctions() {
+  // 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()) {
+    static WasmSignature nullSignature = {{}, {}};
+    WasmSym::initMemory = symtab->addSyntheticFunction(
+        "__wasm_init_memory", WASM_SYMBOL_VISIBILITY_HIDDEN,
+        make<SyntheticFunction>(nullSignature, "__wasm_init_memory"));
+    WasmSym::initMemory->markLive();
+    WasmSym::initMemoryFlag = symtab->addSyntheticDataSymbol(
+        "__wasm_init_memory_flag", WASM_SYMBOL_VISIBILITY_HIDDEN);
+    WasmSym::initMemoryFlag->markLive();
+  }
+}
+
 void Writer::createInitMemoryFunction() {
   LLVM_DEBUG(dbgs() << "createInitMemoryFunction\n");
+  assert(WasmSym::initMemory);
   assert(WasmSym::initMemoryFlag);
+  assert(hasPassiveInitializedSegments());
   uint64_t flagAddress = WasmSym::initMemoryFlag->getVirtualAddress();
   bool is64 = config->is64.getValueOr(false);
   std::string bodyContent;
   {
     raw_string_ostream os(bodyContent);
-    // 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, WASM_OPCODE_I32_ADD, "add");
-      writeU8(os, WASM_OPCODE_LOCAL_SET, "local.set");
-      writeUleb128(os, 0, "local 0");
-    } else {
-      writeUleb128(os, 0, "num locals");
-    }
-
-    if (hasPassiveInitializedSegments()) {
-      // 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,
-      // and wakes all the other threads. Once the flag has been set to 2,
-      // subsequently started threads will skip the sleep. All threads
-      // unconditionally drop their passive data segments once memory has been
-      // initialized. The generated code is as follows:
-      //
-      // (func $__wasm_init_memory
-      //  (if
-      //   (i32.atomic.rmw.cmpxchg align=2 offset=0
-      //    (i32.const $__init_memory_flag)
-      //    (i32.const 0)
-      //    (i32.const 1)
-      //   )
-      //   (then
-      //    (drop
-      //     (i32.atomic.wait align=2 offset=0
-      //      (i32.const $__init_memory_flag)
-      //      (i32.const 1)
-      //      (i32.const -1)
-      //     )
-      //    )
-      //   )
-      //   (else
-      //    ( ... initialize data segments ... )
-      //    (i32.atomic.store align=2 offset=0
-      //     (i32.const $__init_memory_flag)
-      //     (i32.const 2)
-      //    )
-      //    (drop
-      //     (i32.atomic.notify align=2 offset=0
-      //      (i32.const $__init_memory_flag)
-      //      (i32.const -1u)
-      //     )
-      //    )
-      //   )
-      //  )
-      //  ( ... drop data segments ... )
-      // )
-      //
-      // 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");
-        }
-      };
+    // 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, WASM_OPCODE_I32_ADD, "add");
+      writeU8(os, WASM_OPCODE_LOCAL_SET, "local.set");
+      writeUleb128(os, 0, "local 0");
+    } else {
+      writeUleb128(os, 0, "num locals");
+    }
+
 
-      // Atomically check whether this is the main thread.
-      writeGetFlagAddress();
-      writeI32Const(os, 0, "expected flag value");
-      writeI32Const(os, 1, "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);
-      writeU8(os, WASM_OPCODE_IF, "IF");
-      writeU8(os, WASM_TYPE_NORESULT, "blocktype");
 
-      // Did not increment 0, so wait for main thread to initialize memory
-      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");
 
-      writeU8(os, WASM_OPCODE_ELSE, "ELSE");
 
-      // Did increment 0, so conditionally initialize passive data segments
-      for (const OutputSegment *s : segments) {
-        if (needsPassiveInitialization(s)) {
-          // 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, WASM_OPCODE_I32_ADD, "i32.add");
-          }
-          // source segment offset
-          writeI32Const(os, 0, "segment offset");
-          // memory region size
-          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");
-        }
-      }
 
-      // 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");
 
-      writeU8(os, WASM_OPCODE_END, "END");
 
-      // Unconditionally drop passive data segments
-      for (const OutputSegment *s : segments) {
-        if (needsPassiveInitialization(s)) {
-          // 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");
-        }
-      }
-    }
     writeU8(os, WASM_OPCODE_END, "END");
   }
 
   createFunction(WasmSym::initMemory, bodyContent);
 }
 
 // For -shared (PIC) output, we create create a synthetic function which will
 // apply any relocations to the data segments on startup.  This function is
void Writer::createSyntheticSections() {
   out.typeSec = make<TypeSection>();
   out.importSec = make<ImportSection>();
   out.functionSec = make<FunctionSection>();
   out.tableSec = make<TableSection>();
   out.memorySec = make<MemorySection>();
   out.eventSec = make<EventSection>();
   out.globalSec = make<GlobalSection>();
   out.exportSec = make<ExportSection>();
-  out.startSec = make<StartSection>(hasPassiveInitializedSegments());
+  out.startSec = make<StartSection>();
   out.elemSec = make<ElemSection>();
   out.dataCountSec = make<DataCountSection>(segments);
   out.linkingSec = make<LinkingSection>(initFunctions, segments);
   out.nameSec = make<NameSection>(segments);
   out.producersSec = make<ProducersSection>();
   out.targetFeaturesSec = make<TargetFeaturesSection>();
 }
 
void Writer::run() {
   log("-- createOutputSegments");
   createOutputSegments();
   log("-- createSyntheticSections");
   createSyntheticSections();
   log("-- populateProducers");
   populateProducers();
   log("-- calculateImports");
   calculateImports();
+  log("-- createSyntheticInitFunctions");
+  createSyntheticInitFunctions();
   log("-- layoutMemory");
   layoutMemory();
 
   if (!config->relocatable) {
     // Create linker synthesized __start_SECNAME/__stop_SECNAME symbols
     // This has to be done after memory layout is performed.
     for (const OutputSegment *seg : segments)
       addStartStopSymbols(seg);