[WebAssembly] Add symbol table to LLD, 2/2

[ncw]

Summary

WebAssembly object files will now have an explicit symbol table. This commit is the second of two halves, adding the actual symbol table itself.

The main changes are adding first-class support for Globals throughout the code as a third type of symbol, alongside existing Function/Data symbols, and Data symbols now no longer use Wasm globals in the intermediate format.

The end result is a bit more boilerplate, but a surprisingly nice reduction of complexity in the core logic, which becomes quite pleasingly neater.

Must be committed simultaneously with D42495, which adds symbol-table support to Clang/LLC.

[ncw]

Updated:

• Rebased on top of GC work
• Pulled out globals-COMDAT into another commit
• Pulled out some other preliminary changes into D42751

[ncw]

Updated: massaged text expectations for new YAML output

[ncw]

Updated: rebased, fixed a failing test after "calculateTypes" change affected the test expectations

[sbc100]

test/wasm/alias.ll

64 ↗

(On Diff #132356)

As discussed on IRC lets keep these exported globals in the executable output (just like we do for functions, no need to export in the relocatable output). Should make the diff smaller too I guess?

[ncw]

Rebased and addressed comments

test/wasm/alias.ll

64 ↗

(On Diff #132356)

OK, I've done that.

We now export a "fake" global specifically for the heap_base and data_end symbols.

Why not for all data symbols? Because actually these are the only "fake" globals that we're currently exporting in non-relocatable output.

As a follow-up commit, we can certainly add a fake-global for all data symbols.

[ncw]

Updated: no functional change, just tweak to fix build after removing Optional from BinaryFormat/Wasm.h

test/wasm/archive.ll

 ; RUN: llc -filetype=obj %s -o %t.o
 ; RUN: llc -filetype=obj %S/Inputs/archive1.ll -o %t.a1.o
 ; RUN: llc -filetype=obj %S/Inputs/archive2.ll -o %t.a2.o
 ; RUN: llc -filetype=obj %S/Inputs/hello.ll -o %t.a3.o
 ; RUN: llvm-ar rcs %t.a %t.a1.o %t.a2.o %t.a3.o
 ; RUN: rm -f %t.imports
 ; RUN: not lld -flavor wasm --check-signatures %t.a %t.o -o %t.wasm 2>&1 | FileCheck -check-prefix=CHECK-UNDEFINED %s
 
 ; CHECK-UNDEFINED: undefined symbol: missing_func
 
 ; RUN: echo 'missing_func' > %t.imports
-; RUN: lld -flavor wasm --check-signatures %t.a %t.o -o %t.wasm
+; RUN: lld -flavor wasm --check-signatures -r %t.a %t.o -o %t.wasm
 
 ; RUN: llvm-nm -a %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 declare i32 @foo() local_unnamed_addr #1
 declare i32 @missing_func() local_unnamed_addr #1
 
 define void @_start() local_unnamed_addr #0 {
 entry:
   %call1 = call i32 @foo() #2
   %call2 = call i32 @missing_func() #2
   ret void
 }
 
-; Verify that multually dependant object files in an archive is handled
-; correctly.
+; Verify that mutually dependant object files in an archive is handled
+; correctly.  Since we're using llvm-nm, we must link with --relocatable.
+;
+; TODO Udptae LLD so that the symbol table is written out for non-relocatable
+;   output (with an option to strip it)
 
 ; CHECK:      00000003 T _start
 ; CHECK-NEXT: 00000001 T bar
 ; CHECK-NEXT: 00000002 T foo
 ; CHECK-NEXT:          U missing_func
 
 ; Verify that symbols from unused objects don't appear in the symbol table
 ; CHECK-NOT: hello
 
 ; Specifying the same archive twice is allowed.
 ; RUN: lld -flavor wasm --check-signatures %t.a %t.a %t.o -o %t.wasm

test/wasm/data-layout.ll

 ; CHECK:        - Type:            GLOBAL
 ; CHECK-NEXT:     Globals:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Type:            I32
 ; CHECK-NEXT:         Mutable:         true
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           66608
-; CHECK-NEXT:       - Index:           1
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           66608
 
 ; CHECK:         - 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:         0100000000000000000000000000000003000000000000001C040000
 ; CHECK-NEXT:       - SectionOffset:   41
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1052
 ; CHECK-NEXT:         Content:         68656C6C6F0A00
 
 
 ; RUN: lld -flavor wasm --check-signatures --relocatable -o %t_reloc.wasm %t.o %t.hello.o
 ; RUN: obj2yaml %t_reloc.wasm | FileCheck %s -check-prefix=RELOC
 
-; RELOC:        - Type:            GLOBAL
-; RELOC-NEXT:     Globals:
-; RELOC-NEXT:       - Index:           0
-; RELOC-NEXT:         Type:            I32
-; RELOC-NEXT:         Mutable:         false
-; RELOC-NEXT:         InitExpr:
-; RELOC-NEXT:           Opcode:          I32_CONST
-; RELOC-NEXT:           Value:           0
-; RELOC-NEXT:       - Index:           1
-; RELOC-NEXT:         Type:            I32
-; RELOC-NEXT:         Mutable:         false
-; RELOC-NEXT:         InitExpr:
-; RELOC-NEXT:           Opcode:          I32_CONST
-; RELOC-NEXT:           Value:           16
-
 ; RELOC:       - Type:            DATA
 ; RELOC-NEXT:     Relocations:
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_I32
 ; RELOC-NEXT:         Index:           5
 ; RELOC-NEXT:         Offset:          0x00000018
 ; RELOC-NEXT:     Segments:
 ; RELOC-NEXT:       - SectionOffset:   6
 ; RELOC-NEXT:         MemoryIndex:     0

 ; RELOC-NEXT:         Content:         1C000000
 ; RELOC-NEXT:       - SectionOffset:   33
 ; RELOC-NEXT:         MemoryIndex:     0
 ; RELOC-NEXT:         Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           28
 ; RELOC-NEXT:         Content:         68656C6C6F0A00
 
-; RELOC:       - Type:            CUSTOM
+; RELOC:        - Type:            CUSTOM
 ; RELOC-NEXT:     Name:            linking
 ; RELOC-NEXT:     DataSize:        35
+; RELOC-NEXT:     SymbolTable:
+; RELOC-NEXT:       - Index:           0
+; RELOC-NEXT:         Kind:            DATA
+; RELOC-NEXT:         Name:            foo
+; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
+; RELOC-NEXT:         SegmentIndex:    0
+; RELOC-NEXT:         Size:            4
+; RELOC-NEXT:       - Index:           1
+; RELOC-NEXT:         Kind:            DATA
+; RELOC-NEXT:         Name:            aligned_bar
+; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
+; RELOC-NEXT:         SegmentIndex:    1
+; RELOC-NEXT:         Size:            4
+; RELOC-NEXT:       - Index:           2
+; RELOC-NEXT:         Kind:            DATA
+; RELOC-NEXT:         Name:            external_ref
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         SegmentIndex:    2
+; RELOC-NEXT:         Size:            4
+; RELOC:            - Index:           5
+; RELOC-NEXT:         Kind:            DATA
+; RELOC-NEXT:         Name:            hello_str
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         SegmentIndex:    3
+; RELOC-NEXT:         Size:            7

test/wasm/init-fini.ll

 ; CHECK-NEXT: ...
 
 
 ; RUN: lld -flavor wasm --check-signatures -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:     SymbolInfo:
-; RELOC-NEXT:       - Name:            __dso_handle
+; RELOC-NEXT:     SymbolTable:
+; RELOC-NEXT:       - Index:           0
+; RELOC-NEXT:         Kind:            DATA
+; RELOC-NEXT:         Name:            __dso_handle
 ; RELOC-NEXT:         Flags:           [ BINDING_WEAK, VISIBILITY_HIDDEN ]
-; RELOC-NEXT:       - Name:            func1
+; RELOC-NEXT:       - Index:           1
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            func1
 ; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; RELOC-NEXT:       - Name:            func2
+; RELOC-NEXT:         FunctionIndex:   0
+; RELOC-NEXT:       - Index:           2
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            func2
 ; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; RELOC-NEXT:       - Name:            func3
+; RELOC-NEXT:         FunctionIndex:   1
+; RELOC-NEXT:       - Index:           3
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            func3
 ; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; RELOC-NEXT:       - Name:            func4
+; RELOC-NEXT:         FunctionIndex:   2
+; RELOC-NEXT:       - Index:           4
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            func4
 ; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; RELOC-NEXT:       - Name:            _start
+; RELOC-NEXT:         FunctionIndex:   3
+; RELOC-NEXT:       - Index:           5
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            __cxa_atexit
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   4
+; RELOC-NEXT:       - Index:           6
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            _start
 ; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; RELOC-NEXT:       - Name:            .Lcall_dtors.101
+; RELOC-NEXT:         FunctionIndex:   5
+; RELOC-NEXT:       - Index:           7
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            .Lcall_dtors.101
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            .Lregister_call_dtors.101
+; RELOC-NEXT:         FunctionIndex:   6
+; RELOC-NEXT:       - Index:           8
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            .Lregister_call_dtors.101
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            .Lbitcast
+; RELOC-NEXT:         FunctionIndex:   7
+; RELOC-NEXT:       - Index:           9
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            .Lbitcast
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            .Lcall_dtors.1001
+; RELOC-NEXT:         FunctionIndex:   8
+; RELOC-NEXT:       - Index:           10
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            .Lcall_dtors.1001
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            .Lregister_call_dtors.1001
+; RELOC-NEXT:         FunctionIndex:   9
+; RELOC-NEXT:       - Index:           11
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            .Lregister_call_dtors.1001
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            myctor
+; RELOC-NEXT:         FunctionIndex:   10
+; RELOC-NEXT:       - Index:           12
+; RELOC-NEXT:         Kind:            GLOBAL
+; RELOC-NEXT:         Name:            __stack_pointer
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         GlobalIndex:     0
+; RELOC-NEXT:       - Index:           13
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            myctor
 ; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; RELOC-NEXT:       - Name:            mydtor
+; RELOC-NEXT:         FunctionIndex:   11
+; RELOC-NEXT:       - Index:           14
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            mydtor
 ; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; RELOC-NEXT:       - Name:            .Lcall_dtors.101.1
+; RELOC-NEXT:         FunctionIndex:   12
+; RELOC-NEXT:       - Index:           15
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            .Lcall_dtors.101
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            .Lregister_call_dtors.101.1
+; RELOC-NEXT:         FunctionIndex:   13
+; RELOC-NEXT:       - Index:           16
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            .Lregister_call_dtors.101
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            .Lcall_dtors.202
+; RELOC-NEXT:         FunctionIndex:   14
+; RELOC-NEXT:       - Index:           17
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            .Lcall_dtors.202
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            .Lregister_call_dtors.202
+; RELOC-NEXT:         FunctionIndex:   15
+; RELOC-NEXT:       - Index:           18
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            .Lregister_call_dtors.202
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            .Lcall_dtors.2002
+; RELOC-NEXT:         FunctionIndex:   16
+; RELOC-NEXT:       - Index:           19
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            .Lcall_dtors.2002
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            .Lregister_call_dtors.2002
+; RELOC-NEXT:         FunctionIndex:   17
+; RELOC-NEXT:       - Index:           20
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            .Lregister_call_dtors.2002
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
+; RELOC-NEXT:         FunctionIndex:   18
 ; RELOC-NEXT:     InitFunctions:
 ; RELOC-NEXT:       - Priority:        101
-; RELOC-NEXT:         Symbol:          2
+; RELOC-NEXT:         Symbol:          1
 ; RELOC-NEXT:       - Priority:        101
-; RELOC-NEXT:         Symbol:          3
+; RELOC-NEXT:         Symbol:          2
 ; RELOC-NEXT:       - Priority:        101
-; RELOC-NEXT:         Symbol:          9
+; RELOC-NEXT:         Symbol:          8
 ; RELOC-NEXT:       - Priority:        101
 ; RELOC-NEXT:         Symbol:          13
 ; RELOC-NEXT:       - Priority:        101
 ; RELOC-NEXT:         Symbol:          16
 ; RELOC-NEXT:       - Priority:        202
 ; RELOC-NEXT:         Symbol:          13
 ; RELOC-NEXT:       - Priority:        202
 ; RELOC-NEXT:         Symbol:          18
 ; RELOC-NEXT:       - Priority:        1001
-; RELOC-NEXT:         Symbol:          2
+; RELOC-NEXT:         Symbol:          1
 ; RELOC-NEXT:       - Priority:        1001
-; RELOC-NEXT:         Symbol:          12
+; RELOC-NEXT:         Symbol:          11
 ; RELOC-NEXT:       - Priority:        2002
 ; RELOC-NEXT:         Symbol:          13
 ; RELOC-NEXT:       - Priority:        2002
 ; RELOC-NEXT:         Symbol:          20
 ; RELOC-NEXT:   - Type:            CUSTOM
 ; RELOC-NEXT:     Name:            name
 ; RELOC-NEXT:     FunctionNames:
 ; RELOC-NEXT:       - Index:           0

test/wasm/locals-duplicate.test

 ; RELOC-NEXT:       - ElemType:        ANYFUNC
 ; RELOC-NEXT:         Limits:
 ; RELOC-NEXT:           Flags:           [ HAS_MAX ]
 ; RELOC-NEXT:           Initial:         0x00000007
 ; RELOC-NEXT:           Maximum:         0x00000007
 ; RELOC-NEXT:   - Type:            MEMORY
 ; RELOC-NEXT:     Memories:
 ; RELOC-NEXT:       - Initial:         0x00000001
-; RELOC-NEXT:   - Type:            GLOBAL
-; RELOC-NEXT:     Globals:
-; RELOC-NEXT:       - Index:           0
-; RELOC-NEXT:         Type:            I32
-; RELOC-NEXT:         Mutable:         false
-; RELOC-NEXT:         InitExpr:
-; RELOC-NEXT:           Opcode:          I32_CONST
-; RELOC-NEXT:           Value:           0
-; RELOC-NEXT:       - Index:           1
-; RELOC-NEXT:         Type:            I32
-; RELOC-NEXT:         Mutable:         false
-; RELOC-NEXT:         InitExpr:
-; RELOC-NEXT:           Opcode:          I32_CONST
-; RELOC-NEXT:           Value:           8
-; RELOC-NEXT:       - Index:           2
-; RELOC-NEXT:         Type:            I32
-; RELOC-NEXT:         Mutable:         false
-; RELOC-NEXT:         InitExpr:
-; RELOC-NEXT:           Opcode:          I32_CONST
-; RELOC-NEXT:           Value:           16
-; RELOC-NEXT:       - Index:           3
-; RELOC-NEXT:         Type:            I32
-; RELOC-NEXT:         Mutable:         false
-; RELOC-NEXT:         InitExpr:
-; RELOC-NEXT:           Opcode:          I32_CONST
-; RELOC-NEXT:           Value:           4
-; RELOC-NEXT:       - Index:           4
-; RELOC-NEXT:         Type:            I32
-; RELOC-NEXT:         Mutable:         false
-; RELOC-NEXT:         InitExpr:
-; RELOC-NEXT:           Opcode:          I32_CONST
-; RELOC-NEXT:           Value:           12
-; RELOC-NEXT:       - Index:           5
-; RELOC-NEXT:         Type:            I32
-; RELOC-NEXT:         Mutable:         false
-; RELOC-NEXT:         InitExpr:
-; RELOC-NEXT:           Opcode:          I32_CONST
-; RELOC-NEXT:           Value:           20
-; RELOC-NEXT:   - Type:            EXPORT
-; RELOC-NEXT:     Exports:
-; RELOC-NEXT:       - Name:            colliding_func1.1
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           0
-; RELOC-NEXT:       - Name:            colliding_func2
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           1
-; RELOC-NEXT:       - Name:            colliding_func3
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           2
-; RELOC-NEXT:       - Name:            get_global1A
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           3
-; RELOC-NEXT:       - Name:            get_global2A
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           4
-; RELOC-NEXT:       - Name:            get_global3A
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           5
-; RELOC-NEXT:       - Name:            get_func1A
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           6
-; RELOC-NEXT:       - Name:            get_func2A
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           7
-; RELOC-NEXT:       - Name:            get_func3A
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           8
-; RELOC-NEXT:       - Name:            colliding_func1
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           9
-; RELOC-NEXT:       - Name:            colliding_func2.1
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           10
-; RELOC-NEXT:       - Name:            colliding_func3.1
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           11
-; RELOC-NEXT:       - Name:            get_global1B
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           12
-; RELOC-NEXT:       - Name:            get_global2B
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           13
-; RELOC-NEXT:       - Name:            get_global3B
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           14
-; RELOC-NEXT:       - Name:            get_func1B
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           15
-; RELOC-NEXT:       - Name:            get_func2B
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           16
-; RELOC-NEXT:       - Name:            get_func3B
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           17
-; RELOC-NEXT:       - Name:            colliding_global1.1
-; RELOC-NEXT:         Kind:            GLOBAL
-; RELOC-NEXT:         Index:           0
-; RELOC-NEXT:       - Name:            colliding_global2
-; RELOC-NEXT:         Kind:            GLOBAL
-; RELOC-NEXT:         Index:           1
-; RELOC-NEXT:       - Name:            colliding_global3
-; RELOC-NEXT:         Kind:            GLOBAL
-; RELOC-NEXT:         Index:           2
-; RELOC-NEXT:       - Name:            colliding_global1
-; RELOC-NEXT:         Kind:            GLOBAL
-; RELOC-NEXT:         Index:           3
-; RELOC-NEXT:       - Name:            colliding_global2.1
-; RELOC-NEXT:         Kind:            GLOBAL
-; RELOC-NEXT:         Index:           4
-; RELOC-NEXT:       - Name:            colliding_global3.1
-; RELOC-NEXT:         Kind:            GLOBAL
-; RELOC-NEXT:         Index:           5
 ; RELOC-NEXT:   - Type:            ELEM
 ; RELOC-NEXT:     Segments:
 ; RELOC-NEXT:       - Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           1
 ; RELOC-NEXT:         Functions:       [ 0, 1, 2, 9, 10, 11 ]
 ; RELOC-NEXT:   - Type:            CODE
 ; RELOC-NEXT:     Relocations:
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
-; RELOC-NEXT:         Index:           18
+; RELOC-NEXT:         Index:           4
 ; RELOC-NEXT:         Offset:          0x00000013
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
-; RELOC-NEXT:         Index:           19
+; RELOC-NEXT:         Index:           6
 ; RELOC-NEXT:         Offset:          0x0000001C
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
-; RELOC-NEXT:         Index:           20
+; RELOC-NEXT:         Index:           8
 ; RELOC-NEXT:         Offset:          0x00000025
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
 ; RELOC-NEXT:         Index:           0
 ; RELOC-NEXT:         Offset:          0x0000002E
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
 ; RELOC-NEXT:         Index:           1
 ; RELOC-NEXT:         Offset:          0x00000037
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
 ; RELOC-NEXT:         Index:           2
 ; RELOC-NEXT:         Offset:          0x00000040
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
-; RELOC-NEXT:         Index:           21
+; RELOC-NEXT:         Index:           16
 ; RELOC-NEXT:         Offset:          0x00000058
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
-; RELOC-NEXT:         Index:           22
+; RELOC-NEXT:         Index:           18
 ; RELOC-NEXT:         Offset:          0x00000061
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
-; RELOC-NEXT:         Index:           23
+; RELOC-NEXT:         Index:           20
 ; RELOC-NEXT:         Offset:          0x0000006A
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
-; RELOC-NEXT:         Index:           9
+; RELOC-NEXT:         Index:           12
 ; RELOC-NEXT:         Offset:          0x00000073
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
-; RELOC-NEXT:         Index:           10
+; RELOC-NEXT:         Index:           13
 ; RELOC-NEXT:         Offset:          0x0000007C
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
-; RELOC-NEXT:         Index:           11
+; RELOC-NEXT:         Index:           14
 ; RELOC-NEXT:         Offset:          0x00000085
 ; RELOC-NEXT:     Functions:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:         Body:            41020B
 ; RELOC-NEXT:       - Index:           1
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:         Body:            41020B

 ; RELOC-NEXT:         MemoryIndex:     0
 ; RELOC-NEXT:         Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           16
 ; RELOC-NEXT:         Content:         '0000000000000000'
 ; RELOC-NEXT:   - Type:            CUSTOM
 ; RELOC-NEXT:     Name:            linking
 ; RELOC-NEXT:     DataSize:        24
-; RELOC-NEXT:     SymbolInfo:
-; RELOC-NEXT:       - Name:            colliding_func1.1
+; RELOC-NEXT:     SymbolTable:
+; RELOC-NEXT:       - Index:           0
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            colliding_func1
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            colliding_func3
+; RELOC-NEXT:         FunctionIndex:   0
+; RELOC-NEXT:       - Index:           1
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            colliding_func2
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   1
+; RELOC-NEXT:       - Index:           2
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            colliding_func3
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            colliding_func2.1
+; RELOC-NEXT:         FunctionIndex:   2
+; RELOC-NEXT:       - Index:           3
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            get_global1A
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   3
+; RELOC-NEXT:       - Index:           4
+; RELOC-NEXT:         Kind:            DATA
+; RELOC-NEXT:         Name:            colliding_global1
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            colliding_func3.1
+; RELOC-NEXT:         SegmentIndex:    0
+; RELOC-NEXT:         Size:            4
+; RELOC-NEXT:       - Index:           5
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            get_global2A
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   4
+; RELOC-NEXT:       - Index:           6
+; RELOC-NEXT:         Kind:            DATA
+; RELOC-NEXT:         Name:            colliding_global2
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         SegmentIndex:    1
+; RELOC-NEXT:         Size:            4
+; RELOC-NEXT:       - Index:           7
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            get_global3A
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   5
+; RELOC-NEXT:       - Index:           8
+; RELOC-NEXT:         Kind:            DATA
+; RELOC-NEXT:         Name:            colliding_global3
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            colliding_global1.1
+; RELOC-NEXT:         SegmentIndex:    2
+; RELOC-NEXT:         Size:            4
+; RELOC-NEXT:       - Index:           9
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            get_func1A
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   6
+; RELOC-NEXT:       - Index:           10
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            get_func2A
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   7
+; RELOC-NEXT:       - Index:           11
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            get_func3A
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   8
+; RELOC-NEXT:       - Index:           12
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            colliding_func1
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   9
+; RELOC-NEXT:       - Index:           13
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            colliding_func2
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            colliding_global3
+; RELOC-NEXT:         FunctionIndex:   10
+; RELOC-NEXT:       - Index:           14
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            colliding_func3
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            colliding_global2.1
+; RELOC-NEXT:         FunctionIndex:   11
+; RELOC-NEXT:       - Index:           15
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            get_global1B
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   12
+; RELOC-NEXT:       - Index:           16
+; RELOC-NEXT:         Kind:            DATA
+; RELOC-NEXT:         Name:            colliding_global1
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         SegmentIndex:    0
+; RELOC-NEXT:         Offset:          4
+; RELOC-NEXT:         Size:            4
+; RELOC-NEXT:       - Index:           17
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            get_global2B
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   13
+; RELOC-NEXT:       - Index:           18
+; RELOC-NEXT:         Kind:            DATA
+; RELOC-NEXT:         Name:            colliding_global2
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            colliding_global3.1
+; RELOC-NEXT:         SegmentIndex:    1
+; RELOC-NEXT:         Offset:          4
+; RELOC-NEXT:         Size:            4
+; RELOC-NEXT:       - Index:           19
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            get_global3B
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   14
+; RELOC-NEXT:       - Index:           20
+; RELOC-NEXT:         Kind:            DATA
+; RELOC-NEXT:         Name:            colliding_global3
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
+; RELOC-NEXT:         SegmentIndex:    2
+; RELOC-NEXT:         Offset:          4
+; RELOC-NEXT:         Size:            4
+; RELOC-NEXT:       - Index:           21
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            get_func1B
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   15
+; RELOC-NEXT:       - Index:           22
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            get_func2B
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   16
+; RELOC-NEXT:       - Index:           23
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            get_func3B
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   17
 ; RELOC-NEXT:     SegmentInfo:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Name:            .bss.colliding_global1
 ; RELOC-NEXT:         Alignment:       4
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:       - Index:           1
 ; RELOC-NEXT:         Name:            .bss.colliding_global2
 ; RELOC-NEXT:         Alignment:       4

test/wasm/many-functions.ll

 entry:
   %call = tail call i32 @func()
   ret i32 %call
 }
 
 ; CHECK:        - Type:            CODE
 ; CHECK-NEXT:     Relocations:
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000008
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000014
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000020
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000002C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000038
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000044
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000050
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000005C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000068
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000074
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000080
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000008C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000098
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000000A4
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000000B0
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000000BC
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000000C8
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000000D4
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000000E0
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000000EC
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000000F8
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000104
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000110
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000011C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000128
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000134
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000140
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000014C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000158
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000164
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000170
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000017C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000188
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000194
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000001A0
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000001AC
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000001B8
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000001C4
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000001D0
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000001DC
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000001E8
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000001F4
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000200
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000020C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000218
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000224
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000230
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000023C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000248
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000254
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000260
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000026C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000278
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000284
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000290
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000029C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000002A8
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000002B4
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000002C0
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000002CC
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000002D8
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000002E4
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000002F0
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000002FC
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000308
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000314
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000320
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000032C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000338
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000344
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000350
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000035C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000368
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000374
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000380
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000038C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000398
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000003A4
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000003B0
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000003BC
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000003C8
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000003D4
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000003E0
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000003EC
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000003F8
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000404
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000410
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000041C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000428
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000434
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000440
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000044C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000458
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000464
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000470
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000047C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000488
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000494
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000004A0
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000004AC
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000004B8
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000004C4
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000004D0
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000004DC
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000004E8
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000004F4
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000500
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000050C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000518
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000524
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000530
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000053C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000548
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000554
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000560
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000056C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000578
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000584
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000590
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000059C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000005A8
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000005B4
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000005C0
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000005CC
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000005D8
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000005E4
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           130
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000005F0
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:         Index:           129
 ; CHECK-NEXT:         Offset:          0x000005FC
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:         Index:           129
 ; CHECK-NEXT:         Offset:          0x00000608
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
-; CHECK-NEXT:         Index:           129
+; CHECK-NEXT:         Index:           131
 ; CHECK-NEXT:         Offset:          0x00000611
 ; CHECK-NEXT:     Functions:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4100280284808080000B
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4100280284808080000B

 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           4
 ; CHECK-NEXT:         Content:         '01000000'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        8
+; CHECK-NEXT:     SymbolTable:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f1
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   0
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            foo
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         SegmentIndex:    1
+; CHECK-NEXT:         Size:            4
+; CHECK-NEXT:       - Index:           2
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f2
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   1
+; CHECK-NEXT:       - Index:           3
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f3
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   2
+; CHECK-NEXT:       - Index:           4
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f4
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   3
+; CHECK-NEXT:       - Index:           5
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f5
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   4
+; CHECK-NEXT:       - Index:           6
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f6
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   5
+; CHECK-NEXT:       - Index:           7
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f7
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   6
+; CHECK-NEXT:       - Index:           8
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f8
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   7
+; CHECK-NEXT:       - Index:           9
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f9
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   8
+; CHECK-NEXT:       - Index:           10
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f10
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   9
+; CHECK-NEXT:       - Index:           11
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f11
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   10
+; CHECK-NEXT:       - Index:           12
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f12
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   11
+; CHECK-NEXT:       - Index:           13
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f13
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   12
+; CHECK-NEXT:       - Index:           14
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f14
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   13
+; CHECK-NEXT:       - Index:           15
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f15
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   14
+; CHECK-NEXT:       - Index:           16
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f16
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   15
+; CHECK-NEXT:       - Index:           17
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f17
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   16
+; CHECK-NEXT:       - Index:           18
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f18
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   17
+; CHECK-NEXT:       - Index:           19
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f19
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   18
+; CHECK-NEXT:       - Index:           20
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f20
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   19
+; CHECK-NEXT:       - Index:           21
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f21
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   20
+; CHECK-NEXT:       - Index:           22
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f22
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   21
+; CHECK-NEXT:       - Index:           23
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f23
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   22
+; CHECK-NEXT:       - Index:           24
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f24
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   23
+; CHECK-NEXT:       - Index:           25
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f25
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   24
+; CHECK-NEXT:       - Index:           26
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f26
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   25
+; CHECK-NEXT:       - Index:           27
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f27
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   26
+; CHECK-NEXT:       - Index:           28
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f28
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   27
+; CHECK-NEXT:       - Index:           29
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f29
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   28
+; CHECK-NEXT:       - Index:           30
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f30
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   29
+; CHECK-NEXT:       - Index:           31
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f31
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   30
+; CHECK-NEXT:       - Index:           32
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f32
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   31
+; CHECK-NEXT:       - Index:           33
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f33
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   32
+; CHECK-NEXT:       - Index:           34
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f34
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   33
+; CHECK-NEXT:       - Index:           35
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f35
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   34
+; CHECK-NEXT:       - Index:           36
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f36
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   35
+; CHECK-NEXT:       - Index:           37
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f37
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   36
+; CHECK-NEXT:       - Index:           38
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f38
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   37
+; CHECK-NEXT:       - Index:           39
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f39
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   38
+; CHECK-NEXT:       - Index:           40
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f40
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   39
+; CHECK-NEXT:       - Index:           41
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f41
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   40
+; CHECK-NEXT:       - Index:           42
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f42
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   41
+; CHECK-NEXT:       - Index:           43
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f43
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   42
+; CHECK-NEXT:       - Index:           44
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f44
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   43
+; CHECK-NEXT:       - Index:           45
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f45
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   44
+; CHECK-NEXT:       - Index:           46
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f46
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   45
+; CHECK-NEXT:       - Index:           47
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f47
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   46
+; CHECK-NEXT:       - Index:           48
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f48
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   47
+; CHECK-NEXT:       - Index:           49
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f49
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   48
+; CHECK-NEXT:       - Index:           50
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f50
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   49
+; CHECK-NEXT:       - Index:           51
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f51
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   50
+; CHECK-NEXT:       - Index:           52
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f52
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   51
+; CHECK-NEXT:       - Index:           53
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f53
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   52
+; CHECK-NEXT:       - Index:           54
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f54
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   53
+; CHECK-NEXT:       - Index:           55
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f55
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   54
+; CHECK-NEXT:       - Index:           56
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f56
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   55
+; CHECK-NEXT:       - Index:           57
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f57
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   56
+; CHECK-NEXT:       - Index:           58
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f58
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   57
+; CHECK-NEXT:       - Index:           59
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f59
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   58
+; CHECK-NEXT:       - Index:           60
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f60
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   59
+; CHECK-NEXT:       - Index:           61
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f61
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   60
+; CHECK-NEXT:       - Index:           62
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f62
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   61
+; CHECK-NEXT:       - Index:           63
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f63
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   62
+; CHECK-NEXT:       - Index:           64
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f64
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   63
+; CHECK-NEXT:       - Index:           65
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f65
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   64
+; CHECK-NEXT:       - Index:           66
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f66
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   65
+; CHECK-NEXT:       - Index:           67
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f67
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   66
+; CHECK-NEXT:       - Index:           68
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f68
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   67
+; CHECK-NEXT:       - Index:           69
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f69
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   68
+; CHECK-NEXT:       - Index:           70
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f70
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   69
+; CHECK-NEXT:       - Index:           71
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f71
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   70
+; CHECK-NEXT:       - Index:           72
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f72
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   71
+; CHECK-NEXT:       - Index:           73
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f73
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   72
+; CHECK-NEXT:       - Index:           74
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f74
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   73
+; CHECK-NEXT:       - Index:           75
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f75
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   74
+; CHECK-NEXT:       - Index:           76
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f76
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   75
+; CHECK-NEXT:       - Index:           77
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f77
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   76
+; CHECK-NEXT:       - Index:           78
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f78
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   77
+; CHECK-NEXT:       - Index:           79
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f79
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   78
+; CHECK-NEXT:       - Index:           80
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f80
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   79
+; CHECK-NEXT:       - Index:           81
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f81
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   80
+; CHECK-NEXT:       - Index:           82
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f82
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   81
+; CHECK-NEXT:       - Index:           83
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f83
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   82
+; CHECK-NEXT:       - Index:           84
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f84
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   83
+; CHECK-NEXT:       - Index:           85
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f85
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   84
+; CHECK-NEXT:       - Index:           86
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f86
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   85
+; CHECK-NEXT:       - Index:           87
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f87
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   86
+; CHECK-NEXT:       - Index:           88
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f88
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   87
+; CHECK-NEXT:       - Index:           89
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f89
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   88
+; CHECK-NEXT:       - Index:           90
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f90
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   89
+; CHECK-NEXT:       - Index:           91
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f91
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   90
+; CHECK-NEXT:       - Index:           92
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f92
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   91
+; CHECK-NEXT:       - Index:           93
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f93
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   92
+; CHECK-NEXT:       - Index:           94
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f94
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   93
+; CHECK-NEXT:       - Index:           95
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f95
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   94
+; CHECK-NEXT:       - Index:           96
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f96
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   95
+; CHECK-NEXT:       - Index:           97
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f97
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   96
+; CHECK-NEXT:       - Index:           98
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f98
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   97
+; CHECK-NEXT:       - Index:           99
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f99
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   98
+; CHECK-NEXT:       - Index:           100
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f100
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   99
+; CHECK-NEXT:       - Index:           101
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f101
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   100
+; CHECK-NEXT:       - Index:           102
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f102
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   101
+; CHECK-NEXT:       - Index:           103
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f103
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   102
+; CHECK-NEXT:       - Index:           104
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f104
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   103
+; CHECK-NEXT:       - Index:           105
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f105
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   104
+; CHECK-NEXT:       - Index:           106
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f106
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   105
+; CHECK-NEXT:       - Index:           107
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f107
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   106
+; CHECK-NEXT:       - Index:           108
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f108
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   107
+; CHECK-NEXT:       - Index:           109
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f109
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   108
+; CHECK-NEXT:       - Index:           110
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f110
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   109
+; CHECK-NEXT:       - Index:           111
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f111
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   110
+; CHECK-NEXT:       - Index:           112
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f112
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   111
+; CHECK-NEXT:       - Index:           113
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f113
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   112
+; CHECK-NEXT:       - Index:           114
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f114
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   113
+; CHECK-NEXT:       - Index:           115
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f115
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   114
+; CHECK-NEXT:       - Index:           116
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f116
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   115
+; CHECK-NEXT:       - Index:           117
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f117
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   116
+; CHECK-NEXT:       - Index:           118
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f118
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   117
+; CHECK-NEXT:       - Index:           119
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f119
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   118
+; CHECK-NEXT:       - Index:           120
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f120
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   119
+; CHECK-NEXT:       - Index:           121
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f121
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   120
+; CHECK-NEXT:       - Index:           122
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f122
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   121
+; CHECK-NEXT:       - Index:           123
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f123
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   122
+; CHECK-NEXT:       - Index:           124
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f124
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   123
+; CHECK-NEXT:       - Index:           125
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f125
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   124
+; CHECK-NEXT:       - Index:           126
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f126
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   125
+; CHECK-NEXT:       - Index:           127
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f127
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   126
+; CHECK-NEXT:       - Index:           128
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f128
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   127
+; CHECK-NEXT:       - Index:           129
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            g0
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         SegmentIndex:    0
+; CHECK-NEXT:         Size:            4
+; CHECK-NEXT:       - Index:           130
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f129
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   128
+; CHECK-NEXT:       - Index:           131
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            func
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   129
 ; CHECK-NEXT:     SegmentInfo:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            .data.g0
 ; CHECK-NEXT:         Alignment:       4
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            .data.foo
 ; CHECK-NEXT:         Alignment:       4
 ; CHECK-NEXT:         Flags:           [ ]

test/wasm/relocatable.ll

 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           foo_import
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        1
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           bar_import
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        1
-; CHECK-NEXT:       - Module:          env
-; CHECK-NEXT:         Field:           data_import
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         GlobalType:      I32
-; CHECK-NEXT:         GlobalMutable:   false
 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 2, 1, 1 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:
 ; CHECK-NEXT:       - ElemType:        ANYFUNC
 ; CHECK-NEXT:         Limits:
 ; CHECK-NEXT:           Flags:           [ HAS_MAX ]
 ; CHECK-NEXT:           Initial:         0x00000004
 ; CHECK-NEXT:           Maximum:         0x00000004
 ; CHECK-NEXT:   - Type:            MEMORY
 ; CHECK-NEXT:     Memories:
 ; CHECK-NEXT:       - Initial:         0x00000001
-; CHECK-NEXT:   - Type:            GLOBAL
-; CHECK-NEXT:     Globals:
-; CHECK-NEXT:       - Index:           1
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           0
-; CHECK-NEXT:       - Index:           2
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           28
-; CHECK-NEXT:       - Index:           3
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           8
-; CHECK-NEXT:       - Index:           4
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           12
-; CHECK-NEXT:       - Index:           5
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           16
-; CHECK-NEXT:       - Index:           6
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           24
-; CHECK-NEXT:   - Type:            EXPORT
-; CHECK-NEXT:     Exports:
-; CHECK-NEXT:       - Name:            hello
-; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           3
-; CHECK-NEXT:       - Name:            my_func
-; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           4
-; CHECK-NEXT:       - Name:            func_comdat
-; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           5
-; CHECK-NEXT:       - Name:            hello_str
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           1
-; CHECK-NEXT:       - Name:            data_comdat
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           2
-; CHECK-NEXT:       - Name:            func_addr1
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           3
-; CHECK-NEXT:       - Name:            func_addr2
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           4
-; CHECK-NEXT:       - Name:            func_addr3
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           5
-; CHECK-NEXT:       - Name:            data_addr1
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           6
 ; CHECK-NEXT:   - Type:            ELEM
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1
 ; CHECK-NEXT:         Functions:       [ 4, 1, 2 ]
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Relocations:
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
-; CHECK-NEXT:         Index:           7
+; CHECK-NEXT:         Index:           2
 ; CHECK-NEXT:         Offset:          0x00000004
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Offset:          0x0000000A
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
-; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:         Index:           3
 ; CHECK-NEXT:         Offset:          0x00000013
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
-; CHECK-NEXT:         Index:           2
+; CHECK-NEXT:         Index:           4
 ; CHECK-NEXT:         Offset:          0x0000001A
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
 ; CHECK-NEXT:         Index:           8
 ; CHECK-NEXT:         Offset:          0x00000026
 ; CHECK-NEXT:     Functions:
 ; CHECK-NEXT:       - Index:         3
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:          4180808080001080808080000B
 ; CHECK-NEXT:       - Index:         4
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:          1081808080001A1082808080001A41010B
 ; CHECK-NEXT:       - Index:         5
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:          419C808080000B
 ; CHECK-NEXT:   - Type:            DATA
 ; CHECK-NEXT:     Relocations:
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_I32
-; CHECK-NEXT:         Index:           5
+; CHECK-NEXT:         Index:           6
 ; CHECK-NEXT:         Offset:          0x00000012
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_I32
-; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:         Index:           3
 ; CHECK-NEXT:         Offset:          0x0000001B
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_I32
-; CHECK-NEXT:         Index:           2
+; CHECK-NEXT:         Index:           4
 ; CHECK-NEXT:         Offset:          0x00000024
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_I32
-; CHECK-NEXT:         Index:           3
+; CHECK-NEXT:         Index:           5
 ; CHECK-NEXT:         Offset:          0x0000002D
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - SectionOffset:   6
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           0
 ; CHECK-NEXT:         Content:         68656C6C6F0A00

 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           28
 ; CHECK-NEXT:         Content:         '616263'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        31
-; CHECK-NEXT:     SymbolInfo:
-; CHECK-NEXT:       - Name:            bar_import
-; CHECK-NEXT:         Flags:           [ BINDING_WEAK ]
-; CHECK-NEXT:       - Name:            hello
+; CHECK-NEXT:     SymbolTable:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            puts
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   0
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            hello
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; CHECK-NEXT:       - Name:            my_func
+; CHECK-NEXT:         FunctionIndex:   3
+; CHECK-NEXT:       - Index:           2
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            hello_str
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         SegmentIndex:    0
+; CHECK-NEXT:         Size:            7
+; CHECK-NEXT:       - Index:           3
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            foo_import
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   1
+; CHECK-NEXT:       - Index:           4
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            bar_import
+; CHECK-NEXT:         Flags:           [ BINDING_WEAK ]
+; CHECK-NEXT:         FunctionIndex:   2
+; CHECK-NEXT:       - Index:           5
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            data_import
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:       - Index:           6
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            my_func
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; CHECK-NEXT:       - Name:            func_comdat
+; CHECK-NEXT:         FunctionIndex:   4
+; CHECK-NEXT:       - Index:           7
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            func_comdat
 ; CHECK-NEXT:         Flags:           [ BINDING_WEAK ]
-; CHECK-NEXT:       - Name:            data_comdat
+; CHECK-NEXT:         FunctionIndex:   5
+; CHECK-NEXT:       - Index:           8
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            data_comdat
 ; CHECK-NEXT:         Flags:           [ BINDING_WEAK ]
-; CHECK-NEXT:       - Name:            func_addr1
+; CHECK-NEXT:         SegmentIndex:    5
+; CHECK-NEXT:         Size:            3
+; CHECK-NEXT:       - Index:           9
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            func_addr1
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; CHECK-NEXT:       - Name:            func_addr2
+; CHECK-NEXT:         SegmentIndex:    1
+; CHECK-NEXT:         Size:            4
+; CHECK-NEXT:       - Index:           10
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            func_addr2
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; CHECK-NEXT:       - Name:            func_addr3
+; CHECK-NEXT:         SegmentIndex:    2
+; CHECK-NEXT:         Size:            4
+; CHECK-NEXT:       - Index:           11
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            func_addr3
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; CHECK-NEXT:       - Name:            data_addr1
+; CHECK-NEXT:         SegmentIndex:    3
+; CHECK-NEXT:         Size:            4
+; CHECK-NEXT:       - Index:           12
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            data_addr1
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
+; CHECK-NEXT:         SegmentIndex:    4
+; CHECK-NEXT:         Size:            4
 ; CHECK-NEXT:     SegmentInfo:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            .rodata.hello_str
 ; CHECK-NEXT:         Alignment:       1
 ; CHECK-NEXT:         Flags:           [  ]
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            .data.func_addr1
 ; CHECK-NEXT:         Alignment:       4

test/wasm/signature-mismatch.ll

 ; RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
 ; RUN: llc -filetype=obj %s -o %t.main.o
 ; RUN: not lld -flavor wasm --check-signatures -o %t.wasm %t.main.o %t.ret32.o 2>&1 | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 ; Function Attrs: nounwind
 define hidden void @_start() local_unnamed_addr #0 {
 entry:
   %call = tail call i32 @ret32(i32 1, i64 2, i32 3) #2
   ret void
 }
 
 declare i32 @ret32(i32, i64, i32) local_unnamed_addr #1
 
-; CHECK: error: function signature mismatch: ret32
+; CHECK: error: Function signature mismatch: ret32
 ; CHECK-NEXT: >>> defined as (I32, I64, I32) -> I32 in {{.*}}.main.o
 ; CHECK-NEXT: >>> defined as (F32) -> I32 in {{.*}}.ret32.o

test/wasm/stack-pointer.ll

 ; CHECK-NEXT:         ReturnType:      I32
 ; CHECK-NEXT:         ParamTypes:
 ; CHECK-NEXT:   - Type:            IMPORT
 ; CHECK-NEXT:     Imports:
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __stack_pointer
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         GlobalType:      I32
-; CHECK-NEXT:         GlobalMutable:   false
+; CHECK-NEXT:         GlobalMutable:   true
 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 0 ]
 ; 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:     Memories:
 ; CHECK-NEXT:       - Initial:         0x00000000
-; CHECK-NEXT:   - Type:            EXPORT
-; CHECK-NEXT:     Exports:
-; CHECK-NEXT:       - Name:            _start
-; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           0
 ; 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:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        0
+; CHECK-NEXT:     SymbolTable:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Kind:            GLOBAL
+; CHECK-NEXT:         Name:            __stack_pointer
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         GlobalIndex:     0
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            _start
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   0
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            _start
 ; CHECK-NEXT: ...

test/wasm/symbol-type-mismatch.ll

 ; RUN: llc -filetype=obj %s -o %t.o
 ; RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
 ; RUN: not lld -flavor wasm --check-signatures -o %t.wasm %t.o %t.ret32.o 2>&1 | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 @ret32 = extern_weak global i32, align 4
 
 ; CHECK: error: symbol type mismatch: ret32
-; CHECK: >>> defined as Global in {{.*}}symbol-type-mismatch.ll.tmp.o
+; CHECK: >>> defined as Data in {{.*}}symbol-type-mismatch.ll.tmp.o
 ; CHECK: >>> defined as Function in {{.*}}.ret32.o

test/wasm/weak-alias.ll

 ; RELOC-NEXT:         ReturnType:      I32
 ; RELOC-NEXT:         ParamTypes:
 ; RELOC-NEXT:   - Type:            IMPORT
 ; RELOC-NEXT:     Imports:
 ; RELOC-NEXT:       - Module:          env
 ; RELOC-NEXT:         Field:           __stack_pointer
 ; RELOC-NEXT:         Kind:            GLOBAL
 ; RELOC-NEXT:         GlobalType:      I32
-; RELOC-NEXT:         GlobalMutable:   false
+; RELOC-NEXT:         GlobalMutable:   true
 ; RELOC-NEXT:   - Type:            FUNCTION
 ; RELOC-NEXT:     FunctionTypes:   [ 0, 1, 1, 1, 1, 1 ]
 ; RELOC-NEXT:   - Type:            TABLE
 ; RELOC-NEXT:     Tables:
 ; RELOC-NEXT:       - ElemType:        ANYFUNC
 ; RELOC-NEXT:         Limits:
 ; RELOC-NEXT:           Flags:           [ HAS_MAX ]
 ; RELOC-NEXT:           Initial:         0x00000002
 ; RELOC-NEXT:           Maximum:         0x00000002
 ; RELOC-NEXT:   - Type:            MEMORY
 ; RELOC-NEXT:     Memories:
 ; RELOC-NEXT:       - Initial:         0x00000000
-; RELOC-NEXT:   - Type:            EXPORT
-; RELOC-NEXT:     Exports:
-; RELOC-NEXT:       - Name:            _start
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           0
-; RELOC-NEXT:       - Name:            direct_fn
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           1
-; RELOC-NEXT:       - Name:            call_direct
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           2
-; RELOC-NEXT:       - Name:            call_alias
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           3
-; RELOC-NEXT:       - Name:            call_alias_ptr
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           4
-; RELOC-NEXT:       - Name:            call_direct_ptr
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           5
-; RELOC-NEXT:       - Name:            alias_fn
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           1
 ; RELOC-NEXT:   - Type:            ELEM
 ; RELOC-NEXT:     Segments:
 ; RELOC-NEXT:       - Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           1
 ; RELOC-NEXT:         Functions:       [ 1 ]
 ; RELOC-NEXT:   - Type:            CODE
 ; RELOC-NEXT:     Relocations:
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
 ; RELOC-NEXT:         Index:           7
 ; RELOC-NEXT:         Offset:          0x00000004
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
 ; RELOC-NEXT:         Index:           2
 ; RELOC-NEXT:         Offset:          0x00000013
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
 ; RELOC-NEXT:         Index:           7
 ; RELOC-NEXT:         Offset:          0x0000001C
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_INDEX_LEB
-; RELOC-NEXT:         Index:           0
+; RELOC-NEXT:         Index:           1
 ; RELOC-NEXT:         Offset:          0x00000027
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_INDEX_LEB
-; RELOC-NEXT:         Index:           0
+; RELOC-NEXT:         Index:           1
 ; RELOC-NEXT:         Offset:          0x00000032
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
 ; RELOC-NEXT:         Index:           7
 ; RELOC-NEXT:         Offset:          0x0000003A
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
 ; RELOC-NEXT:         Index:           7
 ; RELOC-NEXT:         Offset:          0x00000043
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_INDEX_LEB
-; RELOC-NEXT:         Index:           0
+; RELOC-NEXT:         Index:           1
 ; RELOC-NEXT:         Offset:          0x00000050
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_INDEX_LEB
-; RELOC-NEXT:         Index:           0
+; RELOC-NEXT:         Index:           1
 ; RELOC-NEXT:         Offset:          0x0000005D
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_INDEX_LEB
-; RELOC-NEXT:         Index:           0
+; RELOC-NEXT:         Index:           1
 ; RELOC-NEXT:         Offset:          0x00000068
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
 ; RELOC-NEXT:         Index:           2
 ; RELOC-NEXT:         Offset:          0x00000070
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
 ; RELOC-NEXT:         Index:           2
 ; RELOC-NEXT:         Offset:          0x00000079
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_INDEX_LEB
-; RELOC-NEXT:         Index:           0
+; RELOC-NEXT:         Index:           1
 ; RELOC-NEXT:         Offset:          0x00000086
 ; RELOC-NEXT:     Functions:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:         Body:            1081808080001A0B
 ; RELOC-NEXT:       - Index:           1
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:         Body:            41000B

 ; RELOC-NEXT:       - Index:           5
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:           - Type:            I32
 ; RELOC-NEXT:             Count:           2
 ; RELOC-NEXT:         Body:            23808080800041106B220024808080800020004181808080003602081081808080002101200041106A24808080800020010B
 ; RELOC-NEXT:   - Type:            CUSTOM
 ; RELOC-NEXT:     Name:            linking
 ; RELOC-NEXT:     DataSize:        0
-; RELOC-NEXT:     SymbolInfo:
-; RELOC-NEXT:       - Name:            alias_fn
+; RELOC-NEXT:     SymbolTable:
+; RELOC-NEXT:       - Index:           0
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            _start
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   0
+; RELOC-NEXT:       - Index:           1
+; RELOC-NEXT:         Kind:            GLOBAL
+; RELOC-NEXT:         Name:            __stack_pointer
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         GlobalIndex:     0
+; RELOC-NEXT:       - Index:           2
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            direct_fn
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   1
+; RELOC-NEXT:       - Index:           3
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            call_direct
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   2
+; RELOC-NEXT:       - Index:           4
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            call_alias
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   3
+; RELOC-NEXT:       - Index:           5
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            call_alias_ptr
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   4
+; RELOC-NEXT:       - Index:           6
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            call_direct_ptr
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   5
+; RELOC-NEXT:       - Index:           7
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            alias_fn
 ; RELOC-NEXT:         Flags:           [ BINDING_WEAK ]
+; RELOC-NEXT:         FunctionIndex:   1
 ; RELOC-NEXT:   - Type:            CUSTOM
 ; RELOC-NEXT:     Name:            name
 ; RELOC-NEXT:     FunctionNames:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Name:            _start
 ; RELOC-NEXT:       - Index:           1
 ; RELOC-NEXT:         Name:            direct_fn
 ; RELOC-NEXT:       - Index:           2
 ; RELOC-NEXT:         Name:            call_direct
 ; RELOC-NEXT:       - Index:           3
 ; RELOC-NEXT:         Name:            call_alias
 ; RELOC-NEXT:       - Index:           4
 ; RELOC-NEXT:         Name:            call_alias_ptr
 ; RELOC-NEXT:       - Index:           5
 ; RELOC-NEXT:         Name:            call_direct_ptr
 ; RELOC-NEXT: ...

wasm/Driver.cpp

if (Config->Relocatable) {
     if (Config->GcSections)
       error("-r and --gc-sections may not be used together");
     if (Args.hasArg(OPT_undefined))
       error("-r -and --undefined may not be used together");
   }
 
   Symbol *EntrySym = nullptr;
   if (!Config->Relocatable) {
-    static WasmSignature Signature = {{}, WASM_TYPE_NORESULT};
+    static WasmSignature EntrySignature = {{}, WASM_TYPE_NORESULT};
+    static WasmGlobalType StackPointerSignature = {WASM_TYPE_I32, true};
     if (!Config->Entry.empty())
-      EntrySym = Symtab->addUndefinedFunction(Config->Entry, &Signature);
+      EntrySym = Symtab->addUndefinedFunction(Config->Entry, &EntrySignature);
 
     // Handle the `--undefined <sym>` options.
     for (auto* Arg : Args.filtered(OPT_undefined))
       Symtab->addUndefinedFunction(Arg->getValue(), nullptr);
     WasmSym::CallCtors = Symtab->addDefinedFunction(
-        "__wasm_call_ctors", &Signature, WASM_SYMBOL_VISIBILITY_HIDDEN);
-    WasmSym::StackPointer = Symtab->addDefinedGlobal("__stack_pointer");
-    WasmSym::HeapBase = Symtab->addDefinedGlobal("__heap_base");
-    WasmSym::DsoHandle = Symtab->addDefinedGlobal("__dso_handle");
-    WasmSym::DataEnd = Symtab->addDefinedGlobal("__data_end");
+        "__wasm_call_ctors", &EntrySignature, WASM_SYMBOL_VISIBILITY_HIDDEN);
+    WasmSym::StackPointer = Symtab->addDefinedGlobal(
+        "__stack_pointer", &StackPointerSignature,
+        // Can't export the SP right now because it's mutable, and mutable
+        // globals aren't yet supported in the official binary format.
+        // TODO(sbc): Remove this if/when the "mutable global" proposal is accepted.
+        WASM_SYMBOL_VISIBILITY_HIDDEN);
+    WasmSym::HeapBase = Symtab->addDefinedData("__heap_base");
+    WasmSym::DsoHandle = Symtab->addDefinedData(
+        "__dso_handle", WASM_SYMBOL_VISIBILITY_HIDDEN);
+    WasmSym::DataEnd = Symtab->addDefinedData("__data_end");
   }
 
   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/InputChunks.h

 #include "Config.h"
 #include "InputFiles.h"
 #include "WriterUtils.h"
 #include "lld/Common/ErrorHandler.h"
 #include "llvm/Object/Wasm.h"
 
 using llvm::object::WasmSegment;
 using llvm::wasm::WasmFunction;
+using llvm::wasm::WasmGlobal;
 using llvm::wasm::WasmRelocation;
 using llvm::wasm::WasmSignature;
+using llvm::wasm::WasmInitExpr;
 using llvm::object::WasmSection;
 
 namespace lld {
 namespace wasm {
 
 class ObjFile;
 class OutputSegment;
 
 class InputChunk {
 public:
-  enum Kind { DataSegment, Function };
+  enum Kind { DataSegment, Function, Global };
 
-  Kind kind() const { return SectionKind; };
+  Kind kind() const { return SectionKind; }
 
   uint32_t getSize() const { return data().size(); }
 
   void copyRelocations(const WasmSection &Section);
 
   void writeTo(uint8_t *SectionStart) const;
 
   void setOutputOffset(uint32_t Offset) {
     OutputOffset = Offset;
     calcRelocations();
   }
 
   uint32_t getOutputOffset() const { return OutputOffset; }
   ArrayRef<WasmRelocation> getRelocations() const { return Relocations; }
   StringRef getFileName() const { return File->getName(); }
 
   virtual StringRef getComdat() const = 0;
   virtual StringRef getName() const = 0;
+  virtual bool hasOutputIndex() const = 0;
+  virtual uint32_t getOutputIndex() const = 0;
 
   bool Discarded = false;
   std::vector<OutputRelocation> OutRelocations;
   ObjFile *File;
 
   // The garbage collector sets sections' Live bits.
   // If GC is disabled, all sections are considered live by default.
   unsigned Live : 1;
void setOutputSegment(const OutputSegment *Segment, uint32_t Offset) {
     OutputSegmentOffset = Offset;
   }
 
   uint32_t getAlignment() const { return Segment.Data.Alignment; }
   uint32_t startVA() const { return Segment.Data.Offset.Value.Int32; }
   uint32_t endVA() const { return startVA() + getSize(); }
   StringRef getName() const override { return Segment.Data.Name; }
   StringRef getComdat() const override { return Segment.Data.Comdat; }
+  bool hasOutputIndex() const override { return OutputSeg != nullptr; }
+  uint32_t getOutputIndex() const override;
 
   int32_t OutputSegmentOffset = 0;
 
 protected:
   ArrayRef<uint8_t> data() const override { return Segment.Data.Content; }
   uint32_t getInputSectionOffset() const override {
     return Segment.SectionOffset;
   }
InputFunction(const WasmSignature &S, const WasmFunction *Func,
       : InputChunk(F, InputChunk::Function), Signature(S), Function(Func) {}
 
   static bool classof(const InputChunk *C) {
     return C->kind() == InputChunk::Function;
   }
 
   StringRef getName() const override { return Function->Name; }
   StringRef getComdat() const override { return Function->Comdat; }
-  uint32_t getOutputIndex() const { return OutputIndex.getValue(); }
-  bool hasOutputIndex() const { return OutputIndex.hasValue(); }
+  uint32_t getOutputIndex() const override { return OutputIndex.getValue(); }
+  bool hasOutputIndex() const override { return OutputIndex.hasValue(); }
   void setOutputIndex(uint32_t Index);
   uint32_t getTableIndex() const { return TableIndex.getValue(); }
   bool hasTableIndex() const { return TableIndex.hasValue(); }
   void setTableIndex(uint32_t Index);
 
   const WasmSignature &Signature;
 
 protected:
protected:
   llvm::Optional<uint32_t> OutputIndex;
   llvm::Optional<uint32_t> TableIndex;
 };
 
 class SyntheticFunction : public InputFunction {
 public:
   SyntheticFunction(const WasmSignature &S, ArrayRef<uint8_t> Body,
                     StringRef Name)
-      : InputFunction(S, nullptr, nullptr), Name(Name), Body(Body) {}
+      : InputFunction(S, nullptr, nullptr), Name(Name), Body(Body)
+  { Live = true; }
 
   StringRef getName() const override { return Name; }
 
 protected:
   ArrayRef<uint8_t> data() const override { return Body; }
 
   StringRef Name;
   ArrayRef<uint8_t> Body;
 };
 
+// Represents a single Wasm Global within an input file. These are combined to
+// form the final GLOBALS section.
+class InputGlobal : public InputChunk {
+public:
+  InputGlobal(const WasmGlobalType &Signature, const WasmGlobal *G,
+              ObjFile *F)
+      : InputChunk(F, InputChunk::Global), Signature(Signature), Global(G) {}
+
+  static bool classof(const InputChunk *C) {
+    return C->kind() == InputChunk::Global;
+  }
+
+  virtual const WasmInitExpr &initExpr() const { return Global->InitExpr; }
+  StringRef getComdat() const override { return StringRef(); }
+  uint32_t getOutputIndex() const override { return OutputIndex.getValue(); }
+  bool hasOutputIndex() const override { return OutputIndex.hasValue(); }
+  void setOutputIndex(uint32_t Index);
+
+  const WasmGlobalType &Signature;
+
+protected:
+  StringRef getName() const override { return {}; }
+  ArrayRef<uint8_t> data() const override { return {}; }
+  uint32_t getInputSectionOffset() const override { return 0; }
+
+  const WasmGlobal *Global;
+  llvm::Optional<uint32_t> OutputIndex;
+};
+
+class SyntheticGlobal : public InputGlobal {
+public:
+  SyntheticGlobal(const WasmGlobalType &Signature, const WasmInitExpr &InitExpr)
+      : InputGlobal(Signature, nullptr, nullptr), InitExpr(InitExpr)
+  { Live = true; }
+
+  const WasmInitExpr &initExpr() const override { return InitExpr; }
+
+protected:
+  const WasmInitExpr InitExpr;
+};
+
 } // namespace wasm
 } // namespace lld
 
 #endif // LLD_WASM_INPUT_CHUNKS_H

wasm/InputChunks.cpp

 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;
 using namespace lld;
 using namespace lld::wasm;
 
 uint32_t InputSegment::translateVA(uint32_t Address) const {
-  assert(Address >= startVA() && Address < endVA());
+  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())
for (const WasmRelocation &Reloc : Relocations) {
     if (Config->Relocatable)
       NewReloc.NewIndex = File->calcNewIndex(Reloc);
 
     NewReloc.Value = File->calcNewValue(Reloc);
     OutRelocations.emplace_back(NewReloc);
   }
 }
 
+uint32_t InputSegment::getOutputIndex() const {
+  return OutputSeg->Index;
+}
+
 void InputFunction::setOutputIndex(uint32_t Index) {
   DEBUG(dbgs() << "InputFunction::setOutputIndex: " << getName() << " -> " << Index << "\n");
   assert(!hasOutputIndex());
   OutputIndex = Index;
 }
 
 void InputFunction::setTableIndex(uint32_t Index) {
   DEBUG(dbgs() << "InputFunction::setTableIndex: " << getName() << " -> " << Index << "\n");
   assert(!hasTableIndex());
   TableIndex = Index;
 }
+
+
+void InputGlobal::setOutputIndex(uint32_t Index) {
+  DEBUG(dbgs() << "InputGlobal::setOutputIndex: " << Index << "\n");
+  assert(!hasOutputIndex());
+  OutputIndex = Index;
+}

wasm/InputFiles.h

 using llvm::wasm::WasmSignature;
 using llvm::wasm::WasmRelocation;
 
 namespace lld {
 namespace wasm {
 
 class InputChunk;
 class InputFunction;
+class InputGlobal;
 class InputSegment;
 
 class InputFile {
 public:
   enum Kind {
     ObjectKind,
     ArchiveKind,
   };
public:
   uint32_t calcNewValue(const WasmRelocation &Reloc) const;
 
   const WasmSection *CodeSection = nullptr;
   const WasmSection *DataSection = nullptr;
 
   std::vector<uint32_t> TypeMap;
   std::vector<bool> TypeIsUsed;
   std::vector<InputSegment *> Segments;
+  std::vector<InputGlobal *> Globals;
   std::vector<InputFunction *> Functions;
 
   ArrayRef<Symbol *> getSymbols() const { return Symbols; }
   Symbol *getFunctionSymbol(uint32_t Index) const;
+  Symbol *getDataSymbol(uint32_t Index) const;
   Symbol *getGlobalSymbol(uint32_t Index) const;
 
 private:
   uint32_t relocateVirtualAddress(uint32_t Index) const;
   uint32_t relocateFunctionIndex(uint32_t Original) const;
   uint32_t relocateTypeIndex(uint32_t Original) const;
   uint32_t relocateGlobalIndex(uint32_t Original) const;
   uint32_t relocateTableIndex(uint32_t Original) const;
   uint32_t relocateFunctionSymbolIndex(uint32_t Original) const;
   uint32_t relocateGlobalSymbolIndex(uint32_t Original) const;
+  uint32_t relocateDataSymbolIndex(uint32_t Original) const;
 
   Symbol *createDefined(const WasmSymbol &Sym, Symbol::Kind Kind,
                         InputChunk *Chunk = nullptr,
-                        uint32_t Address = UINT32_MAX);
-  Symbol *createUndefined(const WasmSymbol &Sym, Symbol::Kind Kind,
-                          const WasmSignature *Signature = nullptr);
+                        uint32_t DataAddress = UINT32_MAX,
+                        uint32_t DataSize = 0);
+  Symbol *createUndefined(const WasmSymbol &Sym, Symbol::Kind Kind);
+
   void initializeSymbols();
   InputSegment *getSegment(const WasmSymbol &WasmSym) const;
-  const WasmSignature *getFunctionSig(const WasmSymbol &Sym) const;
-  uint32_t getGlobalValue(const WasmSymbol &Sym) const;
+  std::pair<uint32_t,uint32_t> getDataAddressAndSize(
+      const WasmSymbol &WasmSym) const;
   InputFunction *getFunction(const WasmSymbol &Sym) const;
+  InputGlobal *getGlobal(const WasmSymbol &Sym) const;
   bool isExcludedByComdat(InputChunk *Chunk) const;
 
   // List of all symbols referenced or defined by this file.
   std::vector<Symbol *> Symbols;
 
   uint32_t NumGlobalImports = 0;
   uint32_t NumFunctionImports = 0;
   std::unique_ptr<WasmObjectFile> WasmObj;

wasm/InputFiles.cpp

Optional<MemoryBufferRef> lld::wasm::readFile(StringRef Path) {
   return MBRef;
 }
 
 void ObjFile::dumpInfo() const {
   log("info for: " + getName() + "\n" +
       "              Symbols : " + Twine(Symbols.size()) + "\n");
 }
 
-uint32_t ObjFile::relocateVirtualAddress(uint32_t GlobalIndex) const {
-  return getGlobalSymbol(GlobalIndex)->getVirtualAddress();
+uint32_t ObjFile::relocateVirtualAddress(uint32_t Index) const {
+  return getDataSymbol(Index)->getVirtualAddress();
 }
 
 uint32_t ObjFile::relocateFunctionIndex(uint32_t Original) const {
   const Symbol *Sym = getFunctionSymbol(Original);
   uint32_t Index = Sym->getOutputIndex();
   DEBUG(dbgs() << "relocateFunctionIndex: " << toString(*Sym) << ": "
                << Original << " -> " << Index << "\n");
   return Index;

 uint32_t ObjFile::relocateGlobalSymbolIndex(uint32_t Original) const {
   Symbol *Sym = getGlobalSymbol(Original);
   uint32_t Index = Sym->getOutputSymbolIndex();
   DEBUG(dbgs() << "relocateGlobalSymbolIndex: " << toString(*Sym) << ": "
                << Original << " -> " << Index << "\n");
   return Index;
 }
 
+uint32_t ObjFile::relocateDataSymbolIndex(uint32_t Original) const {
+  Symbol *Sym = getDataSymbol(Original);
+  uint32_t Index = Sym->getOutputSymbolIndex();
+  DEBUG(dbgs() << "relocateDataSymbolIndex: " << toString(*Sym) << ": "
+               << Original << " -> " << Index << "\n");
+  return Index;
+}
+
 // Relocations contain an index into the function, global or table index
 // space of the input file.  This function takes a relocation and returns the
 // relocated index (i.e. translates from the input index space to the output
 // index space).
 uint32_t ObjFile::calcNewIndex(const WasmRelocation &Reloc) const {
   switch (Reloc.Type) {
   case R_WEBASSEMBLY_TYPE_INDEX_LEB:
     return relocateTypeIndex(Reloc.Index);
   case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
   case R_WEBASSEMBLY_TABLE_INDEX_I32:
   case R_WEBASSEMBLY_TABLE_INDEX_SLEB:
     return relocateFunctionSymbolIndex(Reloc.Index);
   case R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
+    return relocateGlobalSymbolIndex(Reloc.Index);
   case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
   case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
   case R_WEBASSEMBLY_MEMORY_ADDR_I32:
-    return relocateGlobalSymbolIndex(Reloc.Index);
+    return relocateDataSymbolIndex(Reloc.Index);
   default:
     llvm_unreachable("unknown relocation type");
   }
 }
 
 // Translate from the relocation's index into the final linked output value.
 uint32_t ObjFile::calcNewValue(const WasmRelocation &Reloc) const {
   switch (Reloc.Type) {
void ObjFile::parse() {
   TypeMap.resize(getWasmObj()->types().size());
   TypeIsUsed.resize(getWasmObj()->types().size(), false);
 
   initializeSymbols();
 }
 
 // Return the InputSegment in which a given symbol is defined.
 InputSegment *ObjFile::getSegment(const WasmSymbol &WasmSym) const {
-  uint32_t Address = WasmObj->getWasmSymbolValue(WasmSym);
-  for (InputSegment *Segment : Segments) {
-    if (Address >= Segment->startVA() && Address < Segment->endVA()) {
-      DEBUG(dbgs() << "Found symbol in segment: " << WasmSym.Name << " -> "
-                   << Segment->getName() << "\n");
-
-      return Segment;
-    }
-  }
-  error("symbol not found in any segment: " + WasmSym.Name);
-  return nullptr;
-}
-
-// Get the value stored in the wasm global represented by this symbol.
-// This represents the virtual address of the symbol in the input file.
-uint32_t ObjFile::getGlobalValue(const WasmSymbol &Sym) const {
-  assert(Sym.ElementIndex >= NumGlobalImports);
-  const WasmGlobal &Global =
-      getWasmObj()->globals()[Sym.ElementIndex - NumGlobalImports];
-  assert(Global.Type.Type == llvm::wasm::WASM_TYPE_I32);
-  return Global.InitExpr.Value.Int32;
-}
-
-// Get the signature for a given function symbol, either by looking
-// it up in function sections (for defined functions), of the imports section
-// (for imported functions).
-const WasmSignature *ObjFile::getFunctionSig(const WasmSymbol &Sym) const {
-  DEBUG(dbgs() << "getFunctionSig: " << Sym.Name << "\n");
-  return &WasmObj->types()[Sym.FunctionType];
+  return Segments[WasmSym.Info.Segment.getValue().Segment];
+}
+
+std::pair<uint32_t,uint32_t> ObjFile::getDataAddressAndSize(
+    const WasmSymbol &WasmSym) const {
+  auto &Segment = WasmSym.Info.Segment.getValue();
+  return std::make_pair(getSegment(WasmSym)->startVA() + Segment.Offset,
+                        Segment.Size);
 }
 
 InputFunction *ObjFile::getFunction(const WasmSymbol &Sym) const {
-  assert(Sym.ElementIndex >= NumFunctionImports);
-  uint32_t FunctionIndex = Sym.ElementIndex - NumFunctionImports;
+  assert(Sym.Info.ElementIndex >= NumFunctionImports);
+  uint32_t FunctionIndex = Sym.Info.ElementIndex - NumFunctionImports;
   return Functions[FunctionIndex];
 }
 
+InputGlobal *ObjFile::getGlobal(const WasmSymbol &Sym) const {
+  assert(Sym.Info.ElementIndex >= NumGlobalImports);
+  uint32_t GlobalIndex = Sym.Info.ElementIndex - NumGlobalImports;
+  return Globals[GlobalIndex];
+}
+
 bool ObjFile::isExcludedByComdat(InputChunk *Chunk) const {
   StringRef Comdat = Chunk->getComdat();
   return !Comdat.empty() && Symtab->findComdat(Comdat) != this;
 }
 
 Symbol *ObjFile::getFunctionSymbol(uint32_t Index) const {
   Symbol *Sym = Symbols[Index];
   assert(Sym->isFunction());
   return Sym;
 }
 
+Symbol *ObjFile::getDataSymbol(uint32_t Index) const {
+  Symbol *Sym = Symbols[Index];
+  assert(Sym->isData());
+  return Sym;
+}
+
 Symbol *ObjFile::getGlobalSymbol(uint32_t Index) const {
   Symbol *Sym = Symbols[Index];
   assert(Sym->isGlobal());
   return Sym;
 }
 
 void ObjFile::initializeSymbols() {
   Symbols.reserve(WasmObj->getNumberOfSymbols());
for (const auto &C : WasmObj->comdats())
     Symtab->addComdat(C, this);
 
   for (const WasmSegment &S : WasmObj->dataSegments()) {
     InputSegment *Seg = make<InputSegment>(S, this);
     Seg->copyRelocations(*DataSection);
     Segments.emplace_back(Seg);
   }
 
+  for (const WasmGlobal &G : WasmObj->globals()) {
+    const WasmGlobalType &Sig = G.Type;
+    InputGlobal *Global = make<InputGlobal>(Sig, &G, this);
+    Globals.emplace_back(Global);
+  }
+
   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);
     F->copyRelocations(*CodeSection);
     Functions.emplace_back(F);
   }
 
-  // Populate `FunctionSymbols` and `GlobalSymbols` based on the WasmSymbols
-  // in the object
+  // Populate `Symbols` based on the WasmSymbols in the object
   for (const SymbolRef &Sym : WasmObj->symbols()) {
     const WasmSymbol &WasmSym = WasmObj->getWasmSymbol(Sym.getRawDataRefImpl());
     Symbol *S;
-    switch (WasmSym.Type) {
-    case WasmSymbol::SymbolType::FUNCTION_EXPORT: {
+    switch (WasmSym.Info.Kind) {
+    case WASM_SYMBOL_TYPE_FUNCTION:
+      if (WasmSym.isDefined()) {
         InputFunction *Function = getFunction(WasmSym);
         if (!isExcludedByComdat(Function)) {
-        S = createDefined(WasmSym, Symbol::Kind::DefinedFunctionKind, Function);
+          S = createDefined(WasmSym, Symbol::Kind::DefinedFunctionKind,
+                            Function);
           break;
         } else {
           Function->Discarded = true;
-        LLVM_FALLTHROUGH; // Exclude function, and add the symbol as undefined
+          // Exclude function, and add the symbol as undefined
         }
       }
-    case WasmSymbol::SymbolType::FUNCTION_IMPORT:
-      S = createUndefined(WasmSym, Symbol::Kind::UndefinedFunctionKind,
-                          getFunctionSig(WasmSym));
+      S = createUndefined(WasmSym, Symbol::Kind::UndefinedFunctionKind);
       break;
-    case WasmSymbol::SymbolType::GLOBAL_EXPORT: {
+
+    case WASM_SYMBOL_TYPE_DATA:
+      if (WasmSym.isDefined()) {
         InputSegment *Segment = getSegment(WasmSym);
         if (!isExcludedByComdat(Segment)) {
-        S = createDefined(WasmSym, Symbol::Kind::DefinedGlobalKind, Segment,
-                          getGlobalValue(WasmSym));
+          uint32_t DataAddress, DataSize;
+          std::tie(DataAddress, DataSize) = getDataAddressAndSize(WasmSym);
+          S = createDefined(WasmSym, Symbol::Kind::DefinedDataKind, Segment,
+                            DataAddress, DataSize);
           break;
         } else {
           Segment->Discarded = true;
-        LLVM_FALLTHROUGH; // Exclude global, and add the symbol as undefined
+          // Exclude data, and add the symbol as undefined
+        }
       }
+      S = createUndefined(WasmSym, Symbol::Kind::UndefinedDataKind);
+      break;
+
+    case WASM_SYMBOL_TYPE_GLOBAL:
+      if (WasmSym.isDefined()) {
+        InputGlobal *Global = getGlobal(WasmSym);
+        S = createDefined(WasmSym, Symbol::Kind::DefinedGlobalKind, Global);
+        break;
       }
-    case WasmSymbol::SymbolType::GLOBAL_IMPORT:
       S = createUndefined(WasmSym, Symbol::Kind::UndefinedGlobalKind);
       break;
     }
 
     Symbols.push_back(S);
   }
 }
 
-Symbol *ObjFile::createUndefined(const WasmSymbol &Sym, Symbol::Kind Kind,
-                                 const WasmSignature *Signature) {
-  return Symtab->addUndefined(Sym.Name, Kind, Sym.Flags, this, Signature);
+Symbol *ObjFile::createUndefined(const WasmSymbol &Sym, Symbol::Kind Kind) {
+  return Symtab->addUndefined(Sym.Info.Name, Kind, Sym.Info.Flags, this,
+                              Sym.FunctionType, Sym.GlobalType);
 }
 
 Symbol *ObjFile::createDefined(const WasmSymbol &Sym, Symbol::Kind Kind,
-                               InputChunk *Chunk, uint32_t Address) {
+                               InputChunk *Chunk, uint32_t DataAddress,
+                               uint32_t DataSize) {
   Symbol *S;
   if (Sym.isBindingLocal()) {
-    S = make<Symbol>(Sym.Name, true);
-    S->update(Kind, this, Sym.Flags, Chunk, Address);
+    S = make<Symbol>(Sym.Info.Name, true);
+    S->update(Kind, this, Sym.Info.Flags, Chunk, DataAddress, DataSize);
     return S;
   }
-  return Symtab->addDefined(Sym.Name, Kind, Sym.Flags, this, Chunk, Address);
+  return Symtab->addDefined(Sym.Info.Name, Kind, Sym.Info.Flags, this, Chunk,
+                            DataAddress, DataSize);
 }
 
 void ArchiveFile::parse() {
   // Parse a MemoryBufferRef as an archive file.
   DEBUG(dbgs() << "Parsing library: " << toString(this) << "\n");
   File = CHECK(Archive::create(MB), toString(this));
 
   // Read the symbol table to construct Lazy symbols.

wasm/MarkLive.cpp

auto EnqueueSuccessors = [Enqueue](InputChunk &Chunk) {
     for (const WasmRelocation Reloc : Chunk.getRelocations()) {
       switch (Reloc.Type) {
       case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
       case R_WEBASSEMBLY_TABLE_INDEX_I32:
       case R_WEBASSEMBLY_TABLE_INDEX_SLEB:
         Enqueue(Chunk.File->getFunctionSymbol(Reloc.Index));
         break;
       case R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
+        Enqueue(Chunk.File->getGlobalSymbol(Reloc.Index));
+        break;
       case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
       case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
       case R_WEBASSEMBLY_MEMORY_ADDR_I32:
-        Enqueue(Chunk.File->getGlobalSymbol(Reloc.Index));
+        Enqueue(Chunk.File->getDataSymbol(Reloc.Index));
         break;
       }
     }
   };
 
   while (!Q.empty())
     EnqueueSuccessors(*Q.pop_back_val());
 
   // Report garbage-collected sections.
   if (Config->PrintGcSections) {
     auto CheckChunk = [](const InputChunk *C) {
       if (!C->Live)
         message("removing unused section '" + C->getName() + "' in file '" +
                 C->getFileName() + "'");
     };
 
     for (const ObjFile *Obj : Symtab->ObjectFiles) {
       for (InputChunk *C : Obj->Functions)
         CheckChunk(C);
+      for (InputChunk *C : Obj->Globals)
+        CheckChunk(C);
       for (InputChunk *C : Obj->Segments)
         CheckChunk(C);
     }
   }
 }

wasm/OutputSegment.h

 
 namespace lld {
 namespace wasm {
 
 class InputSegment;
 
 class OutputSegment {
 public:
-  OutputSegment(StringRef N) : Name(N) {}
+  OutputSegment(StringRef N, uint32_t Index) : Name(N), Index(Index) {}
 
   void addInputSegment(InputSegment *Segment) {
     Alignment = std::max(Alignment, Segment->getAlignment());
     InputSegments.push_back(Segment);
     Size = llvm::alignTo(Size, Segment->getAlignment());
     Segment->setOutputSegment(this, Size);
     Size += Segment->getSize();
   }
 
   uint32_t getSectionOffset() const { return SectionOffset; }
 
   void setSectionOffset(uint32_t Offset) { SectionOffset = Offset; }
 
   StringRef Name;
+  const uint32_t Index;
   uint32_t Alignment = 0;
   uint32_t StartVA = 0;
   std::vector<InputSegment *> InputSegments;
 
   // Sum of the size of the all the input segments
   uint32_t Size = 0;
 
   // Segment header

wasm/SymbolTable.h

 #include "InputFiles.h"
 #include "Symbols.h"
 
 #include "llvm/ADT/CachedHashString.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/raw_ostream.h"
 
 using llvm::wasm::WasmSignature;
+using llvm::wasm::WasmGlobalType;
 
 namespace lld {
 namespace wasm {
 
 class InputSegment;
 
 // SymbolTable is a bucket of all known symbols, including defined,
 // undefined, or lazy symbols (the last one is symbols in archive
public:
   void reportRemainingUndefines();
 
   ArrayRef<Symbol *> getSymbols() const { return SymVector; }
   Symbol *find(StringRef Name);
   ObjFile *findComdat(StringRef Name) const;
 
   Symbol *addDefined(StringRef Name, Symbol::Kind Kind, uint32_t Flags,
                      InputFile *F, InputChunk *Chunk = nullptr,
-                     uint32_t Address = 0);
+                     uint32_t DataAddress = UINT32_MAX, uint32_t DataSize = 0);
   Symbol *addUndefined(StringRef Name, Symbol::Kind Kind, uint32_t Flags,
-                       InputFile *F, const WasmSignature *Signature = nullptr);
+                       InputFile *F,
+                       const WasmSignature *FunctionSignature = nullptr,
+                       const WasmGlobalType *GlobalSignature = nullptr);
   Symbol *addUndefinedFunction(StringRef Name, const WasmSignature *Type);
-  Symbol *addDefinedGlobal(StringRef Name);
   Symbol *addDefinedFunction(StringRef Name, const WasmSignature *Type,
-                             uint32_t Flags);
+                             uint32_t Flags = 0);
+  Symbol *addDefinedData(StringRef Name, uint32_t Flags = 0);
+  Symbol *addDefinedGlobal(StringRef Name, const WasmGlobalType *Type,
+                           uint32_t Flags = 0);
   void addLazy(ArchiveFile *F, const Archive::Symbol *Sym);
   bool addComdat(StringRef Name, ObjFile *);
 
 private:
   std::pair<Symbol *, bool> insert(StringRef Name);
 
   llvm::DenseMap<llvm::CachedHashStringRef, ObjFile *> ComdatMap;
   llvm::DenseMap<llvm::CachedHashStringRef, Symbol *> SymMap;

wasm/SymbolTable.cpp

void SymbolTable::reportDuplicate(Symbol *Existing, InputFile *NewFile) {
   error("duplicate symbol: " + toString(*Existing) + "\n>>> defined in " +
         toString(Existing->getFile()) + "\n>>> defined in " +
         toString(NewFile));
 }
 
 // Check the type of new symbol matches that of the symbol is replacing.
 // For functions this can also involve verifying that the signatures match.
 static void checkSymbolTypes(const Symbol &Existing, const InputFile &F,
-                             Symbol::Kind Kind, const WasmSignature *NewSig) {
+                             Symbol::Kind Kind,
+                             const WasmSignature *NewFunctionSig,
+                             const WasmGlobalType *NewGlobalSig) {
   if (Existing.isLazy())
     return;
 
-  bool NewIsFunction = Kind == Symbol::Kind::UndefinedFunctionKind ||
-                       Kind == Symbol::Kind::DefinedFunctionKind;
+  WasmSymbolType NewType = toWasmType(Kind);
+  WasmSymbolType ExistingType = toWasmType(Existing.getKind());
 
   // First check the symbol types match (i.e. either both are function
   // symbols or both are data symbols).
-  if (Existing.isFunction() != NewIsFunction) {
+  if (NewType != ExistingType) {
     error("symbol type mismatch: " + Existing.getName() + "\n>>> defined as " +
-          (Existing.isFunction() ? "Function" : "Global") + " in " +
-          toString(Existing.getFile()) + "\n>>> defined as " +
-          (NewIsFunction ? "Function" : "Global") + " in " + F.getName());
+          toString(ExistingType) + " in " + toString(Existing.getFile()) +
+          "\n>>> defined as " + toString(NewType) + " in " + F.getName());
     return;
   }
 
-  // For function symbols, optionally check the function signature matches too.
-  if (!NewIsFunction || !Config->CheckSignatures)
+  // For function/global symbols, optionally check the signature matches too.
+  if (NewType == WASM_SYMBOL_TYPE_DATA || !Config->CheckSignatures)
     return;
+
+  DEBUG(dbgs() << "checkSymbolTypes: " << Existing.getName() << "\n");
+
+  std::string OldSigStr, NewSigStr;
+  if (NewType == WASM_SYMBOL_TYPE_FUNCTION) {
     // Skip the signature check if the existing function has no signature (e.g.
     // if it is an undefined symbol generated by --undefined command line flag).
     if (!Existing.hasFunctionType())
       return;
 
-  DEBUG(dbgs() << "checkSymbolTypes: " << Existing.getName() << "\n");
-  assert(NewSig);
-
-  const WasmSignature &OldSig = Existing.getFunctionType();
-  if (*NewSig == OldSig)
+    assert(NewFunctionSig != nullptr);
+    const WasmSignature& OldSig = Existing.getFunctionType();
+    if (*NewFunctionSig == OldSig)
       return;
 
-  error("function signature mismatch: " + Existing.getName() +
-        "\n>>> defined as " + toString(OldSig) + " in " +
-        toString(Existing.getFile()) + "\n>>> defined as " + toString(*NewSig) +
+    OldSigStr = toString(OldSig);
+    NewSigStr = toString(*NewFunctionSig);
+  } else {
+    assert(NewType == WASM_SYMBOL_TYPE_GLOBAL);
+    if (!Existing.hasGlobalType())
+      return;
+
+    assert(NewGlobalSig != nullptr);
+    const WasmGlobalType &OldSig = Existing.getGlobalType();
+    if (*NewGlobalSig == OldSig)
+      return;
+
+    OldSigStr = toString(OldSig);
+    NewSigStr = toString(*NewGlobalSig);
+  }
+
+  error(toString(NewType) + " signature mismatch: " + Existing.getName() +
+        "\n>>> defined as " + OldSigStr + " in " +
+        toString(Existing.getFile()) + "\n>>> defined as " + NewSigStr +
         " in " + F.getName());
 }
 
 static void checkSymbolTypes(const Symbol &Existing, const InputFile &F,
                              Symbol::Kind Kind, const InputChunk *Chunk) {
-  const WasmSignature *Sig = nullptr;
-  if (auto *F = dyn_cast_or_null<InputFunction>(Chunk))
-    Sig = &F->Signature;
-  return checkSymbolTypes(Existing, F, Kind, Sig);
+  const WasmSignature *FunctionSig = nullptr;
+  if (auto *Function = dyn_cast_or_null<InputFunction>(Chunk))
+    FunctionSig = &Function->Signature;
+  const WasmGlobalType *GlobalSig = nullptr;
+  if (auto *Global = dyn_cast_or_null<InputGlobal>(Chunk))
+    GlobalSig = &Global->Signature;
+  return checkSymbolTypes(Existing, F, Kind, FunctionSig, GlobalSig);
 }
 
 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);
   } else if (!S->isDefined()) {
     DEBUG(dbgs() << "resolving existing undefined function: " << Name << "\n");
     S->update(Symbol::DefinedFunctionKind, nullptr, Flags);
   }
   return S;
 }
 
-Symbol *SymbolTable::addDefinedGlobal(StringRef Name) {
+Symbol *SymbolTable::addDefinedData(StringRef Name, uint32_t Flags) {
+  DEBUG(dbgs() << "addDefinedData: " << Name << "\n");
+  Symbol *S;
+  bool WasInserted;
+  std::tie(S, WasInserted) = insert(Name);
+  if (WasInserted) {
+    S->update(Symbol::DefinedDataKind, nullptr, Flags);
+  } else if (!S->isData()) {
+    error("symbol type mismatch: " + Name);
+  } else if (!S->isDefined()) {
+    DEBUG(dbgs() << "resolving existing undefined data: " << Name << "\n");
+    S->update(Symbol::DefinedDataKind, nullptr, Flags);
+  }
+  return S;
+}
+
+Symbol *SymbolTable::addDefinedGlobal(StringRef Name,
+                                      const WasmGlobalType *Type,
+                                      uint32_t Flags) {
   DEBUG(dbgs() << "addDefinedGlobal: " << Name << "\n");
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
   if (WasInserted) {
-    S->update(Symbol::DefinedGlobalKind);
+    S->update(Symbol::DefinedGlobalKind, nullptr, Flags);
+    S->setGlobalType(Type);
   } else if (!S->isGlobal()) {
     error("symbol type mismatch: " + Name);
   } else {
     DEBUG(dbgs() << "resolving existing undefined global: " << Name << "\n");
-    S->update(Symbol::DefinedGlobalKind);
+    S->update(Symbol::DefinedGlobalKind, nullptr, Flags);
   }
   return S;
 }
 
 Symbol *SymbolTable::addDefined(StringRef Name, Symbol::Kind Kind,
                                 uint32_t Flags, InputFile *F, InputChunk *Chunk,
-                                uint32_t Address) {
-  DEBUG(dbgs() << "addDefined: " << Name << " addr:" << Address << "\n");
+                                uint32_t DataAddress, uint32_t DataSize) {
+  DEBUG(dbgs() << "addDefined: " << Name << "\n");
   Symbol *S;
   bool WasInserted;
 
   std::tie(S, WasInserted) = insert(Name);
   if (WasInserted) {
-    S->update(Kind, F, Flags, Chunk, Address);
+    S->update(Kind, F, Flags, Chunk, DataAddress, DataSize);
   } else if (S->isLazy()) {
     // The existing symbol is lazy. Replace it without checking types since
     // lazy symbols don't have any type information.
     DEBUG(dbgs() << "replacing existing lazy symbol: " << Name << "\n");
-    S->update(Kind, F, Flags, Chunk, Address);
+    S->update(Kind, F, Flags, Chunk, DataAddress, DataSize);
   } else if (!S->isDefined()) {
     // The existing symbol table entry is undefined. The new symbol replaces
     // it, after checking the type matches
     DEBUG(dbgs() << "resolving existing undefined symbol: " << Name << "\n");
     checkSymbolTypes(*S, *F, Kind, Chunk);
-    S->update(Kind, F, Flags, Chunk, Address);
+    S->update(Kind, F, Flags, Chunk, DataAddress, DataSize);
   } else if ((Flags & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_WEAK) {
     // the new symbol is weak we can ignore it
     DEBUG(dbgs() << "existing symbol takes precedence\n");
   } else if (S->isWeak()) {
     // the new symbol is not weak and the existing symbol is, so we replace
     // it
     DEBUG(dbgs() << "replacing existing weak symbol\n");
     checkSymbolTypes(*S, *F, Kind, Chunk);
-    S->update(Kind, F, Flags, Chunk, Address);
+    S->update(Kind, F, Flags, Chunk, DataAddress, DataSize);
   } else {
     // neither symbol is week. They conflict.
     reportDuplicate(S, F);
   }
   return S;
 }
 
 Symbol *SymbolTable::addUndefinedFunction(StringRef Name,
                                           const WasmSignature *Type) {
   DEBUG(dbgs() << "addUndefinedFunction: " << Name << "\n");
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
   if (WasInserted) {
     S->update(Symbol::UndefinedFunctionKind);
     S->setFunctionType(Type);
   } else if (!S->isFunction()) {
     error("symbol type mismatch: " + Name);
   }
   return S;
 }
 
 Symbol *SymbolTable::addUndefined(StringRef Name, Symbol::Kind Kind,
                                   uint32_t Flags, InputFile *F,
-                                  const WasmSignature *Type) {
+                                  const WasmSignature *FunctionType,
+                                  const WasmGlobalType *GlobalType) {
   DEBUG(dbgs() << "addUndefined: " << Name << "\n");
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
   if (WasInserted) {
     S->update(Kind, F, Flags);
-    if (Type)
-      S->setFunctionType(Type);
+    if (FunctionType)
+      S->setFunctionType(FunctionType);
+    if (GlobalType)
+      S->setGlobalType(GlobalType);
   } else if (S->isLazy()) {
     DEBUG(dbgs() << "resolved by existing lazy\n");
     auto *AF = cast<ArchiveFile>(S->getFile());
     AF->addMember(&S->getArchiveSymbol());
   } else if (S->isDefined()) {
     DEBUG(dbgs() << "resolved by existing\n");
-    checkSymbolTypes(*S, *F, Kind, Type);
+    checkSymbolTypes(*S, *F, Kind, FunctionType, GlobalType);
   }
   return S;
 }
 
 void SymbolTable::addLazy(ArchiveFile *F, const Archive::Symbol *Sym) {
   DEBUG(dbgs() << "addLazy: " << Sym->getName() << "\n");
   StringRef Name = Sym->getName();
   Symbol *S;

wasm/Symbols.h

 #ifndef LLD_WASM_SYMBOLS_H
 #define LLD_WASM_SYMBOLS_H
 
 #include "lld/Common/LLVM.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/Wasm.h"
 
 using llvm::object::Archive;
+using llvm::object::WasmSymbol;
 using llvm::wasm::WasmSignature;
+using llvm::wasm::WasmGlobalType;
+using llvm::wasm::WasmSymbolType;
 
 namespace lld {
 namespace wasm {
 
 class InputFile;
 class InputChunk;
 
 class Symbol {
 public:
   enum Kind {
     DefinedFunctionKind,
+    DefinedDataKind,
     DefinedGlobalKind,
 
     LazyKind,
     UndefinedFunctionKind,
+    UndefinedDataKind,
     UndefinedGlobalKind,
 
     LastDefinedKind = DefinedGlobalKind,
     InvalidKind,
   };
 
   Symbol(StringRef Name, uint32_t Flags) : Flags(Flags), Name(Name) {}
 
   Kind getKind() const { return SymbolKind; }
 
   bool isLazy() const { return SymbolKind == LazyKind; }
   bool isDefined() const { return SymbolKind <= LastDefinedKind; }
   bool isUndefined() const {
-    return SymbolKind == UndefinedGlobalKind ||
-           SymbolKind == UndefinedFunctionKind;
+    return SymbolKind == UndefinedFunctionKind ||
+           SymbolKind == UndefinedDataKind ||
+           SymbolKind == UndefinedGlobalKind;
   }
   bool isFunction() const {
     return SymbolKind == DefinedFunctionKind ||
            SymbolKind == UndefinedFunctionKind;
   }
-  bool isGlobal() const { return !isFunction(); }
+  bool isData() const {
+    return SymbolKind == DefinedDataKind ||
+           SymbolKind == UndefinedDataKind;
+  }
+  bool isGlobal() const {
+    return SymbolKind == DefinedGlobalKind ||
+           SymbolKind == UndefinedGlobalKind;
+  }
   bool isLocal() const;
   bool isWeak() const;
   bool isHidden() const;
 
   // Returns the symbol name.
   StringRef getName() const { return Name; }
 
   // Returns the file from which this symbol was created.
   InputFile *getFile() const { return File; }
   InputChunk *getChunk() const { return Chunk; }
 
   bool hasFunctionType() const { return FunctionType != nullptr; }
   const WasmSignature &getFunctionType() const;
   void setFunctionType(const WasmSignature *Type);
+
+  bool hasGlobalType() const { return GlobalType != nullptr; }
+  const WasmGlobalType &getGlobalType() const;
+  void setGlobalType(const WasmGlobalType *Type);
+
   void setHidden(bool IsHidden);
 
   uint32_t getOutputIndex() const;
 
   // Returns true if an output index has been set for this symbol
   bool hasOutputIndex() const;
 
-  // Set the output index of the symbol, in the function or global Wasm
-  // index space of the output object - that is, for defined symbols only,
-  // its position in the list of defined function bodies / global decls.
+  // Set the output index of the symbol, in the Wasm index space of the output
+  // object - that is, for defined symbols only, its position in the list of
+  // Wasm imports+code for functions, imports+globals for globals.
   void setOutputIndex(uint32_t Index);
 
-  // Get/set the output symbol index, in the function or global Symbol index
-  // space - that is, the position in the list of imports+exports.  This is
+  // Get/set the output symbol index, in the Symbol index space.  This is
   // only used for relocatable output.
   uint32_t getOutputSymbolIndex() const;
   void setOutputSymbolIndex(uint32_t Index);
 
   uint32_t getTableIndex() const;
 
   // Returns true if a table index has been set for this symbol
   bool hasTableIndex() const;
 
   // Set the table index of the symbol
   void setTableIndex(uint32_t Index);
 
-  // Returns the virtual address of a defined global.
-  // Only works for globals, not functions.
+  // Returns the output virtual address of a defined data symbol.
   uint32_t getVirtualAddress() const;
+  void setVirtualAddress(uint32_t Value);
 
-  void setVirtualAddress(uint32_t VA);
+  // Returns the offset of a defined data symbol within its OutputSegment.
+  uint32_t getOutputSegmentOffset() const;
+  uint32_t getVirtualSize() const { return VirtualSize; }
 
   void update(Kind K, InputFile *F = nullptr, uint32_t Flags = 0,
-              InputChunk *chunk = nullptr, uint32_t Address = UINT32_MAX);
+              InputChunk *Chunk = nullptr, uint32_t Address = UINT32_MAX,
+              uint32_t Size = 0);
+  void updateChunk(InputChunk *C) { Chunk = C; }
 
   void setArchiveSymbol(const Archive::Symbol &Sym) { ArchiveSymbol = Sym; }
   const Archive::Symbol &getArchiveSymbol() { return ArchiveSymbol; }
 
 protected:
   uint32_t Flags;
   uint32_t VirtualAddress = 0;
+  uint32_t VirtualSize = 0;
 
   StringRef Name;
   Archive::Symbol ArchiveSymbol = {nullptr, 0, 0};
   Kind SymbolKind = InvalidKind;
   InputFile *File = nullptr;
   InputChunk *Chunk = nullptr;
   llvm::Optional<uint32_t> OutputIndex;
   llvm::Optional<uint32_t> OutputSymbolIndex;
   llvm::Optional<uint32_t> TableIndex;
   const WasmSignature *FunctionType = nullptr;
+  const WasmGlobalType *GlobalType = nullptr;
 };
 
 // linker-generated symbols
 struct WasmSym {
   // __stack_pointer
   // Global that holds the address of the top of the explicit value stack in
   // linear memory.
   static Symbol *StackPointer;
struct WasmSym {
   static Symbol *DsoHandle;
 };
 
 } // namespace wasm
 
 // Returns a symbol name for an error message.
 std::string toString(const wasm::Symbol &Sym);
 std::string toString(wasm::Symbol::Kind Kind);
+std::string toString(WasmSymbolType Type);
+WasmSymbolType toWasmType(wasm::Symbol::Kind Kind);
 
 } // namespace lld
 
 #endif

wasm/Symbols.cpp

 }
 
 void Symbol::setFunctionType(const WasmSignature *Type) {
   assert(FunctionType == nullptr);
   assert(!Chunk);
   FunctionType = Type;
 }
 
+const WasmGlobalType &Symbol::getGlobalType() const {
+  if (auto *G = dyn_cast_or_null<InputGlobal>(Chunk))
+    return G->Signature;
+
+  assert(GlobalType != nullptr);
+  return *GlobalType;
+}
+
+void Symbol::setGlobalType(const WasmGlobalType *Type) {
+  assert(GlobalType == nullptr);
+  assert(Chunk == nullptr);
+  GlobalType = Type;
+}
+
 uint32_t Symbol::getVirtualAddress() const {
-  assert(isGlobal());
+  assert(isData());
   DEBUG(dbgs() << "getVirtualAddress: " << getName() << "\n");
   return Chunk ? dyn_cast<InputSegment>(Chunk)->translateVA(VirtualAddress)
                : VirtualAddress;
 }
 
+uint32_t Symbol::getOutputSegmentOffset() const {
+  assert(isData() && hasOutputIndex());
+  DEBUG(dbgs() << "getOutputSegmentOffset: " << getName() << "\n");
+  const InputSegment *Segment = dyn_cast<InputSegment>(Chunk);
+  return Segment->OutputSegmentOffset + (VirtualAddress - Segment->startVA());
+}
+
 bool Symbol::hasOutputIndex() const {
-  if (auto *F = dyn_cast_or_null<InputFunction>(Chunk))
-    return F->hasOutputIndex();
-  return OutputIndex.hasValue();
+  return Chunk ? Chunk->hasOutputIndex() : OutputIndex.hasValue();
 }
 
 uint32_t Symbol::getOutputIndex() const {
-  if (auto *F = dyn_cast_or_null<InputFunction>(Chunk))
-    return F->getOutputIndex();
-  return OutputIndex.getValue();
+  return Chunk ? Chunk->getOutputIndex() : OutputIndex.getValue();
 }
 
 uint32_t Symbol::getOutputSymbolIndex() const {
   return OutputSymbolIndex.getValue();
 }
 
 void Symbol::setVirtualAddress(uint32_t Value) {
   DEBUG(dbgs() << "setVirtualAddress " << Name << " -> " << Value << "\n");
-  assert(isGlobal());
+  assert(isData());
   VirtualAddress = Value;
 }
 
 void Symbol::setOutputIndex(uint32_t Index) {
   DEBUG(dbgs() << "setOutputIndex " << Name << " -> " << Index << "\n");
-  assert(!dyn_cast_or_null<InputFunction>(Chunk));
+  assert(!Chunk);
   assert(!OutputIndex.hasValue());
   OutputIndex = Index;
 }
 
 void Symbol::setOutputSymbolIndex(uint32_t Index) {
   DEBUG(dbgs() << "setOutputSymbolIndex " << Name << " -> " << Index << "\n");
   assert(!OutputSymbolIndex.hasValue());
   OutputSymbolIndex = Index;
if (auto *F = dyn_cast_or_null<InputFunction>(Chunk)) {
     return;
   }
   DEBUG(dbgs() << "setTableIndex " << Name << " -> " << Index << "\n");
   assert(!TableIndex.hasValue());
   TableIndex = Index;
 }
 
 void Symbol::update(Kind K, InputFile *F, uint32_t Flags_, InputChunk *Chunk_,
-                    uint32_t Address) {
+                    uint32_t Address, uint32_t Size) {
   SymbolKind = K;
   File = F;
   Flags = Flags_;
   Chunk = Chunk_;
-  if (Address != UINT32_MAX)
+  if (Address != UINT32_MAX) {
     setVirtualAddress(Address);
+    VirtualSize = Size;
+  }
 }
 
 bool Symbol::isWeak() const {
   return (Flags & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_WEAK;
 }
 
 bool Symbol::isLocal() const {
   return (Flags & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_LOCAL;
if (Optional<std::string> S = demangleItanium(Sym.getName()))
       return "`" + *S + "'";
   return Sym.getName();
 }
 
 std::string lld::toString(wasm::Symbol::Kind Kind) {
   switch (Kind) {
   case wasm::Symbol::DefinedFunctionKind:
     return "DefinedFunction";
+  case wasm::Symbol::DefinedDataKind:
+    return "DefinedData";
   case wasm::Symbol::DefinedGlobalKind:
     return "DefinedGlobal";
   case wasm::Symbol::UndefinedFunctionKind:
     return "UndefinedFunction";
+  case wasm::Symbol::UndefinedDataKind:
+    return "UndefinedData";
   case wasm::Symbol::UndefinedGlobalKind:
     return "UndefinedGlobal";
   case wasm::Symbol::LazyKind:
     return "LazyKind";
   }
   llvm_unreachable("Invalid symbol kind!");
 }
+
+std::string lld::toString(WasmSymbolType Type) {
+  switch (Type) {
+  case llvm::wasm::WASM_SYMBOL_TYPE_FUNCTION:
+    return "Function";
+  case llvm::wasm::WASM_SYMBOL_TYPE_DATA:
+    return "Data";
+  case llvm::wasm::WASM_SYMBOL_TYPE_GLOBAL:
+    return "Global";
+  }
+  llvm_unreachable("Invalid symbol type");
+  return "";
+}
+
+WasmSymbolType lld::toWasmType(wasm::Symbol::Kind Kind) {
+  switch (Kind) {
+  case wasm::Symbol::DefinedFunctionKind:
+  case wasm::Symbol::UndefinedFunctionKind:
+    return llvm::wasm::WASM_SYMBOL_TYPE_FUNCTION;
+  case wasm::Symbol::DefinedDataKind:
+  case wasm::Symbol::UndefinedDataKind:
+    return llvm::wasm::WASM_SYMBOL_TYPE_DATA;
+  case wasm::Symbol::DefinedGlobalKind:
+  case wasm::Symbol::UndefinedGlobalKind:
+    return llvm::wasm::WASM_SYMBOL_TYPE_GLOBAL;
+  default:
+    llvm_unreachable("kind with no type");
+    return static_cast<WasmSymbolType>(-1);
+  }
+}

wasm/Writer.cpp

 #include "lld/Common/Threads.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/LEB128.h"
 
 #include <cstdarg>
 #include <map>
+#include <llvm/BinaryFormat/Wasm.h>
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;
 using namespace lld;
 using namespace lld::wasm;
 
for (int32_t Param : Sig.ParamTypes)
       Value += DenseMapInfo<int32_t>::getHashValue(Param);
     return Value;
   }
   static bool isEqual(const WasmSignature &LHS, const WasmSignature &RHS) {
     return LHS == RHS;
   }
 };
 
-// A Wasm export to be written into the export section.
-struct WasmExportEntry {
-  const Symbol *Sym;
-  StringRef FieldName; // may not match the Symbol name
-};
-
-// An init entry to be written to either the synthentic init func or the
+// An init entry to be written to either the synthetic init func or the
 // linking metadata.
 struct WasmInitEntry {
   const Symbol *Sym;
   uint32_t Priority;
 };
 
 // The writer writes a SymbolTable result to a file.
 class Writer {
 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 calculateExports();
+  void assignSymtab();
   void calculateTypes();
   void createOutputSegments();
   void layoutMemory();
   void createHeader();
   void createSections();
   SyntheticSection *createSyntheticSection(uint32_t Type,
                                            StringRef Name = "");
 
private:
   uint32_t DataSize = 0;
   uint32_t NumMemoryPages = 0;
 
   std::vector<const WasmSignature *> Types;
   DenseMap<WasmSignature, int32_t, WasmSignatureDenseMapInfo> TypeIndices;
   std::vector<const Symbol *> ImportedSymbols;
   unsigned NumImportedFunctions = 0;
   unsigned NumImportedGlobals = 0;
-  std::vector<WasmExportEntry> ExportedSymbols;
-  std::vector<Symbol *> DefinedGlobals;
+  std::vector<Symbol *> ExportedSymbols;
+  std::vector<const Symbol *> DefinedFakeGlobals;
+  std::vector<InputGlobal *> DefinedGlobals;
   std::vector<InputFunction *> DefinedFunctions;
   std::vector<const Symbol *> IndirectFunctions;
+  std::vector<const Symbol *> SymtabEntries;
   std::vector<WasmInitEntry> 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::unique_ptr<SyntheticGlobal> StackPtrGlobal;
 
   std::vector<OutputSegment *> Segments;
   llvm::SmallDenseMap<StringRef, OutputSegment *> SegmentMap;
 };
 
 } // anonymous namespace
 
 static void debugPrint(const char *fmt, ...) {
void Writer::createImportSection() {
 
   for (const Symbol *Sym : ImportedSymbols) {
     WasmImport Import;
     Import.Module = "env";
     Import.Field = Sym->getName();
     if (Sym->isFunction()) {
       Import.Kind = WASM_EXTERNAL_FUNCTION;
       Import.SigIndex = lookupType(Sym->getFunctionType());
-    } else {
+    } else if (Sym->isGlobal()) {
       Import.Kind = WASM_EXTERNAL_GLOBAL;
-      Import.Global.Mutable = false;
-      Import.Global.Type = WASM_TYPE_I32;
+      Import.Global = Sym->getGlobalType();
+    } else {
+      llvm_unreachable("invalid import type");
     }
     writeImport(OS, Import);
   }
 }
 
 void Writer::createTypeSection() {
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_TYPE);
   raw_ostream &OS = Section->getStream();
void Writer::createMemorySection() {
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, 1, "memory count");
   writeUleb128(OS, 0, "memory limits flags");
   writeUleb128(OS, NumMemoryPages, "initial pages");
 }
 
 void Writer::createGlobalSection() {
-  if (DefinedGlobals.empty())
+  unsigned NumGlobals = DefinedGlobals.size() + DefinedFakeGlobals.size();
+  if (NumGlobals == 0)
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_GLOBAL);
   raw_ostream &OS = Section->getStream();
 
-  writeUleb128(OS, DefinedGlobals.size(), "global count");
-  for (const Symbol *Sym : DefinedGlobals) {
+  writeUleb128(OS, NumGlobals, "global count");
+  for (const InputGlobal *G : DefinedGlobals) {
     WasmGlobal Global;
-    Global.Type.Type = WASM_TYPE_I32;
-    Global.Type.Mutable = Sym == WasmSym::StackPointer;
+    Global.Type = G->Signature;
+    Global.InitExpr = G->initExpr();
+    writeGlobal(OS, Global);
+  }
+  for (const Symbol *Sym : DefinedFakeGlobals) {
+    WasmGlobal Global;
+    Global.Type = {WASM_TYPE_I32, false};
     Global.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
     Global.InitExpr.Value.Int32 = Sym->getVirtualAddress();
     writeGlobal(OS, Global);
   }
 }
 
 void Writer::createTableSection() {
   // Always output a table section, even if there are no indirect calls.
void Writer::createExportSection() {
   if (ExportMemory) {
     WasmExport MemoryExport;
     MemoryExport.Name = "memory";
     MemoryExport.Kind = WASM_EXTERNAL_MEMORY;
     MemoryExport.Index = 0;
     writeExport(OS, MemoryExport);
   }
 
-  for (const WasmExportEntry &E : ExportedSymbols) {
-    DEBUG(dbgs() << "Export: " << E.Sym->getName() << "\n");
+  unsigned FakeGlobalIndex = NumImportedGlobals + DefinedGlobals.size();
+  for (const Symbol *Sym : ExportedSymbols) {
+    DEBUG(dbgs() << "Export: " << Sym->getName() << "\n");
     WasmExport Export;
-    Export.Name = E.FieldName;
-    Export.Index = E.Sym->getOutputIndex();
-    if (E.Sym->isFunction())
+    Export.Name = Sym->getName();
+    if (Sym->isFunction()) {
+      Export.Index = Sym->getOutputIndex();
       Export.Kind = WASM_EXTERNAL_FUNCTION;
-    else
+    } else if (Sym->isGlobal()) {
+      Export.Index = Sym->getOutputIndex();
       Export.Kind = WASM_EXTERNAL_GLOBAL;
+    } else {
+      Export.Index = FakeGlobalIndex++;
+      Export.Kind = WASM_EXTERNAL_GLOBAL;
+    }
     writeExport(OS, Export);
   }
 }
 
 void Writer::createStartSection() {}
 
 void Writer::createElemSection() {
   if (IndirectFunctions.empty())
void Writer::createLinkingSection() {
   SubSection DataSizeSubSection(WASM_DATA_SIZE);
   writeUleb128(DataSizeSubSection.getStream(), DataSize, "data size");
   DataSizeSubSection.finalizeContents();
   DataSizeSubSection.writeToStream(OS);
 
   if (!Config->Relocatable)
     return;
 
-  std::vector<std::pair<StringRef, uint32_t>> SymbolInfo;
-  auto addSymInfo = [&](const Symbol *Sym, StringRef ExternalName) {
+  if (!SymtabEntries.empty()) {
+    SubSection SubSection(WASM_SYMBOL_TABLE);
+    writeUleb128(SubSection.getStream(), SymtabEntries.size(), "num sym info");
+    for (const Symbol *Sym : SymtabEntries) {
+      assert(Sym->isDefined() || Sym->isUndefined());
+      uint32_t Kind = Sym->isFunction() ? llvm::wasm::WASM_SYMBOL_TYPE_FUNCTION :
+                      Sym->isGlobal()   ? llvm::wasm::WASM_SYMBOL_TYPE_GLOBAL
+                                        : llvm::wasm::WASM_SYMBOL_TYPE_DATA;
       uint32_t Flags =
           (Sym->isLocal() ? WASM_SYMBOL_BINDING_LOCAL :
            Sym->isWeak() ? WASM_SYMBOL_BINDING_WEAK : 0) |
           (Sym->isHidden() ? WASM_SYMBOL_VISIBILITY_HIDDEN : 0);
-    if (Flags)
-      SymbolInfo.emplace_back(ExternalName, Flags);
-  };
-  // (Imports can't have internal linkage, their names don't need to be budged.)
-  for (const Symbol *Sym : ImportedSymbols)
-    addSymInfo(Sym, Sym->getName());
-  for (const WasmExportEntry &E : ExportedSymbols)
-    addSymInfo(E.Sym, E.FieldName);
-  if (!SymbolInfo.empty()) {
-    SubSection SubSection(WASM_SYMBOL_INFO);
-    writeUleb128(SubSection.getStream(), SymbolInfo.size(), "num sym info");
-    for (auto Pair: SymbolInfo) {
-      writeStr(SubSection.getStream(), Pair.first, "sym name");
-      writeUleb128(SubSection.getStream(), Pair.second, "sym flags");
+      writeUleb128(SubSection.getStream(), Kind, "sym kind");
+      writeUleb128(SubSection.getStream(), Flags, "sym flags");
+      switch (Kind) {
+      case llvm::wasm::WASM_SYMBOL_TYPE_FUNCTION:
+      case llvm::wasm::WASM_SYMBOL_TYPE_GLOBAL:
+        writeUleb128(SubSection.getStream(), Sym->getOutputIndex(),
+                     "index");
+        if (Sym->isDefined())
+          writeStr(SubSection.getStream(), Sym->getName(), "sym name");
+        break;
+      case llvm::wasm::WASM_SYMBOL_TYPE_DATA:
+        writeStr(SubSection.getStream(), Sym->getName(), "sym name");
+        SubSection.getStream() << static_cast<uint8_t>(Sym->isDefined());
+        if (Sym->isDefined()) {
+          writeUleb128(SubSection.getStream(), Sym->getOutputIndex(),
+                       "index");
+          writeUleb128(SubSection.getStream(), Sym->getOutputSegmentOffset(),
+                       "data offset");
+          writeUleb128(SubSection.getStream(), Sym->getVirtualSize(),
+                       "data size");
+        }
+        break;
+      }
     }
     SubSection.finalizeContents();
     SubSection.writeToStream(OS);
   }
 
   if (Segments.size()) {
     SubSection SubSection(WASM_SEGMENT_INFO);
     writeUleb128(SubSection.getStream(), Segments.size(), "num data segments");
void Writer::layoutMemory() {
   // Stack comes after static data and bss
   if (!Config->Relocatable) {
     MemoryPtr = alignTo(MemoryPtr, kStackAlignment);
     if (Config->ZStackSize != alignTo(Config->ZStackSize, kStackAlignment))
       error("stack size must be " + Twine(kStackAlignment) + "-byte aligned");
     debugPrint("mem: stack size  = %d\n", Config->ZStackSize);
     debugPrint("mem: stack base  = %d\n", MemoryPtr);
     MemoryPtr += Config->ZStackSize;
-    WasmSym::StackPointer->setVirtualAddress(MemoryPtr);
+
+    WasmInitExpr StackInit;
+    StackInit.Opcode = WASM_OPCODE_I32_CONST;
+    StackInit.Value.Int32 = MemoryPtr;
+    StackPtrGlobal.reset(new SyntheticGlobal(
+        WasmSym::StackPointer->getGlobalType(), StackInit));
+    StackPtrGlobal->setOutputIndex(NumImportedGlobals + DefinedGlobals.size());
+    DefinedGlobals.emplace_back(StackPtrGlobal.get());
+    WasmSym::StackPointer->updateChunk(StackPtrGlobal.get());
     debugPrint("mem: stack top   = %d\n", MemoryPtr);
+
     // Set `__heap_base` to directly follow the end of the stack.  We don't
     // allocate any heap memory up front, but instead really on the malloc/brk
     // implementation growing the memory at runtime.
     WasmSym::HeapBase->setVirtualAddress(MemoryPtr);
     debugPrint("mem: heap base   = %d\n", MemoryPtr);
   }
 
   uint32_t MemSize = alignTo(MemoryPtr, WasmPageSize);
for (OutputSection *S : OutputSections) {
     S->setOffset(FileSize);
     S->finalizeContents();
     FileSize += S->getSize();
   }
 }
 
 void Writer::calculateImports() {
   for (Symbol *Sym : Symtab->getSymbols()) {
-    if (!Sym->isUndefined() || (Sym->isWeak() && !Config->Relocatable))
+    if (!Sym->isUndefined() || Sym->isData() ||
+        (Sym->isWeak() && !Config->Relocatable))
       continue;
 
     Sym->setOutputIndex(ImportedSymbols.size());
-    Sym->setOutputSymbolIndex(ImportedSymbols.size());
     ImportedSymbols.emplace_back(Sym);
     if (Sym->isFunction())
       ++NumImportedFunctions;
     else
       ++NumImportedGlobals;
   }
 }
 
 void Writer::calculateExports() {
-  bool ExportHidden = Config->Relocatable;
-  StringSet<> UsedNames;
+  if (Config->Relocatable)
+    return;
 
-  auto BudgeLocalName = [&](const Symbol *Sym) {
-    StringRef SymName = Sym->getName();
-    // We can't budge non-local names.
-    if (!Sym->isLocal())
-      return SymName;
-    // We must budge local names that have a collision with a symbol that we
-    // haven't yet processed.
-    if (!Symtab->find(SymName) && UsedNames.insert(SymName).second)
-      return SymName;
-    for (unsigned I = 1; ; ++I) {
-      std::string NameBuf = (SymName + "." + Twine(I)).str();
-      if (!UsedNames.count(NameBuf)) {
-        StringRef Name = Saver.save(NameBuf);
-        UsedNames.insert(Name); // Insert must use safe StringRef from save()
-        return Name;
-      }
+  auto ExportSym = [&](Symbol *Sym) {
+    if (!Sym->isDefined())
+      return;
+    if (Sym->isHidden() || Sym->isLocal())
+      return;
+
+    InputChunk *Chunk = Sym->getChunk(); // null for synthetic data symbols
+    if (Chunk && Sym->getChunk()->Discarded)
+      return;
+    // We should never be exporting a non-live symbol
+    assert(!Chunk || Sym->getChunk()->Live);
+
+    if (Sym->isData()) {
+      // TODO Remove this check here; for non-relocatable output we actually
+      // used only to create fake-global exports for the synthetic symbols.  Fix
+      // this in a future commit
+      if (Sym != WasmSym::DataEnd && Sym != WasmSym::HeapBase)
+        return;
+      DefinedFakeGlobals.emplace_back(Sym);
     }
+    ExportedSymbols.emplace_back(Sym);
   };
 
-  unsigned SymbolIndex = ImportedSymbols.size();
-  if (WasmSym::CallCtors && (!WasmSym::CallCtors->isHidden() || ExportHidden)) {
-    WasmSym::CallCtors->setOutputSymbolIndex(SymbolIndex++);
-    ExportedSymbols.emplace_back(
-        WasmExportEntry{WasmSym::CallCtors, WasmSym::CallCtors->getName()});
+  // TODO The two loops below should be replaced with this single loop, with
+  // ExportSym inlined:
+//  for (Symbol *Sym : Symtab->getSymbols())
+//    ExportSym(Sym);
+  // Making that change would reorder the output though, so it should be done as
+  // a separate commit.
+
+  for (ObjFile *File : Symtab->ObjectFiles) {
+    for (Symbol *Sym : File->getSymbols()) {
+      if (File == Sym->getFile())
+        ExportSym(Sym);
+    }
   }
+  for (Symbol *Sym : Symtab->getSymbols()) {
+    if (Sym->getFile() == nullptr)
+      ExportSym(Sym);
+  }
+}
+
+void Writer::assignSymtab() {
+  if (!Config->Relocatable)
+    return;
 
-  for (ObjFile *File : Symtab->ObjectFiles) {
+  unsigned SymbolIndex = SymtabEntries.size();
+  for (ObjFile* File : Symtab->ObjectFiles) {
+    DEBUG(dbgs() << "Symtab entries: " << File->getName() << "\n");
     for (Symbol *Sym : File->getSymbols()) {
-      if (!Sym->isDefined() || File != Sym->getFile())
-        continue;
-      if (Sym->isGlobal())
+      if (Sym->getFile() != File)
         continue;
+      if (Sym->isDefined()) {
         if (Sym->getChunk()->Discarded)
           continue;
-
-      if ((Sym->isHidden() || Sym->isLocal()) && !ExportHidden)
-        continue;
-
-      // We should never be exporting a non-live symbol
-      assert(Sym->getChunk()->Live);
-
+      } else {
+        assert(Sym->isUndefined()); // Can't be lazy
+      }
       Sym->setOutputSymbolIndex(SymbolIndex++);
-      ExportedSymbols.emplace_back(WasmExportEntry{Sym, BudgeLocalName(Sym)});
+      SymtabEntries.emplace_back(Sym);
     }
   }
 
-  for (Symbol *Sym : DefinedGlobals) {
-    // Can't export the SP right now because its mutable, and mutuable globals
-    // are yet supported in the official binary format.
-    // TODO(sbc): Remove this if/when the "mutable global" proposal is accepted.
-    if (Sym == WasmSym::StackPointer)
-      continue;
-    Sym->setOutputSymbolIndex(SymbolIndex++);
-    ExportedSymbols.emplace_back(WasmExportEntry{Sym, BudgeLocalName(Sym)});
-  }
+  // For the moment, relocatable output doesn't contain any synthetic functions,
+  // so no need to look through the Symtab for symbols not referenced by
+  // Symtab->ObjectFiles.
 }
 
 uint32_t Writer::lookupType(const WasmSignature &Sig) {
   auto It = TypeIndices.find(Sig);
   if (It == TypeIndices.end()) {
     error("type not found: " + toString(Sig));
     return 0;
   }
if (Sym->isFunction())
       registerType(Sym->getFunctionType());
 
   for (const InputFunction *F : DefinedFunctions)
     registerType(F->Signature);
 }
 
 void Writer::assignIndexes() {
   uint32_t GlobalIndex = NumImportedGlobals + DefinedGlobals.size();
-  uint32_t FunctionIndex = NumImportedFunctions + DefinedFunctions.size();
-
-  auto AddDefinedGlobal = [&](Symbol* Sym) {
-    if (Sym) {
-      DefinedGlobals.emplace_back(Sym);
-      Sym->setOutputIndex(GlobalIndex++);
-    }
-  };
-  AddDefinedGlobal(WasmSym::StackPointer);
-  AddDefinedGlobal(WasmSym::HeapBase);
-  AddDefinedGlobal(WasmSym::DataEnd);
-
-  if (Config->Relocatable)
-    DefinedGlobals.reserve(Symtab->getSymbols().size());
-
-  uint32_t TableIndex = kInitialTableOffset;
-
-  if (Config->Relocatable) {
-    for (ObjFile *File : Symtab->ObjectFiles) {
-      DEBUG(dbgs() << "Globals: " << File->getName() << "\n");
-      for (Symbol *Sym : File->getSymbols()) {
-        // Create wasm globals for data symbols defined in this file
-        if (!Sym->isDefined() || File != Sym->getFile())
-          continue;
-        if (Sym->isFunction())
-          continue;
-
-        AddDefinedGlobal(Sym);
-      }
+    for (InputGlobal *Global : File->Globals) {
+      if (Global->Discarded || !Global->Live)
+      DefinedGlobals.emplace_back(Global);
+      Global->setOutputIndex(GlobalIndex++);
     }
   }
 
+  uint32_t FunctionIndex = NumImportedFunctions + DefinedFunctions.size();
   for (ObjFile *File : Symtab->ObjectFiles) {
     DEBUG(dbgs() << "Functions: " << File->getName() << "\n");
     for (InputFunction *Func : File->Functions) {
       if (Func->Discarded || !Func->Live)
         continue;
       DefinedFunctions.emplace_back(Func);
       Func->setOutputIndex(FunctionIndex++);
     }
   }
 
+  uint32_t TableIndex = kInitialTableOffset;
   for (ObjFile *File : Symtab->ObjectFiles) {
     DEBUG(dbgs() << "Handle relocs: " << File->getName() << "\n");
     auto HandleRelocs = [&](InputChunk *Chunk) {
       if (Chunk->Discarded)
         return;
       ArrayRef<WasmSignature> Types = File->getWasmObj()->types();
       for (const WasmRelocation& Reloc : Chunk->getRelocations()) {
         if (Reloc.Type == R_WEBASSEMBLY_TABLE_INDEX_I32 ||
void Writer::createOutputSegments() {
   for (ObjFile *File : Symtab->ObjectFiles) {
     for (InputSegment *Segment : File->Segments) {
       if (Segment->Discarded || !Segment->Live)
         continue;
       StringRef Name = getOutputDataSegmentName(Segment->getName());
       OutputSegment *&S = SegmentMap[Name];
       if (S == nullptr) {
         DEBUG(dbgs() << "new segment: " << Name << "\n");
-        S = make<OutputSegment>(Name);
+        S = make<OutputSegment>(Name, Segments.size());
         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 = NumImportedFunctions + DefinedFunctions.size();
   WasmSym::CallCtors->setOutputIndex(FunctionIndex);
 
   // First write the body bytes to a string.
   std::string FunctionBody;
-  static WasmSignature Signature = {{}, WASM_TYPE_NORESULT};
+  const WasmSignature &Signature = WasmSym::CallCtors->getFunctionType();
   {
     raw_string_ostream OS(FunctionBody);
     writeUleb128(OS, 0, "num locals");
     for (const WasmInitEntry &F : InitFunctions) {
       writeU8(OS, OPCODE_CALL, "CALL");
       writeUleb128(OS, F.Sym->getOutputIndex(), "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;
   ArrayRef<uint8_t> BodyArray(
       reinterpret_cast<const uint8_t *>(CtorFunctionBody.data()),
       CtorFunctionBody.size());
   CtorFunction = llvm::make_unique<SyntheticFunction>(
       Signature, BodyArray, WasmSym::CallCtors->getName());
   CtorFunction->setOutputIndex(FunctionIndex);
+  WasmSym::CallCtors->updateChunk(CtorFunction.get());
   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) {
std::stable_sort(InitFunctions.begin(), InitFunctions.end(),
                    });
 }
 
 void Writer::run() {
   log("-- calculateImports");
   calculateImports();
   log("-- assignIndexes");
   assignIndexes();
-  log("-- calculateExports");
-  calculateExports();
   log("-- calculateInitFunctions");
   calculateInitFunctions();
   if (!Config->Relocatable)
     createCtorFunction();
   log("-- calculateTypes");
   calculateTypes();
+  log("-- layoutMemory");
+  layoutMemory();
+  log("-- calculateExports");
+  calculateExports();
+  log("-- assignSymtab");
+  assignSymtab();
 
   if (errorHandler().Verbose) {
     log("Defined Functions: " + Twine(DefinedFunctions.size()));
     log("Defined Globals  : " + Twine(DefinedGlobals.size()));
     log("Function Imports : " + Twine(NumImportedFunctions));
     log("Global Imports   : " + Twine(NumImportedGlobals));
     for (ObjFile *File : Symtab->ObjectFiles)
       File->dumpInfo();
   }
 
-  log("-- layoutMemory");
-  layoutMemory();
-
   createHeader();
   log("-- createSections");
   createSections();
 
   log("-- openFile");
   openFile();
   if (errorCount())
     return;

wasm/WriterUtils.h

inline bool operator==(const llvm::wasm::WasmSignature &LHS,
   return LHS.ReturnType == RHS.ReturnType && LHS.ParamTypes == RHS.ParamTypes;
 }
 
 inline bool operator!=(const llvm::wasm::WasmSignature &LHS,
                        const llvm::wasm::WasmSignature &RHS) {
   return !(LHS == RHS);
 }
 
+// Used for general comparison
+inline bool operator==(const llvm::wasm::WasmGlobalType &LHS,
+                       const llvm::wasm::WasmGlobalType &RHS) {
+  return LHS.Type == RHS.Type && LHS.Mutable == RHS.Mutable;
+}
+
+inline bool operator!=(const llvm::wasm::WasmGlobalType &LHS,
+                       const llvm::wasm::WasmGlobalType &RHS) {
+  return !(LHS == RHS);
+}
+
 namespace lld {
 namespace wasm {
 
 struct OutputRelocation {
   llvm::wasm::WasmRelocation Reloc;
   uint32_t NewIndex;
   uint32_t Value;
 };

 void writeExport(raw_ostream &OS, const llvm::wasm::WasmExport &Export);
 
 void writeReloc(raw_ostream &OS, const OutputRelocation &Reloc);
 
 } // namespace wasm
 
 std::string toString(const llvm::wasm::ValType Type);
 std::string toString(const llvm::wasm::WasmSignature &Sig);
+std::string toString(const llvm::wasm::WasmGlobalType &Sig);
 
 } // namespace lld
 
 #endif // LLD_WASM_WRITERUTILS_H

wasm/WriterUtils.cpp

std::string lld::toString(const WasmSignature &Sig) {
   }
   S += ") -> ";
   if (Sig.ReturnType == WASM_TYPE_NORESULT)
     S += "void";
   else
     S += toString(static_cast<ValType>(Sig.ReturnType));
   return S.str();
 }
+
+std::string lld::toString(const WasmGlobalType &Sig) {
+  SmallString<128> S;
+  if (Sig.Mutable)
+    S += "mutable ";
+  S += toString(static_cast<ValType>(Sig.Type));
+  return S.str();
+}