1 /* BFD back-end for AArch64 COFF files.
2 Copyright (C) 2021-2023 Free Software Foundation, Inc.
3
4 This file is part of BFD, the Binary File Descriptor library.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
20
21
22 #ifndef COFF_WITH_peAArch64
23 #define COFF_WITH_peAArch64
24 #endif
25
26 /* Note we have to make sure not to include headers twice.
27 Not all headers are wrapped in #ifdef guards, so we define
28 PEI_HEADERS to prevent double including here. */
29 #ifndef PEI_HEADERS
30 #include "sysdep.h"
31 #include "bfd.h"
32 #include "libbfd.h"
33 #include "coff/aarch64.h"
34 #include "coff/internal.h"
35 #include "coff/pe.h"
36 #include "libcoff.h"
37 #include "libiberty.h"
38 #endif
39
40 #include "libcoff.h"
41
42 /* For these howto special functions,
43 output_bfd == NULL => final link, or objdump -W and other calls to
44 bfd_simple_get_relocated_section_contents
45 output_bfd != NULL && output_bfd != abfd => ld -r
46 output_bfd != NULL && output_bfd == abfd => gas.
47 FIXME: ld -r is punted to bfd_perform_relocation. This won't be
48 correct for cases where the addend needs to be adjusted, eg. for
49 relocations against section symbols, and the field is split because
50 bfd_perform_relocation can't write addends to split relocation fields. */
51
52 static bfd_reloc_status_type
53 coff_aarch64_rel21_reloc (bfd *abfd,
54 arelent *reloc_entry,
55 asymbol *symbol,
56 void *data,
57 asection *input_section,
58 bfd *output_bfd,
59 char **error_message ATTRIBUTE_UNUSED)
60 {
61 if (output_bfd != NULL && output_bfd != abfd)
62 return bfd_reloc_continue;
63
64 if (!bfd_reloc_offset_in_range (reloc_entry->howto, abfd,
65 input_section, reloc_entry->address))
66 return bfd_reloc_outofrange;
67
68 uint32_t op = bfd_getl32 (data + reloc_entry->address);
69 bfd_vma relocation = reloc_entry->addend;
70 bfd_reloc_status_type ret = bfd_reloc_ok;
71 if (output_bfd == NULL)
72 {
73 if (bfd_is_und_section (symbol->section))
74 {
75 if ((symbol->flags & BSF_WEAK) == 0)
76 ret = bfd_reloc_undefined;
77 }
78 else if (!bfd_is_com_section (symbol->section))
79 relocation += (symbol->value
80 + symbol->section->output_offset
81 + symbol->section->output_section->vma);
82 bfd_vma addend = ((op >> 3) & 0x1ffffc) | ((op >> 29) & 0x3);
83 addend = (addend ^ 0x100000) - 0x100000;
84 relocation += addend;
85 relocation -= (reloc_entry->address
86 + input_section->output_offset
87 + input_section->output_section->vma);
88 relocation = (bfd_signed_vma) relocation >> reloc_entry->howto->rightshift;
89 }
90 if (relocation + 0x100000 > 0x1fffff)
91 ret = bfd_reloc_overflow;
92
93 op &= 0x9f00001f;
94 op |= (relocation & 0x1ffffc) << 3;
95 op |= (relocation & 0x3) << 29;
96
97 bfd_putl32 (op, data + reloc_entry->address);
98
99 return ret;
100 }
101
102 static bfd_reloc_status_type
103 coff_aarch64_po12l_reloc (bfd *abfd,
104 arelent *reloc_entry,
105 asymbol *symbol ATTRIBUTE_UNUSED,
106 void *data,
107 asection *input_section,
108 bfd *output_bfd,
109 char **error_message ATTRIBUTE_UNUSED)
110 {
111 if (output_bfd != NULL && output_bfd != abfd)
112 return bfd_reloc_continue;
113
114 if (!bfd_reloc_offset_in_range (reloc_entry->howto, abfd,
115 input_section, reloc_entry->address))
116 return bfd_reloc_outofrange;
117
118 uint32_t op = bfd_getl32 (data + reloc_entry->address);
119 bfd_vma relocation = reloc_entry->addend & 0xfff;
120 int shift;
121
122 if ((op & 0xff800000) == 0x3d800000)
123 {
124 /* LDR / STR with q register */
125 shift = 4;
126 }
127 else
128 {
129 /* top two bits represent how much addend should be shifted */
130 shift = op >> 30;
131 }
132
133 bfd_reloc_status_type ret = bfd_reloc_ok;
134 if (output_bfd == NULL)
135 {
136 if (bfd_is_und_section (symbol->section))
137 {
138 if ((symbol->flags & BSF_WEAK) == 0)
139 ret = bfd_reloc_undefined;
140 }
141 else if (!bfd_is_com_section (symbol->section))
142 relocation += (symbol->value
143 + symbol->section->output_offset
144 + symbol->section->output_section->vma);
145 bfd_vma addend = (op >> 10) & 0xfff;
146 addend <<= shift;
147 relocation += addend;
148 }
149
150 if (relocation & ((1 << shift) - 1))
151 ret = bfd_reloc_overflow;
152
153 op &= 0xffc003ff;
154 op |= (relocation >> shift << 10) & 0x3ffc00;
155
156 bfd_putl32 (op, data + reloc_entry->address);
157
158 return ret;
159 }
160
161 static bfd_reloc_status_type
162 coff_aarch64_addr32nb_reloc (bfd *abfd,
163 arelent *reloc_entry,
164 asymbol *symbol ATTRIBUTE_UNUSED,
165 void *data,
166 asection *input_section,
167 bfd *output_bfd,
168 char **error_message)
169 {
170 if (output_bfd != NULL && output_bfd != abfd)
171 return bfd_reloc_continue;
172
173 if (!bfd_reloc_offset_in_range (reloc_entry->howto, abfd,
174 input_section, reloc_entry->address))
175 return bfd_reloc_outofrange;
176
177 bfd_vma relocation = reloc_entry->addend;
178 bfd_reloc_status_type ret = bfd_reloc_ok;
179 if (output_bfd == NULL)
180 {
181 if (bfd_is_und_section (symbol->section))
182 {
183 if ((symbol->flags & BSF_WEAK) == 0)
184 ret = bfd_reloc_undefined;
185 }
186 else if (!bfd_is_com_section (symbol->section))
187 relocation += (symbol->value
188 + symbol->section->output_offset
189 + symbol->section->output_section->vma);
190 bfd_vma addend = bfd_getl_signed_32 (data + reloc_entry->address);
191 relocation += addend;
192 bfd *obfd = input_section->output_section->owner;
193 if (bfd_get_flavour (obfd) == bfd_target_coff_flavour
194 && obj_pe (obfd))
195 relocation -= pe_data (obfd)->pe_opthdr.ImageBase;
196 else
197 {
198 *error_message = "unsupported";
199 return bfd_reloc_dangerous;
200 }
201 }
202
203 if (relocation + 0x80000000 > 0xffffffff)
204 ret = bfd_reloc_overflow;
205
206 bfd_putl32 (relocation, data + reloc_entry->address);
207
208 return ret;
209 }
210
211 static bfd_reloc_status_type
212 coff_aarch64_secrel_reloc (bfd *abfd,
213 arelent *reloc_entry,
214 asymbol *symbol ATTRIBUTE_UNUSED,
215 void *data,
216 asection *input_section,
217 bfd *output_bfd,
218 char **error_message ATTRIBUTE_UNUSED)
219 {
220 if (output_bfd != NULL && output_bfd != abfd)
221 return bfd_reloc_continue;
222
223 if (!bfd_reloc_offset_in_range (reloc_entry->howto, abfd,
224 input_section, reloc_entry->address))
225 return bfd_reloc_outofrange;
226
227 bfd_vma relocation = reloc_entry->addend;
228 bfd_reloc_status_type ret = bfd_reloc_ok;
229 if (output_bfd == NULL)
230 {
231 if (bfd_is_und_section (symbol->section))
232 {
233 if ((symbol->flags & BSF_WEAK) == 0)
234 ret = bfd_reloc_undefined;
235 }
236 else if (!bfd_is_com_section (symbol->section))
237 relocation += (symbol->value
238 + symbol->section->output_offset);
239 bfd_vma addend = bfd_getl_signed_32 (data + reloc_entry->address);
240 relocation += addend;
241 }
242 if (relocation > 0xffffffff)
243 ret = bfd_reloc_overflow;
244
245 bfd_putl32 (relocation, data + reloc_entry->address);
246
247 return ret;
248 }
249
250 #define coff_aarch64_NULL NULL
251 #undef HOWTO_INSTALL_ADDEND
252 #define HOWTO_INSTALL_ADDEND 1
253 #define HOW(type, right, size, bits, pcrel, left, ovf, func, mask) \
254 HOWTO (type, right, size, bits, pcrel, left, complain_overflow_##ovf, \
255 coff_aarch64_##func, #type, true, mask, mask, false)
256
257 static const reloc_howto_type arm64_reloc_howto_abs
258 = HOW (IMAGE_REL_ARM64_ABSOLUTE,
259 0, 0, 0, false, 0, dont, NULL, 0);
260
261 static const reloc_howto_type arm64_reloc_howto_64
262 = HOW (IMAGE_REL_ARM64_ADDR64,
263 0, 8, 64, false, 0, dont, NULL, UINT64_C (-1));
264
265 static const reloc_howto_type arm64_reloc_howto_32
266 = HOW (IMAGE_REL_ARM64_ADDR32,
267 0, 4, 32, false, 0, signed, NULL, 0xffffffff);
268
269 static const reloc_howto_type arm64_reloc_howto_32_pcrel
270 = HOW (IMAGE_REL_ARM64_REL32,
271 0, 4, 32, true, 0, signed, NULL, 0xffffffff);
272
273 static const reloc_howto_type arm64_reloc_howto_branch26
274 = HOW (IMAGE_REL_ARM64_BRANCH26,
275 2, 4, 26, true, 0, signed, NULL, 0x3ffffff);
276
277 static const reloc_howto_type arm64_reloc_howto_page21
278 = HOW (IMAGE_REL_ARM64_PAGEBASE_REL21,
279 12, 4, 21, true, 0, signed, rel21_reloc, 0x1fffff);
280
281 static const reloc_howto_type arm64_reloc_howto_lo21
282 = HOW (IMAGE_REL_ARM64_REL21,
283 0, 4, 21, true, 0, signed, rel21_reloc, 0x1fffff);
284
285 static const reloc_howto_type arm64_reloc_howto_pgoff12l
286 = HOW (IMAGE_REL_ARM64_PAGEOFFSET_12L,
287 0, 4, 12, true, 10, signed, po12l_reloc, 0x3ffc00);
288
289 static const reloc_howto_type arm64_reloc_howto_branch19
290 = HOW (IMAGE_REL_ARM64_BRANCH19,
291 2, 4, 19, true, 5, signed, NULL, 0xffffe0);
292
293 static const reloc_howto_type arm64_reloc_howto_branch14
294 = HOW (IMAGE_REL_ARM64_BRANCH14,
295 2, 4, 14, true, 5, signed, NULL, 0x7ffe0);
296
297 static const reloc_howto_type arm64_reloc_howto_pgoff12a
298 = HOW (IMAGE_REL_ARM64_PAGEOFFSET_12A,
299 0, 4, 12, true, 10, dont, NULL, 0x3ffc00);
300
301 static const reloc_howto_type arm64_reloc_howto_32nb
302 = HOW (IMAGE_REL_ARM64_ADDR32NB,
303 0, 4, 32, false, 0, signed, addr32nb_reloc, 0xffffffff);
304
305 static const reloc_howto_type arm64_reloc_howto_secrel
306 = HOW (IMAGE_REL_ARM64_SECREL,
307 0, 4, 32, false, 0, dont, secrel_reloc, 0xffffffff);
308
309 static const reloc_howto_type arm64_reloc_howto_secidx
310 = HOW (IMAGE_REL_ARM64_SECTION,
311 0, 2, 16, false, 0, dont, NULL, 0xffff);
312
313 static const reloc_howto_type* const arm64_howto_table[] = {
314 &arm64_reloc_howto_abs,
315 &arm64_reloc_howto_64,
316 &arm64_reloc_howto_32,
317 &arm64_reloc_howto_32_pcrel,
318 &arm64_reloc_howto_branch26,
319 &arm64_reloc_howto_page21,
320 &arm64_reloc_howto_lo21,
321 &arm64_reloc_howto_pgoff12l,
322 &arm64_reloc_howto_branch19,
323 &arm64_reloc_howto_branch14,
324 &arm64_reloc_howto_pgoff12a,
325 &arm64_reloc_howto_32nb,
326 &arm64_reloc_howto_secrel,
327 &arm64_reloc_howto_secidx
328 };
329
330 /* No adjustment to addends should be needed. The actual relocation
331 addend is in the section contents. Unfortunately this means actual
332 addends are not shown by objdump -r, but that's true for most
333 COFF/PE targets where arelent.addend is an adjustment. */
334 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
335 cache_ptr->addend = 0;
336
337 #ifndef NUM_ELEM
338 #define NUM_ELEM(a) ((sizeof (a)) / sizeof ((a)[0]))
339 #endif
340
341 #define NUM_RELOCS NUM_ELEM (arm64_howto_table)
342
343 #define coff_bfd_reloc_type_lookup coff_aarch64_reloc_type_lookup
344 #define coff_bfd_reloc_name_lookup coff_aarch64_reloc_name_lookup
345
346 static reloc_howto_type *
347 coff_aarch64_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED, bfd_reloc_code_real_type code)
348 {
349 switch (code)
350 {
351 case BFD_RELOC_64:
352 return &arm64_reloc_howto_64;
353 case BFD_RELOC_32:
354 return &arm64_reloc_howto_32;
355 case BFD_RELOC_32_PCREL:
356 return &arm64_reloc_howto_32_pcrel;
357 case BFD_RELOC_AARCH64_CALL26:
358 case BFD_RELOC_AARCH64_JUMP26:
359 return &arm64_reloc_howto_branch26;
360 case BFD_RELOC_AARCH64_ADR_HI21_PCREL:
361 case BFD_RELOC_AARCH64_ADR_HI21_NC_PCREL:
362 return &arm64_reloc_howto_page21;
363 case BFD_RELOC_AARCH64_TSTBR14:
364 return &arm64_reloc_howto_branch14;
365 case BFD_RELOC_AARCH64_ADR_LO21_PCREL:
366 return &arm64_reloc_howto_lo21;
367 case BFD_RELOC_AARCH64_ADD_LO12:
368 return &arm64_reloc_howto_pgoff12a;
369 case BFD_RELOC_AARCH64_LDST8_LO12:
370 case BFD_RELOC_AARCH64_LDST16_LO12:
371 case BFD_RELOC_AARCH64_LDST32_LO12:
372 case BFD_RELOC_AARCH64_LDST64_LO12:
373 case BFD_RELOC_AARCH64_LDST128_LO12:
374 return &arm64_reloc_howto_pgoff12l;
375 case BFD_RELOC_AARCH64_BRANCH19:
376 return &arm64_reloc_howto_branch19;
377 case BFD_RELOC_RVA:
378 return &arm64_reloc_howto_32nb;
379 case BFD_RELOC_32_SECREL:
380 return &arm64_reloc_howto_secrel;
381 case BFD_RELOC_16_SECIDX:
382 return &arm64_reloc_howto_secidx;
383 default:
384 BFD_FAIL ();
385 return NULL;
386 }
387
388 return NULL;
389 }
390
391 static reloc_howto_type *
392 coff_aarch64_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
393 const char *r_name)
394 {
395 unsigned int i;
396
397 for (i = 0; i < NUM_RELOCS; i++)
398 if (arm64_howto_table[i]->name != NULL
399 && strcasecmp (arm64_howto_table[i]->name, r_name) == 0)
400 return arm64_howto_table[i];
401
402 return NULL;
403 }
404
405 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER 2
406 #define COFF_PAGE_SIZE 0x1000
407
408 static reloc_howto_type *
409 coff_aarch64_rtype_lookup (unsigned int code)
410 {
411 switch (code)
412 {
413 case IMAGE_REL_ARM64_ABSOLUTE:
414 return &arm64_reloc_howto_abs;
415 case IMAGE_REL_ARM64_ADDR64:
416 return &arm64_reloc_howto_64;
417 case IMAGE_REL_ARM64_ADDR32:
418 return &arm64_reloc_howto_32;
419 case IMAGE_REL_ARM64_REL32:
420 return &arm64_reloc_howto_32_pcrel;
421 case IMAGE_REL_ARM64_BRANCH26:
422 return &arm64_reloc_howto_branch26;
423 case IMAGE_REL_ARM64_PAGEBASE_REL21:
424 return &arm64_reloc_howto_page21;
425 case IMAGE_REL_ARM64_REL21:
426 return &arm64_reloc_howto_lo21;
427 case IMAGE_REL_ARM64_PAGEOFFSET_12L:
428 return &arm64_reloc_howto_pgoff12l;
429 case IMAGE_REL_ARM64_BRANCH19:
430 return &arm64_reloc_howto_branch19;
431 case IMAGE_REL_ARM64_BRANCH14:
432 return &arm64_reloc_howto_branch14;
433 case IMAGE_REL_ARM64_PAGEOFFSET_12A:
434 return &arm64_reloc_howto_pgoff12a;
435 case IMAGE_REL_ARM64_ADDR32NB:
436 return &arm64_reloc_howto_32nb;
437 case IMAGE_REL_ARM64_SECREL:
438 return &arm64_reloc_howto_secrel;
439 case IMAGE_REL_ARM64_SECTION:
440 return &arm64_reloc_howto_secidx;
441 default:
442 return NULL;
443 }
444
445 return NULL;
446 }
447
448 #define RTYPE2HOWTO(cache_ptr, dst) \
449 ((cache_ptr)->howto = coff_aarch64_rtype_lookup((dst)->r_type))
450
451 static reloc_howto_type *
452 coff_aarch64_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
453 asection *sec ATTRIBUTE_UNUSED,
454 struct internal_reloc *rel,
455 struct coff_link_hash_entry *h ATTRIBUTE_UNUSED,
456 struct internal_syment *sym ATTRIBUTE_UNUSED,
457 bfd_vma *addendp)
458 {
459 reloc_howto_type *howto = coff_aarch64_rtype_lookup (rel->r_type);
460
461 /* Cancel out code in _bfd_coff_generic_relocate_section. */
462 *addendp = 0;
463
464 return howto;
465 }
466
467 #define coff_rtype_to_howto coff_aarch64_rtype_to_howto
468
469 #define SELECT_RELOC(x,howto) { (x).r_type = (howto)->type; }
470
471 #ifndef bfd_pe_print_pdata
472 #define bfd_pe_print_pdata NULL
473 #endif
474
475 #ifdef COFF_WITH_PE
476 /* Return TRUE if this relocation should
477 appear in the output .reloc section. */
478
479 static bool
480 in_reloc_p (bfd * abfd ATTRIBUTE_UNUSED,
481 reloc_howto_type * howto)
482 {
483 return !howto->pc_relative;
484 }
485 #endif
486
487 static bool
488 coff_pe_aarch64_relocate_section (bfd *output_bfd,
489 struct bfd_link_info *info,
490 bfd *input_bfd,
491 asection *input_section,
492 bfd_byte *contents,
493 struct internal_reloc *relocs,
494 struct internal_syment *syms,
495 asection **sections)
496 {
497 struct internal_reloc *rel;
498 struct internal_reloc *relend;
499
500 if (bfd_link_relocatable (info))
501 return true;
502
503 rel = relocs;
504 relend = rel + input_section->reloc_count;
505
506 /* The addend for a relocation is stored in the immediate bits of each
507 opcode. So for each relocation, we need to extract the immediate value,
508 use this to calculate what it should be for the symbol, and rewrite the
509 opcode into the section stream. */
510
511 for (; rel < relend; rel++)
512 {
513 long symndx;
514 struct coff_link_hash_entry *h;
515 bfd_vma sym_value;
516 asection *sec = NULL;
517 uint64_t dest_vma;
518
519 /* skip trivial relocations */
520 if (rel->r_type == IMAGE_REL_ARM64_ADDR32
521 || rel->r_type == IMAGE_REL_ARM64_ADDR64
522 || rel->r_type == IMAGE_REL_ARM64_ABSOLUTE)
523 continue;
524
525 symndx = rel->r_symndx;
526 sym_value = syms[symndx].n_value;
527
528 h = obj_coff_sym_hashes (input_bfd)[symndx];
529
530 if (h && h->root.type == bfd_link_hash_defined)
531 {
532 sec = h->root.u.def.section;
533 sym_value = h->root.u.def.value;
534 }
535 else
536 {
537 sec = sections[symndx];
538 }
539
540 if (!sec)
541 continue;
542
543 if (bfd_is_und_section (sec))
544 continue;
545
546 if (discarded_section (sec))
547 continue;
548
549 dest_vma = sec->output_section->vma + sec->output_offset + sym_value;
550
551 if (symndx < 0
552 || (unsigned long) symndx >= obj_raw_syment_count (input_bfd))
553 continue;
554
555 /* All the relocs handled below operate on 4 bytes. */
556 if (input_section->size < rel->r_vaddr
557 || input_section->size - rel->r_vaddr < 4)
558 {
559 _bfd_error_handler
560 /* xgettext: c-format */
561 (_("%pB: bad reloc address %#" PRIx64 " in section `%pA'"),
562 input_bfd, (uint64_t) rel->r_vaddr, input_section);
563 continue;
564 }
565
566 switch (rel->r_type)
567 {
568 case IMAGE_REL_ARM64_ADDR32NB:
569 {
570 uint64_t val;
571 int32_t addend;
572
573 addend = bfd_getl32 (contents + rel->r_vaddr);
574
575 dest_vma += addend;
576
577 val = dest_vma;
578 val -= pe_data (output_bfd)->pe_opthdr.ImageBase;
579
580 if (val > 0xffffffff)
581 (*info->callbacks->reloc_overflow)
582 (info, h ? &h->root : NULL, syms[symndx]._n._n_name,
583 "IMAGE_REL_ARM64_ADDR32NB", addend, input_bfd,
584 input_section, rel->r_vaddr - input_section->vma);
585
586 bfd_putl32 (val, contents + rel->r_vaddr);
587 rel->r_type = IMAGE_REL_ARM64_ABSOLUTE;
588
589 break;
590 }
591
592 case IMAGE_REL_ARM64_BRANCH26:
593 {
594 uint64_t cur_vma;
595 uint32_t opcode;
596 int64_t addend, val;
597
598 opcode = bfd_getl32 (contents + rel->r_vaddr);
599
600 addend = (opcode & 0x3ffffff) << 2;
601
602 if (addend & 0x8000000)
603 addend |= 0xfffffffff0000000;
604
605 dest_vma += addend;
606 cur_vma = input_section->output_section->vma
607 + input_section->output_offset
608 + rel->r_vaddr;
609
610 val = (dest_vma >> 2) - (cur_vma >> 2);
611
612 if (val > 0x1ffffff || val < -0x2000000)
613 (*info->callbacks->reloc_overflow)
614 (info, h ? &h->root : NULL, syms[symndx]._n._n_name,
615 "IMAGE_REL_ARM64_BRANCH26", addend, input_bfd,
616 input_section, rel->r_vaddr - input_section->vma);
617
618 opcode &= 0xfc000000;
619 opcode |= val & 0x3ffffff;
620
621 bfd_putl32 (opcode, contents + rel->r_vaddr);
622 rel->r_type = IMAGE_REL_ARM64_ABSOLUTE;
623
624 break;
625 }
626
627 case IMAGE_REL_ARM64_BRANCH19:
628 {
629 uint64_t cur_vma;
630 uint32_t opcode;
631 int64_t addend, val;
632
633 opcode = bfd_getl32 (contents + rel->r_vaddr);
634
635 addend = (opcode & 0xffffe0) >> 3;
636
637 if (addend & 0x100000)
638 addend |= 0xffffffffffe00000;
639
640 dest_vma += addend;
641 cur_vma = input_section->output_section->vma
642 + input_section->output_offset
643 + rel->r_vaddr;
644
645 val = (dest_vma >> 2) - (cur_vma >> 2);
646
647 if (val > 0x3ffff || val < -0x40000)
648 (*info->callbacks->reloc_overflow)
649 (info, h ? &h->root : NULL, syms[symndx]._n._n_name,
650 "IMAGE_REL_ARM64_BRANCH19", addend, input_bfd,
651 input_section, rel->r_vaddr - input_section->vma);
652
653 opcode &= 0xff00001f;
654 opcode |= (val & 0x7ffff) << 5;
655
656 bfd_putl32 (opcode, contents + rel->r_vaddr);
657 rel->r_type = IMAGE_REL_ARM64_ABSOLUTE;
658
659 break;
660 }
661
662 case IMAGE_REL_ARM64_BRANCH14:
663 {
664 uint64_t cur_vma;
665 uint32_t opcode;
666 int64_t addend, val;
667
668 opcode = bfd_getl32 (contents + rel->r_vaddr);
669
670 addend = (opcode & 0x7ffe0) >> 3;
671
672 if (addend & 0x8000)
673 addend |= 0xffffffffffff0000;
674
675 dest_vma += addend;
676 cur_vma = input_section->output_section->vma
677 + input_section->output_offset
678 + rel->r_vaddr;
679
680 val = (dest_vma >> 2) - (cur_vma >> 2);
681
682 if (val > 0x1fff || val < -0x2000)
683 (*info->callbacks->reloc_overflow)
684 (info, h ? &h->root : NULL, syms[symndx]._n._n_name,
685 "IMAGE_REL_ARM64_BRANCH14", addend, input_bfd,
686 input_section, rel->r_vaddr - input_section->vma);
687
688 opcode &= 0xfff8001f;
689 opcode |= (val & 0x3fff) << 5;
690
691 bfd_putl32 (opcode, contents + rel->r_vaddr);
692 rel->r_type = IMAGE_REL_ARM64_ABSOLUTE;
693
694 break;
695 }
696
697 case IMAGE_REL_ARM64_PAGEBASE_REL21:
698 {
699 uint64_t cur_vma;
700 uint32_t opcode;
701 int64_t addend, val;
702
703 opcode = bfd_getl32 (contents + rel->r_vaddr);
704
705 addend = ((opcode & 0xffffe0) >> 3)
706 | ((opcode & 0x60000000) >> 29);
707
708 if (addend & 0x100000)
709 addend |= 0xffffffffffe00000;
710
711 dest_vma += addend;
712 cur_vma = input_section->output_section->vma
713 + input_section->output_offset
714 + rel->r_vaddr;
715
716 val = (dest_vma >> 12) - (cur_vma >> 12);
717
718 if (val > 0xfffff || val < -0x100000)
719 (*info->callbacks->reloc_overflow)
720 (info, h ? &h->root : NULL, syms[symndx]._n._n_name,
721 "IMAGE_REL_ARM64_PAGEBASE_REL21", addend, input_bfd,
722 input_section, rel->r_vaddr - input_section->vma);
723
724 opcode &= 0x9f00001f;
725 opcode |= (val & 0x3) << 29;
726 opcode |= (val & 0x1ffffc) << 3;
727
728 bfd_putl32 (opcode, contents + rel->r_vaddr);
729 rel->r_type = IMAGE_REL_ARM64_ABSOLUTE;
730
731 break;
732 }
733
734 case IMAGE_REL_ARM64_REL21:
735 {
736 uint64_t cur_vma;
737 uint32_t opcode;
738 int64_t addend, val;
739
740 opcode = bfd_getl32 (contents + rel->r_vaddr);
741
742 addend = ((opcode & 0xffffe0) >> 3)
743 | ((opcode & 0x60000000) >> 29);
744
745 if (addend & 0x100000)
746 addend |= 0xffffffffffe00000;
747
748 dest_vma += addend;
749 cur_vma = input_section->output_section->vma
750 + input_section->output_offset
751 + rel->r_vaddr;
752
753 val = dest_vma - cur_vma;
754
755 if (val > 0xfffff || val < -0x100000)
756 (*info->callbacks->reloc_overflow)
757 (info, h ? &h->root : NULL, syms[symndx]._n._n_name,
758 "IMAGE_REL_ARM64_REL21", addend, input_bfd,
759 input_section, rel->r_vaddr - input_section->vma);
760
761 opcode &= 0x9f00001f;
762 opcode |= (val & 0x3) << 29;
763 opcode |= (val & 0x1ffffc) << 3;
764
765 bfd_putl32 (opcode, contents + rel->r_vaddr);
766 rel->r_type = IMAGE_REL_ARM64_ABSOLUTE;
767
768 break;
769 }
770
771 case IMAGE_REL_ARM64_PAGEOFFSET_12L:
772 {
773 uint32_t opcode, val;
774 uint8_t shift;
775 int32_t addend;
776
777 opcode = bfd_getl32 (contents + rel->r_vaddr);
778
779 addend = (opcode & 0x3ffc00) >> 10;
780
781 if ((opcode & 0xff800000) == 0x3d800000)
782 {
783 /* LDR / STR with q register */
784 shift = 4;
785 }
786 else
787 {
788 /* top two bits represent how much addend should be shifted */
789 shift = opcode >> 30;
790 }
791
792 addend <<= shift;
793
794 dest_vma += addend;
795
796 /* only interested in bottom 12 bits */
797 val = dest_vma & 0xfff;
798
799 if (val & ((1 << shift) - 1))
800 (*info->callbacks->reloc_overflow)
801 (info, h ? &h->root : NULL, syms[symndx]._n._n_name,
802 "IMAGE_REL_ARM64_PAGEOFFSET_12L", addend, input_bfd,
803 input_section, rel->r_vaddr - input_section->vma);
804
805 val >>= shift;
806
807 opcode &= 0xffc003ff;
808 opcode |= val << 10;
809
810 bfd_putl32 (opcode, contents + rel->r_vaddr);
811 rel->r_type = IMAGE_REL_ARM64_ABSOLUTE;
812
813 break;
814 }
815
816 case IMAGE_REL_ARM64_PAGEOFFSET_12A:
817 {
818 uint32_t opcode, val;
819 int32_t addend;
820
821 opcode = bfd_getl32 (contents + rel->r_vaddr);
822
823 addend = (opcode & 0x3ffc00) >> 10;
824
825 dest_vma += addend;
826
827 /* only interested in bottom 12 bits */
828 val = dest_vma & 0xfff;
829
830 opcode &= 0xffc003ff;
831 opcode |= val << 10;
832
833 bfd_putl32 (opcode, contents + rel->r_vaddr);
834 rel->r_type = IMAGE_REL_ARM64_ABSOLUTE;
835
836 break;
837 }
838
839 case IMAGE_REL_ARM64_SECREL:
840 {
841 uint64_t val;
842 int32_t addend;
843
844 addend = bfd_getl32 (contents + rel->r_vaddr);
845
846 val = sec->output_offset + sym_value + addend;
847
848 if (val > 0xffffffff)
849 (*info->callbacks->reloc_overflow)
850 (info, h ? &h->root : NULL, syms[symndx]._n._n_name,
851 "IMAGE_REL_ARM64_SECREL", addend, input_bfd,
852 input_section, rel->r_vaddr - input_section->vma);
853
854 bfd_putl32 (val, contents + rel->r_vaddr);
855 rel->r_type = IMAGE_REL_ARM64_ABSOLUTE;
856
857 break;
858 }
859
860 case IMAGE_REL_ARM64_SECTION:
861 {
862 uint16_t idx = 0, i = 1;
863 asection *s;
864
865 s = output_bfd->sections;
866 while (s)
867 {
868 if (s == sec->output_section)
869 {
870 idx = i;
871 break;
872 }
873
874 i++;
875 s = s->next;
876 }
877
878
879 bfd_putl16 (idx, contents + rel->r_vaddr);
880 rel->r_type = IMAGE_REL_ARM64_ABSOLUTE;
881
882 break;
883 }
884
885 default:
886 info->callbacks->einfo (_("%F%P: Unhandled relocation type %u\n"),
887 rel->r_type);
888 BFD_FAIL ();
889 return false;
890 }
891 }
892
893 return _bfd_coff_generic_relocate_section (output_bfd, info, input_bfd,
894 input_section, contents,
895 relocs, syms, sections);
896 }
897
898 #define coff_relocate_section coff_pe_aarch64_relocate_section
899
900 #include "coffcode.h"
901
902 /* Prevent assertion in md_apply_fix by forcing use_rela_p on for new
903 sections. */
904 static bool
905 coff_aarch64_new_section_hook (bfd *abfd, asection *section)
906 {
907 if (!coff_new_section_hook (abfd, section))
908 return false;
909
910 section->use_rela_p = 1;
911
912 return true;
913 }
914
915 #define coff_aarch64_close_and_cleanup coff_close_and_cleanup
916 #define coff_aarch64_bfd_free_cached_info coff_bfd_free_cached_info
917 #define coff_aarch64_get_section_contents coff_get_section_contents
918 #define coff_aarch64_get_section_contents_in_window coff_get_section_contents_in_window
919
920 /* Target vectors. */
921 const bfd_target
922 #ifdef TARGET_SYM
923 TARGET_SYM =
924 #else
925 # error "target symbol name not specified"
926 #endif
927 {
928 #ifdef TARGET_NAME
929 TARGET_NAME,
930 #else
931 # error "target name not specified"
932 #endif
933 bfd_target_coff_flavour,
934 BFD_ENDIAN_LITTLE, /* Data byte order is little. */
935 BFD_ENDIAN_LITTLE, /* Header byte order is little. */
936
937 (HAS_RELOC | EXEC_P /* Object flags. */
938 | HAS_LINENO | HAS_DEBUG
939 | HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED | BFD_COMPRESS | BFD_DECOMPRESS),
940
941 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* Section flags. */
942 #if defined(COFF_WITH_PE)
943 | SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_READONLY | SEC_DEBUGGING
944 #endif
945 | SEC_CODE | SEC_DATA | SEC_EXCLUDE ),
946
947 #ifdef TARGET_UNDERSCORE
948 TARGET_UNDERSCORE, /* Leading underscore. */
949 #else
950 0, /* Leading underscore. */
951 #endif
952 '/', /* Ar_pad_char. */
953 15, /* Ar_max_namelen. */
954 0, /* match priority. */
955 TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols. */
956
957 /* Data conversion functions. */
958 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
959 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
960 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Data. */
961 /* Header conversion functions. */
962 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
963 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
964 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Hdrs. */
965
966 /* Note that we allow an object file to be treated as a core file as well. */
967 { /* bfd_check_format. */
968 _bfd_dummy_target,
969 coff_object_p,
970 bfd_generic_archive_p,
971 coff_object_p
972 },
973 { /* bfd_set_format. */
974 _bfd_bool_bfd_false_error,
975 coff_mkobject,
976 _bfd_generic_mkarchive,
977 _bfd_bool_bfd_false_error
978 },
979 { /* bfd_write_contents. */
980 _bfd_bool_bfd_false_error,
981 coff_write_object_contents,
982 _bfd_write_archive_contents,
983 _bfd_bool_bfd_false_error
984 },
985
986 BFD_JUMP_TABLE_GENERIC (coff_aarch64),
987 BFD_JUMP_TABLE_COPY (coff),
988 BFD_JUMP_TABLE_CORE (_bfd_nocore),
989 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
990 BFD_JUMP_TABLE_SYMBOLS (coff),
991 BFD_JUMP_TABLE_RELOCS (coff),
992 BFD_JUMP_TABLE_WRITE (coff),
993 BFD_JUMP_TABLE_LINK (coff),
994 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
995
996 NULL,
997
998 COFF_SWAP_TABLE
999 };