maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/lld/test/mach-o/arm-interworking.yaml

289 lines
8.6 KiB
YAML
Raw Normal View History

Delete unnecessary generality in loadFile. loadFile could load mulitple files just because yaml has a feature for putting multiple documents in one file. Designing a linker around what yaml can do seems like a bad idea to me. This patch changes it to read a single file. There are further improvements to be done to the api and they will follow shortly. llvm-svn: 235724
2015-04-24 23:51:45 +08:00
# RUN: lld -flavor darwin -arch armv7 -r -print_atoms %s \
# RUN: %p/Inputs/arm-interworking.yaml -o %t | FileCheck %s \
[mach-o] Fix stub generation to work for dylibs and bundles Split up the CRuntimeFile into one part for output types that need an entry point and another part for output types that use stubs. Add file 'test/mach-o/Inputs/libSystem.yaml' for use by test cases that use -dylib and therefore may now need the helper symbol in libSystem.dylib. llvm-svn: 215602
2014-08-14 07:31:07 +08:00
# RUN: && lld -flavor darwin -arch armv7 -dylib -print_atoms \
Have one version of libSystem for each arch. NFC. An upcoming commit will change how we choose to reference a dylib. Currently dylibs are only given an LC_LOAD_DYLIB in the final image if an atom is used. This is different from ld64 which adds the load command when the dylib is referenced on the cmdline. In order to change this behaviour, we need libSystem.yaml to actually contain a mach header so that it is parsed as a dylib, instead of currently being parsed as a normalised file. To get a mach header, we also require an arch, so now we have one libsystem per arch and all the tests have been updated to choose the correct one. llvm-svn: 278372
2016-08-12 02:08:59 +08:00
# RUN: %p/Inputs/armv7/libSystem.yaml %t -o %t2 | FileCheck %s \
[MachO] Use llvm-readobj in lieu of macho-dump. The latter will be removed from the tree anytime soon. llvm-svn: 248300
2015-09-23 01:31:01 +08:00
# RUN: && llvm-readobj -s -sd %t2 | FileCheck -check-prefix=CODE %s
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
#
# Test thumb and arm branches round trip through -r.
# Test bl/blx instructions are fixed up properly.
#
#
--- !mach-o
arch: armv7
file-type: MH_OBJECT
flags: [ MH_SUBSECTIONS_VIA_SYMBOLS ]
Remove trailing whitespace characters. llvm-svn: 235897
2015-04-28 01:18:04 +08:00
sections:
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
- segment: __TEXT
section: __text
type: S_REGULAR
attributes: [ S_ATTR_PURE_INSTRUCTIONS, S_ATTR_SOME_INSTRUCTIONS ]
alignment: 2
address: 0x0000000000000000
Remove trailing whitespace characters. llvm-svn: 235897
2015-04-28 01:18:04 +08:00
content: [ 0xFF, 0xF7, 0xFE, 0xFF, 0xC0, 0x46, 0xFF, 0xF7,
0xFC, 0xEF, 0xC0, 0x46, 0xFF, 0xF7, 0xF8, 0xEF,
0xFF, 0xF7, 0xF6, 0xFF, 0xC0, 0x46, 0xFF, 0xF7,
0xF3, 0xFF, 0xC0, 0x46, 0x00, 0xF0, 0x06, 0xE8,
0xC0, 0x46, 0x00, 0xF0, 0x03, 0xF8, 0x00, 0xF0,
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
0x02, 0xF8, 0x70, 0x47, 0x70, 0x47, 0x70, 0x47 ]
Remove trailing whitespace characters. llvm-svn: 235897
2015-04-28 01:18:04 +08:00
relocations:
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
- offset: 0x00000026
type: ARM_THUMB_RELOC_BR22
length: 2
pc-rel: true
extern: false
symbol: 1
- offset: 0x00000022
type: ARM_THUMB_RELOC_BR22
length: 2
pc-rel: true
extern: false
symbol: 1
- offset: 0x0000001C
type: ARM_THUMB_RELOC_BR22
length: 2
pc-rel: true
extern: false
symbol: 1
- offset: 0x00000016
type: ARM_THUMB_RELOC_BR22
length: 2
pc-rel: true
extern: false
symbol: 1
- offset: 0x00000010
type: ARM_THUMB_RELOC_BR22
length: 2
pc-rel: true
extern: false
symbol: 1
- offset: 0x0000000C
type: ARM_THUMB_RELOC_BR22
length: 2
pc-rel: true
extern: true
symbol: 5
- offset: 0x00000006
type: ARM_THUMB_RELOC_BR22
length: 2
pc-rel: true
extern: true
symbol: 5
- offset: 0x00000000
type: ARM_THUMB_RELOC_BR22
length: 2
pc-rel: true
extern: true
symbol: 4
- segment: __DATA
section: __data
type: S_REGULAR
attributes: [ ]
address: 0x0000000000000030
content: [ 0x2D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ]
Remove trailing whitespace characters. llvm-svn: 235897
2015-04-28 01:18:04 +08:00
relocations:
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
- offset: 0x00000004
type: ARM_RELOC_VANILLA
length: 2
pc-rel: false
extern: true
symbol: 4
- offset: 0x00000000
type: ARM_RELOC_VANILLA
length: 2
pc-rel: false
extern: false
symbol: 1
Remove trailing whitespace characters. llvm-svn: 235897
2015-04-28 01:18:04 +08:00
local-symbols:
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
- name: _t3
type: N_SECT
sect: 1
desc: [ N_ARM_THUMB_DEF ]
value: 0x000000000000002E
- name: _d1
type: N_SECT
sect: 2
value: 0x0000000000000030
Remove trailing whitespace characters. llvm-svn: 235897
2015-04-28 01:18:04 +08:00
global-symbols:
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
- name: _t1
type: N_SECT
scope: [ N_EXT ]
sect: 1
desc: [ N_ARM_THUMB_DEF ]
value: 0x0000000000000000
- name: _t2
type: N_SECT
scope: [ N_EXT ]
sect: 1
desc: [ N_ARM_THUMB_DEF ]
value: 0x000000000000002C
Remove trailing whitespace characters. llvm-svn: 235897
2015-04-28 01:18:04 +08:00
undefined-symbols:
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
- name: _a1
type: N_UNDF
scope: [ N_EXT ]
value: 0x0000000000000000
- name: _a2
type: N_UNDF
scope: [ N_EXT ]
value: 0x0000000000000000
...
Remove trailing whitespace characters. llvm-svn: 235897
2015-04-28 01:18:04 +08:00
# CHECK: defined-atoms:
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
# CHECK: - name: _d1
# CHECK: type: data
Remove trailing whitespace characters. llvm-svn: 235897
2015-04-28 01:18:04 +08:00
# CHECK: references:
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
# CHECK: - kind: pointer32
# CHECK: offset: 0
# CHECK: target: _t2
# CHECK: - kind: pointer32
# CHECK: offset: 4
# CHECK: target: _a1
# CHECK: - name: _d2
# CHECK: type: data
Remove trailing whitespace characters. llvm-svn: 235897
2015-04-28 01:18:04 +08:00
# CHECK: references:
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
# CHECK: - kind: pointer32
# CHECK: offset: 0
# CHECK: target: _t1
# CHECK: - kind: pointer32
# CHECK: offset: 4
# CHECK: target: _a1
# CHECK: - name: _t1
# CHECK: scope: global
Remove trailing whitespace characters. llvm-svn: 235897
2015-04-28 01:18:04 +08:00
# CHECK: references:
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
# CHECK: - kind: modeThumbCode
# CHECK: offset: 0
# CHECK: target: _t1
[mach-o] Add Pass to create are shim Atoms for ARM interworking. Arm code has two instruction encodings "thumb" and "arm". When branching from one code encoding to another, you need to use an instruction that switches the instruction mode. Usually the transition only happens at call sites, and the linker can transform a BL instruction in BLX (or vice versa). But if the compiler did a tail call optimization and a function ends with a branch (not branch and link), there is no pc-rel BX instruction. The ShimPass looks for pc-rel B instructions that will need to switch mode. For those cases it synthesizes a shim which does the transition, then modifies the original atom with the B instruction to target to the shim atom. llvm-svn: 219655
2014-10-14 09:51:42 +08:00
# CHECK: - kind: thumb_bl22
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
# CHECK: offset: 0
# CHECK: target: _a1
[mach-o] Add Pass to create are shim Atoms for ARM interworking. Arm code has two instruction encodings "thumb" and "arm". When branching from one code encoding to another, you need to use an instruction that switches the instruction mode. Usually the transition only happens at call sites, and the linker can transform a BL instruction in BLX (or vice versa). But if the compiler did a tail call optimization and a function ends with a branch (not branch and link), there is no pc-rel BX instruction. The ShimPass looks for pc-rel B instructions that will need to switch mode. For those cases it synthesizes a shim which does the transition, then modifies the original atom with the B instruction to target to the shim atom. llvm-svn: 219655
2014-10-14 09:51:42 +08:00
# CHECK: - kind: thumb_bl22
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
# CHECK: offset: 6
# CHECK: target: _a2
[mach-o] Add Pass to create are shim Atoms for ARM interworking. Arm code has two instruction encodings "thumb" and "arm". When branching from one code encoding to another, you need to use an instruction that switches the instruction mode. Usually the transition only happens at call sites, and the linker can transform a BL instruction in BLX (or vice versa). But if the compiler did a tail call optimization and a function ends with a branch (not branch and link), there is no pc-rel BX instruction. The ShimPass looks for pc-rel B instructions that will need to switch mode. For those cases it synthesizes a shim which does the transition, then modifies the original atom with the B instruction to target to the shim atom. llvm-svn: 219655
2014-10-14 09:51:42 +08:00
# CHECK: - kind: thumb_bl22
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
# CHECK: offset: 12
# CHECK: target: _a2
[mach-o] Add Pass to create are shim Atoms for ARM interworking. Arm code has two instruction encodings "thumb" and "arm". When branching from one code encoding to another, you need to use an instruction that switches the instruction mode. Usually the transition only happens at call sites, and the linker can transform a BL instruction in BLX (or vice versa). But if the compiler did a tail call optimization and a function ends with a branch (not branch and link), there is no pc-rel BX instruction. The ShimPass looks for pc-rel B instructions that will need to switch mode. For those cases it synthesizes a shim which does the transition, then modifies the original atom with the B instruction to target to the shim atom. llvm-svn: 219655
2014-10-14 09:51:42 +08:00
# CHECK: - kind: thumb_bl22
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
# CHECK: offset: 16
# CHECK: target: _t1
[mach-o] Add Pass to create are shim Atoms for ARM interworking. Arm code has two instruction encodings "thumb" and "arm". When branching from one code encoding to another, you need to use an instruction that switches the instruction mode. Usually the transition only happens at call sites, and the linker can transform a BL instruction in BLX (or vice versa). But if the compiler did a tail call optimization and a function ends with a branch (not branch and link), there is no pc-rel BX instruction. The ShimPass looks for pc-rel B instructions that will need to switch mode. For those cases it synthesizes a shim which does the transition, then modifies the original atom with the B instruction to target to the shim atom. llvm-svn: 219655
2014-10-14 09:51:42 +08:00
# CHECK: - kind: thumb_bl22
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
# CHECK: offset: 22
# CHECK: target: _t1
[mach-o] Add Pass to create are shim Atoms for ARM interworking. Arm code has two instruction encodings "thumb" and "arm". When branching from one code encoding to another, you need to use an instruction that switches the instruction mode. Usually the transition only happens at call sites, and the linker can transform a BL instruction in BLX (or vice versa). But if the compiler did a tail call optimization and a function ends with a branch (not branch and link), there is no pc-rel BX instruction. The ShimPass looks for pc-rel B instructions that will need to switch mode. For those cases it synthesizes a shim which does the transition, then modifies the original atom with the B instruction to target to the shim atom. llvm-svn: 219655
2014-10-14 09:51:42 +08:00
# CHECK: - kind: thumb_bl22
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
# CHECK: offset: 28
# CHECK: target: _t2
[mach-o] Add Pass to create are shim Atoms for ARM interworking. Arm code has two instruction encodings "thumb" and "arm". When branching from one code encoding to another, you need to use an instruction that switches the instruction mode. Usually the transition only happens at call sites, and the linker can transform a BL instruction in BLX (or vice versa). But if the compiler did a tail call optimization and a function ends with a branch (not branch and link), there is no pc-rel BX instruction. The ShimPass looks for pc-rel B instructions that will need to switch mode. For those cases it synthesizes a shim which does the transition, then modifies the original atom with the B instruction to target to the shim atom. llvm-svn: 219655
2014-10-14 09:51:42 +08:00
# CHECK: - kind: thumb_bl22
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
# CHECK: offset: 34
# CHECK: target: _t2
[mach-o] Add Pass to create are shim Atoms for ARM interworking. Arm code has two instruction encodings "thumb" and "arm". When branching from one code encoding to another, you need to use an instruction that switches the instruction mode. Usually the transition only happens at call sites, and the linker can transform a BL instruction in BLX (or vice versa). But if the compiler did a tail call optimization and a function ends with a branch (not branch and link), there is no pc-rel BX instruction. The ShimPass looks for pc-rel B instructions that will need to switch mode. For those cases it synthesizes a shim which does the transition, then modifies the original atom with the B instruction to target to the shim atom. llvm-svn: 219655
2014-10-14 09:51:42 +08:00
# CHECK: - kind: thumb_bl22
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
# CHECK: offset: 38
# CHECK: target: _t3
# CHECK: - name: _t2
# CHECK: scope: global
# CHECK: content: [ 70, 47 ]
Remove trailing whitespace characters. llvm-svn: 235897
2015-04-28 01:18:04 +08:00
# CHECK: references:
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
# CHECK: - kind: modeThumbCode
# CHECK: offset: 0
# CHECK: target: _t2
# CHECK: - name: _t3
# CHECK: content: [ 70, 47 ]
Remove trailing whitespace characters. llvm-svn: 235897
2015-04-28 01:18:04 +08:00
# CHECK: references:
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
# CHECK: - kind: modeThumbCode
# CHECK: offset: 0
# CHECK: target: _t3
# CHECK: - name: _a1
# CHECK: scope: global
Remove trailing whitespace characters. llvm-svn: 235897
2015-04-28 01:18:04 +08:00
# CHECK: references:
[mach-o] Add Pass to create are shim Atoms for ARM interworking. Arm code has two instruction encodings "thumb" and "arm". When branching from one code encoding to another, you need to use an instruction that switches the instruction mode. Usually the transition only happens at call sites, and the linker can transform a BL instruction in BLX (or vice versa). But if the compiler did a tail call optimization and a function ends with a branch (not branch and link), there is no pc-rel BX instruction. The ShimPass looks for pc-rel B instructions that will need to switch mode. For those cases it synthesizes a shim which does the transition, then modifies the original atom with the B instruction to target to the shim atom. llvm-svn: 219655
2014-10-14 09:51:42 +08:00
# CHECK: - kind: arm_bl24
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
# CHECK: offset: 0
# CHECK: target: _a1
[mach-o] Add Pass to create are shim Atoms for ARM interworking. Arm code has two instruction encodings "thumb" and "arm". When branching from one code encoding to another, you need to use an instruction that switches the instruction mode. Usually the transition only happens at call sites, and the linker can transform a BL instruction in BLX (or vice versa). But if the compiler did a tail call optimization and a function ends with a branch (not branch and link), there is no pc-rel BX instruction. The ShimPass looks for pc-rel B instructions that will need to switch mode. For those cases it synthesizes a shim which does the transition, then modifies the original atom with the B instruction to target to the shim atom. llvm-svn: 219655
2014-10-14 09:51:42 +08:00
# CHECK: - kind: arm_bl24
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
# CHECK: offset: 4
# CHECK: target: _a2
[mach-o] Add Pass to create are shim Atoms for ARM interworking. Arm code has two instruction encodings "thumb" and "arm". When branching from one code encoding to another, you need to use an instruction that switches the instruction mode. Usually the transition only happens at call sites, and the linker can transform a BL instruction in BLX (or vice versa). But if the compiler did a tail call optimization and a function ends with a branch (not branch and link), there is no pc-rel BX instruction. The ShimPass looks for pc-rel B instructions that will need to switch mode. For those cases it synthesizes a shim which does the transition, then modifies the original atom with the B instruction to target to the shim atom. llvm-svn: 219655
2014-10-14 09:51:42 +08:00
# CHECK: - kind: arm_bl24
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
# CHECK: offset: 8
# CHECK: target: _t1
[mach-o] Add Pass to create are shim Atoms for ARM interworking. Arm code has two instruction encodings "thumb" and "arm". When branching from one code encoding to another, you need to use an instruction that switches the instruction mode. Usually the transition only happens at call sites, and the linker can transform a BL instruction in BLX (or vice versa). But if the compiler did a tail call optimization and a function ends with a branch (not branch and link), there is no pc-rel BX instruction. The ShimPass looks for pc-rel B instructions that will need to switch mode. For those cases it synthesizes a shim which does the transition, then modifies the original atom with the B instruction to target to the shim atom. llvm-svn: 219655
2014-10-14 09:51:42 +08:00
# CHECK: - kind: arm_bl24
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
# CHECK: offset: 12
# CHECK: target: _t2
# CHECK: - name: _a2
# CHECK: scope: global
[MachO] Use llvm-readobj in lieu of macho-dump. The latter will be removed from the tree anytime soon. llvm-svn: 248300
2015-09-23 01:31:01 +08:00
# CODE: Name: __text (5F 5F 74 65 78 74 00 00 00 00 00 00 00 00 00 00)
# CODE: Segment: __TEXT (5F 5F 54 45 58 54 00 00 00 00 00 00 00 00 00 00)
# CODE: SectionData (
# CODE: 0000: 00F016E8 C04600F0 1EE8C046 00F01AE8
# CODE: 0010: FFF7F6FF C046FFF7 F3FFC046 00F006F8
# CODE: 0020: C04600F0 03F800F0 02F87047 70477047
# CODE: 0030: FEFFFFEB 020000EB F0FFFFFA FAFFFFFA
# CODE: 0040: 1EFF2FE1 1EFF2FE1
# CODE: )
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
[MachO] Use llvm-readobj in lieu of macho-dump. The latter will be removed from the tree anytime soon. llvm-svn: 248300
2015-09-23 01:31:01 +08:00
# CODE: Name: __data (5F 5F 64 61 74 61 00 00 00 00 00 00 00 00 00 00)
# CODE: Segment: __DATA (5F 5F 44 41 54 41 00 00 00 00 00 00 00 00 00 00)
# CODE: SectionData (
# CODE: 0000: E50F0000 E80F0000 B90F0000 E80F0000
# CODE: )
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
[MachO] Use llvm-readobj in lieu of macho-dump. The latter will be removed from the tree anytime soon. llvm-svn: 248300
2015-09-23 01:31:01 +08:00
# When we get a good mach-o disassembler the above __text section content check can be change to be symbolic.
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
# Verify the low (thumb) bit is set on the first and third pointers but not the second and fourth.
# Input file one:
#
# .align 2
# .code 16
# .globl _t1
# .thumb_func _t1
#_t1:
# bl _a1
# nop
# blx _a2
# nop
# blx _a2
# bl _t1
# nop
# bl _t1
# nop
# blx _t2
# nop
# blx _t2
# bx lr
Remove trailing whitespace characters. llvm-svn: 235897
2015-04-28 01:18:04 +08:00
#
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
# .globl _t2
# .thumb_func _t2
#_t2:
# bx lr
Remove trailing whitespace characters. llvm-svn: 235897
2015-04-28 01:18:04 +08:00
#
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
# .data
#_d1: .long _t2
# .long _a1
Remove trailing whitespace characters. llvm-svn: 235897
2015-04-28 01:18:04 +08:00
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
# Input file two:
#
# .align 2
# .code 32
# .globl _a1
#_a1:
# bl _a1
# blx _a2
# bl _t1
# blx _t2
# bx lr
Remove trailing whitespace characters. llvm-svn: 235897
2015-04-28 01:18:04 +08:00
#
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
# .globl _a2
#_a2:
# bx lr
Remove trailing whitespace characters. llvm-svn: 235897
2015-04-28 01:18:04 +08:00
#
[mach-o] Implement interworking between thumb and arm code All iOS arm processor support switching between arm and thumb mode at call sites by using the BLX instruction (instead of BL). But the compiler does not know the implementation mode for extern functions, so the linker must update BL/BLX instructions to match what is linked is actually linked together. In addition, pointers to functions (such as vtables) must have the low bit set if the target of the pointer is a thumb mode function. llvm-svn: 214140
2014-07-29 07:06:09 +08:00
# .data
#_d2: .long _t1
# .long _a1
Remove trailing whitespace characters. llvm-svn: 235897
2015-04-28 01:18:04 +08:00