This is an archive of the discontinued LLVM Phabricator instance.

Differential D42585

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

Authored by ncw on Jan 26 2018, 10:15 AM.

Details

Reviewers
sbc100
sunfish
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.

Diff Detail

Event Timeline

ncw created this revision.Jan 26 2018, 10:15 AM
Herald added subscribers: llvm-commits, aheejin, jgravelle-google and 2 others. · View Herald TranscriptJan 26 2018, 10:15 AM
ncw mentioned this in D42495: [WebAssembly] Add symbol table to LLVM, 2/2.Jan 26 2018, 10:16 AM
ncw updated this revision to Diff 132218.Jan 31 2018, 11:11 AM

Updated:

  • Rebased on top of GC work
  • Pulled out globals-COMDAT into another commit
  • Pulled out some other preliminary changes into D42751
ncw mentioned this in D42753: [WebAssembly] Add LLD support for defined globals.Jan 31 2018, 11:20 AM
ncw updated this revision to Diff 132308.Jan 31 2018, 6:09 PM

Updated: massaged text expectations for new YAML output

ncw updated this revision to Diff 132356.Feb 1 2018, 3:58 AM

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

sbc100 added inline comments.Feb 6 2018, 7:46 PM
test/wasm/alias.ll
64

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 updated this revision to Diff 133232.Feb 7 2018, 9:04 AM

Rebased and addressed comments

test/wasm/alias.ll
64

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 this revision to Diff 133532.Feb 8 2018, 4:18 PM

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

ncw abandoned this revision.Feb 14 2018, 5:32 AM
Herald added a subscriber: arichardson. · View Herald TranscriptFeb 14 2018, 5:32 AM

Revision Contents

Diff 132308

test/wasm/alias.ll

Show All 38 Lines
; CHECK-NEXT: - Type: GLOBAL ; CHECK-NEXT: - Type: GLOBAL
; CHECK-NEXT: Globals: ; CHECK-NEXT: Globals:
; CHECK-NEXT: - Index: 0 ; CHECK-NEXT: - Index: 0
; CHECK-NEXT: Type: I32 ; CHECK-NEXT: Type: I32
; CHECK-NEXT: Mutable: true ; CHECK-NEXT: Mutable: true
; CHECK-NEXT: InitExpr: ; CHECK-NEXT: InitExpr:
; CHECK-NEXT: Opcode: I32_CONST ; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 66560 ; CHECK-NEXT: Value: 66560
; CHECK-NEXT: - Index: 1
; CHECK-NEXT: Type: I32
; CHECK-NEXT: Mutable: false
; CHECK-NEXT: InitExpr:
; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 66560
; CHECK-NEXT: - Type: EXPORT ; CHECK-NEXT: - Type: EXPORT
; CHECK-NEXT: Exports: ; CHECK-NEXT: Exports:
; CHECK-NEXT: - Name: memory ; CHECK-NEXT: - Name: memory
; CHECK-NEXT: Kind: MEMORY ; CHECK-NEXT: Kind: MEMORY
; CHECK-NEXT: Index: 0 ; CHECK-NEXT: Index: 0
; CHECK-NEXT: - Name: _start ; CHECK-NEXT: - Name: _start
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 0 ; CHECK-NEXT: Index: 0
; CHECK-NEXT: - Name: start_alias ; CHECK-NEXT: - Name: start_alias
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 0 ; CHECK-NEXT: Index: 0
; CHECK-NEXT: - Name: __heap_base
sbc100Unsubmitted
Not Done
ReplyInline Actions

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?

sbc100: As discussed on IRC lets keep these exported globals in the executable output (just like we do…
ncwAuthorUnsubmitted
Not Done
ReplyInline Actions

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: OK, I've done that. We now export a "fake" global specifically for the __heap_base and…
; CHECK-NEXT: Kind: GLOBAL
; CHECK-NEXT: Index: 1
; CHECK-NEXT: - Type: CODE ; CHECK-NEXT: - Type: CODE
; CHECK-NEXT: Functions: ; CHECK-NEXT: Functions:
; CHECK-NEXT: - Index: 0 ; CHECK-NEXT: - Index: 0
; CHECK-NEXT: Locals: ; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 41000B ; CHECK-NEXT: Body: 41000B
; CHECK-NEXT: - Index: 1 ; CHECK-NEXT: - Index: 1
; CHECK-NEXT: Locals: ; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 0B ; CHECK-NEXT: Body: 0B
Show All 11 Lines

test/wasm/archive.ll

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

test/wasm/call-indirect.ll

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Lines
; CHECK-NEXT: - Type: GLOBAL ; CHECK-NEXT: - Type: GLOBAL
; CHECK-NEXT: Globals: ; CHECK-NEXT: Globals:
; CHECK-NEXT: - Index: 0 ; CHECK-NEXT: - Index: 0
; CHECK-NEXT: Type: I32 ; CHECK-NEXT: Type: I32
; CHECK-NEXT: Mutable: true ; CHECK-NEXT: Mutable: true
; CHECK-NEXT: InitExpr: ; CHECK-NEXT: InitExpr:
; CHECK-NEXT: Opcode: I32_CONST ; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 66576 ; CHECK-NEXT: Value: 66576
; CHECK-NEXT: - Index: 1
; CHECK-NEXT: Type: I32
; CHECK-NEXT: Mutable: false
; CHECK-NEXT: InitExpr:
; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 66576
; CHECK-NEXT: - Type: EXPORT ; CHECK-NEXT: - Type: EXPORT
; CHECK-NEXT: Exports: ; CHECK-NEXT: Exports:
; CHECK-NEXT: - Name: memory ; CHECK-NEXT: - Name: memory
; CHECK-NEXT: Kind: MEMORY ; CHECK-NEXT: Kind: MEMORY
; CHECK-NEXT: Index: 0 ; CHECK-NEXT: Index: 0
; CHECK-NEXT: - Name: bar ; CHECK-NEXT: - Name: bar
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 0 ; CHECK-NEXT: Index: 0
; CHECK-NEXT: - Name: call_bar_indirect ; CHECK-NEXT: - Name: call_bar_indirect
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 1 ; CHECK-NEXT: Index: 1
; CHECK-NEXT: - Name: foo ; CHECK-NEXT: - Name: foo
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 2 ; CHECK-NEXT: Index: 2
; CHECK-NEXT: - Name: _start ; CHECK-NEXT: - Name: _start
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 3 ; CHECK-NEXT: Index: 3
; CHECK-NEXT: - Name: call_ptr ; CHECK-NEXT: - Name: call_ptr
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 4 ; CHECK-NEXT: Index: 4
; CHECK-NEXT: - Name: __heap_base
; CHECK-NEXT: Kind: GLOBAL
; CHECK-NEXT: Index: 1
; CHECK-NEXT: - Type: ELEM ; CHECK-NEXT: - Type: ELEM
; CHECK-NEXT: Segments: ; CHECK-NEXT: Segments:
; CHECK-NEXT: - Offset: ; CHECK-NEXT: - Offset:
; CHECK-NEXT: Opcode: I32_CONST ; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 1 ; CHECK-NEXT: Value: 1
; CHECK-NEXT: Functions: [ 0, 2 ] ; CHECK-NEXT: Functions: [ 0, 2 ]
; CHECK-NEXT: - Type: CODE ; CHECK-NEXT: - Type: CODE
; CHECK-NEXT: Functions: ; CHECK-NEXT: Functions:
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

test/wasm/comdats.ll

Show All 16 Lines
; CHECK: - Type: GLOBAL ; CHECK: - Type: GLOBAL
; CHECK-NEXT: Globals: ; CHECK-NEXT: Globals:
; CHECK-NEXT: - Index: 0 ; CHECK-NEXT: - Index: 0
; CHECK-NEXT: Type: I32 ; CHECK-NEXT: Type: I32
; CHECK-NEXT: Mutable: true ; CHECK-NEXT: Mutable: true
; CHECK-NEXT: InitExpr: ; CHECK-NEXT: InitExpr:
; CHECK-NEXT: Opcode: I32_CONST ; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 66576 ; CHECK-NEXT: Value: 66576
; CHECK-NEXT: - Index: 1
; CHECK-NEXT: Type: I32
; CHECK-NEXT: Mutable: false
; CHECK-NEXT: InitExpr:
; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 66576
; CHECK-NEXT: - Type: EXPORT ; CHECK-NEXT: - Type: EXPORT
; CHECK-NEXT: Exports: ; CHECK-NEXT: Exports:
; CHECK-NEXT: - Name: memory ; CHECK-NEXT: - Name: memory
; CHECK-NEXT: Kind: MEMORY ; CHECK-NEXT: Kind: MEMORY
; CHECK-NEXT: Index: 0 ; CHECK-NEXT: Index: 0
; CHECK-NEXT: - Name: _start ; CHECK-NEXT: - Name: _start
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 0 ; CHECK-NEXT: Index: 0
; CHECK-NEXT: - Name: inlineFn ; CHECK-NEXT: - Name: inlineFn
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 1 ; CHECK-NEXT: Index: 1
; CHECK-NEXT: - Name: callInline1 ; CHECK-NEXT: - Name: callInline1
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 2 ; CHECK-NEXT: Index: 2
; CHECK-NEXT: - Name: callInline2 ; CHECK-NEXT: - Name: callInline2
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 3 ; CHECK-NEXT: Index: 3
; CHECK-NEXT: - Name: __heap_base
; CHECK-NEXT: Kind: GLOBAL
; CHECK-NEXT: Index: 1
; CHECK-NEXT: - Type: ELEM ; CHECK-NEXT: - Type: ELEM
; CHECK-NEXT: Segments: ; CHECK-NEXT: Segments:
; CHECK-NEXT: - Offset: ; CHECK-NEXT: - Offset:
; CHECK-NEXT: Opcode: I32_CONST ; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 1 ; CHECK-NEXT: Value: 1
; CHECK-NEXT: Functions: [ 1 ] ; CHECK-NEXT: Functions: [ 1 ]
; CHECK-NEXT: - Type: CODE ; CHECK-NEXT: - Type: CODE
; CHECK-NEXT: Functions: ; CHECK-NEXT: Functions:
Show All 23 Lines

test/wasm/data-layout.ll

Show All 14 Lines
; CHECK: - Type: GLOBAL ; CHECK: - Type: GLOBAL
; CHECK-NEXT: Globals: ; CHECK-NEXT: Globals:
; CHECK-NEXT: - Index: 0 ; CHECK-NEXT: - Index: 0
; CHECK-NEXT: Type: I32 ; CHECK-NEXT: Type: I32
; CHECK-NEXT: Mutable: true ; CHECK-NEXT: Mutable: true
; CHECK-NEXT: InitExpr: ; CHECK-NEXT: InitExpr:
; CHECK-NEXT: Opcode: I32_CONST ; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 66608 ; 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: - Type: DATA
; CHECK-NEXT: Segments: ; CHECK-NEXT: Segments:
; CHECK-NEXT: - SectionOffset: 7 ; CHECK-NEXT: - SectionOffset: 7
; CHECK-NEXT: MemoryIndex: 0 ; CHECK-NEXT: MemoryIndex: 0
; CHECK-NEXT: Offset: ; CHECK-NEXT: Offset:
; CHECK-NEXT: Opcode: I32_CONST ; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 1024 ; CHECK-NEXT: Value: 1024
; CHECK-NEXT: Content: 0100000000000000000000000000000003000000000000001C040000 ; CHECK-NEXT: Content: 0100000000000000000000000000000003000000000000001C040000
; CHECK-NEXT: - SectionOffset: 41 ; CHECK-NEXT: - SectionOffset: 41
; CHECK-NEXT: MemoryIndex: 0 ; CHECK-NEXT: MemoryIndex: 0
; CHECK-NEXT: Offset: ; CHECK-NEXT: Offset:
; CHECK-NEXT: Opcode: I32_CONST ; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 1052 ; CHECK-NEXT: Value: 1052
; CHECK-NEXT: Content: 68656C6C6F0A00 ; CHECK-NEXT: Content: 68656C6C6F0A00
; RUN: lld -flavor wasm --relocatable -o %t_reloc.wasm %t.o %t.hello.o ; RUN: lld -flavor wasm --relocatable -o %t_reloc.wasm %t.o %t.hello.o
; RUN: obj2yaml %t_reloc.wasm | FileCheck %s -check-prefix=RELOC ; 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: - Type: DATA
; RELOC-NEXT: Relocations: ; RELOC-NEXT: Relocations:
; RELOC-NEXT: - Type: R_WEBASSEMBLY_MEMORY_ADDR_I32 ; RELOC-NEXT: - Type: R_WEBASSEMBLY_MEMORY_ADDR_I32
; RELOC-NEXT: Index: 5 ; RELOC-NEXT: Index: 5
; RELOC-NEXT: Offset: 0x00000018 ; RELOC-NEXT: Offset: 0x00000018
; RELOC-NEXT: Segments: ; RELOC-NEXT: Segments:
; RELOC-NEXT: - SectionOffset: 6 ; RELOC-NEXT: - SectionOffset: 6
; RELOC-NEXT: MemoryIndex: 0 ; RELOC-NEXT: MemoryIndex: 0
Show All 15 Lines
; RELOC-NEXT: Content: 1C000000 ; RELOC-NEXT: Content: 1C000000
; RELOC-NEXT: - SectionOffset: 33 ; RELOC-NEXT: - SectionOffset: 33
; RELOC-NEXT: MemoryIndex: 0 ; RELOC-NEXT: MemoryIndex: 0
; RELOC-NEXT: Offset: ; RELOC-NEXT: Offset:
; RELOC-NEXT: Opcode: I32_CONST ; RELOC-NEXT: Opcode: I32_CONST
; RELOC-NEXT: Value: 28 ; RELOC-NEXT: Value: 28
; RELOC-NEXT: Content: 68656C6C6F0A00 ; RELOC-NEXT: Content: 68656C6C6F0A00
; RELOC: - Type: CUSTOM ; RELOC: - Type: CUSTOM
; RELOC-NEXT: Name: linking ; RELOC-NEXT: Name: linking
; RELOC-NEXT: DataSize: 35 ; 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/export.ll

Show All 22 Lines
; CHECK-NEXT: Kind: MEMORY ; CHECK-NEXT: Kind: MEMORY
; CHECK-NEXT: Index: 0 ; CHECK-NEXT: Index: 0
; CHECK-NEXT: - Name: hidden_function ; CHECK-NEXT: - Name: hidden_function
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 0 ; CHECK-NEXT: Index: 0
; CHECK-NEXT: - Name: _start ; CHECK-NEXT: - Name: _start
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 1 ; CHECK-NEXT: Index: 1
; CHECK-NEXT: - Name: __heap_base
; CHECK-NEXT: Kind: GLOBAL
; CHECK-NEXT: Index: 1
; CHECK-NEXT: - Type: CODE ; CHECK-NEXT: - Type: CODE

test/wasm/init-fini.ll

Show First 20 Lines • Show All 103 Lines • ▼ Show 20 Lines
; CHECK-NEXT: ... ; CHECK-NEXT: ...
; RUN: lld -flavor wasm -r %t.o %t.global-ctor-dtor.o -o %t.reloc.wasm ; RUN: lld -flavor wasm -r %t.o %t.global-ctor-dtor.o -o %t.reloc.wasm
; RUN: obj2yaml %t.reloc.wasm | FileCheck -check-prefix=RELOC %s ; RUN: obj2yaml %t.reloc.wasm | FileCheck -check-prefix=RELOC %s
; RELOC: Name: linking ; RELOC: Name: linking
; RELOC-NEXT: DataSize: 0 ; RELOC-NEXT: DataSize: 0
; RELOC-NEXT: SymbolInfo: ; RELOC-NEXT: SymbolTable:
; RELOC-NEXT: - Name: __dso_handle
; RELOC-NEXT: - Index: 0
; RELOC-NEXT: Kind: DATA
; RELOC-NEXT: Name: __dso_handle
; RELOC-NEXT: Flags: [ BINDING_WEAK, VISIBILITY_HIDDEN ] ; 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: FunctionIndex: 18
; RELOC-NEXT: InitFunctions: ; RELOC-NEXT: InitFunctions:
; RELOC-NEXT: - Priority: 101 ; RELOC-NEXT: - Priority: 101
; RELOC-NEXT: FunctionIndex: 2 ; RELOC-NEXT: FunctionIndex: 1
; RELOC-NEXT: - Priority: 101 ; RELOC-NEXT: - Priority: 101
; RELOC-NEXT: FunctionIndex: 3 ; RELOC-NEXT: FunctionIndex: 2
; RELOC-NEXT: - Priority: 101 ; RELOC-NEXT: - Priority: 101
; RELOC-NEXT: FunctionIndex: 9 ; RELOC-NEXT: FunctionIndex: 8
; RELOC-NEXT: - Priority: 101 ; RELOC-NEXT: - Priority: 101
; RELOC-NEXT: FunctionIndex: 13 ; RELOC-NEXT: FunctionIndex: 13
; RELOC-NEXT: - Priority: 101 ; RELOC-NEXT: - Priority: 101
; RELOC-NEXT: FunctionIndex: 16 ; RELOC-NEXT: FunctionIndex: 16
; RELOC-NEXT: - Priority: 202 ; RELOC-NEXT: - Priority: 202
; RELOC-NEXT: FunctionIndex: 13 ; RELOC-NEXT: FunctionIndex: 13
; RELOC-NEXT: - Priority: 202 ; RELOC-NEXT: - Priority: 202
; RELOC-NEXT: FunctionIndex: 18 ; RELOC-NEXT: FunctionIndex: 18
; RELOC-NEXT: - Priority: 1001 ; RELOC-NEXT: - Priority: 1001
; RELOC-NEXT: FunctionIndex: 2 ; RELOC-NEXT: FunctionIndex: 1
; RELOC-NEXT: - Priority: 1001 ; RELOC-NEXT: - Priority: 1001
; RELOC-NEXT: FunctionIndex: 12 ; RELOC-NEXT: FunctionIndex: 11
; RELOC-NEXT: - Priority: 2002 ; RELOC-NEXT: - Priority: 2002
; RELOC-NEXT: FunctionIndex: 13 ; RELOC-NEXT: FunctionIndex: 13
; RELOC-NEXT: - Priority: 2002 ; RELOC-NEXT: - Priority: 2002
; RELOC-NEXT: FunctionIndex: 20 ; RELOC-NEXT: FunctionIndex: 20
; RELOC-NEXT: - Type: CUSTOM ; RELOC-NEXT: - Type: CUSTOM
; RELOC-NEXT: Name: name ; RELOC-NEXT: Name: name
; RELOC-NEXT: FunctionNames: ; RELOC-NEXT: FunctionNames:
; RELOC-NEXT: - Index: 0 ; RELOC-NEXT: - Index: 0
Show All 38 Lines

test/wasm/load-undefined.test

Show All 16 Lines
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 0 ; CHECK-NEXT: Index: 0
; CHECK-NEXT: - Name: ret32 ; CHECK-NEXT: - Name: ret32
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 1 ; CHECK-NEXT: Index: 1
; CHECK-NEXT: - Name: ret64 ; CHECK-NEXT: - Name: ret64
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 2 ; CHECK-NEXT: Index: 2
; CHECK-NEXT: - Name: __heap_base
; CHECK-NEXT: Kind: GLOBAL
; CHECK-NEXT: Index: 1
; CHECK-NEXT: - Type: ; CHECK-NEXT: - Type:
; Verify that referencing a symbol that doesn't exist won't work ; Verify that referencing a symbol that doesn't exist won't work
; RUN: not lld -flavor wasm %t.start.o -o %t.wasm -u symboldoesnotexist 2>&1 | FileCheck -check-prefix=CHECK-UNDEFINED1 %s ; RUN: not lld -flavor wasm %t.start.o -o %t.wasm -u symboldoesnotexist 2>&1 | FileCheck -check-prefix=CHECK-UNDEFINED1 %s
; CHECK-UNDEFINED1: error: undefined symbol: symboldoesnotexist ; CHECK-UNDEFINED1: error: undefined symbol: symboldoesnotexist
; RUN: not lld -flavor wasm %t.start.o -o %t.wasm --undefined symboldoesnotexist --allow-undefined 2>&1 | FileCheck -check-prefix=CHECK-UNDEFINED2 %s ; RUN: not lld -flavor wasm %t.start.o -o %t.wasm --undefined symboldoesnotexist --allow-undefined 2>&1 | FileCheck -check-prefix=CHECK-UNDEFINED2 %s
; CHECK-UNDEFINED2: function forced with --undefined not found: symboldoesnotexist ; CHECK-UNDEFINED2: function forced with --undefined not found: symboldoesnotexist

test/wasm/local-symbols.ll

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
; CHECK-NEXT: - Type: GLOBAL ; CHECK-NEXT: - Type: GLOBAL
; CHECK-NEXT: Globals: ; CHECK-NEXT: Globals:
; CHECK-NEXT: - Index: 0 ; CHECK-NEXT: - Index: 0
; CHECK-NEXT: Type: I32 ; CHECK-NEXT: Type: I32
; CHECK-NEXT: Mutable: true ; CHECK-NEXT: Mutable: true
; CHECK-NEXT: InitExpr: ; CHECK-NEXT: InitExpr:
; CHECK-NEXT: Opcode: I32_CONST ; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 66576 ; CHECK-NEXT: Value: 66576
; CHECK-NEXT: - Index: 1
; CHECK-NEXT: Type: I32
; CHECK-NEXT: Mutable: false
; CHECK-NEXT: InitExpr:
; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 66576
; CHECK-NEXT: - Type: EXPORT ; CHECK-NEXT: - Type: EXPORT
; CHECK-NEXT: Exports: ; CHECK-NEXT: Exports:
; CHECK-NEXT: - Name: memory ; CHECK-NEXT: - Name: memory
; CHECK-NEXT: Kind: MEMORY ; CHECK-NEXT: Kind: MEMORY
; CHECK-NEXT: Index: 0 ; CHECK-NEXT: Index: 0
; CHECK-NEXT: - Name: _start ; CHECK-NEXT: - Name: _start
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 1 ; CHECK-NEXT: Index: 1
; CHECK-NEXT: - Name: __heap_base
; CHECK-NEXT: Kind: GLOBAL
; CHECK-NEXT: Index: 1
; CHECK-NEXT: - Type: CODE ; CHECK-NEXT: - Type: CODE
; CHECK-NEXT: Functions: ; CHECK-NEXT: Functions:
; CHECK-NEXT: - Index: 0 ; CHECK-NEXT: - Index: 0
; CHECK-NEXT: Locals: ; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 4100280284888080000B ; CHECK-NEXT: Body: 4100280284888080000B
; CHECK-NEXT: - Index: 1 ; CHECK-NEXT: - Index: 1
; CHECK-NEXT: Locals: ; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 1080808080001A41010B ; CHECK-NEXT: Body: 1080808080001A41010B
Show All 24 Lines

test/wasm/locals-duplicate.test

Show All 30 Lines
; CHECK-NEXT: - Type: GLOBAL ; CHECK-NEXT: - Type: GLOBAL
; CHECK-NEXT: Globals: ; CHECK-NEXT: Globals:
; CHECK-NEXT: - Index: 0 ; CHECK-NEXT: - Index: 0
; CHECK-NEXT: Type: I32 ; CHECK-NEXT: Type: I32
; CHECK-NEXT: Mutable: true ; CHECK-NEXT: Mutable: true
; CHECK-NEXT: InitExpr: ; CHECK-NEXT: InitExpr:
; CHECK-NEXT: Opcode: I32_CONST ; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 66592 ; CHECK-NEXT: Value: 66592
; CHECK-NEXT: - Index: 1
; CHECK-NEXT: Type: I32
; CHECK-NEXT: Mutable: false
; CHECK-NEXT: InitExpr:
; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 66592
; CHECK-NEXT: - Type: EXPORT ; CHECK-NEXT: - Type: EXPORT
; CHECK-NEXT: Exports: ; CHECK-NEXT: Exports:
; CHECK-NEXT: - Name: memory ; CHECK-NEXT: - Name: memory
; CHECK-NEXT: Kind: MEMORY ; CHECK-NEXT: Kind: MEMORY
; CHECK-NEXT: Index: 0 ; CHECK-NEXT: Index: 0
; CHECK-NEXT: - Name: colliding_func2 ; CHECK-NEXT: - Name: colliding_func2
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 1 ; CHECK-NEXT: Index: 1
Show All 31 Lines
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 15 ; CHECK-NEXT: Index: 15
; CHECK-NEXT: - Name: get_func2B ; CHECK-NEXT: - Name: get_func2B
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 16 ; CHECK-NEXT: Index: 16
; CHECK-NEXT: - Name: get_func3B ; CHECK-NEXT: - Name: get_func3B
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 17 ; CHECK-NEXT: Index: 17
; CHECK-NEXT: - Name: __heap_base
; CHECK-NEXT: Kind: GLOBAL
; CHECK-NEXT: Index: 1
; CHECK-NEXT: - Type: ELEM ; CHECK-NEXT: - Type: ELEM
; CHECK-NEXT: Segments: ; CHECK-NEXT: Segments:
; CHECK-NEXT: - Offset: ; CHECK-NEXT: - Offset:
; CHECK-NEXT: Opcode: I32_CONST ; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 1 ; CHECK-NEXT: Value: 1
; CHECK-NEXT: Functions: [ 0, 1, 2, 9, 10, 11 ] ; CHECK-NEXT: Functions: [ 0, 1, 2, 9, 10, 11 ]
; CHECK-NEXT: - Type: CODE ; CHECK-NEXT: - Type: CODE
; CHECK-NEXT: Functions: ; CHECK-NEXT: Functions:
▲ Show 20 Lines • Show All 129 Lines • ▼ Show 20 Lines
; RELOC-NEXT: - ElemType: ANYFUNC ; RELOC-NEXT: - ElemType: ANYFUNC
; RELOC-NEXT: Limits: ; RELOC-NEXT: Limits:
; RELOC-NEXT: Flags: [ HAS_MAX ] ; RELOC-NEXT: Flags: [ HAS_MAX ]
; RELOC-NEXT: Initial: 0x00000007 ; RELOC-NEXT: Initial: 0x00000007
; RELOC-NEXT: Maximum: 0x00000007 ; RELOC-NEXT: Maximum: 0x00000007
; RELOC-NEXT: - Type: MEMORY ; RELOC-NEXT: - Type: MEMORY
; RELOC-NEXT: Memories: ; RELOC-NEXT: Memories:
; RELOC-NEXT: - Initial: 0x00000001 ; 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: - Type: ELEM
; RELOC-NEXT: Segments: ; RELOC-NEXT: Segments:
; RELOC-NEXT: - Offset: ; RELOC-NEXT: - Offset:
; RELOC-NEXT: Opcode: I32_CONST ; RELOC-NEXT: Opcode: I32_CONST
; RELOC-NEXT: Value: 1 ; RELOC-NEXT: Value: 1
; RELOC-NEXT: Functions: [ 0, 1, 2, 9, 10, 11 ] ; RELOC-NEXT: Functions: [ 0, 1, 2, 9, 10, 11 ]
; RELOC-NEXT: - Type: CODE ; RELOC-NEXT: - Type: CODE
; RELOC-NEXT: Relocations: ; RELOC-NEXT: Relocations:
; RELOC-NEXT: - Type: R_WEBASSEMBLY_MEMORY_ADDR_SLEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_MEMORY_ADDR_SLEB
; RELOC-NEXT: Index: 18 ; RELOC-NEXT: Index: 4
; RELOC-NEXT: Offset: 0x00000013 ; RELOC-NEXT: Offset: 0x00000013
; RELOC-NEXT: - Type: R_WEBASSEMBLY_MEMORY_ADDR_SLEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_MEMORY_ADDR_SLEB
; RELOC-NEXT: Index: 19 ; RELOC-NEXT: Index: 6
; RELOC-NEXT: Offset: 0x0000001C ; RELOC-NEXT: Offset: 0x0000001C
; RELOC-NEXT: - Type: R_WEBASSEMBLY_MEMORY_ADDR_SLEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_MEMORY_ADDR_SLEB
; RELOC-NEXT: Index: 20 ; RELOC-NEXT: Index: 8
; RELOC-NEXT: Offset: 0x00000025 ; RELOC-NEXT: Offset: 0x00000025
; RELOC-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB
; RELOC-NEXT: Index: 0 ; RELOC-NEXT: Index: 0
; RELOC-NEXT: Offset: 0x0000002E ; RELOC-NEXT: Offset: 0x0000002E
; RELOC-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB
; RELOC-NEXT: Index: 1 ; RELOC-NEXT: Index: 1
; RELOC-NEXT: Offset: 0x00000037 ; RELOC-NEXT: Offset: 0x00000037
; RELOC-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB
; RELOC-NEXT: Index: 2 ; RELOC-NEXT: Index: 2
; RELOC-NEXT: Offset: 0x00000040 ; RELOC-NEXT: Offset: 0x00000040
; RELOC-NEXT: - Type: R_WEBASSEMBLY_MEMORY_ADDR_SLEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_MEMORY_ADDR_SLEB
; RELOC-NEXT: Index: 21 ; RELOC-NEXT: Index: 16
; RELOC-NEXT: Offset: 0x00000058 ; RELOC-NEXT: Offset: 0x00000058
; RELOC-NEXT: - Type: R_WEBASSEMBLY_MEMORY_ADDR_SLEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_MEMORY_ADDR_SLEB
; RELOC-NEXT: Index: 22 ; RELOC-NEXT: Index: 18
; RELOC-NEXT: Offset: 0x00000061 ; RELOC-NEXT: Offset: 0x00000061
; RELOC-NEXT: - Type: R_WEBASSEMBLY_MEMORY_ADDR_SLEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_MEMORY_ADDR_SLEB
; RELOC-NEXT: Index: 23 ; RELOC-NEXT: Index: 20
; RELOC-NEXT: Offset: 0x0000006A ; RELOC-NEXT: Offset: 0x0000006A
; RELOC-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB
; RELOC-NEXT: Index: 9 ; RELOC-NEXT: Index: 12
; RELOC-NEXT: Offset: 0x00000073 ; RELOC-NEXT: Offset: 0x00000073
; RELOC-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB
; RELOC-NEXT: Index: 10 ; RELOC-NEXT: Index: 13
; RELOC-NEXT: Offset: 0x0000007C ; RELOC-NEXT: Offset: 0x0000007C
; RELOC-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB
; RELOC-NEXT: Index: 11 ; RELOC-NEXT: Index: 14
; RELOC-NEXT: Offset: 0x00000085 ; RELOC-NEXT: Offset: 0x00000085
; RELOC-NEXT: Functions: ; RELOC-NEXT: Functions:
; RELOC-NEXT: - Index: 0 ; RELOC-NEXT: - Index: 0
; RELOC-NEXT: Locals: ; RELOC-NEXT: Locals:
; RELOC-NEXT: Body: 41020B ; RELOC-NEXT: Body: 41020B
; RELOC-NEXT: - Index: 1 ; RELOC-NEXT: - Index: 1
; RELOC-NEXT: Locals: ; RELOC-NEXT: Locals:
; RELOC-NEXT: Body: 41020B ; RELOC-NEXT: Body: 41020B
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines
; RELOC-NEXT: MemoryIndex: 0 ; RELOC-NEXT: MemoryIndex: 0
; RELOC-NEXT: Offset: ; RELOC-NEXT: Offset:
; RELOC-NEXT: Opcode: I32_CONST ; RELOC-NEXT: Opcode: I32_CONST
; RELOC-NEXT: Value: 16 ; RELOC-NEXT: Value: 16
; RELOC-NEXT: Content: '0000000000000000' ; RELOC-NEXT: Content: '0000000000000000'
; RELOC-NEXT: - Type: CUSTOM ; RELOC-NEXT: - Type: CUSTOM
; RELOC-NEXT: Name: linking ; RELOC-NEXT: Name: linking
; RELOC-NEXT: DataSize: 24 ; RELOC-NEXT: DataSize: 24
; RELOC-NEXT: SymbolInfo: ; RELOC-NEXT: SymbolTable:
; RELOC-NEXT: - Name: colliding_func1.1 ; RELOC-NEXT: - Index: 0
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: colliding_func1
; RELOC-NEXT: Flags: [ BINDING_LOCAL ] ; 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: 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: 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: 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: 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: 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: 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: 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: SegmentInfo:
; RELOC-NEXT: - Index: 0 ; RELOC-NEXT: - Index: 0
; RELOC-NEXT: Name: .bss.colliding_global1 ; RELOC-NEXT: Name: .bss.colliding_global1
; RELOC-NEXT: Alignment: 4 ; RELOC-NEXT: Alignment: 4
; RELOC-NEXT: Flags: [ ] ; RELOC-NEXT: Flags: [ ]
; RELOC-NEXT: - Index: 1 ; RELOC-NEXT: - Index: 1
; RELOC-NEXT: Name: .bss.colliding_global2 ; RELOC-NEXT: Name: .bss.colliding_global2
; RELOC-NEXT: Alignment: 4 ; RELOC-NEXT: Alignment: 4
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

test/wasm/many-functions.ll

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

test/wasm/relocatable.ll

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
; CHECK-NEXT: - Module: env ; CHECK-NEXT: - Module: env
; CHECK-NEXT: Field: foo_import ; CHECK-NEXT: Field: foo_import
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: SigIndex: 2 ; CHECK-NEXT: SigIndex: 2
; CHECK-NEXT: - Module: env ; CHECK-NEXT: - Module: env
; CHECK-NEXT: Field: bar_import ; CHECK-NEXT: Field: bar_import
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: SigIndex: 2 ; CHECK-NEXT: SigIndex: 2
; 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: - Type: FUNCTION
; CHECK-NEXT: FunctionTypes: [ 0, 2, 2 ] ; CHECK-NEXT: FunctionTypes: [ 0, 2, 2 ]
; CHECK-NEXT: - Type: TABLE ; CHECK-NEXT: - Type: TABLE
; CHECK-NEXT: Tables: ; CHECK-NEXT: Tables:
; CHECK-NEXT: - ElemType: ANYFUNC ; CHECK-NEXT: - ElemType: ANYFUNC
; CHECK-NEXT: Limits: ; CHECK-NEXT: Limits:
; CHECK-NEXT: Flags: [ HAS_MAX ] ; CHECK-NEXT: Flags: [ HAS_MAX ]
; CHECK-NEXT: Initial: 0x00000004 ; CHECK-NEXT: Initial: 0x00000004
; CHECK-NEXT: Maximum: 0x00000004 ; CHECK-NEXT: Maximum: 0x00000004
; CHECK-NEXT: - Type: MEMORY ; CHECK-NEXT: - Type: MEMORY
; CHECK-NEXT: Memories: ; CHECK-NEXT: Memories:
; CHECK-NEXT: - Initial: 0x00000001 ; 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: - Type: ELEM
; CHECK-NEXT: Segments: ; CHECK-NEXT: Segments:
; CHECK-NEXT: - Offset: ; CHECK-NEXT: - Offset:
; CHECK-NEXT: Opcode: I32_CONST ; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 1 ; CHECK-NEXT: Value: 1
; CHECK-NEXT: Functions: [ 4, 1, 2 ] ; CHECK-NEXT: Functions: [ 4, 1, 2 ]
; CHECK-NEXT: - Type: CODE ; CHECK-NEXT: - Type: CODE
; CHECK-NEXT: Relocations: ; CHECK-NEXT: Relocations:
; CHECK-NEXT: - Type: R_WEBASSEMBLY_MEMORY_ADDR_SLEB ; CHECK-NEXT: - Type: R_WEBASSEMBLY_MEMORY_ADDR_SLEB
; CHECK-NEXT: Index: 7 ; CHECK-NEXT: Index: 2
; CHECK-NEXT: Offset: 0x00000004 ; CHECK-NEXT: Offset: 0x00000004
; CHECK-NEXT: - Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB ; CHECK-NEXT: - Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB
; CHECK-NEXT: Index: 0 ; CHECK-NEXT: Index: 0
; CHECK-NEXT: Offset: 0x0000000A ; CHECK-NEXT: Offset: 0x0000000A
; CHECK-NEXT: - Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB ; CHECK-NEXT: - Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB
; CHECK-NEXT: Index: 1 ; CHECK-NEXT: Index: 3
; CHECK-NEXT: Offset: 0x00000013 ; CHECK-NEXT: Offset: 0x00000013
; CHECK-NEXT: - Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB ; CHECK-NEXT: - Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB
; CHECK-NEXT: Index: 2 ; CHECK-NEXT: Index: 4
; CHECK-NEXT: Offset: 0x0000001A ; CHECK-NEXT: Offset: 0x0000001A
; CHECK-NEXT: - Type: R_WEBASSEMBLY_MEMORY_ADDR_SLEB ; CHECK-NEXT: - Type: R_WEBASSEMBLY_MEMORY_ADDR_SLEB
; CHECK-NEXT: Index: 8 ; CHECK-NEXT: Index: 8
; CHECK-NEXT: Offset: 0x00000026 ; CHECK-NEXT: Offset: 0x00000026
; CHECK-NEXT: Functions: ; CHECK-NEXT: Functions:
; CHECK-NEXT: - Index: 3 ; CHECK-NEXT: - Index: 3
; CHECK-NEXT: Locals: ; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 4180808080001080808080000B ; CHECK-NEXT: Body: 4180808080001080808080000B
; CHECK-NEXT: - Index: 4 ; CHECK-NEXT: - Index: 4
; CHECK-NEXT: Locals: ; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 1081808080001A1082808080001A41010B ; CHECK-NEXT: Body: 1081808080001A1082808080001A41010B
; CHECK-NEXT: - Index: 5 ; CHECK-NEXT: - Index: 5
; CHECK-NEXT: Locals: ; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 419C808080000B ; CHECK-NEXT: Body: 419C808080000B
; CHECK-NEXT: - Type: DATA ; CHECK-NEXT: - Type: DATA
; CHECK-NEXT: Relocations: ; CHECK-NEXT: Relocations:
; CHECK-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_I32 ; CHECK-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_I32
; CHECK-NEXT: Index: 5 ; CHECK-NEXT: Index: 6
; CHECK-NEXT: Offset: 0x00000012 ; CHECK-NEXT: Offset: 0x00000012
; CHECK-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_I32 ; CHECK-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_I32
; CHECK-NEXT: Index: 1 ; CHECK-NEXT: Index: 3
; CHECK-NEXT: Offset: 0x0000001B ; CHECK-NEXT: Offset: 0x0000001B
; CHECK-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_I32 ; CHECK-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_I32
; CHECK-NEXT: Index: 2 ; CHECK-NEXT: Index: 4
; CHECK-NEXT: Offset: 0x00000024 ; CHECK-NEXT: Offset: 0x00000024
; CHECK-NEXT: - Type: R_WEBASSEMBLY_MEMORY_ADDR_I32 ; CHECK-NEXT: - Type: R_WEBASSEMBLY_MEMORY_ADDR_I32
; CHECK-NEXT: Index: 3 ; CHECK-NEXT: Index: 5
; CHECK-NEXT: Offset: 0x0000002D ; CHECK-NEXT: Offset: 0x0000002D
; CHECK-NEXT: Segments: ; CHECK-NEXT: Segments:
; CHECK-NEXT: - SectionOffset: 6 ; CHECK-NEXT: - SectionOffset: 6
; CHECK-NEXT: MemoryIndex: 0 ; CHECK-NEXT: MemoryIndex: 0
; CHECK-NEXT: Offset: ; CHECK-NEXT: Offset:
; CHECK-NEXT: Opcode: I32_CONST ; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 0 ; CHECK-NEXT: Value: 0
; CHECK-NEXT: Content: 68656C6C6F0A00 ; CHECK-NEXT: Content: 68656C6C6F0A00
Show All 25 Lines
; CHECK-NEXT: MemoryIndex: 0 ; CHECK-NEXT: MemoryIndex: 0
; CHECK-NEXT: Offset: ; CHECK-NEXT: Offset:
; CHECK-NEXT: Opcode: I32_CONST ; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 28 ; CHECK-NEXT: Value: 28
; CHECK-NEXT: Content: '616263' ; CHECK-NEXT: Content: '616263'
; CHECK-NEXT: - Type: CUSTOM ; CHECK-NEXT: - Type: CUSTOM
; CHECK-NEXT: Name: linking ; CHECK-NEXT: Name: linking
; CHECK-NEXT: DataSize: 31 ; CHECK-NEXT: DataSize: 31
; CHECK-NEXT: SymbolInfo: ; CHECK-NEXT: SymbolTable:
; CHECK-NEXT: - Name: bar_import ; CHECK-NEXT: - Index: 0
; CHECK-NEXT: Flags: [ BINDING_WEAK ] ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: - Name: hello ; 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: 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: 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: 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: 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: 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: 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: 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: Flags: [ VISIBILITY_HIDDEN ]
; CHECK-NEXT: SegmentIndex: 4
; CHECK-NEXT: Size: 4
; CHECK-NEXT: SegmentInfo: ; CHECK-NEXT: SegmentInfo:
; CHECK-NEXT: - Index: 0 ; CHECK-NEXT: - Index: 0
; CHECK-NEXT: Name: .rodata.hello_str ; CHECK-NEXT: Name: .rodata.hello_str
; CHECK-NEXT: Alignment: 1 ; CHECK-NEXT: Alignment: 1
; CHECK-NEXT: Flags: [ ] ; CHECK-NEXT: Flags: [ ]
; CHECK-NEXT: - Index: 1 ; CHECK-NEXT: - Index: 1
; CHECK-NEXT: Name: .data.func_addr1 ; CHECK-NEXT: Name: .data.func_addr1
; CHECK-NEXT: Alignment: 4 ; CHECK-NEXT: Alignment: 4
Show All 40 Lines

test/wasm/signature-mismatch.ll

; RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o ; RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
; RUN: llc -filetype=obj %s -o %t.main.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 ; 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" target triple = "wasm32-unknown-unknown-wasm"
; Function Attrs: nounwind ; Function Attrs: nounwind
define hidden void @_start() local_unnamed_addr #0 { define hidden void @_start() local_unnamed_addr #0 {
entry: entry:
%call = tail call i32 @ret32(i32 1, i64 2, i32 3) #2 %call = tail call i32 @ret32(i32 1, i64 2, i32 3) #2
ret void ret void
} }
declare i32 @ret32(i32, i64, i32) local_unnamed_addr #1 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 (I32, I64, I32) -> I32 in {{.*}}.main.o
; CHECK-NEXT: >>> defined as (F32) -> I32 in {{.*}}.ret32.o ; CHECK-NEXT: >>> defined as (F32) -> I32 in {{.*}}.ret32.o

test/wasm/stack-pointer.ll

Show All 20 Lines
; CHECK-NEXT: ReturnType: I32 ; CHECK-NEXT: ReturnType: I32
; CHECK-NEXT: ParamTypes: ; CHECK-NEXT: ParamTypes:
; CHECK-NEXT: - Type: IMPORT ; CHECK-NEXT: - Type: IMPORT
; CHECK-NEXT: Imports: ; CHECK-NEXT: Imports:
; CHECK-NEXT: - Module: env ; CHECK-NEXT: - Module: env
; CHECK-NEXT: Field: __stack_pointer ; CHECK-NEXT: Field: __stack_pointer
; CHECK-NEXT: Kind: GLOBAL ; CHECK-NEXT: Kind: GLOBAL
; CHECK-NEXT: GlobalType: I32 ; CHECK-NEXT: GlobalType: I32
; CHECK-NEXT: GlobalMutable: false ; CHECK-NEXT: GlobalMutable: true
; CHECK-NEXT: - Type: FUNCTION ; CHECK-NEXT: - Type: FUNCTION
; CHECK-NEXT: FunctionTypes: [ 0 ] ; CHECK-NEXT: FunctionTypes: [ 0 ]
; CHECK-NEXT: - Type: TABLE ; CHECK-NEXT: - Type: TABLE
; CHECK-NEXT: Tables: ; CHECK-NEXT: Tables:
; CHECK-NEXT: - ElemType: ANYFUNC ; CHECK-NEXT: - ElemType: ANYFUNC
; CHECK-NEXT: Limits: ; CHECK-NEXT: Limits:
; CHECK-NEXT: Flags: [ HAS_MAX ] ; CHECK-NEXT: Flags: [ HAS_MAX ]
; CHECK-NEXT: Initial: 0x00000001 ; CHECK-NEXT: Initial: 0x00000001
; CHECK-NEXT: Maximum: 0x00000001 ; CHECK-NEXT: Maximum: 0x00000001
; CHECK-NEXT: - Type: MEMORY ; CHECK-NEXT: - Type: MEMORY
; CHECK-NEXT: Memories: ; CHECK-NEXT: Memories:
; CHECK-NEXT: - Initial: 0x00000000 ; 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: - Type: CODE
; CHECK-NEXT: Relocations: ; CHECK-NEXT: Relocations:
; CHECK-NEXT: - Type: R_WEBASSEMBLY_GLOBAL_INDEX_LEB ; CHECK-NEXT: - Type: R_WEBASSEMBLY_GLOBAL_INDEX_LEB
; CHECK-NEXT: Index: 0 ; CHECK-NEXT: Index: 0
; CHECK-NEXT: Offset: 0x00000004 ; CHECK-NEXT: Offset: 0x00000004
; CHECK-NEXT: Functions: ; CHECK-NEXT: Functions:
; CHECK-NEXT: - Index: 0 ; CHECK-NEXT: - Index: 0
; CHECK-NEXT: Locals: ; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 23808080800041106B1A41000B ; CHECK-NEXT: Body: 23808080800041106B1A41000B
; CHECK-NEXT: - Type: CUSTOM ; CHECK-NEXT: - Type: CUSTOM
; CHECK-NEXT: Name: linking ; CHECK-NEXT: Name: linking
; CHECK-NEXT: DataSize: 0 ; 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: - Type: CUSTOM
; CHECK-NEXT: Name: name ; CHECK-NEXT: Name: name
; CHECK-NEXT: FunctionNames: ; CHECK-NEXT: FunctionNames:
; CHECK-NEXT: - Index: 0 ; CHECK-NEXT: - Index: 0
; CHECK-NEXT: Name: _start ; CHECK-NEXT: Name: _start
; CHECK-NEXT: ... ; CHECK-NEXT: ...

test/wasm/symbol-type-mismatch.ll

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

test/wasm/visibility-hidden.ll

Show All 39 Lines
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 1 ; CHECK-NEXT: Index: 1
; CHECK-NEXT: - Name: _start ; CHECK-NEXT: - Name: _start
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 2 ; CHECK-NEXT: Index: 2
; CHECK-NEXT: - Name: archiveDefault ; CHECK-NEXT: - Name: archiveDefault
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 4 ; CHECK-NEXT: Index: 4
; CHECK-NEXT: - Name: __heap_base
; CHECK-NEXT: Kind: GLOBAL
; CHECK-NEXT: Index: 1
; CHECK-NEXT: - Type: ; CHECK-NEXT: - Type:

test/wasm/weak-alias-overide.ll

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
; CHECK-NEXT: - Type: GLOBAL ; CHECK-NEXT: - Type: GLOBAL
; CHECK-NEXT: Globals: ; CHECK-NEXT: Globals:
; CHECK-NEXT: - Index: 0 ; CHECK-NEXT: - Index: 0
; CHECK-NEXT: Type: I32 ; CHECK-NEXT: Type: I32
; CHECK-NEXT: Mutable: true ; CHECK-NEXT: Mutable: true
; CHECK-NEXT: InitExpr: ; CHECK-NEXT: InitExpr:
; CHECK-NEXT: Opcode: I32_CONST ; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 66560 ; CHECK-NEXT: Value: 66560
; CHECK-NEXT: - Index: 1
; CHECK-NEXT: Type: I32
; CHECK-NEXT: Mutable: false
; CHECK-NEXT: InitExpr:
; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 66560
; CHECK-NEXT: - Type: EXPORT ; CHECK-NEXT: - Type: EXPORT
; CHECK-NEXT: Exports: ; CHECK-NEXT: Exports:
; CHECK-NEXT: - Name: memory ; CHECK-NEXT: - Name: memory
; CHECK-NEXT: Kind: MEMORY ; CHECK-NEXT: Kind: MEMORY
; CHECK-NEXT: Index: 0 ; CHECK-NEXT: Index: 0
; CHECK-NEXT: - Name: alias_fn ; CHECK-NEXT: - Name: alias_fn
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 0 ; CHECK-NEXT: Index: 0
Show All 10 Lines
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 4 ; CHECK-NEXT: Index: 4
; CHECK-NEXT: - Name: call_alias_ptr ; CHECK-NEXT: - Name: call_alias_ptr
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 5 ; CHECK-NEXT: Index: 5
; CHECK-NEXT: - Name: call_direct_ptr ; CHECK-NEXT: - Name: call_direct_ptr
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 6 ; CHECK-NEXT: Index: 6
; CHECK-NEXT: - Name: __heap_base
; CHECK-NEXT: Kind: GLOBAL
; CHECK-NEXT: Index: 1
; CHECK-NEXT: - Type: ELEM ; CHECK-NEXT: - Type: ELEM
; CHECK-NEXT: Segments: ; CHECK-NEXT: Segments:
; CHECK-NEXT: - Offset: ; CHECK-NEXT: - Offset:
; CHECK-NEXT: Opcode: I32_CONST ; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 1 ; CHECK-NEXT: Value: 1
; CHECK-NEXT: Functions: [ 0, 2 ] ; CHECK-NEXT: Functions: [ 0, 2 ]
; CHECK-NEXT: - Type: CODE ; CHECK-NEXT: - Type: CODE
; CHECK-NEXT: Functions: ; CHECK-NEXT: Functions:
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

test/wasm/weak-alias.ll

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
; CHECK-NEXT: - Type: GLOBAL ; CHECK-NEXT: - Type: GLOBAL
; CHECK-NEXT: Globals: ; CHECK-NEXT: Globals:
; CHECK-NEXT: - Index: 0 ; CHECK-NEXT: - Index: 0
; CHECK-NEXT: Type: I32 ; CHECK-NEXT: Type: I32
; CHECK-NEXT: Mutable: true ; CHECK-NEXT: Mutable: true
; CHECK-NEXT: InitExpr: ; CHECK-NEXT: InitExpr:
; CHECK-NEXT: Opcode: I32_CONST ; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 66560 ; CHECK-NEXT: Value: 66560
; CHECK-NEXT: - Index: 1
; CHECK-NEXT: Type: I32
; CHECK-NEXT: Mutable: false
; CHECK-NEXT: InitExpr:
; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 66560
; CHECK-NEXT: - Type: EXPORT ; CHECK-NEXT: - Type: EXPORT
; CHECK-NEXT: Exports: ; CHECK-NEXT: Exports:
; CHECK-NEXT: - Name: memory ; CHECK-NEXT: - Name: memory
; CHECK-NEXT: Kind: MEMORY ; CHECK-NEXT: Kind: MEMORY
; CHECK-NEXT: Index: 0 ; CHECK-NEXT: Index: 0
; CHECK-NEXT: - Name: _start ; CHECK-NEXT: - Name: _start
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 0 ; CHECK-NEXT: Index: 0
Show All 10 Lines
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 4 ; CHECK-NEXT: Index: 4
; CHECK-NEXT: - Name: call_direct_ptr ; CHECK-NEXT: - Name: call_direct_ptr
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 5 ; CHECK-NEXT: Index: 5
; CHECK-NEXT: - Name: alias_fn ; CHECK-NEXT: - Name: alias_fn
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 1 ; CHECK-NEXT: Index: 1
; CHECK-NEXT: - Name: __heap_base
; CHECK-NEXT: Kind: GLOBAL
; CHECK-NEXT: Index: 1
; CHECK-NEXT: - Type: ELEM ; CHECK-NEXT: - Type: ELEM
; CHECK-NEXT: Segments: ; CHECK-NEXT: Segments:
; CHECK-NEXT: - Offset: ; CHECK-NEXT: - Offset:
; CHECK-NEXT: Opcode: I32_CONST ; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 1 ; CHECK-NEXT: Value: 1
; CHECK-NEXT: Functions: [ 1 ] ; CHECK-NEXT: Functions: [ 1 ]
; CHECK-NEXT: - Type: CODE ; CHECK-NEXT: - Type: CODE
; CHECK-NEXT: Functions: ; CHECK-NEXT: Functions:
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
; RELOC-NEXT: ReturnType: I32 ; RELOC-NEXT: ReturnType: I32
; RELOC-NEXT: ParamTypes: ; RELOC-NEXT: ParamTypes:
; RELOC-NEXT: - Type: IMPORT ; RELOC-NEXT: - Type: IMPORT
; RELOC-NEXT: Imports: ; RELOC-NEXT: Imports:
; RELOC-NEXT: - Module: env ; RELOC-NEXT: - Module: env
; RELOC-NEXT: Field: __stack_pointer ; RELOC-NEXT: Field: __stack_pointer
; RELOC-NEXT: Kind: GLOBAL ; RELOC-NEXT: Kind: GLOBAL
; RELOC-NEXT: GlobalType: I32 ; RELOC-NEXT: GlobalType: I32
; RELOC-NEXT: GlobalMutable: false ; RELOC-NEXT: GlobalMutable: true
; RELOC-NEXT: - Type: FUNCTION ; RELOC-NEXT: - Type: FUNCTION
; RELOC-NEXT: FunctionTypes: [ 0, 0, 0, 0, 0, 0 ] ; RELOC-NEXT: FunctionTypes: [ 0, 0, 0, 0, 0, 0 ]
; RELOC-NEXT: - Type: TABLE ; RELOC-NEXT: - Type: TABLE
; RELOC-NEXT: Tables: ; RELOC-NEXT: Tables:
; RELOC-NEXT: - ElemType: ANYFUNC ; RELOC-NEXT: - ElemType: ANYFUNC
; RELOC-NEXT: Limits: ; RELOC-NEXT: Limits:
; RELOC-NEXT: Flags: [ HAS_MAX ] ; RELOC-NEXT: Flags: [ HAS_MAX ]
; RELOC-NEXT: Initial: 0x00000002 ; RELOC-NEXT: Initial: 0x00000002
; RELOC-NEXT: Maximum: 0x00000002 ; RELOC-NEXT: Maximum: 0x00000002
; RELOC-NEXT: - Type: MEMORY ; RELOC-NEXT: - Type: MEMORY
; RELOC-NEXT: Memories: ; RELOC-NEXT: Memories:
; RELOC-NEXT: - Initial: 0x00000000 ; 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: - Type: ELEM
; RELOC-NEXT: Segments: ; RELOC-NEXT: Segments:
; RELOC-NEXT: - Offset: ; RELOC-NEXT: - Offset:
; RELOC-NEXT: Opcode: I32_CONST ; RELOC-NEXT: Opcode: I32_CONST
; RELOC-NEXT: Value: 1 ; RELOC-NEXT: Value: 1
; RELOC-NEXT: Functions: [ 1 ] ; RELOC-NEXT: Functions: [ 1 ]
; RELOC-NEXT: - Type: CODE ; RELOC-NEXT: - Type: CODE
; RELOC-NEXT: Relocations: ; RELOC-NEXT: Relocations:
; RELOC-NEXT: - Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB
; RELOC-NEXT: Index: 7 ; RELOC-NEXT: Index: 7
; RELOC-NEXT: Offset: 0x00000004 ; RELOC-NEXT: Offset: 0x00000004
; RELOC-NEXT: - Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB
; RELOC-NEXT: Index: 2 ; RELOC-NEXT: Index: 2
; RELOC-NEXT: Offset: 0x00000012 ; RELOC-NEXT: Offset: 0x00000012
; RELOC-NEXT: - Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB
; RELOC-NEXT: Index: 7 ; RELOC-NEXT: Index: 7
; RELOC-NEXT: Offset: 0x0000001B ; RELOC-NEXT: Offset: 0x0000001B
; RELOC-NEXT: - Type: R_WEBASSEMBLY_GLOBAL_INDEX_LEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_GLOBAL_INDEX_LEB
; RELOC-NEXT: Index: 0 ; RELOC-NEXT: Index: 1
; RELOC-NEXT: Offset: 0x00000026 ; RELOC-NEXT: Offset: 0x00000026
; RELOC-NEXT: - Type: R_WEBASSEMBLY_GLOBAL_INDEX_LEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_GLOBAL_INDEX_LEB
; RELOC-NEXT: Index: 0 ; RELOC-NEXT: Index: 1
; RELOC-NEXT: Offset: 0x00000031 ; RELOC-NEXT: Offset: 0x00000031
; RELOC-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB
; RELOC-NEXT: Index: 7 ; RELOC-NEXT: Index: 7
; RELOC-NEXT: Offset: 0x00000039 ; RELOC-NEXT: Offset: 0x00000039
; RELOC-NEXT: - Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB
; RELOC-NEXT: Index: 7 ; RELOC-NEXT: Index: 7
; RELOC-NEXT: Offset: 0x00000042 ; RELOC-NEXT: Offset: 0x00000042
; RELOC-NEXT: - Type: R_WEBASSEMBLY_GLOBAL_INDEX_LEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_GLOBAL_INDEX_LEB
; RELOC-NEXT: Index: 0 ; RELOC-NEXT: Index: 1
; RELOC-NEXT: Offset: 0x0000004F ; RELOC-NEXT: Offset: 0x0000004F
; RELOC-NEXT: - Type: R_WEBASSEMBLY_GLOBAL_INDEX_LEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_GLOBAL_INDEX_LEB
; RELOC-NEXT: Index: 0 ; RELOC-NEXT: Index: 1
; RELOC-NEXT: Offset: 0x0000005C ; RELOC-NEXT: Offset: 0x0000005C
; RELOC-NEXT: - Type: R_WEBASSEMBLY_GLOBAL_INDEX_LEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_GLOBAL_INDEX_LEB
; RELOC-NEXT: Index: 0 ; RELOC-NEXT: Index: 1
; RELOC-NEXT: Offset: 0x00000067 ; RELOC-NEXT: Offset: 0x00000067
; RELOC-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB
; RELOC-NEXT: Index: 2 ; RELOC-NEXT: Index: 2
; RELOC-NEXT: Offset: 0x0000006F ; RELOC-NEXT: Offset: 0x0000006F
; RELOC-NEXT: - Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB
; RELOC-NEXT: Index: 2 ; RELOC-NEXT: Index: 2
; RELOC-NEXT: Offset: 0x00000078 ; RELOC-NEXT: Offset: 0x00000078
; RELOC-NEXT: - Type: R_WEBASSEMBLY_GLOBAL_INDEX_LEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_GLOBAL_INDEX_LEB
; RELOC-NEXT: Index: 0 ; RELOC-NEXT: Index: 1
; RELOC-NEXT: Offset: 0x00000085 ; RELOC-NEXT: Offset: 0x00000085
; RELOC-NEXT: Functions: ; RELOC-NEXT: Functions:
; RELOC-NEXT: - Index: 0 ; RELOC-NEXT: - Index: 0
; RELOC-NEXT: Locals: ; RELOC-NEXT: Locals:
; RELOC-NEXT: Body: 1081808080000B ; RELOC-NEXT: Body: 1081808080000B
; RELOC-NEXT: - Index: 1 ; RELOC-NEXT: - Index: 1
; RELOC-NEXT: Locals: ; RELOC-NEXT: Locals:
; RELOC-NEXT: Body: 41000B ; RELOC-NEXT: Body: 41000B
Show All 11 Lines
; RELOC-NEXT: - Index: 5 ; RELOC-NEXT: - Index: 5
; RELOC-NEXT: Locals: ; RELOC-NEXT: Locals:
; RELOC-NEXT: - Type: I32 ; RELOC-NEXT: - Type: I32
; RELOC-NEXT: Count: 2 ; RELOC-NEXT: Count: 2
; RELOC-NEXT: Body: 23808080800041106B220024808080800020004181808080003602081081808080002101200041106A24808080800020010B ; RELOC-NEXT: Body: 23808080800041106B220024808080800020004181808080003602081081808080002101200041106A24808080800020010B
; RELOC-NEXT: - Type: CUSTOM ; RELOC-NEXT: - Type: CUSTOM
; RELOC-NEXT: Name: linking ; RELOC-NEXT: Name: linking
; RELOC-NEXT: DataSize: 0 ; RELOC-NEXT: DataSize: 0
; RELOC-NEXT: SymbolInfo: ; RELOC-NEXT: SymbolTable:
; RELOC-NEXT: - Name: alias_fn ; 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: Flags: [ BINDING_WEAK ]
; RELOC-NEXT: FunctionIndex: 1
; RELOC-NEXT: - Type: CUSTOM ; RELOC-NEXT: - Type: CUSTOM
; RELOC-NEXT: Name: name ; RELOC-NEXT: Name: name
; RELOC-NEXT: FunctionNames: ; RELOC-NEXT: FunctionNames:
; RELOC-NEXT: - Index: 0 ; RELOC-NEXT: - Index: 0
; RELOC-NEXT: Name: _start ; RELOC-NEXT: Name: _start
; RELOC-NEXT: - Index: 1 ; RELOC-NEXT: - Index: 1
; RELOC-NEXT: Name: direct_fn ; RELOC-NEXT: Name: direct_fn
; RELOC-NEXT: - Index: 2 ; RELOC-NEXT: - Index: 2
; RELOC-NEXT: Name: call_direct ; RELOC-NEXT: Name: call_direct
; RELOC-NEXT: - Index: 3 ; RELOC-NEXT: - Index: 3
; RELOC-NEXT: Name: call_alias ; RELOC-NEXT: Name: call_alias
; RELOC-NEXT: - Index: 4 ; RELOC-NEXT: - Index: 4
; RELOC-NEXT: Name: call_alias_ptr ; RELOC-NEXT: Name: call_alias_ptr
; RELOC-NEXT: - Index: 5 ; RELOC-NEXT: - Index: 5
; RELOC-NEXT: Name: call_direct_ptr ; RELOC-NEXT: Name: call_direct_ptr
; RELOC-NEXT: ... ; RELOC-NEXT: ...

test/wasm/weak-symbols.ll

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
; CHECK-NEXT: - Type: GLOBAL ; CHECK-NEXT: - Type: GLOBAL
; CHECK-NEXT: Globals: ; CHECK-NEXT: Globals:
; CHECK-NEXT: - Index: 0 ; CHECK-NEXT: - Index: 0
; CHECK-NEXT: Type: I32 ; CHECK-NEXT: Type: I32
; CHECK-NEXT: Mutable: true ; CHECK-NEXT: Mutable: true
; CHECK-NEXT: InitExpr: ; CHECK-NEXT: InitExpr:
; CHECK-NEXT: Opcode: I32_CONST ; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 66576 ; CHECK-NEXT: Value: 66576
; CHECK-NEXT: - Index: 1
; CHECK-NEXT: Type: I32
; CHECK-NEXT: Mutable: false
; CHECK-NEXT: InitExpr:
; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 66576
; CHECK-NEXT: - Type: EXPORT ; CHECK-NEXT: - Type: EXPORT
; CHECK-NEXT: Exports: ; CHECK-NEXT: Exports:
; CHECK-NEXT: - Name: memory ; CHECK-NEXT: - Name: memory
; CHECK-NEXT: Kind: MEMORY ; CHECK-NEXT: Kind: MEMORY
; CHECK-NEXT: Index: 0 ; CHECK-NEXT: Index: 0
; CHECK-NEXT: - Name: _start ; CHECK-NEXT: - Name: _start
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 0 ; CHECK-NEXT: Index: 0
; CHECK-NEXT: - Name: weakFn ; CHECK-NEXT: - Name: weakFn
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 1 ; CHECK-NEXT: Index: 1
; CHECK-NEXT: - Name: exportWeak1 ; CHECK-NEXT: - Name: exportWeak1
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 2 ; CHECK-NEXT: Index: 2
; CHECK-NEXT: - Name: exportWeak2 ; CHECK-NEXT: - Name: exportWeak2
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 4 ; CHECK-NEXT: Index: 4
; CHECK-NEXT: - Name: __heap_base
; CHECK-NEXT: Kind: GLOBAL
; CHECK-NEXT: Index: 1
; CHECK-NEXT: - Type: ELEM ; CHECK-NEXT: - Type: ELEM
; CHECK-NEXT: Segments: ; CHECK-NEXT: Segments:
; CHECK-NEXT: - Offset: ; CHECK-NEXT: - Offset:
; CHECK-NEXT: Opcode: I32_CONST ; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 1 ; CHECK-NEXT: Value: 1
; CHECK-NEXT: Functions: [ 1 ] ; CHECK-NEXT: Functions: [ 1 ]
; CHECK-NEXT: - Type: CODE ; CHECK-NEXT: - Type: CODE
; CHECK-NEXT: Functions: ; CHECK-NEXT: Functions:
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

test/wasm/weak-undefined.ll

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
; CHECK-NEXT: - Type: GLOBAL ; CHECK-NEXT: - Type: GLOBAL
; CHECK-NEXT: Globals: ; CHECK-NEXT: Globals:
; CHECK-NEXT: - Index: 0 ; CHECK-NEXT: - Index: 0
; CHECK-NEXT: Type: I32 ; CHECK-NEXT: Type: I32
; CHECK-NEXT: Mutable: true ; CHECK-NEXT: Mutable: true
; CHECK-NEXT: InitExpr: ; CHECK-NEXT: InitExpr:
; CHECK-NEXT: Opcode: I32_CONST ; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 66560 ; CHECK-NEXT: Value: 66560
; CHECK-NEXT: - Index: 1
; CHECK-NEXT: Type: I32
; CHECK-NEXT: Mutable: false
; CHECK-NEXT: InitExpr:
; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 66560
; CHECK-NEXT: - Type: EXPORT ; CHECK-NEXT: - Type: EXPORT
; CHECK-NEXT: Exports: ; CHECK-NEXT: Exports:
; CHECK-NEXT: - Name: memory ; CHECK-NEXT: - Name: memory
; CHECK-NEXT: Kind: MEMORY ; CHECK-NEXT: Kind: MEMORY
; CHECK-NEXT: Index: 0 ; CHECK-NEXT: Index: 0
; CHECK-NEXT: - Name: get_address_of_foo ; CHECK-NEXT: - Name: get_address_of_foo
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 0 ; CHECK-NEXT: Index: 0
; CHECK-NEXT: - Name: get_address_of_global_var ; CHECK-NEXT: - Name: get_address_of_global_var
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 1 ; CHECK-NEXT: Index: 1
; CHECK-NEXT: - Name: _start ; CHECK-NEXT: - Name: _start
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 2 ; CHECK-NEXT: Index: 2
; CHECK-NEXT: - Name: __heap_base
; CHECK-NEXT: Kind: GLOBAL
; CHECK-NEXT: Index: 1
; CHECK-NEXT: - Type: CODE ; CHECK-NEXT: - Type: CODE
; CHECK-NEXT: Functions: ; CHECK-NEXT: Functions:
; CHECK-NEXT: - Index: 0 ; CHECK-NEXT: - Index: 0
; CHECK-NEXT: Locals: ; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 4180808080000B ; CHECK-NEXT: Body: 4180808080000B
; CHECK-NEXT: - Index: 1 ; CHECK-NEXT: - Index: 1
; CHECK-NEXT: Locals: ; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 4180808080000B ; CHECK-NEXT: Body: 4180808080000B
Show All 10 Lines

wasm/Config.h

Show All 35 Linesstruct Configuration {
llvm::StringRef Entry; llvm::StringRef Entry;
llvm::StringRef OutputFile; llvm::StringRef OutputFile;
llvm::StringSet<> AllowUndefinedSymbols; llvm::StringSet<> AllowUndefinedSymbols;
std::vector<llvm::StringRef> SearchPaths; std::vector<llvm::StringRef> SearchPaths;
Symbol *StackPointerSymbol = nullptr; Symbol *StackPointerSymbol = nullptr;
Symbol *HeapBaseSymbol = nullptr; Symbol *HeapBaseSymbol = nullptr;
Symbol *CtorSymbol = nullptr; Symbol *CtorSymbol = nullptr;
llvm::wasm::ValType PtrType = llvm::wasm::ValType::I32;
}; };
// The only instance of Configuration struct. // The only instance of Configuration struct.
extern Configuration *Config; extern Configuration *Config;
} // namespace wasm } // namespace wasm
} // namespace lld } // namespace lld
#endif #endif

wasm/Driver.cpp

Show First 20 Lines • Show All 286 Lines • ▼ Show 20 Lines if (Config->Relocatable) {
if (Config->GcSections) if (Config->GcSections)
error("-r and --gc-sections may not be used together"); error("-r and --gc-sections may not be used together");
if (Args.hasArg(OPT_undefined)) if (Args.hasArg(OPT_undefined))
error("-r -and --undefined may not be used together"); error("-r -and --undefined may not be used together");
} }
Symbol *EntrySym = nullptr; Symbol *EntrySym = nullptr;
if (!Config->Relocatable) { if (!Config->Relocatable) {
static WasmSignature Signature = {{}, WASM_TYPE_NORESULT}; static WasmSignature EntrySignature = {{}, WASM_TYPE_NORESULT};
static WasmGlobalType StackPointerSignature =
{static_cast<int32_t>(Config->PtrType), true};
if (!Config->Entry.empty()) if (!Config->Entry.empty())
EntrySym = Symtab->addUndefinedFunction(Config->Entry, &Signature); EntrySym = Symtab->addUndefinedFunction(Config->Entry, &EntrySignature);
// Handle the `--undefined <sym>` options. // Handle the `--undefined <sym>` options.
for (auto* Arg : Args.filtered(OPT_undefined)) for (auto* Arg : Args.filtered(OPT_undefined))
Symtab->addUndefinedFunction(Arg->getValue(), nullptr); Symtab->addUndefinedFunction(Arg->getValue(), nullptr);
// Create linker-synthetic symbols // Create linker-synthetic symbols
// __wasm_call_ctors: // __wasm_call_ctors:
// Function that directly calls all ctors in priority order. // Function that directly calls all ctors in priority order.
// __stack_pointer: // __stack_pointer:
// Wasm global that holds the address of the top of the explict // Wasm global that holds the address of the top of the explict
// value stack in linear memory. // value stack in linear memory.
// __dso_handle; // __dso_handle;
// Global in calls to __cxa_atexit to determine current DLL // Global in calls to __cxa_atexit to determine current DLL
Config->CtorSymbol = Symtab->addDefinedFunction( Config->CtorSymbol = Symtab->addDefinedFunction(
"__wasm_call_ctors", &Signature, WASM_SYMBOL_VISIBILITY_HIDDEN); "__wasm_call_ctors", &EntrySignature, WASM_SYMBOL_VISIBILITY_HIDDEN);
Config->StackPointerSymbol = Symtab->addDefinedGlobal("__stack_pointer"); Config->StackPointerSymbol = Symtab->addDefinedGlobal(
Config->HeapBaseSymbol = Symtab->addDefinedGlobal("__heap_base"); "__stack_pointer", &StackPointerSignature,
Symtab->addDefinedGlobal("__dso_handle")->setVirtualAddress(0); // 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);
Config->HeapBaseSymbol = Symtab->addDefinedData("__heap_base");
Symtab->addDefinedData("__dso_handle")->setVirtualAddress(0);
} }
createFiles(Args); createFiles(Args);
if (errorCount()) if (errorCount())
return; return;
// Add all files to the symbol table. This will add almost all // Add all files to the symbol table. This will add almost all
// symbols that we need to the symbol table. // symbols that we need to the symbol table.
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

wasm/InputChunks.h

Show All 17 Lines
#include "Config.h" #include "Config.h"
#include "InputFiles.h" #include "InputFiles.h"
#include "WriterUtils.h" #include "WriterUtils.h"
#include "lld/Common/ErrorHandler.h" #include "lld/Common/ErrorHandler.h"
#include "llvm/Object/Wasm.h" #include "llvm/Object/Wasm.h"
using llvm::object::WasmSegment; using llvm::object::WasmSegment;
using llvm::wasm::WasmFunction; using llvm::wasm::WasmFunction;
using llvm::wasm::WasmGlobal;
using llvm::wasm::WasmRelocation; using llvm::wasm::WasmRelocation;
using llvm::wasm::WasmSignature; using llvm::wasm::WasmSignature;
using llvm::wasm::WasmInitExpr;
using llvm::object::WasmSection; using llvm::object::WasmSection;
namespace lld { namespace lld {
namespace wasm { namespace wasm {
class ObjFile; class ObjFile;
class OutputSegment; class OutputSegment;
class InputChunk { class InputChunk {
public: 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(); } uint32_t getSize() const { return data().size(); }
void copyRelocations(const WasmSection &Section); void copyRelocations(const WasmSection &Section);
void writeTo(uint8_t *SectionStart) const; void writeTo(uint8_t *SectionStart) const;
void setOutputOffset(uint32_t Offset) { void setOutputOffset(uint32_t Offset) {
OutputOffset = Offset; OutputOffset = Offset;
calcRelocations(); calcRelocations();
} }
uint32_t getOutputOffset() const { return OutputOffset; } uint32_t getOutputOffset() const { return OutputOffset; }
ArrayRef<WasmRelocation> getRelocations() const { return Relocations; } ArrayRef<WasmRelocation> getRelocations() const { return Relocations; }
StringRef getFileName() const { return File->getName(); } StringRef getFileName() const { return File->getName(); }
virtual StringRef getComdat() const = 0; virtual StringRef getComdat() const = 0;
virtual StringRef getName() const = 0; virtual StringRef getName() const = 0;
virtual bool hasOutputIndex() const = 0;
virtual uint32_t getOutputIndex() const = 0;
bool Discarded = false; bool Discarded = false;
std::vector<OutputRelocation> OutRelocations; std::vector<OutputRelocation> OutRelocations;
const ObjFile *File; const ObjFile *File;
// The garbage collector sets sections' Live bits. // The garbage collector sets sections' Live bits.
// If GC is disabled, all sections are considered live by default. // If GC is disabled, all sections are considered live by default.
unsigned Live : 1; unsigned Live : 1;
Show All 37 Lines void setOutputSegment(const OutputSegment *Segment, uint32_t Offset) {
OutputSegmentOffset = Offset; OutputSegmentOffset = Offset;
} }
uint32_t getAlignment() const { return Segment.Data.Alignment; } uint32_t getAlignment() const { return Segment.Data.Alignment; }
uint32_t startVA() const { return Segment.Data.Offset.Value.Int32; } uint32_t startVA() const { return Segment.Data.Offset.Value.Int32; }
uint32_t endVA() const { return startVA() + getSize(); } uint32_t endVA() const { return startVA() + getSize(); }
StringRef getName() const override { return Segment.Data.Name; } StringRef getName() const override { return Segment.Data.Name; }
StringRef getComdat() const override { return Segment.Data.Comdat; } StringRef getComdat() const override { return Segment.Data.Comdat; }
bool hasOutputIndex() const override { return OutputSeg != nullptr; }
uint32_t getOutputIndex() const override;
int32_t OutputSegmentOffset = 0; int32_t OutputSegmentOffset = 0;
protected: protected:
ArrayRef<uint8_t> data() const override { return Segment.Data.Content; } ArrayRef<uint8_t> data() const override { return Segment.Data.Content; }
uint32_t getInputSectionOffset() const override { uint32_t getInputSectionOffset() const override {
return Segment.SectionOffset; return Segment.SectionOffset;
} }
Show All 11 Lines InputFunction(const WasmSignature &S, const WasmFunction *Func,
: InputChunk(F, InputChunk::Function), Signature(S), Function(Func) {} : InputChunk(F, InputChunk::Function), Signature(S), Function(Func) {}
static bool classof(const InputChunk *C) { static bool classof(const InputChunk *C) {
return C->kind() == InputChunk::Function; return C->kind() == InputChunk::Function;
} }
StringRef getName() const override { return Function->Name; } StringRef getName() const override { return Function->Name; }
StringRef getComdat() const override { return Function->Comdat; } StringRef getComdat() const override { return Function->Comdat; }
uint32_t getOutputIndex() const { return OutputIndex.getValue(); } uint32_t getOutputIndex() const override { return OutputIndex.getValue(); }
bool hasOutputIndex() const { return OutputIndex.hasValue(); } bool hasOutputIndex() const override { return OutputIndex.hasValue(); }
void setOutputIndex(uint32_t Index); void setOutputIndex(uint32_t Index);
uint32_t getTableIndex() const { return TableIndex.getValue(); } uint32_t getTableIndex() const { return TableIndex.getValue(); }
bool hasTableIndex() const { return TableIndex.hasValue(); } bool hasTableIndex() const { return TableIndex.hasValue(); }
void setTableIndex(uint32_t Index); void setTableIndex(uint32_t Index);
const WasmSignature &Signature; const WasmSignature &Signature;
protected: protected:
Show All 9 Linesprotected:
llvm::Optional<uint32_t> OutputIndex; llvm::Optional<uint32_t> OutputIndex;
llvm::Optional<uint32_t> TableIndex; llvm::Optional<uint32_t> TableIndex;
}; };
class SyntheticFunction : public InputFunction { class SyntheticFunction : public InputFunction {
public: public:
SyntheticFunction(const WasmSignature &S, ArrayRef<uint8_t> Body, SyntheticFunction(const WasmSignature &S, ArrayRef<uint8_t> Body,
StringRef Name) 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; } StringRef getName() const override { return Name; }
protected: protected:
ArrayRef<uint8_t> data() const override { return Body; } ArrayRef<uint8_t> data() const override { return Body; }
StringRef Name; StringRef Name;
ArrayRef<uint8_t> Body; 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,
const 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 wasm
} // namespace lld } // namespace lld
#endif // LLD_WASM_INPUT_CHUNKS_H #endif // LLD_WASM_INPUT_CHUNKS_H

wasm/InputChunks.cpp

Show All 16 Lines
#define DEBUG_TYPE "lld" #define DEBUG_TYPE "lld"
using namespace llvm; using namespace llvm;
using namespace llvm::wasm; using namespace llvm::wasm;
using namespace lld; using namespace lld;
using namespace lld::wasm; using namespace lld::wasm;
uint32_t InputSegment::translateVA(uint32_t Address) const { 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(); int32_t Delta = OutputSeg->StartVA + OutputSegmentOffset - startVA();
DEBUG(dbgs() << "translateVA: " << getName() << " Delta=" << Delta DEBUG(dbgs() << "translateVA: " << getName() << " Delta=" << Delta
<< " Address=" << Address << "\n"); << " Address=" << Address << "\n");
return Address + Delta; return Address + Delta;
} }
void InputChunk::copyRelocations(const WasmSection &Section) { void InputChunk::copyRelocations(const WasmSection &Section) {
if (Section.Relocations.empty()) if (Section.Relocations.empty())
▲ Show 20 Lines • Show All 73 Lines • ▼ Show 20 Lines for (const WasmRelocation &Reloc : Relocations) {
if (Config->Relocatable) if (Config->Relocatable)
NewReloc.NewIndex = File->calcNewIndex(Reloc); NewReloc.NewIndex = File->calcNewIndex(Reloc);
NewReloc.Value = File->calcNewValue(Reloc); NewReloc.Value = File->calcNewValue(Reloc);
OutRelocations.emplace_back(NewReloc); OutRelocations.emplace_back(NewReloc);
} }
} }
uint32_t InputSegment::getOutputIndex() const {
return OutputSeg->Index;
}
void InputFunction::setOutputIndex(uint32_t Index) { void InputFunction::setOutputIndex(uint32_t Index) {
DEBUG(dbgs() << "InputFunction::setOutputIndex: " << getName() << " -> " << Index << "\n"); DEBUG(dbgs() << "InputFunction::setOutputIndex: " << getName() << " -> " << Index << "\n");
assert(!hasOutputIndex()); assert(!hasOutputIndex());
OutputIndex = Index; OutputIndex = Index;
} }
void InputFunction::setTableIndex(uint32_t Index) { void InputFunction::setTableIndex(uint32_t Index) {
DEBUG(dbgs() << "InputFunction::setTableIndex: " << getName() << " -> " << Index << "\n"); DEBUG(dbgs() << "InputFunction::setTableIndex: " << getName() << " -> " << Index << "\n");
assert(!hasTableIndex()); assert(!hasTableIndex());
TableIndex = Index; TableIndex = Index;
} }
void InputGlobal::setOutputIndex(uint32_t Index) {
DEBUG(dbgs() << "InputGlobal::setOutputIndex: " << Index << "\n");
assert(!hasOutputIndex());
OutputIndex = Index;
}

wasm/InputFiles.h

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

wasm/InputFiles.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 LinesOptional<MemoryBufferRef> lld::wasm::readFile(StringRef Path) {
return MBRef; return MBRef;
} }
void ObjFile::dumpInfo() const { void ObjFile::dumpInfo() const {
log("info for: " + getName() + "\n" + log("info for: " + getName() + "\n" +
" Symbols : " + Twine(Symbols.size()) + "\n"); " Symbols : " + Twine(Symbols.size()) + "\n");
} }
uint32_t ObjFile::relocateVirtualAddress(uint32_t GlobalIndex) const { uint32_t ObjFile::relocateVirtualAddress(uint32_t Index) const {
return getGlobalSymbol(GlobalIndex)->getVirtualAddress(); return getDataSymbol(Index)->getVirtualAddress();
} }
uint32_t ObjFile::relocateFunctionIndex(uint32_t Original) const { uint32_t ObjFile::relocateFunctionIndex(uint32_t Original) const {
const Symbol *Sym = getFunctionSymbol(Original); const Symbol *Sym = getFunctionSymbol(Original);
uint32_t Index = Sym->getOutputIndex(); uint32_t Index = Sym->getOutputIndex();
DEBUG(dbgs() << "relocateFunctionIndex: " << toString(*Sym) << ": " DEBUG(dbgs() << "relocateFunctionIndex: " << toString(*Sym) << ": "
<< Original << " -> " << Index << "\n"); << Original << " -> " << Index << "\n");
return Index; return Index;
Show All 32 Lines
uint32_t ObjFile::relocateGlobalSymbolIndex(uint32_t Original) const { uint32_t ObjFile::relocateGlobalSymbolIndex(uint32_t Original) const {
Symbol *Sym = getGlobalSymbol(Original); Symbol *Sym = getGlobalSymbol(Original);
uint32_t Index = Sym->getOutputSymbolIndex(); uint32_t Index = Sym->getOutputSymbolIndex();
DEBUG(dbgs() << "relocateGlobalSymbolIndex: " << toString(*Sym) << ": " DEBUG(dbgs() << "relocateGlobalSymbolIndex: " << toString(*Sym) << ": "
<< Original << " -> " << Index << "\n"); << Original << " -> " << Index << "\n");
return Index; 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 // Relocations contain an index into the function, global or table index
// space of the input file. This function takes a relocation and returns the // 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 // relocated index (i.e. translates from the input index space to the output
// index space). // index space).
uint32_t ObjFile::calcNewIndex(const WasmRelocation &Reloc) const { uint32_t ObjFile::calcNewIndex(const WasmRelocation &Reloc) const {
switch (Reloc.Type) { switch (Reloc.Type) {
case R_WEBASSEMBLY_TYPE_INDEX_LEB: case R_WEBASSEMBLY_TYPE_INDEX_LEB:
return relocateTypeIndex(Reloc.Index); return relocateTypeIndex(Reloc.Index);
case R_WEBASSEMBLY_FUNCTION_INDEX_LEB: case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
case R_WEBASSEMBLY_TABLE_INDEX_I32: case R_WEBASSEMBLY_TABLE_INDEX_I32:
case R_WEBASSEMBLY_TABLE_INDEX_SLEB: case R_WEBASSEMBLY_TABLE_INDEX_SLEB:
return relocateFunctionSymbolIndex(Reloc.Index); return relocateFunctionSymbolIndex(Reloc.Index);
case R_WEBASSEMBLY_GLOBAL_INDEX_LEB: case R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
return relocateGlobalSymbolIndex(Reloc.Index);
case R_WEBASSEMBLY_MEMORY_ADDR_LEB: case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
case R_WEBASSEMBLY_MEMORY_ADDR_SLEB: case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
case R_WEBASSEMBLY_MEMORY_ADDR_I32: case R_WEBASSEMBLY_MEMORY_ADDR_I32:
return relocateGlobalSymbolIndex(Reloc.Index); return relocateDataSymbolIndex(Reloc.Index);
default: default:
llvm_unreachable("unknown relocation type"); llvm_unreachable("unknown relocation type");
} }
} }
// Translate from the relocation's index into the final linked output value. // Translate from the relocation's index into the final linked output value.
uint32_t ObjFile::calcNewValue(const WasmRelocation &Reloc) const { uint32_t ObjFile::calcNewValue(const WasmRelocation &Reloc) const {
switch (Reloc.Type) { switch (Reloc.Type) {
Show All 39 Lines else if (Section.Type == WASM_SEC_DATA)
DataSection = &Section; DataSection = &Section;
} }
initializeSymbols(); initializeSymbols();
} }
// Return the InputSegment in which a given symbol is defined. // Return the InputSegment in which a given symbol is defined.
InputSegment *ObjFile::getSegment(const WasmSymbol &WasmSym) const { InputSegment *ObjFile::getSegment(const WasmSymbol &WasmSym) const {
uint32_t Address = WasmObj->getWasmSymbolValue(WasmSym); return Segments[WasmSym.Segment.getValue().Segment];
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. std::pair<uint32_t,uint32_t> ObjFile::getDataAddressAndSize(
// This represents the virtual address of the symbol in the input file. const WasmSymbol &WasmSym) const {
uint32_t ObjFile::getGlobalValue(const WasmSymbol &Sym) const { auto &Segment = WasmSym.Segment.getValue();
assert(Sym.ElementIndex >= NumGlobalImports); return std::make_pair(getSegment(WasmSym)->startVA() + Segment.Offset,
const WasmGlobal &Global = Segment.Size);
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];
} }
InputFunction *ObjFile::getFunction(const WasmSymbol &Sym) const { InputFunction *ObjFile::getFunction(const WasmSymbol &Sym) const {
assert(Sym.ElementIndex >= NumFunctionImports); assert(Sym.ElementIndex >= NumFunctionImports);
uint32_t FunctionIndex = Sym.ElementIndex - NumFunctionImports; uint32_t FunctionIndex = Sym.ElementIndex - NumFunctionImports;
return Functions[FunctionIndex]; return Functions[FunctionIndex];
} }
InputGlobal *ObjFile::getGlobal(const WasmSymbol &Sym) const {
assert(Sym.ElementIndex >= NumGlobalImports);
uint32_t GlobalIndex = Sym.ElementIndex - NumGlobalImports;
return Globals[GlobalIndex];
}
bool ObjFile::isExcludedByComdat(InputChunk *Chunk) const { bool ObjFile::isExcludedByComdat(InputChunk *Chunk) const {
StringRef Comdat = Chunk->getComdat(); StringRef Comdat = Chunk->getComdat();
return !Comdat.empty() && Symtab->findComdat(Comdat) != this; return !Comdat.empty() && Symtab->findComdat(Comdat) != this;
} }
Symbol *ObjFile::getFunctionSymbol(uint32_t Index) const { Symbol *ObjFile::getFunctionSymbol(uint32_t Index) const {
Symbol *Sym = Symbols[Index]; Symbol *Sym = Symbols[Index];
assert(Sym->isFunction()); assert(Sym->isFunction());
return Sym; 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 *ObjFile::getGlobalSymbol(uint32_t Index) const {
Symbol *Sym = Symbols[Index]; Symbol *Sym = Symbols[Index];
assert(Sym->isGlobal()); assert(Sym->isGlobal());
return Sym; return Sym;
} }
void ObjFile::initializeSymbols() { void ObjFile::initializeSymbols() {
Symbols.reserve(WasmObj->getNumberOfSymbols()); Symbols.reserve(WasmObj->getNumberOfSymbols());
Show All 9 Lines for (const auto &C : WasmObj->comdats())
Symtab->addComdat(C, this); Symtab->addComdat(C, this);
for (const WasmSegment &S : WasmObj->dataSegments()) { for (const WasmSegment &S : WasmObj->dataSegments()) {
InputSegment *Seg = make<InputSegment>(S, this); InputSegment *Seg = make<InputSegment>(S, this);
Seg->copyRelocations(*DataSection); Seg->copyRelocations(*DataSection);
Segments.emplace_back(Seg); 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) { for (size_t I = 0; I < Funcs.size(); ++I) {
const WasmFunction &Func = Funcs[I]; const WasmFunction &Func = Funcs[I];
const WasmSignature &Sig = Types[FuncTypes[I]]; const WasmSignature &Sig = Types[FuncTypes[I]];
InputFunction *F = make<InputFunction>(Sig, &Func, this); InputFunction *F = make<InputFunction>(Sig, &Func, this);
F->copyRelocations(*CodeSection); F->copyRelocations(*CodeSection);
Functions.emplace_back(F); Functions.emplace_back(F);
} }
// Populate `FunctionSymbols` and `GlobalSymbols` based on the WasmSymbols // Populate `Symbols` based on the WasmSymbols in the object
// in the object
for (const SymbolRef &Sym : WasmObj->symbols()) { for (const SymbolRef &Sym : WasmObj->symbols()) {
const WasmSymbol &WasmSym = WasmObj->getWasmSymbol(Sym.getRawDataRefImpl()); const WasmSymbol &WasmSym = WasmObj->getWasmSymbol(Sym.getRawDataRefImpl());
Symbol *S; Symbol *S;
switch (WasmSym.Type) { switch (WasmSym.Type) {
case WasmSymbol::SymbolType::FUNCTION_EXPORT: { case WasmSymbol::SymbolType::FUNCTION:
if (WasmSym.ElementIndex >= NumFunctionImports) {
InputFunction *Function = getFunction(WasmSym); InputFunction *Function = getFunction(WasmSym);
if (!isExcludedByComdat(Function)) { if (!isExcludedByComdat(Function)) {
S = createDefined(WasmSym, Symbol::Kind::DefinedFunctionKind, Function); S = createDefined(WasmSym, Symbol::Kind::DefinedFunctionKind,
Function);
break; break;
} else { } else {
Function->Discarded = true; 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);
S = createUndefined(WasmSym, Symbol::Kind::UndefinedFunctionKind,
getFunctionSig(WasmSym));
break; break;
case WasmSymbol::SymbolType::GLOBAL_EXPORT: {
case WasmSymbol::SymbolType::DATA:
if (WasmSym.Segment.hasValue()) {
InputSegment *Segment = getSegment(WasmSym); InputSegment *Segment = getSegment(WasmSym);
if (!isExcludedByComdat(Segment)) { if (!isExcludedByComdat(Segment)) {
S = createDefined(WasmSym, Symbol::Kind::DefinedGlobalKind, Segment, uint32_t DataAddress, DataSize;
getGlobalValue(WasmSym)); std::tie(DataAddress, DataSize) = getDataAddressAndSize(WasmSym);
S = createDefined(WasmSym, Symbol::Kind::DefinedDataKind, Segment,
DataAddress, DataSize);
break; break;
} else { } else {
Segment->Discarded = true; 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 WasmSymbol::SymbolType::GLOBAL:
if (WasmSym.ElementIndex >= NumGlobalImports) {
InputGlobal *Global = getGlobal(WasmSym);
S = createDefined(WasmSym, Symbol::Kind::DefinedGlobalKind, Global);
break;
} }
case WasmSymbol::SymbolType::GLOBAL_IMPORT:
S = createUndefined(WasmSym, Symbol::Kind::UndefinedGlobalKind); S = createUndefined(WasmSym, Symbol::Kind::UndefinedGlobalKind);
break; break;
} }
Symbols.push_back(S); Symbols.push_back(S);
} }
} }
Symbol *ObjFile::createUndefined(const WasmSymbol &Sym, Symbol::Kind Kind, Symbol *ObjFile::createUndefined(const WasmSymbol &Sym, Symbol::Kind Kind) {
const WasmSignature *Signature) { return Symtab->addUndefined(Sym.Name, Kind, Sym.Flags, this, Sym.FunctionType,
return Symtab->addUndefined(Sym.Name, Kind, Sym.Flags, this, Signature); Sym.GlobalType);
} }
Symbol *ObjFile::createDefined(const WasmSymbol &Sym, Symbol::Kind Kind, Symbol *ObjFile::createDefined(const WasmSymbol &Sym, Symbol::Kind Kind,
InputChunk *Chunk, uint32_t Address) { InputChunk *Chunk, uint32_t DataAddress,
uint32_t DataSize) {
Symbol *S; Symbol *S;
if (Sym.isBindingLocal()) { if (Sym.isBindingLocal()) {
S = make<Symbol>(Sym.Name, true); S = make<Symbol>(Sym.Name, true);
S->update(Kind, this, Sym.Flags, Chunk, Address); S->update(Kind, this, Sym.Flags, Chunk, DataAddress, DataSize);
return S; return S;
} }
return Symtab->addDefined(Sym.Name, Kind, Sym.Flags, this, Chunk, Address); return Symtab->addDefined(Sym.Name, Kind, Sym.Flags, this, Chunk, DataAddress,
DataSize);
} }
void ArchiveFile::parse() { void ArchiveFile::parse() {
// Parse a MemoryBufferRef as an archive file. // Parse a MemoryBufferRef as an archive file.
DEBUG(dbgs() << "Parsing library: " << toString(this) << "\n"); DEBUG(dbgs() << "Parsing library: " << toString(this) << "\n");
File = CHECK(Archive::create(MB), toString(this)); File = CHECK(Archive::create(MB), toString(this));
// Read the symbol table to construct Lazy symbols. // Read the symbol table to construct Lazy symbols.
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

wasm/MarkLive.cpp

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

wasm/OutputSegment.h

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

wasm/SymbolTable.h

Show All 12 Lines
#include "InputFiles.h" #include "InputFiles.h"
#include "Symbols.h" #include "Symbols.h"
#include "llvm/ADT/CachedHashString.h" #include "llvm/ADT/CachedHashString.h"
#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMap.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
using llvm::wasm::WasmSignature; using llvm::wasm::WasmSignature;
using llvm::wasm::WasmGlobalType;
namespace lld { namespace lld {
namespace wasm { namespace wasm {
class InputSegment; class InputSegment;
// SymbolTable is a bucket of all known symbols, including defined, // SymbolTable is a bucket of all known symbols, including defined,
// undefined, or lazy symbols (the last one is symbols in archive // undefined, or lazy symbols (the last one is symbols in archive
Show All 17 Linespublic:
void reportRemainingUndefines(); void reportRemainingUndefines();
ArrayRef<Symbol *> getSymbols() const { return SymVector; } ArrayRef<Symbol *> getSymbols() const { return SymVector; }
Symbol *find(StringRef Name); Symbol *find(StringRef Name);
ObjFile *findComdat(StringRef Name) const; ObjFile *findComdat(StringRef Name) const;
Symbol *addDefined(StringRef Name, Symbol::Kind Kind, uint32_t Flags, Symbol *addDefined(StringRef Name, Symbol::Kind Kind, uint32_t Flags,
InputFile *F, InputChunk *Chunk = nullptr, 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, 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 *addUndefinedFunction(StringRef Name, const WasmSignature *Type);
Symbol *addDefinedGlobal(StringRef Name);
Symbol *addDefinedFunction(StringRef Name, const WasmSignature *Type, 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); void addLazy(ArchiveFile *F, const Archive::Symbol *Sym);
bool addComdat(StringRef Name, ObjFile *); bool addComdat(StringRef Name, ObjFile *);
private: private:
std::pair<Symbol *, bool> insert(StringRef Name); std::pair<Symbol *, bool> insert(StringRef Name);
llvm::DenseMap<llvm::CachedHashStringRef, ObjFile *> ComdatMap; llvm::DenseMap<llvm::CachedHashStringRef, ObjFile *> ComdatMap;
llvm::DenseMap<llvm::CachedHashStringRef, Symbol *> SymMap; llvm::DenseMap<llvm::CachedHashStringRef, Symbol *> SymMap;
Show All 9 Lines

wasm/SymbolTable.cpp

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

wasm/Symbols.h

Show All 9 Lines
#ifndef LLD_WASM_SYMBOLS_H #ifndef LLD_WASM_SYMBOLS_H
#define LLD_WASM_SYMBOLS_H #define LLD_WASM_SYMBOLS_H
#include "lld/Common/LLVM.h" #include "lld/Common/LLVM.h"
#include "llvm/Object/Archive.h" #include "llvm/Object/Archive.h"
#include "llvm/Object/Wasm.h" #include "llvm/Object/Wasm.h"
using llvm::object::Archive; using llvm::object::Archive;
using llvm::object::WasmSymbol;
using llvm::wasm::WasmSignature; using llvm::wasm::WasmSignature;
using llvm::wasm::WasmGlobalType;
namespace lld { namespace lld {
namespace wasm { namespace wasm {
class InputFile; class InputFile;
class InputChunk; class InputChunk;
class Symbol { class Symbol {
public: public:
enum Kind { enum Kind {
DefinedFunctionKind, DefinedFunctionKind,
DefinedDataKind,
DefinedGlobalKind, DefinedGlobalKind,
LazyKind, LazyKind,
UndefinedFunctionKind, UndefinedFunctionKind,
UndefinedDataKind,
UndefinedGlobalKind, UndefinedGlobalKind,
LastDefinedKind = DefinedGlobalKind, LastDefinedKind = DefinedGlobalKind,
InvalidKind, InvalidKind,
}; };
Symbol(StringRef Name, uint32_t Flags) : Flags(Flags), Name(Name) {} Symbol(StringRef Name, uint32_t Flags) : Flags(Flags), Name(Name) {}
Kind getKind() const { return SymbolKind; } Kind getKind() const { return SymbolKind; }
bool isLazy() const { return SymbolKind == LazyKind; } bool isLazy() const { return SymbolKind == LazyKind; }
bool isDefined() const { return SymbolKind <= LastDefinedKind; } bool isDefined() const { return SymbolKind <= LastDefinedKind; }
bool isUndefined() const { bool isUndefined() const {
return SymbolKind == UndefinedGlobalKind || return SymbolKind == UndefinedFunctionKind ||
SymbolKind == UndefinedFunctionKind; SymbolKind == UndefinedDataKind ||
SymbolKind == UndefinedGlobalKind;
} }
bool isFunction() const { bool isFunction() const {
return SymbolKind == DefinedFunctionKind || return SymbolKind == DefinedFunctionKind ||
SymbolKind == UndefinedFunctionKind; 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 isLocal() const;
bool isWeak() const; bool isWeak() const;
bool isHidden() const; bool isHidden() const;
// Returns the symbol name. // Returns the symbol name.
StringRef getName() const { return Name; } StringRef getName() const { return Name; }
// Returns the file from which this symbol was created. // Returns the file from which this symbol was created.
InputFile *getFile() const { return File; } InputFile *getFile() const { return File; }
InputChunk *getChunk() const { return Chunk; } InputChunk *getChunk() const { return Chunk; }
bool hasFunctionType() const { return FunctionType != nullptr; } bool hasFunctionType() const { return FunctionType != nullptr; }
const WasmSignature &getFunctionType() const; const WasmSignature &getFunctionType() const;
void setFunctionType(const WasmSignature *Type); void setFunctionType(const WasmSignature *Type);
bool hasGlobalType() const { return GlobalType != nullptr; }
const WasmGlobalType &getGlobalType() const;
void setGlobalType(const WasmGlobalType *Type);
void setHidden(bool IsHidden); void setHidden(bool IsHidden);
uint32_t getOutputIndex() const; uint32_t getOutputIndex() const;
// Returns true if an output index has been set for this symbol // Returns true if an output index has been set for this symbol
bool hasOutputIndex() const; bool hasOutputIndex() const;
// Set the output index of the symbol, in the function or global Wasm // Set the output index of the symbol, in the Wasm index space of the output
// index space of the output object - that is, for defined symbols only, // object - that is, for defined symbols only, its position in the list of
// its position in the list of defined function bodies / global decls. // Wasm imports+code for functions, imports+globals for globals.
void setOutputIndex(uint32_t Index); void setOutputIndex(uint32_t Index);
// Get/set the output symbol index, in the function or global Symbol index // Get/set the output symbol index, in the Symbol index space. This is
// space - that is, the position in the list of imports+exports. This is
// only used for relocatable output. // only used for relocatable output.
uint32_t getOutputSymbolIndex() const; uint32_t getOutputSymbolIndex() const;
void setOutputSymbolIndex(uint32_t Index); void setOutputSymbolIndex(uint32_t Index);
uint32_t getTableIndex() const; uint32_t getTableIndex() const;
// Returns true if a table index has been set for this symbol // Returns true if a table index has been set for this symbol
bool hasTableIndex() const; bool hasTableIndex() const;
// Set the table index of the symbol // Set the table index of the symbol
void setTableIndex(uint32_t Index); void setTableIndex(uint32_t Index);
// Returns the virtual address of a defined global. // Returns the output virtual address of a defined data symbol.
// Only works for globals, not functions.
uint32_t getVirtualAddress() const; 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, 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; } void setArchiveSymbol(const Archive::Symbol &Sym) { ArchiveSymbol = Sym; }
const Archive::Symbol &getArchiveSymbol() { return ArchiveSymbol; } const Archive::Symbol &getArchiveSymbol() { return ArchiveSymbol; }
protected: protected:
uint32_t Flags; uint32_t Flags;
uint32_t VirtualAddress = 0; uint32_t VirtualAddress = 0;
uint32_t VirtualSize = 0;
StringRef Name; StringRef Name;
Archive::Symbol ArchiveSymbol = {nullptr, 0, 0}; Archive::Symbol ArchiveSymbol = {nullptr, 0, 0};
Kind SymbolKind = InvalidKind; Kind SymbolKind = InvalidKind;
InputFile *File = nullptr; InputFile *File = nullptr;
InputChunk *Chunk = nullptr; InputChunk *Chunk = nullptr;
llvm::Optional<uint32_t> OutputIndex; llvm::Optional<uint32_t> OutputIndex;
llvm::Optional<uint32_t> OutputSymbolIndex; llvm::Optional<uint32_t> OutputSymbolIndex;
llvm::Optional<uint32_t> TableIndex; llvm::Optional<uint32_t> TableIndex;
const WasmSignature *FunctionType = nullptr; const WasmSignature *FunctionType = nullptr;
const WasmGlobalType *GlobalType = nullptr;
}; };
} // namespace wasm } // namespace wasm
// Returns a symbol name for an error message. // Returns a symbol name for an error message.
std::string toString(const wasm::Symbol &Sym); std::string toString(const wasm::Symbol &Sym);
std::string toString(wasm::Symbol::Kind Kind); std::string toString(wasm::Symbol::Kind Kind);
std::string toString(WasmSymbol::SymbolType Type);
WasmSymbol::SymbolType toWasmType(wasm::Symbol::Kind Kind);
} // namespace lld } // namespace lld
#endif #endif

wasm/Symbols.cpp

Show All 30 Lines
} }
void Symbol::setFunctionType(const WasmSignature *Type) { void Symbol::setFunctionType(const WasmSignature *Type) {
assert(FunctionType == nullptr); assert(FunctionType == nullptr);
assert(!Chunk); assert(!Chunk);
FunctionType = Type; 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 { uint32_t Symbol::getVirtualAddress() const {
assert(isGlobal()); assert(isData());
DEBUG(dbgs() << "getVirtualAddress: " << getName() << "\n"); DEBUG(dbgs() << "getVirtualAddress: " << getName() << "\n");
return Chunk ? dyn_cast<InputSegment>(Chunk)->translateVA(VirtualAddress) return Chunk ? dyn_cast<InputSegment>(Chunk)->translateVA(VirtualAddress)
: 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 { bool Symbol::hasOutputIndex() const {
if (auto *F = dyn_cast_or_null<InputFunction>(Chunk)) return Chunk ? Chunk->hasOutputIndex() : OutputIndex.hasValue();
return F->hasOutputIndex();
return OutputIndex.hasValue();
} }
uint32_t Symbol::getOutputIndex() const { uint32_t Symbol::getOutputIndex() const {
if (auto *F = dyn_cast_or_null<InputFunction>(Chunk)) return Chunk ? Chunk->getOutputIndex() : OutputIndex.getValue();
return F->getOutputIndex();
return OutputIndex.getValue();
} }
uint32_t Symbol::getOutputSymbolIndex() const { uint32_t Symbol::getOutputSymbolIndex() const {
return OutputSymbolIndex.getValue(); return OutputSymbolIndex.getValue();
} }
void Symbol::setVirtualAddress(uint32_t Value) { void Symbol::setVirtualAddress(uint32_t Value) {
DEBUG(dbgs() << "setVirtualAddress " << Name << " -> " << Value << "\n"); DEBUG(dbgs() << "setVirtualAddress " << Name << " -> " << Value << "\n");
assert(isGlobal()); assert(isData());
VirtualAddress = Value; VirtualAddress = Value;
} }
void Symbol::setOutputIndex(uint32_t Index) { void Symbol::setOutputIndex(uint32_t Index) {
DEBUG(dbgs() << "setOutputIndex " << Name << " -> " << Index << "\n"); DEBUG(dbgs() << "setOutputIndex " << Name << " -> " << Index << "\n");
assert(!dyn_cast_or_null<InputFunction>(Chunk)); assert(!Chunk);
assert(!OutputIndex.hasValue()); assert(!OutputIndex.hasValue());
OutputIndex = Index; OutputIndex = Index;
} }
void Symbol::setOutputSymbolIndex(uint32_t Index) { void Symbol::setOutputSymbolIndex(uint32_t Index) {
DEBUG(dbgs() << "setOutputSymbolIndex " << Name << " -> " << Index << "\n"); DEBUG(dbgs() << "setOutputSymbolIndex " << Name << " -> " << Index << "\n");
assert(!OutputSymbolIndex.hasValue()); assert(!OutputSymbolIndex.hasValue());
OutputSymbolIndex = Index; OutputSymbolIndex = Index;
Show All 20 Lines if (auto *F = dyn_cast_or_null<InputFunction>(Chunk)) {
return; return;
} }
DEBUG(dbgs() << "setTableIndex " << Name << " -> " << Index << "\n"); DEBUG(dbgs() << "setTableIndex " << Name << " -> " << Index << "\n");
assert(!TableIndex.hasValue()); assert(!TableIndex.hasValue());
TableIndex = Index; TableIndex = Index;
} }
void Symbol::update(Kind K, InputFile *F, uint32_t Flags_, InputChunk *Chunk_, void Symbol::update(Kind K, InputFile *F, uint32_t Flags_, InputChunk *Chunk_,
uint32_t Address) { uint32_t Address, uint32_t Size) {
SymbolKind = K; SymbolKind = K;
File = F; File = F;
Flags = Flags_; Flags = Flags_;
Chunk = Chunk_; Chunk = Chunk_;
if (Address != UINT32_MAX) if (Address != UINT32_MAX) {
setVirtualAddress(Address); setVirtualAddress(Address);
VirtualSize = Size;
}
} }
bool Symbol::isWeak() const { bool Symbol::isWeak() const {
return (Flags & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_WEAK; return (Flags & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_WEAK;
} }
bool Symbol::isLocal() const { bool Symbol::isLocal() const {
return (Flags & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_LOCAL; return (Flags & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_LOCAL;
Show All 18 Lines if (Optional<std::string> S = demangleItanium(Sym.getName()))
return "`" + *S + "'"; return "`" + *S + "'";
return Sym.getName(); return Sym.getName();
} }
std::string lld::toString(wasm::Symbol::Kind Kind) { std::string lld::toString(wasm::Symbol::Kind Kind) {
switch (Kind) { switch (Kind) {
case wasm::Symbol::DefinedFunctionKind: case wasm::Symbol::DefinedFunctionKind:
return "DefinedFunction"; return "DefinedFunction";
case wasm::Symbol::DefinedDataKind:
return "DefinedData";
case wasm::Symbol::DefinedGlobalKind: case wasm::Symbol::DefinedGlobalKind:
return "DefinedGlobal"; return "DefinedGlobal";
case wasm::Symbol::UndefinedFunctionKind: case wasm::Symbol::UndefinedFunctionKind:
return "UndefinedFunction"; return "UndefinedFunction";
case wasm::Symbol::UndefinedDataKind:
return "UndefinedData";
case wasm::Symbol::UndefinedGlobalKind: case wasm::Symbol::UndefinedGlobalKind:
return "UndefinedGlobal"; return "UndefinedGlobal";
case wasm::Symbol::LazyKind: case wasm::Symbol::LazyKind:
return "LazyKind"; return "LazyKind";
} }
llvm_unreachable("Invalid symbol kind!"); llvm_unreachable("Invalid symbol kind!");
} }
std::string lld::toString(WasmSymbol::SymbolType Type) {
switch (Type) {
case WasmSymbol::SymbolType::FUNCTION:
return "Function";
case WasmSymbol::SymbolType::DATA:
return "Data";
case WasmSymbol::SymbolType::GLOBAL:
return "Global";
}
llvm_unreachable("Invalid symbol type");
}
WasmSymbol::SymbolType lld::toWasmType(wasm::Symbol::Kind Kind) {
switch (Kind) {
case wasm::Symbol::DefinedFunctionKind:
case wasm::Symbol::UndefinedFunctionKind:
return WasmSymbol::SymbolType::FUNCTION;
case wasm::Symbol::DefinedDataKind:
case wasm::Symbol::UndefinedDataKind:
return WasmSymbol::SymbolType::DATA;
case wasm::Symbol::DefinedGlobalKind:
case wasm::Symbol::UndefinedGlobalKind:
return WasmSymbol::SymbolType::GLOBAL;
default:
llvm_unreachable("kind with no type");
break;
}
return static_cast<WasmSymbol::SymbolType>(-1);
}

wasm/Writer.cpp

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines for (int32_t Param : Sig.ParamTypes)
Value += DenseMapInfo<int32_t>::getHashValue(Param); Value += DenseMapInfo<int32_t>::getHashValue(Param);
return Value; return Value;
} }
static bool isEqual(const WasmSignature &LHS, const WasmSignature &RHS) { static bool isEqual(const WasmSignature &LHS, const WasmSignature &RHS) {
return LHS == RHS; return LHS == RHS;
} }
}; };
// A Wasm export to be written into the export section. // An init entry to be written to either the synthetic init func or the
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
// linking metadata. // linking metadata.
struct WasmInitEntry { struct WasmInitEntry {
const Symbol *Sym; const Symbol *Sym;
uint32_t Priority; uint32_t Priority;
}; };
// The writer writes a SymbolTable result to a file. // The writer writes a SymbolTable result to a file.
class Writer { class Writer {
public: public:
void run(); void run();
private: private:
void openFile(); void openFile();
uint32_t lookupType(const WasmSignature &Sig); uint32_t lookupType(const WasmSignature &Sig);
uint32_t registerType(const WasmSignature &Sig); uint32_t registerType(const WasmSignature &Sig);
void createCtorFunction(); void createCtorFunction();
void calculateInitFunctions(); void calculateInitFunctions();
void assignIndexes(); void assignIndexes();
void calculateImports(); void calculateImports();
void calculateExports(); void calculateExports();
void assignSymtab();
void calculateTypes(); void calculateTypes();
void createOutputSegments(); void createOutputSegments();
void layoutMemory(); void layoutMemory();
void createHeader(); void createHeader();
void createSections(); void createSections();
SyntheticSection *createSyntheticSection(uint32_t Type, SyntheticSection *createSyntheticSection(uint32_t Type,
StringRef Name = ""); StringRef Name = "");
Show All 22 Linesprivate:
uint32_t DataSize = 0; uint32_t DataSize = 0;
uint32_t NumMemoryPages = 0; uint32_t NumMemoryPages = 0;
std::vector<const WasmSignature *> Types; std::vector<const WasmSignature *> Types;
DenseMap<WasmSignature, int32_t, WasmSignatureDenseMapInfo> TypeIndices; DenseMap<WasmSignature, int32_t, WasmSignatureDenseMapInfo> TypeIndices;
std::vector<const Symbol *> ImportedSymbols; std::vector<const Symbol *> ImportedSymbols;
unsigned NumImportedFunctions = 0; unsigned NumImportedFunctions = 0;
unsigned NumImportedGlobals = 0; unsigned NumImportedGlobals = 0;
std::vector<WasmExportEntry> ExportedSymbols; std::vector<Symbol *> ExportedSymbols;
std::vector<Symbol *> DefinedGlobals; std::vector<InputGlobal *> DefinedGlobals;
std::vector<InputFunction *> DefinedFunctions; std::vector<InputFunction *> DefinedFunctions;
std::vector<const Symbol *> IndirectFunctions; std::vector<const Symbol *> IndirectFunctions;
std::vector<const Symbol *> SymtabEntries;
std::vector<WasmInitEntry> InitFunctions; std::vector<WasmInitEntry> InitFunctions;
// Elements that are used to construct the final output // Elements that are used to construct the final output
std::string Header; std::string Header;
std::vector<OutputSection *> OutputSections; std::vector<OutputSection *> OutputSections;
std::unique_ptr<FileOutputBuffer> Buffer; std::unique_ptr<FileOutputBuffer> Buffer;
std::unique_ptr<SyntheticFunction> CtorFunction; std::unique_ptr<SyntheticFunction> CtorFunction;
std::string CtorFunctionBody; std::string CtorFunctionBody;
std::unique_ptr<SyntheticGlobal> StackPtrGlobal;
std::vector<OutputSegment *> Segments; std::vector<OutputSegment *> Segments;
llvm::SmallDenseMap<StringRef, OutputSegment *> SegmentMap; llvm::SmallDenseMap<StringRef, OutputSegment *> SegmentMap;
}; };
} // anonymous namespace } // anonymous namespace
static void debugPrint(const char *fmt, ...) { static void debugPrint(const char *fmt, ...) {
Show All 31 Linesvoid Writer::createImportSection() {
for (const Symbol *Sym : ImportedSymbols) { for (const Symbol *Sym : ImportedSymbols) {
WasmImport Import; WasmImport Import;
Import.Module = "env"; Import.Module = "env";
Import.Field = Sym->getName(); Import.Field = Sym->getName();
if (Sym->isFunction()) { if (Sym->isFunction()) {
Import.Kind = WASM_EXTERNAL_FUNCTION; Import.Kind = WASM_EXTERNAL_FUNCTION;
Import.SigIndex = lookupType(Sym->getFunctionType()); Import.SigIndex = lookupType(Sym->getFunctionType());
} else { } else if (Sym->isGlobal()) {
Import.Kind = WASM_EXTERNAL_GLOBAL; Import.Kind = WASM_EXTERNAL_GLOBAL;
Import.Global.Mutable = false; Import.Global = Sym->getGlobalType();
Import.Global.Type = WASM_TYPE_I32; } else {
llvm_unreachable("invalid import type");
} }
writeImport(OS, Import); writeImport(OS, Import);
} }
} }
void Writer::createTypeSection() { void Writer::createTypeSection() {
SyntheticSection *Section = createSyntheticSection(WASM_SEC_TYPE); SyntheticSection *Section = createSyntheticSection(WASM_SEC_TYPE);
raw_ostream &OS = Section->getStream(); raw_ostream &OS = Section->getStream();
Show All 29 Lines
void Writer::createGlobalSection() { void Writer::createGlobalSection() {
if (DefinedGlobals.empty()) if (DefinedGlobals.empty())
return; return;
SyntheticSection *Section = createSyntheticSection(WASM_SEC_GLOBAL); SyntheticSection *Section = createSyntheticSection(WASM_SEC_GLOBAL);
raw_ostream &OS = Section->getStream(); raw_ostream &OS = Section->getStream();
writeUleb128(OS, DefinedGlobals.size(), "global count"); writeUleb128(OS, DefinedGlobals.size(), "global count");
for (const Symbol *Sym : DefinedGlobals) { for (const InputGlobal *G : DefinedGlobals) {
WasmGlobal Global; WasmGlobal Global;
Global.Type.Type = WASM_TYPE_I32; Global.Type = G->Signature;
Global.Type.Mutable = Sym == Config->StackPointerSymbol; Global.InitExpr = G->initExpr();
Global.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
Global.InitExpr.Value.Int32 = Sym->getVirtualAddress();
writeGlobal(OS, Global); writeGlobal(OS, Global);
} }
} }
void Writer::createTableSection() { void Writer::createTableSection() {
// Always output a table section, even if there are no indirect calls. // Always output a table section, even if there are no indirect calls.
// There are two reasons for this: // There are two reasons for this:
// 1. For executables it is useful to have an empty table slot at 0 // 1. For executables it is useful to have an empty table slot at 0
Show All 29 Linesvoid Writer::createExportSection() {
if (ExportMemory) { if (ExportMemory) {
WasmExport MemoryExport; WasmExport MemoryExport;
MemoryExport.Name = "memory"; MemoryExport.Name = "memory";
MemoryExport.Kind = WASM_EXTERNAL_MEMORY; MemoryExport.Kind = WASM_EXTERNAL_MEMORY;
MemoryExport.Index = 0; MemoryExport.Index = 0;
writeExport(OS, MemoryExport); writeExport(OS, MemoryExport);
} }
for (const WasmExportEntry &E : ExportedSymbols) { for (const Symbol *Sym : ExportedSymbols) {
DEBUG(dbgs() << "Export: " << E.Sym->getName() << "\n"); DEBUG(dbgs() << "Export: " << Sym->getName() << "\n");
WasmExport Export; WasmExport Export;
Export.Name = E.FieldName; Export.Name = Sym->getName();
Export.Index = E.Sym->getOutputIndex(); Export.Index = Sym->getOutputIndex();
if (E.Sym->isFunction()) if (Sym->isFunction())
Export.Kind = WASM_EXTERNAL_FUNCTION; Export.Kind = WASM_EXTERNAL_FUNCTION;
else else if (Sym->isGlobal())
Export.Kind = WASM_EXTERNAL_GLOBAL; Export.Kind = WASM_EXTERNAL_GLOBAL;
else
llvm_unreachable("invalid export kind");
writeExport(OS, Export); writeExport(OS, Export);
} }
} }
void Writer::createStartSection() {} void Writer::createStartSection() {}
void Writer::createElemSection() { void Writer::createElemSection() {
if (IndirectFunctions.empty()) if (IndirectFunctions.empty())
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Linesvoid Writer::createLinkingSection() {
SubSection DataSizeSubSection(WASM_DATA_SIZE); SubSection DataSizeSubSection(WASM_DATA_SIZE);
writeUleb128(DataSizeSubSection.getStream(), DataSize, "data size"); writeUleb128(DataSizeSubSection.getStream(), DataSize, "data size");
DataSizeSubSection.finalizeContents(); DataSizeSubSection.finalizeContents();
DataSizeSubSection.writeToStream(OS); DataSizeSubSection.writeToStream(OS);
if (!Config->Relocatable) if (!Config->Relocatable)
return; return;
std::vector<std::pair<StringRef, uint32_t>> SymbolInfo; if (!SymtabEntries.empty()) {
auto addSymInfo = [&](const Symbol *Sym, StringRef ExternalName) { 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_SYMTAB_FUNCTION :
Sym->isGlobal() ? llvm::wasm::WASM_SYMTAB_GLOBAL
: llvm::wasm::WASM_SYMTAB_DATA;
uint32_t Flags = uint32_t Flags =
(Sym->isLocal() ? WASM_SYMBOL_BINDING_LOCAL : (Sym->isLocal() ? WASM_SYMBOL_BINDING_LOCAL :
Sym->isWeak() ? WASM_SYMBOL_BINDING_WEAK : 0) | Sym->isWeak() ? WASM_SYMBOL_BINDING_WEAK : 0) |
(Sym->isHidden() ? WASM_SYMBOL_VISIBILITY_HIDDEN : 0); (Sym->isHidden() ? WASM_SYMBOL_VISIBILITY_HIDDEN : 0);
if (Flags) writeUleb128(SubSection.getStream(), Kind, "sym kind");
SymbolInfo.emplace_back(ExternalName, Flags); writeUleb128(SubSection.getStream(), Flags, "sym flags");
}; switch (Kind) {
// (Imports can't have internal linkage, their names don't need to be budged.) case llvm::wasm::WASM_SYMTAB_FUNCTION:
for (const Symbol *Sym : ImportedSymbols) case llvm::wasm::WASM_SYMTAB_GLOBAL:
addSymInfo(Sym, Sym->getName()); writeUleb128(SubSection.getStream(), Sym->getOutputIndex(),
for (const WasmExportEntry &E : ExportedSymbols) "index");
addSymInfo(E.Sym, E.FieldName); if (Sym->isDefined())
if (!SymbolInfo.empty()) { writeStr(SubSection.getStream(), Sym->getName(), "sym name");
SubSection SubSection(WASM_SYMBOL_INFO); break;
writeUleb128(SubSection.getStream(), SymbolInfo.size(), "num sym info"); case llvm::wasm::WASM_SYMTAB_DATA:
for (auto Pair: SymbolInfo) { writeStr(SubSection.getStream(), Sym->getName(), "sym name");
writeStr(SubSection.getStream(), Pair.first, "sym name"); SubSection.getStream() << static_cast<uint8_t>(Sym->isDefined());
writeUleb128(SubSection.getStream(), Pair.second, "sym flags"); 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.finalizeContents();
SubSection.writeToStream(OS); SubSection.writeToStream(OS);
} }
if (Segments.size()) { if (Segments.size()) {
SubSection SubSection(WASM_SEGMENT_INFO); SubSection SubSection(WASM_SEGMENT_INFO);
writeUleb128(SubSection.getStream(), Segments.size(), "num data segments"); writeUleb128(SubSection.getStream(), Segments.size(), "num data segments");
▲ Show 20 Lines • Show All 131 Lines • ▼ Show 20 Linesvoid Writer::layoutMemory() {
// Stack comes after static data // Stack comes after static data
if (!Config->Relocatable) { if (!Config->Relocatable) {
MemoryPtr = alignTo(MemoryPtr, kStackAlignment); MemoryPtr = alignTo(MemoryPtr, kStackAlignment);
if (Config->ZStackSize != alignTo(Config->ZStackSize, kStackAlignment)) if (Config->ZStackSize != alignTo(Config->ZStackSize, kStackAlignment))
error("stack size must be " + Twine(kStackAlignment) + "-byte aligned"); error("stack size must be " + Twine(kStackAlignment) + "-byte aligned");
debugPrint("mem: stack size = %d\n", Config->ZStackSize); debugPrint("mem: stack size = %d\n", Config->ZStackSize);
debugPrint("mem: stack base = %d\n", MemoryPtr); debugPrint("mem: stack base = %d\n", MemoryPtr);
MemoryPtr += Config->ZStackSize; MemoryPtr += Config->ZStackSize;
Config->StackPointerSymbol->setVirtualAddress(MemoryPtr);
WasmInitExpr StackInit;
StackInit.Opcode = WASM_OPCODE_I32_CONST;
StackInit.Value.Int32 = MemoryPtr;
StackPtrGlobal.reset(new SyntheticGlobal(
Config->StackPointerSymbol->getGlobalType(), StackInit));
StackPtrGlobal->setOutputIndex(NumImportedGlobals + DefinedGlobals.size());
DefinedGlobals.emplace_back(StackPtrGlobal.get());
Config->StackPointerSymbol->updateChunk(StackPtrGlobal.get());
debugPrint("mem: stack top = %d\n", MemoryPtr); debugPrint("mem: stack top = %d\n", MemoryPtr);
// Set `__heap_base` to directly follow the end of the stack. We don't // 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 // allocate any heap memory up front, but instead really on the malloc/brk
// implementation growing the memory at runtime. // implementation growing the memory at runtime.
Config->HeapBaseSymbol->setVirtualAddress(MemoryPtr); Config->HeapBaseSymbol->setVirtualAddress(MemoryPtr);
debugPrint("mem: heap base = %d\n", MemoryPtr); debugPrint("mem: heap base = %d\n", MemoryPtr);
} }
uint32_t MemSize = alignTo(MemoryPtr, WasmPageSize); uint32_t MemSize = alignTo(MemoryPtr, WasmPageSize);
Show All 34 Lines for (OutputSection *S : OutputSections) {
S->setOffset(FileSize); S->setOffset(FileSize);
S->finalizeContents(); S->finalizeContents();
FileSize += S->getSize(); FileSize += S->getSize();
} }
} }
void Writer::calculateImports() { void Writer::calculateImports() {
for (Symbol *Sym : Symtab->getSymbols()) { for (Symbol *Sym : Symtab->getSymbols()) {
if (!Sym->isUndefined() || (Sym->isWeak() && !Config->Relocatable)) if (!Sym->isUndefined() || Sym->isData() ||
(Sym->isWeak() && !Config->Relocatable))
continue; continue;
Sym->setOutputIndex(ImportedSymbols.size()); Sym->setOutputIndex(ImportedSymbols.size());
Sym->setOutputSymbolIndex(ImportedSymbols.size());
ImportedSymbols.emplace_back(Sym); ImportedSymbols.emplace_back(Sym);
if (Sym->isFunction()) if (Sym->isFunction())
++NumImportedFunctions; ++NumImportedFunctions;
else else
++NumImportedGlobals; ++NumImportedGlobals;
} }
} }
void Writer::calculateExports() { void Writer::calculateExports() {
bool ExportHidden = Config->Relocatable; if (Config->Relocatable)
StringSet<> UsedNames; return;
auto BudgeLocalName = [&](const Symbol *Sym) {
StringRef SymName = Sym->getName(); auto ExportSym = [&](Symbol *Sym) {
// We can't budge non-local names. if (!Sym->isDefined() || Sym->isData())
if (!Sym->isLocal()) return;
return SymName; if (Sym->isHidden() || Sym->isLocal())
// We must budge local names that have a collision with a symbol that we return;
// haven't yet processed. if (Sym->getChunk()->Discarded)
if (!Symtab->find(SymName) && UsedNames.insert(SymName).second) return;
return SymName; // We should never be exporting a non-live symbol
for (unsigned I = 1; ; ++I) { assert(Sym->getChunk()->Live);
std::string NameBuf = (SymName + "." + Twine(I)).str(); ExportedSymbols.emplace_back(Sym);
if (!UsedNames.count(NameBuf)) {
StringRef Name = Saver.save(NameBuf);
UsedNames.insert(Name); // Insert must use safe StringRef from save()
return Name;
}
}
}; };
unsigned SymbolIndex = ImportedSymbols.size(); // TODO The two loops below should be replaced with this single loop, with
if (Config->CtorSymbol && (!Config->CtorSymbol->isHidden() || ExportHidden)) { // ExportSym inlined:
Config->CtorSymbol->setOutputSymbolIndex(SymbolIndex++); // for (Symbol *Sym : Symtab->getSymbols())
ExportedSymbols.emplace_back( // ExportSym(Sym);
WasmExportEntry{Config->CtorSymbol, Config->CtorSymbol->getName()}); // 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;
unsigned SymbolIndex = SymtabEntries.size();
for (ObjFile *File : Symtab->ObjectFiles) { for (ObjFile* File : Symtab->ObjectFiles) {
DEBUG(dbgs() << "Symtab entries: " << File->getName() << "\n");
for (Symbol *Sym : File->getSymbols()) { for (Symbol *Sym : File->getSymbols()) {
if (!Sym->isDefined() || File != Sym->getFile()) if (Sym->getFile() != File)
continue;
if (Sym->isGlobal())
continue; continue;
if (Sym->isDefined()) {
if (Sym->getChunk()->Discarded) if (Sym->getChunk()->Discarded)
continue; continue;
} else {
if ((Sym->isHidden() || Sym->isLocal()) && !ExportHidden) assert(Sym->isUndefined()); // Can't be lazy
continue; }
// We should never be exporting a non-live symbol
assert(Sym->getChunk()->Live);
Sym->setOutputSymbolIndex(SymbolIndex++); Sym->setOutputSymbolIndex(SymbolIndex++);
ExportedSymbols.emplace_back(WasmExportEntry{Sym, BudgeLocalName(Sym)}); SymtabEntries.emplace_back(Sym);
} }
} }
for (Symbol *Sym : DefinedGlobals) { // For the moment, relocatable output doesn't contain any synthetic functions,
// Can't export the SP right now because its mutable, and mutuable globals // so no need to look through the Symtab for symbols not referenced by
// are yet supported in the official binary format. // Symtab->ObjectFiles.
// TODO(sbc): Remove this if/when the "mutable global" proposal is accepted.
if (Sym == Config->StackPointerSymbol)
continue;
Sym->setOutputSymbolIndex(SymbolIndex++);
ExportedSymbols.emplace_back(WasmExportEntry{Sym, BudgeLocalName(Sym)});
}
} }
uint32_t Writer::lookupType(const WasmSignature &Sig) { uint32_t Writer::lookupType(const WasmSignature &Sig) {
auto It = TypeIndices.find(Sig); auto It = TypeIndices.find(Sig);
if (It == TypeIndices.end()) { if (It == TypeIndices.end()) {
error("type not found: " + toString(Sig)); error("type not found: " + toString(Sig));
return 0; return 0;
} }
Show All 18 Linesvoid Writer::calculateTypes() {
for (Symbol *Sym : Symtab->getSymbols()) for (Symbol *Sym : Symtab->getSymbols())
if (Sym->isFunction()) if (Sym->isFunction())
registerType(Sym->getFunctionType()); registerType(Sym->getFunctionType());
} }
void Writer::assignIndexes() { void Writer::assignIndexes() {
uint32_t GlobalIndex = NumImportedGlobals + DefinedGlobals.size(); uint32_t GlobalIndex = NumImportedGlobals + DefinedGlobals.size();
uint32_t FunctionIndex = NumImportedFunctions + DefinedFunctions.size();
if (Config->StackPointerSymbol) {
DefinedGlobals.emplace_back(Config->StackPointerSymbol);
Config->StackPointerSymbol->setOutputIndex(GlobalIndex++);
}
if (Config->HeapBaseSymbol) {
DefinedGlobals.emplace_back(Config->HeapBaseSymbol);
Config->HeapBaseSymbol->setOutputIndex(GlobalIndex++);
}
if (Config->Relocatable)
DefinedGlobals.reserve(Symtab->getSymbols().size());
uint32_t TableIndex = kInitialTableOffset;
for (ObjFile *File : Symtab->ObjectFiles) { for (ObjFile *File : Symtab->ObjectFiles) {
if (Config->Relocatable) {
DEBUG(dbgs() << "Globals: " << File->getName() << "\n"); DEBUG(dbgs() << "Globals: " << File->getName() << "\n");
for (Symbol *Sym : File->getSymbols()) { for (InputGlobal *Global : File->Globals) {
// Create wasm globals for data symbols defined in this file if (Global->Discarded || !Global->Live)
if (!Sym->isDefined() || File != Sym->getFile())
continue;
if (Sym->isFunction())
continue; continue;
DefinedGlobals.emplace_back(Global);
DefinedGlobals.emplace_back(Sym); Global->setOutputIndex(GlobalIndex++);
Sym->setOutputIndex(GlobalIndex++);
}
} }
} }
uint32_t FunctionIndex = NumImportedFunctions + DefinedFunctions.size();
for (ObjFile *File : Symtab->ObjectFiles) { for (ObjFile *File : Symtab->ObjectFiles) {
DEBUG(dbgs() << "Functions: " << File->getName() << "\n"); DEBUG(dbgs() << "Functions: " << File->getName() << "\n");
for (InputFunction *Func : File->Functions) { for (InputFunction *Func : File->Functions) {
if (Func->Discarded || !Func->Live) if (Func->Discarded || !Func->Live)
continue; continue;
DefinedFunctions.emplace_back(Func); DefinedFunctions.emplace_back(Func);
Func->setOutputIndex(FunctionIndex++); Func->setOutputIndex(FunctionIndex++);
} }
} }
uint32_t TableIndex = kInitialTableOffset;
for (ObjFile *File : Symtab->ObjectFiles) { for (ObjFile *File : Symtab->ObjectFiles) {
DEBUG(dbgs() << "Table Indexes: " << File->getName() << "\n"); DEBUG(dbgs() << "Table Indexes: " << File->getName() << "\n");
auto HandleTableRelocs = [&](InputChunk *Chunk) { auto HandleTableRelocs = [&](InputChunk *Chunk) {
if (Chunk->Discarded) if (Chunk->Discarded)
return; return;
for (const WasmRelocation& Reloc : Chunk->getRelocations()) { for (const WasmRelocation& Reloc : Chunk->getRelocations()) {
if (Reloc.Type != R_WEBASSEMBLY_TABLE_INDEX_I32 && if (Reloc.Type != R_WEBASSEMBLY_TABLE_INDEX_I32 &&
Reloc.Type != R_WEBASSEMBLY_TABLE_INDEX_SLEB) Reloc.Type != R_WEBASSEMBLY_TABLE_INDEX_SLEB)
Show All 32 Linesvoid Writer::createOutputSegments() {
for (ObjFile *File : Symtab->ObjectFiles) { for (ObjFile *File : Symtab->ObjectFiles) {
for (InputSegment *Segment : File->Segments) { for (InputSegment *Segment : File->Segments) {
if (Segment->Discarded || !Segment->Live) if (Segment->Discarded || !Segment->Live)
continue; continue;
StringRef Name = getOutputDataSegmentName(Segment->getName()); StringRef Name = getOutputDataSegmentName(Segment->getName());
OutputSegment *&S = SegmentMap[Name]; OutputSegment *&S = SegmentMap[Name];
if (S == nullptr) { if (S == nullptr) {
DEBUG(dbgs() << "new segment: " << Name << "\n"); DEBUG(dbgs() << "new segment: " << Name << "\n");
S = make<OutputSegment>(Name); S = make<OutputSegment>(Name, Segments.size());
Segments.push_back(S); Segments.push_back(S);
} }
S->addInputSegment(Segment); S->addInputSegment(Segment);
DEBUG(dbgs() << "added data: " << Name << ": " << S->Size << "\n"); DEBUG(dbgs() << "added data: " << Name << ": " << S->Size << "\n");
} }
} }
} }
Show All 25 Linesvoid Writer::createCtorFunction() {
OS.flush(); OS.flush();
CtorFunctionBody += FunctionBody; CtorFunctionBody += FunctionBody;
ArrayRef<uint8_t> BodyArray( ArrayRef<uint8_t> BodyArray(
reinterpret_cast<const uint8_t *>(CtorFunctionBody.data()), reinterpret_cast<const uint8_t *>(CtorFunctionBody.data()),
CtorFunctionBody.size()); CtorFunctionBody.size());
CtorFunction = llvm::make_unique<SyntheticFunction>( CtorFunction = llvm::make_unique<SyntheticFunction>(
Signature, BodyArray, Config->CtorSymbol->getName()); Signature, BodyArray, Config->CtorSymbol->getName());
CtorFunction->setOutputIndex(FunctionIndex); CtorFunction->setOutputIndex(FunctionIndex);
Config->CtorSymbol->updateChunk(CtorFunction.get());
DefinedFunctions.emplace_back(CtorFunction.get()); DefinedFunctions.emplace_back(CtorFunction.get());
} }
// Populate InitFunctions vector with init functions from all input objects. // Populate InitFunctions vector with init functions from all input objects.
// This is then used either when creating the output linking section or to // This is then used either when creating the output linking section or to
// synthesize the "__wasm_call_ctors" function. // synthesize the "__wasm_call_ctors" function.
void Writer::calculateInitFunctions() { void Writer::calculateInitFunctions() {
for (ObjFile *File : Symtab->ObjectFiles) { for (ObjFile *File : Symtab->ObjectFiles) {
Show All 13 Lines
void Writer::run() { void Writer::run() {
log("-- calculateTypes"); log("-- calculateTypes");
calculateTypes(); calculateTypes();
log("-- calculateImports"); log("-- calculateImports");
calculateImports(); calculateImports();
log("-- assignIndexes"); log("-- assignIndexes");
assignIndexes(); assignIndexes();
log("-- calculateExports");
calculateExports();
log("-- calculateInitFunctions"); log("-- calculateInitFunctions");
calculateInitFunctions(); calculateInitFunctions();
if (!Config->Relocatable) if (!Config->Relocatable)
createCtorFunction(); createCtorFunction();
log("-- layoutMemory");
layoutMemory();
log("-- calculateExports");
calculateExports();
log("-- assignSymtab");
assignSymtab();
if (errorHandler().Verbose) { if (errorHandler().Verbose) {
log("Defined Functions: " + Twine(DefinedFunctions.size())); log("Defined Functions: " + Twine(DefinedFunctions.size()));
log("Defined Globals : " + Twine(DefinedGlobals.size())); log("Defined Globals : " + Twine(DefinedGlobals.size()));
log("Function Imports : " + Twine(NumImportedFunctions)); log("Function Imports : " + Twine(NumImportedFunctions));
log("Global Imports : " + Twine(NumImportedGlobals)); log("Global Imports : " + Twine(NumImportedGlobals));
for (ObjFile *File : Symtab->ObjectFiles) for (ObjFile *File : Symtab->ObjectFiles)
File->dumpInfo(); File->dumpInfo();
} }
log("-- layoutMemory");
layoutMemory();
createHeader(); createHeader();
log("-- createSections"); log("-- createSections");
createSections(); createSections();
log("-- openFile"); log("-- openFile");
openFile(); openFile();
if (errorCount()) if (errorCount())
return; return;
Show All 37 Lines

wasm/WriterUtils.h

Show All 21 Linesinline bool operator==(const llvm::wasm::WasmSignature &LHS,
return LHS.ReturnType == RHS.ReturnType && LHS.ParamTypes == RHS.ParamTypes; return LHS.ReturnType == RHS.ReturnType && LHS.ParamTypes == RHS.ParamTypes;
} }
inline bool operator!=(const llvm::wasm::WasmSignature &LHS, inline bool operator!=(const llvm::wasm::WasmSignature &LHS,
const llvm::wasm::WasmSignature &RHS) { const llvm::wasm::WasmSignature &RHS) {
return !(LHS == 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 lld {
namespace wasm { namespace wasm {
struct OutputRelocation { struct OutputRelocation {
llvm::wasm::WasmRelocation Reloc; llvm::wasm::WasmRelocation Reloc;
uint32_t NewIndex; uint32_t NewIndex;
uint32_t Value; uint32_t Value;
}; };
Show All 31 Lines
void writeExport(raw_ostream &OS, const llvm::wasm::WasmExport &Export); void writeExport(raw_ostream &OS, const llvm::wasm::WasmExport &Export);
void writeReloc(raw_ostream &OS, const OutputRelocation &Reloc); void writeReloc(raw_ostream &OS, const OutputRelocation &Reloc);
} // namespace wasm } // namespace wasm
std::string toString(const llvm::wasm::ValType Type); std::string toString(const llvm::wasm::ValType Type);
std::string toString(const llvm::wasm::WasmSignature &Sig); std::string toString(const llvm::wasm::WasmSignature &Sig);
std::string toString(const llvm::wasm::WasmGlobalType &Sig);
} // namespace lld } // namespace lld
#endif // LLD_WASM_WRITERUTILS_H #endif // LLD_WASM_WRITERUTILS_H

wasm/WriterUtils.cpp

Show First 20 Lines • Show All 210 Lines • ▼ Show 20 Linesstd::string lld::toString(const WasmSignature &Sig) {
} }
S += ") -> "; S += ") -> ";
if (Sig.ReturnType == WASM_TYPE_NORESULT) if (Sig.ReturnType == WASM_TYPE_NORESULT)
S += "void"; S += "void";
else else
S += toString(static_cast<ValType>(Sig.ReturnType)); S += toString(static_cast<ValType>(Sig.ReturnType));
return S.str(); 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();
}