This is an archive of the discontinued LLVM Phabricator instance.

Differential D42105

[WebAssembly] Symbol changes #4: export relocatable, LLD only
ClosedPublic

Authored by ncw on Jan 16 2018, 7:08 AM.

Details

Reviewers
sbc100
sunfish
Commits
rGd3052d552262: [WebAssembly] Add missing function exports and SYM_INFO to --relocatable output
rLLD322908: [WebAssembly] Add missing function exports and SYM_INFO to --relocatable output
rL322908: [WebAssembly] Add missing function exports and SYM_INFO to --relocatable output
Summary

Fourth chunk split out of D41955.

There is no corresponding LLVM patch to go along with this.

Headline: Fix some bugs in the existing handling of exports when LLD generates "relocatable" output

Changes:

  • LLD's relocatable output was writing out an export for all globals (including file-local syms), but not for functions. Oops. To be consistent with non-relocatable output, all symbols (file-local and public) should be exported. Any symbol targetted by further relocations needs to be exported. The lack of local function exports was just an omission, I think.
  • Second bug: Local symbol names can collide, causing an illegal Wasm file to be generated! Oops again. This only previously affected producing relocatable output from two files, where each had a global with the same name. We need to "budge" the symbol names for locals that are exported on relocatable output.
  • Third bug: LLD's relocatable output wasn't writing out any symbol flags! Thus the local globals weren't being marked as local, and the hidden flag was also stripped...
  • Added tests to exercise colliding local names with/without relocatable flag

Diff Detail

Repository
rL LLVM

Event Timeline

ncw created this revision.Jan 16 2018, 7:08 AM
Herald added subscribers: llvm-commits, aheejin, jgravelle-google and 2 others. · View Herald TranscriptJan 16 2018, 7:09 AM
ncw updated this revision to Diff 129956.Jan 16 2018, 7:18 AM
ncw edited the summary of this revision. (Show Details)

Updated: Fix mistake not exporting weak flag

test/wasm/call-indirect.ll
90 ↗(On Diff #129952)

Test expectations updated: some benign reordering of the imports, due to iterating over Symbols in order of definition, rather than in order of first use

test/wasm/init-fini.ll
146 ↗(On Diff #129952)

Test expectation updated: HIDDEN/LOCAL flag should be written out for LLD's relocatable output

ncw updated this revision to Diff 129974.Jan 16 2018, 9:21 AM

Updated: tiny tweak to calculateImports to fix up case of unresolved weak globals

ncw mentioned this in D41955: [WebAssembly] Add symbol table to LLD, 1/2.Jan 16 2018, 9:49 AM
ncw added inline comments.Jan 17 2018, 7:25 AM
wasm/Writer.cpp
602 ↗(On Diff #129974)

I realise that std::set<std::string> isn't very idiomatic in LLVM, but you can why I chose it. I couldn't think of another way of doing it though that didn't require more code doing explicit buffer management.

Suggestions welcome - otherwise it's hopefully "good enough" for now, especially as it's short-lived and only used for exported functions (which I'd expect to be a small number compared to the overall output size).

ncw updated this revision to Diff 130184.Jan 17 2018, 7:39 AM

Updated:

  • Fixed test after rebase on top of __heap_base change
sbc100 accepted this revision.Jan 17 2018, 12:40 PM

Just a couple of minor nits

test/wasm/Inputs/locals-duplicate1.ll
1 ↗(On Diff #130184)

Are there llvm terms you can use here rather than local and public? I think llvm this internal and external linkage, right?

test/wasm/locals-duplicate.test
1 ↗(On Diff #130184)

Can we give these new files better names? Perhaps duplicate-symbols-internal.test. Locals makes me think of wasm locals, and llvm doesn't use the term local for these symbols either (I think?).

wasm/Writer.cpp
602 ↗(On Diff #129974)

I think llvm::DenseSet<StringRef> is used elsewhere in lld and probably makes sense here. Or llvm::StringSet? I'm not sure what the tradeoffs are between those two.

This revision is now accepted and ready to land.Jan 17 2018, 12:40 PM
ncw added inline comments.Jan 17 2018, 2:37 PM
test/wasm/Inputs/locals-duplicate1.ll
1 ↗(On Diff #130184)

Yes, you're right, maybe those are better terms. "XXX_LOCAL" is the name of the flag in the MC source code corresponding to the IR keyword "internal". "public" is because I couldn't think of the correct opposite!

test/wasm/locals-duplicate.test
1 ↗(On Diff #130184)

Well in LLD we have Symbol::isLocal. The name you suggested is better though.

wasm/Writer.cpp
602 ↗(On Diff #129974)

DenseSet<StringRef> and StringSet both assume that the string itself is owned externally. But the "budged" names can't be stored just as a StringRef, something needs to actually own the buffer to the string itself, hence using std::string. And you can't use a StringRef to refer to things in a vector<std::string> either (can you?) because you have to careful mutating the vector not to reallocate the strings and invalidate any StringRefs (I suppose we can rely on move ctors these days).

Nuisance. I don't suppose it's good style to use make<std::string> or similar magic to allocate strings?

I could maybe see about doing some more explicit buffer management to allow use of an llvm::StringSet.

sbc100 added inline comments.Jan 17 2018, 2:51 PM
test/wasm/locals-duplicate.test
1 ↗(On Diff #130184)

Hmm, you are right. Confusing different nomenclature. I think its because in ELF and Wasm binary format we use local and global. Given that I'm OK with the local and global here.. but maybe just replace public with global?

wasm/Writer.cpp
602 ↗(On Diff #129974)

In that case std::set seems reasonable to me.

ncw updated this revision to Diff 130391.Jan 18 2018, 3:49 AM
ncw marked 2 inline comments as done.

Updated:

  • Fixed terminology in comments
  • Use llvm::StringSaver to get rid of std::set<std::string> in favour of llvm::StringSet
wasm/Writer.cpp
602 ↗(On Diff #129974)

Aha! With some more searching, I've found the idiomatic LLVM solution.

It's called llvm::Saver, a global instance of llvm::StringSaver that lets you get a safe/stable StringRef for a fresh string.

Updated now to use that.

sbc100 added inline comments.Jan 18 2018, 3:11 PM
wasm/Writer.cpp
602 ↗(On Diff #129974)

Nice!

I'm not familiar with StringSaver, but would it make sense to use a saver that has the same lifetime as UsedNames? i.e. a function scoped saver?

sbc100 added inline comments.Jan 18 2018, 3:22 PM
wasm/Writer.cpp
600 ↗(On Diff #130391)

I think this is unrelated? At least all the tests still pass without this line.

sbc100 added inline comments.Jan 18 2018, 3:25 PM
wasm/Writer.cpp
390 ↗(On Diff #130391)

Don't we want to iterate through all symbols here, not just the exported ones? This can be a followup change I think.

Closed by commit rL322908: [WebAssembly] Add missing function exports and SYM_INFO to --relocatable output (authored by sbc). · Explain WhyJan 18 2018, 3:43 PM
This revision was automatically updated to reflect the committed changes.
inglorion added a subscriber: inglorion.Jan 18 2018, 7:13 PM
inglorion added inline comments.
lld/trunk/wasm/Writer.cpp
67

gcc seems unhappy with this declaration. It complains:

llvm/tools/lld/wasm/Writer.cpp:67:17: error: declaration of ‘const lld::wasm::Symbol* {anonymous}::WasmExportEntry::Symbol’ [-fpermissive]
   const Symbol *Symbol;
             ^
In file included from llvm/tools/lld/wasm/Config.h:17:0,
                 from llvm/tools/lld/wasm/Writer.cpp:13:
llvm/tools/lld/wasm/Symbols.h:27:7: error: changes meaning of ‘Symbol’ from ‘class lld::wasm::Symbol’ [-fpermissive]
 class Symbol {
       ^

I have put up D42278 to rename the field and stop the naming collision.

sbc100 added inline comments.Jan 18 2018, 7:31 PM
lld/trunk/wasm/Writer.cpp
67

Thanks! I already had a local version ready to go so I'll just push that if thats OK?

ncw added inline comments.Jan 19 2018, 3:06 AM
wasm/Writer.cpp
390 ↗(On Diff #130391)

Oh! For "defined" symbols, we can't iterate through the non-exported ones (any functions not exported don't correspond to a Symbol).

But yes, the imports need to be included too. Oops.

600 ↗(On Diff #130391)

It is needed eventually; Patch #5 will fail without it. This is similar to patch #4b (D42237). Maybe I split this badly and it should have gone in with that...

I'll pull this out into another patch.

602 ↗(On Diff #129974)

A function-scoped one wouldn't work. The StringSet<> UsedNames is function-local, but the StringRefs that are returned get put into the WasmExportEntrys in ExportedSymbols, so are used outside this function.

ncw mentioned this in D42305: [WebAssembly] Symbol changes #4c: import weak, LLD only.Jan 19 2018, 10:24 AM
ncw mentioned this in D42306: [WebAssembly] Symbol changes #4d: export import flags, LLD only.

Revision Contents

PathSize
lld/
trunk/
test/
wasm/
Inputs/
49 lines
49 lines
6 lines
39 lines
543 lines
15 lines
6 lines
wasm/
127 lines

Diff 130504

lld/trunk/test/wasm/Inputs/locals-duplicate1.ll

; Will collide: local (internal linkage) with global (external) linkage
@colliding_global1 = internal default global i32 0, align 4
; Will collide: global with local
@colliding_global2 = default global i32 0, align 4
; Will collide: local with local
@colliding_global3 = internal default global i32 0, align 4
; Will collide: local with global
define internal i32 @colliding_func1() {
entry:
ret i32 2
}
; Will collide: global with local
define i32 @colliding_func2() {
entry:
ret i32 2
}
; Will collide: local with local
define internal i32 @colliding_func3() {
entry:
ret i32 2
}
define i32* @get_global1A() {
entry:
ret i32* @colliding_global1
}
define i32* @get_global2A() {
entry:
ret i32* @colliding_global2
}
define i32* @get_global3A() {
entry:
ret i32* @colliding_global3
}
define i32 ()* @get_func1A() {
entry:
ret i32 ()* @colliding_func1
}
define i32 ()* @get_func2A() {
entry:
ret i32 ()* @colliding_func2
}
define i32 ()* @get_func3A() {
entry:
ret i32 ()* @colliding_func3
}

lld/trunk/test/wasm/Inputs/locals-duplicate2.ll

; Will collide: local (internal linkage) with global (external) linkage
@colliding_global1 = default global i32 0, align 4
; Will collide: global with local
@colliding_global2 = internal default global i32 0, align 4
; Will collide: local with local
@colliding_global3 = internal default global i32 0, align 4
; Will collide: local with global
define i32 @colliding_func1() {
entry:
ret i32 2
}
; Will collide: global with local
define internal i32 @colliding_func2() {
entry:
ret i32 2
}
; Will collide: local with local
define internal i32 @colliding_func3() {
entry:
ret i32 2
}
define i32* @get_global1B() {
entry:
ret i32* @colliding_global1
}
define i32* @get_global2B() {
entry:
ret i32* @colliding_global2
}
define i32* @get_global3B() {
entry:
ret i32* @colliding_global3
}
define i32 ()* @get_func1B() {
entry:
ret i32 ()* @colliding_func1
}
define i32 ()* @get_func2B() {
entry:
ret i32 ()* @colliding_func2
}
define i32 ()* @get_func3B() {
entry:
ret i32 ()* @colliding_func3
}

lld/trunk/test/wasm/call-indirect.ll

Show First 20 Lines • Show All 79 Lines • ▼ Show 20 Lines
; 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: 3 ; CHECK-NEXT: Index: 3
; CHECK-NEXT: - Name: foo
; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 2
; 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: Kind: FUNCTION
; CHECK-NEXT: Index: 2
; 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: - Name: __heap_base
; CHECK-NEXT: Kind: GLOBAL ; CHECK-NEXT: Kind: GLOBAL
; CHECK-NEXT: Index: 1 ; CHECK-NEXT: Index: 1
; CHECK-NEXT: - Type: ELEM ; CHECK-NEXT: - Type: ELEM
; CHECK-NEXT: Segments: ; CHECK-NEXT: Segments:
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 101 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: - Name: func1
; RELOC-NEXT: Flags: [ VISIBILITY_HIDDEN ]
; RELOC-NEXT: - Name: func2
; RELOC-NEXT: Flags: [ VISIBILITY_HIDDEN ]
; RELOC-NEXT: - Name: func3
; RELOC-NEXT: Flags: [ VISIBILITY_HIDDEN ]
; RELOC-NEXT: - Name: func4
; RELOC-NEXT: Flags: [ VISIBILITY_HIDDEN ]
; RELOC-NEXT: - Name: _start
; RELOC-NEXT: Flags: [ VISIBILITY_HIDDEN ]
; RELOC-NEXT: - Name: .Lcall_dtors.101
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: - Name: .Lregister_call_dtors.101
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: - Name: .Lbitcast
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: - Name: .Lcall_dtors.1001
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: - Name: .Lregister_call_dtors.1001
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: - Name: myctor
; RELOC-NEXT: Flags: [ VISIBILITY_HIDDEN ]
; RELOC-NEXT: - Name: mydtor
; RELOC-NEXT: Flags: [ VISIBILITY_HIDDEN ]
; RELOC-NEXT: - Name: .Lcall_dtors.101.1
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: - Name: .Lregister_call_dtors.101.1
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: - Name: .Lcall_dtors.202
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: - Name: .Lregister_call_dtors.202
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: - Name: .Lcall_dtors.2002
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: - Name: .Lregister_call_dtors.2002
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: InitFunctions: ; RELOC-NEXT: InitFunctions:
; RELOC-NEXT: - Priority: 101 ; RELOC-NEXT: - Priority: 101
; RELOC-NEXT: FunctionIndex: 0 ; RELOC-NEXT: FunctionIndex: 0
; RELOC-NEXT: - Priority: 101 ; RELOC-NEXT: - Priority: 101
; RELOC-NEXT: FunctionIndex: 1 ; RELOC-NEXT: FunctionIndex: 1
; RELOC-NEXT: - Priority: 101 ; RELOC-NEXT: - Priority: 101
; RELOC-NEXT: FunctionIndex: 7 ; RELOC-NEXT: FunctionIndex: 7
; RELOC-NEXT: - Priority: 101 ; RELOC-NEXT: - Priority: 101
; RELOC-NEXT: FunctionIndex: 11 ; RELOC-NEXT: FunctionIndex: 11
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

lld/trunk/test/wasm/locals-duplicate.test

; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %p/Inputs/locals-duplicate1.ll -o %t1.o
; RUN: llc -filetype=obj -mtriple=wasm32-unknown-unknown-wasm %p/Inputs/locals-duplicate2.ll -o %t2.o
; RUN: lld -flavor wasm --no-entry -o %t.wasm %t1.o %t2.o
; RUN: obj2yaml %t.wasm | FileCheck %s
; CHECK: --- !WASM
; CHECK-NEXT: FileHeader:
; CHECK-NEXT: Version: 0x00000001
; CHECK-NEXT: Sections:
; CHECK-NEXT: - Type: TYPE
; CHECK-NEXT: Signatures:
; CHECK-NEXT: - Index: 0
; CHECK-NEXT: ReturnType: I32
; CHECK-NEXT: ParamTypes:
; CHECK-NEXT: - Index: 1
; CHECK-NEXT: ReturnType: NORESULT
; CHECK-NEXT: ParamTypes:
; CHECK-NEXT: - Type: FUNCTION
; CHECK-NEXT: FunctionTypes: [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
; CHECK-NEXT: 0, 0, 1 ]
; CHECK-NEXT: - Type: TABLE
; CHECK-NEXT: Tables:
; CHECK-NEXT: - ElemType: ANYFUNC
; CHECK-NEXT: Limits:
; CHECK-NEXT: Flags: [ HAS_MAX ]
; CHECK-NEXT: Initial: 0x00000007
; CHECK-NEXT: Maximum: 0x00000007
; CHECK-NEXT: - Type: MEMORY
; CHECK-NEXT: Memories:
; CHECK-NEXT: - Initial: 0x00000002
; CHECK-NEXT: - Type: GLOBAL
; CHECK-NEXT: Globals:
; CHECK-NEXT: - Index: 0
; CHECK-NEXT: Type: I32
; CHECK-NEXT: Mutable: true
; CHECK-NEXT: InitExpr:
; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 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: Exports:
; CHECK-NEXT: - Name: memory
; CHECK-NEXT: Kind: MEMORY
; CHECK-NEXT: Index: 0
; CHECK-NEXT: - Name: colliding_func2
; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 1
; CHECK-NEXT: - Name: get_global1A
; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 3
; CHECK-NEXT: - Name: get_global2A
; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 4
; CHECK-NEXT: - Name: get_global3A
; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 5
; CHECK-NEXT: - Name: get_func1A
; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 6
; CHECK-NEXT: - Name: get_func2A
; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 7
; CHECK-NEXT: - Name: get_func3A
; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 8
; CHECK-NEXT: - Name: colliding_func1
; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 9
; CHECK-NEXT: - Name: get_global1B
; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 12
; CHECK-NEXT: - Name: get_global2B
; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 13
; CHECK-NEXT: - Name: get_global3B
; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 14
; CHECK-NEXT: - Name: get_func1B
; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 15
; CHECK-NEXT: - Name: get_func2B
; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 16
; CHECK-NEXT: - Name: get_func3B
; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 17
; CHECK-NEXT: - Name: __heap_base
; CHECK-NEXT: Kind: GLOBAL
; CHECK-NEXT: Index: 1
; CHECK-NEXT: - Type: ELEM
; CHECK-NEXT: Segments:
; CHECK-NEXT: - Offset:
; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 1
; CHECK-NEXT: Functions: [ 0, 1, 2, 9, 10, 11 ]
; CHECK-NEXT: - Type: CODE
; CHECK-NEXT: Functions:
; CHECK-NEXT: - Index: 0
; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 41020B
; CHECK-NEXT: - Index: 1
; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 41020B
; CHECK-NEXT: - Index: 2
; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 41020B
; CHECK-NEXT: - Index: 3
; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 4180888080000B
; CHECK-NEXT: - Index: 4
; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 4184888080000B
; CHECK-NEXT: - Index: 5
; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 4188888080000B
; CHECK-NEXT: - Index: 6
; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 4181808080000B
; CHECK-NEXT: - Index: 7
; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 4182808080000B
; CHECK-NEXT: - Index: 8
; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 4183808080000B
; CHECK-NEXT: - Index: 9
; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 41020B
; CHECK-NEXT: - Index: 10
; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 41020B
; CHECK-NEXT: - Index: 11
; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 41020B
; CHECK-NEXT: - Index: 12
; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 418C888080000B
; CHECK-NEXT: - Index: 13
; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 4190888080000B
; CHECK-NEXT: - Index: 14
; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 4194888080000B
; CHECK-NEXT: - Index: 15
; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 4184808080000B
; CHECK-NEXT: - Index: 16
; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 4185808080000B
; CHECK-NEXT: - Index: 17
; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 4186808080000B
; CHECK-NEXT: - Index: 18
; CHECK-NEXT: Locals:
; CHECK-NEXT: Body: 0B
; CHECK-NEXT: - Type: DATA
; CHECK-NEXT: Segments:
; CHECK-NEXT: - SectionOffset: 7
; CHECK-NEXT: MemoryIndex: 0
; CHECK-NEXT: Offset:
; CHECK-NEXT: Opcode: I32_CONST
; CHECK-NEXT: Value: 1024
; CHECK-NEXT: Content: '000000000000000000000000000000000000000000000000'
; CHECK-NEXT: - Type: CUSTOM
; CHECK-NEXT: Name: linking
; CHECK-NEXT: DataSize: 24
; CHECK-NEXT: - Type: CUSTOM
; CHECK-NEXT: Name: name
; CHECK-NEXT: FunctionNames:
; CHECK-NEXT: - Index: 0
; CHECK-NEXT: Name: colliding_func1
; CHECK-NEXT: - Index: 1
; CHECK-NEXT: Name: colliding_func2
; CHECK-NEXT: - Index: 2
; CHECK-NEXT: Name: colliding_func3
; CHECK-NEXT: - Index: 3
; CHECK-NEXT: Name: get_global1A
; CHECK-NEXT: - Index: 4
; CHECK-NEXT: Name: get_global2A
; CHECK-NEXT: - Index: 5
; CHECK-NEXT: Name: get_global3A
; CHECK-NEXT: - Index: 6
; CHECK-NEXT: Name: get_func1A
; CHECK-NEXT: - Index: 7
; CHECK-NEXT: Name: get_func2A
; CHECK-NEXT: - Index: 8
; CHECK-NEXT: Name: get_func3A
; CHECK-NEXT: - Index: 9
; CHECK-NEXT: Name: colliding_func1
; CHECK-NEXT: - Index: 10
; CHECK-NEXT: Name: colliding_func2
; CHECK-NEXT: - Index: 11
; CHECK-NEXT: Name: colliding_func3
; CHECK-NEXT: - Index: 12
; CHECK-NEXT: Name: get_global1B
; CHECK-NEXT: - Index: 13
; CHECK-NEXT: Name: get_global2B
; CHECK-NEXT: - Index: 14
; CHECK-NEXT: Name: get_global3B
; CHECK-NEXT: - Index: 15
; CHECK-NEXT: Name: get_func1B
; CHECK-NEXT: - Index: 16
; CHECK-NEXT: Name: get_func2B
; CHECK-NEXT: - Index: 17
; CHECK-NEXT: Name: get_func3B
; CHECK-NEXT: - Index: 18
; CHECK-NEXT: Name: __wasm_call_ctors
; CHECK-NEXT: ...
; RUN: lld -flavor wasm -r --no-entry -o %t.reloc.wasm %t1.o %t2.o
; RUN: obj2yaml %t.reloc.wasm | FileCheck -check-prefix=RELOC %s
; RELOC: --- !WASM
; RELOC-NEXT: FileHeader:
; RELOC-NEXT: Version: 0x00000001
; RELOC-NEXT: Sections:
; RELOC-NEXT: - Type: TYPE
; RELOC-NEXT: Signatures:
; RELOC-NEXT: - Index: 0
; RELOC-NEXT: ReturnType: I32
; RELOC-NEXT: ParamTypes:
; RELOC-NEXT: - Type: FUNCTION
; RELOC-NEXT: FunctionTypes: [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
; RELOC-NEXT: 0, 0 ]
; RELOC-NEXT: - Type: TABLE
; RELOC-NEXT: Tables:
; RELOC-NEXT: - ElemType: ANYFUNC
; RELOC-NEXT: Limits:
; RELOC-NEXT: Flags: [ HAS_MAX ]
; RELOC-NEXT: Initial: 0x00000006
; RELOC-NEXT: Maximum: 0x00000006
; RELOC-NEXT: - Type: MEMORY
; RELOC-NEXT: Memories:
; RELOC-NEXT: - Initial: 0x00000001
; RELOC-NEXT: - Type: GLOBAL
; RELOC-NEXT: Globals:
; RELOC-NEXT: - Index: 0
; RELOC-NEXT: Type: I32
; RELOC-NEXT: Mutable: false
; RELOC-NEXT: InitExpr:
; RELOC-NEXT: Opcode: I32_CONST
; RELOC-NEXT: Value: 0
; RELOC-NEXT: - Index: 1
; RELOC-NEXT: Type: I32
; RELOC-NEXT: Mutable: false
; RELOC-NEXT: InitExpr:
; RELOC-NEXT: Opcode: I32_CONST
; RELOC-NEXT: Value: 8
; RELOC-NEXT: - Index: 2
; RELOC-NEXT: Type: I32
; RELOC-NEXT: Mutable: false
; RELOC-NEXT: InitExpr:
; RELOC-NEXT: Opcode: I32_CONST
; RELOC-NEXT: Value: 16
; RELOC-NEXT: - Index: 3
; RELOC-NEXT: Type: I32
; RELOC-NEXT: Mutable: false
; RELOC-NEXT: InitExpr:
; RELOC-NEXT: Opcode: I32_CONST
; RELOC-NEXT: Value: 4
; RELOC-NEXT: - Index: 4
; RELOC-NEXT: Type: I32
; RELOC-NEXT: Mutable: false
; RELOC-NEXT: InitExpr:
; RELOC-NEXT: Opcode: I32_CONST
; RELOC-NEXT: Value: 12
; RELOC-NEXT: - Index: 5
; RELOC-NEXT: Type: I32
; RELOC-NEXT: Mutable: false
; RELOC-NEXT: InitExpr:
; RELOC-NEXT: Opcode: I32_CONST
; RELOC-NEXT: Value: 20
; RELOC-NEXT: - Type: EXPORT
; RELOC-NEXT: Exports:
; RELOC-NEXT: - Name: colliding_func1.1
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Index: 0
; RELOC-NEXT: - Name: colliding_func2
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Index: 1
; RELOC-NEXT: - Name: colliding_func3
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Index: 2
; RELOC-NEXT: - Name: get_global1A
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Index: 3
; RELOC-NEXT: - Name: get_global2A
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Index: 4
; RELOC-NEXT: - Name: get_global3A
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Index: 5
; RELOC-NEXT: - Name: get_func1A
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Index: 6
; RELOC-NEXT: - Name: get_func2A
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Index: 7
; RELOC-NEXT: - Name: get_func3A
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Index: 8
; RELOC-NEXT: - Name: colliding_func1
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Index: 9
; RELOC-NEXT: - Name: colliding_func2.1
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Index: 10
; RELOC-NEXT: - Name: colliding_func3.1
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Index: 11
; RELOC-NEXT: - Name: get_global1B
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Index: 12
; RELOC-NEXT: - Name: get_global2B
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Index: 13
; RELOC-NEXT: - Name: get_global3B
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Index: 14
; RELOC-NEXT: - Name: get_func1B
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Index: 15
; RELOC-NEXT: - Name: get_func2B
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Index: 16
; RELOC-NEXT: - Name: get_func3B
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Index: 17
; RELOC-NEXT: - Name: colliding_global1.1
; RELOC-NEXT: Kind: GLOBAL
; RELOC-NEXT: Index: 0
; RELOC-NEXT: - Name: colliding_global2
; RELOC-NEXT: Kind: GLOBAL
; RELOC-NEXT: Index: 1
; RELOC-NEXT: - Name: colliding_global3
; RELOC-NEXT: Kind: GLOBAL
; RELOC-NEXT: Index: 2
; RELOC-NEXT: - Name: colliding_global1
; RELOC-NEXT: Kind: GLOBAL
; RELOC-NEXT: Index: 3
; RELOC-NEXT: - Name: colliding_global2.1
; RELOC-NEXT: Kind: GLOBAL
; RELOC-NEXT: Index: 4
; RELOC-NEXT: - Name: colliding_global3.1
; RELOC-NEXT: Kind: GLOBAL
; RELOC-NEXT: Index: 5
; RELOC-NEXT: - Type: ELEM
; RELOC-NEXT: Segments:
; RELOC-NEXT: - Offset:
; RELOC-NEXT: Opcode: I32_CONST
; RELOC-NEXT: Value: 0
; RELOC-NEXT: Functions: [ 0, 1, 2, 9, 10, 11 ]
; RELOC-NEXT: - Type: CODE
; RELOC-NEXT: Relocations:
; RELOC-NEXT: - Type: R_WEBASSEMBLY_MEMORY_ADDR_SLEB
; RELOC-NEXT: Index: 0
; RELOC-NEXT: Offset: 0x00000013
; RELOC-NEXT: - Type: R_WEBASSEMBLY_MEMORY_ADDR_SLEB
; RELOC-NEXT: Index: 1
; RELOC-NEXT: Offset: 0x0000001C
; RELOC-NEXT: - Type: R_WEBASSEMBLY_MEMORY_ADDR_SLEB
; RELOC-NEXT: Index: 2
; RELOC-NEXT: Offset: 0x00000025
; RELOC-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB
; RELOC-NEXT: Index: 0
; RELOC-NEXT: Offset: 0x0000002E
; RELOC-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB
; RELOC-NEXT: Index: 1
; RELOC-NEXT: Offset: 0x00000037
; RELOC-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB
; RELOC-NEXT: Index: 2
; RELOC-NEXT: Offset: 0x00000040
; RELOC-NEXT: - Type: R_WEBASSEMBLY_MEMORY_ADDR_SLEB
; RELOC-NEXT: Index: 3
; RELOC-NEXT: Offset: 0x00000058
; RELOC-NEXT: - Type: R_WEBASSEMBLY_MEMORY_ADDR_SLEB
; RELOC-NEXT: Index: 4
; RELOC-NEXT: Offset: 0x00000061
; RELOC-NEXT: - Type: R_WEBASSEMBLY_MEMORY_ADDR_SLEB
; RELOC-NEXT: Index: 5
; RELOC-NEXT: Offset: 0x0000006A
; RELOC-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB
; RELOC-NEXT: Index: 3
; RELOC-NEXT: Offset: 0x00000073
; RELOC-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB
; RELOC-NEXT: Index: 4
; RELOC-NEXT: Offset: 0x0000007C
; RELOC-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB
; RELOC-NEXT: Index: 5
; RELOC-NEXT: Offset: 0x00000085
; RELOC-NEXT: Functions:
; RELOC-NEXT: - Index: 0
; RELOC-NEXT: Locals:
; RELOC-NEXT: Body: 41020B
; RELOC-NEXT: - Index: 1
; RELOC-NEXT: Locals:
; RELOC-NEXT: Body: 41020B
; RELOC-NEXT: - Index: 2
; RELOC-NEXT: Locals:
; RELOC-NEXT: Body: 41020B
; RELOC-NEXT: - Index: 3
; RELOC-NEXT: Locals:
; RELOC-NEXT: Body: 4180808080000B
; RELOC-NEXT: - Index: 4
; RELOC-NEXT: Locals:
; RELOC-NEXT: Body: 4188808080000B
; RELOC-NEXT: - Index: 5
; RELOC-NEXT: Locals:
; RELOC-NEXT: Body: 4190808080000B
; RELOC-NEXT: - Index: 6
; RELOC-NEXT: Locals:
; RELOC-NEXT: Body: 4180808080000B
; RELOC-NEXT: - Index: 7
; RELOC-NEXT: Locals:
; RELOC-NEXT: Body: 4181808080000B
; RELOC-NEXT: - Index: 8
; RELOC-NEXT: Locals:
; RELOC-NEXT: Body: 4182808080000B
; RELOC-NEXT: - Index: 9
; RELOC-NEXT: Locals:
; RELOC-NEXT: Body: 41020B
; RELOC-NEXT: - Index: 10
; RELOC-NEXT: Locals:
; RELOC-NEXT: Body: 41020B
; RELOC-NEXT: - Index: 11
; RELOC-NEXT: Locals:
; RELOC-NEXT: Body: 41020B
; RELOC-NEXT: - Index: 12
; RELOC-NEXT: Locals:
; RELOC-NEXT: Body: 4184808080000B
; RELOC-NEXT: - Index: 13
; RELOC-NEXT: Locals:
; RELOC-NEXT: Body: 418C808080000B
; RELOC-NEXT: - Index: 14
; RELOC-NEXT: Locals:
; RELOC-NEXT: Body: 4194808080000B
; RELOC-NEXT: - Index: 15
; RELOC-NEXT: Locals:
; RELOC-NEXT: Body: 4183808080000B
; RELOC-NEXT: - Index: 16
; RELOC-NEXT: Locals:
; RELOC-NEXT: Body: 4184808080000B
; RELOC-NEXT: - Index: 17
; RELOC-NEXT: Locals:
; RELOC-NEXT: Body: 4185808080000B
; RELOC-NEXT: - Type: DATA
; RELOC-NEXT: Segments:
; RELOC-NEXT: - SectionOffset: 6
; RELOC-NEXT: MemoryIndex: 0
; RELOC-NEXT: Offset:
; RELOC-NEXT: Opcode: I32_CONST
; RELOC-NEXT: Value: 0
; RELOC-NEXT: Content: '0000000000000000'
; RELOC-NEXT: - SectionOffset: 19
; RELOC-NEXT: MemoryIndex: 0
; RELOC-NEXT: Offset:
; RELOC-NEXT: Opcode: I32_CONST
; RELOC-NEXT: Value: 8
; RELOC-NEXT: Content: '0000000000000000'
; RELOC-NEXT: - SectionOffset: 32
; RELOC-NEXT: MemoryIndex: 0
; RELOC-NEXT: Offset:
; RELOC-NEXT: Opcode: I32_CONST
; RELOC-NEXT: Value: 16
; RELOC-NEXT: Content: '0000000000000000'
; RELOC-NEXT: - Type: CUSTOM
; RELOC-NEXT: Name: linking
; RELOC-NEXT: DataSize: 24
; RELOC-NEXT: SymbolInfo:
; RELOC-NEXT: - Name: colliding_func1.1
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: - Name: colliding_func3
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: - Name: colliding_func2.1
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: - Name: colliding_func3.1
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: - Name: colliding_global1.1
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: - Name: colliding_global3
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: - Name: colliding_global2.1
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: - Name: colliding_global3.1
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: SegmentInfo:
; RELOC-NEXT: - Index: 0
; RELOC-NEXT: Name: .bss.colliding_global1
; RELOC-NEXT: Alignment: 4
; RELOC-NEXT: Flags: [ ]
; RELOC-NEXT: - Index: 1
; RELOC-NEXT: Name: .bss.colliding_global2
; RELOC-NEXT: Alignment: 4
; RELOC-NEXT: Flags: [ ]
; RELOC-NEXT: - Index: 2
; RELOC-NEXT: Name: .bss.colliding_global3
; RELOC-NEXT: Alignment: 4
; RELOC-NEXT: Flags: [ ]
; RELOC-NEXT: - Type: CUSTOM
; RELOC-NEXT: Name: name
; RELOC-NEXT: FunctionNames:
; RELOC-NEXT: - Index: 0
; RELOC-NEXT: Name: colliding_func1
; RELOC-NEXT: - Index: 1
; RELOC-NEXT: Name: colliding_func2
; RELOC-NEXT: - Index: 2
; RELOC-NEXT: Name: colliding_func3
; RELOC-NEXT: - Index: 3
; RELOC-NEXT: Name: get_global1A
; RELOC-NEXT: - Index: 4
; RELOC-NEXT: Name: get_global2A
; RELOC-NEXT: - Index: 5
; RELOC-NEXT: Name: get_global3A
; RELOC-NEXT: - Index: 6
; RELOC-NEXT: Name: get_func1A
; RELOC-NEXT: - Index: 7
; RELOC-NEXT: Name: get_func2A
; RELOC-NEXT: - Index: 8
; RELOC-NEXT: Name: get_func3A
; RELOC-NEXT: - Index: 9
; RELOC-NEXT: Name: colliding_func1
; RELOC-NEXT: - Index: 10
; RELOC-NEXT: Name: colliding_func2
; RELOC-NEXT: - Index: 11
; RELOC-NEXT: Name: colliding_func3
; RELOC-NEXT: - Index: 12
; RELOC-NEXT: Name: get_global1B
; RELOC-NEXT: - Index: 13
; RELOC-NEXT: Name: get_global2B
; RELOC-NEXT: - Index: 14
; RELOC-NEXT: Name: get_global3B
; RELOC-NEXT: - Index: 15
; RELOC-NEXT: Name: get_func1B
; RELOC-NEXT: - Index: 16
; RELOC-NEXT: Name: get_func2B
; RELOC-NEXT: - Index: 17
; RELOC-NEXT: Name: get_func3B
; RELOC-NEXT: ...

lld/trunk/test/wasm/relocatable.ll

Show First 20 Lines • Show All 194 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: 20 ; CHECK-NEXT: Value: 20
; 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: 23 ; CHECK-NEXT: DataSize: 23
; CHECK-NEXT: SymbolInfo:
; CHECK-NEXT: - Name: hello
; CHECK-NEXT: Flags: [ VISIBILITY_HIDDEN ]
; CHECK-NEXT: - Name: my_func
; CHECK-NEXT: Flags: [ VISIBILITY_HIDDEN ]
; CHECK-NEXT: - Name: func_comdat
; CHECK-NEXT: Flags: [ BINDING_WEAK ]
; CHECK-NEXT: - Name: data_comdat
; CHECK-NEXT: Flags: [ BINDING_WEAK ]
; CHECK-NEXT: - Name: func_addr1
; CHECK-NEXT: Flags: [ VISIBILITY_HIDDEN ]
; CHECK-NEXT: - Name: func_addr2
; CHECK-NEXT: Flags: [ VISIBILITY_HIDDEN ]
; CHECK-NEXT: - Name: data_addr1
; CHECK-NEXT: Flags: [ VISIBILITY_HIDDEN ]
; 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 34 Lines

lld/trunk/test/wasm/visibility-hidden.ll

Show All 31 Lines
; CHECK: - Type: EXPORT ; CHECK: - 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: 2 ; CHECK-NEXT: Index: 2
; CHECK-NEXT: - Name: archiveDefault
; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 4
; CHECK-NEXT: - Name: objectDefault ; CHECK-NEXT: - Name: objectDefault
; CHECK-NEXT: Kind: FUNCTION ; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 1 ; CHECK-NEXT: Index: 1
; CHECK-NEXT: - Name: archiveDefault
; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Index: 4
; CHECK-NEXT: - Name: __heap_base ; CHECK-NEXT: - Name: __heap_base
; CHECK-NEXT: Kind: GLOBAL ; CHECK-NEXT: Kind: GLOBAL
; CHECK-NEXT: Index: 1 ; CHECK-NEXT: Index: 1
; CHECK-NEXT: - Type: ; CHECK-NEXT: - Type:

lld/trunk/wasm/Writer.cpp

Show First 20 Lines • Show All 56 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.
struct WasmExportEntry {
const Symbol *Symbol;
inglorionUnsubmitted
Not Done
ReplyInline Actions

gcc seems unhappy with this declaration. It complains:

llvm/tools/lld/wasm/Writer.cpp:67:17: error: declaration of ‘const lld::wasm::Symbol* {anonymous}::WasmExportEntry::Symbol’ [-fpermissive]
   const Symbol *Symbol;
             ^
In file included from llvm/tools/lld/wasm/Config.h:17:0,
                 from llvm/tools/lld/wasm/Writer.cpp:13:
llvm/tools/lld/wasm/Symbols.h:27:7: error: changes meaning of ‘Symbol’ from ‘class lld::wasm::Symbol’ [-fpermissive]
 class Symbol {
       ^

I have put up D42278 to rename the field and stop the naming collision.

inglorion: gcc seems unhappy with this declaration. It complains: llvm/tools/lld/wasm/Writer.cpp:67…
sbc100Unsubmitted
Not Done
ReplyInline Actions

Thanks! I already had a local version ready to go so I'll just push that if thats OK?

sbc100: Thanks! I already had a local version ready to go so I'll just push that if thats OK?
StringRef FieldName; // may not match the Symbol name
};
// 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 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;
uint32_t InitialTableOffset = 0; uint32_t InitialTableOffset = 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 *> ImportedFunctions; std::vector<const Symbol *> ImportedFunctions;
std::vector<const Symbol *> ImportedGlobals; std::vector<const Symbol *> ImportedGlobals;
std::vector<WasmExportEntry> ExportedSymbols;
std::vector<const Symbol *> DefinedGlobals; std::vector<const Symbol *> DefinedGlobals;
std::vector<InputFunction *> DefinedFunctions; std::vector<InputFunction *> DefinedFunctions;
std::vector<const Symbol *> IndirectFunctions; std::vector<const Symbol *> IndirectFunctions;
std::vector<WasmInitFunc> InitFunctions; std::vector<WasmInitFunc> 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;
▲ Show 20 Lines • Show All 129 Lines • ▼ Show 20 Linesvoid Writer::createTableSection() {
writeSleb128(OS, WASM_TYPE_ANYFUNC, "table type"); writeSleb128(OS, WASM_TYPE_ANYFUNC, "table type");
writeUleb128(OS, WASM_LIMITS_FLAG_HAS_MAX, "table flags"); writeUleb128(OS, WASM_LIMITS_FLAG_HAS_MAX, "table flags");
writeUleb128(OS, TableSize, "table initial size"); writeUleb128(OS, TableSize, "table initial size");
writeUleb128(OS, TableSize, "table max size"); writeUleb128(OS, TableSize, "table max size");
} }
void Writer::createExportSection() { void Writer::createExportSection() {
bool ExportMemory = !Config->Relocatable && !Config->ImportMemory; bool ExportMemory = !Config->Relocatable && !Config->ImportMemory;
Symbol *EntrySym = Symtab->find(Config->Entry);
bool ExportEntry = !Config->Relocatable && EntrySym && EntrySym->isDefined();
bool ExportHidden = Config->EmitRelocs;
uint32_t NumExports = ExportMemory ? 1 : 0;
std::vector<const Symbol *> SymbolExports;
if (ExportEntry)
SymbolExports.emplace_back(EntrySym);
for (const Symbol *Sym : Symtab->getSymbols()) {
if (Sym->isUndefined() || Sym->isGlobal())
continue;
if (Sym->isHidden() && !ExportHidden)
continue;
if (ExportEntry && Sym == EntrySym)
continue;
SymbolExports.emplace_back(Sym);
}
for (const Symbol *Sym : DefinedGlobals) { uint32_t NumExports = (ExportMemory ? 1 : 0) + ExportedSymbols.size();
// Can't export the SP right now because it mutable and mutable globals
// connot be exported.
if (Sym == Config->StackPointerSymbol)
continue;
SymbolExports.emplace_back(Sym);
}
NumExports += SymbolExports.size();
if (!NumExports) if (!NumExports)
return; return;
SyntheticSection *Section = createSyntheticSection(WASM_SEC_EXPORT); SyntheticSection *Section = createSyntheticSection(WASM_SEC_EXPORT);
raw_ostream &OS = Section->getStream(); raw_ostream &OS = Section->getStream();
writeUleb128(OS, NumExports, "export count"); writeUleb128(OS, NumExports, "export count");
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 Symbol *Sym : SymbolExports) { for (const WasmExportEntry &E : ExportedSymbols) {
DEBUG(dbgs() << "Export: " << Sym->getName() << "\n"); DEBUG(dbgs() << "Export: " << E.Symbol->getName() << "\n");
WasmExport Export; WasmExport Export;
Export.Name = Sym->getName(); Export.Name = E.FieldName;
Export.Index = Sym->getOutputIndex(); Export.Index = E.Symbol->getOutputIndex();
if (Sym->isFunction()) if (E.Symbol->isFunction())
Export.Kind = WASM_EXTERNAL_FUNCTION; Export.Kind = WASM_EXTERNAL_FUNCTION;
else else
Export.Kind = WASM_EXTERNAL_GLOBAL; Export.Kind = WASM_EXTERNAL_GLOBAL;
writeExport(OS, Export); writeExport(OS, Export);
} }
} }
void Writer::createStartSection() {} void Writer::createStartSection() {}
▲ Show 20 Lines • Show All 78 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;
for (const WasmExportEntry &E : ExportedSymbols) {
uint32_t Flags =
(E.Symbol->isLocal() ? WASM_SYMBOL_BINDING_LOCAL :
E.Symbol->isWeak() ? WASM_SYMBOL_BINDING_WEAK : 0) |
(E.Symbol->isHidden() ? WASM_SYMBOL_VISIBILITY_HIDDEN : 0);
if (Flags)
SymbolInfo.emplace_back(E.FieldName, Flags);
}
if (!SymbolInfo.empty()) {
SubSection SubSection(WASM_SYMBOL_INFO);
writeUleb128(SubSection.getStream(), SymbolInfo.size(), "num sym info");
for (auto Pair: SymbolInfo) {
writeStr(SubSection.getStream(), Pair.first, "sym name");
writeUleb128(SubSection.getStream(), Pair.second, "sym flags");
}
SubSection.finalizeContents();
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");
for (const OutputSegment *S : Segments) { for (const OutputSegment *S : Segments) {
writeStr(SubSection.getStream(), S->Name, "segment name"); writeStr(SubSection.getStream(), S->Name, "segment name");
writeUleb128(SubSection.getStream(), S->Alignment, "alignment"); writeUleb128(SubSection.getStream(), S->Alignment, "alignment");
writeUleb128(SubSection.getStream(), 0, "flags"); writeUleb128(SubSection.getStream(), 0, "flags");
} }
▲ Show 20 Lines • Show All 188 Lines • ▼ Show 20 Lines if (Sym->isFunction()) {
ImportedFunctions.push_back(Sym); ImportedFunctions.push_back(Sym);
} else { } else {
Sym->setOutputIndex(ImportedGlobals.size()); Sym->setOutputIndex(ImportedGlobals.size());
ImportedGlobals.push_back(Sym); ImportedGlobals.push_back(Sym);
} }
} }
} }
void Writer::calculateExports() {
Symbol *EntrySym = Symtab->find(Config->Entry);
bool ExportEntry = !Config->Relocatable && EntrySym && EntrySym->isDefined();
bool ExportHidden = Config->EmitRelocs;
StringSet<> UsedNames;
auto BudgeLocalName = [&](const Symbol *Sym) {
StringRef SymName = Sym->getName();
// We can't budge non-local names.
if (!Sym->isLocal())
return SymName;
// We must budge local names that have a collision with a symbol that we
// haven't yet processed.
if (!Symtab->find(SymName) && UsedNames.insert(SymName).second)
return SymName;
for (unsigned I = 1; ; ++I) {
std::string NameBuf = (SymName + "." + Twine(I)).str();
if (!UsedNames.count(NameBuf)) {
StringRef Name = Saver.save(NameBuf);
UsedNames.insert(Name); // Insert must use safe StringRef from save()
return Name;
}
}
};
if (ExportEntry)
ExportedSymbols.emplace_back(WasmExportEntry{EntrySym, EntrySym->getName()});
if (Config->CtorSymbol && ExportHidden &&
!(ExportEntry && Config->CtorSymbol == EntrySym))
ExportedSymbols.emplace_back(
WasmExportEntry{Config->CtorSymbol, Config->CtorSymbol->getName()});
for (ObjFile *File : Symtab->ObjectFiles) {
for (Symbol *Sym : File->getSymbols()) {
if (!Sym->isDefined() || File != Sym->getFile())
continue;
if (Sym->isGlobal())
continue;
if (Sym->getFunction()->Discarded)
continue;
if ((Sym->isHidden() || Sym->isLocal()) && !ExportHidden)
continue;
if (ExportEntry && Sym == EntrySym)
continue;
ExportedSymbols.emplace_back(WasmExportEntry{Sym, BudgeLocalName(Sym)});
}
}
for (const Symbol *Sym : DefinedGlobals) {
// Can't export the SP right now because it's mutable and mutable globals
// cannot be exported.
if (Sym == Config->StackPointerSymbol)
continue;
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;
} }
return It->second; return It->second;
} }
▲ Show 20 Lines • Show All 169 Lines • ▼ Show 20 Lines if (!Config->Relocatable)
InitialTableOffset = 1; InitialTableOffset = 1;
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();
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()));
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines