[WebAssembly] Create synthetic __wasm_call_ctors function

[sbc100]

Summary

This change create a new synthetic function in the final
output binary which calls the static constructors in sequence.

See: https://github.com/WebAssembly/tool-conventions/issues/25

[sbc100]

• rebase

[ruiu]

wasm/Driver.cpp

303

Since no one sets Config->CtorFunction, I'd inline it and directly write "__wasm_call_ctors" here.

wasm/InputChunks.h

136

I'd try to make the class hierarchy as shallow as possible. Do you think inheriting InputFunction is better than inheriting InputChunk?

wasm/Writer.cpp

708

Are you going to do the same thing for .dtors in a follow-up patch?

Please write a comment to describe this function creates a linker-synthesized function that calls initialization functions, which in turn be called by the startup routine on process startup.

727

Please add a comment.

[sbc100]

wasm/Driver.cpp

303

I was going to make this configurable via flag, but maybe I'll wait until we really need that before adding it.

wasm/InputChunks.h

136

Right now the CodeSection is built from a vector of InputFunction * so this is needed. I think I tried refactoring and failed, but I can try again.

wasm/Writer.cpp

708

llvm already lowers all the dtors to ctors that call __cxa_atexit.
See: https://reviews.llvm.org/D41211

[AndrewScheidecker]

wasm/Writer.cpp

714

This size needs to account for the variable length function indices. Perhaps just wait until after the encoded function is generated to compute the size?

717

“END” -> “CALL”
Also, instructions don’t use leb128 encoding.

[sbc100]

• feedback

wasm/Writer.cpp

714

Good call, I was being very lazy.

[sbc100]

• implement ctor/dtor priority

[ruiu]

wasm/InputChunks.h

142–144

This comment is not specific to this patch, but why does this function returns 'const uint8_t *' instead of ArrayRef<uint8_t>? Usually the latter type is better because it does bound-checking.

[sbc100]

wasm/InputChunks.h

142–144

Good point. I'll see if I can good up a patch.

test/wasm/Inputs/global-ctor-dtor.ll

 define hidden void @myctor() {
 entry:
   ret void
 }
 
 define hidden void @mydtor() {
 entry:
   %ptr = alloca i32
   ret void
 }
 
[e-mail]_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @myctor, i8* null }]
[e-mail]_ctors = appending global [3 x { i32, void ()*, i8* }] [
+  { i32, void ()*, i8* } { i32 2002, void ()* @myctor, i8* null },
+  { i32, void ()*, i8* } { i32 101, void ()* @myctor, i8* null },
+  { i32, void ()*, i8* } { i32 202, void ()* @myctor, i8* null }
+]
 
[e-mail]_dtors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @mydtor, i8* null }]
[e-mail]_dtors = appending global [3 x { i32, void ()*, i8* }] [
+  { i32, void ()*, i8* } { i32 2002, void ()* @mydtor, i8* null },
+  { i32, void ()*, i8* } { i32 101, void ()* @mydtor, i8* null },
+  { i32, void ()*, i8* } { i32 202, void ()* @mydtor, i8* null }
+]

test/wasm/alias.ll

 ; CHECK-NEXT: FileHeader:      
 ; CHECK-NEXT:   Version:         0x00000001
 ; CHECK-NEXT: Sections:        
 ; CHECK-NEXT:   - Type:            TYPE
 ; CHECK-NEXT:     Signatures:      
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         ReturnType:      I32
 ; CHECK-NEXT:         ParamTypes:      
+; CHECK-NEXT:      - Index:           1
+; CHECK-NEXT:        ReturnType:      NORESULT
+; CHECK-NEXT:        ParamTypes:
 ; CHECK-NEXT:   - Type:            FUNCTION
-; CHECK-NEXT:     FunctionTypes:   [ 0 ]
+; CHECK-NEXT:     FunctionTypes:   [ 0, 1 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:          
 ; CHECK-NEXT:       - ElemType:        ANYFUNC
 ; CHECK-NEXT:         Limits:          
 ; CHECK-NEXT:           Flags:           [ HAS_MAX ]
 ; CHECK-NEXT:           Initial:         0x00000001
 ; CHECK-NEXT:           Maximum:         0x00000001
 ; CHECK-NEXT:   - Type:            MEMORY

 ; CHECK-NEXT:       - Name:            start_alias
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Functions:       
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Locals:          
 ; CHECK-NEXT:         Body:            41000B
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         Locals:          
+; CHECK-NEXT:         Body:            0B
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        0
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:   
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            start_alias
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         Name:            __wasm_call_ctors
 ; CHECK-NEXT: ...

test/wasm/call-indirect.ll

 ; CHECK-NEXT:         ReturnType:      NORESULT
 ; CHECK-NEXT:         ParamTypes:      
 ; CHECK-NEXT:           - I32
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         ReturnType:      I64
 ; CHECK-NEXT:         ParamTypes:      
 ; CHECK-NEXT:           - I64
 ; CHECK-NEXT:   - Type:            FUNCTION
-; CHECK-NEXT:     FunctionTypes:   [ 0, 1, 0, 0, 2 ]
+; CHECK-NEXT:     FunctionTypes:   [ 0, 1, 0, 0, 2, 1 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:
 ; CHECK-NEXT:       - ElemType:        ANYFUNC
 ; CHECK-NEXT:         Limits:
 ; CHECK-NEXT:           Flags:           [ HAS_MAX ]
 ; CHECK-NEXT:           Initial:         0x00000003
 ; CHECK-NEXT:           Maximum:         0x00000003
 ; CHECK-NEXT:   - Type:            MEMORY

 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            41020B
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            410028028888808000118080808000001A41000B
 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            42012000118380808000001A0B
+; CHECK-NEXT:       - Index:           5
+; 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:         '010000000200000002000000'

test/wasm/function-imports-first.ll

 ; CHECK-NEXT:      - Index:           0
 ; CHECK-NEXT:        ReturnType:      NORESULT
 ; CHECK-NEXT:        ParamTypes:
 ; CHECK-NEXT:      - Index:           1
 ; CHECK-NEXT:        ReturnType:      I32
 ; CHECK-NEXT:        ParamTypes:
 ; CHECK-NEXT:          - F32
 ; CHECK:  - Type:            FUNCTION
-; CHECK-NEXT:    FunctionTypes: [ 0, 1 ]
+; CHECK-NEXT:    FunctionTypes: [ 0, 1, 0 ]
 ; CHECK:  - Type:            CODE
 ; CHECK-NEXT:    Functions:
 ; CHECK-NEXT:      - Index:           0
 ; CHECK-NEXT:        Locals:
 ; CHECK-NEXT:        Body:            43000000001081808080001A0B
 ; CHECK-NEXT:      - Index:           1
 ; CHECK-NEXT:        Locals:
 ; CHECK-NEXT:        Body:            41000B
+; CHECK-NEXT:      - Index:           2
+; CHECK-NEXT:        Locals:
+; CHECK-NEXT:        Body:            0B
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        0
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            _start
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            ret32
+; CHECK-NEXT:       - Index:           2
+; CHECK-NEXT:         Name:            __wasm_call_ctors
 ; CHECK-NEXT: ...

test/wasm/function-imports.ll

 ; CHECK-NEXT:      - Index:           0
 ; CHECK-NEXT:        ReturnType:      I32
 ; CHECK-NEXT:        ParamTypes:
 ; CHECK-NEXT:          - F32
 ; CHECK-NEXT:      - Index:           1
 ; CHECK-NEXT:        ReturnType:      NORESULT
 ; CHECK-NEXT:        ParamTypes:
 ; CHECK-NEXT:  - Type:            FUNCTION
-; CHECK-NEXT:    FunctionTypes:   [ 0, 1 ]
+; CHECK-NEXT:    FunctionTypes:   [ 0, 1, 1 ]
 ; CHECK:       - Type:            CODE
 ; CHECK-NEXT:    Functions:
 ; CHECK:           - Index:       0
 ; CHECK:           - Index:       1
+; CHECK:           - Index:       2
 ; CHECK:         Name:            name
 ; CHECK-NEXT:    FunctionNames:
 ; CHECK-NEXT:      - Index:           0
 ; CHECK-NEXT:        Name:            ret32
 ; CHECK-NEXT:      - Index:           1
 ; CHECK-NEXT:        Name:            _start
+; CHECK-NEXT:      - Index:           2
+; CHECK-NEXT:        Name:            __wasm_call_ctors
 ; CHECK-NEXT: ...

test/wasm/init-fini.ll

 ; RUN: llc -mtriple=wasm32-unknown-unknown-wasm -filetype=obj -o %t.o %s
 ; RUN: llc -mtriple=wasm32-unknown-unknown-wasm -filetype=obj %S/Inputs/global-ctor-dtor.ll -o %t.global-ctor-dtor.o
 
 define hidden void @func1() {
 entry:
   ret void
 }
 
 define hidden void @func2() {
 entry:
   ret void
 }
 
+define hidden void @func3() {
+entry:
+  ret void
+}
+
+define hidden void @func4() {
+entry:
+  ret void
+}
+
 define void @__cxa_atexit() {
   ret void
 }
 
 define hidden 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 }]
[e-mail]_ctors = appending global [3 x { i32, void ()*, i8* }] [
+  { i32, void ()*, i8* } { i32 1001, void ()* @func1, i8* null },
+  { i32, void ()*, i8* } { i32 101, void ()* @func1, i8* null },
+  { i32, void ()*, i8* } { i32 101, void ()* @func2, i8* null }
+]
+
[e-mail]_dtors = appending global [3 x { i32, void ()*, i8* }] [
+  { i32, void ()*, i8* } { i32 1001, void ()* @func3, i8* null },
+  { i32, void ()*, i8* } { i32 101, void ()* @func3, i8* null },
+  { i32, void ()*, i8* } { i32 101, void ()* @func4, i8* null }
+]
 
 ; RUN: lld -flavor wasm %t.o %t.global-ctor-dtor.o -o %t.wasm
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
-; CHECK:          Name:            linking
+; CHECK:        - Type:            ELEM
+; CHECK-NEXT:     Segments:        
+; CHECK-NEXT:       - Offset:          
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           1
+; CHECK-NEXT:         Functions:       [ 6, 9, 13, 15, 17 ]
+
+; CHECK:              Body:            100010011007100B100E100B10101000100A100B10120B
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        0
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:   
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            func1
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            func2
 ; CHECK-NEXT:       - Index:           2
-; CHECK-NEXT:         Name:            __cxa_atexit
+; CHECK-NEXT:         Name:            func3
 ; CHECK-NEXT:       - Index:           3
-; CHECK-NEXT:         Name:            _start
+; CHECK-NEXT:         Name:            func4
 ; CHECK-NEXT:       - Index:           4
-; CHECK-NEXT:         Name:            .Lcall_dtors
+; CHECK-NEXT:         Name:            __cxa_atexit
 ; CHECK-NEXT:       - Index:           5
-; CHECK-NEXT:         Name:            .Lregister_call_dtors
+; CHECK-NEXT:         Name:            _start
 ; CHECK-NEXT:       - Index:           6
-; CHECK-NEXT:         Name:            .Lbitcast
+; CHECK-NEXT:         Name:            .Lcall_dtors.101
 ; CHECK-NEXT:       - Index:           7
-; CHECK-NEXT:         Name:            myctor
+; CHECK-NEXT:         Name:            .Lregister_call_dtors.101
 ; CHECK-NEXT:       - Index:           8
-; CHECK-NEXT:         Name:            mydtor
+; CHECK-NEXT:         Name:            .Lbitcast
 ; CHECK-NEXT:       - Index:           9
-; CHECK-NEXT:         Name:            .Lcall_dtors
+; CHECK-NEXT:         Name:            .Lcall_dtors.1001
 ; CHECK-NEXT:       - Index:           10
-; CHECK-NEXT:         Name:            .Lregister_call_dtors
+; CHECK-NEXT:         Name:            .Lregister_call_dtors.1001
+; CHECK-NEXT:       - Index:           11
+; CHECK-NEXT:         Name:            myctor
+; CHECK-NEXT:       - Index:           12
+; CHECK-NEXT:         Name:            mydtor
+; CHECK-NEXT:       - Index:           13
+; CHECK-NEXT:         Name:            .Lcall_dtors.101
+; CHECK-NEXT:       - Index:           14
+; CHECK-NEXT:         Name:            .Lregister_call_dtors.101
+; CHECK-NEXT:       - Index:           15
+; CHECK-NEXT:         Name:            .Lcall_dtors.202
+; CHECK-NEXT:       - Index:           16
+; CHECK-NEXT:         Name:            .Lregister_call_dtors.202
+; CHECK-NEXT:       - Index:           17
+; CHECK-NEXT:         Name:            .Lcall_dtors.2002
+; CHECK-NEXT:       - Index:           18
+; CHECK-NEXT:         Name:            .Lregister_call_dtors.2002
+; CHECK-NEXT:       - Index:           19
+; CHECK-NEXT:         Name:            __wasm_call_ctors
 ; CHECK-NEXT: ...
 
 
 ; RUN: lld -flavor wasm -r %t.o %t.global-ctor-dtor.o -o %t.reloc.wasm
 ; RUN: obj2yaml %t.reloc.wasm | FileCheck -check-prefix=RELOC %s
 
 ; RELOC:          Name:            linking
 ; RELOC-NEXT:     DataSize:        0
 ; RELOC-NEXT:     InitFunctions:   
-; RELOC-NEXT:       - Priority:        65535
+; RELOC-NEXT:       - Priority:        101
 ; RELOC-NEXT:         FunctionIndex:   0
-; RELOC-NEXT:       - Priority:        65535
-; RELOC-NEXT:         FunctionIndex:   5
-; RELOC-NEXT:       - Priority:        65535
+; RELOC-NEXT:       - Priority:        101
+; RELOC-NEXT:         FunctionIndex:   1
+; RELOC-NEXT:       - Priority:        101
 ; RELOC-NEXT:         FunctionIndex:   7
-; RELOC-NEXT:       - Priority:        65535
+; RELOC-NEXT:       - Priority:        101
+; RELOC-NEXT:         FunctionIndex:   11
+; RELOC-NEXT:       - Priority:        101
+; RELOC-NEXT:         FunctionIndex:   14
+; RELOC-NEXT:       - Priority:        202
+; RELOC-NEXT:         FunctionIndex:   11
+; RELOC-NEXT:       - Priority:        202
+; RELOC-NEXT:         FunctionIndex:   16
+; RELOC-NEXT:       - Priority:        1001
+; RELOC-NEXT:         FunctionIndex:   0
+; RELOC-NEXT:       - Priority:        1001
 ; RELOC-NEXT:         FunctionIndex:   10
+; RELOC-NEXT:       - Priority:        2002
+; RELOC-NEXT:         FunctionIndex:   11
+; RELOC-NEXT:       - Priority:        2002
+; RELOC-NEXT:         FunctionIndex:   18
 ; RELOC-NEXT:   - Type:            CUSTOM
 ; RELOC-NEXT:     Name:            name
 ; RELOC-NEXT:     FunctionNames:   
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Name:            func1
 ; RELOC-NEXT:       - Index:           1
 ; RELOC-NEXT:         Name:            func2
 ; RELOC-NEXT:       - Index:           2
-; RELOC-NEXT:         Name:            __cxa_atexit
+; RELOC-NEXT:         Name:            func3
 ; RELOC-NEXT:       - Index:           3
-; RELOC-NEXT:         Name:            _start
+; RELOC-NEXT:         Name:            func4
 ; RELOC-NEXT:       - Index:           4
-; RELOC-NEXT:         Name:            .Lcall_dtors
+; RELOC-NEXT:         Name:            __cxa_atexit
 ; RELOC-NEXT:       - Index:           5
-; RELOC-NEXT:         Name:            .Lregister_call_dtors
+; RELOC-NEXT:         Name:            _start
 ; RELOC-NEXT:       - Index:           6
-; RELOC-NEXT:         Name:            .Lbitcast
+; RELOC-NEXT:         Name:            .Lcall_dtors.101
 ; RELOC-NEXT:       - Index:           7
-; RELOC-NEXT:         Name:            myctor
+; RELOC-NEXT:         Name:            .Lregister_call_dtors.101
 ; RELOC-NEXT:       - Index:           8
-; RELOC-NEXT:         Name:            mydtor
+; RELOC-NEXT:         Name:            .Lbitcast
 ; RELOC-NEXT:       - Index:           9
-; RELOC-NEXT:         Name:            .Lcall_dtors
+; RELOC-NEXT:         Name:            .Lcall_dtors.1001
 ; RELOC-NEXT:       - Index:           10
-; RELOC-NEXT:         Name:            .Lregister_call_dtors
+; RELOC-NEXT:         Name:            .Lregister_call_dtors.1001
+; RELOC-NEXT:       - Index:           11
+; RELOC-NEXT:         Name:            myctor
+; RELOC-NEXT:       - Index:           12
+; RELOC-NEXT:         Name:            mydtor
+; RELOC-NEXT:       - Index:           13
+; RELOC-NEXT:         Name:            .Lcall_dtors.101
+; RELOC-NEXT:       - Index:           14
+; RELOC-NEXT:         Name:            .Lregister_call_dtors.101
+; RELOC-NEXT:       - Index:           15
+; RELOC-NEXT:         Name:            .Lcall_dtors.202
+; RELOC-NEXT:       - Index:           16
+; RELOC-NEXT:         Name:            .Lregister_call_dtors.202
+; RELOC-NEXT:       - Index:           17
+; RELOC-NEXT:         Name:            .Lcall_dtors.2002
+; RELOC-NEXT:       - Index:           18
+; RELOC-NEXT:         Name:            .Lregister_call_dtors.2002
 ; RELOC-NEXT: ...

test/wasm/local-symbols.ll

 ; CHECK-NEXT: FileHeader:
 ; CHECK-NEXT:   Version:         0x00000001
 ; CHECK-NEXT: Sections:
 ; CHECK-NEXT:   - Type:            TYPE
 ; CHECK-NEXT:     Signatures:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         ReturnType:      I32
 ; CHECK-NEXT:         ParamTypes:
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         ReturnType:      NORESULT
+; CHECK-NEXT:         ParamTypes:   
 ; CHECK-NEXT:   - Type:            FUNCTION
-; CHECK-NEXT:     FunctionTypes:   [ 0, 0 ]
+; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 1 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:
 ; CHECK-NEXT:       - ElemType:        ANYFUNC
 ; CHECK-NEXT:         Limits:
 ; CHECK-NEXT:           Flags:           [ HAS_MAX ]
 ; CHECK-NEXT:           Initial:         0x00000001
 ; CHECK-NEXT:           Maximum:         0x00000001
 ; CHECK-NEXT:   - Type:            MEMORY

 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Functions:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            41020B
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            41010B
+; CHECK-NEXT:       - Index:           2
+; 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:         '0100000003000000'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        8
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            baz
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            _start
+; CHECK-NEXT:       - Index:           2
+; CHECK-NEXT:         Name:            __wasm_call_ctors
 ; CHECK-NEXT: ...

test/wasm/stack-pointer.ll

 ; CHECK-NEXT: FileHeader:
 ; CHECK-NEXT:   Version:         0x00000001
 ; CHECK-NEXT: Sections:
 ; CHECK-NEXT:   - Type:            TYPE
 ; CHECK-NEXT:     Signatures:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         ReturnType:      I32
 ; CHECK-NEXT:         ParamTypes:
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         ReturnType:      NORESULT
+; CHECK-NEXT:         ParamTypes:   
 ; CHECK-NEXT:   - Type:            FUNCTION
-; CHECK-NEXT:     FunctionTypes:   [ 0 ]
+; CHECK-NEXT:     FunctionTypes:   [ 0, 1 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:
 ; CHECK-NEXT:       - ElemType:        ANYFUNC
 ; CHECK-NEXT:         Limits:
 ; CHECK-NEXT:           Flags:           [ HAS_MAX ]
 ; CHECK-NEXT:           Initial:         0x00000001
 ; CHECK-NEXT:           Maximum:         0x00000001
 ; CHECK-NEXT:   - Type:            MEMORY

 ; 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
+; CHECK-NEXT:       - Name:            __wasm_call_ctors
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Relocations:
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_INDEX_LEB
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Offset:          0x00000004
 ; CHECK-NEXT:     Functions:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            23808080800041106B1A41000B
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         Locals:
+; CHECK-NEXT:         Body:            0B
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        0
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            _start
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         Name:            __wasm_call_ctors
 ; CHECK-NEXT: ...

test/wasm/weak-alias-overide.ll

 ; CHECK-NEXT:     Signatures:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         ReturnType:      I32
 ; CHECK-NEXT:         ParamTypes:
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         ReturnType:      NORESULT
 ; CHECK-NEXT:         ParamTypes:
 ; CHECK-NEXT:   - Type:            FUNCTION
-; CHECK-NEXT:     FunctionTypes:   [ 0, 1, 0, 0, 0, 0, 0 ]
+; CHECK-NEXT:     FunctionTypes:   [ 0, 1, 0, 0, 0, 0, 0, 1 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:
 ; CHECK-NEXT:       - ElemType:        ANYFUNC
 ; CHECK-NEXT:         Limits:
 ; CHECK-NEXT:           Flags:           [ HAS_MAX ]
 ; CHECK-NEXT:           Initial:         0x00000003
 ; CHECK-NEXT:           Maximum:         0x00000003
 ; CHECK-NEXT:   - Type:            MEMORY

 ; CHECK-NEXT:           - Type:            I32
 ; CHECK-NEXT:             Count:           2
 ; CHECK-NEXT:         Body:            23808080800041106B220024808080800020004181808080003602081080808080002101200041106A24808080800020010B
 ; CHECK-NEXT:       - Index:           6
 ; CHECK-NEXT:         Locals:          
 ; CHECK-NEXT:           - Type:            I32
 ; CHECK-NEXT:             Count:           2
 ; CHECK-NEXT:         Body:            23808080800041106B220024808080800020004182808080003602081082808080002101200041106A24808080800020010B
+; CHECK-NEXT:       - Index:           7
+; CHECK-NEXT:         Locals:
+; CHECK-NEXT:         Body:            0B
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        0
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            alias_fn
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            _start
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            direct_fn
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Name:            call_direct
 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Name:            call_alias
 ; CHECK-NEXT:       - Index:           5
 ; CHECK-NEXT:         Name:            call_alias_ptr
 ; CHECK-NEXT:       - Index:           6
 ; CHECK-NEXT:         Name:            call_direct_ptr
+; CHECK-NEXT:       - Index:           7
+; CHECK-NEXT:         Name:            __wasm_call_ctors
 ; CHECK-NEXT: ...

test/wasm/weak-alias.ll

 ; CHECK-NEXT: FileHeader:
 ; CHECK-NEXT:   Version:         0x00000001
 ; CHECK-NEXT: Sections:
 ; CHECK-NEXT:   - Type:            TYPE
 ; CHECK-NEXT:     Signatures:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         ReturnType:      I32
 ; CHECK-NEXT:         ParamTypes:
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         ReturnType:      NORESULT
+; CHECK-NEXT:         ParamTypes:   
 ; CHECK-NEXT:   - Type:            FUNCTION
-; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 0, 0, 0, 0 ]
+; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 0, 0, 0, 0, 1 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:
 ; CHECK-NEXT:       - ElemType:        ANYFUNC
 ; CHECK-NEXT:         Limits:
 ; CHECK-NEXT:           Flags:           [ HAS_MAX ]
 ; CHECK-NEXT:           Initial:         0x00000003
 ; CHECK-NEXT:           Maximum:         0x00000003
 ; CHECK-NEXT:   - Type:            MEMORY

 ; CHECK-NEXT:           - Type:            I32
 ; CHECK-NEXT:             Count:           2
 ; CHECK-NEXT:         Body:            23808080800041106B220024808080800020004181808080003602081081808080002101200041106A24808080800020010B
 ; CHECK-NEXT:       - Index:           5
 ; CHECK-NEXT:         Locals:          
 ; CHECK-NEXT:           - Type:            I32
 ; CHECK-NEXT:             Count:           2
 ; CHECK-NEXT:         Body:            23808080800041106B220024808080800020004182808080003602081081808080002101200041106A24808080800020010B
+; CHECK-NEXT:       - Index:           6
+; CHECK-NEXT:         Locals:
+; CHECK-NEXT:         Body:            0B
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        0
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            _start
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            direct_fn
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            call_direct
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Name:            call_alias
 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Name:            call_alias_ptr
 ; CHECK-NEXT:       - Index:           5
 ; CHECK-NEXT:         Name:            call_direct_ptr
+; CHECK-NEXT:       - Index:           6
+; CHECK-NEXT:         Name:            __wasm_call_ctors
 ; CHECK-NEXT: ...

test/wasm/weak-symbols.ll

 ; CHECK-NEXT: FileHeader:
 ; CHECK-NEXT:   Version:         0x00000001
 ; CHECK-NEXT: Sections:
 ; CHECK-NEXT:   - Type:            TYPE
 ; CHECK-NEXT:     Signatures:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         ReturnType:      I32
 ; CHECK-NEXT:         ParamTypes:
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         ReturnType:      NORESULT
+; CHECK-NEXT:         ParamTypes:   
 ; CHECK-NEXT:   - Type:            FUNCTION
-; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 0, 0, 0 ]
+; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 0, 0, 0, 1 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:
 ; CHECK-NEXT:       - ElemType:        ANYFUNC
 ; CHECK-NEXT:         Limits:
 ; CHECK-NEXT:           Flags:           [ HAS_MAX ]
 ; CHECK-NEXT:           Initial:         0x00000002
 ; CHECK-NEXT:           Maximum:         0x00000002
 ; CHECK-NEXT:   - Type:            MEMORY

 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4181808080000B
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            41020B
 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4181808080000B
+; CHECK-NEXT:       - Index:           5
+; 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:         '0100000002000000'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        8
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            _start
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            exportWeak1
 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Name:            exportWeak2
+; CHECK-NEXT:       - Index:           5
+; CHECK-NEXT:         Name:            __wasm_call_ctors
 ; CHECK-NEXT: ...

test/wasm/weak-undefined.ll

 ; CHECK-NEXT: FileHeader:
 ; CHECK-NEXT:   Version:         0x00000001
 ; CHECK-NEXT: Sections:
 ; CHECK-NEXT:   - Type:            TYPE
 ; CHECK-NEXT:     Signatures:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         ReturnType:      I32
 ; CHECK-NEXT:         ParamTypes:
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         ReturnType:      NORESULT
+; CHECK-NEXT:         ParamTypes:   
 ; CHECK-NEXT:   - Type:            FUNCTION
-; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 0 ]
+; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 0, 1 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:
 ; CHECK-NEXT:       - ElemType:        ANYFUNC
 ; CHECK-NEXT:         Limits:
 ; CHECK-NEXT:           Flags:           [ HAS_MAX ]
 ; CHECK-NEXT:           Initial:         0x00000001
 ; CHECK-NEXT:           Maximum:         0x00000001
 ; CHECK-NEXT:   - Type:            MEMORY

 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4180808080000B
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4180808080000B
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4100280280808080000B
+; CHECK-NEXT:       - Index:           3
+; CHECK-NEXT:         Locals:
+; CHECK-NEXT:         Body:            0B
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        0
 ; CHECK-NEXT: ...

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 *CtorSymbol = nullptr;
 };
 
 // The only instance of Configuration struct.
 extern Configuration *Config;
 
 } // namespace wasm
 } // namespace lld
 
 #endif

wasm/Driver.cpp

if (!Args.hasArg(OPT_INPUT))
     error("no input files");
 
   if (Config->Relocatable && !Config->Entry.empty())
     error("entry point specified for relocatable output file");
   if (Config->Relocatable && Args.hasArg(OPT_undefined))
     error("undefined symbols specified for relocatable output file");
 
   if (!Config->Relocatable) {
-    if (!Config->Entry.empty()) {
-      static WasmSignature Signature = {{}, WASM_TYPE_NORESULT};
+    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->CtorSymbol = Symtab->addDefinedFunction(
+        "__wasm_call_ctors", &Signature, WASM_SYMBOL_VISIBILITY_HIDDEN);
     Config->StackPointerSymbol = Symtab->addDefinedGlobal("__stack_pointer");
   }
 
   createFiles(Args);
   if (errorCount())
     return;
 
   // Add all files to the symbol table. This will add almost all

wasm/InputChunks.h

void setOutputOffset(uint32_t Offset) {
     calcRelocations();
   }
 
   uint32_t getOutputOffset() const { return OutputOffset; }
 
   std::vector<OutputRelocation> OutRelocations;
 
 protected:
-  InputChunk(const ObjFile &F) : File(F) {}
+  InputChunk(const ObjFile *F) : File(F) {}
   virtual ~InputChunk() = default;
   void calcRelocations();
   virtual const uint8_t *getData() const = 0;
   virtual uint32_t getInputSectionOffset() const = 0;
 
   std::vector<WasmRelocation> Relocations;
   int32_t OutputOffset = 0;
-  const ObjFile &File;
+  const ObjFile *File;
 };
 
 // Represents a WebAssembly data segment which can be included as part of
 // an output data segments.  Note that in WebAssembly, unlike ELF and other
 // formats, used the term "data segment" to refer to the continous regions of
 // memory that make on the data section. See:
 // https://webassembly.github.io/spec/syntax/modules.html#syntax-data
 //
 // For example, by default, clang will produce a separate data section for
 // each global variable.
 class InputSegment : public InputChunk {
 public:
-  InputSegment(const WasmSegment &Seg, const ObjFile &F)
+  InputSegment(const WasmSegment &Seg, const ObjFile *F)
       : InputChunk(F), Segment(Seg) {}
 
   // Translate an offset in the input segment to an offset in the output
   // segment.
   uint32_t translateVA(uint32_t Address) const;
 
   const OutputSegment *getOutputSegment() const { return OutputSeg; }
 
protected:
   const WasmSegment &Segment;
   const OutputSegment *OutputSeg = nullptr;
 };
 
 // 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,
-                const ObjFile &F)
+  InputFunction(const WasmSignature &S, const WasmFunction *Func,
+                const ObjFile *F)
       : InputChunk(F), Signature(S), WrittenToNameSec(false), Function(Func) {}
 
-  uint32_t getSize() const override { return Function.Size; }
+  uint32_t getSize() const override { return Function->Size; }
   const uint8_t *getData() const override {
-    return File.CodeSection->Content.data() + getInputSectionOffset();
+    return File->CodeSection->Content.data() + getInputSectionOffset();
   }
 
   uint32_t getOutputIndex() const { return OutputIndex.getValue(); };
   bool hasOutputIndex() const { return OutputIndex.hasValue(); };
-  void setOutputIndex(uint32_t Index) {
-    assert(!hasOutputIndex());
-    OutputIndex = Index;
-  };
+  void setOutputIndex(uint32_t Index);
 
   const WasmSignature &Signature;
 
   unsigned WrittenToNameSec : 1;
 
 protected:
   uint32_t getInputSectionOffset() const override {
-    return Function.CodeSectionOffset;
+    return Function->CodeSectionOffset;
   }
-  const WasmFunction &Function;
+  const WasmFunction *Function;
   llvm::Optional<uint32_t> OutputIndex;
 };
 
+class SyntheticFunction : public InputFunction {
+public:
+  SyntheticFunction(const WasmSignature &S, StringRef Body)
+      : InputFunction(S, nullptr, nullptr), Body(Body) {}
+
+  uint32_t getSize() const override { return Body.size(); }
+  const uint8_t *getData() const override {
+    return reinterpret_cast<const uint8_t *>(Body.data());
+  }
+
+protected:
+  StringRef Body;
+};
+
 } // namespace wasm
 } // namespace lld
 
 #endif // LLD_WASM_INPUT_CHUNKS_H

wasm/InputChunks.cpp

uint32_t InputSegment::translateVA(uint32_t Address) const {
   assert(Address >= startVA() && Address < endVA());
   int32_t Delta = OutputSeg->StartVA + OutputSegmentOffset - startVA();
   DEBUG(dbgs() << "translateVA: " << getName() << " Delta=" << Delta
                << " Address=" << Address << "\n");
   return Address + Delta;
 }
 
 void InputChunk::copyRelocations(const WasmSection &Section) {
+  if (Section.Relocations.empty())
+    return;
   size_t Start = getInputSectionOffset();
   size_t Size = getSize();
   for (const WasmRelocation &R : Section.Relocations)
     if (R.Offset >= Start && R.Offset < Start + Size)
       Relocations.push_back(R);
 }
 
 static void applyRelocation(uint8_t *Buf, const OutputRelocation &Reloc) {
void InputChunk::writeTo(uint8_t *SectionStart) const {
   memcpy(SectionStart + getOutputOffset(), getData(), getSize());
   applyRelocations(SectionStart, OutRelocations);
 }
 
 // Populate OutRelocations based on the input relocations and offset within the
 // output section.  Calculates the updated index and offset for each relocation
 // as well as the value to write out in the final binary.
 void InputChunk::calcRelocations() {
+  if (Relocations.empty())
+    return;
   int32_t Off = getOutputOffset() - getInputSectionOffset();
-  DEBUG(dbgs() << "calcRelocations: " << File.getName()
+  DEBUG(dbgs() << "calcRelocations: " << File->getName()
                << " offset=" << Twine(Off) << "\n");
   for (const WasmRelocation &Reloc : Relocations) {
     OutputRelocation NewReloc;
     NewReloc.Reloc = Reloc;
     assert(Reloc.Offset + Off > 0);
     NewReloc.Reloc.Offset += Off;
     DEBUG(dbgs() << "reloc: type=" << Reloc.Type << " index=" << Reloc.Index
                  << " offset=" << Reloc.Offset
                  << " newOffset=" << NewReloc.Reloc.Offset << "\n");
 
     if (Config->EmitRelocs)
-      NewReloc.NewIndex = File.calcNewIndex(Reloc);
+      NewReloc.NewIndex = File->calcNewIndex(Reloc);
 
     switch (Reloc.Type) {
     case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
     case R_WEBASSEMBLY_MEMORY_ADDR_I32:
     case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
-      NewReloc.Value = File.getRelocatedAddress(Reloc.Index) + Reloc.Addend;
+      NewReloc.Value = File->getRelocatedAddress(Reloc.Index) + Reloc.Addend;
       break;
     default:
-      NewReloc.Value = File.calcNewIndex(Reloc);
+      NewReloc.Value = File->calcNewIndex(Reloc);
       break;
     }
 
     OutRelocations.emplace_back(NewReloc);
   }
 }
+
+void InputFunction::setOutputIndex(uint32_t Index) {
+  DEBUG(dbgs() << "InputFunction::setOutputIndex: " << Index << "\n");
+  assert(!hasOutputIndex());
+  OutputIndex = Index;
+};

wasm/InputFiles.cpp

case WASM_EXTERNAL_GLOBAL:
       break;
     }
   }
 
   FunctionSymbols.resize(NumFunctionImports + WasmObj->functions().size());
   GlobalSymbols.resize(NumGlobalImports + WasmObj->globals().size());
 
   for (const WasmSegment &S : WasmObj->dataSegments()) {
-    InputSegment *Seg = make<InputSegment>(S, *this);
+    InputSegment *Seg = make<InputSegment>(S, this);
     Seg->copyRelocations(*DataSection);
     Segments.emplace_back(Seg);
   }
 
   ArrayRef<WasmFunction> Funcs = WasmObj->functions();
   ArrayRef<uint32_t> FuncTypes = WasmObj->functionTypes();
   ArrayRef<WasmSignature> Types = WasmObj->types();
   for (size_t I = 0; I < Funcs.size(); ++I) {
     const WasmFunction &Func = Funcs[I];
     const WasmSignature &Sig = Types[FuncTypes[I]];
-    InputFunction *F = make<InputFunction>(Sig, Func, *this);
+    InputFunction *F = make<InputFunction>(Sig, &Func, this);
     F->copyRelocations(*CodeSection);
     Functions.emplace_back(F);
   }
 
   // Populate `FunctionSymbols` and `GlobalSymbols` based on the WasmSymbols
   // in the object
   for (const SymbolRef &Sym : WasmObj->symbols()) {
     const WasmSymbol &WasmSym = WasmObj->getWasmSymbol(Sym.getRawDataRefImpl());
case WasmSymbol::SymbolType::FUNCTION_EXPORT:
       break;
     case WasmSymbol::SymbolType::DEBUG_FUNCTION_NAME:
       // These are for debugging only, no need to create linker symbols for them
       continue;
     }
 
     Symbols.push_back(S);
     if (WasmSym.isFunction()) {
-      DEBUG(dbgs() << "Function: " << WasmSym.ElementIndex << " -> "
-                   << toString(*S) << "\n");
       FunctionSymbols[WasmSym.ElementIndex] = S;
       if (WasmSym.HasAltIndex)
         FunctionSymbols[WasmSym.AltIndex] = S;
     } else {
-      DEBUG(dbgs() << "Global: " << WasmSym.ElementIndex << " -> "
-                   << toString(*S) << "\n");
       GlobalSymbols[WasmSym.ElementIndex] = S;
       if (WasmSym.HasAltIndex)
         GlobalSymbols[WasmSym.AltIndex] = S;
     }
   }
 
   DEBUG(for (size_t I = 0; I < FunctionSymbols.size(); ++I)
             assert(FunctionSymbols[I] != nullptr);

wasm/SymbolTable.h

public:
 
   Symbol *addDefined(StringRef Name, Symbol::Kind Kind, uint32_t Flags,
                      InputFile *F, const InputSegment *Segment = nullptr,
                      InputFunction *Function = nullptr, uint32_t Address = 0);
   Symbol *addUndefined(StringRef Name, Symbol::Kind Kind, uint32_t Flags,
                        InputFile *F, const WasmSignature *Signature = nullptr);
   Symbol *addUndefinedFunction(StringRef Name, const WasmSignature *Type);
   Symbol *addDefinedGlobal(StringRef Name);
+  Symbol *addDefinedFunction(StringRef Name, const WasmSignature *Type,
+                             uint32_t Flags);
   void addLazy(ArchiveFile *F, const Archive::Symbol *Sym);
 
 private:
   std::pair<Symbol *, bool> insert(StringRef Name);
 
   llvm::DenseMap<llvm::CachedHashStringRef, Symbol *> SymMap;
   std::vector<Symbol *> SymVector;
 };
 
 extern SymbolTable *Symtab;
 
 } // namespace wasm
 } // namespace lld
 
 #endif

wasm/SymbolTable.cpp

if (*NewSig == OldSig)
     return;
 
   error("function signature mismatch: " + Existing.getName() +
         "\n>>> defined as " + toString(OldSig) + " in " +
         toString(Existing.getFile()) + "\n>>> defined as " + toString(*NewSig) +
         " in " + F.getName());
 }
 
+Symbol *SymbolTable::addDefinedFunction(StringRef Name,
+                                        const WasmSignature *Type,
+                                        uint32_t Flags) {
+  DEBUG(dbgs() << "addDefinedFunction: " << Name << "\n");
+  Symbol *S;
+  bool WasInserted;
+  std::tie(S, WasInserted) = insert(Name);
+  if (WasInserted) {
+    S->update(Symbol::DefinedFunctionKind, nullptr, Flags);
+    S->setFunctionType(Type);
+  } else if (!S->isFunction()) {
+    error("symbol type mismatch: " + Name);
+  }
+  return S;
+}
+
 Symbol *SymbolTable::addDefinedGlobal(StringRef Name) {
   DEBUG(dbgs() << "addDefinedGlobal: " << Name << "\n");
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
   if (WasInserted)
     S->update(Symbol::DefinedGlobalKind);
   else if (!S->isGlobal())

wasm/Writer.cpp

 //===- Writer.cpp ---------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Writer.h"
 
+#include "llvm/ADT/DenseSet.h"
 #include "Config.h"
 #include "InputChunks.h"
 #include "OutputSections.h"
 #include "OutputSegment.h"
 #include "SymbolTable.h"
 #include "WriterUtils.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"

 public:
   void run();
 
 private:
   void openFile();
 
   uint32_t lookupType(const WasmSignature &Sig);
   uint32_t registerType(const WasmSignature &Sig);
+  void createCtorFunction();
+  void calculateInitFunctions();
   void assignIndexes();
   void calculateImports();
   void calculateOffsets();
   void calculateTypes();
   void createOutputSegments();
   void layoutMemory();
   void createHeader();
   void createSections();
private:
 
   std::vector<const WasmSignature *> Types;
   DenseMap<WasmSignature, int32_t, WasmSignatureDenseMapInfo> TypeIndices;
   std::vector<const Symbol *> ImportedFunctions;
   std::vector<const Symbol *> ImportedGlobals;
   std::vector<const Symbol *> DefinedGlobals;
   std::vector<InputFunction *> DefinedFunctions;
   std::vector<const Symbol *> IndirectFunctions;
+  std::vector<WasmInitFunc> InitFunctions;
 
   // Elements that are used to construct the final output
   std::string Header;
   std::vector<OutputSection *> OutputSections;
 
   std::unique_ptr<FileOutputBuffer> Buffer;
+  std::unique_ptr<SyntheticFunction> CtorFunction;
+  std::string CtorFunctionBody;
 
   std::vector<OutputSegment *> Segments;
   llvm::SmallDenseMap<StringRef, OutputSegment *> SegmentMap;
 };
 
 } // anonymous namespace
 
 static void debugPrint(const char *fmt, ...) {
for (const OutputSegment *S : Segments) {
       writeStr(SubSection.getStream(), S->Name, "segment name");
       writeUleb128(SubSection.getStream(), S->Alignment, "alignment");
       writeUleb128(SubSection.getStream(), 0, "flags");
     }
     SubSection.finalizeContents();
     SubSection.writeToStream(OS);
   }
 
-  std::vector<WasmInitFunc> InitFunctions;
-  for (ObjFile *File : Symtab->ObjectFiles) {
-    const WasmLinkingData &L = File->getWasmObj()->linkingData();
-    InitFunctions.reserve(InitFunctions.size() + L.InitFunctions.size());
-    for (const WasmInitFunc &F : L.InitFunctions)
-      InitFunctions.emplace_back(WasmInitFunc{
-          F.Priority, File->relocateFunctionIndex(F.FunctionIndex)});
-  }
-
   if (!InitFunctions.empty()) {
     SubSection SubSection(WASM_INIT_FUNCS);
     writeUleb128(SubSection.getStream(), InitFunctions.size(),
                  "num init functionsw");
     for (const WasmInitFunc &F : InitFunctions) {
       writeUleb128(SubSection.getStream(), F.Priority, "priority");
       writeUleb128(SubSection.getStream(), F.FunctionIndex, "function index");
     }
     SubSection.finalizeContents();
     SubSection.writeToStream(OS);
   }
 }
 
 // Create the custom "name" section containing debug symbol names.
 void Writer::createNameSection() {
   // Create an array of all function sorted by function index space
   std::vector<const Symbol *> Names;
 
-  for (ObjFile *File : Symtab->ObjectFiles) {
-    Names.reserve(Names.size() + File->getSymbols().size());
-    for (Symbol *S : File->getSymbols()) {
-      if (!S->isFunction() || S->isWeak() || S->WrittenToNameSec)
-        continue;
-      // We also need to guard against two different symbols (two different
-      // names) for the same wasm function.  While this is possible (aliases)
-      // it is not legal in the "name" section.
-      InputFunction *Function = S->getFunction();
-      if (Function) {
-        if (Function->WrittenToNameSec)
-          continue;
-        Function->WrittenToNameSec = true;
-      }
-      S->WrittenToNameSec = true;
-      Names.emplace_back(S);
+  auto AddToNames = [&](Symbol* S) {
+    if (!S->isFunction() || S->WrittenToNameSec)
+        return;
+        return;
+  };
+
+  for (ObjFile *File : Symtab->ObjectFiles) {
+    Names.reserve(Names.size() + File->getSymbols().size());
+    DEBUG(dbgs() << "adding names from: " << File->getName() << "\n");
+    for (Symbol *S : File->getSymbols()) {
+      if (S->isWeak())
+        continue;
+      AddToNames(S);
     }
   }
 
+  DEBUG(dbgs() << "adding symtab names\n");
+  for (Symbol *S : Symtab->getSymbols()) {
+    DEBUG(dbgs() << "sym: " << S->getName() << "\n");
+    if (S->getFile())
+      continue;
+    AddToNames(S);
+  }
+
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_CUSTOM, "name");
 
   std::sort(Names.begin(), Names.end(), [](const Symbol *A, const Symbol *B) {
     return A->getOutputIndex() < B->getOutputIndex();
   });
 
   SubSection FunctionSubsection(WASM_NAMES_FUNCTION);
   raw_ostream &OS = FunctionSubsection.getStream();

 }
 
 void Writer::calculateTypes() {
   for (ObjFile *File : Symtab->ObjectFiles) {
     File->TypeMap.reserve(File->getWasmObj()->types().size());
     for (const WasmSignature &Sig : File->getWasmObj()->types())
       File->TypeMap.push_back(registerType(Sig));
   }
+
+  for (Symbol *Sym : Symtab->getSymbols())
+    if (Sym->isFunction())
+      registerType(Sym->getFunctionType());
 }
 
 void Writer::assignIndexes() {
-  uint32_t GlobalIndex = ImportedGlobals.size();
-  uint32_t FunctionIndex = ImportedFunctions.size();
+  uint32_t GlobalIndex = ImportedGlobals.size() + DefinedGlobals.size();
+  uint32_t FunctionIndex = ImportedFunctions.size() + DefinedFunctions.size();
 
   if (Config->StackPointerSymbol) {
     DefinedGlobals.emplace_back(Config->StackPointerSymbol);
     Config->StackPointerSymbol->setOutputIndex(GlobalIndex++);
   }
 
   if (Config->EmitRelocs)
     DefinedGlobals.reserve(Symtab->getSymbols().size());
for (InputSegment *Segment : File->Segments) {
         Segments.push_back(S);
       }
       S->addInputSegment(Segment);
       DEBUG(dbgs() << "added data: " << Name << ": " << S->Size << "\n");
     }
   }
 }
 
+static const int OPCODE_CALL = 0x10;
+static const int OPCODE_END = 0xb;
+
+// Create synthetic "__wasm_call_ctors" function based on ctor functions
+// in input object.
+void Writer::createCtorFunction() {
+  uint32_t FunctionIndex = ImportedFunctions.size() + DefinedFunctions.size();
+  Config->CtorSymbol->setOutputIndex(FunctionIndex);
+
+  // First write the body bytes to a string.
+  std::string FunctionBody;
+  static WasmSignature Signature = {{}, WASM_TYPE_NORESULT};
+  {
+    raw_string_ostream OS(FunctionBody);
+    writeUleb128(OS, 0, "num locals");
+    for (const WasmInitFunc &F : InitFunctions) {
+      writeU8(OS, OPCODE_CALL, "CALL");
+      writeUleb128(OS, F.FunctionIndex, "function index");
+    }
+    writeU8(OS, OPCODE_END, "END");
+  }
+
+  // Once we know the size of the body we can create the final function body
+  raw_string_ostream OS(CtorFunctionBody);
+  writeUleb128(OS, FunctionBody.size(), "function size");
+  OS.flush();
+  CtorFunctionBody += FunctionBody;
+  CtorFunction =
+      llvm::make_unique<SyntheticFunction>(Signature, CtorFunctionBody);
+  DefinedFunctions.emplace_back(CtorFunction.get());
+}
+
+// Populate InitFunctions vector with init functions from all input objects.
+// This is then used either when creating the output linking section or to
+// synthesize the "__wasm_call_ctors" function.
+void Writer::calculateInitFunctions() {
+  for (ObjFile *File : Symtab->ObjectFiles) {
+    const WasmLinkingData &L = File->getWasmObj()->linkingData();
+    InitFunctions.reserve(InitFunctions.size() + L.InitFunctions.size());
+    for (const WasmInitFunc &F : L.InitFunctions)
+      InitFunctions.emplace_back(WasmInitFunc{
+          F.Priority, File->relocateFunctionIndex(F.FunctionIndex)});
+  }
+  // Sort in order of priority (lowest first) so that they are called
+  // in the correct order.
+  std::sort(InitFunctions.begin(), InitFunctions.end(),
+            [](const WasmInitFunc &L, const WasmInitFunc &R) {
+              return L.Priority < R.Priority;
+            });
+}
+
 void Writer::run() {
   if (!Config->Relocatable)
     InitialTableOffset = 1;
 
   log("-- calculateTypes");
   calculateTypes();
   log("-- calculateImports");
   calculateImports();
   log("-- assignIndexes");
   assignIndexes();
+  log("-- calculateInitFunctions");
+  calculateInitFunctions();
+  if (!Config->Relocatable)
+    createCtorFunction();
 
   if (errorHandler().Verbose) {
     log("Defined Functions: " + Twine(DefinedFunctions.size()));
     log("Defined Globals  : " + Twine(DefinedGlobals.size()));
     log("Function Imports : " + Twine(ImportedFunctions.size()));
     log("Global Imports   : " + Twine(ImportedGlobals.size()));
     log("Total Imports    : " +
         Twine(ImportedFunctions.size() + ImportedGlobals.size()));