[wasm-ld] Add support for calling constructors in reactors.

[sunfish]

Summary

With [WebAssembly/wasi-libc#328], we no longer want the behavior of
automatically inserting constructor calls on every command export.
The libc is now responsible for calling constructor calls in its
_start entrypoint. So it makes sense to remove support for
auto-wrapping command exports now.

At the same time, with [WebAssembly/wasi-libc#328], we are moving to
a place where users who had previously been building reactors and
getting away with not running the constructors will suddenly have a
harder time doing so.

And as in [WebAssembly/wasi-libc#329], we're anticipating Wasm modules
being used in more environments where these invariants won't be as easy
to enforce.

So instead of removing the auto-wrapping *command* export code entirely,
convert into code to code that auto-wraps *reactor* exports. And give
it logic to call __wasm_call_ctors only if it hasn't been called yet.
That way, constructors will run automatically on the first export call,
so existing users won't be suddenly broken, and so reactors in general
won't be as tricky to use.

[WebAssembly/wasi-libc#328]: https://github.com/WebAssembly/wasi-libc/pull/328
[WebAssembly/wasi-libc#338]: https://github.com/WebAssembly/wasi-libc/pull/338
[WebAssembly/wasi-libc#329]: https://github.com/WebAssembly/wasi-libc/pull/329

[sbc100]

Aren't reactors supposed to define an _initialize function that takes care of this?

Perhaps the idea is to make the reactor model work even for users that don't link against crt1_reactor.o?

In that case could we instead create a default _initialize function here and avoid the wrappers completely?

e.g.

if (!isDefined("_initialize")) {
  create_default_initialize();
}

Obviously this would mean that if a user supplies their own initialize function that they need to take care of calling __wasm_call_ctors, but that seems like a pretty reasonable expectation.

lld/test/wasm/init-fini-no-gc.ll

59

These days we can use llvm-object -d to disassembly the code here, making the test more readable. See lld/test/wasm/tls.s for example.

lld/test/wasm/reactor-exports.s

87–90

Ditto, we can use disassembly here now.

lld/wasm/Symbols.h

539

This could be tricky because wasm globals are non-shared and therefore thread local.

@tlively solved this problem for data segment initialization by using a word of memory instead. Search for initMemoryFlag to see how it was done in that case.

lld/wasm/Writer.cpp

1083

Odd indentation here?

[sunfish]

In D135903#3856577, @sbc100 wrote:

Aren't reactors supposed to define an _initialize function that takes care of this?

Yes, but there are two considerations. One, not everyone is calling _initialize today, because in some situations today things work without it, however with the change to make malloc have a constructor, that will change. The other is that I'm anticipating use cases, such as loading a wasm module in JS, where _initialize might not be automatically called, and developers won't know to manually call it.

Perhaps the idea is to make the reactor model work even for users that don't link against crt1_reactor.o?

Yep. It'll be a transition, but that's one of the things this will enable.

In that case could we instead create a default _initialize function here and avoid the wrappers completely?

I don't think we can avoid the wrappers, if there are constructors. The wasm start function is too early for user constructors, because it's limited in what it can do. As I mentioned above, I want to avoid the requirement that _initialize be called explicitly, so wrappers seem like the only option.

One way we eventually can avoid the wrappers is to eliminate all the constructors, such as by writing a malloc which doesn't need them, and making other changes, and encouraging users to avoid static constructors. That is a longer-term goal though.

[sbc100]

In D135903#3856942, @sunfish wrote:

In D135903#3856577, @sbc100 wrote:

Aren't reactors supposed to define an _initialize function that takes care of this?

Yes, but there are two considerations. One, not everyone is calling _initialize today, because in some situations today things work without it, however with the change to make malloc have a constructor, that will change. The other is that I'm anticipating use cases, such as loading a wasm module in JS, where _initialize might not be automatically called, and developers won't know to manually call it.

Perhaps the idea is to make the reactor model work even for users that don't link against crt1_reactor.o?

Yep. It'll be a transition, but that's one of the things this will enable.

In that case could we instead create a default _initialize function here and avoid the wrappers completely?

I don't think we can avoid the wrappers, if there are constructors. The wasm start function is too early for user constructors, because it's limited in what it can do. As I mentioned above, I want to avoid the requirement that _initialize be called explicitly, so wrappers seem like the only option.

One way we eventually can avoid the wrappers is to eliminate all the constructors, such as by writing a malloc which doesn't need them, and making other changes, and encouraging users to avoid static constructors. That is a longer-term goal though.

Sounds reasonable.

However, shouldn't the long term goal be to have all wasi loaders run the _initialize function correctly, as spec'd?

Also, IIUC if _initialize exists and calls __wasm_call_ctors then these wrappers won't be generated (because __wasm_call_ctors will be referenced) .. so this solution doesn't help modules that contain a valid _initialize function. Again it seems like fixing the runtime such that it calls initialize would be better solution here. At least from the perspective of wasi.

What about this solution that I think works even in the face of an correct _initialize function:

1. Is no _initialize function exists, create a synthetic one that just calls __wasm_call_ctors
2. Create a wrapper around _initialize which can detect when it has been run, or not
3. Create wrappers around all the exports that guard against _initialize not being called yet

One problem with this solution is that it adds non-optional overhead to all reactors and even well-behaved runtimes that call _initialize have to then pay that price.. so I guess there should be way to disable it too?

[sunfish]

• Use a memory location instead of a wasm global, and support threads.
• Use llvm-objdump -d in tests.

[sunfish]

• Fix indentation.

[sunfish]

In D135903#3856975, @sbc100 wrote:

However, shouldn't the long term goal be to have all wasi loaders run the _initialize function correctly, as spec'd?

I'll be proposing we drop the _initialize convention altogether. It was never properly standardized, and I now think we're better off without it. One of the nice things about this will be that we don't need wasi-specific loaders for reactors. Given a reactor, we can just load it into any wasm runtime and call functions on it, and it just works. This is how Web-oriented Wasm tends to work—you create a wasm module that exports/imports stuff, and then write JS code that instantiates it and calls it. You don't expect an implicitly-created _initialize function that you have to remember to call first. So dropping the _initialize function will make this kind of reactor-like use case less different from Wasm on the Web.

Also, IIUC if _initialize exists and calls __wasm_call_ctors then these wrappers won't be generated (because __wasm_call_ctors will be referenced) .. so this solution doesn't help modules that contain a valid _initialize function.

Yeah; the next step here will be to change the clang driver to stop passing --entry=_initialize and use --no-entry when linking a reactor, which will stop emitting _initialize and enable the wrappers.

[sbc100]

lso, IIUC if _initialize exists and calls __wasm_call_ctors then these wrappers won't be generated (because __wasm_call_ctors will be referenced) .. so this solution doesn't help modules that contain a valid _initialize function.

Yeah; the next step here will be to change the clang driver to stop passing --entry=_initialize and use --no-entry when linking a reactor, which will stop emitting _initialize and enable the wrappers.

Ok, so if emscripten (or any other toolchain) wants to continue to handle initialization using _start (function name not section name) and/or _initialize then it won't pay the cost of the extra wrappers?

lld/test/wasm/init-fini-gc.ll

+; RUN: llc -filetype=obj -o %t.o %s
+; RUN: wasm-ld %t.o -o %t.wasm
+; RUN: obj2yaml %t.wasm | FileCheck %s
+
+; RUN: wasm-ld --export=__wasm_call_ctors %t.o -o %t.export.wasm
+; RUN: obj2yaml %t.export.wasm | FileCheck %s -check-prefix=EXPORT
+
+; Test that we don't emit wrappers or call __wasm_call_ctor even when not
+; referenced.
+
+target triple = "wasm32-unknown-unknown"
+
+define hidden void @_start() {
+entry:
+  ret void
+}
+
+define hidden void @func1() {
+entry:
+  ret void
+}
+
+define hidden void @func2() {
+entry:
+  ret void
+}
+
+define hidden i32 @__cxa_atexit(i32 %func, i32 %arg, i32 %dso_handle) {
+  ret i32 0
+}
+
[e-mail]_ctors = appending global [1 x { i32, void ()*, i8* }] [
+  { i32, void ()*, i8* } { i32 1, void ()* @func1, i8* null }
+]
+
[e-mail]_dtors = appending global [1 x { i32, void ()*, i8* }] [
+  { i32, void ()*, i8* } { i32 1, void ()* @func2, i8* null }
+]
+
+; Check that we have exactly the needed exports: `memory` because that's
+; currently on by default, and `_start`, because that's the default entrypoint.
+
+; CHECK:       - Type:            EXPORT
+; CHECK-NEXT:    Exports:
+; CHECK-NEXT:      - Name:            memory
+; CHECK-NEXT:        Kind:            MEMORY
+; CHECK-NEXT:        Index:           0
+; CHECK-NEXT:      - Name:            _start
+; CHECK-NEXT:        Kind:            FUNCTION
+; CHECK-NEXT:        Index:           1
+
+; Check the body of `_start`'s command-export wrapper.
+
+; CHECK:       - Type:            CODE
+
+; CHECK:           - Index:           1
+; CHECK-NEXT:        Locals:          []
+; CHECK-NEXT:        Body:            0B
+
+; Check the symbol table to ensure all the functions are here, and that
+; index 7 above refers to the function we think it does.
+
+; CHECK:       - Type:            CUSTOM
+; CHECK-NEXT:    Name:            name
+; CHECK-NEXT:    FunctionNames:
+; CHECK-NEXT:      - Index:           0
+; CHECK-NEXT:        Name:            __wasm_call_ctors
+; CHECK-NEXT:      - Index:           1
+; CHECK-NEXT:        Name:            _start
+; CHECK-NEXT:      - Index:           2
+; CHECK-NEXT:        Name:            func1
+; CHECK-NEXT:      - Index:           3
+; CHECK-NEXT:        Name:            func2
+; CHECK-NEXT:      - Index:           4
+; CHECK-NEXT:        Name:            __cxa_atexit
+; CHECK-NEXT:      - Index:           5
+; CHECK-NEXT:        Name:            .Lcall_dtors.1
+; CHECK-NEXT:      - Index:           6
+; CHECK-NEXT:        Name:            .Lregister_call_dtors.1
+
+; EXPORT: __wasm_call_ctors
+; EXPORT: func1
+; EXPORT: func2
+; EXPORT: __cxa_atexit

lld/test/wasm/init-fini-no-gc.ll

 ; RUN: llc -filetype=obj -o %t.o %s
-; RUN: wasm-ld %t.o -o %t.wasm
+; RUN: wasm-ld --no-entry --export=export_func %t.o -o %t.wasm
+; RUN: llvm-objdump -d --no-show-raw-insn --no-leading-addr %t.wasm | FileCheck --check-prefix=ASM %s --
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
-; RUN: wasm-ld --export=__wasm_call_ctors %t.o -o %t.export.wasm
-; RUN: obj2yaml %t.export.wasm | FileCheck %s -check-prefix=EXPORT
+; RUN: llc -mattr=+atomics,+bulk-memory -filetype=obj -o %t.o %s
+; RUN: wasm-ld --shared-memory --no-entry --export=export_func %t.o -o %t.wasm
+; RUN: llvm-objdump -d --no-show-raw-insn --no-leading-addr %t.wasm | FileCheck --check-prefix=SHARED-ASM %s --
 
-; Test that we emit wrappers and call __wasm_call_ctor when not referenced.
+; Test that we emit wrappers which call __wasm_call_ctor.
 
 target triple = "wasm32-unknown-unknown"
 
-define hidden void @_start() {
+define hidden void @export_func() {
 entry:
   ret void
 }
 
 define hidden void @func1() {
 entry:
   ret void
 }
@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [
   { i32, void ()*, i8* } { i32 1, void ()* @func1, i8* null }
 ]
 
 @llvm.global_dtors = appending global [1 x { i32, void ()*, i8* }] [
   { i32, void ()*, i8* } { i32 1, void ()* @func2, i8* null }
 ]
 
 ; Check that we have exactly the needed exports: `memory` because that's
-; currently on by default, and `_start`, because that's the default entrypoint.
+; currently on by default, and `export_func`, because we asked for it.
 
 ; CHECK:       - Type:            EXPORT
 ; CHECK-NEXT:    Exports:
 ; CHECK-NEXT:      - Name:            memory
 ; CHECK-NEXT:        Kind:            MEMORY
 ; CHECK-NEXT:        Index:           0
-; CHECK-NEXT:      - Name:            _start
+; CHECK-NEXT:      - Name:            export_func
 ; CHECK-NEXT:        Kind:            FUNCTION
 ; CHECK-NEXT:        Index:           7
 
-; Check the body of `_start`'s command-export wrapper.
+; Check the body of `export_func`'s reactor-export wrapper.
 
 ; CHECK:       - Type:            CODE
 
 ; CHECK:           - Index:           7
 ; CHECK-NEXT:        Locals:          []
-; CHECK-NEXT:        Body:            100010010B
+; CHECK-NEXT:        Body:            02404180082802000D00100041800841013602000B10010B
 
 ; Check the symbol table to ensure all the functions are here, and that
 ; index 7 above refers to the function we think it does.
 
 ; CHECK:       - Type:            CUSTOM
 ; CHECK-NEXT:    Name:            name
 ; CHECK-NEXT:    FunctionNames:
 ; CHECK-NEXT:      - Index:           0
 ; CHECK-NEXT:        Name:            __wasm_call_ctors
 ; CHECK-NEXT:      - Index:           1
-; CHECK-NEXT:        Name:            _start
+; CHECK-NEXT:        Name:            export_func
 ; CHECK-NEXT:      - Index:           2
 ; CHECK-NEXT:        Name:            func1
 ; CHECK-NEXT:      - Index:           3
 ; CHECK-NEXT:        Name:            func2
 ; CHECK-NEXT:      - Index:           4
 ; CHECK-NEXT:        Name:            __cxa_atexit
 ; CHECK-NEXT:      - Index:           5
 ; CHECK-NEXT:        Name:            .Lcall_dtors.1
 ; CHECK-NEXT:      - Index:           6
 ; CHECK-NEXT:        Name:            .Lregister_call_dtors.1
 ; CHECK-NEXT:      - Index:           7
-; CHECK-NEXT:        Name:            _start.command_export
+; CHECK-NEXT:        Name:            export_func.reactor_export
 
-; EXPORT: __wasm_call_ctors
-; EXPORT: func1
-; EXPORT: func2
-; EXPORT: __cxa_atexit
+; Check the body of the generated wrapper.
+
+; ASM: <export_func.reactor_export>:
+; ASM-EMPTY:
+; ASM-NEXT:         block
+; ASM-NEXT:         i32.const       1024
+; ASM-NEXT:         i32.load        0
+; ASM-NEXT:         br_if           0                       # 0: down to label1
+; ASM-NEXT:         call    0
+; ASM-NEXT:         i32.const       1024
+; ASM-NEXT:         i32.const       1
+; ASM-NEXT:         i32.store       0
+; ASM-NEXT:         end
+; ASM-NEXT:         call    1
+; ASM-NEXT:         end
+
+; Check the body of the generated wrapper in shared-memory mode.
+
+; SHARED-ASM: <export_func.reactor_export>:
+; SHARED-ASM-EMPTY:
+; SHARED-ASM-NEXT:  block
+; SHARED-ASM-NEXT:  block
+; SHARED-ASM-NEXT:  block
+; SHARED-ASM-NEXT:  i32.const 1024
+; SHARED-ASM-NEXT:  i32.const 0
+; SHARED-ASM-NEXT:  i32.const 1
+; SHARED-ASM-NEXT:  i32.atomic.rmw.cmpxchg 0
+; SHARED-ASM-NEXT:  br_table {0, 1, 2} # 1: down to label2
+; SHARED-ASM-NEXT:  # 2: down to label1
+; SHARED-ASM-NEXT:  end
+; SHARED-ASM-NEXT:  call 0
+; SHARED-ASM-NEXT:  i32.const 1024
+; SHARED-ASM-NEXT:  i32.const 2
+; SHARED-ASM-NEXT:  i32.atomic.store 0
+; SHARED-ASM-NEXT:  i32.const 1024
+; SHARED-ASM-NEXT:  i32.const -1
+; SHARED-ASM-NEXT:  memory.atomic.notify 0
+; SHARED-ASM-NEXT:  drop
+; SHARED-ASM-NEXT:  br 1 # 1: down to label2
+; SHARED-ASM-NEXT:  end
+; SHARED-ASM-NEXT:  i32.const 1024
+; SHARED-ASM-NEXT:  i32.const 1
+; SHARED-ASM-NEXT:  i64.const -1
+; SHARED-ASM-NEXT:  memory.atomic.wait32 0
+; SHARED-ASM-NEXT:  drop
+; SHARED-ASM-NEXT:  end
+; SHARED-ASM-NEXT:  call 1
+; SHARED-ASM-NEXT:  end

lld/test/wasm/reactor-exports-no-tors.s

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
 # RUN: wasm-ld --no-entry %t.o -o %t.wasm
 # RUN: obj2yaml %t.wasm | FileCheck %s
 
-# Like command-exports.s, but with no ctors or dtors, so there should be no
+# Like reactor-exports.s, but with no ctors or dtors, so there should be no
 # __wasm_call_ctors, __cxa_atexit, or wrappers.
 
   .globl  foo_i32
 foo_i32:
   .functype  foo_i32 (i32, i32) -> (i32)
   local.get 0
   local.get 1
   i32.add

lld/test/wasm/reactor-exports.s

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
 # RUN: wasm-ld --no-entry %t.o -o %t.wasm
+# RUN: llvm-objdump -d --no-show-raw-insn --no-leading-addr %t.wasm | FileCheck --check-prefix=ASM %s --
 # RUN: obj2yaml %t.wasm | FileCheck %s
 
-# This test defines a command with two exported functions, as well as a static
+# This test defines a reactor with two exported functions, as well as a static
 # constructor and a static destructor. Check that the exports, constructor, and
 # destructor are all set up properly.
 
   .globl  foo_i32
 foo_i32:
   .functype  foo_i32 (i32, i32) -> (i32)
   local.get 0
   local.get 1

 # CHECK-NEXT:      - Name:            foo_f64
 # CHECK-NEXT:        Kind:            FUNCTION
 # CHECK-NEXT:        Index:           9
 
 # CHECK:       - Type:            CODE
 
 # CHECK:           - Index:           8
 # CHECK-NEXT:        Locals:          []
-# CHECK-NEXT:        Body:            10002000200110010B
+# CHECK-NEXT:        Body:            02404180082802000D00100041800841013602000B2000200110010B
 # CHECK-NEXT:      - Index:           9
 # CHECK-NEXT:        Locals:          []
-# CHECK-NEXT:        Body:            10002000200110020B
+# CHECK-NEXT:        Body:            02404180082802000D00100041800841013602000B2000200110020B
 
 # CHECK:       - Type:            CUSTOM
 # CHECK-NEXT:    Name:            name
 # CHECK-NEXT:    FunctionNames:
 # CHECK-NEXT:      - Index:           0
 # CHECK-NEXT:        Name:            __wasm_call_ctors
 # CHECK-NEXT:      - Index:           1
 # CHECK-NEXT:        Name:            foo_i32
 # CHECK-NEXT:      - Index:           2
 # CHECK-NEXT:        Name:            foo_f64
 # CHECK-NEXT:      - Index:           3
 # CHECK-NEXT:        Name:            some_ctor
 # CHECK-NEXT:      - Index:           4
 # CHECK-NEXT:        Name:            some_dtor
 # CHECK-NEXT:      - Index:           5
 # CHECK-NEXT:        Name:            __cxa_atexit
 # CHECK-NEXT:      - Index:           6
 # CHECK-NEXT:        Name:            .Lcall_dtors.1
 # CHECK-NEXT:      - Index:           7
 # CHECK-NEXT:        Name:            .Lregister_call_dtors.1
 # CHECK-NEXT:      - Index:           8
-# CHECK-NEXT:        Name:            foo_i32.command_export
+# CHECK-NEXT:        Name:            foo_i32.reactor_export
 # CHECK-NEXT:      - Index:           9
-# CHECK-NEXT:        Name:            foo_f64.command_export
+# CHECK-NEXT:        Name:            foo_f64.reactor_export
+
+# Check the body of the generated wrapper.
+
+# ASM: <foo_i32.reactor_export>:
+# ASM-EMPTY:
+# ASM-NEXT:         block
+# ASM-NEXT:         i32.const       1024
+# ASM-NEXT:         i32.load        0
+# ASM-NEXT:         br_if           0                       # 0: down to label1
+# ASM-NEXT:         call    0
+# ASM-NEXT:         i32.const       1024
+# ASM-NEXT:         i32.const       1
+# ASM-NEXT:         i32.store       0
+# ASM-NEXT:         end
+# ASM-NEXT:         local.get 0
+# ASM-NEXT:         local.get 1
+# ASM-NEXT:         call    1
+# ASM-NEXT:         end
+
+# ASM: <foo_f64.reactor_export>:
+# ASM-EMPTY:
+# ASM-NEXT:         block
+# ASM-NEXT:         i32.const       1024
+# ASM-NEXT:         i32.load        0
+# ASM-NEXT:         br_if           0                       # 0: down to label2
+# ASM-NEXT:         call    0
+# ASM-NEXT:         i32.const       1024
+# ASM-NEXT:         i32.const       1
+# ASM-NEXT:         i32.store       0
+# ASM-NEXT:         end
+# ASM-NEXT:         local.get 0
+# ASM-NEXT:         local.get 1
+# ASM-NEXT:         call    2
+# ASM-NEXT:         end

lld/wasm/Symbols.h

struct WasmSym {
   static GlobalSymbol *tlsSize;
 
   // __tls_size
   // Symbol whose value is the alignment of the TLS block.
   static GlobalSymbol *tlsAlign;
 
   // __data_end
   // Symbol marking the end of the data and bss.
   static DefinedData *dataEnd;
 
   // __heap_base
   // Symbol marking the end of the data, bss and explicit stack.  Any linear
   // memory following this address is not used by the linked code and can
   // therefore be used as a backing store for brk()/malloc() implementations.
   static DefinedData *heapBase;
 
   // __wasm_init_memory_flag
   // Symbol whose contents are nonzero iff memory has already been initialized.
   static DefinedData *initMemoryFlag;
 
+  // __ctors_done
+  // Symbol whose value is non-zero if the global ctors have been called.
+  static DefinedData *ctorsDone;
+
   // __wasm_init_memory
   // Function that initializes passive data segments during instantiation.
   static DefinedFunction *initMemory;
 
   // __wasm_call_ctors
   // Function that directly calls all ctors in priority order.
   static DefinedFunction *callCtors;
 

lld/wasm/Symbols.cpp

 DefinedFunction *WasmSym::applyGlobalTLSRelocs;
 DefinedFunction *WasmSym::initTLS;
 DefinedFunction *WasmSym::startFunction;
 DefinedData *WasmSym::dsoHandle;
 DefinedData *WasmSym::dataEnd;
 DefinedData *WasmSym::globalBase;
 DefinedData *WasmSym::heapBase;
 DefinedData *WasmSym::initMemoryFlag;
+DefinedData *WasmSym::ctorsDone;
 GlobalSymbol *WasmSym::stackPointer;
 GlobalSymbol *WasmSym::tlsBase;
 GlobalSymbol *WasmSym::tlsSize;
 GlobalSymbol *WasmSym::tlsAlign;
 UndefinedGlobal *WasmSym::tableBase;
 DefinedData *WasmSym::definedTableBase;
 UndefinedGlobal *WasmSym::tableBase32;
 DefinedData *WasmSym::definedTableBase32;

lld/wasm/Writer.cpp

private:
   void createSyntheticInitFunctions();
   void createInitMemoryFunction();
   void createStartFunction();
   void createApplyDataRelocationsFunction();
   void createApplyGlobalRelocationsFunction();
   void createApplyGlobalTLSRelocationsFunction();
   void createCallCtorsFunction();
   void createInitTLSFunction();
-  void createCommandExportWrappers();
-  void createCommandExportWrapper(uint32_t functionIndex, DefinedFunction *f);
+  void createReactorExportWrappers();
+  void createReactorExportWrapper(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
private:
   void writeHeader();
   void writeSections();
 
   uint64_t fileSize = 0;
 
   std::vector<WasmInitEntry> initFunctions;
   llvm::StringMap<std::vector<InputChunk *>> customSectionMapping;
 
-  // Stable storage for command export wrapper function name strings.
-  std::list<std::string> commandExportWrapperNames;
+  // Stable storage for reactor export wrapper function name strings.
+  std::list<std::string> reactorExportWrapperNames;
 
   // Elements that are used to construct the final output
   std::string header;
   std::vector<OutputSection *> outputSections;
 
   std::unique_ptr<FileOutputBuffer> buffer;
 
   std::vector<OutputSegment *> segments;
WasmSym::initMemoryFlag = symtab->addSyntheticDataSymbol(
         "__wasm_init_memory_flag", WASM_SYMBOL_VISIBILITY_HIDDEN);
     WasmSym::initMemoryFlag->markLive();
     WasmSym::initMemoryFlag->setVA(memoryPtr);
     log(formatv("mem: {0,-15} offset={1,-8} size={2,-8} align={3}",
                 "__wasm_init_memory_flag", memoryPtr, 4, 4));
     memoryPtr += 4;
   }
 
+  // If we need a `__ctors_done` flag, create one.
+  if (!config->relocatable && !config->isPic && config->entry.empty() &&
+      !WasmSym::callCtors->isUsedInRegularObj &&
+      !WasmSym::callCtors->isExported()) {
+    bool needCtorsDone = false;
+    for (ObjFile *file : symtab->objectFiles) {
+      const WasmLinkingData &l = file->getWasmObj()->linkingData();
+      for (const WasmInitFunc &f : l.InitFunctions) {
+        FunctionSymbol *sym = file->getFunctionSymbol(f.Symbol);
+        // comdat exclusions can cause init functions be discarded.
+        if (sym->isDiscarded() || !sym->isLive())
+          continue;
+        needCtorsDone = true;
+        break;
+      }
+    }
+    if (needCtorsDone) {
+      memoryPtr = alignTo(memoryPtr, 4);
+      WasmSym::ctorsDone = symtab->addSyntheticDataSymbol(
+          "__ctors_done", WASM_SYMBOL_VISIBILITY_HIDDEN);
+      WasmSym::ctorsDone->markLive();
+      WasmSym::ctorsDone->setVA(memoryPtr);
+      log(formatv("mem: {0,-15} offset={1,-8} size={2,-8} align={3}",
+                  "__ctors_done", memoryPtr, 4, 4));
+      memoryPtr += 4;
+    }
+  }
+
   if (WasmSym::dataEnd)
     WasmSym::dataEnd->setVA(memoryPtr);
 
   uint64_t staticDataSize = memoryPtr - dataStart;
   log("mem: static data = " + Twine(staticDataSize));
   if (config->isPic)
     out.dylinkSec->memSize = staticDataSize;
 
void Writer::calculateTypes() {
 
   for (const InputFunction *f : out.functionSec->inputFunctions)
     out.typeSec->registerType(f->signature);
 
   for (const InputTag *t : out.tagSec->inputTags)
     out.typeSec->registerType(t->signature);
 }
 
-// In a command-style link, create a wrapper for each exported symbol
+// In a reactor-style link, create a wrapper for each exported symbol
 // which calls the constructors and destructors.
-void Writer::createCommandExportWrappers() {
+void Writer::createReactorExportWrappers() {
   // This logic doesn't currently support Emscripten-style PIC mode.
   assert(!config->isPic);
 
-  // If there are no ctors and there's no libc `__wasm_call_dtors` to
-  // call, don't wrap the exports.
-  if (initFunctions.empty() && WasmSym::callDtors == nullptr)
+  // If there are no ctors, don't wrap the exports.
+  if (initFunctions.empty())
     return;
 
   std::vector<DefinedFunction *> toWrap;
 
   for (Symbol *sym : symtab->symbols())
     if (sym->isExported())
       if (auto *f = dyn_cast<DefinedFunction>(sym))
         toWrap.push_back(f);
 
   for (auto *f : toWrap) {
-    auto funcNameStr = (f->getName() + ".command_export").str();
-    commandExportWrapperNames.push_back(funcNameStr);
-    const std::string &funcName = commandExportWrapperNames.back();
+    auto funcNameStr = (f->getName() + ".reactor_export").str();
+    reactorExportWrapperNames.push_back(funcNameStr);
+    const std::string &funcName = reactorExportWrapperNames.back();
 
     auto func = make<SyntheticFunction>(*f->getSignature(), funcName);
     if (f->function->getExportName())
       func->setExportName(f->function->getExportName()->str());
     else
       func->setExportName(f->getName().str());
 
     DefinedFunction *def =
         symtab->addSyntheticFunction(funcName, f->flags, func);
     def->markLive();
 
     def->flags |= WASM_SYMBOL_EXPORTED;
     def->flags &= ~WASM_SYMBOL_VISIBILITY_HIDDEN;
     def->forceExport = f->forceExport;
 
     f->flags |= WASM_SYMBOL_VISIBILITY_HIDDEN;
     f->flags &= ~WASM_SYMBOL_EXPORTED;
     f->forceExport = false;
 
     out.functionSec->addFunction(func);
 
-    createCommandExportWrapper(f->getFunctionIndex(), def);
+    createReactorExportWrapper(f->getFunctionIndex(), def);
   }
 }
 
 static void finalizeIndirectFunctionTable() {
   if (!WasmSym::indirectFunctionTable)
     return;
 
   if (shouldImport(WasmSym::indirectFunctionTable) &&
void Writer::createInitMemoryFunction() {
   uint64_t flagAddress;
   if (config->sharedMemory) {
     assert(WasmSym::initMemoryFlag);
     flagAddress = WasmSym::initMemoryFlag->getVA();
   }
   bool is64 = config->is64.value_or(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,
     // 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:
std::string bodyContent;
     writeU8(os, WASM_OPCODE_END, "END");
   }
 
   createFunction(WasmSym::callCtors, bodyContent);
 }
 
 // Create a wrapper around a function export which calls the
 // static constructors and destructors.
-void Writer::createCommandExportWrapper(uint32_t functionIndex,
+void Writer::createReactorExportWrapper(uint32_t functionIndex,
                                         DefinedFunction *f) {
   // First write the body's contents to a string.
   std::string bodyContent;
   {
     raw_string_ostream os(bodyContent);
     writeUleb128(os, 0, "num locals");
 
     // Call `__wasm_call_ctors` which call static constructors (and
     // applies any runtime relocations in Emscripten-style PIC mode)
     if (WasmSym::callCtors->isLive()) {
+      bool is64 = config->is64.value_or(false);
+      uint64_t flagAddress = WasmSym::ctorsDone->getVA();
+      if (config->sharedMemory) {
+        // Set up destination blocks
+        writeU8(os, WASM_OPCODE_BLOCK, "block $done");
+        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.
+        writePtrConst(os, flagAddress, is64, "flag address");
+        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 $done");
+
+        writeU8(os, WASM_OPCODE_END, "end $init");
+      } else {
+        writeU8(os, WASM_OPCODE_BLOCK, "BLOCK");
+        writeU8(os, WASM_TYPE_NORESULT, "no result");
+
+        // If `__ctors_done` is true, skip the rest of the code here.
+        writePtrConst(os, flagAddress, is64, "flag address");
+        writeU8(os, WASM_OPCODE_I32_LOAD, "LOAD");
+        writeMemArg(os, 2, 0);
+        writeU8(os, WASM_OPCODE_BR_IF, "BR_IF");
+        writeUleb128(os, 0, "BR_IF immediate");
+      }
+
+      // Call `__wasm_call_ctors`.
       writeU8(os, WASM_OPCODE_CALL, "CALL");
       writeUleb128(os, WasmSym::callCtors->getFunctionIndex(),
-                   "function index");
+
+      if (config->sharedMemory) {
+        // Set flag to 2 to mark end of initialization
+        writePtrConst(os, flagAddress, is64, "flag address");
+        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
+        writePtrConst(os, flagAddress, is64, "flag address");
+        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 the done label
+        writeU8(os, WASM_OPCODE_BR, "br");
+        writeUleb128(os, 1, "label $done");
+
+        writeU8(os, WASM_OPCODE_END, "end $wait");
+
+        // Wait for the winning thread to initialize memory
+        writePtrConst(os, flagAddress, is64, "flag address");
+        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_END, "end $done");
+      } else {
+        // Set `__ctors_done` to true.
+        writePtrConst(os, flagAddress, is64, "flag address");
+        writeI32Const(os, 1, "new flag value");
+        writeU8(os, WASM_OPCODE_I32_STORE, "STORE");
+        writeMemArg(os, 2, 0);
+
+        writeU8(os, WASM_OPCODE_END, "END");
+      }
     }
 
     // Call the user's code, leaving any return values on the operand stack.
     for (size_t i = 0; i < f->signature->Params.size(); ++i) {
       writeU8(os, WASM_OPCODE_LOCAL_GET, "local.get");
       writeUleb128(os, i, "local index");
     }
     writeU8(os, WASM_OPCODE_CALL, "CALL");
if (!config->relocatable) {
     if (WasmSym::applyGlobalTLSRelocs)
       createApplyGlobalTLSRelocationsFunction();
     if (WasmSym::initMemory)
       createInitMemoryFunction();
     createStartFunction();
 
     createCallCtorsFunction();
 
-    // Create export wrappers for commands if needed.
+    // Create export wrappers for reactors if needed.
     //
     // If the input contains a call to `__wasm_call_ctors`, either in one of
     // the input objects or an explicit export from the command-line, we
     // assume ctors and dtors are taken care of already.
-    if (!config->relocatable && !config->isPic &&
+    if (!config->isPic && config->entry.empty() &&
         !WasmSym::callCtors->isUsedInRegularObj &&
         !WasmSym::callCtors->isExported()) {
-      log("-- createCommandExportWrappers");
-      createCommandExportWrappers();
+      log("-- createReactorExportWrappers");
+      createReactorExportWrappers();
     }
   }
 
   if (WasmSym::initTLS && WasmSym::initTLS->isLive()) {
     log("-- createInitTLSFunction");
     createInitTLSFunction();
   }
 

llvm/include/llvm/BinaryFormat/Wasm.h

 enum : unsigned {
   WASM_OPCODE_END = 0x0b,
   WASM_OPCODE_CALL = 0x10,
   WASM_OPCODE_LOCAL_GET = 0x20,
   WASM_OPCODE_LOCAL_SET = 0x21,
   WASM_OPCODE_LOCAL_TEE = 0x22,
   WASM_OPCODE_GLOBAL_GET = 0x23,
   WASM_OPCODE_GLOBAL_SET = 0x24,
+  WASM_OPCODE_I32_LOAD = 0x28,
   WASM_OPCODE_I32_STORE = 0x36,
   WASM_OPCODE_I64_STORE = 0x37,
   WASM_OPCODE_I32_CONST = 0x41,
   WASM_OPCODE_I64_CONST = 0x42,
   WASM_OPCODE_F32_CONST = 0x43,
   WASM_OPCODE_F64_CONST = 0x44,
+  WASM_OPCODE_I32_EQZ = 0x45,
   WASM_OPCODE_I32_ADD = 0x6a,
   WASM_OPCODE_I32_SUB = 0x6b,
   WASM_OPCODE_I32_MUL = 0x6c,
   WASM_OPCODE_I64_ADD = 0x7c,
   WASM_OPCODE_I64_SUB = 0x7d,
   WASM_OPCODE_I64_MUL = 0x7e,
   WASM_OPCODE_REF_NULL = 0xd0,
 };
 
 // Opcodes used in synthetic functions.
 enum : unsigned {
   WASM_OPCODE_BLOCK = 0x02,
   WASM_OPCODE_BR = 0x0c,
+  WASM_OPCODE_BR_IF = 0x0d,
   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,