1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
|
# RUN: rm -rf %t && mkdir -p %t
# RUN: llvm-mc -triple=aarch64-unknown-linux-gnu -relax-relocations=false \
# RUN: -position-independent -filetype=obj -o %t/elf_reloc.o %s
# RUN: llvm-jitlink -noexec \
# RUN: -abs external_data=0xdeadbeef \
# RUN: -abs external_func=0xcafef00d \
# RUN: -check %s %t/elf_reloc.o
.text
.globl main
.p2align 2
.type main,@function
main:
ret
.size main, .-main
# Check R_AARCH64_CALL26 / R_AARCH64_JUMP26 relocation of a local function call
#
# jitlink-check: decode_operand(local_func_call26, 0)[25:0] = (local_func - local_func_call26)[27:2]
# jitlink-check: decode_operand(local_func_jump26, 0)[25:0] = (local_func - local_func_jump26)[27:2]
.globl local_func
.p2align 2
.type local_func,@function
local_func:
ret
.size local_func, .-local_func
.globl local_func_call26
.p2align 2
local_func_call26:
bl local_func
.size local_func_call26, .-local_func_call26
.globl local_func_jump26
.p2align 2
local_func_jump26:
b local_func
.size local_func_jump26, .-local_func_jump26
# Check R_AARCH64_ADR_PREL_LO21 relocation of a local symbol
#
# jitlink-check: decode_operand(test_adr_prel_lo21, 1) = (adr_data - test_adr_prel_lo21)[20:0]
.globl test_adr_prel_lo21, adr_data
.p2align 2
test_adr_prel_lo21:
adr x0, adr_data
.size test_adr_prel_lo21, .-test_adr_prel_lo21
## ADR encoding is a bit tricky so use an offset with an irregular bit pattern
## to test this bit better
adr_data = test_adr_prel_lo21 + 0xe46f2
# Check R_AARCH64_ADR_PREL_PG_HI21 / R_AARCH64_ADD_ABS_LO12_NC relocation of a local symbol
#
# For the ADR_PREL_PG_HI21/ADRP instruction we have the 21-bit delta to the 4k page
# containing the global.
#
# jitlink-check: decode_operand(test_adr_prel, 1) = (named_data - test_adr_prel)[32:12]
# jitlink-check: decode_operand(test_add_abs_lo12, 2) = (named_data + 0)[11:0]
.globl test_adr_prel
.p2align 2
test_adr_prel:
adrp x0, named_data
.size test_adr_prel, .-test_adr_prel
.globl test_add_abs_lo12
.p2align 2
test_add_abs_lo12:
add x0, x0, :lo12:named_data
.size test_add_abs_lo12, .-test_add_abs_lo12
# Check that calls/jumps to external functions trigger the generation of stubs and GOT
# entries.
#
# jitlink-check: decode_operand(test_external_call, 0) = (stub_addr(elf_reloc.o, external_func) - test_external_call)[27:2]
# jitlink-check: decode_operand(test_external_jump, 0) = (stub_addr(elf_reloc.o, external_func) - test_external_jump)[27:2]
# jitlink-check: *{8}(got_addr(elf_reloc.o, external_func)) = external_func
.globl test_external_call
.p2align 2
test_external_call:
bl external_func
.size test_external_call, .-test_external_call
.globl test_external_jump
.p2align 2
test_external_jump:
b external_func
.size test_external_jump, .-test_external_jump
# Check R_AARCH64_LDST*_ABS_LO12_NC relocation of a local symbol
#
# The immediate value should be the symbol address right shifted according to its instruction bitwidth.
#
# jitlink-check: decode_operand(test_ldrb, 2) = named_data[11:0]
# jitlink-check: decode_operand(test_ldrsb, 2) = (named_data + 0)[11:0]
# jitlink-check: decode_operand(test_ldrh, 2) = (named_data + 0)[11:1]
# jitlink-check: decode_operand(test_ldrsh, 2) = (named_data + 0)[11:1]
# jitlink-check: decode_operand(test_ldr_32bit, 2) = (named_data + 0)[11:2]
# jitlink-check: decode_operand(test_ldr_64bit, 2) = (named_data + 0)[11:3]
# jitlink-check: decode_operand(test_strb, 2) = named_data[11:0]
# jitlink-check: decode_operand(test_strh, 2) = (named_data + 0)[11:1]
# jitlink-check: decode_operand(test_str_32bit, 2) = (named_data + 0)[11:2]
# jitlink-check: decode_operand(test_str_64bit, 2) = (named_data + 0)[11:3]
.globl test_ldrb
test_ldrb:
ldrb w0, [x1, :lo12:named_data]
.size test_ldrb, .-test_ldrb
.globl test_ldrsb
test_ldrsb:
ldrsb w0, [x1, :lo12:named_data]
.size test_ldrsb, .-test_ldrsb
.globl test_ldrh
test_ldrh:
ldrh w0, [x1, :lo12:named_data]
.size test_ldrh, .-test_ldrh
.globl test_ldrsh
test_ldrsh:
ldrsh w0, [x1, :lo12:named_data]
.size test_ldrsh, .-test_ldrsh
.globl test_ldr_32bit
test_ldr_32bit:
ldr w0, [x1, :lo12:named_data]
.size test_ldr_32bit, .-test_ldr_32bit
.globl test_ldr_64bit
test_ldr_64bit:
ldr x0, [x1, :lo12:named_data]
.size test_ldr_64bit, .-test_ldr_64bit
.globl test_strb
test_strb:
strb w0, [x1, :lo12:named_data]
.size test_strb, .-test_strb
.globl test_strh
test_strh:
strh w0, [x1, :lo12:named_data]
.size test_strh, .-test_strh
.globl test_str_32bit
test_str_32bit:
str w0, [x1, :lo12:named_data]
.size test_str_32bit, .-test_str_32bit
.globl test_str_64bit
test_str_64bit:
str x0, [x1, :lo12:named_data]
.size test_str_64bit, .-test_str_64bit
# Check R_AARCH64_MOVW_UABS_G*_NC relocation of a local symbol
#
# The immediate value should be the symbol address right shifted according to LSL value
#
# jitlink-check: decode_operand(test_movz_g0_nc, 1) = named_data[15:0]
# jitlink-check: decode_operand(test_movk_g0_nc, 2) = named_data[15:0]
# jitlink-check: decode_operand(test_movz_g1_nc, 1) = named_data[31:16]
# jitlink-check: decode_operand(test_movk_g1_nc, 2) = named_data[31:16]
# jitlink-check: decode_operand(test_movz_g2_nc, 1) = named_data[47:32]
# jitlink-check: decode_operand(test_movk_g2_nc, 2) = named_data[47:32]
# jitlink-check: decode_operand(test_movz_g3, 1) = named_data[63:48]
# jitlink-check: decode_operand(test_movk_g3, 2) = named_data[63:48]
.globl test_movz_g0_nc
test_movz_g0_nc:
movz x0, #:abs_g0_nc:named_data
.size test_movz_g0_nc, .-test_movz_g0_nc
.globl test_movk_g0_nc
test_movk_g0_nc:
movk x0, #:abs_g0_nc:named_data
.size test_movk_g0_nc, .-test_movk_g0_nc
.globl test_movz_g1_nc
test_movz_g1_nc:
movz x0, #:abs_g1_nc:named_data
.size test_movz_g1_nc, .-test_movz_g1_nc
.globl test_movk_g1_nc
test_movk_g1_nc:
movk x0, #:abs_g1_nc:named_data
.size test_movk_g1_nc, .-test_movk_g1_nc
.globl test_movz_g2_nc
test_movz_g2_nc:
movz x0, #:abs_g2_nc:named_data
.size test_movz_g2_nc, .-test_movz_g2_nc
.globl test_movk_g2_nc
test_movk_g2_nc:
movk x0, #:abs_g2_nc:named_data
.size test_movk_g2_nc, .-test_movk_g2_nc
.globl test_movk_g3
test_movk_g3:
movk x0, #:abs_g3:named_data
.size test_movk_g3, .-test_movk_g3
.globl test_movz_g3
test_movz_g3:
movz x0, #:abs_g3:named_data
.size test_movz_g3, .-test_movz_g3
# Check R_AARCH64_ABS64 relocation of a function pointer to local symbol
#
# jitlink-check: *{8}local_func_addr_quad = named_func
.globl local_func_addr_quad
.p2align 3
local_func_addr_quad:
.xword named_func
.size local_func_addr_quad, 8
# Check R_AARCH64_ABS64 relocation of a function pointer to external symbol
#
# jitlink-check: *{8}external_func_addr_quad = external_func
.globl external_func_addr_quad
.p2align 3
external_func_addr_quad:
.xword external_func
.size external_func_addr_quad, 8
# Check R_AARCH64_ADR_GOT_PAGE / R_AARCH64_LD64_GOT_LO12_NC handling with a
# reference to an external symbol. Validate both the reference to the GOT entry,
# and also the content of the GOT entry.
#
# For the ADRP :got: instruction we have the 21-bit delta to the 4k page
# containing the GOT entry for external_data.
#
# For the LDR :got_lo12: instruction we have the 12-bit offset of the entry
# within the page.
#
# jitlink-check: *{8}(got_addr(elf_reloc.o, external_data)) = external_data
# jitlink-check: decode_operand(test_adr_gotpage_external, 1) = \
# jitlink-check: (got_addr(elf_reloc.o, external_data)[32:12] - \
# jitlink-check: test_adr_gotpage_external[32:12])
# jitlink-check: decode_operand(test_ld64_gotlo12_external, 2) = \
# jitlink-check: got_addr(elf_reloc.o, external_data)[11:3]
.globl test_adr_gotpage_external
.p2align 2
test_adr_gotpage_external:
adrp x0, :got:external_data
.size test_adr_gotpage_external, .-test_adr_gotpage_external
.globl test_ld64_gotlo12_external
.p2align 2
test_ld64_gotlo12_external:
ldr x0, [x0, :got_lo12:external_data]
.size test_ld64_gotlo12_external, .-test_ld64_gotlo12_external
# Check R_AARCH64_TSTBR14 for tbz
#
# jitlink-check: decode_operand(test_tstbr14_tbz, 2) = \
# jitlink-check: (test_tstbr14_tbz_target - test_tstbr14_tbz)[16:2]
.globl test_tstbr14_tbz, test_tstbr14_tbz_target
.p2align 2
test_tstbr14_tbz:
tbz x0, 0, test_tstbr14_tbz_target
.skip (1 << 14)
test_tstbr14_tbz_target:
.size test_tstbr14_tbz, .-test_tstbr14_tbz
# Check R_AARCH64_TSTBR14 for tbnz
#
# jitlink-check: decode_operand(test_tstbr14_tbnz, 2) = \
# jitlink-check: (test_tstbr14_tbnz_target - test_tstbr14_tbnz)[16:2]
.globl test_tstbr14_tbnz, test_tstbr14_tbnz_target
.p2align 2
test_tstbr14_tbnz:
tbnz x0, 0, test_tstbr14_tbnz_target
.skip (1 << 14)
test_tstbr14_tbnz_target:
.size test_tstbr14_tbnz, .-test_tstbr14_tbnz
# Check R_AARCH64_CONDBR19 for compare and branch instructions
#
# jitlink-check: decode_operand(test_condbr19_cbz, 1) = \
# jitlink-check: (test_condbr19_cbz_target - test_condbr19_cbz)[21:2]
.globl test_condbr19_cbz, test_condbr19_cbz_target
.p2align 2
test_condbr19_cbz:
cbz x0, test_condbr19_cbz_target
.skip (1 << 19)
test_condbr19_cbz_target:
.size test_condbr19_cbz, .-test_condbr19_cbz
# Check R_AARCH64_CONDBR19 for conditional branch instructions
#
# jitlink-check: decode_operand(test_condbr19_bc, 1) = \
# jitlink-check: (test_condbr19_bc_target - test_condbr19_bc)[21:2]
.globl test_condbr19_bc, test_condbr19_bc_target
.p2align 2
test_condbr19_bc:
b.eq test_condbr19_bc_target
.skip (1 << 19)
test_condbr19_bc_target:
.size test_condbr19_bc, .-test_condbr19_bc
.globl named_data
.p2align 4
.type named_data,@object
named_data:
.quad 0x2222222222222222
.quad 0x3333333333333333
.size named_data, .-named_data
.globl named_func
.p2align 2
.type named_func,@function
named_func:
ret
.size named_func, .-named_func
|
