This is an archive of the discontinued LLVM Phabricator instance.

Differential D75659

[llvm-objdump] --syms: make flags closer to GNU objdump
ClosedPublic

Authored by MaskRay on Mar 4 2020, 5:48 PM.

Details

Reviewers
grimar
jhenderson
rupprecht
• espindola
Commits
rGf9a0056016fb: [llvm-objdump] --syms: make flags closer to GNU objdump
Summary

This fixes several issues. The behavior changes are:

A SHN_COMMON symbol does not have the 'g' flag.
An undefined symbol does not have 'g' or 'l' flag.
A STB_GLOBAL SymbolRef::ST_Unknown symbol has the 'g' flag.
A STB_LOCAL SymbolRef::ST_Unknown symbol has the 'l' flag.

There are 30+ other lld tests need fixing.

Diff Detail

Event Timeline

MaskRay created this revision.Mar 4 2020, 5:48 PM
Herald added a reviewer: • espindola. · View Herald TranscriptMar 4 2020, 5:48 PM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: llvm-commits, aheejin, jgravelle-google and 3 others. · View Herald Transcript
Harbormaster failed remote builds in B48138: Diff 248362!Mar 4 2020, 6:31 PM
grimar added a comment.EditedMar 5 2020, 12:58 AM

It looks fine, I confirm I observe the same behavior with "GNU objdump (GNU Binutils for Ubuntu) 2.31.1".

There are 30+ other lld tests need fixing.

I think you can continue with this, perhaps worth to wait for a second opinion just in case.

rupprecht accepted this revision.Mar 5 2020, 9:18 AM
This revision is now accepted and ready to land.Mar 5 2020, 9:18 AM
Closed by commit rGf9a0056016fb: [llvm-objdump] --syms: make flags closer to GNU objdump (authored by MaskRay). · Explain WhyMar 5 2020, 10:24 AM
This revision was automatically updated to reflect the committed changes.
Herald added subscribers: atanasyan, jrtc27. · View Herald TranscriptMar 5 2020, 10:24 AM
MaskRay mentioned this in D75756: [llvm-objdump] Teach `llvm-objdump` dump dynamic symbols..Mar 6 2020, 9:09 AM
Higuoxing mentioned this in rG948ef5b1a604: [llvm-objdump] Teach `llvm-objdump` dump dynamic symbols..Apr 4 2020, 8:14 PM

Revision Contents

PathSize
lld/
test/
ELF/
2 lines
2 lines
14 lines
2 lines
2 lines
4 lines
linkerscript/
4 lines
10 lines
8 lines
2 lines
10 lines
2 lines
22 lines
4 lines
2 lines
16 lines
32 lines
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
4 lines
12 lines
4 lines
6 lines
6 lines
6 lines
4 lines
2 lines
4 lines
4 lines
4 lines
2 lines
4 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
10 lines
llvm/
test/
MC/
AArch64/
6 lines
6 lines
ARM/
4 lines
14 lines
10 lines
6 lines
AsmParser/
4 lines
Hexagon/
2 lines
4 lines
tools/
llvm-objdump/
WebAssembly/
4 lines
X86/
2 lines
6 lines
2 lines
tools/
llvm-objdump/
2 lines

Diff 248542

lld/test/ELF/arm-target1.s

Show All 20 Lines
.text .text
.word patatino(target1) .word patatino(target1)
patatino: patatino:
.word 32 .word 32
// Force generation of $d.0 as section is not all data // Force generation of $d.0 as section is not all data
nop nop
// RELATIVE: SYMBOL TABLE: // RELATIVE: SYMBOL TABLE:
// RELATIVE: 00001154 .text 00000000 patatino // RELATIVE: 00001154 l .text 00000000 patatino
// RELATIVE: Disassembly of section .text: // RELATIVE: Disassembly of section .text:
// RELATIVE-EMPTY: // RELATIVE-EMPTY:
// RELATIVE: $d.0: // RELATIVE: $d.0:
// RELATIVE: 1150: 04 00 00 00 .word 0x00000004 // RELATIVE: 1150: 04 00 00 00 .word 0x00000004
// ABS: can't create dynamic relocation R_ARM_TARGET1 against symbol: patatino in readonly segment; recompile object files with -fPIC or pass '-Wl,-z,notext' to allow text relocations in the output // ABS: can't create dynamic relocation R_ARM_TARGET1 against symbol: patatino in readonly segment; recompile object files with -fPIC or pass '-Wl,-z,notext' to allow text relocations in the output
// ABS: >>> defined in {{.*}}.o // ABS: >>> defined in {{.*}}.o
// ABS: >>> referenced by {{.*}}.o:(.text+0x0) // ABS: >>> referenced by {{.*}}.o:(.text+0x0)

lld/test/ELF/bss-start-common.s

# REQUIRES: x86 # REQUIRES: x86
# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
# RUN: ld.lld %t -o %t2 # RUN: ld.lld %t -o %t2
# RUN: llvm-objdump -t -section-headers %t2 | FileCheck %s # RUN: llvm-objdump -t -section-headers %t2 | FileCheck %s
## Test __bss_start is defined at the start of .bss ## Test __bss_start is defined at the start of .bss
# CHECK: Sections: # CHECK: Sections:
# CHECK: Idx Name Size VMA Type # CHECK: Idx Name Size VMA Type
# CHECK: 2 .bss 00000004 [[ADDR:[0-za-f]+]] BSS # CHECK: 2 .bss 00000004 [[ADDR:[0-za-f]+]] BSS
# CHECK: SYMBOL TABLE: # CHECK: SYMBOL TABLE:
# CHECK: [[ADDR]] .bss 0000000000000000 __bss_start # CHECK: [[ADDR]] g .bss 0000000000000000 __bss_start
.global __bss_start .global __bss_start
.text .text
_start: _start:
.comm sym1,4,4 .comm sym1,4,4

lld/test/ELF/edata-etext.s

Show All 12 Lines
## 4) Addresses of _edata == edata, _end == end and _etext == etext. ## 4) Addresses of _edata == edata, _end == end and _etext == etext.
# CHECK: Sections: # CHECK: Sections:
# CHECK-NEXT: Idx Name Size VMA Type # CHECK-NEXT: Idx Name Size VMA Type
# CHECK-NEXT: 0 00000000 0000000000000000 # CHECK-NEXT: 0 00000000 0000000000000000
# CHECK-NEXT: 1 .text 00000001 0000000000201158 TEXT # CHECK-NEXT: 1 .text 00000001 0000000000201158 TEXT
# CHECK-NEXT: 2 .data 00000002 0000000000202159 DATA # CHECK-NEXT: 2 .data 00000002 0000000000202159 DATA
# CHECK-NEXT: 3 .bss 00000006 000000000020215c BSS # CHECK-NEXT: 3 .bss 00000006 000000000020215c BSS
# CHECK: SYMBOL TABLE: # CHECK: SYMBOL TABLE:
# CHECK-NEXT: 000000000020215b .data 0000000000000000 _edata # CHECK-NEXT: 000000000020215b g .data 0000000000000000 _edata
# CHECK-NEXT: 0000000000202162 .bss 0000000000000000 _end # CHECK-NEXT: 0000000000202162 g .bss 0000000000000000 _end
# CHECK-NEXT: 0000000000201159 .text 0000000000000000 _etext # CHECK-NEXT: 0000000000201159 g .text 0000000000000000 _etext
# CHECK-NEXT: 0000000000201158 .text 0000000000000000 _start # CHECK-NEXT: 0000000000201158 g .text 0000000000000000 _start
# CHECK-NEXT: 000000000020215b .data 0000000000000000 edata # CHECK-NEXT: 000000000020215b g .data 0000000000000000 edata
# CHECK-NEXT: 0000000000202162 .bss 0000000000000000 end # CHECK-NEXT: 0000000000202162 g .bss 0000000000000000 end
# CHECK-NEXT: 0000000000201159 .text 0000000000000000 etext # CHECK-NEXT: 0000000000201159 g .text 0000000000000000 etext
# RUN: ld.lld -r %t.o -o %t2 # RUN: ld.lld -r %t.o -o %t2
# RUN: llvm-objdump -t %t2 | FileCheck %s --check-prefix=RELOCATABLE # RUN: llvm-objdump -t %t2 | FileCheck %s --check-prefix=RELOCATABLE
# RELOCATABLE: 0000000000000000 *UND* 0000000000000000 _edata # RELOCATABLE: 0000000000000000 *UND* 0000000000000000 _edata
# RELOCATABLE-NEXT: 0000000000000000 *UND* 0000000000000000 _end # RELOCATABLE-NEXT: 0000000000000000 *UND* 0000000000000000 _end
# RELOCATABLE-NEXT: 0000000000000000 *UND* 0000000000000000 _etext # RELOCATABLE-NEXT: 0000000000000000 *UND* 0000000000000000 _etext
.global _start,_end,_etext,_edata,end,etext,edata .global _start,_end,_etext,_edata,end,etext,edata
.text .text
_start: _start:
nop nop
.data .data
.word 1 .word 1
.bss .bss
.align 4 .align 4
.space 6 .space 6

lld/test/ELF/edata-no-bss.s

# REQUIRES: x86 # REQUIRES: x86
## _edata points to the end of the last mapped initialized section. ## _edata points to the end of the last mapped initialized section.
# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
# RUN: ld.lld %t.o -o %t --gc-sections # RUN: ld.lld %t.o -o %t --gc-sections
# RUN: llvm-objdump -t -section-headers %t | FileCheck %s # RUN: llvm-objdump -t -section-headers %t | FileCheck %s
# CHECK: .data 00000008 000000000020215c DATA # CHECK: .data 00000008 000000000020215c DATA
# CHECK: 0000000000202164 .data 0000000000000000 _edata # CHECK: 0000000000202164 g .data 0000000000000000 _edata
.text .text
.globl _start .globl _start
_start: _start:
.long .data - . .long .data - .
.data .data
.quad 0 .quad 0
.globl _edata .globl _edata

lld/test/ELF/i386-pc8-pc16-addend.s

# REQUIRES: x86 # REQUIRES: x86
# RUN: llvm-mc -filetype=obj -triple=i386-pc-linux-gnu %s -o %t1.o # RUN: llvm-mc -filetype=obj -triple=i386-pc-linux-gnu %s -o %t1.o
# RUN: ld.lld %t1.o -o %t.out # RUN: ld.lld %t1.o -o %t.out
# RUN: llvm-objdump -s -t %t.out | FileCheck %s # RUN: llvm-objdump -s -t %t.out | FileCheck %s
# CHECK: SYMBOL TABLE: # CHECK: SYMBOL TABLE:
# CHECK: 004010b7 .und # CHECK: 004010b7 l .und
# CHECK: Contents of section .text: # CHECK: Contents of section .text:
# CHECK-NEXT: 4010b4 020000 # CHECK-NEXT: 4010b4 020000
## 0x4010b7 - 0x4010b4 + addend(-1) = 0x02 ## 0x4010b7 - 0x4010b4 + addend(-1) = 0x02
## 0x4010b7 - 0x4010b5 + addend(-2) = 0x0000 ## 0x4010b7 - 0x4010b5 + addend(-2) = 0x0000
.byte und-.-1 .byte und-.-1
.short und-.-2 .short und-.-2
.section .und, "ax" .section .und, "ax"
und: und:

lld/test/ELF/i386-reloc8-reloc16-addend.s

# REQUIRES: x86 # REQUIRES: x86
# RUN: llvm-mc -filetype=obj -triple=i386-pc-linux-gnu %s -o %t1.o # RUN: llvm-mc -filetype=obj -triple=i386-pc-linux-gnu %s -o %t1.o
# RUN: ld.lld -Ttext=0x0 %t1.o -o %t.out # RUN: ld.lld -Ttext=0x0 %t1.o -o %t.out
# RUN: llvm-objdump -s -t %t.out | FileCheck %s # RUN: llvm-objdump -s -t %t.out | FileCheck %s
## 0x3 + addend(-1) = 0x02 ## 0x3 + addend(-1) = 0x02
## 0x3 + addend(-2) = 0x0100 ## 0x3 + addend(-2) = 0x0100
# CHECK: SYMBOL TABLE: # CHECK: SYMBOL TABLE:
# CHECK: 00000003 .und # CHECK-NEXT: 00000003 l .und 00000000 und
# CHECK: Contents of section .text: # CHECK: Contents of section .text:
# CHECK-NEXT: 0000 020100 # CHECK-NEXT: 0000 020100
.byte und-1 .byte und-1
.short und-2 .short und-2
.section .und, "ax" .section .und, "ax"
und: und:

lld/test/ELF/linkerscript/absolute2.s

# REQUIRES: x86 # REQUIRES: x86
# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
# RUN: echo "SECTIONS { .text : { *(.text) } foo = ABSOLUTE(_start) + _start; };" > %t.script # RUN: echo "SECTIONS { .text : { *(.text) } foo = ABSOLUTE(_start) + _start; };" > %t.script
# RUN: ld.lld -o %t --script %t.script %t.o # RUN: ld.lld -o %t --script %t.script %t.o
# RUN: llvm-objdump -t %t | FileCheck %s # RUN: llvm-objdump -t %t | FileCheck %s
# RUN: echo "SECTIONS { .text : { *(.text) } foo = _start + ABSOLUTE(_start); };" > %t.script # RUN: echo "SECTIONS { .text : { *(.text) } foo = _start + ABSOLUTE(_start); };" > %t.script
# RUN: ld.lld -o %t --script %t.script %t.o # RUN: ld.lld -o %t --script %t.script %t.o
# RUN: llvm-objdump -t %t | FileCheck %s # RUN: llvm-objdump -t %t | FileCheck %s
# CHECK: 0000000000000001 .text 0000000000000000 _start # CHECK: 0000000000000001 g .text 0000000000000000 _start
# CHECK: 0000000000000002 .text 0000000000000000 foo # CHECK: 0000000000000002 g .text 0000000000000000 foo
.global _start .global _start
nop nop
_start: _start:

lld/test/ELF/linkerscript/align4.test

# REQUIRES: x86 # REQUIRES: x86
# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/align.s -o %t.o # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/align.s -o %t.o
# RUN: ld.lld -o %t --script %s %t.o # RUN: ld.lld -o %t --script %s %t.o
# RUN: llvm-objdump -t %t | FileCheck %s # RUN: llvm-objdump -t %t | FileCheck %s
# CHECK-LABEL: SYMBOL TABLE: # CHECK-LABEL: SYMBOL TABLE:
# CHECK-NEXT: 0000000000014008 .text 0000000000000000 _start # CHECK-NEXT: 0000000000014008 g .text 0000000000000000 _start
# CHECK-NEXT: 0000000000010000 *ABS* 0000000000000000 __code_base__ # CHECK-NEXT: 0000000000010000 g *ABS* 0000000000000000 __code_base__
# CHECK-NEXT: 0000000000001000 *ABS* 0000000000000000 VAR # CHECK-NEXT: 0000000000001000 g *ABS* 0000000000000000 VAR
# CHECK-NEXT: 0000000000011000 .bbb 0000000000000000 __start_bbb # CHECK-NEXT: 0000000000011000 g .bbb 0000000000000000 __start_bbb
# CHECK-NEXT: 0000000000012000 .bbb 0000000000000000 __end_bbb # CHECK-NEXT: 0000000000012000 g .bbb 0000000000000000 __end_bbb
VAR = 0x1000; VAR = 0x1000;
__code_base__ = 0x10000; __code_base__ = 0x10000;
SECTIONS { SECTIONS {
. = __code_base__; . = __code_base__;
.aaa : { *(.aaa) } .aaa : { *(.aaa) }
.bbb : ALIGN(VAR) { *(.bbb) } .bbb : ALIGN(VAR) { *(.bbb) }
. = ALIGN(., VAR * 4); . = ALIGN(., VAR * 4);
.ccc : { *(.ccc) } .ccc : { *(.ccc) }
__start_bbb = ADDR(.bbb); __start_bbb = ADDR(.bbb);
__end_bbb = ALIGN(__start_bbb + SIZEOF(.bbb), VAR); __end_bbb = ALIGN(__start_bbb + SIZEOF(.bbb), VAR);
} }

lld/test/ELF/linkerscript/align5.test

Show All 11 Lines .aaa : {
zed1 = ALIGN(., 0x100) + 1; zed1 = ALIGN(., 0x100) + 1;
zed2 = ALIGN(., 0x100) - 1; zed2 = ALIGN(., 0x100) - 1;
} }
.bbb : { *(.bbb); } .bbb : { *(.bbb); }
.ccc : { *(.ccc); } .ccc : { *(.ccc); }
.text : { *(.text); } .text : { *(.text); }
} }
# CHECK: 0000000000001000 .aaa 0000000000000000 foo # CHECK: 0000000000001000 g .aaa 0000000000000000 foo
# CHECK: 0000000000001000 .aaa 0000000000000000 bar # CHECK: 0000000000001000 g .aaa 0000000000000000 bar
# CHECK: 0000000000001001 .aaa 0000000000000000 zed1 # CHECK: 0000000000001001 g .aaa 0000000000000000 zed1
# CHECK: 0000000000000fff .aaa 0000000000000000 zed2 # CHECK: 0000000000000fff g .aaa 0000000000000000 zed2

lld/test/ELF/linkerscript/data-commands-gc.s

# REQUIRES: x86 # REQUIRES: x86
# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
# RUN: echo "SECTIONS { .text : { *(.text*) QUAD(bar) } }" > %t.script # RUN: echo "SECTIONS { .text : { *(.text*) QUAD(bar) } }" > %t.script
# RUN: ld.lld --gc-sections -o %t %t.o --script %t.script # RUN: ld.lld --gc-sections -o %t %t.o --script %t.script
# RUN: llvm-objdump -t %t | FileCheck %s # RUN: llvm-objdump -t %t | FileCheck %s
# CHECK: 0000000000000008 .rodata 0000000000000000 bar # CHECK: 0000000000000008 g .rodata 0000000000000000 bar
.section .rodata.bar .section .rodata.bar
.quad 0x1122334455667788 .quad 0x1122334455667788
.global bar .global bar
bar: bar:
.section .text .section .text
.global _start .global _start
_start: _start:
nop nop

lld/test/ELF/linkerscript/loadaddr.s

Show All 12 Lines
# RUN: ddd_lma = LOADADDR(.ddd); \ # RUN: ddd_lma = LOADADDR(.ddd); \
# RUN: txt_lma = LOADADDR(.text); \ # RUN: txt_lma = LOADADDR(.text); \
# RUN: }" > %t.script # RUN: }" > %t.script
# RUN: ld.lld %t --script %t.script -o %t2 # RUN: ld.lld %t --script %t.script -o %t2
# RUN: llvm-objdump -t %t2 | FileCheck %s # RUN: llvm-objdump -t %t2 | FileCheck %s
# RUN: echo "SECTIONS { v = LOADADDR(.zzz); }" > %t.script # RUN: echo "SECTIONS { v = LOADADDR(.zzz); }" > %t.script
# RUN: not ld.lld %t --script %t.script -o /dev/null 2>&1 | FileCheck --check-prefix=ERROR %s # RUN: not ld.lld %t --script %t.script -o /dev/null 2>&1 | FileCheck --check-prefix=ERROR %s
# CHECK: 0000000000002000 *ABS* 0000000000000000 aaa_lma # CHECK: 0000000000002000 g *ABS* 0000000000000000 aaa_lma
# CHECK-NEXT: 0000000000002008 *ABS* 0000000000000000 bbb_lma # CHECK-NEXT: 0000000000002008 g *ABS* 0000000000000000 bbb_lma
# CHECK-NEXT: 0000000000003000 *ABS* 0000000000000000 ccc_lma # CHECK-NEXT: 0000000000003000 g *ABS* 0000000000000000 ccc_lma
# CHECK-NEXT: 0000000000004000 *ABS* 0000000000000000 ddd_lma # CHECK-NEXT: 0000000000004000 g *ABS* 0000000000000000 ddd_lma
# CHECK-NEXT: 0000000000004008 *ABS* 0000000000000000 txt_lma # CHECK-NEXT: 0000000000004008 g *ABS* 0000000000000000 txt_lma
# ERROR: {{.*}}.script:1: undefined section .zzz # ERROR: {{.*}}.script:1: undefined section .zzz
.global _start .global _start
_start: _start:
nop nop
.section .aaa, "a" .section .aaa, "a"
.quad 0 .quad 0
Show All 9 Lines

lld/test/ELF/linkerscript/symbol-only.test

Show All 12 Lines
# CHECK: Sections: # CHECK: Sections:
# CHECK-NEXT: Idx Name Size VMA # CHECK-NEXT: Idx Name Size VMA
# CHECK-NEXT: 0 00000000 0000000000000000 # CHECK-NEXT: 0 00000000 0000000000000000
# CHECK: abc 00000000 [[ADDR:[0-9a-f]*]] # CHECK: abc 00000000 [[ADDR:[0-9a-f]*]]
# CHECK: bar 00000000 0000000000001000 # CHECK: bar 00000000 0000000000001000
# CHECK: SYMBOL TABLE: # CHECK: SYMBOL TABLE:
# CHECK: [[ADDR]] abc 0000000000000000 foo # CHECK: [[ADDR]] g abc 0000000000000000 foo

lld/test/ELF/linkerscript/symbol-reserved.s

# REQUIRES: x86 # REQUIRES: x86
## Test linker synthesized symbols (e.g. __ehdr_start, _end) can be used in linker scripts. ## Test linker synthesized symbols (e.g. __ehdr_start, _end) can be used in linker scripts.
# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
# RUN: echo "PROVIDE_HIDDEN(newsym = __ehdr_start + 5);" > %t.script # RUN: echo "PROVIDE_HIDDEN(newsym = __ehdr_start + 5);" > %t.script
# RUN: ld.lld -o %t1 %t.script %t # RUN: ld.lld -o %t1 %t.script %t
# RUN: llvm-objdump -t %t1 | FileCheck %s # RUN: llvm-objdump -t %t1 | FileCheck %s
# CHECK: 0000000000200005 .text 0000000000000000 .hidden newsym # CHECK: 0000000000200005 l .text 0000000000000000 .hidden newsym
# RUN: ld.lld -o %t1.so %t.script %t -shared # RUN: ld.lld -o %t1.so %t.script %t -shared
# RUN: llvm-objdump -t %t1.so | FileCheck --check-prefix=SHARED %s # RUN: llvm-objdump -t %t1.so | FileCheck --check-prefix=SHARED %s
# SHARED: 0000000000000005 .dynsym 0000000000000000 .hidden newsym # SHARED: 0000000000000005 l .dynsym 0000000000000000 .hidden newsym
# RUN: echo "PROVIDE_HIDDEN(newsym = ALIGN(__ehdr_start, CONSTANT(MAXPAGESIZE)) + 5);" > %t.script # RUN: echo "PROVIDE_HIDDEN(newsym = ALIGN(__ehdr_start, CONSTANT(MAXPAGESIZE)) + 5);" > %t.script
# RUN: ld.lld -o %t1 %t.script %t # RUN: ld.lld -o %t1 %t.script %t
# RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=ALIGNED %s # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=ALIGNED %s
# ALIGNED: 0000000000200005 .text 0000000000000000 .hidden newsym # ALIGNED: 0000000000200005 l .text 0000000000000000 .hidden newsym
# RUN: echo "PROVIDE_HIDDEN(newsym = ALIGN(3, 8) + 10);" > %t.script # RUN: echo "PROVIDE_HIDDEN(newsym = ALIGN(3, 8) + 10);" > %t.script
# RUN: ld.lld -o %t1 %t.script %t # RUN: ld.lld -o %t1 %t.script %t
# RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=ALIGN-ADD %s # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=ALIGN-ADD %s
# ALIGN-ADD: 0000000000000012 *ABS* 0000000000000000 .hidden newsym # ALIGN-ADD: 0000000000000012 l *ABS* 0000000000000000 .hidden newsym
# RUN: echo "PROVIDE_HIDDEN(newsym = ALIGN(11, 8) - 10);" > %t.script # RUN: echo "PROVIDE_HIDDEN(newsym = ALIGN(11, 8) - 10);" > %t.script
# RUN: ld.lld -o %t1 %t.script %t # RUN: ld.lld -o %t1 %t.script %t
# RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=ALIGN-SUB %s # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=ALIGN-SUB %s
# ALIGN-SUB: 0000000000000006 *ABS* 0000000000000000 .hidden newsym # ALIGN-SUB: 0000000000000006 l *ABS* 0000000000000000 .hidden newsym
# RUN: echo "PROVIDE_HIDDEN(newsym = ALIGN(_end, CONSTANT(MAXPAGESIZE)) + 5);" > %t.script # RUN: echo "PROVIDE_HIDDEN(newsym = ALIGN(_end, CONSTANT(MAXPAGESIZE)) + 5);" > %t.script
# RUN: ld.lld -o %t1 %t %t.script # RUN: ld.lld -o %t1 %t %t.script
# RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=RELATIVE %s # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=RELATIVE %s
# RELATIVE: 0000000000202005 .text 0000000000000000 .hidden newsym # RELATIVE: 0000000000202005 l .text 0000000000000000 .hidden newsym
# RELATIVE: 0000000000201127 .text 0000000000000000 _end # RELATIVE: 0000000000201127 g .text 0000000000000000 _end
# RUN: echo "PROVIDE_HIDDEN(newsym = ALIGN(_end, CONSTANT(MAXPAGESIZE)) + 5);" > %t.script # RUN: echo "PROVIDE_HIDDEN(newsym = ALIGN(_end, CONSTANT(MAXPAGESIZE)) + 5);" > %t.script
# RUN: ld.lld -o %t1 --script %p/Inputs/symbol-reserved.script %t %t.script # RUN: ld.lld -o %t1 --script %p/Inputs/symbol-reserved.script %t %t.script
# RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=RELATIVE-ADD %s # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=RELATIVE-ADD %s
# RELATIVE-ADD: 0000000000001005 .text 0000000000000000 .hidden newsym # RELATIVE-ADD: 0000000000001005 l .text 0000000000000000 .hidden newsym
# RELATIVE-ADD: 0000000000000007 .text 0000000000000000 .hidden _end # RELATIVE-ADD: 0000000000000007 l .text 0000000000000000 .hidden _end
# RUN: echo "PROVIDE_HIDDEN(newsym = ALIGN(_end, CONSTANT(MAXPAGESIZE)) - 5);" > %t.script # RUN: echo "PROVIDE_HIDDEN(newsym = ALIGN(_end, CONSTANT(MAXPAGESIZE)) - 5);" > %t.script
# RUN: ld.lld -o %t1 --script %p/Inputs/symbol-reserved.script %t %t.script # RUN: ld.lld -o %t1 --script %p/Inputs/symbol-reserved.script %t %t.script
# RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=RELATIVE-SUB %s # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=RELATIVE-SUB %s
# RELATIVE-SUB: 0000000000000ffb .text 0000000000000000 .hidden newsym # RELATIVE-SUB: 0000000000000ffb l .text 0000000000000000 .hidden newsym
# RELATIVE-SUB: 0000000000000007 .text 0000000000000000 .hidden _end # RELATIVE-SUB: 0000000000000007 l .text 0000000000000000 .hidden _end
.global _start .global _start
_start: _start:
lea newsym(%rip),%rax lea newsym(%rip),%rax

lld/test/ELF/linkerscript/symbolreferenced.s

# REQUIRES: x86 # REQUIRES: x86
# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
# Provide new symbol. The value should be 1, like set in PROVIDE() # Provide new symbol. The value should be 1, like set in PROVIDE()
# RUN: echo "SECTIONS { PROVIDE(newsym = 1);}" > %t.script # RUN: echo "SECTIONS { PROVIDE(newsym = 1);}" > %t.script
# RUN: ld.lld -o %t1 --script %t.script %t # RUN: ld.lld -o %t1 --script %t.script %t
# RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=PROVIDE1 %s # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=PROVIDE1 %s
# PROVIDE1: 0000000000000001 *ABS* 0000000000000000 newsym # PROVIDE1: 0000000000000001 g *ABS* 0000000000000000 newsym
# Provide new symbol (hidden). The value should be 1 # Provide new symbol (hidden). The value should be 1
# RUN: echo "SECTIONS { PROVIDE_HIDDEN(newsym = 1);}" > %t.script # RUN: echo "SECTIONS { PROVIDE_HIDDEN(newsym = 1);}" > %t.script
# RUN: ld.lld -o %t1 --script %t.script %t # RUN: ld.lld -o %t1 --script %t.script %t
# RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=HIDDEN1 %s # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=HIDDEN1 %s
# HIDDEN1: 0000000000000001 *ABS* 0000000000000000 .hidden newsym # HIDDEN1: 0000000000000001 l *ABS* 0000000000000000 .hidden newsym
.global _start .global _start
_start: _start:
nop nop
.globl patatino .globl patatino
patatino: patatino:
movl newsym, %eax movl newsym, %eax

lld/test/ELF/linkerscript/symbols-non-alloc.test

# REQUIRES: x86 # REQUIRES: x86
# RUN: echo '.section .nonalloc,""; .quad 0' \ # RUN: echo '.section .nonalloc,""; .quad 0' \
# RUN: | llvm-mc -filetype=obj -triple=x86_64-unknown-linux - -o %t # RUN: | llvm-mc -filetype=obj -triple=x86_64-unknown-linux - -o %t
# RUN: ld.lld -o %t2 --script %s %t # RUN: ld.lld -o %t2 --script %s %t
# RUN: llvm-objdump -section-headers -t %t2 | FileCheck %s # RUN: llvm-objdump -section-headers -t %t2 | FileCheck %s
# CHECK: Sections: # CHECK: Sections:
# CHECK: .nonalloc 00000008 0000000000000000 # CHECK: .nonalloc 00000008 0000000000000000
# CHECK: SYMBOL TABLE: # CHECK: SYMBOL TABLE:
# CHECK: 0000000000000008 .nonalloc 0000000000000000 Sym # CHECK: 0000000000000008 g .nonalloc 0000000000000000 Sym
SECTIONS { SECTIONS {
. = SIZEOF_HEADERS; . = SIZEOF_HEADERS;
.text : { *(.text) } .text : { *(.text) }
.nonalloc : { *(.nonalloc) } .nonalloc : { *(.nonalloc) }
Sym = .; Sym = .;
} }

lld/test/ELF/linkerscript/symbols.s

Show All 19 Lines
# RUN: ld.lld -o %t1 --script %t.script %t # RUN: ld.lld -o %t1 --script %t.script %t
# RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=DONTPROVIDE %s # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=DONTPROVIDE %s
# Provide existing symbol. The value should be 0, even though we # Provide existing symbol. The value should be 0, even though we
# have value of 1 in PROVIDE() # have value of 1 in PROVIDE()
# RUN: echo "SECTIONS { PROVIDE(somesym = 1);}" > %t.script # RUN: echo "SECTIONS { PROVIDE(somesym = 1);}" > %t.script
# RUN: ld.lld -o %t1 --script %t.script %t # RUN: ld.lld -o %t1 --script %t.script %t
# RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=PROVIDE2 %s # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=PROVIDE2 %s
# PROVIDE2: 0000000000000000 *ABS* 0000000000000000 somesym # PROVIDE2: 0000000000000000 g *ABS* 0000000000000000 somesym
# Provide existing symbol. The value should be 0, even though we # Provide existing symbol. The value should be 0, even though we
# have value of 1 in PROVIDE_HIDDEN(). Visibility should not change # have value of 1 in PROVIDE_HIDDEN(). Visibility should not change
# RUN: echo "SECTIONS { PROVIDE_HIDDEN(somesym = 1);}" > %t.script # RUN: echo "SECTIONS { PROVIDE_HIDDEN(somesym = 1);}" > %t.script
# RUN: ld.lld -o %t1 --script %t.script %t # RUN: ld.lld -o %t1 --script %t.script %t
# RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=HIDDEN2 %s # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=HIDDEN2 %s
# HIDDEN2: 0000000000000000 *ABS* 0000000000000000 somesym # HIDDEN2: 0000000000000000 g *ABS* 0000000000000000 somesym
# Hidden symbol assignment. # Hidden symbol assignment.
# RUN: echo "SECTIONS { HIDDEN(newsym = 1);}" > %t.script # RUN: echo "SECTIONS { HIDDEN(newsym = 1);}" > %t.script
# RUN: ld.lld -o %t1 --script %t.script %t # RUN: ld.lld -o %t1 --script %t.script %t
# RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=HIDDEN3 %s # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=HIDDEN3 %s
# HIDDEN3: 0000000000000001 *ABS* 0000000000000000 .hidden newsym # HIDDEN3: 0000000000000001 l *ABS* 0000000000000000 .hidden newsym
# The symbol is not referenced. Don't provide it. # The symbol is not referenced. Don't provide it.
# RUN: echo "PROVIDE(newsym = 1);" > %t.script # RUN: echo "PROVIDE(newsym = 1);" > %t.script
# RUN: ld.lld -o %t1 --script %t.script %t # RUN: ld.lld -o %t1 --script %t.script %t
# RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=DONTPROVIDE %s # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=DONTPROVIDE %s
# The symbol is not referenced. Don't provide it. # The symbol is not referenced. Don't provide it.
# RUN: echo "PROVIDE_HIDDEN(newsym = 1);" > %t.script # RUN: echo "PROVIDE_HIDDEN(newsym = 1);" > %t.script
# RUN: ld.lld -o %t1 --script %t.script %t # RUN: ld.lld -o %t1 --script %t.script %t
# RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=DONTPROVIDE %s # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=DONTPROVIDE %s
# Provide existing symbol. The value should be 0, even though we # Provide existing symbol. The value should be 0, even though we
# have value of 1 in PROVIDE() # have value of 1 in PROVIDE()
# RUN: echo "PROVIDE(somesym = 1);" > %t.script # RUN: echo "PROVIDE(somesym = 1);" > %t.script
# RUN: ld.lld -o %t1 --script %t.script %t # RUN: ld.lld -o %t1 --script %t.script %t
# RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=PROVIDE5 %s # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=PROVIDE5 %s
# PROVIDE5: 0000000000000000 *ABS* 0000000000000000 somesym # PROVIDE5: 0000000000000000 g *ABS* 0000000000000000 somesym
# Provide existing symbol. The value should be 0, even though we # Provide existing symbol. The value should be 0, even though we
# have value of 1 in PROVIDE_HIDDEN(). Visibility should not change # have value of 1 in PROVIDE_HIDDEN(). Visibility should not change
# RUN: echo "PROVIDE_HIDDEN(somesym = 1);" > %t.script # RUN: echo "PROVIDE_HIDDEN(somesym = 1);" > %t.script
# RUN: ld.lld -o %t1 --script %t.script %t # RUN: ld.lld -o %t1 --script %t.script %t
# RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=HIDDEN5 %s # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=HIDDEN5 %s
# HIDDEN5: 0000000000000000 *ABS* 0000000000000000 somesym # HIDDEN5: 0000000000000000 g *ABS* 0000000000000000 somesym
# Simple symbol assignment. All three symbols should have the # Simple symbol assignment. All three symbols should have the
# same value. # same value.
# RUN: echo "foo = 0x100; SECTIONS { bar = foo; } baz = bar;" > %t.script # RUN: echo "foo = 0x100; SECTIONS { bar = foo; } baz = bar;" > %t.script
# RUN: ld.lld -o %t1 --script %t.script %t # RUN: ld.lld -o %t1 --script %t.script %t
# RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=SIMPLE2 %s # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=SIMPLE2 %s
# SIMPLE2: 0000000000000100 *ABS* 0000000000000000 foo # SIMPLE2: 0000000000000100 g *ABS* 0000000000000000 foo
# SIMPLE2: 0000000000000100 *ABS* 0000000000000000 bar # SIMPLE2: 0000000000000100 g *ABS* 0000000000000000 bar
# SIMPLE2: 0000000000000100 *ABS* 0000000000000000 baz # SIMPLE2: 0000000000000100 g *ABS* 0000000000000000 baz
.global _start .global _start
_start: _start:
nop nop
.global somesym .global somesym
somesym = 0 somesym = 0

lld/test/ELF/linkerscript/synthetic-symbols1.test

Show All 32 Lines .eh_frame_hdr : {
*(.eh_frame_hdr) *(.eh_frame_hdr)
__eh_frame_hdr_end = .; __eh_frame_hdr_end = .;
__eh_frame_hdr_end2 = ABSOLUTE(ALIGN(0x10)); __eh_frame_hdr_end2 = ABSOLUTE(ALIGN(0x10));
} }
.eh_frame : {} .eh_frame : {}
} }
# CHECK: 0000000000000128 .foo 0000000000000000 .hidden _end_sec # CHECK: 0000000000000128 l .foo 0000000000000000 .hidden _end_sec
# CHECK-NEXT: 0000000000000120 .foo 0000000000000000 _begin_sec # CHECK-NEXT: 0000000000000120 g .foo 0000000000000000 _begin_sec
# CHECK-NEXT: 0000000000000128 *ABS* 0000000000000000 _end_sec_abs # CHECK-NEXT: 0000000000000128 g *ABS* 0000000000000000 _end_sec_abs
# CHECK-NEXT: 000000000000104c .text 0000000000000000 _start # CHECK-NEXT: 000000000000104c g .text 0000000000000000 _start
# CHECK-NEXT: 0000000000000120 .foo 0000000000000000 begin_foo # CHECK-NEXT: 0000000000000120 g .foo 0000000000000000 begin_foo
# CHECK-NEXT: 0000000000000128 .foo 0000000000000000 end_foo # CHECK-NEXT: 0000000000000128 g .foo 0000000000000000 end_foo
# CHECK-NEXT: 0000000000000008 *ABS* 0000000000000000 size_foo_1 # CHECK-NEXT: 0000000000000008 g *ABS* 0000000000000000 size_foo_1
# CHECK-NEXT: 0000000000000008 *ABS* 0000000000000000 size_foo_1_abs # CHECK-NEXT: 0000000000000008 g *ABS* 0000000000000000 size_foo_1_abs
# CHECK-NEXT: 0000000000001000 .foo 0000000000000000 begin_bar # CHECK-NEXT: 0000000000001000 g .foo 0000000000000000 begin_bar
# CHECK-NEXT: 0000000000001004 .foo 0000000000000000 end_bar # CHECK-NEXT: 0000000000001004 g .foo 0000000000000000 end_bar
# CHECK-NEXT: 0000000000000ee4 *ABS* 0000000000000000 size_foo_2 # CHECK-NEXT: 0000000000000ee4 g *ABS* 0000000000000000 size_foo_2
# CHECK-NEXT: 0000000000000ee4 *ABS* 0000000000000000 size_foo_3 # CHECK-NEXT: 0000000000000ee4 g *ABS* 0000000000000000 size_foo_3
# CHECK-NEXT: 0000000000001004 .eh_frame_hdr 0000000000000000 __eh_frame_hdr_start # CHECK-NEXT: 0000000000001004 g .eh_frame_hdr 0000000000000000 __eh_frame_hdr_start
# CHECK-NEXT: 0000000000001010 *ABS* 0000000000000000 __eh_frame_hdr_start2 # CHECK-NEXT: 0000000000001010 g *ABS* 0000000000000000 __eh_frame_hdr_start2
# CHECK-NEXT: 0000000000001018 .eh_frame_hdr 0000000000000000 __eh_frame_hdr_end # CHECK-NEXT: 0000000000001018 g .eh_frame_hdr 0000000000000000 __eh_frame_hdr_end
# CHECK-NEXT: 0000000000001020 *ABS* 0000000000000000 __eh_frame_hdr_end2 # CHECK-NEXT: 0000000000001020 g *ABS* 0000000000000000 __eh_frame_hdr_end2

lld/test/ELF/linkerscript/synthetic-symbols3.test

# REQUIRES: x86 # REQUIRES: x86
# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/synthetic-symbols.s -o %t # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/synthetic-symbols.s -o %t
# RUN: ld.lld -o %t.exe --eh-frame-hdr --script %s %t # RUN: ld.lld -o %t.exe --eh-frame-hdr --script %s %t
# RUN: llvm-objdump -t %t.exe | FileCheck %s # RUN: llvm-objdump -t %t.exe | FileCheck %s
# Check that we can specify synthetic symbols without defining SECTIONS. # Check that we can specify synthetic symbols without defining SECTIONS.
PROVIDE_HIDDEN(_begin_sec = _start); PROVIDE_HIDDEN(_begin_sec = _start);
PROVIDE_HIDDEN(_end_sec = ADDR(.text) + SIZEOF(.text)); PROVIDE_HIDDEN(_end_sec = ADDR(.text) + SIZEOF(.text));
# CHECK: 00000000002011ac .text 0000000000000000 .hidden _begin_sec # CHECK: 00000000002011ac l .text 0000000000000000 .hidden _begin_sec
# CHECK-NEXT: 00000000002011ad .text 0000000000000000 .hidden _end_sec # CHECK-NEXT: 00000000002011ad l .text 0000000000000000 .hidden _end_sec

lld/test/ELF/linkerscript/synthetic-symbols4.test

# REQUIRES: x86 # REQUIRES: x86
# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/synthetic-symbols.s -o %t.o # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/synthetic-symbols.s -o %t.o
# RUN: ld.lld -o %t --eh-frame-hdr --script %s %t.o # RUN: ld.lld -o %t --eh-frame-hdr --script %s %t.o
# RUN: llvm-objdump -t %t | FileCheck %s # RUN: llvm-objdump -t %t | FileCheck %s
SECTIONS { SECTIONS {
. = 0x201000; . = 0x201000;
.text : { *(.text) } .text : { *(.text) }
PROVIDE_HIDDEN(_begin_sec = ADDR(.text)); PROVIDE_HIDDEN(_begin_sec = ADDR(.text));
PROVIDE_HIDDEN(_end_sec = ADDR(.text) + SIZEOF(.text)); PROVIDE_HIDDEN(_end_sec = ADDR(.text) + SIZEOF(.text));
} }
# CHECK: 0000000000201054 .text 0000000000000000 .hidden _begin_sec # CHECK: 0000000000201054 l .text 0000000000000000 .hidden _begin_sec
# CHECK-NEXT: 0000000000201055 .text 0000000000000000 .hidden _end_sec # CHECK-NEXT: 0000000000201055 l .text 0000000000000000 .hidden _end_sec

lld/test/ELF/mips-32.s

Show All 19 Lines# RUN: | FileCheck -check-prefix=REL %s
.data .data
.globl v2 .globl v2
v1: v1:
.word v2+4 # R_MIPS_32 target v2 addend 4 .word v2+4 # R_MIPS_32 target v2 addend 4
v2: v2:
.word v1 # R_MIPS_32 target v1 addend 0 .word v1 # R_MIPS_32 target v1 addend 0
# SYM: SYMBOL TABLE: # SYM: SYMBOL TABLE:
# SYM: 00011000 .data 00000000 v1 # SYM: 00011000 l .data 00000000 v1
# BE: Contents of section .data: # BE: Contents of section .data:
# BE-NEXT: {{.*}} 00000004 00011000 # BE-NEXT: {{.*}} 00000004 00011000
# ^-- v2+4 ^-- v1 # ^-- v2+4 ^-- v1
# EL: Contents of section .data: # EL: Contents of section .data:
# EL-NEXT: {{.*}} 04000000 00100100 # EL-NEXT: {{.*}} 04000000 00100100
# ^-- v2+4 ^-- v1 # ^-- v2+4 ^-- v1
Show All 15 Lines

lld/test/ELF/mips-64-got.s

# REQUIRES: mips # REQUIRES: mips
# Check MIPS N64 ABI GOT relocations # Check MIPS N64 ABI GOT relocations
# RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux \ # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux \
# RUN: %p/Inputs/mips-pic.s -o %t.so.o # RUN: %p/Inputs/mips-pic.s -o %t.so.o
# RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %t.exe.o # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %t.exe.o
# RUN: echo "SECTIONS { . = 0x30000; .text : { *(.text) } }" > %t.script # RUN: echo "SECTIONS { . = 0x30000; .text : { *(.text) } }" > %t.script
# RUN: ld.lld %t.so.o -shared -soname=t.so -o %t.so # RUN: ld.lld %t.so.o -shared -soname=t.so -o %t.so
# RUN: ld.lld %t.exe.o --script %t.script %t.so -o %t.exe # RUN: ld.lld %t.exe.o --script %t.script %t.so -o %t.exe
# RUN: llvm-objdump -d -t --no-show-raw-insn %t.exe | FileCheck %s # RUN: llvm-objdump -d -t --no-show-raw-insn %t.exe | FileCheck %s
# RUN: llvm-readelf -r -s -A %t.exe | FileCheck -check-prefix=GOT %s # RUN: llvm-readelf -r -s -A %t.exe | FileCheck -check-prefix=GOT %s
# CHECK: {{[0-9a-f]+}}1c8 .text 0000000000000000 foo # CHECK: {{[0-9a-f]+}}1c8 l .text 0000000000000000 foo
# CHECK: __start: # CHECK: __start:
# CHECK-NEXT: {{.*}} ld $2, -32736($gp) # CHECK-NEXT: {{.*}} ld $2, -32736($gp)
# CHECK-NEXT: {{.*}} daddiu $2, $2, 456 # CHECK-NEXT: {{.*}} daddiu $2, $2, 456
# CHECK-NEXT: {{.*}} addiu $2, $2, -32704 # CHECK-NEXT: {{.*}} addiu $2, $2, -32704
# CHECK-NEXT: {{.*}} addiu $2, $2, -32720 # CHECK-NEXT: {{.*}} addiu $2, $2, -32720
# CHECK-NEXT: {{.*}} addiu $2, $2, -32712 # CHECK-NEXT: {{.*}} addiu $2, $2, -32712
Show All 39 Lines

lld/test/ELF/mips-64-rels.s

# REQUIRES: mips # REQUIRES: mips
# Check handling multiple MIPS N64 ABI relocations packed # Check handling multiple MIPS N64 ABI relocations packed
# into the single relocation record. # into the single relocation record.
# RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %t.o # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %t.o
# RUN: echo "SECTIONS { \ # RUN: echo "SECTIONS { \
# RUN: . = 0x20000; .text ALIGN(0x1000) : { *(.text) } \ # RUN: . = 0x20000; .text ALIGN(0x1000) : { *(.text) } \
# RUN: . = 0x30000; .got : { *(.got) } \ # RUN: . = 0x30000; .got : { *(.got) } \
# RUN: }" > %t.script # RUN: }" > %t.script
# RUN: ld.lld %t.o --script %t.script -o %t.exe # RUN: ld.lld %t.o --script %t.script -o %t.exe
# RUN: llvm-objdump -d -s -t --print-imm-hex --no-show-raw-insn %t.exe | FileCheck %s # RUN: llvm-objdump -d -s -t --print-imm-hex --no-show-raw-insn %t.exe | FileCheck %s
# RUN: llvm-readobj -r %t.exe | FileCheck -check-prefix=REL %s # RUN: llvm-readobj -r %t.exe | FileCheck -check-prefix=REL %s
# CHECK: 0000000000037ff0 .got 0000000000000000 .hidden _gp # CHECK: 0000000000037ff0 l .got 0000000000000000 .hidden _gp
# CHECK: Contents of section .rodata: # CHECK: Contents of section .rodata:
# CHECK-NEXT: {{[0-9a-f]+}} ffffffff fffe9014 # CHECK-NEXT: {{[0-9a-f]+}} ffffffff fffe9014
# ^-- 0x21004 - 0x37ff0 = 0xfffffffffffe9014 # ^-- 0x21004 - 0x37ff0 = 0xfffffffffffe9014
# CHECK: __start: # CHECK: __start:
# CHECK-NEXT: 21000: lui $gp, 0x1 # CHECK-NEXT: 21000: lui $gp, 0x1
# ^-- 0x21000 - 0x37ff0 # ^-- 0x21000 - 0x37ff0
Show All 25 Lines

lld/test/ELF/mips-64.s

# REQUIRES: mips # REQUIRES: mips
# Check R_MIPS_64 relocation calculation. # Check R_MIPS_64 relocation calculation.
# RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %t.o # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %t.o
# RUN: ld.lld -shared %t.o -o %t.so # RUN: ld.lld -shared %t.o -o %t.so
# RUN: llvm-objdump -s -t %t.so | FileCheck -check-prefix=SYM %s # RUN: llvm-objdump -s -t %t.so | FileCheck -check-prefix=SYM %s
# RUN: llvm-readelf --dynamic-table -r -s -A %t.so | FileCheck %s # RUN: llvm-readelf --dynamic-table -r -s -A %t.so | FileCheck %s
.data .data
.globl v2 .globl v2
v1: v1:
.quad v2+8 # R_MIPS_64 target v2 addend 8 .quad v2+8 # R_MIPS_64 target v2 addend 8
v2: v2:
.quad v1 # R_MIPS_64 target v1 addend 0 .quad v1 # R_MIPS_64 target v1 addend 0
# SYM: SYMBOL TABLE: # SYM: SYMBOL TABLE:
# SYM: 00000000[[V1:[0-9a-f]+]] .data 0000000000000000 v1 # SYM: 00000000[[V1:[0-9a-f]+]] l .data 0000000000000000 v1
# SYM: Contents of section .data: # SYM: Contents of section .data:
# SYM-NEXT: {{.*}} 00000000 00000008 00000000 [[V1]] # SYM-NEXT: {{.*}} 00000000 00000008 00000000 [[V1]]
# CHECK: Dynamic section # CHECK: Dynamic section
# CHECK: (RELSZ) 32 (bytes) # CHECK: (RELSZ) 32 (bytes)
# CHECK: (RELENT) 16 (bytes) # CHECK: (RELENT) 16 (bytes)
Show All 11 Lines

lld/test/ELF/mips-got16-relocatable.s

Show All 16 Lines
# OBJ-NEXT: addiu $4, $25, 0 # OBJ-NEXT: addiu $4, $25, 0
# OBJ-NEXT: 00000004: R_MIPS_LO16 .data # OBJ-NEXT: 00000004: R_MIPS_LO16 .data
# OBJ: lw $25, 0($gp) # OBJ: lw $25, 0($gp)
# OBJ-NEXT: 00000010: R_MIPS_GOT16 .data # OBJ-NEXT: 00000010: R_MIPS_GOT16 .data
# OBJ-NEXT: addiu $4, $25, 16 # OBJ-NEXT: addiu $4, $25, 16
# OBJ-NEXT: 00000014: R_MIPS_LO16 .data # OBJ-NEXT: 00000014: R_MIPS_LO16 .data
# SO: SYMBOL TABLE # SO: SYMBOL TABLE
# SO: {{0*}}[[D1:[0-9a-f]{1,4}]] .data {{0+}} data # SO: {{0*}}[[D1:[0-9a-f]{1,4}]] l .data {{0+}} data
# SO: {{0*}}[[D2:[0-9a-f]{1,4}]] .data {{0+}} data # SO: {{0*}}[[D2:[0-9a-f]{1,4}]] l .data {{0+}} data
# SO: Disassembly of section .text: # SO: Disassembly of section .text:
# SO-EMPTY: # SO-EMPTY:
# SO-NEXT: .text: # SO-NEXT: .text:
# SO-NEXT: lw $25, -0x7fe8($gp) # SO-NEXT: lw $25, -0x7fe8($gp)
# SO-NEXT: addiu $4, $25, 0x[[D1]] # SO-NEXT: addiu $4, $25, 0x[[D1]]
# SO: lw $25, -0x7fe8($gp) # SO: lw $25, -0x7fe8($gp)
# SO-NEXT: addiu $4, $25, 0x[[D2]] # SO-NEXT: addiu $4, $25, 0x[[D2]]
.text .text
lw $t9, %got(.data)($gp) lw $t9, %got(.data)($gp)
addiu $a0, $t9, %lo(.data) addiu $a0, $t9, %lo(.data)
.data .data
data: data:
.word 0 .word 0

lld/test/ELF/mips-got16.s

# REQUIRES: mips # REQUIRES: mips
# Check R_MIPS_GOT16 relocation calculation. # Check R_MIPS_GOT16 relocation calculation.
# RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t.o # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t.o
# RUN: echo "SECTIONS { \ # RUN: echo "SECTIONS { \
# RUN: . = 0x1000; .text ALIGN(0x1000) : { *(.text) } \ # RUN: . = 0x1000; .text ALIGN(0x1000) : { *(.text) } \
# RUN: . = 0x3000; .data : { *(.data) } \ # RUN: . = 0x3000; .data : { *(.data) } \
# RUN: }" > %t.script # RUN: }" > %t.script
# RUN: ld.lld %t.o -shared --script %t.script -o %t.so # RUN: ld.lld %t.o -shared --script %t.script -o %t.so
# RUN: llvm-objdump -d -t --no-show-raw-insn %t.so | FileCheck %s # RUN: llvm-objdump -d -t --no-show-raw-insn %t.so | FileCheck %s
# RUN: llvm-readelf -r -A %t.so | FileCheck -check-prefix=GOT %s # RUN: llvm-readelf -r -A %t.so | FileCheck -check-prefix=GOT %s
# CHECK: SYMBOL TABLE: # CHECK: SYMBOL TABLE:
# CHECK: 00024008 .data 00000000 .hidden bar # CHECK: 00024008 l .data 00000000 .hidden bar
# CHECK: 00000000 *UND* 00000000 foo # CHECK: 00000000 *UND* 00000000 foo
# CHECK: __start: # CHECK: __start:
# CHECK-NEXT: lw $8, -32744($gp) # CHECK-NEXT: lw $8, -32744($gp)
# CHECK-NEXT: addi $8, $8, 8236 # CHECK-NEXT: addi $8, $8, 8236
# CHECK-NEXT: lw $8, -32732($gp) # CHECK-NEXT: lw $8, -32732($gp)
# CHECK-NEXT: addi $8, $8, -16384 # CHECK-NEXT: addi $8, $8, -16384
# CHECK-NEXT: lw $8, -32728($gp) # CHECK-NEXT: lw $8, -32728($gp)
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

lld/test/ELF/mips-gp-disp.s

Show All 11 Lines
# RUN: llvm-readelf --symbols %S/Inputs/mips-gp-disp.so \ # RUN: llvm-readelf --symbols %S/Inputs/mips-gp-disp.so \
# RUN: | FileCheck -check-prefix=EXT-SO %s # RUN: | FileCheck -check-prefix=EXT-SO %s
# RUN: llvm-objdump -d -t --no-show-raw-insn %t.so | FileCheck -check-prefix=DIS %s # RUN: llvm-objdump -d -t --no-show-raw-insn %t.so | FileCheck -check-prefix=DIS %s
# RUN: llvm-readelf -r %t.so | FileCheck -check-prefix=REL %s # RUN: llvm-readelf -r %t.so | FileCheck -check-prefix=REL %s
# INT-SO: 00000000 0 NOTYPE LOCAL HIDDEN ABS _gp_disp # INT-SO: 00000000 0 NOTYPE LOCAL HIDDEN ABS _gp_disp
# EXT-SO: 00020000 0 NOTYPE GLOBAL DEFAULT 9 _gp_disp # EXT-SO: 00020000 0 NOTYPE GLOBAL DEFAULT 9 _gp_disp
# DIS: 00037ff0 .got 00000000 .hidden _gp # DIS: 00037ff0 l .got 00000000 .hidden _gp
# DIS: 00002000 .text 00000000 __start # DIS: 00002000 g .text 00000000 __start
# DIS: Disassembly of section .text: # DIS: Disassembly of section .text:
# DIS-EMPTY: # DIS-EMPTY:
# DIS-NEXT: __start: # DIS-NEXT: __start:
# DIS-NEXT: lui $8, 3 # DIS-NEXT: lui $8, 3
# DIS-NEXT: addi $8, $8, 24560 # DIS-NEXT: addi $8, $8, 24560
# ^-- (_gp - __start) & 0xffff # ^-- (_gp - __start) & 0xffff
# REL: There are no relocations in this file # REL: There are no relocations in this file
.text .text
.globl __start .globl __start
__start: __start:
lui $t0,%hi(_gp_disp) lui $t0,%hi(_gp_disp)
addi $t0,$t0,%lo(_gp_disp) addi $t0,$t0,%lo(_gp_disp)
lw $v0,%call16(_foo)($gp) lw $v0,%call16(_foo)($gp)

lld/test/ELF/mips-gp-ext.s

Show All 19 Lines
# RUN: echo "SECTIONS { \ # RUN: echo "SECTIONS { \
# RUN: .text : { *(.text) } \ # RUN: .text : { *(.text) } \
# RUN: _gp = 0x200; \ # RUN: _gp = 0x200; \
# RUN: .got : { *(.got) } }" > %t.abs.script # RUN: .got : { *(.got) } }" > %t.abs.script
# RUN: ld.lld -shared -o %t.abs.so --script %t.abs.script %t.o # RUN: ld.lld -shared -o %t.abs.so --script %t.abs.script %t.o
# RUN: llvm-objdump -s -t %t.abs.so | FileCheck --check-prefix=ABS %s # RUN: llvm-objdump -s -t %t.abs.so | FileCheck --check-prefix=ABS %s
# REL: 000000e0 .text 00000000 foo # REL: 000000e0 l .text 00000000 foo
# REL: 00000000 *ABS* 00000000 .hidden _gp_disp # REL: 00000000 l *ABS* 00000000 .hidden _gp_disp
# REL: 000001ec *ABS* 00000000 .hidden _gp # REL: 000001ec l *ABS* 00000000 .hidden _gp
# REL: Contents of section .reginfo: # REL: Contents of section .reginfo:
# REL-NEXT: 0018 10000104 00000000 00000000 00000000 # REL-NEXT: 0018 10000104 00000000 00000000 00000000
# REL-NEXT: 0028 00000000 000001ec # REL-NEXT: 0028 00000000 000001ec
# ^-- _gp # ^-- _gp
# REL: Contents of section .text: # REL: Contents of section .text:
# REL-NEXT: 00e0 3c080000 2108010c 8f82ff1c # REL-NEXT: 00e0 3c080000 2108010c 8f82ff1c
# ^-- %hi(_gp_disp) # ^-- %hi(_gp_disp)
# ^-- %lo(_gp_disp) # ^-- %lo(_gp_disp)
# ^-- 8 - (0x1ec - 0x100) # ^-- 8 - (0x1ec - 0x100)
# G - (GP - .got) # G - (GP - .got)
# REL: Contents of section .data: # REL: Contents of section .data:
# REL-NEXT: 00f0 fffffef4 # REL-NEXT: 00f0 fffffef4
# ^-- 0x30-0x1ec # ^-- 0x30-0x1ec
# foo - GP # foo - GP
# ABS: 000000e0 .text 00000000 foo # ABS: 000000e0 l .text 00000000 foo
# ABS: 00000000 *ABS* 00000000 .hidden _gp_disp # ABS: 00000000 l *ABS* 00000000 .hidden _gp_disp
# ABS: 00000200 *ABS* 00000000 .hidden _gp # ABS: 00000200 l *ABS* 00000000 .hidden _gp
# ABS: Contents of section .reginfo: # ABS: Contents of section .reginfo:
# ABS-NEXT: 0018 10000104 00000000 00000000 00000000 # ABS-NEXT: 0018 10000104 00000000 00000000 00000000
# ABS-NEXT: 0028 00000000 00000200 # ABS-NEXT: 0028 00000000 00000200
# ^-- _gp # ^-- _gp
# ABS: Contents of section .text: # ABS: Contents of section .text:
# ABS-NEXT: 00e0 3c080000 21080120 8f82ff08 # ABS-NEXT: 00e0 3c080000 21080120 8f82ff08
Show All 18 Lines

lld/test/ELF/mips-gp-local.s

# REQUIRES: mips # REQUIRES: mips
# Check handling of relocations against __gnu_local_gp symbol. # Check handling of relocations against __gnu_local_gp symbol.
# RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t.o # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t.o
# RUN: echo "SECTIONS { \ # RUN: echo "SECTIONS { \
# RUN: . = 0x10000; .text ALIGN(0x1000) : { *(.text) } \ # RUN: . = 0x10000; .text ALIGN(0x1000) : { *(.text) } \
# RUN: . = 0x30000; .got : { *(.got) } \ # RUN: . = 0x30000; .got : { *(.got) } \
# RUN: }" > %t.script # RUN: }" > %t.script
# RUN: ld.lld --script %t.script -o %t.exe %t.o # RUN: ld.lld --script %t.script -o %t.exe %t.o
# RUN: llvm-objdump -d -t --no-show-raw-insn %t.exe | FileCheck %s # RUN: llvm-objdump -d -t --no-show-raw-insn %t.exe | FileCheck %s
# CHECK: 00037ff0 .got 00000000 .hidden _gp # CHECK: 00037ff0 l .got 00000000 .hidden _gp
# CHECK: 00011000 .text 00000000 __start # CHECK: 00011000 g .text 00000000 __start
# CHECK: __start: # CHECK: __start:
# CHECK-NEXT: lui $8, 3 # CHECK-NEXT: lui $8, 3
# CHECK-NEXT: addi $8, $8, 32752 # CHECK-NEXT: addi $8, $8, 32752
.text .text
.globl __start .globl __start
__start: __start:
lui $t0,%hi(__gnu_local_gp) lui $t0,%hi(__gnu_local_gp)
addi $t0,$t0,%lo(__gnu_local_gp) addi $t0,$t0,%lo(__gnu_local_gp)

lld/test/ELF/mips-gprel32-relocs-gp0.s

Show All 9 Lines
# RUN: . = 0x20000; .text : { *(.text) } \ # RUN: . = 0x20000; .text : { *(.text) } \
# RUN: }" > %t.script # RUN: }" > %t.script
# RUN: ld.lld -shared --script %t.script -o %t.so %S/Inputs/mips-gp0-non-zero.o # RUN: ld.lld -shared --script %t.script -o %t.so %S/Inputs/mips-gp0-non-zero.o
# RUN: llvm-objdump -s -t %t.so | FileCheck --check-prefix=DUMP %s # RUN: llvm-objdump -s -t %t.so | FileCheck --check-prefix=DUMP %s
# REL: GP: 0x0 # REL: GP: 0x0
# DUMP: SYMBOL TABLE: # DUMP: SYMBOL TABLE:
# DUMP: 00020008 .text 00000000 bar # DUMP: 00020008 l .text 00000000 bar
# DUMP: 00020004 .text 00000000 foo # DUMP: 00020004 l .text 00000000 foo
# DUMP: 00028000 .got 00000000 .hidden _gp # DUMP: 00028000 l .got 00000000 .hidden _gp
# DUMP: Contents of section .rodata: # DUMP: Contents of section .rodata:
# DUMP: 1000 fffffff4 fffffff8 # DUMP: 1000 fffffff4 fffffff8
# ^ 0x20004 + 0x7ff0 - 0x28000 # ^ 0x20004 + 0x7ff0 - 0x28000
# ^ 0x20008 + 0x7ff0 - 0x28000 # ^ 0x20008 + 0x7ff0 - 0x28000
.text .text
.global __start .global __start
Show All 11 Lines

lld/test/ELF/mips-gprel32-relocs.s

Show All 18 Linesbar:
nop nop
.section .rodata, "a" .section .rodata, "a"
v1: v1:
.gpword foo .gpword foo
.gpword bar .gpword bar
# CHECK: SYMBOL TABLE: # CHECK: SYMBOL TABLE:
# CHECK: 00020008 .text 00000000 bar # CHECK: 00020008 l .text 00000000 bar
# CHECK: 00020004 .text 00000000 foo # CHECK: 00020004 l .text 00000000 foo
# CHECK: 00028000 .got 00000000 .hidden _gp # CHECK: 00028000 l .got 00000000 .hidden _gp
# CHECK: Contents of section .rodata: # CHECK: Contents of section .rodata:
# CHECK: 1000 ffff8004 ffff8008 # CHECK: 1000 ffff8004 ffff8008
# ^ 0x20004 - 0x28000 # ^ 0x20004 - 0x28000
# ^ 0x20008 - 0x28000 # ^ 0x20008 - 0x28000

lld/test/ELF/mips-hilo-gp-disp.s

Show All 18 Lines__start:
lui $t0,%hi(_gp_disp) lui $t0,%hi(_gp_disp)
addi $t0,$t0,%lo(_gp_disp) addi $t0,$t0,%lo(_gp_disp)
lw $v0,%call16(_foo)($gp) lw $v0,%call16(_foo)($gp)
bar: bar:
lui $t0,%hi(_gp_disp) lui $t0,%hi(_gp_disp)
addi $t0,$t0,%lo(_gp_disp) addi $t0,$t0,%lo(_gp_disp)
# CHECK: SYMBOL TABLE: # CHECK: SYMBOL TABLE:
# CHECK: 0001100c .text 00000000 bar # CHECK: 0001100c l .text 00000000 bar
# CHECK: 00037ff0 .got 00000000 .hidden _gp # CHECK: 00037ff0 l .got 00000000 .hidden _gp
# CHECK: 00011000 .text 00000000 __start # CHECK: 00011000 g .text 00000000 __start
# CHECK: Disassembly of section .text: # CHECK: Disassembly of section .text:
# CHECK-EMPTY: # CHECK-EMPTY:
# CHECK-NEXT: __start: # CHECK-NEXT: __start:
# CHECK-NEXT: 11000: lui $8, 2 # CHECK-NEXT: 11000: lui $8, 2
# ^-- %hi(0x37ff0-0x11000) # ^-- %hi(0x37ff0-0x11000)
# CHECK-NEXT: 11004: addi $8, $8, 28656 # CHECK-NEXT: 11004: addi $8, $8, 28656
# ^-- %lo(0x37ff0-0x11004+4) # ^-- %lo(0x37ff0-0x11004+4)
# CHECK: bar: # CHECK: bar:
# CHECK-NEXT: 1100c: lui $8, 2 # CHECK-NEXT: 1100c: lui $8, 2
# ^-- %hi(0x37ff0-0x1100c) # ^-- %hi(0x37ff0-0x1100c)
# CHECK-NEXT: 11010: addi $8, $8, 28644 # CHECK-NEXT: 11010: addi $8, $8, 28644
# ^-- %lo(0x37ff0-0x11010+4) # ^-- %lo(0x37ff0-0x11010+4)

lld/test/ELF/mips-hilo-hi-only.s

Show All 10 Lines__start:
lui $t0,%hi(__start+0x10000) lui $t0,%hi(__start+0x10000)
addi $t0,$t0,%lo(_label) addi $t0,$t0,%lo(_label)
_label: _label:
nop nop
# WARN: can't find matching R_MIPS_LO16 relocation for R_MIPS_HI16 # WARN: can't find matching R_MIPS_LO16 relocation for R_MIPS_HI16
# CHECK: SYMBOL TABLE: # CHECK: SYMBOL TABLE:
# CHECK: 00020{{0*}}[[VAL:[0-9a-f]+]] .text 00000000 _label # CHECK: 00020{{0*}}[[VAL:[0-9a-f]+]] l .text 00000000 _label
# CHECK: 00020{{.*}} .text 00000000 __start # CHECK: 00020{{.*}} g .text 00000000 __start
# CHECK: __start: # CHECK: __start:
# CHECK-NEXT: lui $8, 0x3 # CHECK-NEXT: lui $8, 0x3
# ^-- %hi(__start) w/o addend # ^-- %hi(__start) w/o addend
# CHECK-NEXT: addi $8, $8, 0x[[VAL]] # CHECK-NEXT: addi $8, $8, 0x[[VAL]]
# ^-- %lo(_label) # ^-- %lo(_label)

lld/test/ELF/mips-hilo.s

Show All 26 Linesl1:
.globl g1 .globl g1
.type g1,@object .type g1,@object
.size g1,4 .size g1,4
g1: g1:
.word 0 .word 0
# CHECK: SYMBOL TABLE: # CHECK: SYMBOL TABLE:
# CHECK: 0021020 l O .data 00000004 l1 # CHECK: 0021020 l O .data 00000004 l1
# CHECK: 0021000 .text 00000000 __start # CHECK: 0021000 g .text 00000000 __start
# CHECK: 0021024 g O .data 00000004 g1 # CHECK: 0021024 g O .data 00000004 g1
# CHECK: __start: # CHECK: __start:
# CHECK-NEXT: 21000: lui $8, 2 # CHECK-NEXT: 21000: lui $8, 2
# ^-- %hi(__start+4) # ^-- %hi(__start+4)
# CHECK-NEXT: 21004: lui $9, 2 # CHECK-NEXT: 21004: lui $9, 2
# ^-- %hi(g1+8) # ^-- %hi(g1+8)
# CHECK-NEXT: 21008: addi $8, $8, 4100 # CHECK-NEXT: 21008: addi $8, $8, 4100
Show All 9 Lines

lld/test/ELF/mips-mgot.s

Show All 10 Lines
# RUN: . = 0x70000; .got : { *(.got) } \ # RUN: . = 0x70000; .got : { *(.got) } \
# RUN: }" > %t.script # RUN: }" > %t.script
# RUN: ld.lld -shared -mips-got-size 52 --script %t.script %t0.o %t1.o %t2.o -o %t.so # RUN: ld.lld -shared -mips-got-size 52 --script %t.script %t0.o %t1.o %t2.o -o %t.so
# RUN: llvm-objdump -s -section=.got -t %t.so | FileCheck %s # RUN: llvm-objdump -s -section=.got -t %t.so | FileCheck %s
# RUN: llvm-readobj -r --dyn-syms -A %t.so | FileCheck -check-prefix=GOT %s # RUN: llvm-readobj -r --dyn-syms -A %t.so | FileCheck -check-prefix=GOT %s
# CHECK: SYMBOL TABLE: # CHECK: SYMBOL TABLE:
# CHECK: 00000000 l O .tdata 00000000 loc0 # CHECK: 00000000 l O .tdata 00000000 loc0
# CHECK: [[FOO0:[0-9a-f]+]] .text 00000000 foo0 # CHECK: [[FOO0:[0-9a-f]+]] g .text 00000000 foo0
# CHECK: 00000000 g O .tdata 00000000 tls0 # CHECK: 00000000 g O .tdata 00000000 tls0
# CHECK: 00000004 g O .tdata 00000000 tls1 # CHECK: 00000004 g O .tdata 00000000 tls1
# CHECK: [[FOO2:[0-9a-f]+]] .text 00000000 foo2 # CHECK: [[FOO2:[0-9a-f]+]] g .text 00000000 foo2
# CHECK: Contents of section .got: # CHECK: Contents of section .got:
# CHECK-NEXT: 70000 00000000 80000000 [[FOO0]] [[FOO2]] # CHECK-NEXT: 70000 00000000 80000000 [[FOO0]] [[FOO2]]
# CHECK-NEXT: 70010 00000000 00000004 00010000 00020000 # CHECK-NEXT: 70010 00000000 00000004 00010000 00020000
# CHECK-NEXT: 70020 00030000 00040000 00050000 00060000 # CHECK-NEXT: 70020 00030000 00040000 00050000 00060000
# CHECK-NEXT: 70030 00000000 00000000 00000000 00000000 # CHECK-NEXT: 70030 00000000 00000000 00000000 00000000
# CHECK-NEXT: 70040 00000000 00000000 00000000 # CHECK-NEXT: 70040 00000000 00000000 00000000
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

lld/test/ELF/mips-micro-cross-calls.s

Show All 10 Lines
# RUN: --no-show-raw-insn --print-imm-hex %t-eb.exe \ # RUN: --no-show-raw-insn --print-imm-hex %t-eb.exe \
# RUN: | FileCheck --check-prefixes=SYM,REG %s # RUN: | FileCheck --check-prefixes=SYM,REG %s
# RUN: llvm-objdump -d -t -mattr=+micromips \ # RUN: llvm-objdump -d -t -mattr=+micromips \
# RUN: --no-show-raw-insn --print-imm-hex %t-eb.exe \ # RUN: --no-show-raw-insn --print-imm-hex %t-eb.exe \
# RUN: | FileCheck --check-prefixes=SYM,MICRO %s # RUN: | FileCheck --check-prefixes=SYM,MICRO %s
# REG: {{0*}}[[FOOT:[0-9a-f]+]] l F .text 0000000e 0x80 __microLA25Thunk_foo # REG: {{0*}}[[FOOT:[0-9a-f]+]] l F .text 0000000e 0x80 __microLA25Thunk_foo
# REG: {{0*}}[[BAR:[0-9a-f]+]] g F .text 00000000 bar # REG: {{0*}}[[BAR:[0-9a-f]+]] g F .text 00000000 bar
# REG: {{0*}}[[MIC:[0-9a-f]+]] .text 00000000 0x80 micro # REG: {{0*}}[[MIC:[0-9a-f]+]] g .text 00000000 0x80 micro
# REG: __start: # REG: __start:
# REG-NEXT: jalx 0x[[MIC]] <micro> # REG-NEXT: jalx 0x[[MIC]] <micro>
# REG-NEXT: nop # REG-NEXT: nop
# REG-NEXT: jalx 0x[[FOOT]] <__microLA25Thunk_foo> # REG-NEXT: jalx 0x[[FOOT]] <__microLA25Thunk_foo>
# REG: __LA25Thunk_bar: # REG: __LA25Thunk_bar:
# REG-NEXT: lui $25, 0x2 # REG-NEXT: lui $25, 0x2
# REG-NEXT: j 0x[[BAR]] <bar> # REG-NEXT: j 0x[[BAR]] <bar>
# MICRO: {{0*}}[[BART:[0-9a-f]+]] l F .text 00000010 __LA25Thunk_bar # MICRO: {{0*}}[[BART:[0-9a-f]+]] l F .text 00000010 __LA25Thunk_bar
# MICRO: {{0*}}[[START:[0-9a-f]+]] .text 00000000 __start # MICRO: {{0*}}[[START:[0-9a-f]+]] g .text 00000000 __start
# MICRO: {{0*}}[[FOO:[0-9a-f]+]] g F .text 00000000 0x80 foo # MICRO: {{0*}}[[FOO:[0-9a-f]+]] g F .text 00000000 0x80 foo
# MICRO: micro: # MICRO: micro:
# MICRO-NEXT: jalx 0x[[START]] # MICRO-NEXT: jalx 0x[[START]]
# MICRO-NEXT: nop # MICRO-NEXT: nop
# MICRO-NEXT: jalx 0x[[BART]] # MICRO-NEXT: jalx 0x[[BART]]
# MICRO: __microLA25Thunk_foo: # MICRO: __microLA25Thunk_foo:
Show All 15 Lines

lld/test/ELF/mips-micro-relocs.s

Show All 19 Lines
# RUN: -mattr=micromips %S/Inputs/mips-micro.s -o %t1el.o # RUN: -mattr=micromips %S/Inputs/mips-micro.s -o %t1el.o
# RUN: llvm-mc -filetype=obj -triple=mipsel-unknown-linux \ # RUN: llvm-mc -filetype=obj -triple=mipsel-unknown-linux \
# RUN: -mattr=micromips %s -o %t2el.o # RUN: -mattr=micromips %s -o %t2el.o
# RUN: ld.lld -o %tel.exe -script %t.script %t1el.o %t2el.o # RUN: ld.lld -o %tel.exe -script %t.script %t1el.o %t2el.o
# RUN: llvm-objdump -d -t -s -mattr=micromips --no-show-raw-insn %tel.exe \ # RUN: llvm-objdump -d -t -s -mattr=micromips --no-show-raw-insn %tel.exe \
# RUN: | FileCheck --check-prefixes=ASM,EL %s # RUN: | FileCheck --check-prefixes=ASM,EL %s
# RUN: llvm-readelf -h %tel.exe | FileCheck --check-prefix=ELF %s # RUN: llvm-readelf -h %tel.exe | FileCheck --check-prefix=ELF %s
# ASM: 00038000 .got 00000000 .hidden _gp # ASM: 00038000 l .got 00000000 .hidden _gp
# ASM: 00020100 g F .text 00000000 0x80 foo # ASM: 00020100 g F .text 00000000 0x80 foo
# ASM: 00020110 .text 00000000 0x80 __start # ASM: 00020110 g .text 00000000 0x80 __start
# EB: Contents of section .data: # EB: Contents of section .data:
# EB-NEXT: 30000 fffe8111 # EB-NEXT: 30000 fffe8111
# EB: Contents of section .debug_info # EB: Contents of section .debug_info
# EB-NEXT: 0000 00020111 # EB-NEXT: 0000 00020111
# EL: Contents of section .data: # EL: Contents of section .data:
Show All 37 Lines

lld/test/ELF/mips-micror6-relocs.s

Show All 15 Lines
# RUN: llvm-mc -filetype=obj -triple=mipsel -mcpu=mips32r6 \ # RUN: llvm-mc -filetype=obj -triple=mipsel -mcpu=mips32r6 \
# RUN: %S/Inputs/mips-micro.s -o %t1el.o # RUN: %S/Inputs/mips-micro.s -o %t1el.o
# RUN: llvm-mc -filetype=obj -triple=mipsel -mcpu=mips32r6 %s -o %t2el.o # RUN: llvm-mc -filetype=obj -triple=mipsel -mcpu=mips32r6 %s -o %t2el.o
# RUN: ld.lld -o %tel.exe -script %t.script %t1el.o %t2el.o # RUN: ld.lld -o %tel.exe -script %t.script %t1el.o %t2el.o
# RUN: llvm-objdump -d -t -mattr=micromips --no-show-raw-insn %tel.exe \ # RUN: llvm-objdump -d -t -mattr=micromips --no-show-raw-insn %tel.exe \
# RUN: | FileCheck %s # RUN: | FileCheck %s
# CHECK: 00020100 g F .text 00000000 0x80 foo # CHECK: 00020100 g F .text 00000000 0x80 foo
# CHECK: 00020110 .text 00000000 0x80 __start # CHECK: 00020110 g .text 00000000 0x80 __start
# CHECK: __start: # CHECK: __start:
# CHECK-NEXT: 20110: lapc $2, -12 # CHECK-NEXT: 20110: lapc $2, -12
# CHECK-NEXT: beqzc $3, -36 # CHECK-NEXT: beqzc $3, -36
# CHECK-NEXT: balc -24 <foo> # CHECK-NEXT: balc -24 <foo>
.text .text
.set micromips .set micromips
.global __start .global __start
__start: __start:
addiupc $2, foo+4 # R_MICROMIPS_PC19_S2 addiupc $2, foo+4 # R_MICROMIPS_PC19_S2
beqzc $3, foo+4 # R_MICROMIPS_PC21_S1 beqzc $3, foo+4 # R_MICROMIPS_PC21_S1
balc foo+4 # R_MICROMIPS_PC26_S1 balc foo+4 # R_MICROMIPS_PC26_S1

lld/test/ELF/mips-n32-rels.s

Show All 20 Lines
loc: loc:
daddiu $gp,$gp,%lo(%neg(%gp_rel(__start))) # R_MIPS_GPREL16 daddiu $gp,$gp,%lo(%neg(%gp_rel(__start))) # R_MIPS_GPREL16
# R_MIPS_SUB # R_MIPS_SUB
# R_MIPS_LO16 # R_MIPS_LO16
.section .rodata,"a",@progbits .section .rodata,"a",@progbits
.gpword(loc) # R_MIPS_GPREL32 .gpword(loc) # R_MIPS_GPREL32
# CHECK: 00020104 .text 00000000 loc # CHECK: 00020104 l .text 00000000 loc
# CHECK: 00028100 .got 00000000 .hidden _gp # CHECK: 00028100 l .got 00000000 .hidden _gp
# CHECK: 00020100 g F .text 00000000 __start # CHECK: 00020100 g F .text 00000000 __start
# CHECK: Contents of section .rodata: # CHECK: Contents of section .rodata:
# CHECK-NEXT: {{[0-9a-f]+}} ffff8004 # CHECK-NEXT: {{[0-9a-f]+}} ffff8004
# ^-- loc - _gp # ^-- loc - _gp
# CHECK: Disassembly of section .text: # CHECK: Disassembly of section .text:
# CHECK-EMPTY: # CHECK-EMPTY:
Show All 21 Lines

lld/test/ELF/mips-nonalloc.s

# REQUIRES: mips # REQUIRES: mips
# Check reading addends for relocations in non-allocatable sections. # Check reading addends for relocations in non-allocatable sections.
# RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t1.o # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t1.o
# RUN: echo '.section .debug_info,"",@0x7000001e; .word __start' | \ # RUN: echo '.section .debug_info,"",@0x7000001e; .word __start' | \
# RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux - -o %t2.o # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux - -o %t2.o
# RUN: ld.lld %t1.o %t2.o -o %t.exe # RUN: ld.lld %t1.o %t2.o -o %t.exe
# RUN: llvm-objdump -t -s %t.exe | FileCheck %s # RUN: llvm-objdump -t -s %t.exe | FileCheck %s
# CHECK: [[SYM:[0-9a-f]+]] .text 00000000 __start # CHECK: [[SYM:[0-9a-f]+]] g .text 00000000 __start
# CHECK: Contents of section .debug_info: # CHECK: Contents of section .debug_info:
# CHECK-NEXT: 0000 ffffffff [[SYM]] [[SYM]] # CHECK-NEXT: 0000 ffffffff [[SYM]] [[SYM]]
# ^-------^-- __start # ^-------^-- __start
.global __start .global __start
__start: __start:
nop nop
.section .debug_info,"",@0x7000001e .section .debug_info,"",@0x7000001e
.word 0xffffffff .word 0xffffffff
.word __start .word __start

lld/test/ELF/mips-pc-relocs.s

Show All 20 Lines__start:
beqzc $9, _foo # R_MIPS_PC21_S2 beqzc $9, _foo # R_MIPS_PC21_S2
bc _foo # R_MIPS_PC26_S2 bc _foo # R_MIPS_PC26_S2
aluipc $2, %pcrel_hi(_foo) # R_MIPS_PCHI16 aluipc $2, %pcrel_hi(_foo) # R_MIPS_PCHI16
addiu $2, $2, %pcrel_lo(_foo) # R_MIPS_PCLO16 addiu $2, $2, %pcrel_lo(_foo) # R_MIPS_PCLO16
.data .data
.word _foo+8-. # R_MIPS_PC32 .word _foo+8-. # R_MIPS_PC32
# CHECK: 00020000 .text 00000000 __start # CHECK: 00020000 g .text 00000000 __start
# CHECK: 00020020 .text 00000000 _foo # CHECK: 00020020 g .text 00000000 _foo
# CHECK: Contents of section .data: # CHECK: Contents of section .data:
# CHECK-NEXT: 30000 ffff0028 00000000 00000000 00000000 # CHECK-NEXT: 30000 ffff0028 00000000 00000000 00000000
# ^-- 0x20020 + 8 - 0x30000 # ^-- 0x20020 + 8 - 0x30000
# CHECK: Disassembly of section .text: # CHECK: Disassembly of section .text:
# CHECK-EMPTY: # CHECK-EMPTY:
# CHECK-NEXT: __start: # CHECK-NEXT: __start:
Show All 12 Lines

lld/test/ELF/mips-tls-64.s

Show All 17 Lines
# RUN: ld.lld -shared %t.o %t.so -script %t.script -o %t-out.so # RUN: ld.lld -shared %t.o %t.so -script %t.script -o %t-out.so
# RUN: llvm-objdump -d -s -t --no-show-raw-insn %t-out.so \ # RUN: llvm-objdump -d -s -t --no-show-raw-insn %t-out.so \
# RUN: | FileCheck -check-prefix=DIS-SO %s # RUN: | FileCheck -check-prefix=DIS-SO %s
# RUN: llvm-readobj -r -A %t-out.so | FileCheck -check-prefix=SO %s # RUN: llvm-readobj -r -A %t-out.so | FileCheck -check-prefix=SO %s
# DIS: 0000000000000000 l O .tdata 0000000000000000 loc # DIS: 0000000000000000 l O .tdata 0000000000000000 loc
# DIS: 0000000000000004 g O .tdata 0000000000000000 bar # DIS: 0000000000000004 g O .tdata 0000000000000000 bar
# DIS: 0000000000000000 g O *UND* 0000000000000000 foo # DIS: 0000000000000000 O *UND* 0000000000000000 foo
# DIS: Contents of section .got: # DIS: Contents of section .got:
# DIS-NEXT: 30000 00000000 00000000 80000000 00000000 # DIS-NEXT: 30000 00000000 00000000 80000000 00000000
# DIS-NEXT: 30010 00000000 00000000 ffffffff ffff9004 # DIS-NEXT: 30010 00000000 00000000 ffffffff ffff9004
# DIS-NEXT: 30020 00000000 00000000 00000000 00000000 # DIS-NEXT: 30020 00000000 00000000 00000000 00000000
# DIS-NEXT: 30030 00000000 00000001 00000000 00000000 # DIS-NEXT: 30030 00000000 00000001 00000000 00000000
# DIS-NEXT: 30040 00000000 00000001 ffffffff ffff8004 # DIS-NEXT: 30040 00000000 00000001 ffffffff ffff8004
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

lld/test/ELF/mips-tls-static-64.s

# REQUIRES: mips # REQUIRES: mips
# Check handling TLS related relocations and symbols when linking # Check handling TLS related relocations and symbols when linking
# a 64-bit static executable. # a 64-bit static executable.
# RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %t # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %t
# RUN: ld.lld -static %t -o %t.exe # RUN: ld.lld -static %t -o %t.exe
# RUN: llvm-objdump -s -t %t.exe | FileCheck %s # RUN: llvm-objdump -s -t %t.exe | FileCheck %s
# CHECK: SYMBOL TABLE: # CHECK: SYMBOL TABLE:
# CHECK: [[TGA:[0-9a-f]{8}]] .text 0000000000000000 __tls_get_addr # CHECK: [[TGA:[0-9a-f]{8}]] g .text 0000000000000000 __tls_get_addr
# CHECK: 0000000000000000 g O .tdata 0000000000000000 tls1 # CHECK: 0000000000000000 g O .tdata 0000000000000000 tls1
# #
# CHECK: Contents of section .data: # CHECK: Contents of section .data:
# CHECK-NEXT: {{.*}} [[TGA]] ffffffff ffff8004 ffffffff # CHECK-NEXT: {{.*}} [[TGA]] ffffffff ffff8004 ffffffff
# CHECK-NEXT: {{.*}} ffff9004 # CHECK-NEXT: {{.*}} ffff9004
.text .text
.global __start .global __start
Show All 18 Lines

lld/test/ELF/mips-tls-static.s

# REQUIRES: mips # REQUIRES: mips
# Check handling TLS related relocations and symbols when linking # Check handling TLS related relocations and symbols when linking
# a static executable. # a static executable.
# RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t
# RUN: ld.lld -static %t -o %t.exe # RUN: ld.lld -static %t -o %t.exe
# RUN: llvm-objdump -s -t %t.exe | FileCheck %s # RUN: llvm-objdump -s -t %t.exe | FileCheck %s
# CHECK: SYMBOL TABLE: # CHECK: SYMBOL TABLE:
# CHECK: [[TGA:[0-9a-f]+]] .text 00000000 __tls_get_addr # CHECK: [[TGA:[0-9a-f]+]] g .text 00000000 __tls_get_addr
# CHECK: 00000000 g O .tdata 00000000 tls1 # CHECK: 00000000 g O .tdata 00000000 tls1
# #
# CHECK: Contents of section .data: # CHECK: Contents of section .data:
# CHECK-NEXT: {{.*}} [[TGA]] ffff8004 ffff9004 # CHECK-NEXT: {{.*}} [[TGA]] ffff8004 ffff9004
# CHECK: Contents of section .got: # CHECK: Contents of section .got:
# CHECK-NEXT: {{.*}} 00000000 80000000 ffff9000 00000001 # CHECK-NEXT: {{.*}} 00000000 80000000 ffff9000 00000001
# CHECK-NEXT: {{.*}} ffff8000 00000001 00000000 # CHECK-NEXT: {{.*}} ffff8000 00000001 00000000
Show All 23 Lines

lld/test/ELF/mips-tls.s

Show All 17 Lines
# RUN: ld.lld -shared %t.o %t.so -script %t.script -o %t-out.so # RUN: ld.lld -shared %t.o %t.so -script %t.script -o %t-out.so
# RUN: llvm-objdump -d -s -t --no-show-raw-insn %t-out.so \ # RUN: llvm-objdump -d -s -t --no-show-raw-insn %t-out.so \
# RUN: | FileCheck -check-prefix=DIS-SO %s # RUN: | FileCheck -check-prefix=DIS-SO %s
# RUN: llvm-readobj -r -A %t-out.so | FileCheck -check-prefix=SO %s # RUN: llvm-readobj -r -A %t-out.so | FileCheck -check-prefix=SO %s
# DIS: 00000000 l O .tdata 00000000 loc # DIS: 00000000 l O .tdata 00000000 loc
# DIS: 00000004 g O .tdata 00000000 bar # DIS: 00000004 g O .tdata 00000000 bar
# DIS: 00000000 g O *UND* 00000000 foo # DIS: 00000000 O *UND* 00000000 foo
# DIS: Contents of section .got: # DIS: Contents of section .got:
# DIS-NEXT: 30000 00000000 80000000 00000000 ffff9004 # DIS-NEXT: 30000 00000000 80000000 00000000 ffff9004
# DIS-NEXT: 30010 00000000 00000000 00000001 00000000 # DIS-NEXT: 30010 00000000 00000000 00000001 00000000
# DIS-NEXT: 30020 00000001 ffff8004 # DIS-NEXT: 30020 00000001 ffff8004
# DIS: __start: # DIS: __start:
# DIS-NEXT: addiu $2, $3, -32736 # DIS-NEXT: addiu $2, $3, -32736
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

lld/test/ELF/wrap-no-real.s

Show All 12 Lines
// CHECK: _start: // CHECK: _start:
// CHECK-NEXT: movl $0x11010, %edx // CHECK-NEXT: movl $0x11010, %edx
// CHECK-NEXT: movl $0x11010, %edx // CHECK-NEXT: movl $0x11010, %edx
// CHECK-NEXT: movl $0x11000, %edx // CHECK-NEXT: movl $0x11000, %edx
// RUN: llvm-objdump -t %t | FileCheck -check-prefix=SYM %s // RUN: llvm-objdump -t %t | FileCheck -check-prefix=SYM %s
// SYM: {{.*}} .dynamic 0000000000000000 .hidden _DYNAMIC // SYM: {{.*}} l .dynamic 0000000000000000 .hidden _DYNAMIC
// SYM-NEXT: 0000000000011000 *ABS* 0000000000000000 __real_foo // SYM-NEXT: 0000000000011000 g *ABS* 0000000000000000 __real_foo
// SYM-NEXT: 0000000000011010 *ABS* 0000000000000000 __wrap_foo // SYM-NEXT: 0000000000011010 g *ABS* 0000000000000000 __wrap_foo
// SYM-NEXT: {{.*}} .text 0000000000000000 _start // SYM-NEXT: {{.*}} g .text 0000000000000000 _start
// SYM-NEXT: 0000000000011000 *ABS* 0000000000000000 foo // SYM-NEXT: 0000000000011000 g *ABS* 0000000000000000 foo
.global _start .global _start
_start: _start:
movl $foo, %edx movl $foo, %edx
movl $__wrap_foo, %edx movl $__wrap_foo, %edx
movl $__real_foo, %edx movl $__real_foo, %edx

llvm/test/MC/AArch64/inst-directive.s

Show All 24 Lines
// CHECK-ASM: .inst 0x5e104020 // CHECK-ASM: .inst 0x5e104020
// CHECK-OBJ: Section { // CHECK-OBJ: Section {
// CHECK-OBJ: Name: .inst.aarch64_inst // CHECK-OBJ: Name: .inst.aarch64_inst
// CHECK-OBJ: SectionData ( // CHECK-OBJ: SectionData (
// CHECK-OBJ-NEXT: 0000: 2040105E // CHECK-OBJ-NEXT: 0000: 2040105E
// CHECK-OBJ-NEXT: ) // CHECK-OBJ-NEXT: )
// CHECK-SYMS-NOT: 0000000000000000 .inst.aarch64_inst 0000000000000000 $d // CHECK-SYMS-NOT: 0000000000000000 l .inst.aarch64_inst 0000000000000000 $d
// CHECK-SYMS: 0000000000000000 .inst.aarch64_inst 0000000000000000 $x // CHECK-SYMS: 0000000000000000 l .inst.aarch64_inst 0000000000000000 $x
// CHECK-SYMS-NOT: 0000000000000000 .inst.aarch64_inst 0000000000000000 $d // CHECK-SYMS-NOT: 0000000000000000 l .inst.aarch64_inst 0000000000000000 $d

llvm/test/MC/AArch64/mapping-across-sections.s

Show All 15 Lines// Changing back to .text should not emit a redundant $x
add w0, w0, w0 add w0, w0, w0
// With all those constraints, we want: // With all those constraints, we want:
// + .text to have $x at 0 and no others // + .text to have $x at 0 and no others
// + .wibble to have $x at 0 // + .wibble to have $x at 0
// + .starts_data to have $d at 0 // + .starts_data to have $d at 0
// CHECK: 0000000000000000 .starts_data 0000000000000000 $d // CHECK: 0000000000000000 l .starts_data 0000000000000000 $d
// CHECK-NEXT: 0000000000000000 .text 0000000000000000 $x // CHECK-NEXT: 0000000000000000 l .text 0000000000000000 $x
// CHECK-NEXT: 0000000000000000 .wibble 0000000000000000 $x // CHECK-NEXT: 0000000000000000 l .wibble 0000000000000000 $x
// CHECK-NOT: ${{[adtx]}} // CHECK-NOT: ${{[adtx]}}

llvm/test/MC/ARM/mapping-initial.s

@ RUN: llvm-mc -triple=armv7a-none-eabi -filetype=obj < %s | llvm-objdump -t - | FileCheck %s --check-prefix=ARM @ RUN: llvm-mc -triple=armv7a-none-eabi -filetype=obj < %s | llvm-objdump -t - | FileCheck %s --check-prefix=ARM
@ RUN: llvm-mc -triple=armebv7a-none-eabi -filetype=obj < %s | llvm-objdump -t - | FileCheck %s --check-prefix=ARM @ RUN: llvm-mc -triple=armebv7a-none-eabi -filetype=obj < %s | llvm-objdump -t - | FileCheck %s --check-prefix=ARM
@ RUN: llvm-mc -triple=thumbv7a-none-eabi -filetype=obj < %s | llvm-objdump -t - | FileCheck %s --check-prefix=THUMB @ RUN: llvm-mc -triple=thumbv7a-none-eabi -filetype=obj < %s | llvm-objdump -t - | FileCheck %s --check-prefix=THUMB
@ RUN: llvm-mc -triple=thumbebv7a-none-eabi -filetype=obj < %s | llvm-objdump -t - | FileCheck %s --check-prefix=THUMB @ RUN: llvm-mc -triple=thumbebv7a-none-eabi -filetype=obj < %s | llvm-objdump -t - | FileCheck %s --check-prefix=THUMB
add r0, r0, r0 add r0, r0, r0
@ ARM: 00000000 .text 00000000 $a @ ARM: 00000000 l .text 00000000 $a
@ THUMB: 00000000 .text 00000000 $t @ THUMB: 00000000 l .text 00000000 $t

llvm/test/MC/ARM/mapping-within-section.s

Show All 18 Lines@ $d at 0x0012
.ascii "012" .ascii "012"
.byte 1 .byte 1
.byte 2 .byte 2
.byte 3 .byte 3
@ $a at 0x0018 @ $a at 0x0018
.arm .arm
add r0, r0, r0 add r0, r0, r0
@ CHECK: 00000000 .text 00000000 $a @ CHECK: 00000000 l .text 00000000 $a
@ CHECK-NEXT: 0000000c .text 00000000 $a @ CHECK-NEXT: 0000000c l .text 00000000 $a
@ CHECK-NEXT: 00000018 .text 00000000 $a @ CHECK-NEXT: 00000018 l .text 00000000 $a
@ CHECK-NEXT: 00000004 .text 00000000 $d @ CHECK-NEXT: 00000004 l .text 00000000 $d
@ CHECK-NEXT: 00000012 .text 00000000 $d @ CHECK-NEXT: 00000012 l .text 00000000 $d
@ CHECK-NEXT: 00000008 .text 00000000 $t @ CHECK-NEXT: 00000008 l .text 00000000 $t
@ CHECK-NEXT: 00000010 .text 00000000 $t @ CHECK-NEXT: 00000010 l .text 00000000 $t

llvm/test/MC/ARM/multi-section-mapping.s

Show All 36 Lines@ cause $d to appear in the .text section
.word 0 .word 0
@ With all those constraints, we want: @ With all those constraints, we want:
@ + .text to have $a at 0, $t at 8, $d at 12 @ + .text to have $a at 0, $t at 8, $d at 12
@ + .wibble to have $a at 0 @ + .wibble to have $a at 0
@ + .starts_thumb to have $t at 0 @ + .starts_thumb to have $t at 0
@ + .starts_data to have $d at 0 @ + .starts_data to have $d at 0
@ CHECK: 00000000 .text 00000000 $a @ CHECK: 00000000 l .text 00000000 $a
@ CHECK-NEXT: 00000000 .wibble 00000000 $a @ CHECK-NEXT: 00000000 l .wibble 00000000 $a
@ CHECK-NEXT: 0000000a .text 00000000 $d @ CHECK-NEXT: 0000000a l .text 00000000 $d
@ CHECK-NEXT: 00000000 .starts_thumb 00000000 $t @ CHECK-NEXT: 00000000 l .starts_thumb 00000000 $t
@ CHECK-NEXT: 00000008 .text 00000000 $t @ CHECK-NEXT: 00000008 l .text 00000000 $t
@ CHECK-NOT: ${{[adt]}} @ CHECK-NOT: ${{[adt]}}

llvm/test/MC/ARM/relocated-mapping.s

@ RUN: llvm-mc -triple=arm-linux-gnueabi -filetype=obj < %s | llvm-objdump -t - | FileCheck %s @ RUN: llvm-mc -triple=arm-linux-gnueabi -filetype=obj < %s | llvm-objdump -t - | FileCheck %s
@ Implementation-detail test (unfortunately): values that are relocated do not @ Implementation-detail test (unfortunately): values that are relocated do not
@ go via MCStreamer::EmitBytes; make sure they still emit a mapping symbol. @ go via MCStreamer::EmitBytes; make sure they still emit a mapping symbol.
add r0, r0, r0 add r0, r0, r0
.word somewhere .word somewhere
add r0, r0, r0 add r0, r0, r0
@ CHECK: 00000000 .text 00000000 $a @ CHECK: 00000000 l .text 00000000 $a
@ CHECK-NEXT: 00000008 .text 00000000 $a @ CHECK-NEXT: 00000008 l .text 00000000 $a
@ CHECK-NEXT: 00000004 .text 00000000 $d @ CHECK-NEXT: 00000004 l .text 00000000 $d

llvm/test/MC/AsmParser/defsym.s

Show All 10 Lines
.ifndef b .ifndef b
.err .err
.endif .endif
.if b<>11 .if b<>11
.err .err
.endif .endif
# CHECK: 00000007 *ABS* 00000000 a # CHECK: 00000007 l *ABS* 00000000 a
# CHECK: 0000000b *ABS* 00000000 b # CHECK: 0000000b l *ABS* 00000000 b
No newline at end of file

llvm/test/MC/Hexagon/common-redeclare.s

# RUN: llvm-mc -arch=hexagon -filetype=obj %s | llvm-objdump -t - | FileCheck %s # RUN: llvm-mc -arch=hexagon -filetype=obj %s | llvm-objdump -t - | FileCheck %s
# CHECK: 00000062 g O *COM* 00000008 quartet_table_isqrt # CHECK: 00000062 O *COM* 00000008 quartet_table_isqrt
.common quartet_table_isqrt, 98, 8 .common quartet_table_isqrt, 98, 8
.common quartet_table_isqrt, 98, 8 .common quartet_table_isqrt, 98, 8

llvm/test/MC/Hexagon/offset.s

# RUN: llvm-mc -arch=hexagon -filetype=obj %s | llvm-objdump -t - | FileCheck %s # RUN: llvm-mc -arch=hexagon -filetype=obj %s | llvm-objdump -t - | FileCheck %s
# #
sym_a: sym_a:
.set sym_d, sym_a + 8 .set sym_d, sym_a + 8
# CHECK: 00000000 .text 00000000 sym_a # CHECK: 00000000 l .text 00000000 sym_a
# CHECK: 00000008 .text 00000000 sym_d # CHECK: 00000008 l .text 00000000 sym_d

llvm/test/tools/llvm-objdump/WebAssembly/symbol-table.test

RUN: llvm-objdump -t %p/../Inputs/trivial.obj.wasm | FileCheck %s RUN: llvm-objdump -t %p/../Inputs/trivial.obj.wasm | FileCheck %s
CHECK: SYMBOL TABLE: CHECK: SYMBOL TABLE:
CHECK-NEXT: 00000001 g F CODE main CHECK-NEXT: 00000001 g F CODE main
CHECK-NEXT: 00000000 l O DATA .L.str CHECK-NEXT: 00000000 l O DATA .L.str
CHECK-NEXT: 00000000 g F *UND* puts CHECK-NEXT: 00000000 F *UND* puts
CHECK-NEXT: 00000019 l F CODE .LSomeOtherFunction_bitcast CHECK-NEXT: 00000019 l F CODE .LSomeOtherFunction_bitcast
CHECK-NEXT: 00000000 g F *UND* SomeOtherFunction CHECK-NEXT: 00000000 F *UND* SomeOtherFunction
CHECK-NEXT: 00000010 g O DATA var CHECK-NEXT: 00000010 g O DATA var

llvm/test/tools/llvm-objdump/X86/adjust-vma.test

Show All 23 Lines
# ADJUST-NEXT: 4 .data 00000004 0000000000123000 DATA # ADJUST-NEXT: 4 .data 00000004 0000000000123000 DATA
# ADJUST-NEXT: 5 .rela.data 00000018 0000000000000000 # ADJUST-NEXT: 5 .rela.data 00000018 0000000000000000
# ADJUST-NEXT: 6 .symtab 00000060 0000000000000000 # ADJUST-NEXT: 6 .symtab 00000060 0000000000000000
# ADJUST-NEXT: 7 .strtab 00000010 0000000000000000 # ADJUST-NEXT: 7 .strtab 00000010 0000000000000000
# ADJUST-NEXT: 8 .shstrtab 0000003c 0000000000000000 # ADJUST-NEXT: 8 .shstrtab 0000003c 0000000000000000
# COMMON: SYMBOL TABLE: # COMMON: SYMBOL TABLE:
# COMMON-NEXT: 0000000000000001 l F .text 0000000000000000 func # COMMON-NEXT: 0000000000000001 l F .text 0000000000000000 func
# COMMON-NEXT: 0000000000000000 .text 0000000000000000 sym # COMMON-NEXT: 0000000000000000 l .text 0000000000000000 sym
# COMMON-NEXT: 0000000000000000 l d .text 0000000000000000 .text # COMMON-NEXT: 0000000000000000 l d .text 0000000000000000 .text
# NOADJUST: 0000000000000000 sym: # NOADJUST: 0000000000000000 sym:
# NOADJUST-NEXT: 0: {{.*}} nop # NOADJUST-NEXT: 0: {{.*}} nop
# NOADJUST: 0000000000000001 func: # NOADJUST: 0000000000000001 func:
# NOADJUST-NEXT: 1: {{.*}} retq # NOADJUST-NEXT: 1: {{.*}} retq
# ADJUST: 0000000000123000 sym: # ADJUST: 0000000000123000 sym:
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

llvm/test/tools/llvm-objdump/X86/out-of-section-sym.test

// Check that llvm-objdump does not attempt to disassemble symbols outside // Check that llvm-objdump does not attempt to disassemble symbols outside
// of section boundaries. // of section boundaries.
// RUN: llvm-objdump -d -t %p/Inputs/out-of-section-sym.elf-i386 >%t0 // RUN: llvm-objdump -d -t %p/Inputs/out-of-section-sym.elf-i386 >%t0
// RUN: llvm-objdump -dt %p/Inputs/out-of-section-sym.elf-i386 >%t1 // RUN: llvm-objdump -dt %p/Inputs/out-of-section-sym.elf-i386 >%t1
// RUN: cmp %t0 %t1 // RUN: cmp %t0 %t1
// RUN: FileCheck --input-file %t0 %s // RUN: FileCheck --input-file %t0 %s
CHECK: SYMBOL TABLE: CHECK: SYMBOL TABLE:
CHECK-NEXT: 00000010 l d .text 00000000 .text CHECK-NEXT: 00000010 l d .text 00000000 .text
CHECK-NEXT: 00000010 .text 00000000 _start CHECK-NEXT: 00000010 l .text 00000000 _start
CHECK-NEXT: 00000020 .text 00000000 _fdata CHECK-NEXT: 00000020 g .text 00000000 _fdata
CHECK-NEXT: 00000010 .text 00000000 _ftext CHECK-NEXT: 00000010 g .text 00000000 _ftext
CHECK-EMPTY: CHECK-EMPTY:
CHECK-NEXT: Disassembly of section .text: CHECK-NEXT: Disassembly of section .text:
CHECK-EMPTY: CHECK-EMPTY:
CHECK-NEXT: _start: CHECK-NEXT: _start:
CHECK-NEXT: 10: c3 retl CHECK-NEXT: 10: c3 retl

llvm/test/tools/llvm-objdump/common-symbol-elf.test

// RUN: llvm-objdump -t %p/Inputs/common-symbol-elf | FileCheck %s // RUN: llvm-objdump -t %p/Inputs/common-symbol-elf | FileCheck %s
CHECK: 00000400 g O *COM* 00000008 common_symbol CHECK: 00000400 O *COM* 00000008 common_symbol

llvm/tools/llvm-objdump/llvm-objdump.cpp

Show First 20 Lines • Show All 1,892 Lines • ▼ Show 20 Lines for (auto I = O->symbol_begin(), E = O->symbol_end(); I != E; ++I) {
bool Global = Flags & SymbolRef::SF_Global; bool Global = Flags & SymbolRef::SF_Global;
bool Weak = Flags & SymbolRef::SF_Weak; bool Weak = Flags & SymbolRef::SF_Weak;
bool Absolute = Flags & SymbolRef::SF_Absolute; bool Absolute = Flags & SymbolRef::SF_Absolute;
bool Common = Flags & SymbolRef::SF_Common; bool Common = Flags & SymbolRef::SF_Common;
bool Hidden = Flags & SymbolRef::SF_Hidden; bool Hidden = Flags & SymbolRef::SF_Hidden;
char GlobLoc = ' '; char GlobLoc = ' ';
if (Type != SymbolRef::ST_Unknown) if ((Section != O->section_end() || Absolute) && !Weak)
GlobLoc = Global ? 'g' : 'l'; GlobLoc = Global ? 'g' : 'l';
char Debug = (Type == SymbolRef::ST_Debug || Type == SymbolRef::ST_File) char Debug = (Type == SymbolRef::ST_Debug || Type == SymbolRef::ST_File)
? 'd' : ' '; ? 'd' : ' ';
char FileFunc = ' '; char FileFunc = ' ';
if (Type == SymbolRef::ST_File) if (Type == SymbolRef::ST_File)
FileFunc = 'f'; FileFunc = 'f';
else if (Type == SymbolRef::ST_Function) else if (Type == SymbolRef::ST_Function)
FileFunc = 'F'; FileFunc = 'F';
▲ Show 20 Lines • Show All 467 Lines • Show Last 20 Lines