Add .init_array support to Wasm LLD

[ncw]

Summary

I hope this is the right approach!

What I've done is added some (hacky?) plumbing so that for Wasm we export the start/end of .init_array and .fini_array using the well-known __{init,fini}_array_{start,end} symbols.

(Aside: the way this is implemented on desktop (Linux) platforms is that the driver which invokes LLD adds some special files "crtbegin.o" and "crtend.o" to the link line. Those are shipped as part of the platform, and register dummy functions with the magic names __{init,fini}_array_{start,end}, and in turn libc has a weak dependency on those symbols so that it can traverse the array of symbols.)

I had a go with the same approach as on desktop Linux - but it didn't work quite as simply as I'd like, plus there's the nuisance of actually shipping and maintaining the crtbegin/end.o files...

The approach I've gone for instead is to explicitly fudge in those symbols in LLD, and export their addresses manually.

It all works - which is perhaps the only redeeming virtue of this sort of special-casing.

Note this approach should be portable to other libc implementations (not just Musl), since the symbols __init_array_start etc are mandated by the ABI (Musl doesn't create/define those, it relies on GCC to supply them). So, creating those symbols ourselves in LLD is OK, we can add a note to the C ABI document on GitHub to say that crt1.o and __init_array_start from Musl's point of view will work exactly as on desktop linux.

Testing

I've tested with Musl, and the tests in lld/tests/wasm showcase a basic C++ file that uses a global static constructor and a C function annotated with __attribute__((constructor)). The Wasm file at the end does indeed run nicely in the browser, calling each global constructor exactly once.

[sunfish]

I'm not too bothered by the special-casing here.

That said, I have an idea for a different approach and I'm curious what you and others think. Instead of traditional .init_array sections, what if we taught the linker to link multiple start sections, by synthesizing a new start function that calls all the start functions from the input? So if you link a.o and b.o, and each have a start function, the output would contain a start function containing two calls, one to a.o's start function and one to b.o's. Start functions never have arguments or return values, so the synthesized start function would just look like "0x10 <first callee> 0x10 <second callee> ..." (0x10 is the call opcode).

This would require changes to how eg. musl and other things work. However, it would fit well within the spirit of using the wasm format for .o files in a natural way.

(There's also .fini_array, but we can talk about that if the overall idea is worth pursuing.)

[ruiu]

I wonder if you can do everything in the loader. We can let lld create .init_array and .fini_array (which is default behavior) and make a change to the loader so that the loader executes each function pointer in .init_array and .fini_array sections, no?

[ncw]

@sunfish, I think that's an interesting idea. Here are some thoughts I've had:

Pros of building "composite start function" on link:

• Uses native WebAssembly information rather than custom section. That is a genuinely nice change.

Cons:

• Adds asymmetry to destructor handling, when it feels like they should be mirror features
• Won't work out of the box with musl (needless friction with upstream?)
• Less extensible to other sections. I don't expect any other sections to need this treatment, currently, but maybe other languages apart from C have initialisation concerns - like Haskell or Rust...? Sticking as close to ELF as possible for C sets a good precedent for making those other languages easy to integrate. If you're suggesting adapting Musl's startup to WebAssembly, are we going to have to adapt the runtimes of other languages too?
• Assumes that start functions can be run in any order, but that's actually not exactly the case. In particular, libc does its own initialisation _before_ any user-defined constructors, so that thread-local storage and printf are usable in all user-supplied code. It's a bit cheeky of libc to get special privileges like that (by virtue of supplying the entrypoint, it's able to do its own initialisation first). There would have to be a way to force this behaviour to continue - but it wouldn't be insurmountable, you'd just to have some "loose" object file (eg. "crt2.o") that we could guarantee appears first on the link-line.

In D40614#939712, @ruiu wrote:

I wonder if you can do everything in the loader. We can let lld create .init_array and .fini_array (which is default behavior) and make a change to the loader so that the loader executes each function pointer in .init_array and .fini_array sections, no?

I'm not sure what you mean by the "loader" - is that the runtime WebAssembly interpreter/AOT-compiler? At runtime, the "sections" don't exist anymore, they're only available here to the linker. At runtime, you're right we want the interpreter to execute each function, and that's only achievable in WebAssembly via the START function.

[sunfish]

Cons:
Adds asymmetry to destructor handling, when it feels like they should be mirror features

Actually, it's not entirely clear that .fini_array is desirable for current wasm. It's nice to be compatible with tools that expect it, but it's usually better to use atexit/__cxa_atexit instead, because that makes it feasible to run destructors in reverse order of the runtime order of the corresponding constructors. For example, C++ uses __cxa_atexit and not .fini_array on ELF, in part for this reason.

Won't work out of the box with musl (needless friction with upstream?)

It would be some friction. I don't think it's needless though :-).

Less extensible to other sections. I don't expect any other sections to need this treatment, currently, but maybe other languages apart from C have initialisation concerns - like Haskell or Rust...? Sticking as close to ELF as possible for C sets a good precedent for making those other languages easy to integrate. If you're suggesting adapting Musl's startup to WebAssembly, are we going to have to adapt the runtimes of other languages too?

ELF is a standard that some tools support, so by emulating ELF, we make it easier to port these tools.

On the other hand, there are people looking to port and build tools for wasm that have no knowledge of ELF. If we do things the wasm way, rather than the ELF way, it'll be easier to promote interoperability between all these tools on wasm, because wasm is the thing they're all guaranteed to have in common.

Assumes that start functions can be run in any order, but that's actually not exactly the case. In particular, libc does its own initialisation _before_ any user-defined constructors, so that thread-local storage and printf are usable in all user-supplied code. It's a bit cheeky of libc to get special privileges like that (by virtue of supplying the entrypoint, it's able to do its own initialisation first). There would have to be a way to force this behaviour to continue - but it wouldn't be insurmountable, you'd just to have some "loose" object file (eg. "crt2.o") that we could guarantee appears first on the link-line.

We'd just do the same thing that ELF does: order the functions in the combined start function in the order they appear on the link command line. Then we just put the initialization in crt1.o/crti.o/crtbegin.o and but those before any user code, and we're good, just like ELF.

[ncw]

(Rebased.)

We probably need some move votes then to reach consensus. On the one hand, Dan's idea is maybe a bit cleaner for C/C++ in the long term. There should probably be a principle on how much we want to emulate ELF, which we would then stick to. Choosing not to implement support for .fini_array (__attribute__((destructor)) on exit()) also seems a bit premature, although I admit it's probably hardly-used. Potentially a good number of Emscripten programs do call exit() though.

At the moment, LLD is far, far from being able to link "generic" Wasm files together. The entire model revolves around custom sections providing ELFy data defined in the "Tool conventions", so using a start section instead of .init_array really isn't going to a huge difference for generic tools that want to produce inputs for LLD to process. I can appreciate the desire to reduce the ELFyness of the conventions though.

Either way, we could still do this (smaller) change right now, and come back and do Dan's change later, once we've got C++ working.

[ncw]

Rubbish, when I rebased I must have sent the wrong diff... OK, here's the correct rebased diff.

[sbc100]

I've also been working on a similar change: https://reviews.llvm.org/D40760

Sorry its been in the works for a while but I hadn't uploaded it yet.

[ncw]

CHANGES:

• Rebased...
• Integrated Sam's changes from D40760, in particular his tests and his renaming/refactoring (where possible)

I suspect there'll be some more conflicts as soon as D40859 is merged. I'm quite happy for D40859 to be merged first, and I can rebase this patch.

(NB. My entrypoint changes are "Ready to Land" in Phabricator, so I've rebased on top of those, since surely they'll be merged sooner than this. I'm just trying to minimise the amount of rebasing and conflicts.)

[ncw]

As expected, it needed rebasing after D40859. I don't know whether this will be merged - but I've done the rebase anyway just so we're at least looking at the right change.

Now that Sam's Global changes are merged, it's a shorter diff.

[ncw]

Abandoning - but! I need to remember to keep the test files, which might still be useful.

test/wasm/call-indirect.ll

 ; CHECK-NEXT:       - Initial:         0x00000002
 ; CHECK-NEXT:   - Type:            GLOBAL
 ; CHECK-NEXT:     Globals:         
 ; CHECK-NEXT:       - Type:            I32
 ; CHECK-NEXT:         Mutable:         true
 ; CHECK-NEXT:         InitExpr:        
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           66576
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
 ; CHECK-NEXT:   - 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:           3

test/wasm/data-layout.ll

 ; CHECK-NEXT:         Mutable:         true
 ; CHECK-NEXT:         InitExpr:        
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           66608
 ; CHECK-NEXT:       - Type:            I32
 ; CHECK-NEXT:         Mutable:         false
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1052
 ; CHECK-NEXT:       - Type:            I32
 ; CHECK-NEXT:         Mutable:         false
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1024
 ; CHECK-NEXT:       - Type:            I32
 ; CHECK-NEXT:         Mutable:         false
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1040
 ; CHECK-NEXT:       - Type:            I32
 ; CHECK-NEXT:         Mutable:         false
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1048
 
 ; CHECK:       - Type:            DATA
 ; CHECK-NEXT:     Relocations:
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_I32
-; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:         Index:           5
 ; CHECK-NEXT:         Offset:          0x0000001F
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - SectionOffset:   7
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1024
 ; CHECK-NEXT:         Content:         0100000000000000000000000000000003000000000000001C040000

test/wasm/init-array-cxx.ll

+; RUN: llc -filetype=obj %s -o %t.o
+; RUN: lld -flavor wasm -o %t.wasm %t.o --allow-undefined
+; RUN: obj2yaml %t.wasm | FileCheck %s
+
+; ==== Generated from ====
+; extern void externalFn(void); // Avoid optimising out ctor calls
+;
+; struct StaticCtor {
+;   StaticCtor();
+; };
+; // Not inline to avoid a COMDAT:
+; StaticCtor::StaticCtor() { externalFn(); }
+; 
+; static StaticCtor staticCtor;
+; 
+; void __attribute__((constructor)) ctorFunction() { externalFn(); }
+; 
+; extern void (*const __init_array_start)(void), (*const __init_array_end)(void);
+; 
+; typedef unsigned long uintptr_t;
+; extern "C" void _start(void) {
+;   for (void (*const *i)(void) = &__init_array_start;
+;        (uintptr_t)i < (uintptr_t)&__init_array_end;
+;        ++i) {
+;     (*i)();
+;   }
+; }
+; ========================
+
+
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown-wasm"
+
+%struct.StaticCtor = type { i8 }
+
+@__init_array_start = external constant void ()*, align 4
+@__init_array_end = external constant void ()*, align 4
[e-mail]_ctors = appending global [2 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @_Z12ctorFunctionv, i8* null }, { i32, void ()*, i8* } { i32 65535, void ()* @_GLOBAL__sub_I_init_test.cxx, i8* null }]
+
+@_ZN10StaticCtorC1Ev = hidden alias %struct.StaticCtor* (%struct.StaticCtor*), %struct.StaticCtor* (%struct.StaticCtor*)* @_ZN10StaticCtorC2Ev
+
+; Function Attrs: optsize
+define hidden %struct.StaticCtor* @_ZN10StaticCtorC2Ev(%struct.StaticCtor* readnone returned %this) unnamed_addr #0 {
+entry:
+  tail call void @_Z10externalFnv() #2
+  ret %struct.StaticCtor* %this
+}
+
+; Function Attrs: optsize
+declare void @_Z10externalFnv() local_unnamed_addr #1
+
+; Function Attrs: optsize
+define hidden void @_Z12ctorFunctionv() #0 {
+entry:
+  tail call void @_Z10externalFnv() #2
+  ret void
+}
+
+; Function Attrs: optsize
+define hidden void @_start() local_unnamed_addr #0 {
+entry:
+  br i1 icmp ult (void ()** @__init_array_start, void ()** @__init_array_end), label %for.body.preheader, label %for.cond.cleanup
+
+for.body.preheader:                               ; preds = %entry
+  br label %for.body
+
+for.cond.cleanup:                                 ; preds = %for.body, %entry
+  ret void
+
+for.body:                                         ; preds = %for.body.preheader, %for.body
+  %i.04 = phi void ()** [ %incdec.ptr, %for.body ], [ @__init_array_start, %for.body.preheader ]
+  %0 = load void ()*, void ()** %i.04, align 4, !tbaa !2
+  tail call void %0() #2
+  %incdec.ptr = getelementptr inbounds void ()*, void ()** %i.04, i32 1
+  %cmp = icmp ult void ()** %incdec.ptr, @__init_array_end
+  br i1 %cmp, label %for.body, label %for.cond.cleanup
+}
+
+; Function Attrs: optsize
+define internal void @_GLOBAL__sub_I_init_test.cxx() #0 section ".text.__startup" {
+entry:
+  tail call void @_Z10externalFnv() #2
+  ret void
+}
+
+attributes #0 = { optsize "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="generic" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { optsize "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="generic" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #2 = { optsize }
+
+!llvm.module.flags = !{!0}
+!llvm.ident = !{!1}
+
+!0 = !{i32 1, !"wchar_size", i32 4}
+!1 = !{!"clang version 6.0.0 (trunk 318652)"}
+!2 = !{!3, !3, i64 0}
+!3 = !{!"any pointer", !4, i64 0}
+!4 = !{!"omnipotent char", !5, i64 0}
+!5 = !{!"Simple C++ TBAA"}
+
+; CHECK:       - Type:            IMPORT
+; CHECK-NEXT:    Imports:
+; CHECK-NEXT:      - Module:          env
+; CHECK-NEXT:        Field:           _Z10externalFnv
+; CHECK-NEXT:        Kind:            FUNCTION
+; CHECK-NEXT:        SigIndex:        1
+; 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:           3
+; CHECK-NEXT:  - Type:            ELEM
+; CHECK-NEXT:    Segments:
+; CHECK-NEXT:      - Offset:
+; CHECK-NEXT:          Opcode:          I32_CONST
+; CHECK-NEXT:          Value:           1
+; CHECK-NEXT:        Functions:       [ 2, 4 ]
+; CHECK-NEXT:  - Type:            CODE
+; CHECK-NEXT:    Functions:
+; CHECK-NEXT:      - Locals:
+; CHECK-NEXT:        Body:            10808080800020000B
+; CHECK-NEXT:      - Locals:
+; CHECK-NEXT:        Body:            1080808080000B
+; CHECK-NEXT:      - Locals:
+; CHECK-NEXT:          - Type:            I32
+; CHECK-NEXT:            Count:           1
+; CHECK-NEXT:        Body:            418088808000210002404180888080004188888080004F0D000340200028020011818080800000200041046A2200418888808000490D000B0B0B
+; CHECK-NEXT:      - Locals:
+; CHECK-NEXT:        Body:            1080808080000B
+; CHECK-NEXT:  - Type:            DATA
+; CHECK-NEXT:    Segments:
+; CHECK-NEXT:      - SectionOffset:   7
+; CHECK-NEXT:        MemoryIndex:     0
+; CHECK-NEXT:        Offset:
+; CHECK-NEXT:          Opcode:          I32_CONST
+; CHECK-NEXT:          Value:           1024
+; CHECK-NEXT:        Content:         '0100000002000000'

test/wasm/init-array-empty.ll

+; RUN: llc -filetype=obj %s -o %t.o
+; RUN: lld -flavor wasm -o %t.wasm %t.o
+; RUN: obj2yaml %t.wasm | FileCheck %s
+
+; ==== Generated from ====
+; extern void (*const __init_array_start)(void), (*const __init_array_end)(void);
+; 
+; typedef unsigned long uintptr_t;
+; extern "C" void _start(void) {
+;   for (void (*const *i)(void) = &__init_array_start;
+;        (uintptr_t)i < (uintptr_t)&__init_array_end;
+;        ++i) {
+;     (*i)();
+;   }
+; }
+; ========================
+
+
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown-wasm"
+
+@__init_array_start = external constant void ()*, align 4
+@__init_array_end = external constant void ()*, align 4
+
+; Function Attrs: optsize
+define hidden void @_start() local_unnamed_addr #0 {
+entry:
+  br i1 icmp ult (void ()** @__init_array_start, void ()** @__init_array_end), label %for.body.preheader, label %for.cond.cleanup
+
+for.body.preheader:                               ; preds = %entry
+  br label %for.body
+
+for.cond.cleanup:                                 ; preds = %for.body, %entry
+  ret void
+
+for.body:                                         ; preds = %for.body.preheader, %for.body
+  %i.04 = phi void ()** [ %incdec.ptr, %for.body ], [ @__init_array_start, %for.body.preheader ]
+  %0 = load void ()*, void ()** %i.04, align 4, !tbaa !2
+  tail call void %0() #1
+  %incdec.ptr = getelementptr inbounds void ()*, void ()** %i.04, i32 1
+  %cmp = icmp ult void ()** %incdec.ptr, @__init_array_end
+  br i1 %cmp, label %for.body, label %for.cond.cleanup
+}
+
+attributes #0 = { optsize "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="generic" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { optsize }
+
+!llvm.module.flags = !{!0}
+!llvm.ident = !{!1}
+
+!0 = !{i32 1, !"wchar_size", i32 4}
+!1 = !{!"clang version 6.0.0 (trunk 318652)"}
+!2 = !{!3, !3, i64 0}
+!3 = !{!"any pointer", !4, i64 0}
+!4 = !{!"omnipotent char", !5, i64 0}
+!5 = !{!"Simple C++ TBAA"}
+
+
+; 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:           0
+; CHECK-NEXT:  - Type:            CODE
+; CHECK-NEXT:    Functions:       
+; CHECK-NEXT:      - Locals:          
+; CHECK-NEXT:          - Type:            I32
+; CHECK-NEXT:            Count:           1
+; CHECK-NEXT:        Body:            418080808000210002404180808080004180808080004F0D000340200028020011808080800000200041046A2200418080808000490D000B0B0B

test/wasm/init-fini-array.ll

+; RUN: llc -mtriple wasm32-unknown-unknown-wasm -filetype=obj -o %t.o %s
+; RUN: lld -flavor wasm %t.o -o %t.wasm
+; RUN: obj2yaml %t.wasm | FileCheck %s
+
+define void @func1() {
+entry:
+  ret void
+}
+
+define void @func2() {
+entry:
+  ret void
+}
+
+define void @_start() {
+entry:
+  ret void
+}
+
[e-mail]_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @func1, i8* null }]
+
[e-mail]_dtors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @func2, i8* null }]
+
+; CHECK:      --- !WASM
+; CHECK:        - Type:            GLOBAL
+; CHECK-NEXT:     Globals:
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         true
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           66576
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           1024
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           1028
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           1028
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           1032
+; CHECK-NEXT:   - 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:           2
+; CHECK-NEXT:       - Name:            func1
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:       - Name:            func2
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:   - Type:            ELEM
+; CHECK-NEXT:     Segments:
+; CHECK-NEXT:       - Offset:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           1
+; CHECK-NEXT:         Functions:       [ 0, 1 ]
+; CHECK-NEXT:   - Type:            CODE
+; CHECK-NEXT:     Functions:
+; CHECK-NEXT:       - Locals:
+; CHECK-NEXT:         Body:            0B
+; CHECK-NEXT:       - Locals:
+; CHECK-NEXT:         Body:            0B
+; CHECK-NEXT:       - Locals:
+; CHECK-NEXT:         Body:            0B
+; CHECK-NEXT:   - Type:            DATA
+; CHECK-NEXT:     Segments:
+; CHECK-NEXT:       - SectionOffset:   7
+; CHECK-NEXT:         MemoryIndex:     0
+; CHECK-NEXT:         Offset:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           1024
+; CHECK-NEXT:         Content:         '01000000'
+; CHECK-NEXT:       - SectionOffset:   17
+; CHECK-NEXT:         MemoryIndex:     0
+; CHECK-NEXT:         Offset:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           1028
+; CHECK-NEXT:         Content:         '02000000'

test/wasm/local-symbols.ll

 ; CHECK-NEXT:       - Initial:         0x00000002
 ; CHECK-NEXT:   - Type:            GLOBAL
 ; CHECK-NEXT:     Globals:         
 ; CHECK-NEXT:       - Type:            I32
 ; CHECK-NEXT:         Mutable:         true
 ; CHECK-NEXT:         InitExpr:        
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           66576
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
 ; CHECK-NEXT:   - 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

test/wasm/stack-pointer.ll

 ; CHECK-NEXT:       - Initial:         0x00000002
 ; CHECK-NEXT:   - Type:            GLOBAL
 ; CHECK-NEXT:     Globals:         
 ; CHECK-NEXT:       - Type:            I32
 ; CHECK-NEXT:         Mutable:         true
 ; CHECK-NEXT:         InitExpr:        
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           66560
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
 ; CHECK-NEXT:   - 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:           0

test/wasm/weak-alias-overide.ll

 ; CHECK-NEXT:       - Initial:         0x00000002
 ; CHECK-NEXT:   - Type:            GLOBAL
 ; CHECK-NEXT:     Globals:         
 ; CHECK-NEXT:       - Type:            I32
 ; CHECK-NEXT:         Mutable:         true
 ; CHECK-NEXT:         InitExpr:        
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           66560
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
 ; CHECK-NEXT:   - 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

test/wasm/weak-alias.ll

 ; CHECK-NEXT:       - Initial:         0x00000002
 ; CHECK-NEXT:   - Type:            GLOBAL
 ; CHECK-NEXT:     Globals:         
 ; CHECK-NEXT:       - Type:            I32
 ; CHECK-NEXT:         Mutable:         true
 ; CHECK-NEXT:         InitExpr:        
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           66560
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
 ; CHECK-NEXT:   - 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:           0

test/wasm/weak-external.ll

 ; CHECK-NEXT:       - Initial:         0x00000002
 ; CHECK-NEXT:   - Type:            GLOBAL
 ; CHECK-NEXT:     Globals:
 ; CHECK-NEXT:       - Type:            I32
 ; CHECK-NEXT:         Mutable:         true
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           66560
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
 ; CHECK-NEXT:   - 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:           2

wasm/Config.h

struct Configuration {
   uint32_t MaxMemory;
   uint32_t ZStackSize;
   llvm::StringRef Entry;
   llvm::StringRef OutputFile;
 
   llvm::StringSet<> AllowUndefinedSymbols;
   std::vector<llvm::StringRef> SearchPaths;
   Symbol *StackPointerSymbol = nullptr;
+  Symbol *InitArrayStartSymbol = nullptr;
+  Symbol *InitArrayEndSymbol = nullptr;
+  Symbol *FiniArrayStartSymbol = nullptr;
+  Symbol *FiniArrayEndSymbol = nullptr;
 };
 
 // The only instance of Configuration struct.
 extern Configuration *Config;
 
 } // namespace wasm
 } // namespace lld
 
 #endif

wasm/Driver.cpp

 // Inject a new undefined symbol into the link.  This will cause the link to
 // fail unless this symbol can be found.
 static void addSyntheticUndefinedFunction(StringRef Name,
                                           const WasmSignature *Type) {
   log("injecting undefined func: " + Name);
   Symtab->addUndefinedFunction(Name, Type);
 }
 
+static Symbol *addDefinedGlobalWithDefault(StringRef Name, uint32_t DefaultAddr) {
+  Symbol *Sym = Symtab->addDefinedGlobal(Name);
+  Sym->setVirtualAddress(DefaultAddr);
+  return Sym;
+}
+
 static void printHelp(const char *Argv0) {
   WasmOptTable Table;
   Table.PrintHelp(outs(), Argv0, "LLVM Linker", false);
 }
 
 WasmOptTable::WasmOptTable() : OptTable(OptInfo) {}
 
 opt::InputArgList WasmOptTable::parse(ArrayRef<const char *> Argv) {
if (!Config->Entry.empty()) {
       addSyntheticUndefinedFunction(Config->Entry, &Signature);
     }
 
     // Handle the `--undefined <sym>` options.
     for (StringRef S : args::getStrings(Args, OPT_undefined))
       addSyntheticUndefinedFunction(S, nullptr);
 
     Config->StackPointerSymbol = Symtab->addDefinedGlobal("__stack_pointer");
+    Config->InitArrayStartSymbol = addDefinedGlobalWithDefault("__init_array_start", 0);
+    Config->InitArrayEndSymbol = addDefinedGlobalWithDefault("__init_array_end", 0);
+    Config->FiniArrayStartSymbol = addDefinedGlobalWithDefault("__fini_array_start", 0);
+    Config->FiniArrayEndSymbol = addDefinedGlobalWithDefault("__fini_array_end", 0);
   }
 
   createFiles(Args);
   if (errorCount())
     return;
 
   // Add all files to the symbol table. This will add almost all
   // symbols that we need to the symbol table.

wasm/Symbols.cpp

 uint32_t Symbol::getOutputIndex() const {
   if (isUndefined() && isWeak())
     return 0;
   return OutputIndex.getValue();
 }
 
 void Symbol::setVirtualAddress(uint32_t Value) {
   DEBUG(dbgs() << "setVirtualAddress " << Name << " -> " << Value << "\n");
-  assert(!VirtualAddress.hasValue());
   VirtualAddress = Value;
 }
 
 void Symbol::setOutputIndex(uint32_t Index) {
   DEBUG(dbgs() << "setOutputIndex " << Name << " -> " << Index << "\n");
   assert(!hasOutputIndex());
   OutputIndex = Index;
 }

wasm/Writer.cpp

for (const Symbol *Sym : Symtab->getSymbols()) {
     SymbolExports.emplace_back(Sym);
   }
 
   for (const Symbol *Sym : DefinedGlobals) {
     // Can't export the SP right now because it mutable and mutable globals
     // connot be exported.
     if (Sym == Config->StackPointerSymbol)
       continue;
+    // Don't export the .init_array/.fini_array symbols, they're only internal.
+    if (Sym == Config->InitArrayStartSymbol || Sym == Config->InitArrayEndSymbol ||
+        Sym == Config->FiniArrayStartSymbol || Sym == Config->FiniArrayEndSymbol)
+      continue;
     SymbolExports.emplace_back(Sym);
   }
 
   NumExports += SymbolExports.size();
   if (!NumExports)
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_EXPORT);
void Writer::layoutMemory() {
   createOutputSegments();
 
   // Static data comes first
   for (OutputSegment *Seg : Segments) {
     MemoryPtr = alignTo(MemoryPtr, Seg->Alignment);
     Seg->StartVA = MemoryPtr;
     debugPrint("mem: %-10s offset=%-8d size=%-4d align=%d\n",
                Seg->Name.str().c_str(), MemoryPtr, Seg->Size, Seg->Alignment);
+
+    if (!Config->Relocatable) {
+      if (Seg->Name == ".init_array") {
+        Config->InitArrayStartSymbol->setVirtualAddress(MemoryPtr);
+        Config->InitArrayEndSymbol->setVirtualAddress(MemoryPtr + Seg->Size);
+      } else if (Seg->Name == ".fini_array") {
+        Config->FiniArrayStartSymbol->setVirtualAddress(MemoryPtr);
+        Config->FiniArrayEndSymbol->setVirtualAddress(MemoryPtr + Seg->Size);
+      }
+    }
+
     MemoryPtr += Seg->Size;
   }
 
   DataSize = MemoryPtr;
   if (!Config->Relocatable)
     DataSize -= Config->GlobalBase;
   debugPrint("mem: static data = %d\n", DataSize);
 
for (ObjFile *File : Symtab->ObjectFiles) {
     for (const WasmSignature &Sig : File->getWasmObj()->types())
       File->TypeMap.push_back(getTypeIndex(Sig));
   }
 }
 
 void Writer::assignSymbolIndexes() {
   uint32_t GlobalIndex = GlobalImports.size();
 
-  if (Config->StackPointerSymbol) {
-    DefinedGlobals.emplace_back(Config->StackPointerSymbol);
-    Config->StackPointerSymbol->setOutputIndex(GlobalIndex++);
+  Symbol *SyntheticGlobals[] = {
+      Config->StackPointerSymbol,
+      Config->InitArrayStartSymbol, Config->InitArrayEndSymbol,
+      Config->FiniArrayStartSymbol, Config->FiniArrayEndSymbol
+  };
+  for (Symbol *Sym : SyntheticGlobals) {
+    if (Sym) {
+      DefinedGlobals.emplace_back(Sym);
+      Sym->setOutputIndex(GlobalIndex++);
+    }
   }
 
   if (Config->EmitRelocs)
     DefinedGlobals.reserve(Symtab->getSymbols().size());
 
   for (ObjFile *File : Symtab->ObjectFiles) {
     DEBUG(dbgs() << "assignSymbolIndexes: " << File->getName() << "\n");
     for (Symbol *Sym : File->getSymbols()) {