[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

54

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

86–89

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

1055

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: 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 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:            024023010D001000410124010B10010B
 
 ; 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
-
-; EXPORT: __wasm_call_ctors
-; EXPORT: func1
-; EXPORT: func2
-; EXPORT: __cxa_atexit
+; CHECK-NEXT:        Name:            export_func.reactor_export

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: 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:            024023010D001000410124010B2000200110010B
 # CHECK-NEXT:      - Index:           9
 # CHECK-NEXT:        Locals:          []
-# CHECK-NEXT:        Body:            10002000200110020B
+# CHECK-NEXT:        Body:            024023010D001000410124010B2000200110020B
 
 # 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

lld/wasm/Symbols.h

struct WasmSym {
   // __tls_size
   // Symbol whose value is the size of the TLS block.
   static GlobalSymbol *tlsSize;
 
   // __tls_size
   // Symbol whose value is the alignment of the TLS block.
   static GlobalSymbol *tlsAlign;
 
+  // __ctors_done
+  // Symbol whose value is non-zero if the global ctors have been called.
+  static GlobalSymbol *ctorsDone;
+
   // __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.

lld/wasm/Symbols.cpp

 DefinedData *WasmSym::dataEnd;
 DefinedData *WasmSym::globalBase;
 DefinedData *WasmSym::heapBase;
 DefinedData *WasmSym::initMemoryFlag;
 GlobalSymbol *WasmSym::stackPointer;
 GlobalSymbol *WasmSym::tlsBase;
 GlobalSymbol *WasmSym::tlsSize;
 GlobalSymbol *WasmSym::tlsAlign;
+GlobalSymbol *WasmSym::ctorsDone;
 UndefinedGlobal *WasmSym::tableBase;
 DefinedData *WasmSym::definedTableBase;
 UndefinedGlobal *WasmSym::tableBase32;
 DefinedData *WasmSym::definedTableBase32;
 UndefinedGlobal *WasmSym::memoryBase;
 DefinedData *WasmSym::definedMemoryBase;
 TableSymbol *WasmSym::indirectFunctionTable;
 

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;
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::createSyntheticInitFunctions() {
   // itself as the Wasm start function, otherwise we need to synthesize
   // a new function to call them in sequence.
   if (WasmSym::applyGlobalRelocs && WasmSym::initMemory) {
     WasmSym::startFunction = symtab->addSyntheticFunction(
         "__wasm_start", WASM_SYMBOL_VISIBILITY_HIDDEN,
         make<SyntheticFunction>(nullSignature, "__wasm_start"));
     WasmSym::startFunction->markLive();
   }
+
+  // If we need a `__ctors_done` global, 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) {
+      llvm::wasm::WasmGlobal wasmGlobal;
+      bool is64 = config->is64.value_or(false);
+      wasmGlobal.Type = {uint8_t(is64 ? WASM_TYPE_I64 : WASM_TYPE_I32), true};
+      wasmGlobal.InitExpr = intConst(0, is64);
+      wasmGlobal.SymbolName = "__ctors_done";
+      InputGlobal *g = make<InputGlobal>(wasmGlobal, nullptr);
+      WasmSym::ctorsDone = symtab->addSyntheticGlobal("__ctors_done", WASM_SYMBOL_VISIBILITY_HIDDEN, g);
+      WasmSym::ctorsDone->markLive();
+    }
+  }
 }
 
 void Writer::createInitMemoryFunction() {
   LLVM_DEBUG(dbgs() << "createInitMemoryFunction\n");
   assert(WasmSym::initMemory);
   assert(hasPassiveInitializedSegments());
   uint64_t flagAddress;
   if (config->sharedMemory) {
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()) {
+      WasmSym::ctorsDone->markLive();
+
+      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.
+      writeU8(os, WASM_OPCODE_GLOBAL_GET, "GLOBAL_GET");
+      writeUleb128(os, WasmSym::ctorsDone->getGlobalIndex(), "flag (global index)");
+      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");
+
+      // Set `__ctors_done` to true.
+      writeI32Const(os, 1, "new flag value");
+      writeU8(os, WASM_OPCODE_GLOBAL_SET, "GLOBAL_SET");
+      writeUleb128(os, WasmSym::ctorsDone->getGlobalIndex(), "flag (global index)");
+
+      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_GLOBAL_GET = 0x23,
   WASM_OPCODE_GLOBAL_SET = 0x24,
   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,