[WebAssembly] New-style command support

[sunfish]

Summary

This adds support for new-style command support. In this mode, all exports
are considered command entrypoints, and the linker inserts calls to
__wasm_call_ctors and __wasm_call_dtors for all such entrypoints.

This enables support for:

• Command entrypoints taking arguments other than strings and return values other than int.
• Multicall executables without requiring on the use of string-based command-line arguments.

This new behavior is disabled when the input has an explicit call to
__wasm_call_ctors, indicating code not expecting new-style command
support.

This change does mean that wasm-ld no longer supports DCE-ing the
__wasm_call_ctors function when there are no calls to it. If there are no
calls to it, and there are ctors present, we assume it's wasm-ld's job to
insert the calls. This seems ok though, because if there are ctors present,
the program is expecting them to be called. This change affects the
init-fini-gc.ll test.

[sunfish]

Use the return value of handleUndefined instead of doing a separate lookup, which avoids a redundant lookup and handles LazySymbols properly.

[sunfish]

Run clang-format and fix lint warnings.

[sbc100]

Interesting direction! I'm only skimmed it for now. Not strongly opposed to this direction although it makes me sad to see more codegen/magic in the linker.

lld/wasm/Driver.cpp

475

Can we make this a separate change? Its seems pretty distinct.

lld/wasm/MarkLive.cpp

76

Is this just a de-duplication with the code below? It is related to this change to independent?

lld/wasm/Writer.cpp

1159

Can you replace these 2 lines with WasmSym::callCtors->isExported() ?

[sunfish]

• Address review feedback
• Mark callCtors live in the MarkLive pass rather than in the Writer pass.

[sunfish]

lld/wasm/Driver.cpp

475

Ok, I've removed it, and I'll submit it in a separate patch.

lld/wasm/MarkLive.cpp

76

I guess it is deduplication and possibly separable, but it's closely related to the rest of the patch.

Previously, when the input didn't have a __wasm_call_ctors call, we'd treat the init functions as dead code and delete them. With this patch, when the input doesn't have a __wasm_call_ctors call, we assume it's wasm-ld's job to insert __wasm_call_ctors calls. So it no longer makes sense to say "if __wasm_call_ctors is live then the init functions are live". The init functions are now just always live.

lld/wasm/Writer.cpp

1159

Done.

[sbc100]

lld/test/wasm/command-exports-no-tors.ll

5

no-tors.ll -> no-ctors.ll?

Also, I've been converting existing tests over to the .s format. For an example of this see ctor_return_value.s. If possible, I'd prefer to add .s tests only going forward .

lld/test/wasm/command-exports.ll

2

Ditto .s if possible.

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

8

I guess we should rename this test...?

27

Why this?

72

What do we actually want to test for here?

lld/wasm/Writer.cpp

624

config->isPic is already checked at the call site.

[sbc100]

Description needs updating after --emscripten was split out.

[sbc100]

lld/wasm/Writer.cpp

946

The comment say *or* but the code says "&&".

Can this part just be reverted? Since callCtors should not be live unless its needed.

[sunfish]

Address review feedback.

lld/test/wasm/command-exports-no-tors.ll

5

no-tors.ll has no ctors *or* dtors. I've now converted these to .s tests.

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

8

Renamed.

27

That's how __cxa_atexit will typically be defined. And we don't want it being exported to prevent GC, which might defeat the purpose of the test.

72

I've now added comments to these CHECK lines.

lld/wasm/Writer.cpp

624

I've now changed it to an assert.

[sunfish]

Friendly ping!

[sbc100]

The description needs updating to reflect the fact that this change no longer adds the --emscripten flag.

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

8 ↗

(On Diff #282304)

You can remove the .section directives for all functions I believe to make the tests most concise.

10 ↗

(On Diff #282304)

And these explicit .type entries for functions. (the .functype on its own below I think is enough).

18 ↗

(On Diff #282304)

And these two lines can go too.

lld/test/wasm/command-exports.s

94 ↗

(On Diff #282304)

No need for __dso_handle here or above.

[sunfish]

Thanks! Description updated, fixes applied, and landed in https://reviews.llvm.org/rG6cd8511e5932

[realuptime]

Hey, this new behaviour broke existing functionality!

I can still see this a workaround by making a call to __wasm_call_ctors.
Be sure that people are notified when such functionality change!

Calling by default C++ static constructors and functions (static int x = somefunc()) for each "export" entry point is a very very bad idea!!!
I had to compile with -fno-c++-static-destructors first and then refactor my code.
Or use no_destroy flag(https://clang.llvm.org/docs/AttributeReference.html#no-destroy).
For example, on the project that I am working on I am calling a function(export.NeedsDisplay()) for each rendered frame, which could be 1000 times per second without VSYNC!

The project:
http://myapp.eu/wasi/

Here is my GitHub issue, which is closed now after spending two days finding the cause!
https://github.com/WebAssembly/WASI/issues/471

[yamt]

there are use cases for a command to export non-main functions.
eg. malloc/free stuff mentioned in https://github.com/bytecodealliance/wasm-micro-runtime/blob/main/doc/memory_tune.md
this change broke them.
for my very specific case it can be worked around eg. by "-mexec-model=reactor -emain". but i feel it isn't a right thing to do.

[sbc100]

In D81689#3611504, @yamt wrote:

there are use cases for a command to export non-main functions.
eg. malloc/free stuff mentioned in https://github.com/bytecodealliance/wasm-micro-runtime/blob/main/doc/memory_tune.md
this change broke them.
for my very specific case it can be worked around eg. by "-mexec-model=reactor -emain". but i feel it isn't a right thing to do.

I believe the correct fix is to reference __wasm_call_ctors() somewhere, either by calling it or by exporting. A common way to do this is to have a _start function that calls __wasm_call_ctors and then main.

[sunfish]

In D81689#3612529, @sbc100 wrote:

In D81689#3611504, @yamt wrote:

there are use cases for a command to export non-main functions.
eg. malloc/free stuff mentioned in https://github.com/bytecodealliance/wasm-micro-runtime/blob/main/doc/memory_tune.md
this change broke them.

One consideration is that that wamr API doesn't seem compatible with closest thing we have to a spec, which states "Command instances may assume that they will be called from the environment at most once. Command instances may assume that none of their exports are accessed outside the duration of that call.". It's debatable how authoritative that spec is, but the big picture is that there's not currently much clarity on the relationship between LLVM and engines.

for my very specific case it can be worked around eg. by "-mexec-model=reactor -emain". but i feel it isn't a right thing to do.

It's difficult to talk about the "right thing to do" in the short term. I'm giving a presentation at the upcoming WASI meeting about "WASI Preview2", which is a plan for a major new successor to the current wasi_snapshot_preview1 API, which will include a new clear definition of "commands", which I expect will be our best chance at fixing these issues.

I believe the correct fix is to reference __wasm_call_ctors() somewhere, either by calling it or by exporting. A common way to do this is to have a _start function that calls __wasm_call_ctors and then main.

This may work for now, but note that it isn't a documented workaround, and we may break it in future LLVM releases.

[yamt]

In D81689#3613499, @sunfish wrote:

In D81689#3612529, @sbc100 wrote:

In D81689#3611504, @yamt wrote:

there are use cases for a command to export non-main functions.
eg. malloc/free stuff mentioned in https://github.com/bytecodealliance/wasm-micro-runtime/blob/main/doc/memory_tune.md
this change broke them.

One consideration is that that wamr API doesn't seem compatible with closest thing we have to a spec, which states "Command instances may assume that they will be called from the environment at most once. Command instances may assume that none of their exports are accessed outside the duration of that call.". It's debatable how authoritative that spec is, but the big picture is that there's not currently much clarity on the relationship between LLVM and engines.

• if "outside the duration of that call" mean it's ok to access exports during the call of _start, the wamr api seems compatible to me. (those malloc/free exports are used during the execution of _start, as far as i understand.)

• does the "command" concept implies wasi?

• i feel it's simpler to have two types of --export (eg. a new cli option to specify extra entry points), rather than flipping the semantics of all --export with a global command/reactor switch.

for my very specific case it can be worked around eg. by "-mexec-model=reactor -emain". but i feel it isn't a right thing to do.

It's difficult to talk about the "right thing to do" in the short term. I'm giving a presentation at the upcoming WASI meeting about "WASI Preview2", which is a plan for a major new successor to the current wasi_snapshot_preview1 API, which will include a new clear definition of "commands", which I expect will be our best chance at fixing these issues.

unfortunately the meeting is at midnight for me.

[sunfish]

In D81689#3614033, @yamt wrote:

In D81689#3613499, @sunfish wrote:

In D81689#3612529, @sbc100 wrote:

In D81689#3611504, @yamt wrote:

there are use cases for a command to export non-main functions.
eg. malloc/free stuff mentioned in https://github.com/bytecodealliance/wasm-micro-runtime/blob/main/doc/memory_tune.md
this change broke them.

One consideration is that that wamr API doesn't seem compatible with closest thing we have to a spec, which states "Command instances may assume that they will be called from the environment at most once. Command instances may assume that none of their exports are accessed outside the duration of that call.". It's debatable how authoritative that spec is, but the big picture is that there's not currently much clarity on the relationship between LLVM and engines.

• if "outside the duration of that call" mean it's ok to access exports during the call of _start, the wamr api seems compatible to me. (those malloc/free exports are used during the execution of _start, as far as i understand.)

I'm referring to the "will be called from the environment at most once" part.
If I understand correctly, these malloc/free exports are used to make
additional calls into the instance.

• does the "command" concept implies wasi?

That's a complex question :-). The concept of a "command" isn't in core
WebAssembly, at least. Consequently, it needs to be defined in some other
standards layer. At the moment, WASI has a definition for its own use.

It looks like the component model will provide a definition soon, with the
canonical ABI defining how a "command" looks in core WebAssembly, and with
WASI Preview2 I'm planning to propose WASI switch to that.

• i feel it's simpler to have two types of --export (eg. a new cli option to specify extra entry points), rather than flipping the semantics of all --export with a global command/reactor switch.

I don't currently have a clear view of what functionality LLVM should support,
and am reluctant to add more compatibility surface area until we have more
clarity about this.

for my very specific case it can be worked around eg. by "-mexec-model=reactor -emain". but i feel it isn't a right thing to do.

It's difficult to talk about the "right thing to do" in the short term. I'm giving a presentation at the upcoming WASI meeting about "WASI Preview2", which is a plan for a major new successor to the current wasi_snapshot_preview1 API, which will include a new clear definition of "commands", which I expect will be our best chance at fixing these issues.

unfortunately the meeting is at midnight for me.

I'll post the slides in the meeting notes, and I'll be following up with
documentation and standards proposals.

[yamt]

In D81689#3619437, @sunfish wrote:

In D81689#3614033, @yamt wrote:

In D81689#3613499, @sunfish wrote:

In D81689#3612529, @sbc100 wrote:

In D81689#3611504, @yamt wrote:

there are use cases for a command to export non-main functions.
eg. malloc/free stuff mentioned in https://github.com/bytecodealliance/wasm-micro-runtime/blob/main/doc/memory_tune.md
this change broke them.

One consideration is that that wamr API doesn't seem compatible with closest thing we have to a spec, which states "Command instances may assume that they will be called from the environment at most once. Command instances may assume that none of their exports are accessed outside the duration of that call.". It's debatable how authoritative that spec is, but the big picture is that there's not currently much clarity on the relationship between LLVM and engines.

• if "outside the duration of that call" mean it's ok to access exports during the call of _start, the wamr api seems compatible to me. (those malloc/free exports are used during the execution of _start, as far as i understand.)

I'm referring to the "will be called from the environment at most once" part.
If I understand correctly, these malloc/free exports are used to make
additional calls into the instance.

the sentence made me think it was only about the entry point of the command. (_start)
what's "called" here is "command instances", not exported functions, isn't it?

a related question:
does it mean to prevent any callback-style apis?
i have a system in which the embedder provides C-callback style api to modules.
it's via C function pointers (func table indexes), not via exports, though.

• does the "command" concept implies wasi?

That's a complex question :-). The concept of a "command" isn't in core
WebAssembly, at least. Consequently, it needs to be defined in some other
standards layer. At the moment, WASI has a definition for its own use.

It looks like the component model will provide a definition soon, with the
canonical ABI defining how a "command" looks in core WebAssembly, and with
WASI Preview2 I'm planning to propose WASI switch to that.

ok. thank you for explanation.

• i feel it's simpler to have two types of --export (eg. a new cli option to specify extra entry points), rather than flipping the semantics of all --export with a global command/reactor switch.

I don't currently have a clear view of what functionality LLVM should support,
and am reluctant to add more compatibility surface area until we have more
clarity about this

i agree it isn't the best moment to make changes.

my point is that some of exports are entry points of the command and the others are not.

for my very specific case it can be worked around eg. by "-mexec-model=reactor -emain". but i feel it isn't a right thing to do.

It's difficult to talk about the "right thing to do" in the short term. I'm giving a presentation at the upcoming WASI meeting about "WASI Preview2", which is a plan for a major new successor to the current wasi_snapshot_preview1 API, which will include a new clear definition of "commands", which I expect will be our best chance at fixing these issues.

unfortunately the meeting is at midnight for me.

I'll post the slides in the meeting notes, and I'll be following up with
documentation and standards proposals.

ok. thank you.

[sbc100]

IIUC, with commands you can call back into the module, but only while the command entry point (_start) is running. i.e. while _start is running it can call out, and you can callback in as much as you want.

Once _start returns the instance is no longer in a valid state and can no longer called into (for example it would not be valid to call malloc after _start returns since the heap data structures may have been torn down).

If you want to call into a module after _start returns (and have the state preserved between calls) then what you want is a reactor and you should use _initialize rather than _start.

[yamt]

In D81689#3621510, @sbc100 wrote:

IIUC, with commands you can call back into the module, but only while the command entry point (_start) is running. i.e. while _start is running it can call out, and you can callback in as much as you want.

Once _start returns the instance is no longer in a valid state and can no longer called into (for example it would not be valid to call malloc after _start returns since the heap data structures may have been torn down).

If you want to call into a module after _start returns (and have the state preserved between calls) then what you want is a reactor and you should use _initialize rather than _start.

sure.
but i'm not sure how it's related to this change.

in the wamr malloc/free use case mentioned above, these exports are used while _start is running as far as i know.

[yamt]

for my very specific case it can be worked around eg. by "-mexec-model=reactor -emain". but i feel it isn't a right thing to do.

It's difficult to talk about the "right thing to do" in the short term. I'm giving a presentation at the upcoming WASI meeting about "WASI Preview2", which is a plan for a major new successor to the current wasi_snapshot_preview1 API, which will include a new clear definition of "commands", which I expect will be our best chance at fixing these issues.

unfortunately the meeting is at midnight for me.

I'll post the slides in the meeting notes, and I'll be following up with
documentation and standards proposals.

https://github.com/WebAssembly/meetings/blob/main/wasi/2022/WASI-06-30.md

lld/test/wasm/command-exports-no-tors.ll

+; RUN: llc -filetype=obj -o %t.o %s
+; RUN: wasm-ld --no-entry %t.o -o %t.wasm
+; RUN: obj2yaml %t.wasm | FileCheck %s
+
+; Like command-exports.ll, but with no ctors or dtors, so there should be no
+; __wasm_call_ctors, __cxa_atexit, or wrappers.
+
+target triple = "wasm32-unknown-unknown"
+
+define i32 @foo_i32(i32 %a, i32 %b) #0 {
+entry:
+  %c = add i32 %a, %b
+  ret i32 %c
+}
+
+define double @foo_f64(double %a, double %b) #1 {
+entry:
+  %c = fadd double %a, %b
+  ret double %c
+}
+
+attributes #0 = { "wasm-export-name"="foo_i32" }
+
+attributes #1 = { "wasm-export-name"="foo_f64" }
+
+; CHECK:       - Type:            EXPORT
+; CHECK-NEXT:    Exports:
+; CHECK-NEXT:      - Name:            memory
+; CHECK-NEXT:        Kind:            MEMORY
+; CHECK-NEXT:        Index:           0
+; CHECK-NEXT:      - Name:            foo_i32
+; CHECK-NEXT:        Kind:            FUNCTION
+; CHECK-NEXT:        Index:           0
+; CHECK-NEXT:      - Name:            foo_f64
+; CHECK-NEXT:        Kind:            FUNCTION
+; CHECK-NEXT:        Index:           1
+
+; CHECK:       - Type:            CODE
+
+; CHECK:           - Index:           0
+; CHECK-NEXT:        Locals:          []
+; CHECK-NEXT:        Body:            200020016A0B
+; CHECK-NEXT:      - Index:           1
+; CHECK-NEXT:        Locals:          []
+; CHECK-NEXT:        Body:            20002001A00B
+
+; CHECK:       - Type:            CUSTOM
+; CHECK-NEXT:    Name:            name
+; CHECK-NEXT:    FunctionNames:
+; CHECK-NEXT:      - Index:           0
+; CHECK-NEXT:        Name:            foo_i32
+; CHECK-NEXT:      - Index:           1
+; CHECK-NEXT:        Name:            foo_f64

lld/test/wasm/command-exports.ll

+; RUN: llc -filetype=obj -o %t.o %s
+; RUN: wasm-ld --no-entry %t.o -o %t.wasm
+; RUN: obj2yaml %t.wasm | FileCheck %s
+
+target triple = "wasm32-unknown-unknown"
+
+define i32 @foo_i32(i32 %a, i32 %b) #0 {
+entry:
+  %c = add i32 %a, %b
+  ret i32 %c
+}
+
+define double @foo_f64(double %a, double %b) #1 {
+entry:
+  %c = fadd double %a, %b
+  ret double %c
+}
+
+define void @some_ctor() {
+entry:
+  ret void
+}
+
+define void @some_dtor() {
+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 ()* @some_ctor, i8* null }
+]
+
[e-mail]_dtors = appending global [1 x { i32, void ()*, i8* }] [
+  { i32, void ()*, i8* } { i32 1, void ()* @some_dtor, i8* null }
+]
+
+attributes #0 = { "wasm-export-name"="foo_i32" }
+
+attributes #1 = { "wasm-export-name"="foo_f64" }
+
+; CHECK:       - Type:            EXPORT
+; CHECK-NEXT:    Exports:
+; CHECK-NEXT:      - Name:            memory
+; CHECK-NEXT:        Kind:            MEMORY
+; CHECK-NEXT:        Index:           0
+; CHECK-NEXT:      - Name:            foo_i32
+; CHECK-NEXT:        Kind:            FUNCTION
+; CHECK-NEXT:        Index:           8
+; 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:      - Index:           9
+; CHECK-NEXT:        Locals:          []
+; CHECK-NEXT:        Body:            10002000200110020B
+
+; 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:      - Index:           9
+; CHECK-NEXT:        Name:            foo_f64.command_export

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 %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 the __wasm_call_ctor function if not referenced
+; Test that we emit wrappers and call __wasm_call_ctor 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 i32 @__cxa_atexit(i32 %func, i32 %arg, i32 %dso_handle) {
+define hidden i32 @__cxa_atexit(i32 %func, i32 %arg, i32 %dso_handle) {
   ret i32 0
 }
 
 @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-NOT: __cxa_atexit
-; CHECK-NOT: __wasm_call_ctors
+; 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:           7
+
+; CHECK:       - Type:            CODE
+
+; CHECK:           - Index:           7
+; CHECK-NEXT:        Locals:          []
+; CHECK-NEXT:        Body:            100010010B
+
+; 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
+; CHECK-NEXT:      - Index:           7
+; CHECK-NEXT:        Name:            _start.command_export
 
 ; EXPORT: __wasm_call_ctors
 ; EXPORT: func1
 ; EXPORT: func2
 ; EXPORT: __cxa_atexit

lld/wasm/Driver.cpp

static Symbol *handleUndefined(StringRef name) {
   // Since symbol S may not be used inside the program, LTO may
   // eliminate it. Mark the symbol as "used" to prevent it.
   sym->isUsedInRegularObj = true;
 
   if (auto *lazySym = dyn_cast<LazySymbol>(sym))
     lazySym->fetch();
 
   return sym;
 }
 
 static void handleLibcall(StringRef name) {
   Symbol *sym = symtab->find(name);
   if (!sym)
     return;
 
   if (auto *lazySym = dyn_cast<LazySymbol>(sym)) {
     MemoryBufferRef mb = lazySym->getMemberBuffer();
static void createSyntheticSymbols() {
   if (config->isPic) {
     // For PIC code we create a synthetic function __wasm_apply_relocs which
     // is called from __wasm_call_ctors before the user-level constructors.
     WasmSym::applyRelocs = symtab->addSyntheticFunction(
         "__wasm_apply_relocs", WASM_SYMBOL_VISIBILITY_HIDDEN,
         make<SyntheticFunction>(nullSignature, "__wasm_apply_relocs"));
   }
 
-
   if (config->isPic) {
     WasmSym::stackPointer =
         createUndefinedGlobal("__stack_pointer", &mutableGlobalTypeI32);
     // For PIC code, we import two global variables (__memory_base and
     // __table_base) from the environment and use these as the offset at
     // which to load our static data and function table.
     // See:
     // https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md
if (!config->relocatable && !config->entry.empty()) {
     entrySym = handleUndefined(config->entry);
     if (entrySym && entrySym->isDefined())
       entrySym->forceExport = true;
     else
       error("entry symbol not defined (pass --no-entry to suppress): " +
             config->entry);
   }
 
+  // If the user code defines a `__wasm_call_dtors` function, remember it so
+  // that we can call it from the command export wrappers. Unlike
+  // `__wasm_call_ctors` which we synthesize, `__wasm_call_dtors` is defined
+  // by libc/etc., because destructors are registered dynamically with
+  // `__cxa_atexit` and friends.
+  if (!config->relocatable && !config->shared &&
+      !WasmSym::callCtors->isUsedInRegularObj &&
+      WasmSym::callCtors->getName() != config->entry &&
+      !config->exportedSymbols.count(WasmSym::callCtors->getName())) {
+    if (Symbol *callDtors = handleUndefined("__wasm_call_dtors")) {
+      if (auto *callDtorsFunc = dyn_cast<DefinedFunction>(callDtors)) {
+        if (callDtorsFunc->signature &&
+            (!callDtorsFunc->signature->Params.empty() ||
+             !callDtorsFunc->signature->Returns.empty())) {
+          error("__wasm_call_dtors must have no argument or return values");
+        }
+        WasmSym::callDtors = callDtorsFunc;
+      } else {
+        error("__wasm_call_dtors must be a function");
+      }
+    }
+  }
+
   createOptionalSymbols();
 
   if (errorCount())
     return;
 
   // Create wrapped symbols for -wrap option.
   std::vector<WrappedSymbol> wrapped = addWrappedSymbols(args);
 

lld/wasm/InputChunks.h

protected:
   const WasmSegment &segment;
 };
 
 // Represents a single wasm function within and input file.  These are
 // combined to create the final output CODE section.
 class InputFunction : public InputChunk {
 public:
   InputFunction(const WasmSignature &s, const WasmFunction *func, ObjFile *f)
-      : InputChunk(f, InputChunk::Function), signature(s), function(func) {}
+      : InputChunk(f, InputChunk::Function), signature(s), function(func),
+        exportName(func && func->ExportName.hasValue()
+                       ? (*func->ExportName).str()
+                       : llvm::Optional<std::string>()) {}
 
   static bool classof(const InputChunk *c) {
     return c->kind() == InputChunk::Function ||
            c->kind() == InputChunk::SyntheticFunction;
   }
 
   void writeTo(uint8_t *sectionStart) const override;
   StringRef getName() const override { return function->SymbolName; }
   StringRef getDebugName() const override { return function->DebugName; }
   llvm::Optional<StringRef> getExportName() const {
-    return function ? function->ExportName : llvm::Optional<StringRef>();
+    return exportName.hasValue() ? llvm::Optional<StringRef>(*exportName)
+                                 : llvm::Optional<StringRef>();
   }
+  void setExportName(std::string exportName) { this->exportName = exportName; }
   uint32_t getComdat() const override { return function->Comdat; }
   uint32_t getFunctionInputOffset() const { return getInputSectionOffset(); }
   uint32_t getFunctionCodeOffset() const { return function->CodeOffset; }
   uint32_t getSize() const override {
     if (config->compressRelocations && file) {
       assert(compressedSize);
       return compressedSize;
     }

 protected:
   ArrayRef<uint8_t> data() const override {
     assert(!config->compressRelocations);
     return file->codeSection->Content.slice(getInputSectionOffset(),
                                             function->Size);
   }
 
   const WasmFunction *function;
+  llvm::Optional<std::string> exportName;
   llvm::Optional<uint32_t> functionIndex;
   llvm::Optional<uint32_t> tableIndex;
   uint32_t compressedFuncSize = 0;
   uint32_t compressedSize = 0;
 };
 
 class SyntheticFunction : public InputFunction {
 public:

lld/wasm/MarkLive.cpp

 class MarkLive {
 public:
   void run();
 
 private:
   void enqueue(Symbol *sym);
   void markSymbol(Symbol *sym);
   void mark();
+  bool isCallCtorsLive();
 
   // A list of chunks to visit.
   SmallVector<InputChunk *, 256> queue;
 };
 
 } // namespace
 
 void MarkLive::enqueue(Symbol *sym) {
   if (!sym || sym->isLive())
     return;
   LLVM_DEBUG(dbgs() << "markLive: " << sym->getName() << "\n");
   sym->markLive();
   if (InputChunk *chunk = sym->getChunk())
     queue.push_back(chunk);
-
-  // The ctor functions are all referenced by the synthetic callCtors
-  // function.  However, this function does not contain relocations so we
-  // have to manually mark the ctors as live if callCtors itself is live.
-  if (sym == WasmSym::callCtors) {
-    if (config->isPic)
-      enqueue(WasmSym::applyRelocs);
-    for (const ObjFile *obj : symtab->objectFiles) {
-      const WasmLinkingData &l = obj->getWasmObj()->linkingData();
-      for (const WasmInitFunc &f : l.InitFunctions) {
-        auto* initSym = obj->getFunctionSymbol(f.Symbol);
-        if (!initSym->isDiscarded())
-          enqueue(initSym);
-      }
-    }
-  }
 }
 
 void MarkLive::run() {
   // Add GC root symbols.
   if (!config->entry.empty())
     enqueue(symtab->find(config->entry));
 
   // We need to preserve any no-strip or exported symbol
   for (Symbol *sym : symtab->getSymbols())
     if (sym->isNoStrip() || sym->isExported())
       enqueue(sym);
 
-  // For relocatable output, we need to preserve all the ctor functions
-  if (config->relocatable) {
-    for (const ObjFile *obj : symtab->objectFiles) {
-      const WasmLinkingData &l = obj->getWasmObj()->linkingData();
-      for (const WasmInitFunc &f : l.InitFunctions)
-        enqueue(obj->getFunctionSymbol(f.Symbol));
+  // If we'll be calling the user's `__wasm_call_dtors` function, mark it live.
+  if (Symbol *callDtors = WasmSym::callDtors)
+    enqueue(callDtors);
+
+  // The ctor functions are all referenced by the synthetic callCtors
+  // function.  However, this function does not contain relocations so we
+  // have to manually mark the ctors as live.
+    for (const WasmInitFunc &f : l.InitFunctions) {
+      auto *initSym = obj->getFunctionSymbol(f.Symbol);
+      if (!initSym->isDiscarded())
+        enqueue(initSym);
     }
   }
 
+  // In Emscripten-style PIC, `__wasm_call_ctors` calls `__wasm_apply_relocs`.
   if (config->isPic)
+    enqueue(WasmSym::applyRelocs);
+
+  // If we have any non-discarded init functions, mark `__wasm_call_ctors` as
+  // live so that we assign it an index and call it.
+  if (isCallCtorsLive())
     enqueue(WasmSym::callCtors);
 
   if (config->sharedMemory && !config->shared)
     enqueue(WasmSym::initMemory);
 
   mark();
 }
 
for (InputChunk *c : symtab->syntheticFunctions)
       if (!c->live)
         message("removing unused section " + toString(c));
     for (InputGlobal *g : symtab->syntheticGlobals)
       if (!g->live)
         message("removing unused section " + toString(g));
   }
 }
 
+bool MarkLive::isCallCtorsLive() {
+  // In a reloctable link, we don't call `__wasm_call_ctors`.
+  if (config->relocatable)
+    return false;
+
+  // In Emscripten-style PIC, we call `__wasm_call_ctors` which calls
+  // `__wasm_apply_relocs`.
+  if (config->isPic)
+    return true;
+
+  // If there are any init functions, mark `__wasm_call_ctors` live so that
+  // it can call them.
+  for (const ObjFile *file : symtab->objectFiles) {
+    const WasmLinkingData &l = file->getWasmObj()->linkingData();
+    for (const WasmInitFunc &f : l.InitFunctions)
+      if (!file->getFunctionSymbol(f.Symbol)->isDiscarded())
+        return true;
+  }
+
+  return false;
+}
+
 } // namespace wasm
 } // namespace lld

lld/wasm/Symbols.h

struct WasmSym {
   // __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;
 
+  // __wasm_call_dtors
+  // Function that calls the libc/etc. cleanup function.
+  static DefinedFunction *callDtors;
+
   // __wasm_apply_relocs
   // Function that applies relocations to data segment post-instantiation.
   static DefinedFunction *applyRelocs;
 
   // __wasm_init_tls
   // Function that allocates thread-local storage and initializes it.
   static DefinedFunction *initTLS;
 

lld/wasm/Symbols.cpp

std::string toString(wasm::Symbol::Kind kind) {
   case wasm::Symbol::OutputSectionKind:
     return "OutputSectionKind";
   }
   llvm_unreachable("invalid symbol kind");
 }
 
 namespace wasm {
 DefinedFunction *WasmSym::callCtors;
+DefinedFunction *WasmSym::callDtors;
 DefinedFunction *WasmSym::initMemory;
 DefinedFunction *WasmSym::applyRelocs;
 DefinedFunction *WasmSym::initTLS;
 DefinedData *WasmSym::dsoHandle;
 DefinedData *WasmSym::dataEnd;
 DefinedData *WasmSym::globalBase;
 DefinedData *WasmSym::heapBase;
 DefinedData *WasmSym::initMemoryFlag;

lld/wasm/Writer.cpp

private:
 
   bool needsPassiveInitialization(const OutputSegment *segment);
   bool hasPassiveInitializedSegments();
 
   void createInitMemoryFunction();
   void createApplyRelocationsFunction();
   void createCallCtorsFunction();
   void createInitTLSFunction();
+  void createCommandExportWrappers();
+  void createCommandExportWrapper(uint32_t functionIndex, DefinedFunction *f);
 
   void assignIndexes();
   void populateSymtab();
   void populateProducers();
   void populateTargetFeatures();
   void calculateInitFunctions();
   void calculateImports();
   void calculateExports();
private:
   void writeHeader();
   void writeSections();
 
   uint64_t fileSize = 0;
 
   std::vector<WasmInitEntry> initFunctions;
   llvm::StringMap<std::vector<InputSection *>> customSectionMapping;
 
+  // Stable storage for command export wrapper function name strings.
+  std::list<std::string> commandExportWrapperNames;
+
   // 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;
   llvm::SmallDenseMap<StringRef, OutputSegment *> segmentMap;
void Writer::calculateTypes() {
 
   for (const InputFunction *f : out.functionSec->inputFunctions)
     out.typeSec->registerType(f->signature);
 
   for (const InputEvent *e : out.eventSec->inputEvents)
     out.typeSec->registerType(e->signature);
 }
 
+// In a command-style link, create a wrapper for each exported symbol
+// which calls the constructors and destructors.
+void Writer::createCommandExportWrappers() {
+  // If there are no ctors, and we aren't calling `__wasm_apply_relocs` for
+  // Emscripten-style PIC mode, and there's no libc `__wasm_call_dtors` to
+  // call, don't wrap the exports.
+  if (initFunctions.empty() && !config->isPic && WasmSym::callDtors == NULL)
+    return;
+
+  std::vector<DefinedFunction *> toWrap;
+
+  for (Symbol *sym : symtab->getSymbols())
+    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 func = make<SyntheticFunction>(*f->getSignature(), funcName);
+    if (f->function->getExportName().hasValue())
+      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);
+  }
+}
+
 static void scanRelocations() {
   for (ObjFile *file : symtab->objectFiles) {
     LLVM_DEBUG(dbgs() << "scanRelocations: " << file->getName() << "\n");
     for (InputChunk *chunk : file->functions)
       scanRelocations(chunk);
     for (InputChunk *chunk : file->segments)
       scanRelocations(chunk);
     for (auto &p : file->customSections)
void Writer::createApplyRelocationsFunction() {
   }
 
   createFunction(WasmSym::applyRelocs, bodyContent);
 }
 
 // Create synthetic "__wasm_call_ctors" function based on ctor functions
 // in input object.
 void Writer::createCallCtorsFunction() {
-  if (!WasmSym::callCtors->isLive())
+  // If __wasm_call_ctors isn't referenced, or there aren't any ctors and we
+  // aren't calling `__wasm_apply_relocs` for Emscripten-style PIC, don't
+  // define the `__wasm_call_ctors` function.
+  if (!WasmSym::callCtors->isLive() && initFunctions.empty() && !config->isPic)
     return;
 
   // First write the body's contents to a string.
   std::string bodyContent;
   {
     raw_string_ostream os(bodyContent);
     writeUleb128(os, 0, "num locals");
 
for (const WasmInitEntry &f : initFunctions) {
       writeUleb128(os, f.sym->getFunctionIndex(), "function index");
     }
     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,
+                                        DefinedFunction *f) {
+  // First write the body's contents to a string.
+  std::string bodyContent;
+  {
+    raw_string_ostream os(bodyContent);
+    writeUleb128(os, 0, "num locals");
+
+    // If we have any ctors, or we're calling `__wasm_apply_relocs` for
+    // Emscripten-style PIC, call `__wasm_call_ctors` which performs those
+    // calls.
+    if (!initFunctions.empty() || config->isPic) {
+      writeU8(os, WASM_OPCODE_CALL, "CALL");
+      writeUleb128(os, WasmSym::callCtors->getFunctionIndex(),
+                   "function index");
+    }
+
+    // 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");
+    writeUleb128(os, functionIndex, "function index");
+
+    // Call the function that calls the destructors.
+    if (DefinedFunction *callDtors = WasmSym::callDtors) {
+      writeU8(os, WASM_OPCODE_CALL, "CALL");
+      writeUleb128(os, callDtors->getFunctionIndex(), "function index");
+    }
+
+    // End the function, returning the return values from the user's code.
+    writeU8(os, WASM_OPCODE_END, "END");
+  }
+
+  createFunction(f, bodyContent);
+}
+
 void Writer::createInitTLSFunction() {
   if (!WasmSym::initTLS->isLive())
     return;
 
   std::string bodyContent;
   {
     raw_string_ostream os(bodyContent);
 
void Writer::run() {
 
   if (!config->relocatable) {
     // Create linker synthesized functions
     if (config->sharedMemory)
       createInitMemoryFunction();
     if (config->isPic)
       createApplyRelocationsFunction();
     createCallCtorsFunction();
+
+    // Create export wrappers for commands 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 &&
+        !WasmSym::callCtors->isUsedInRegularObj &&
+        !WasmSym::callCtors->isExported()) {
+      log("-- createCommandExportWrappers");
+      createCommandExportWrappers();
+    }
   }
 
   if (!config->relocatable && config->sharedMemory && !config->shared)
     createInitTLSFunction();
 
   if (errorCount())
     return;