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/parse-arm-relocs.yaml

819 lines
27 KiB
YAML
Raw Normal View History

[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# RUN: lld -flavor darwin -arch armv7 -r -print_atoms %s -o %t | FileCheck %s
# RUN: lld -flavor darwin -arch armv7 -r -print_atoms %t -o %t2 | FileCheck %s
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
#
# Test parsing of armv7 relocations.
#
#
--- !mach-o
arch: armv7
file-type: MH_OBJECT
flags: [ MH_SUBSECTIONS_VIA_SYMBOLS ]
sections:
- segment: __TEXT
section: __text
type: S_REGULAR
attributes: [ S_ATTR_PURE_INSTRUCTIONS, S_ATTR_SOME_INSTRUCTIONS ]
alignment: 2
address: 0x0000000000000000
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
content: [ 0x00, 0xF0, 0x4E, 0xF8, 0x00, 0xF0, 0x4E, 0xF8,
0xFF, 0xF7, 0xFA, 0xFF, 0xFF, 0xF7, 0xFA, 0xFF,
0xFF, 0xF7, 0xF6, 0xBF, 0x40, 0xF2, 0x72, 0x01,
0xC0, 0xF2, 0x00, 0x01, 0x40, 0xF2, 0x7A, 0x02,
0xC0, 0xF2, 0x00, 0x02, 0x40, 0xF2, 0x29, 0x01,
0xC0, 0xF2, 0x00, 0x01, 0x79, 0x44, 0x40, 0xF2,
0xA0, 0x03, 0xC0, 0xF2, 0x00, 0x03, 0x40, 0xF2,
0xA8, 0x04, 0xC0, 0xF2, 0x00, 0x04, 0x40, 0xF2,
0x57, 0x03, 0xC0, 0xF2, 0x00, 0x03, 0x40, 0xF2,
0x00, 0x05, 0xC0, 0xF2, 0x00, 0x05, 0x40, 0xF2,
0x08, 0x06, 0xC0, 0xF2, 0x00, 0x06, 0xC0, 0x46,
0x10, 0x00, 0x00, 0xEB, 0x10, 0x00, 0x00, 0xEB,
0xE6, 0xFF, 0xFF, 0xEB, 0xE6, 0xFF, 0xFF, 0xEB,
0xE4, 0xFF, 0xFF, 0xEA, 0x20, 0x10, 0x00, 0xE3,
0x00, 0x10, 0x40, 0xE3, 0x28, 0x20, 0x00, 0xE3,
0x00, 0x20, 0x40, 0xE3, 0x0F, 0x10, 0x81, 0xE0,
0xA0, 0x30, 0x00, 0xE3, 0x00, 0x30, 0x40, 0xE3,
0xA8, 0x40, 0x00, 0xE3, 0x00, 0x40, 0x40, 0xE3,
0x00, 0x50, 0x00, 0xE3, 0x00, 0x50, 0x40, 0xE3,
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
0x08, 0x60, 0x00, 0xE3, 0x00, 0x60, 0x40, 0xE3 ]
relocations:
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
- offset: 0x0000009C
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
type: ARM_RELOC_HALF
length: 1
pc-rel: false
extern: true
symbol: 4
- offset: 0x00000008
type: ARM_RELOC_PAIR
length: 1
pc-rel: false
extern: false
symbol: 16777215
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
- offset: 0x00000098
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
type: ARM_RELOC_HALF
length: 0
pc-rel: false
extern: true
symbol: 4
- offset: 0x00000000
type: ARM_RELOC_PAIR
length: 0
pc-rel: false
extern: false
symbol: 16777215
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
- offset: 0x00000094
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
type: ARM_RELOC_HALF
length: 1
pc-rel: false
extern: true
symbol: 4
- offset: 0x00000000
type: ARM_RELOC_PAIR
length: 1
pc-rel: false
extern: false
symbol: 16777215
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
- offset: 0x00000090
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
type: ARM_RELOC_HALF
length: 0
pc-rel: false
extern: true
symbol: 4
- offset: 0x00000000
type: ARM_RELOC_PAIR
length: 0
pc-rel: false
extern: false
symbol: 16777215
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
- offset: 0x0000008C
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
scattered: true
type: ARM_RELOC_HALF
length: 1
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x000000A0
- offset: 0x000000A8
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
type: ARM_RELOC_PAIR
length: 1
pc-rel: false
extern: false
symbol: 16777215
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
- offset: 0x00000088
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
scattered: true
type: ARM_RELOC_HALF
length: 0
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x000000A0
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
- offset: 0x00000000
type: ARM_RELOC_PAIR
length: 0
pc-rel: false
extern: false
symbol: 16777215
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
- offset: 0x00000084
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
type: ARM_RELOC_HALF
length: 1
pc-rel: false
extern: false
symbol: 2
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
- offset: 0x000000A0
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
type: ARM_RELOC_PAIR
length: 1
pc-rel: false
extern: false
symbol: 16777215
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
- offset: 0x00000080
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
type: ARM_RELOC_HALF
length: 0
pc-rel: false
extern: false
symbol: 2
- offset: 0x00000000
type: ARM_RELOC_PAIR
length: 0
pc-rel: false
extern: false
symbol: 16777215
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
- offset: 0x00000078
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
scattered: true
type: ARM_RELOC_HALF_SECTDIFF
length: 1
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x000000A0
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
- offset: 0x00000028
scattered: true
type: ARM_RELOC_PAIR
length: 1
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x00000080
- offset: 0x00000074
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
scattered: true
type: ARM_RELOC_HALF_SECTDIFF
length: 0
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x000000A0
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
- offset: 0x00000000
scattered: true
type: ARM_RELOC_PAIR
length: 0
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x00000080
- offset: 0x00000070
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
scattered: true
type: ARM_RELOC_HALF_SECTDIFF
length: 1
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x000000A0
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
- offset: 0x00000020
scattered: true
type: ARM_RELOC_PAIR
length: 1
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x00000080
- offset: 0x0000006C
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
scattered: true
type: ARM_RELOC_HALF_SECTDIFF
length: 0
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x000000A0
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
- offset: 0x00000000
scattered: true
type: ARM_RELOC_PAIR
length: 0
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x00000080
- offset: 0x00000068
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
type: ARM_RELOC_BR24
length: 2
pc-rel: true
extern: true
symbol: 4
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
- offset: 0x00000064
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
type: ARM_RELOC_BR24
length: 2
pc-rel: true
extern: true
symbol: 4
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
- offset: 0x00000060
type: ARM_RELOC_BR24
length: 2
pc-rel: true
extern: true
symbol: 4
- offset: 0x0000005C
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
scattered: true
type: ARM_RELOC_BR24
length: 2
pc-rel: true
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x000000A0
- offset: 0x00000058
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
type: ARM_RELOC_BR24
length: 2
pc-rel: true
extern: false
symbol: 2
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
- offset: 0x00000052
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
type: ARM_RELOC_HALF
length: 3
pc-rel: false
extern: true
symbol: 4
- offset: 0x00000008
type: ARM_RELOC_PAIR
length: 3
pc-rel: false
extern: false
symbol: 16777215
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
- offset: 0x0000004E
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
type: ARM_RELOC_HALF
length: 2
pc-rel: false
extern: true
symbol: 4
- offset: 0x00000000
type: ARM_RELOC_PAIR
length: 2
pc-rel: false
extern: false
symbol: 16777215
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
- offset: 0x0000004A
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
type: ARM_RELOC_HALF
length: 3
pc-rel: false
extern: true
symbol: 4
- offset: 0x00000000
type: ARM_RELOC_PAIR
length: 3
pc-rel: false
extern: false
symbol: 16777215
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
- offset: 0x00000046
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
type: ARM_RELOC_HALF
length: 2
pc-rel: false
extern: true
symbol: 4
- offset: 0x00000000
type: ARM_RELOC_PAIR
length: 2
pc-rel: false
extern: false
symbol: 16777215
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
- offset: 0x00000042
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
type: ARM_RELOC_HALF
length: 3
pc-rel: false
extern: false
symbol: 1
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
- offset: 0x00000057
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
type: ARM_RELOC_PAIR
length: 3
pc-rel: false
extern: false
symbol: 16777215
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
- offset: 0x0000003E
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
type: ARM_RELOC_HALF
length: 2
pc-rel: false
extern: false
symbol: 1
- offset: 0x00000000
type: ARM_RELOC_PAIR
length: 2
pc-rel: false
extern: false
symbol: 16777215
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
- offset: 0x0000003A
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
scattered: true
type: ARM_RELOC_HALF
length: 3
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x000000A0
- offset: 0x000000A8
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
type: ARM_RELOC_PAIR
length: 3
pc-rel: false
extern: false
symbol: 16777215
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
- offset: 0x00000036
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
scattered: true
type: ARM_RELOC_HALF
length: 2
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x000000A0
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
- offset: 0x00000000
type: ARM_RELOC_PAIR
length: 2
pc-rel: false
extern: false
symbol: 16777215
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
- offset: 0x00000032
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
type: ARM_RELOC_HALF
length: 3
pc-rel: false
extern: false
symbol: 2
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
- offset: 0x000000A0
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
type: ARM_RELOC_PAIR
length: 3
pc-rel: false
extern: false
symbol: 16777215
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
- offset: 0x0000002E
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
type: ARM_RELOC_HALF
length: 2
pc-rel: false
extern: false
symbol: 2
- offset: 0x00000000
type: ARM_RELOC_PAIR
length: 2
pc-rel: false
extern: false
symbol: 16777215
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
- offset: 0x00000028
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
scattered: true
type: ARM_RELOC_HALF_SECTDIFF
length: 3
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x00000056
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
- offset: 0x00000028
scattered: true
type: ARM_RELOC_PAIR
length: 3
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x0000002E
- offset: 0x00000024
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
scattered: true
type: ARM_RELOC_HALF_SECTDIFF
length: 2
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x00000056
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
- offset: 0x00000000
scattered: true
type: ARM_RELOC_PAIR
length: 2
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x0000002E
- offset: 0x00000020
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
scattered: true
type: ARM_RELOC_HALF_SECTDIFF
length: 3
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x000000A0
- offset: 0x0000007A
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
scattered: true
type: ARM_RELOC_PAIR
length: 3
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x0000002E
- offset: 0x0000001C
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
scattered: true
type: ARM_RELOC_HALF_SECTDIFF
length: 2
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x000000A0
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
- offset: 0x00000000
scattered: true
type: ARM_RELOC_PAIR
length: 2
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x0000002E
- offset: 0x00000018
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
scattered: true
type: ARM_RELOC_HALF_SECTDIFF
length: 3
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x000000A0
- offset: 0x00000072
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
scattered: true
type: ARM_RELOC_PAIR
length: 3
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x0000002E
- offset: 0x00000014
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
scattered: true
type: ARM_RELOC_HALF_SECTDIFF
length: 2
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x000000A0
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
- offset: 0x00000000
scattered: true
type: ARM_RELOC_PAIR
length: 2
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x0000002E
- offset: 0x00000010
type: ARM_THUMB_RELOC_BR22
length: 2
pc-rel: true
extern: true
symbol: 4
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
- offset: 0x0000000C
type: ARM_THUMB_RELOC_BR22
length: 2
pc-rel: true
extern: true
symbol: 4
- offset: 0x00000008
type: ARM_THUMB_RELOC_BR22
length: 2
pc-rel: true
extern: true
symbol: 4
- offset: 0x00000004
scattered: true
type: ARM_THUMB_RELOC_BR22
length: 2
pc-rel: true
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x000000A0
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
- offset: 0x00000000
type: ARM_THUMB_RELOC_BR22
length: 2
pc-rel: true
extern: false
symbol: 2
- segment: __DATA
section: __data
type: S_REGULAR
attributes: [ ]
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
address: 0x00000000000000A0
Remove trailing whitespace characters. llvm-svn: 235897
2015-04-28 01:18:04 +08:00
content: [ 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0xA4, 0xFF, 0xFF, 0xFF,
0xA4, 0xFF, 0xFF, 0xFF, 0x45, 0xFF, 0xFF, 0xFF,
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
0x45, 0xFF, 0xFF, 0xFF ]
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
relocations:
- offset: 0x00000020
scattered: true
type: ARM_RELOC_SECTDIFF
length: 2
pc-rel: false
value: 0x00000000
- offset: 0x00000000
scattered: true
type: ARM_RELOC_PAIR
length: 2
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x000000C0
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
- offset: 0x0000001C
scattered: true
type: ARM_RELOC_SECTDIFF
length: 2
pc-rel: false
value: 0x00000000
- offset: 0x00000000
scattered: true
type: ARM_RELOC_PAIR
length: 2
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x000000BC
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
- offset: 0x00000018
scattered: true
type: ARM_RELOC_SECTDIFF
length: 2
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x00000058
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
- offset: 0x00000000
scattered: true
type: ARM_RELOC_PAIR
length: 2
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x000000B8
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
- offset: 0x00000014
scattered: true
type: ARM_RELOC_SECTDIFF
length: 2
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x00000058
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
- offset: 0x00000000
scattered: true
type: ARM_RELOC_PAIR
length: 2
pc-rel: false
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x000000B4
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
- offset: 0x00000010
type: ARM_RELOC_VANILLA
length: 2
pc-rel: false
extern: true
symbol: 4
- offset: 0x0000000C
type: ARM_RELOC_VANILLA
length: 2
pc-rel: false
extern: true
symbol: 4
- offset: 0x00000008
scattered: true
type: ARM_RELOC_VANILLA
length: 2
pc-rel: false
value: 0x00000000
- offset: 0x00000004
type: ARM_RELOC_VANILLA
length: 2
pc-rel: false
extern: false
symbol: 1
local-symbols:
- name: _foo_thumb
type: N_SECT
sect: 1
desc: [ N_ARM_THUMB_DEF ]
value: 0x0000000000000000
- name: _x
type: N_SECT
sect: 2
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x00000000000000A0
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
- name: _t1
type: N_SECT
sect: 1
desc: [ N_ARM_THUMB_DEF ]
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x0000000000000056
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
- name: _foo_arm
type: N_SECT
sect: 1
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
value: 0x0000000000000058
undefined-symbols:
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
- name: _undef
type: N_UNDF
scope: [ N_EXT ]
value: 0x0000000000000000
...
# CHECK: defined-atoms:
# CHECK: - name: _x
# CHECK: type: data
# CHECK: references:
# CHECK: - kind: pointer32
# CHECK: offset: 4
# CHECK: target: _foo_thumb
# CHECK-NOT: addend:
# CHECK: - kind: pointer32
# CHECK: offset: 8
# CHECK: target: _foo_thumb
# CHECK: addend: 4
# CHECK: - kind: pointer32
# CHECK: offset: 12
# CHECK: target: _undef
# CHECK-NOT: addend:
# CHECK: - kind: pointer32
# CHECK: offset: 16
# CHECK: target: _undef
# CHECK: addend: 4
# CHECK: - kind: delta32
# CHECK: offset: 20
# CHECK: target: _foo_arm
# CHECK-NOT: addend:
# CHECK: - kind: delta32
# CHECK: offset: 24
# CHECK: target: _foo_arm
# CHECK: addend: 4
# CHECK: - kind: delta32
# CHECK: offset: 28
# CHECK: target: _foo_thumb
# CHECK-NOT: addend:
# CHECK: - kind: delta32
# CHECK: offset: 32
# CHECK: target: _foo_thumb
# CHECK: addend: 4
# CHECK: - name: _foo_thumb
# CHECK: references:
[mach-o] add initial support for modes in arm code. This patch just supports marking ranges that are thumb code (vs arm code). Future patches will mark data and jump table ranges. The ranges are encoded as References with offsetInAtom being the start of the range and the target being the same atom. llvm-svn: 213712
2014-07-23 08:51:37 +08:00
# CHECK: - kind: modeThumbCode
# CHECK: offset: 0
[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] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: offset: 0
# CHECK: target: _x
# CHECK-NOT: addend:
[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] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: offset: 4
# CHECK: target: _x
# CHECK: addend: 4
[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] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: offset: 8
# CHECK: target: _undef
# CHECK-NOT: addend:
[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] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: offset: 12
# CHECK: target: _undef
# CHECK: addend: 4
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: - kind: thumb_b22
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: offset: 16
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: target: _undef
# CHECK-NOT: addend:
# CHECK: - kind: thumb_movw_funcRel
# CHECK: offset: 20
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: target: _x
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: addend: -46
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: - kind: thumb_movt_funcRel
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: offset: 24
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: target: _x
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: addend: -46
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: - kind: thumb_movw_funcRel
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: offset: 28
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: target: _x
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: addend: -38
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: - kind: thumb_movt_funcRel
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: offset: 32
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: target: _x
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: addend: -38
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: - kind: thumb_movw_funcRel
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: offset: 36
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: target: _t1
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: addend: -46
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: - kind: thumb_movt_funcRel
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: offset: 40
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: target: _t1
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: addend: -46
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: - kind: thumb_movw
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: offset: 46
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: target: _x
# CHECK-NOT: addend:
# CHECK: - kind: thumb_movt
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: offset: 50
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: target: _x
# CHECK-NOT: addend:
# CHECK: - kind: thumb_movw
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: offset: 54
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: target: _x
# CHECK: addend: 8
# CHECK: - kind: thumb_movt
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: offset: 58
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: target: _x
# CHECK: addend: 8
# CHECK: - kind: thumb_movw
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: offset: 62
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: target: _t1
# CHECK-NOT: addend:
# CHECK: - kind: thumb_movt
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: offset: 66
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: target: _t1
# CHECK-NOT: addend:
# CHECK: - kind: thumb_movw
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: offset: 70
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: target: _undef
# CHECK-NOT: addend:
# CHECK: - kind: thumb_movt
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: offset: 74
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: target: _undef
# CHECK-NOT: addend:
# CHECK: - kind: thumb_movw
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: offset: 78
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: target: _undef
# CHECK: addend: 8
# CHECK: - kind: thumb_movt
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: offset: 82
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: target: _undef
# CHECK: addend: 8
# CHECK: - name: _t1
# CHECK: content: [ C0, 46 ]
[mach-o] add initial support for modes in arm code. This patch just supports marking ranges that are thumb code (vs arm code). Future patches will mark data and jump table ranges. The ranges are encoded as References with offsetInAtom being the start of the range and the target being the same atom. llvm-svn: 213712
2014-07-23 08:51:37 +08:00
# CHECK: references:
# CHECK: - kind: modeThumbCode
# CHECK: offset: 0
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: - name: _foo_arm
# CHECK: references:
[mach-o] add initial support for modes in arm code. This patch just supports marking ranges that are thumb code (vs arm code). Future patches will mark data and jump table ranges. The ranges are encoded as References with offsetInAtom being the start of the range and the target being the same atom. llvm-svn: 213712
2014-07-23 08:51:37 +08:00
# CHECK-NOT: - kind: modeThumbCode
[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] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: offset: 0
# CHECK: target: _x
# CHECK-NOT: addend:
[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] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: offset: 4
# CHECK: target: _x
# CHECK: addend: 4
[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] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: offset: 8
# CHECK: target: _undef
# CHECK-NOT: addend:
[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] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: offset: 12
# CHECK: target: _undef
# CHECK: addend: 4
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: - kind: arm_b24
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: offset: 16
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: target: _undef
# CHECK-NOT: addend:
# CHECK: - kind: arm_movw_funcRel
# CHECK: offset: 20
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: target: _x
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: addend: -40
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: - kind: arm_movt_funcRel
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: offset: 24
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: target: _x
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: addend: -40
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: - kind: arm_movw_funcRel
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: offset: 28
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: target: _x
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: addend: -32
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: - kind: arm_movt_funcRel
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: offset: 32
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: target: _x
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: addend: -32
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: - kind: arm_movw
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: offset: 40
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: target: _x
# CHECK-NOT: addend:
# CHECK: - kind: arm_movt
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: offset: 44
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: target: _x
# CHECK-NOT: addend:
# CHECK: - kind: arm_movw
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: offset: 48
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: target: _x
# CHECK: addend: 8
# CHECK: - kind: arm_movt
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: offset: 52
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: target: _x
# CHECK: addend: 8
# CHECK: - kind: arm_movw
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: offset: 56
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: target: _undef
# CHECK-NOT: addend:
# CHECK: - kind: arm_movt
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: offset: 60
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: target: _undef
# CHECK-NOT: addend:
# CHECK: - kind: arm_movw
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: offset: 64
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: target: _undef
# CHECK: addend: 8
# CHECK: - kind: arm_movt
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# CHECK: offset: 68
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: target: _undef
# CHECK: addend: 8
Remove trailing whitespace characters. llvm-svn: 235897
2015-04-28 01:18:04 +08:00
# CHECK: undefined-atoms:
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# CHECK: - name: _undef
# .align 2
# .code 16
# .thumb_func _foo_thumb
#_foo_thumb:
# bl _x
# bl _x+4
# bl _undef
# bl _undef+4
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# b _undef
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# movw r1, :lower16:(_x-L1)
[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
# movt r1, :upper16:(_x-L1)
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# movw r2, :lower16:(_x+8-L1)
[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
# movt r2, :upper16:(_x+8-L1)
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# movw r1, :lower16:(_t1-L1)
[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
# movt r1, :upper16:(_t1-L1)
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# add r1, pc
#L1:
# movw r3, :lower16:_x
# movt r3, :upper16:_x
# movw r4, :lower16:_x+8
# movt r4, :upper16:_x+8
# movw r3, :lower16:_t1
# movt r3, :upper16:_t1
# movw r5, :lower16:_undef
# movt r5, :upper16:_undef
# movw r6, :lower16:_undef+8
# movt r6, :upper16:_undef+8
#
# .thumb_func _t1
#_t1:
# nop
#
#
# .code 32
Remove trailing whitespace characters. llvm-svn: 235897
2015-04-28 01:18:04 +08:00
# .align 2
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
#_foo_arm:
# bl _x
# bl _x+4
# bl _undef
# bl _undef+4
[mach-o] for 32-bit arm, in -r mode support B (not BL) to undefined symbol When fixing up BL instructions, the linker has to compare the thumbness of the target to decide if the instruction needs to be converted to BLX. But with B instruction there is no BX, so the linker asserts if the target is not the same thumbness. This assert was firing in -r mode when the target was undefined which it interpreted as being non-thumb. Test case change is to add a B (in both thumb and arm code) to an undefined symbol and round trip through -r mode. llvm-svn: 222266
2014-11-19 06:08:50 +08:00
# b _undef
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# movw r1, :lower16:(_x-L2)
[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
# movt r1, :upper16:(_x-L2)
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# movw r2, :lower16:(_x+8-L2)
[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
# movt r2, :upper16:(_x+8-L2)
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
# add r1, pc
#L2:
# movw r3, :lower16:_x
# movt r3, :upper16:_x
# movw r4, :lower16:_x+8
# movt r4, :upper16:_x+8
# movw r5, :lower16:_undef
# movt r5, :upper16:_undef
# movw r6, :lower16:_undef+8
# movt r6, :upper16:_undef+8
Remove trailing whitespace characters. llvm-svn: 235897
2015-04-28 01:18:04 +08:00
#
[mach-o] Add parsing of arm/thumb relocations This converts the very complicated mach-o arm relocations into the simple Reference Kinds in lld. The next patch will use the internal Reference kinds to fix up arm/thumb code. llvm-svn: 212306
2014-07-04 08:11:09 +08:00
#
# .data
#_x: .long 0
# .long _foo_thumb
# .long _foo_thumb+4
# .long _undef
# .long _undef+4
# .long _foo_arm - .
# .long _foo_arm+4- .
# .long _foo_thumb - .
# .long _foo_thumb+4 - .
#