mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2025-12-16 03:03:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

update embedded LLD to 8.0.0rc3

Browse Source
This commit is contained in:
Andrew Kelley 2019-02-28 12:53:08 -05:00
parent 6bc19b437c
commit 5768fcb085
No known key found for this signature in database
GPG Key ID: 7C5F548F728501A9
26 changed files with 411 additions and 223 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
deps/lld-prebuilt/ELF/Options.inc vendored
View File

@ -54,7 +54,7 @@ OPTION(prefix_2, "Bsymbolic-functions", Bsymbolic_functions, Flag, INVALID, INVA
OPTION(prefix_2, "Bsymbolic", Bsymbolic, Flag, INVALID, INVALID, nullptr, 0, 0, OPTION(prefix_2, "Bsymbolic", Bsymbolic, Flag, INVALID, INVALID, nullptr, 0, 0,
"Bind defined symbols locally", nullptr, nullptr) "Bind defined symbols locally", nullptr, nullptr)
OPTION(prefix_2, "build-id=", build_id_eq, Joined, INVALID, INVALID, nullptr, 0, 0, OPTION(prefix_2, "build-id=", build_id_eq, Joined, INVALID, INVALID, nullptr, 0, 0,
"Generate build ID note", "[fast,md5,sha,uuid,0x<hexstring>]", nullptr) "Generate build ID note", "[fast,md5,sha1,uuid,0x<hexstring>]", nullptr)
OPTION(prefix_2, "build-id", build_id, Flag, INVALID, INVALID, nullptr, 0, 0, OPTION(prefix_2, "build-id", build_id, Flag, INVALID, INVALID, nullptr, 0, 0,
"Alias for --build-id=fast", nullptr, nullptr) "Alias for --build-id=fast", nullptr, nullptr)
OPTION(prefix_1, "b", anonymous_16, Separate, INVALID, format, nullptr, 0, 0, OPTION(prefix_1, "b", anonymous_16, Separate, INVALID, format, nullptr, 0, 0,

2
deps/lld/ELF/Driver.cpp vendored
View File

@ -130,7 +130,7 @@ static std::tuple<ELFKind, uint16_t, uint8_t> parseEmulation(StringRef Emul) {
.Cases("elf32btsmip", "elf32btsmipn32", {ELF32BEKind, EM_MIPS}) .Cases("elf32btsmip", "elf32btsmipn32", {ELF32BEKind, EM_MIPS})
.Cases("elf32ltsmip", "elf32ltsmipn32", {ELF32LEKind, EM_MIPS}) .Cases("elf32ltsmip", "elf32ltsmipn32", {ELF32LEKind, EM_MIPS})
.Case("elf32lriscv", {ELF32LEKind, EM_RISCV}) .Case("elf32lriscv", {ELF32LEKind, EM_RISCV})
.Case("elf32ppc", {ELF32BEKind, EM_PPC}) .Cases("elf32ppc", "elf32ppclinux", {ELF32BEKind, EM_PPC})
.Case("elf64btsmip", {ELF64BEKind, EM_MIPS}) .Case("elf64btsmip", {ELF64BEKind, EM_MIPS})
.Case("elf64ltsmip", {ELF64LEKind, EM_MIPS}) .Case("elf64ltsmip", {ELF64LEKind, EM_MIPS})
.Case("elf64lriscv", {ELF64LEKind, EM_RISCV}) .Case("elf64lriscv", {ELF64LEKind, EM_RISCV})

2
deps/lld/ELF/Options.td vendored
View File

@ -30,7 +30,7 @@ def Bstatic: F<"Bstatic">, HelpText<"Do not link against shared libraries">;
def build_id: F<"build-id">, HelpText<"Alias for --build-id=fast">; def build_id: F<"build-id">, HelpText<"Alias for --build-id=fast">;
def build_id_eq: J<"build-id=">, HelpText<"Generate build ID note">, def build_id_eq: J<"build-id=">, HelpText<"Generate build ID note">,
MetaVarName<"[fast,md5,sha,uuid,0x<hexstring>]">; MetaVarName<"[fast,md5,sha1,uuid,0x<hexstring>]">;
defm check_sections: B<"check-sections", defm check_sections: B<"check-sections",
"Check section addresses for overlaps (default)", "Check section addresses for overlaps (default)",

3
deps/lld/ELF/ScriptParser.cpp vendored
View File

@ -392,10 +392,11 @@ static std::pair<ELFKind, uint16_t> parseBfdName(StringRef S) {
.Case("elf32-x86-64", {ELF32LEKind, EM_X86_64}) .Case("elf32-x86-64", {ELF32LEKind, EM_X86_64})
.Case("elf64-aarch64", {ELF64LEKind, EM_AARCH64}) .Case("elf64-aarch64", {ELF64LEKind, EM_AARCH64})
.Case("elf64-littleaarch64", {ELF64LEKind, EM_AARCH64}) .Case("elf64-littleaarch64", {ELF64LEKind, EM_AARCH64})
.Case("elf32-powerpc", {ELF32BEKind, EM_PPC})
.Case("elf64-powerpc", {ELF64BEKind, EM_PPC64}) .Case("elf64-powerpc", {ELF64BEKind, EM_PPC64})
.Case("elf64-powerpcle", {ELF64LEKind, EM_PPC64}) .Case("elf64-powerpcle", {ELF64LEKind, EM_PPC64})
.Case("elf64-x86-64", {ELF64LEKind, EM_X86_64}) .Case("elf64-x86-64", {ELF64LEKind, EM_X86_64})
.Case("elf32-tradbigmips", {ELF32BEKind, EM_MIPS}) .Cases("elf32-tradbigmips", "elf32-bigmips", {ELF32BEKind, EM_MIPS})
.Case("elf32-ntradbigmips", {ELF32BEKind, EM_MIPS}) .Case("elf32-ntradbigmips", {ELF32BEKind, EM_MIPS})
.Case("elf32-tradlittlemips", {ELF32LEKind, EM_MIPS}) .Case("elf32-tradlittlemips", {ELF32LEKind, EM_MIPS})
.Case("elf32-ntradlittlemips", {ELF32LEKind, EM_MIPS}) .Case("elf32-ntradlittlemips", {ELF32LEKind, EM_MIPS})

44
deps/lld/docs/ReleaseNotes.rst vendored
View File

@ -5,18 +5,15 @@ lld 8.0.0 Release Notes
.. contents:: .. contents::
:local: :local:
.. warning::
These are in-progress notes for the upcoming LLVM 8.0.0 release.
Release notes for previous releases can be found on
`the Download Page <https://releases.llvm.org/download.html>`_.
Introduction Introduction
============ ============
This document contains the release notes for the lld linker, release 8.0.0. lld is a high-performance linker that supports ELF (Unix), COFF (Windows),
Here we describe the status of lld, including major improvements Mach-O (macOS), MinGW and WebAssembly. lld is command-line-compatible with
from the previous release. All lld releases may be downloaded GNU linkers and Microsoft link.exe and is significantly faster than the
from the `LLVM releases web site <https://llvm.org/releases/>`_. system default linkers.
lld 8.0.0 has lots of feature improvements and bug fixes.
Non-comprehensive list of changes in this release Non-comprehensive list of changes in this release
================================================= =================================================
@ -33,16 +30,36 @@ ELF Improvements
non-superpages to a superpage if they are aligned to the superpage non-superpages to a superpage if they are aligned to the superpage
size. (`r342746 <https://reviews.llvm.org/rL342746>`_) size. (`r342746 <https://reviews.llvm.org/rL342746>`_)
* lld now attempts to place a ``.note`` segment in the first page of a
generated file, so that you can find some important information
(``.note.gnu.build-id`` in particular) in a core file even if a core
file is truncated by ulimit.
(`r349524 <https://reviews.llvm.org/rL349524>`_)
* lld now reports an error if ``_GLOBAL_OFFSET_TABLE_`` symbol is
defined by an input object file, as the symbol is supposed to be
synthesized by the linker.
(`r347854 <https://reviews.llvm.org/rL347854>`_)
* lld/Hexagon can now link Linux kernel and musl libc for Qualcomm * lld/Hexagon can now link Linux kernel and musl libc for Qualcomm
Hexagon ISA. Hexagon ISA.
* Initial MSP430 ISA support has landed. * Initial MSP430 ISA support has landed.
* The following flags have been added: ``-z interpose``, ``-z global``
* lld now uses the ``sigrie`` instruction as a trap instruction for * lld now uses the ``sigrie`` instruction as a trap instruction for
MIPS targets. MIPS targets.
* lld now creates a TLS segment for AArch64 with a slightly larger
alignment requirement, so that the loader makes a few bytes room
before each TLS segment at runtime. The aim of this change is to
make room to accomodate nonstandard Android TLS slots while keeping
the compatibility with the standard AArch64 ABI.
(`r350681 <https://reviews.llvm.org/rL350681>`_)
* The following flags have been added: ``--call-graph-profile``,
``--no-call-graph-profile``, ``--warn-ifunc-textrel``,
``-z interpose``, ``-z global``, ``-z nodefaultlib``
COFF Improvements COFF Improvements
----------------- -----------------
@ -95,11 +112,6 @@ MinGW Improvements
Previously, the ``--build-id`` option did not actually generate a build id Previously, the ``--build-id`` option did not actually generate a build id
unless ``--pdb`` was specified. unless ``--pdb`` was specified.
MachO Improvements
------------------
* Item 1.
WebAssembly Improvements WebAssembly Improvements
------------------------ ------------------------

1
deps/lld/lib/ReaderWriter/MachO/ArchHandler_x86_64.cpp vendored
View File

@ -622,6 +622,7 @@ void ArchHandler_x86_64::applyFixupFinal(
// Fall into llvm_unreachable(). // Fall into llvm_unreachable().
break; break;
} }
llvm_unreachable("invalid x86_64 Reference Kind");
} }
void ArchHandler_x86_64::applyFixupRelocatable(const Reference &ref, void ArchHandler_x86_64::applyFixupRelocatable(const Reference &ref,

3
deps/lld/test/ELF/emulation-mips.s vendored
View File

@ -7,6 +7,9 @@
# RUN: echo 'OUTPUT_FORMAT(elf32-tradbigmips)' > %tmips.script # RUN: echo 'OUTPUT_FORMAT(elf32-tradbigmips)' > %tmips.script
# RUN: ld.lld %tmips.script -e _start %tmips -o %t4mips # RUN: ld.lld %tmips.script -e _start %tmips -o %t4mips
# RUN: llvm-readobj -file-headers %t4mips | FileCheck --check-prefix=MIPS %s # RUN: llvm-readobj -file-headers %t4mips | FileCheck --check-prefix=MIPS %s
# RUN: echo 'OUTPUT_FORMAT(elf32-bigmips)' > %tmips2.script
# RUN: ld.lld %tmips2.script -e _start %tmips -o %t5mips
# RUN: llvm-readobj -file-headers %t5mips | FileCheck --check-prefix=MIPS %s
# MIPS: ElfHeader { # MIPS: ElfHeader {
# MIPS-NEXT: Ident { # MIPS-NEXT: Ident {
# MIPS-NEXT: Magic: (7F 45 4C 46) # MIPS-NEXT: Magic: (7F 45 4C 46)

37
deps/lld/test/ELF/emulation-ppc.s vendored
View File

@ -103,5 +103,42 @@
# PPC64LE-NEXT: StringTableSectionIndex: # PPC64LE-NEXT: StringTableSectionIndex:
# PPC64LE-NEXT: } # PPC64LE-NEXT: }
# RUN: llvm-mc -filetype=obj -triple=powerpc-unknown-linux %s -o %tppc32
# RUN: ld.lld -m elf32ppc %tppc32 -o %t2ppc32
# RUN: llvm-readobj -file-headers %t2ppc32 | FileCheck --check-prefix=PPC32 %s
# RUN: ld.lld %tppc32 -o %t3ppc32
# RUN: llvm-readobj -file-headers %t3ppc32 | FileCheck --check-prefix=PPC32 %s
# RUN: echo 'OUTPUT_FORMAT(elf32-powerpc)' > %tppc32.script
# RUN: ld.lld %tppc32.script %tppc32 -o %t4ppc32
# RUN: llvm-readobj -file-headers %t4ppc32 | FileCheck --check-prefix=PPC32 %s
# RUN: ld.lld -m elf32ppclinux %tppc32 -o %t5ppc32
# RUN: llvm-readobj -file-headers %t5ppc32 | FileCheck --check-prefix=PPC32 %s
# PPC32: ElfHeader {
# PPC32-NEXT: Ident {
# PPC32-NEXT: Magic: (7F 45 4C 46)
# PPC32-NEXT: Class: 32-bit (0x1)
# PPC32-NEXT: DataEncoding: BigEndian (0x2)
# PPC32-NEXT: FileVersion: 1
# PPC32-NEXT: OS/ABI: SystemV (0x0)
# PPC32-NEXT: ABIVersion: 0
# PPC32-NEXT: Unused: (00 00 00 00 00 00 00)
# PPC32-NEXT: }
# PPC32-NEXT: Type: Executable (0x2)
# PPC32-NEXT: Machine: EM_PPC (0x14)
# PPC32-NEXT: Version: 1
# PPC32-NEXT: Entry:
# PPC32-NEXT: ProgramHeaderOffset: 0x34
# PPC32-NEXT: SectionHeaderOffset:
# PPC32-NEXT: Flags [ (0x0)
# PPC32-NEXT: ]
# PPC32-NEXT: HeaderSize: 52
# PPC32-NEXT: ProgramHeaderEntrySize: 32
# PPC32-NEXT: ProgramHeaderCount:
# PPC32-NEXT: SectionHeaderEntrySize: 40
# PPC32-NEXT: SectionHeaderCount:
# PPC32-NEXT: StringTableSectionIndex:
# PPC32-NEXT: }
.globl _start .globl _start
_start: _start:

6
deps/lld/test/wasm/data-layout.ll vendored
View File

@ -85,10 +85,10 @@ target triple = "wasm32-unknown-unknown"
; 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: 6 ; RELOC-NEXT: Index: 3
; RELOC-NEXT: Offset: 0x00000018 ; RELOC-NEXT: Offset: 0x00000018
; RELOC-NEXT: - Type: R_WEBASSEMBLY_MEMORY_ADDR_I32 ; RELOC-NEXT: - Type: R_WEBASSEMBLY_MEMORY_ADDR_I32
; RELOC-NEXT: Index: 3 ; RELOC-NEXT: Index: 4
; RELOC-NEXT: Offset: 0x0000002E ; RELOC-NEXT: Offset: 0x0000002E
; RELOC-NEXT: Addend: 4 ; RELOC-NEXT: Addend: 4
; RELOC-NEXT: Segments: ; RELOC-NEXT: Segments:
@ -148,7 +148,7 @@ target triple = "wasm32-unknown-unknown"
; RELOC-NEXT: Flags: [ ] ; RELOC-NEXT: Flags: [ ]
; RELOC-NEXT: Segment: 2 ; RELOC-NEXT: Segment: 2
; RELOC-NEXT: Size: 4 ; RELOC-NEXT: Size: 4
; RELOC: - Index: 6 ; RELOC-NEXT: - Index: 3
; RELOC-NEXT: Kind: DATA ; RELOC-NEXT: Kind: DATA
; RELOC-NEXT: Name: hello_str ; RELOC-NEXT: Name: hello_str
; RELOC-NEXT: Flags: [ ] ; RELOC-NEXT: Flags: [ ]

21
deps/lld/test/wasm/import-module.ll vendored Normal file
View File

@ -0,0 +1,21 @@
; RUN: llc -filetype=obj %s -o %t.o
; RUN: wasm-ld --allow-undefined -o %t.wasm %t.o
; RUN: obj2yaml %t.wasm | FileCheck %s
target triple = "wasm32-unknown-unknown-wasm"
define void @_start() {
call void @foo();
ret void
}
declare void @foo() #0
attributes #0 = { "wasm-import-module"="bar" }
; CHECK: - Type: IMPORT
; CHECK-NEXT: Imports:
; CHECK-NEXT: - Module: bar
; CHECK-NEXT: Field: foo
; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: SigIndex: 0

27
deps/lld/test/wasm/import-names.ll vendored Normal file
View File

@ -0,0 +1,27 @@
; RUN: llc -filetype=obj %s -o %t.o
; RUN: wasm-ld --allow-undefined -o %t.wasm %t.o
; RUN: obj2yaml %t.wasm | FileCheck %s
target triple = "wasm32-unknown-unknown"
declare void @f0() #0
define void @_start() {
call void @f0()
ret void
}
attributes #0 = { "wasm-import-module"="somewhere" "wasm-import-name"="something" }
; CHECK: - Type: IMPORT
; CHECK-NEXT: Imports:
; CHECK-NEXT: - Module: somewhere
; CHECK-NEXT: Field: something
; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: SigIndex: 0
; CHECK: - Type: CUSTOM
; CHECK-NEXT: Name: name
; CHECK-NEXT: FunctionNames:
; CHECK-NEXT: - Index: 0
; CHECK-NEXT: Name: f0

88
deps/lld/test/wasm/init-fini.ll vendored
View File

@ -163,64 +163,64 @@ entry:
; RELOC-NEXT: Flags: [ VISIBILITY_HIDDEN ] ; RELOC-NEXT: Flags: [ VISIBILITY_HIDDEN ]
; RELOC-NEXT: Function: 7 ; RELOC-NEXT: Function: 7
; RELOC-NEXT: - Index: 6 ; RELOC-NEXT: - Index: 6
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: .Lcall_dtors.101
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: Function: 8
; RELOC-NEXT: - Index: 7
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: .Lregister_call_dtors.101
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: Function: 9
; RELOC-NEXT: - Index: 8
; RELOC-NEXT: Kind: DATA ; RELOC-NEXT: Kind: DATA
; RELOC-NEXT: Name: __dso_handle ; RELOC-NEXT: Name: __dso_handle
; RELOC-NEXT: Flags: [ BINDING_WEAK, VISIBILITY_HIDDEN, UNDEFINED ] ; RELOC-NEXT: Flags: [ BINDING_WEAK, VISIBILITY_HIDDEN, UNDEFINED ]
; RELOC-NEXT: - Index: 9 ; RELOC-NEXT: - Index: 7
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: .Lcall_dtors.1001
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: Function: 10
; RELOC-NEXT: - Index: 10
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: .Lregister_call_dtors.1001
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: Function: 11
; RELOC-NEXT: - Index: 11
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: .Lcall_dtors.4000
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: Function: 12
; RELOC-NEXT: - Index: 12
; RELOC-NEXT: Kind: FUNCTION ; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: externDtor ; RELOC-NEXT: Name: externDtor
; RELOC-NEXT: Flags: [ VISIBILITY_HIDDEN, UNDEFINED ] ; RELOC-NEXT: Flags: [ VISIBILITY_HIDDEN, UNDEFINED ]
; RELOC-NEXT: Function: 0 ; RELOC-NEXT: Function: 0
; RELOC-NEXT: - Index: 13 ; RELOC-NEXT: - Index: 8
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: .Lregister_call_dtors.4000
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: Function: 13
; RELOC-NEXT: - Index: 14
; RELOC-NEXT: Kind: FUNCTION ; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: externCtor ; RELOC-NEXT: Name: externCtor
; RELOC-NEXT: Flags: [ VISIBILITY_HIDDEN, UNDEFINED ] ; RELOC-NEXT: Flags: [ VISIBILITY_HIDDEN, UNDEFINED ]
; RELOC-NEXT: Function: 1 ; RELOC-NEXT: Function: 1
; RELOC-NEXT: - Index: 15 ; RELOC-NEXT: - Index: 9
; RELOC-NEXT: Kind: FUNCTION ; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: myctor ; RELOC-NEXT: Name: myctor
; RELOC-NEXT: Flags: [ VISIBILITY_HIDDEN ] ; RELOC-NEXT: Flags: [ VISIBILITY_HIDDEN ]
; RELOC-NEXT: Function: 14 ; RELOC-NEXT: Function: 14
; RELOC-NEXT: - Index: 16 ; RELOC-NEXT: - Index: 10
; RELOC-NEXT: Kind: FUNCTION ; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: mydtor ; RELOC-NEXT: Name: mydtor
; RELOC-NEXT: Flags: [ VISIBILITY_HIDDEN ] ; RELOC-NEXT: Flags: [ VISIBILITY_HIDDEN ]
; RELOC-NEXT: Function: 15 ; RELOC-NEXT: Function: 15
; RELOC-NEXT: - Index: 17 ; RELOC-NEXT: - Index: 11
; RELOC-NEXT: Kind: GLOBAL ; RELOC-NEXT: Kind: GLOBAL
; RELOC-NEXT: Name: __stack_pointer ; RELOC-NEXT: Name: __stack_pointer
; RELOC-NEXT: Flags: [ UNDEFINED ] ; RELOC-NEXT: Flags: [ UNDEFINED ]
; RELOC-NEXT: Global: 0 ; RELOC-NEXT: Global: 0
; RELOC-NEXT: - Index: 12
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: .Lcall_dtors.101
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: Function: 8
; RELOC-NEXT: - Index: 13
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: .Lregister_call_dtors.101
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: Function: 9
; RELOC-NEXT: - Index: 14
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: .Lcall_dtors.1001
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: Function: 10
; RELOC-NEXT: - Index: 15
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: .Lregister_call_dtors.1001
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: Function: 11
; RELOC-NEXT: - Index: 16
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: .Lcall_dtors.4000
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: Function: 12
; RELOC-NEXT: - Index: 17
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: .Lregister_call_dtors.4000
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: Function: 13
; RELOC-NEXT: - Index: 18 ; RELOC-NEXT: - Index: 18
; RELOC-NEXT: Kind: FUNCTION ; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: .Lcall_dtors.101 ; RELOC-NEXT: Name: .Lcall_dtors.101
@ -251,36 +251,36 @@ entry:
; RELOC-NEXT: Name: .Lregister_call_dtors.2002 ; RELOC-NEXT: Name: .Lregister_call_dtors.2002
; RELOC-NEXT: Flags: [ BINDING_LOCAL ] ; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: Function: 21 ; RELOC-NEXT: Function: 21
; RELOC-NEXT: InitFunctions: ; RELOC-NEXT: InitFunctions:
; RELOC-NEXT: - Priority: 101 ; RELOC-NEXT: - Priority: 101
; RELOC-NEXT: Symbol: 0 ; RELOC-NEXT: Symbol: 0
; RELOC-NEXT: - Priority: 101 ; RELOC-NEXT: - Priority: 101
; RELOC-NEXT: Symbol: 1 ; RELOC-NEXT: Symbol: 1
; RELOC-NEXT: - Priority: 101 ; RELOC-NEXT: - Priority: 101
; RELOC-NEXT: Symbol: 7 ; RELOC-NEXT: Symbol: 13
; RELOC-NEXT: - Priority: 101 ; RELOC-NEXT: - Priority: 101
; RELOC-NEXT: Symbol: 15 ; RELOC-NEXT: Symbol: 9
; RELOC-NEXT: - Priority: 101 ; RELOC-NEXT: - Priority: 101
; RELOC-NEXT: Symbol: 19 ; RELOC-NEXT: Symbol: 19
; RELOC-NEXT: - Priority: 202 ; RELOC-NEXT: - Priority: 202
; RELOC-NEXT: Symbol: 15 ; RELOC-NEXT: Symbol: 9
; RELOC-NEXT: - Priority: 202 ; RELOC-NEXT: - Priority: 202
; RELOC-NEXT: Symbol: 21 ; RELOC-NEXT: Symbol: 21
; RELOC-NEXT: - Priority: 1001 ; RELOC-NEXT: - Priority: 1001
; RELOC-NEXT: Symbol: 0 ; RELOC-NEXT: Symbol: 0
; RELOC-NEXT: - Priority: 1001 ; RELOC-NEXT: - Priority: 1001
; RELOC-NEXT: Symbol: 10
; RELOC-NEXT: - Priority: 2002
; RELOC-NEXT: Symbol: 15 ; RELOC-NEXT: Symbol: 15
; RELOC-NEXT: - Priority: 2002 ; RELOC-NEXT: - Priority: 2002
; RELOC-NEXT: Symbol: 9
; RELOC-NEXT: - Priority: 2002
; RELOC-NEXT: Symbol: 23 ; RELOC-NEXT: Symbol: 23
; RELOC-NEXT: - Priority: 4000 ; RELOC-NEXT: - Priority: 4000
; RELOC-NEXT: Symbol: 14 ; RELOC-NEXT: Symbol: 8
; RELOC-NEXT: - Priority: 4000 ; RELOC-NEXT: - Priority: 4000
; RELOC-NEXT: Symbol: 13 ; RELOC-NEXT: Symbol: 17
; 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: externDtor ; RELOC-NEXT: Name: externDtor
; RELOC-NEXT: - Index: 1 ; RELOC-NEXT: - Index: 1

152
deps/lld/test/wasm/locals-duplicate.test vendored
View File

@ -270,40 +270,40 @@
; 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: 4 ; RELOC-NEXT: Index: 18
; 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: 6 ; RELOC-NEXT: Index: 3
; 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: 8 ; RELOC-NEXT: Index: 19
; 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: 16
; 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: 0
; 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: 17
; 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: 16 ; RELOC-NEXT: Index: 10
; 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: 18 ; RELOC-NEXT: Index: 22
; 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: 20 ; RELOC-NEXT: Index: 23
; 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: 12 ; RELOC-NEXT: Index: 8
; 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: 13 ; RELOC-NEXT: Index: 20
; 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: 14 ; RELOC-NEXT: Index: 21
; RELOC-NEXT: Offset: 0x00000085 ; RELOC-NEXT: Offset: 0x00000085
; RELOC-NEXT: Functions: ; RELOC-NEXT: Functions:
; RELOC-NEXT: - Index: 0 ; RELOC-NEXT: - Index: 0
@ -386,133 +386,133 @@
; RELOC-NEXT: SymbolTable: ; RELOC-NEXT: SymbolTable:
; RELOC-NEXT: - Index: 0 ; RELOC-NEXT: - Index: 0
; RELOC-NEXT: Kind: FUNCTION ; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: colliding_func1
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: Function: 0
; RELOC-NEXT: - Index: 1
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: colliding_func2 ; RELOC-NEXT: Name: colliding_func2
; RELOC-NEXT: Flags: [ ] ; RELOC-NEXT: Flags: [ ]
; RELOC-NEXT: Function: 1 ; RELOC-NEXT: Function: 1
; RELOC-NEXT: - Index: 2 ; RELOC-NEXT: - Index: 1
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: colliding_func3
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: Function: 2
; RELOC-NEXT: - Index: 3
; RELOC-NEXT: Kind: FUNCTION ; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: get_global1A ; RELOC-NEXT: Name: get_global1A
; RELOC-NEXT: Flags: [ ] ; RELOC-NEXT: Flags: [ ]
; RELOC-NEXT: Function: 3 ; RELOC-NEXT: Function: 3
; RELOC-NEXT: - Index: 4 ; RELOC-NEXT: - Index: 2
; RELOC-NEXT: Kind: DATA
; RELOC-NEXT: Name: colliding_global1
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: Segment: 0
; RELOC-NEXT: Size: 4
; RELOC-NEXT: - Index: 5
; RELOC-NEXT: Kind: FUNCTION ; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: get_global2A ; RELOC-NEXT: Name: get_global2A
; RELOC-NEXT: Flags: [ ] ; RELOC-NEXT: Flags: [ ]
; RELOC-NEXT: Function: 4 ; RELOC-NEXT: Function: 4
; RELOC-NEXT: - Index: 6 ; RELOC-NEXT: - Index: 3
; RELOC-NEXT: Kind: DATA ; RELOC-NEXT: Kind: DATA
; RELOC-NEXT: Name: colliding_global2 ; RELOC-NEXT: Name: colliding_global2
; RELOC-NEXT: Flags: [ ] ; RELOC-NEXT: Flags: [ ]
; RELOC-NEXT: Segment: 1 ; RELOC-NEXT: Segment: 1
; RELOC-NEXT: Size: 4 ; RELOC-NEXT: Size: 4
; RELOC-NEXT: - Index: 7 ; RELOC-NEXT: - Index: 4
; RELOC-NEXT: Kind: FUNCTION ; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: get_global3A ; RELOC-NEXT: Name: get_global3A
; RELOC-NEXT: Flags: [ ] ; RELOC-NEXT: Flags: [ ]
; RELOC-NEXT: Function: 5 ; RELOC-NEXT: Function: 5
; RELOC-NEXT: - Index: 8 ; RELOC-NEXT: - Index: 5
; RELOC-NEXT: Kind: DATA
; RELOC-NEXT: Name: colliding_global3
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: Segment: 2
; RELOC-NEXT: Size: 4
; RELOC-NEXT: - Index: 9
; RELOC-NEXT: Kind: FUNCTION ; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: get_func1A ; RELOC-NEXT: Name: get_func1A
; RELOC-NEXT: Flags: [ ] ; RELOC-NEXT: Flags: [ ]
; RELOC-NEXT: Function: 6 ; RELOC-NEXT: Function: 6
; RELOC-NEXT: - Index: 10 ; RELOC-NEXT: - Index: 6
; RELOC-NEXT: Kind: FUNCTION ; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: get_func2A ; RELOC-NEXT: Name: get_func2A
; RELOC-NEXT: Flags: [ ] ; RELOC-NEXT: Flags: [ ]
; RELOC-NEXT: Function: 7 ; RELOC-NEXT: Function: 7
; RELOC-NEXT: - Index: 11 ; RELOC-NEXT: - Index: 7
; RELOC-NEXT: Kind: FUNCTION ; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: get_func3A ; RELOC-NEXT: Name: get_func3A
; RELOC-NEXT: Flags: [ ] ; RELOC-NEXT: Flags: [ ]
; RELOC-NEXT: Function: 8 ; RELOC-NEXT: Function: 8
; RELOC-NEXT: - Index: 12 ; RELOC-NEXT: - Index: 8
; RELOC-NEXT: Kind: FUNCTION ; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: colliding_func1 ; RELOC-NEXT: Name: colliding_func1
; RELOC-NEXT: Flags: [ ] ; RELOC-NEXT: Flags: [ ]
; RELOC-NEXT: Function: 9 ; RELOC-NEXT: Function: 9
; RELOC-NEXT: - Index: 13 ; RELOC-NEXT: - Index: 9
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: colliding_func2
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: Function: 10
; RELOC-NEXT: - Index: 14
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: colliding_func3
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: Function: 11
; RELOC-NEXT: - Index: 15
; RELOC-NEXT: Kind: FUNCTION ; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: get_global1B ; RELOC-NEXT: Name: get_global1B
; RELOC-NEXT: Flags: [ ] ; RELOC-NEXT: Flags: [ ]
; RELOC-NEXT: Function: 12 ; RELOC-NEXT: Function: 12
; RELOC-NEXT: - Index: 16 ; RELOC-NEXT: - Index: 10
; RELOC-NEXT: Kind: DATA ; RELOC-NEXT: Kind: DATA
; RELOC-NEXT: Name: colliding_global1 ; RELOC-NEXT: Name: colliding_global1
; RELOC-NEXT: Flags: [ ] ; RELOC-NEXT: Flags: [ ]
; RELOC-NEXT: Segment: 0 ; RELOC-NEXT: Segment: 0
; RELOC-NEXT: Offset: 4 ; RELOC-NEXT: Offset: 4
; RELOC-NEXT: Size: 4 ; RELOC-NEXT: Size: 4
; RELOC-NEXT: - Index: 17 ; RELOC-NEXT: - Index: 11
; RELOC-NEXT: Kind: FUNCTION ; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: get_global2B ; RELOC-NEXT: Name: get_global2B
; RELOC-NEXT: Flags: [ ] ; RELOC-NEXT: Flags: [ ]
; RELOC-NEXT: Function: 13 ; RELOC-NEXT: Function: 13
; RELOC-NEXT: - Index: 12
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: get_global3B
; RELOC-NEXT: Flags: [ ]
; RELOC-NEXT: Function: 14
; RELOC-NEXT: - Index: 13
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: get_func1B
; RELOC-NEXT: Flags: [ ]
; RELOC-NEXT: Function: 15
; RELOC-NEXT: - Index: 14
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: get_func2B
; RELOC-NEXT: Flags: [ ]
; RELOC-NEXT: Function: 16
; RELOC-NEXT: - Index: 15
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: get_func3B
; RELOC-NEXT: Flags: [ ]
; RELOC-NEXT: Function: 17
; RELOC-NEXT: - Index: 16
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: colliding_func1
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: Function: 0
; RELOC-NEXT: - Index: 17
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: colliding_func3
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: Function: 2
; RELOC-NEXT: - Index: 18 ; RELOC-NEXT: - Index: 18
; RELOC-NEXT: Kind: DATA ; RELOC-NEXT: Kind: DATA
; RELOC-NEXT: Name: colliding_global1
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: Segment: 0
; RELOC-NEXT: Size: 4
; RELOC-NEXT: - Index: 19
; RELOC-NEXT: Kind: DATA
; RELOC-NEXT: Name: colliding_global3
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: Segment: 2
; RELOC-NEXT: Size: 4
; RELOC-NEXT: - Index: 20
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: colliding_func2
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: Function: 10
; RELOC-NEXT: - Index: 21
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: colliding_func3
; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: Function: 11
; RELOC-NEXT: - Index: 22
; RELOC-NEXT: Kind: DATA
; RELOC-NEXT: Name: colliding_global2 ; RELOC-NEXT: Name: colliding_global2
; RELOC-NEXT: Flags: [ BINDING_LOCAL ] ; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: Segment: 1 ; RELOC-NEXT: Segment: 1
; RELOC-NEXT: Offset: 4 ; RELOC-NEXT: Offset: 4
; RELOC-NEXT: Size: 4 ; RELOC-NEXT: Size: 4
; RELOC-NEXT: - Index: 19 ; RELOC-NEXT: - Index: 23
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: get_global3B
; RELOC-NEXT: Flags: [ ]
; RELOC-NEXT: Function: 14
; RELOC-NEXT: - Index: 20
; RELOC-NEXT: Kind: DATA ; RELOC-NEXT: Kind: DATA
; RELOC-NEXT: Name: colliding_global3 ; RELOC-NEXT: Name: colliding_global3
; RELOC-NEXT: Flags: [ BINDING_LOCAL ] ; RELOC-NEXT: Flags: [ BINDING_LOCAL ]
; RELOC-NEXT: Segment: 2 ; RELOC-NEXT: Segment: 2
; RELOC-NEXT: Offset: 4 ; RELOC-NEXT: Offset: 4
; RELOC-NEXT: Size: 4 ; RELOC-NEXT: Size: 4
; RELOC-NEXT: - Index: 21
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: get_func1B
; RELOC-NEXT: Flags: [ ]
; RELOC-NEXT: Function: 15
; RELOC-NEXT: - Index: 22
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: get_func2B
; RELOC-NEXT: Flags: [ ]
; RELOC-NEXT: Function: 16
; RELOC-NEXT: - Index: 23
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: get_func3B
; RELOC-NEXT: Flags: [ ]
; RELOC-NEXT: Function: 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

36
deps/lld/test/wasm/lto/relocatable-undefined.ll vendored Normal file
View File

@ -0,0 +1,36 @@
; RUN: llvm-as %s -o %t.o
; RUN: wasm-ld -r -o %t.wasm %t.o
; RUN: obj2yaml %t.wasm | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown"
@missing_data = external global i32
declare i32 @missing_func() local_unnamed_addr
define i32 @foo() {
entry:
%0 = call i32 @missing_func()
%1 = load i32, i32* @missing_data, align 4
ret i32 %1
}
; CHECK: - Type: CUSTOM
; CHECK-NEXT: Name: linking
; CHECK-NEXT: Version: 2
; CHECK-NEXT: SymbolTable:
; CHECK-NEXT: - Index: 0
; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Name: missing_func
; CHECK-NEXT: Flags: [ UNDEFINED ]
; CHECK-NEXT: Function: 0
; CHECK-NEXT: - Index: 1
; CHECK-NEXT: Kind: FUNCTION
; CHECK-NEXT: Name: foo
; CHECK-NEXT: Flags: [ ]
; CHECK-NEXT: Function: 1
; CHECK-NEXT: - Index: 2
; CHECK-NEXT: Kind: DATA
; CHECK-NEXT: Name: missing_data
; CHECK-NEXT: Flags: [ UNDEFINED ]

28
deps/lld/test/wasm/weak-alias.ll vendored
View File

@ -187,13 +187,13 @@ entry:
; 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: 4 ; RELOC-NEXT: Index: 1
; 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: 1 ; RELOC-NEXT: Index: 2
; RELOC-NEXT: Offset: 0x00000013 ; RELOC-NEXT: Offset: 0x00000013
; RELOC-NEXT: - Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB
; RELOC-NEXT: Index: 4 ; RELOC-NEXT: Index: 1
; RELOC-NEXT: Offset: 0x0000001C ; RELOC-NEXT: Offset: 0x0000001C
; RELOC-NEXT: - Type: R_WEBASSEMBLY_GLOBAL_INDEX_LEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_GLOBAL_INDEX_LEB
; RELOC-NEXT: Index: 6 ; RELOC-NEXT: Index: 6
@ -202,10 +202,10 @@ entry:
; RELOC-NEXT: Index: 6 ; RELOC-NEXT: Index: 6
; RELOC-NEXT: Offset: 0x00000032 ; RELOC-NEXT: Offset: 0x00000032
; RELOC-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB
; RELOC-NEXT: Index: 4 ; RELOC-NEXT: Index: 1
; RELOC-NEXT: Offset: 0x0000003A ; RELOC-NEXT: Offset: 0x0000003A
; RELOC-NEXT: - Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB
; RELOC-NEXT: Index: 4 ; RELOC-NEXT: Index: 1
; RELOC-NEXT: Offset: 0x00000043 ; RELOC-NEXT: Offset: 0x00000043
; RELOC-NEXT: - Type: R_WEBASSEMBLY_GLOBAL_INDEX_LEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_GLOBAL_INDEX_LEB
; RELOC-NEXT: Index: 6 ; RELOC-NEXT: Index: 6
@ -217,10 +217,10 @@ entry:
; RELOC-NEXT: Index: 6 ; RELOC-NEXT: Index: 6
; RELOC-NEXT: Offset: 0x00000068 ; RELOC-NEXT: Offset: 0x00000068
; RELOC-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB
; RELOC-NEXT: Index: 1 ; RELOC-NEXT: Index: 2
; RELOC-NEXT: Offset: 0x00000070 ; RELOC-NEXT: Offset: 0x00000070
; RELOC-NEXT: - Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB
; RELOC-NEXT: Index: 1 ; RELOC-NEXT: Index: 2
; RELOC-NEXT: Offset: 0x00000079 ; RELOC-NEXT: Offset: 0x00000079
; RELOC-NEXT: - Type: R_WEBASSEMBLY_GLOBAL_INDEX_LEB ; RELOC-NEXT: - Type: R_WEBASSEMBLY_GLOBAL_INDEX_LEB
; RELOC-NEXT: Index: 6 ; RELOC-NEXT: Index: 6
@ -259,24 +259,24 @@ entry:
; RELOC-NEXT: Function: 0 ; RELOC-NEXT: Function: 0
; RELOC-NEXT: - Index: 1 ; RELOC-NEXT: - Index: 1
; RELOC-NEXT: Kind: FUNCTION ; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: alias_fn
; RELOC-NEXT: Flags: [ BINDING_WEAK ]
; RELOC-NEXT: Function: 1
; RELOC-NEXT: - Index: 2
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: direct_fn ; RELOC-NEXT: Name: direct_fn
; RELOC-NEXT: Flags: [ ] ; RELOC-NEXT: Flags: [ ]
; RELOC-NEXT: Function: 1 ; RELOC-NEXT: Function: 1
; RELOC-NEXT: - Index: 2 ; RELOC-NEXT: - Index: 3
; RELOC-NEXT: Kind: FUNCTION ; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: call_direct ; RELOC-NEXT: Name: call_direct
; RELOC-NEXT: Flags: [ ] ; RELOC-NEXT: Flags: [ ]
; RELOC-NEXT: Function: 2 ; RELOC-NEXT: Function: 2
; RELOC-NEXT: - Index: 3 ; RELOC-NEXT: - Index: 4
; RELOC-NEXT: Kind: FUNCTION ; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: call_alias ; RELOC-NEXT: Name: call_alias
; RELOC-NEXT: Flags: [ ] ; RELOC-NEXT: Flags: [ ]
; RELOC-NEXT: Function: 3 ; RELOC-NEXT: Function: 3
; RELOC-NEXT: - Index: 4
; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: alias_fn
; RELOC-NEXT: Flags: [ BINDING_WEAK ]
; RELOC-NEXT: Function: 1
; RELOC-NEXT: - Index: 5 ; RELOC-NEXT: - Index: 5
; RELOC-NEXT: Kind: FUNCTION ; RELOC-NEXT: Kind: FUNCTION
; RELOC-NEXT: Name: call_alias_ptr ; RELOC-NEXT: Name: call_alias_ptr

4
deps/lld/wasm/Driver.cpp vendored
View File

@ -434,7 +434,9 @@ static Symbol *handleUndefined(StringRef Name) {
static UndefinedGlobal * static UndefinedGlobal *
createUndefinedGlobal(StringRef Name, llvm::wasm::WasmGlobalType *Type) { createUndefinedGlobal(StringRef Name, llvm::wasm::WasmGlobalType *Type) {
auto *Sym = auto *Sym =
cast<UndefinedGlobal>(Symtab->addUndefinedGlobal(Name, 0, nullptr, Type)); cast<UndefinedGlobal>(Symtab->addUndefinedGlobal(Name, Name,
DefaultModule, 0,
nullptr, Type));
Config->AllowUndefinedSymbols.insert(Sym->getName()); Config->AllowUndefinedSymbols.insert(Sym->getName());
Sym->IsUsedInRegularObj = true; Sym->IsUsedInRegularObj = true;
return Sym; return Sym;

6
deps/lld/wasm/InputChunks.cpp vendored
View File

@ -23,7 +23,7 @@ using namespace llvm::support::endian;
using namespace lld; using namespace lld;
using namespace lld::wasm; using namespace lld::wasm;
static StringRef ReloctTypeToString(uint8_t RelocType) { static StringRef reloctTypeToString(uint8_t RelocType) {
switch (RelocType) { switch (RelocType) {
#define WASM_RELOC(NAME, REL) \ #define WASM_RELOC(NAME, REL) \
case REL: \ case REL: \
@ -77,7 +77,7 @@ void InputChunk::verifyRelocTargets() const {
warn("expected LEB at relocation site be 5-byte padded"); warn("expected LEB at relocation site be 5-byte padded");
uint32_t ExpectedValue = File->calcExpectedValue(Rel); uint32_t ExpectedValue = File->calcExpectedValue(Rel);
if (ExpectedValue != ExistingValue) if (ExpectedValue != ExistingValue)
warn("unexpected existing value for " + ReloctTypeToString(Rel.Type) + warn("unexpected existing value for " + reloctTypeToString(Rel.Type) +
": existing=" + Twine(ExistingValue) + ": existing=" + Twine(ExistingValue) +
" expected=" + Twine(ExpectedValue)); " expected=" + Twine(ExpectedValue));
} }
@ -103,7 +103,7 @@ void InputChunk::writeTo(uint8_t *Buf) const {
for (const WasmRelocation &Rel : Relocations) { for (const WasmRelocation &Rel : Relocations) {
uint8_t *Loc = Buf + Rel.Offset + Off; uint8_t *Loc = Buf + Rel.Offset + Off;
uint32_t Value = File->calcNewValue(Rel); uint32_t Value = File->calcNewValue(Rel);
LLVM_DEBUG(dbgs() << "apply reloc: type=" << ReloctTypeToString(Rel.Type) LLVM_DEBUG(dbgs() << "apply reloc: type=" << reloctTypeToString(Rel.Type)
<< " addend=" << Rel.Addend << " index=" << Rel.Index << " addend=" << Rel.Addend << " index=" << Rel.Index
<< " value=" << Value << " offset=" << Rel.Offset << " value=" << Value << " offset=" << Rel.Offset
<< "\n"); << "\n");

11
deps/lld/wasm/InputFiles.cpp vendored
View File

@ -377,11 +377,15 @@ Symbol *ObjFile::createUndefined(const WasmSymbol &Sym) {
switch (Sym.Info.Kind) { switch (Sym.Info.Kind) {
case WASM_SYMBOL_TYPE_FUNCTION: case WASM_SYMBOL_TYPE_FUNCTION:
return Symtab->addUndefinedFunction(Name, Flags, this, Sym.Signature); return Symtab->addUndefinedFunction(Name, Sym.Info.ImportName,
Sym.Info.ImportModule, Flags, this,
Sym.Signature);
case WASM_SYMBOL_TYPE_DATA: case WASM_SYMBOL_TYPE_DATA:
return Symtab->addUndefinedData(Name, Flags, this); return Symtab->addUndefinedData(Name, Flags, this);
case WASM_SYMBOL_TYPE_GLOBAL: case WASM_SYMBOL_TYPE_GLOBAL:
return Symtab->addUndefinedGlobal(Name, Flags, this, Sym.GlobalType); return Symtab->addUndefinedGlobal(Name, Sym.Info.ImportName,
Sym.Info.ImportModule, Flags, this,
Sym.GlobalType);
case WASM_SYMBOL_TYPE_SECTION: case WASM_SYMBOL_TYPE_SECTION:
llvm_unreachable("section symbols cannot be undefined"); llvm_unreachable("section symbols cannot be undefined");
} }
@ -445,7 +449,8 @@ static Symbol *createBitcodeSymbol(const lto::InputFile::Symbol &ObjSym,
if (ObjSym.isUndefined()) { if (ObjSym.isUndefined()) {
if (ObjSym.isExecutable()) if (ObjSym.isExecutable())
return Symtab->addUndefinedFunction(Name, Flags, &F, nullptr); return Symtab->addUndefinedFunction(Name, Name, DefaultModule, Flags, &F,
nullptr);
return Symtab->addUndefinedData(Name, Flags, &F); return Symtab->addUndefinedData(Name, Flags, &F);
} }

5
deps/lld/wasm/LTO.cpp vendored
View File

@ -79,8 +79,9 @@ BitcodeCompiler::~BitcodeCompiler() = default;
static void undefine(Symbol *S) { static void undefine(Symbol *S) {
if (auto F = dyn_cast<DefinedFunction>(S)) if (auto F = dyn_cast<DefinedFunction>(S))
replaceSymbol<UndefinedFunction>(F, F->getName(), 0, F->getFile(), replaceSymbol<UndefinedFunction>(F, F->getName(), F->getName(),
F->Signature); DefaultModule, 0,
F->getFile(), F->Signature);
else if (isa<DefinedData>(S)) else if (isa<DefinedData>(S))
replaceSymbol<UndefinedData>(S, S->getName(), 0, S->getFile()); replaceSymbol<UndefinedData>(S, S->getName(), 0, S->getFile());
else else

1
deps/lld/wasm/LTO.h vendored
View File

@ -23,6 +23,7 @@
#include "lld/Common/LLVM.h" #include "lld/Common/LLVM.h"
#include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallString.h"
#include "Writer.h"
#include <memory> #include <memory>
#include <vector> #include <vector>

2
deps/lld/wasm/MarkLive.cpp vendored
View File

@ -85,7 +85,7 @@ void lld::wasm::markLive() {
// equal to null pointer, only reachable via direct call). // equal to null pointer, only reachable via direct call).
if (Reloc.Type == R_WEBASSEMBLY_TABLE_INDEX_SLEB || if (Reloc.Type == R_WEBASSEMBLY_TABLE_INDEX_SLEB ||
Reloc.Type == R_WEBASSEMBLY_TABLE_INDEX_I32) { Reloc.Type == R_WEBASSEMBLY_TABLE_INDEX_I32) {
FunctionSymbol *FuncSym = cast<FunctionSymbol>(Sym); auto *FuncSym = cast<FunctionSymbol>(Sym);
if (FuncSym->hasTableIndex() && FuncSym->getTableIndex() == 0) if (FuncSym->hasTableIndex() && FuncSym->getTableIndex() == 0)
continue; continue;
} }

14
deps/lld/wasm/SymbolTable.cpp vendored
View File

@ -314,8 +314,9 @@ Symbol *SymbolTable::addDefinedEvent(StringRef Name, uint32_t Flags,
return S; return S;
} }
Symbol *SymbolTable::addUndefinedFunction(StringRef Name, uint32_t Flags, Symbol *SymbolTable::addUndefinedFunction(StringRef Name, StringRef ImportName,
InputFile *File, StringRef ImportModule,
uint32_t Flags, InputFile *File,
const WasmSignature *Sig) { const WasmSignature *Sig) {
LLVM_DEBUG(dbgs() << "addUndefinedFunction: " << Name << LLVM_DEBUG(dbgs() << "addUndefinedFunction: " << Name <<
" [" << (Sig ? toString(*Sig) : "none") << "]\n"); " [" << (Sig ? toString(*Sig) : "none") << "]\n");
@ -325,7 +326,8 @@ Symbol *SymbolTable::addUndefinedFunction(StringRef Name, uint32_t Flags,
std::tie(S, WasInserted) = insert(Name, File); std::tie(S, WasInserted) = insert(Name, File);
if (WasInserted) if (WasInserted)
replaceSymbol<UndefinedFunction>(S, Name, Flags, File, Sig); replaceSymbol<UndefinedFunction>(S, Name, ImportName, ImportModule, Flags,
File, Sig);
else if (auto *Lazy = dyn_cast<LazySymbol>(S)) else if (auto *Lazy = dyn_cast<LazySymbol>(S))
Lazy->fetch(); Lazy->fetch();
else else
@ -351,7 +353,8 @@ Symbol *SymbolTable::addUndefinedData(StringRef Name, uint32_t Flags,
return S; return S;
} }
Symbol *SymbolTable::addUndefinedGlobal(StringRef Name, uint32_t Flags, Symbol *SymbolTable::addUndefinedGlobal(StringRef Name, StringRef ImportName,
StringRef ImportModule, uint32_t Flags,
InputFile *File, InputFile *File,
const WasmGlobalType *Type) { const WasmGlobalType *Type) {
LLVM_DEBUG(dbgs() << "addUndefinedGlobal: " << Name << "\n"); LLVM_DEBUG(dbgs() << "addUndefinedGlobal: " << Name << "\n");
@ -361,7 +364,8 @@ Symbol *SymbolTable::addUndefinedGlobal(StringRef Name, uint32_t Flags,
std::tie(S, WasInserted) = insert(Name, File); std::tie(S, WasInserted) = insert(Name, File);
if (WasInserted) if (WasInserted)
replaceSymbol<UndefinedGlobal>(S, Name, Flags, File, Type); replaceSymbol<UndefinedGlobal>(S, Name, ImportName, ImportModule, Flags,
File, Type);
else if (auto *Lazy = dyn_cast<LazySymbol>(S)) else if (auto *Lazy = dyn_cast<LazySymbol>(S))
Lazy->fetch(); Lazy->fetch();
else if (S->isDefined()) else if (S->isDefined())

10
deps/lld/wasm/SymbolTable.h vendored
View File

@ -59,11 +59,13 @@ public:
Symbol *addDefinedEvent(StringRef Name, uint32_t Flags, InputFile *File, Symbol *addDefinedEvent(StringRef Name, uint32_t Flags, InputFile *File,
InputEvent *E); InputEvent *E);
Symbol *addUndefinedFunction(StringRef Name, uint32_t Flags, InputFile *File, Symbol *addUndefinedFunction(StringRef Name, StringRef ImportName,
const WasmSignature *Signature); StringRef ImportModule, uint32_t Flags,
InputFile *File, const WasmSignature *Signature);
Symbol *addUndefinedData(StringRef Name, uint32_t Flags, InputFile *File); Symbol *addUndefinedData(StringRef Name, uint32_t Flags, InputFile *File);
Symbol *addUndefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File, Symbol *addUndefinedGlobal(StringRef Name, StringRef ImportName,
const WasmGlobalType *Type); StringRef ImportModule, uint32_t Flags,
InputFile *File, const WasmGlobalType *Type);
void addLazy(ArchiveFile *F, const llvm::object::Archive::Symbol *Sym); void addLazy(ArchiveFile *F, const llvm::object::Archive::Symbol *Sym);

19
deps/lld/wasm/Symbols.h vendored
View File

@ -149,13 +149,19 @@ public:
class UndefinedFunction : public FunctionSymbol { class UndefinedFunction : public FunctionSymbol {
public: public:
UndefinedFunction(StringRef Name, uint32_t Flags, InputFile *File = nullptr, UndefinedFunction(StringRef Name, StringRef ImportName,
StringRef ImportModule, uint32_t Flags,
InputFile *File = nullptr,
const WasmSignature *Type = nullptr) const WasmSignature *Type = nullptr)
: FunctionSymbol(Name, UndefinedFunctionKind, Flags, File, Type) {} : FunctionSymbol(Name, UndefinedFunctionKind, Flags, File, Type),
ImportName(ImportName), ImportModule(ImportModule) {}
static bool classof(const Symbol *S) { static bool classof(const Symbol *S) {
return S->kind() == UndefinedFunctionKind; return S->kind() == UndefinedFunctionKind;
} }
StringRef ImportName;
StringRef ImportModule;
}; };
class SectionSymbol : public Symbol { class SectionSymbol : public Symbol {
@ -261,13 +267,18 @@ public:
class UndefinedGlobal : public GlobalSymbol { class UndefinedGlobal : public GlobalSymbol {
public: public:
UndefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File = nullptr, UndefinedGlobal(StringRef Name, StringRef ImportName, StringRef ImportModule,
uint32_t Flags, InputFile *File = nullptr,
const WasmGlobalType *Type = nullptr) const WasmGlobalType *Type = nullptr)
: GlobalSymbol(Name, UndefinedGlobalKind, Flags, File, Type) {} : GlobalSymbol(Name, UndefinedGlobalKind, Flags, File, Type),
ImportName(ImportName), ImportModule(ImportModule) {}
static bool classof(const Symbol *S) { static bool classof(const Symbol *S) {
return S->kind() == UndefinedGlobalKind; return S->kind() == UndefinedGlobalKind;
} }
StringRef ImportName;
StringRef ImportModule;
}; };
// Wasm events are features that suspend the current execution and transfer the // Wasm events are features that suspend the current execution and transfer the

108
deps/lld/wasm/Writer.cpp vendored
View File

@ -39,8 +39,9 @@ using namespace llvm::wasm;
using namespace lld; using namespace lld;
using namespace lld::wasm; using namespace lld::wasm;
static constexpr int kStackAlignment = 16; static constexpr int StackAlignment = 16;
static constexpr const char *kFunctionTableName = "__indirect_function_table"; static constexpr const char *FunctionTableName = "__indirect_function_table";
const char *lld::wasm::DefaultModule = "env";
namespace { namespace {
@ -155,7 +156,7 @@ void Writer::createImportSection() {
if (Config->ImportMemory) { if (Config->ImportMemory) {
WasmImport Import; WasmImport Import;
Import.Module = "env"; Import.Module = DefaultModule;
Import.Field = "memory"; Import.Field = "memory";
Import.Kind = WASM_EXTERNAL_MEMORY; Import.Kind = WASM_EXTERNAL_MEMORY;
Import.Memory.Flags = 0; Import.Memory.Flags = 0;
@ -172,8 +173,8 @@ void Writer::createImportSection() {
if (Config->ImportTable) { if (Config->ImportTable) {
uint32_t TableSize = TableBase + IndirectFunctions.size(); uint32_t TableSize = TableBase + IndirectFunctions.size();
WasmImport Import; WasmImport Import;
Import.Module = "env"; Import.Module = DefaultModule;
Import.Field = kFunctionTableName; Import.Field = FunctionTableName;
Import.Kind = WASM_EXTERNAL_TABLE; Import.Kind = WASM_EXTERNAL_TABLE;
Import.Table.ElemType = WASM_TYPE_FUNCREF; Import.Table.ElemType = WASM_TYPE_FUNCREF;
Import.Table.Limits = {0, TableSize, 0}; Import.Table.Limits = {0, TableSize, 0};
@ -182,8 +183,17 @@ void Writer::createImportSection() {
for (const Symbol *Sym : ImportedSymbols) { for (const Symbol *Sym : ImportedSymbols) {
WasmImport Import; WasmImport Import;
Import.Module = "env"; if (auto *F = dyn_cast<UndefinedFunction>(Sym)) {
Import.Field = Sym->getName(); Import.Field = F->ImportName;
Import.Module = F->ImportModule;
} else if (auto *G = dyn_cast<UndefinedGlobal>(Sym)) {
Import.Field = G->ImportName;
Import.Module = G->ImportModule;
} else {
Import.Field = Sym->getName();
Import.Module = DefaultModule;
}
if (auto *FunctionSym = dyn_cast<FunctionSymbol>(Sym)) { if (auto *FunctionSym = dyn_cast<FunctionSymbol>(Sym)) {
Import.Kind = WASM_EXTERNAL_FUNCTION; Import.Kind = WASM_EXTERNAL_FUNCTION;
Import.SigIndex = lookupType(*FunctionSym->Signature); Import.SigIndex = lookupType(*FunctionSym->Signature);
@ -441,6 +451,13 @@ static uint32_t getWasmFlags(const Symbol *Sym) {
Flags |= WASM_SYMBOL_VISIBILITY_HIDDEN; Flags |= WASM_SYMBOL_VISIBILITY_HIDDEN;
if (Sym->isUndefined()) if (Sym->isUndefined())
Flags |= WASM_SYMBOL_UNDEFINED; Flags |= WASM_SYMBOL_UNDEFINED;
if (auto *F = dyn_cast<UndefinedFunction>(Sym)) {
if (F->getName() != F->ImportName)
Flags |= WASM_SYMBOL_EXPLICIT_NAME;
} else if (auto *G = dyn_cast<UndefinedGlobal>(Sym)) {
if (G->getName() != G->ImportName)
Flags |= WASM_SYMBOL_EXPLICIT_NAME;
}
return Flags; return Flags;
} }
@ -506,15 +523,18 @@ void Writer::createLinkingSection() {
if (auto *F = dyn_cast<FunctionSymbol>(Sym)) { if (auto *F = dyn_cast<FunctionSymbol>(Sym)) {
writeUleb128(Sub.OS, F->getFunctionIndex(), "index"); writeUleb128(Sub.OS, F->getFunctionIndex(), "index");
if (Sym->isDefined()) if (Sym->isDefined() ||
(Flags & WASM_SYMBOL_EXPLICIT_NAME) != 0)
writeStr(Sub.OS, Sym->getName(), "sym name"); writeStr(Sub.OS, Sym->getName(), "sym name");
} else if (auto *G = dyn_cast<GlobalSymbol>(Sym)) { } else if (auto *G = dyn_cast<GlobalSymbol>(Sym)) {
writeUleb128(Sub.OS, G->getGlobalIndex(), "index"); writeUleb128(Sub.OS, G->getGlobalIndex(), "index");
if (Sym->isDefined()) if (Sym->isDefined() ||
(Flags & WASM_SYMBOL_EXPLICIT_NAME) != 0)
writeStr(Sub.OS, Sym->getName(), "sym name"); writeStr(Sub.OS, Sym->getName(), "sym name");
} else if (auto *E = dyn_cast<EventSymbol>(Sym)) { } else if (auto *E = dyn_cast<EventSymbol>(Sym)) {
writeUleb128(Sub.OS, E->getEventIndex(), "index"); writeUleb128(Sub.OS, E->getEventIndex(), "index");
if (Sym->isDefined()) if (Sym->isDefined() ||
(Flags & WASM_SYMBOL_EXPLICIT_NAME) != 0)
writeStr(Sub.OS, Sym->getName(), "sym name"); writeStr(Sub.OS, Sym->getName(), "sym name");
} else if (isa<DataSymbol>(Sym)) { } else if (isa<DataSymbol>(Sym)) {
writeStr(Sub.OS, Sym->getName(), "sym name"); writeStr(Sub.OS, Sym->getName(), "sym name");
@ -663,9 +683,9 @@ void Writer::layoutMemory() {
auto PlaceStack = [&]() { auto PlaceStack = [&]() {
if (Config->Relocatable || Config->Shared) if (Config->Relocatable || Config->Shared)
return; return;
MemoryPtr = alignTo(MemoryPtr, kStackAlignment); MemoryPtr = alignTo(MemoryPtr, StackAlignment);
if (Config->ZStackSize != alignTo(Config->ZStackSize, kStackAlignment)) if (Config->ZStackSize != alignTo(Config->ZStackSize, StackAlignment))
error("stack size must be " + Twine(kStackAlignment) + "-byte aligned"); error("stack size must be " + Twine(StackAlignment) + "-byte aligned");
log("mem: stack size = " + Twine(Config->ZStackSize)); log("mem: stack size = " + Twine(Config->ZStackSize));
log("mem: stack base = " + Twine(MemoryPtr)); log("mem: stack base = " + Twine(MemoryPtr));
MemoryPtr += Config->ZStackSize; MemoryPtr += Config->ZStackSize;
@ -814,7 +834,7 @@ void Writer::calculateExports() {
Exports.push_back(WasmExport{"memory", WASM_EXTERNAL_MEMORY, 0}); Exports.push_back(WasmExport{"memory", WASM_EXTERNAL_MEMORY, 0});
if (!Config->Relocatable && Config->ExportTable) if (!Config->Relocatable && Config->ExportTable)
Exports.push_back(WasmExport{kFunctionTableName, WASM_EXTERNAL_TABLE, 0}); Exports.push_back(WasmExport{FunctionTableName, WASM_EXTERNAL_TABLE, 0});
unsigned FakeGlobalIndex = NumImportedGlobals + InputGlobals.size(); unsigned FakeGlobalIndex = NumImportedGlobals + InputGlobals.size();
@ -858,40 +878,42 @@ void Writer::assignSymtab() {
StringMap<uint32_t> SectionSymbolIndices; StringMap<uint32_t> SectionSymbolIndices;
unsigned SymbolIndex = SymtabEntries.size(); unsigned SymbolIndex = SymtabEntries.size();
for (ObjFile *File : Symtab->ObjectFiles) {
LLVM_DEBUG(dbgs() << "Symtab entries: " << File->getName() << "\n");
for (Symbol *Sym : File->getSymbols()) {
if (Sym->getFile() != File)
continue;
if (auto *S = dyn_cast<SectionSymbol>(Sym)) { auto AddSymbol = [&](Symbol *Sym) {
StringRef Name = S->getName(); if (auto *S = dyn_cast<SectionSymbol>(Sym)) {
if (CustomSectionMapping.count(Name) == 0) StringRef Name = S->getName();
continue; if (CustomSectionMapping.count(Name) == 0)
return;
auto SSI = SectionSymbolIndices.find(Name); auto SSI = SectionSymbolIndices.find(Name);
if (SSI != SectionSymbolIndices.end()) { if (SSI != SectionSymbolIndices.end()) {
Sym->setOutputSymbolIndex(SSI->second); Sym->setOutputSymbolIndex(SSI->second);
continue; return;
}
SectionSymbolIndices[Name] = SymbolIndex;
CustomSectionSymbols[Name] = cast<SectionSymbol>(Sym);
Sym->markLive();
} }
// (Since this is relocatable output, GC is not performed so symbols must SectionSymbolIndices[Name] = SymbolIndex;
// be live.) CustomSectionSymbols[Name] = cast<SectionSymbol>(Sym);
assert(Sym->isLive());
Sym->setOutputSymbolIndex(SymbolIndex++);
SymtabEntries.emplace_back(Sym);
}
}
// For the moment, relocatable output doesn't contain any synthetic functions, Sym->markLive();
// so no need to look through the Symtab for symbols not referenced by }
// Symtab->ObjectFiles.
// (Since this is relocatable output, GC is not performed so symbols must
// be live.)
assert(Sym->isLive());
Sym->setOutputSymbolIndex(SymbolIndex++);
SymtabEntries.emplace_back(Sym);
};
for (Symbol *Sym : Symtab->getSymbols())
if (!Sym->isLazy())
AddSymbol(Sym);
for (ObjFile *File : Symtab->ObjectFiles) {
LLVM_DEBUG(dbgs() << "Local symtab entries: " << File->getName() << "\n");
for (Symbol *Sym : File->getSymbols())
if (Sym->isLocal())
AddSymbol(Sym);
}
} }
uint32_t Writer::lookupType(const WasmSignature &Sig) { uint32_t Writer::lookupType(const WasmSignature &Sig) {

2
deps/lld/wasm/Writer.h vendored
View File

@ -15,6 +15,8 @@ namespace wasm {
void writeResult(); void writeResult();
extern const char *DefaultModule;
} // namespace wasm } // namespace wasm
} // namespace lld } // namespace lld