maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/lld/test/ELF/plt-i686.s

145 lines
5.0 KiB
ArmAsm
Raw Normal View History

Start adding target abstractions. This is just enough to get PLT working on 32 bit x86. The idea behind using a virtual interface is that it should be easy to convert any of the functions to template parameters if any turns out to be performance critical. llvm-svn: 248308
2015-09-23 02:19:46 +08:00
// RUN: llvm-mc -filetype=obj -triple=i686-unknown-linux %s -o %t.o
// RUN: llvm-mc -filetype=obj -triple=i686-unknown-linux %p/Inputs/shared.s -o %t2.o
Rename ld.lld2 to ld.lld since it is the default. llvm-svn: 253437
2015-11-18 14:11:01 +08:00
// RUN: ld.lld -shared %t2.o -o %t2.so
// RUN: ld.lld %t.o %t2.so -o %t
[ELF] - Lazy relocations support for x86 target. Patch implements lazy relocations for x86. One of features of x86 is that executable files and shared object files have separate procedure linkage tables. So patch implements both cases. Detailed information about instructions used can be found in http://docs.oracle.com/cd/E19620-01/805-3050/chapter6-1235/index.html (search: x86: Procedure Linkage Table). Differential revision: http://reviews.llvm.org/D14955 llvm-svn: 254098
2015-11-26 05:37:59 +08:00
// RUN: llvm-readobj -s -r %t | FileCheck --check-prefix=CHECK %s
Start adding target abstractions. This is just enough to get PLT working on 32 bit x86. The idea behind using a virtual interface is that it should be easy to convert any of the functions to template parameters if any turns out to be performance critical. llvm-svn: 248308
2015-09-23 02:19:46 +08:00
// RUN: llvm-objdump -d %t | FileCheck --check-prefix=DISASM %s
[ELF] - Lazy relocations support for x86 target. Patch implements lazy relocations for x86. One of features of x86 is that executable files and shared object files have separate procedure linkage tables. So patch implements both cases. Detailed information about instructions used can be found in http://docs.oracle.com/cd/E19620-01/805-3050/chapter6-1235/index.html (search: x86: Procedure Linkage Table). Differential revision: http://reviews.llvm.org/D14955 llvm-svn: 254098
2015-11-26 05:37:59 +08:00
// RUN: ld.lld -shared %t.o %t2.so -o %t
// RUN: llvm-readobj -s -r %t | FileCheck --check-prefix=CHECKSHARED %s
// RUN: llvm-objdump -d %t | FileCheck --check-prefix=DISASMSHARED %s
Start adding target abstractions. This is just enough to get PLT working on 32 bit x86. The idea behind using a virtual interface is that it should be easy to convert any of the functions to template parameters if any turns out to be performance critical. llvm-svn: 248308
2015-09-23 02:19:46 +08:00
// REQUIRES: x86
// CHECK: Name: .plt
// CHECK-NEXT: Type: SHT_PROGBITS
// CHECK-NEXT: Flags [
// CHECK-NEXT: SHF_ALLOC
// CHECK-NEXT: SHF_EXECINSTR
// CHECK-NEXT: ]
ELF2: Write .interp section on the first page in the exectuable. Previously, we reserved the first page for the program header, so no sections would be written to very beginning of the output file. FreeBSD requires .interp section be exist on the first page, so that was not good. This patch calculates the size of the program header and then assign addresses to the sections. Now the first section is located next to the program header. Because the first section is .interp, it's very likely to be on the first page. llvm-svn: 249957
2015-10-11 07:25:39 +08:00
// CHECK-NEXT: Address: 0x11010
Start adding target abstractions. This is just enough to get PLT working on 32 bit x86. The idea behind using a virtual interface is that it should be easy to convert any of the functions to template parameters if any turns out to be performance critical. llvm-svn: 248308
2015-09-23 02:19:46 +08:00
// CHECK-NEXT: Offset:
[ELF] - Lazy relocations support for x86 target. Patch implements lazy relocations for x86. One of features of x86 is that executable files and shared object files have separate procedure linkage tables. So patch implements both cases. Detailed information about instructions used can be found in http://docs.oracle.com/cd/E19620-01/805-3050/chapter6-1235/index.html (search: x86: Procedure Linkage Table). Differential revision: http://reviews.llvm.org/D14955 llvm-svn: 254098
2015-11-26 05:37:59 +08:00
// CHECK-NEXT: Size: 48
Start adding target abstractions. This is just enough to get PLT working on 32 bit x86. The idea behind using a virtual interface is that it should be easy to convert any of the functions to template parameters if any turns out to be performance critical. llvm-svn: 248308
2015-09-23 02:19:46 +08:00
// CHECK-NEXT: Link: 0
// CHECK-NEXT: Info: 0
// CHECK-NEXT: AddressAlignment: 16
[ELF] - Lazy relocations support for x86 target. Patch implements lazy relocations for x86. One of features of x86 is that executable files and shared object files have separate procedure linkage tables. So patch implements both cases. Detailed information about instructions used can be found in http://docs.oracle.com/cd/E19620-01/805-3050/chapter6-1235/index.html (search: x86: Procedure Linkage Table). Differential revision: http://reviews.llvm.org/D14955 llvm-svn: 254098
2015-11-26 05:37:59 +08:00
// CHECK: Name: .got.plt
// CHECK-NEXT: Type: SHT_PROGBITS
// CHECK-NEXT: Flags [
// CHECK-NEXT: SHF_ALLOC
// CHECK-NEXT: SHF_WRITE
// CHECK-NEXT: ]
// CHECK-NEXT: Address: 0x12058
// CHECK-NEXT: Offset: 0x2058
// CHECK-NEXT: Size: 20
// CHECK-NEXT: Link: 0
// CHECK-NEXT: Info: 0
// CHECK-NEXT: AddressAlignment: 4
// CHECK-NEXT: EntrySize: 0
// 0x12058 + got.plt.reserved(12) = 0x12064
// 0x12058 + got.plt.reserved(12) + 4 = 0x12068
Start adding target abstractions. This is just enough to get PLT working on 32 bit x86. The idea behind using a virtual interface is that it should be easy to convert any of the functions to template parameters if any turns out to be performance critical. llvm-svn: 248308
2015-09-23 02:19:46 +08:00
// CHECK: Relocations [
[ELF] - Lazy relocations support for x86 target. Patch implements lazy relocations for x86. One of features of x86 is that executable files and shared object files have separate procedure linkage tables. So patch implements both cases. Detailed information about instructions used can be found in http://docs.oracle.com/cd/E19620-01/805-3050/chapter6-1235/index.html (search: x86: Procedure Linkage Table). Differential revision: http://reviews.llvm.org/D14955 llvm-svn: 254098
2015-11-26 05:37:59 +08:00
// CHECK-NEXT: Section ({{.*}}) .rel.plt {
// CHECK-NEXT: 0x12064 R_386_JUMP_SLOT bar 0x0
// CHECK-NEXT: 0x12068 R_386_JUMP_SLOT zed 0x0
Start adding target abstractions. This is just enough to get PLT working on 32 bit x86. The idea behind using a virtual interface is that it should be easy to convert any of the functions to template parameters if any turns out to be performance critical. llvm-svn: 248308
2015-09-23 02:19:46 +08:00
// CHECK-NEXT: }
// CHECK-NEXT: ]
// Unfortunately FileCheck can't do math, so we have to check for explicit
// values:
[ELF] - Lazy relocations support for x86 target. Patch implements lazy relocations for x86. One of features of x86 is that executable files and shared object files have separate procedure linkage tables. So patch implements both cases. Detailed information about instructions used can be found in http://docs.oracle.com/cd/E19620-01/805-3050/chapter6-1235/index.html (search: x86: Procedure Linkage Table). Differential revision: http://reviews.llvm.org/D14955 llvm-svn: 254098
2015-11-26 05:37:59 +08:00
// 16 is the size of PLT[0]
// (0x11010 + 16) - (0x11000 + 1) - 4 = 27
// (0x11010 + 16) - (0x11005 + 1) - 4 = 22
// (0x11020 + 16) - (0x1100a + 1) - 4 = 33
Start adding target abstractions. This is just enough to get PLT working on 32 bit x86. The idea behind using a virtual interface is that it should be easy to convert any of the functions to template parameters if any turns out to be performance critical. llvm-svn: 248308
2015-09-23 02:19:46 +08:00
// DISASM: _start:
[ELF] - Lazy relocations support for x86 target. Patch implements lazy relocations for x86. One of features of x86 is that executable files and shared object files have separate procedure linkage tables. So patch implements both cases. Detailed information about instructions used can be found in http://docs.oracle.com/cd/E19620-01/805-3050/chapter6-1235/index.html (search: x86: Procedure Linkage Table). Differential revision: http://reviews.llvm.org/D14955 llvm-svn: 254098
2015-11-26 05:37:59 +08:00
// DISASM-NEXT: 11000: e9 1b 00 00 00 jmp 27
// DISASM-NEXT: 11005: e9 16 00 00 00 jmp 22
// DISASM-NEXT: 1100a: e9 21 00 00 00 jmp 33
Start adding target abstractions. This is just enough to get PLT working on 32 bit x86. The idea behind using a virtual interface is that it should be easy to convert any of the functions to template parameters if any turns out to be performance critical. llvm-svn: 248308
2015-09-23 02:19:46 +08:00
[ELF] - Lazy relocations support for x86 target. Patch implements lazy relocations for x86. One of features of x86 is that executable files and shared object files have separate procedure linkage tables. So patch implements both cases. Detailed information about instructions used can be found in http://docs.oracle.com/cd/E19620-01/805-3050/chapter6-1235/index.html (search: x86: Procedure Linkage Table). Differential revision: http://reviews.llvm.org/D14955 llvm-svn: 254098
2015-11-26 05:37:59 +08:00
// 0x11010 - 0x1102b - 5 = -32
// 0x11010 - 0x1103b - 5 = -48
// 73820 = 0x1205C = .got.plt (0x12058) + 4
// 73824 = 0x12060 = .got.plt (0x12058) + 8
// 73828 = 0x12064 = .got.plt (0x12058) + got.plt.reserved(12)
// 73832 = 0x12068 = .got.plt (0x12058) + got.plt.reserved(12) + 4
Start adding target abstractions. This is just enough to get PLT working on 32 bit x86. The idea behind using a virtual interface is that it should be easy to convert any of the functions to template parameters if any turns out to be performance critical. llvm-svn: 248308
2015-09-23 02:19:46 +08:00
// DISASM: Disassembly of section .plt:
// DISASM-NEXT: .plt:
[ELF] - Lazy relocations support for x86 target. Patch implements lazy relocations for x86. One of features of x86 is that executable files and shared object files have separate procedure linkage tables. So patch implements both cases. Detailed information about instructions used can be found in http://docs.oracle.com/cd/E19620-01/805-3050/chapter6-1235/index.html (search: x86: Procedure Linkage Table). Differential revision: http://reviews.llvm.org/D14955 llvm-svn: 254098
2015-11-26 05:37:59 +08:00
// DISASM-NEXT: 11010: ff 35 5c 20 01 00 pushl 73820
// DISASM-NEXT: 11016: ff 25 60 20 01 00 jmpl *73824
// DISASM-NEXT: 1101c: 90 nop
// DISASM-NEXT: 1101d: 90 nop
// DISASM-NEXT: 1101e: 90 nop
// DISASM-NEXT: 1101f: 90 nop
// DISASM-NEXT: 11020: ff 25 64 20 01 00 jmpl *73828
// DISASM-NEXT: 11026: 68 00 00 00 00 pushl $0
// DISASM-NEXT: 1102b: e9 e0 ff ff ff jmp -32 <.plt>
// DISASM-NEXT: 11030: ff 25 68 20 01 00 jmpl *73832
// DISASM-NEXT: 11036: 68 08 00 00 00 pushl $8
// DISASM-NEXT: 1103b: e9 d0 ff ff ff jmp -48 <.plt>
// CHECKSHARED: Name: .plt
// CHECKSHARED-NEXT: Type: SHT_PROGBITS
// CHECKSHARED-NEXT: Flags [
// CHECKSHARED-NEXT: SHF_ALLOC
// CHECKSHARED-NEXT: SHF_EXECINSTR
// CHECKSHARED-NEXT: ]
// CHECKSHARED-NEXT: Address: 0x1010
// CHECKSHARED-NEXT: Offset: 0x1010
// CHECKSHARED-NEXT: Size: 48
// CHECKSHARED-NEXT: Link: 0
// CHECKSHARED-NEXT: Info: 0
// CHECKSHARED-NEXT: AddressAlignment: 16
// CHECKSHARED-NEXT: EntrySize: 0
// CHECKSHARED-NEXT: }
// CHECKSHARED: Name: .got.plt
// CHECKSHARED-NEXT: Type: SHT_PROGBITS
// CHECKSHARED-NEXT: Flags [
// CHECKSHARED-NEXT: SHF_ALLOC
// CHECKSHARED-NEXT: SHF_WRITE
// CHECKSHARED-NEXT: ]
// CHECKSHARED-NEXT: Address: 0x2058
// CHECKSHARED-NEXT: Offset: 0x2058
// CHECKSHARED-NEXT: Size: 20
// CHECKSHARED-NEXT: Link: 0
// CHECKSHARED-NEXT: Info: 0
// CHECKSHARED-NEXT: AddressAlignment: 4
// CHECKSHARED-NEXT: EntrySize: 0
// CHECKSHARED-NEXT: }
// 0x2058 + got.plt.reserved(12) = 0x2064
// 0x2058 + got.plt.reserved(12) + 4 = 0x2068
// CHECKSHARED: Relocations [
// CHECKSHARED-NEXT: Section ({{.*}}) .rel.plt {
// CHECKSHARED-NEXT: 0x2064 R_386_JUMP_SLOT bar 0x0
// CHECKSHARED-NEXT: 0x2068 R_386_JUMP_SLOT zed 0x0
// CHECKSHARED-NEXT: }
// CHECKSHARED-NEXT: ]
// DISASMSHARED: _start:
// DISASMSHARED-NEXT: 1000: e9 1b 00 00 00 jmp 27
// DISASMSHARED-NEXT: 1005: e9 16 00 00 00 jmp 22
// DISASMSHARED-NEXT: 100a: e9 21 00 00 00 jmp 33
// DISASMSHARED-NEXT: Disassembly of section .plt:
// DISASMSHARED-NEXT: .plt:
// DISASMSHARED-NEXT: 1010: ff b3 04 00 00 00 pushl 4(%ebx)
// DISASMSHARED-NEXT: 1016: ff a3 08 00 00 00 jmpl *8(%ebx)
// DISASMSHARED-NEXT: 101c: 90 nop
// DISASMSHARED-NEXT: 101d: 90 nop
// DISASMSHARED-NEXT: 101e: 90 nop
// DISASMSHARED-NEXT: 101f: 90 nop
// DISASMSHARED-NEXT: 1020: ff a3 0c 00 00 00 jmpl *12(%ebx)
// DISASMSHARED-NEXT: 1026: 68 00 00 00 00 pushl $0
// DISASMSHARED-NEXT: 102b: e9 e0 ff ff ff jmp -32 <.plt>
// DISASMSHARED-NEXT: 1030: ff a3 10 00 00 00 jmpl *16(%ebx)
// DISASMSHARED: 1036: 68 08 00 00 00 pushl $8
// DISASMSHARED: 103b: e9 d0 ff ff ff jmp -48 <.plt>
Remove trailing whitespaces. llvm-svn: 250170
2015-10-14 00:13:18 +08:00
Start adding target abstractions. This is just enough to get PLT working on 32 bit x86. The idea behind using a virtual interface is that it should be easy to convert any of the functions to template parameters if any turns out to be performance critical. llvm-svn: 248308
2015-09-23 02:19:46 +08:00
.global _start
_start:
jmp bar@PLT
jmp bar@PLT
jmp zed@PLT