1 /* 32-bit ELF support for ARM
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3 2008, 2009, 2010 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
26 #include "libiberty.h"
29 #include "elf-vxworks.h"
32 /* Return the relocation section associated with NAME. HTAB is the
33 bfd's elf32_arm_link_hash_entry. */
34 #define RELOC_SECTION(HTAB, NAME) \
35 ((HTAB)->use_rel ? ".rel" NAME : ".rela" NAME)
37 /* Return size of a relocation entry. HTAB is the bfd's
38 elf32_arm_link_hash_entry. */
39 #define RELOC_SIZE(HTAB) \
41 ? sizeof (Elf32_External_Rel) \
42 : sizeof (Elf32_External_Rela))
44 /* Return function to swap relocations in. HTAB is the bfd's
45 elf32_arm_link_hash_entry. */
46 #define SWAP_RELOC_IN(HTAB) \
48 ? bfd_elf32_swap_reloc_in \
49 : bfd_elf32_swap_reloca_in)
51 /* Return function to swap relocations out. HTAB is the bfd's
52 elf32_arm_link_hash_entry. */
53 #define SWAP_RELOC_OUT(HTAB) \
55 ? bfd_elf32_swap_reloc_out \
56 : bfd_elf32_swap_reloca_out)
58 #define elf_info_to_howto 0
59 #define elf_info_to_howto_rel elf32_arm_info_to_howto
61 #define ARM_ELF_ABI_VERSION 0
62 #define ARM_ELF_OS_ABI_VERSION ELFOSABI_ARM
64 static bfd_boolean elf32_arm_write_section (bfd *output_bfd,
65 struct bfd_link_info *link_info,
69 /* Note: code such as elf32_arm_reloc_type_lookup expect to use e.g.
70 R_ARM_PC24 as an index into this, and find the R_ARM_PC24 HOWTO
73 static reloc_howto_type elf32_arm_howto_table_1[] =
76 HOWTO (R_ARM_NONE, /* type */
78 0, /* size (0 = byte, 1 = short, 2 = long) */
80 FALSE, /* pc_relative */
82 complain_overflow_dont,/* complain_on_overflow */
83 bfd_elf_generic_reloc, /* special_function */
84 "R_ARM_NONE", /* name */
85 FALSE, /* partial_inplace */
88 FALSE), /* pcrel_offset */
90 HOWTO (R_ARM_PC24, /* type */
92 2, /* size (0 = byte, 1 = short, 2 = long) */
94 TRUE, /* pc_relative */
96 complain_overflow_signed,/* complain_on_overflow */
97 bfd_elf_generic_reloc, /* special_function */
98 "R_ARM_PC24", /* name */
99 FALSE, /* partial_inplace */
100 0x00ffffff, /* src_mask */
101 0x00ffffff, /* dst_mask */
102 TRUE), /* pcrel_offset */
104 /* 32 bit absolute */
105 HOWTO (R_ARM_ABS32, /* type */
107 2, /* size (0 = byte, 1 = short, 2 = long) */
109 FALSE, /* pc_relative */
111 complain_overflow_bitfield,/* complain_on_overflow */
112 bfd_elf_generic_reloc, /* special_function */
113 "R_ARM_ABS32", /* name */
114 FALSE, /* partial_inplace */
115 0xffffffff, /* src_mask */
116 0xffffffff, /* dst_mask */
117 FALSE), /* pcrel_offset */
119 /* standard 32bit pc-relative reloc */
120 HOWTO (R_ARM_REL32, /* type */
122 2, /* size (0 = byte, 1 = short, 2 = long) */
124 TRUE, /* pc_relative */
126 complain_overflow_bitfield,/* complain_on_overflow */
127 bfd_elf_generic_reloc, /* special_function */
128 "R_ARM_REL32", /* name */
129 FALSE, /* partial_inplace */
130 0xffffffff, /* src_mask */
131 0xffffffff, /* dst_mask */
132 TRUE), /* pcrel_offset */
134 /* 8 bit absolute - R_ARM_LDR_PC_G0 in AAELF */
135 HOWTO (R_ARM_LDR_PC_G0, /* type */
137 0, /* size (0 = byte, 1 = short, 2 = long) */
139 TRUE, /* pc_relative */
141 complain_overflow_dont,/* complain_on_overflow */
142 bfd_elf_generic_reloc, /* special_function */
143 "R_ARM_LDR_PC_G0", /* name */
144 FALSE, /* partial_inplace */
145 0xffffffff, /* src_mask */
146 0xffffffff, /* dst_mask */
147 TRUE), /* pcrel_offset */
149 /* 16 bit absolute */
150 HOWTO (R_ARM_ABS16, /* type */
152 1, /* size (0 = byte, 1 = short, 2 = long) */
154 FALSE, /* pc_relative */
156 complain_overflow_bitfield,/* complain_on_overflow */
157 bfd_elf_generic_reloc, /* special_function */
158 "R_ARM_ABS16", /* name */
159 FALSE, /* partial_inplace */
160 0x0000ffff, /* src_mask */
161 0x0000ffff, /* dst_mask */
162 FALSE), /* pcrel_offset */
164 /* 12 bit absolute */
165 HOWTO (R_ARM_ABS12, /* type */
167 2, /* size (0 = byte, 1 = short, 2 = long) */
169 FALSE, /* pc_relative */
171 complain_overflow_bitfield,/* complain_on_overflow */
172 bfd_elf_generic_reloc, /* special_function */
173 "R_ARM_ABS12", /* name */
174 FALSE, /* partial_inplace */
175 0x00000fff, /* src_mask */
176 0x00000fff, /* dst_mask */
177 FALSE), /* pcrel_offset */
179 HOWTO (R_ARM_THM_ABS5, /* type */
181 1, /* size (0 = byte, 1 = short, 2 = long) */
183 FALSE, /* pc_relative */
185 complain_overflow_bitfield,/* complain_on_overflow */
186 bfd_elf_generic_reloc, /* special_function */
187 "R_ARM_THM_ABS5", /* name */
188 FALSE, /* partial_inplace */
189 0x000007e0, /* src_mask */
190 0x000007e0, /* dst_mask */
191 FALSE), /* pcrel_offset */
194 HOWTO (R_ARM_ABS8, /* type */
196 0, /* size (0 = byte, 1 = short, 2 = long) */
198 FALSE, /* pc_relative */
200 complain_overflow_bitfield,/* complain_on_overflow */
201 bfd_elf_generic_reloc, /* special_function */
202 "R_ARM_ABS8", /* name */
203 FALSE, /* partial_inplace */
204 0x000000ff, /* src_mask */
205 0x000000ff, /* dst_mask */
206 FALSE), /* pcrel_offset */
208 HOWTO (R_ARM_SBREL32, /* type */
210 2, /* size (0 = byte, 1 = short, 2 = long) */
212 FALSE, /* pc_relative */
214 complain_overflow_dont,/* complain_on_overflow */
215 bfd_elf_generic_reloc, /* special_function */
216 "R_ARM_SBREL32", /* name */
217 FALSE, /* partial_inplace */
218 0xffffffff, /* src_mask */
219 0xffffffff, /* dst_mask */
220 FALSE), /* pcrel_offset */
222 HOWTO (R_ARM_THM_CALL, /* type */
224 2, /* size (0 = byte, 1 = short, 2 = long) */
226 TRUE, /* pc_relative */
228 complain_overflow_signed,/* complain_on_overflow */
229 bfd_elf_generic_reloc, /* special_function */
230 "R_ARM_THM_CALL", /* name */
231 FALSE, /* partial_inplace */
232 0x07ff07ff, /* src_mask */
233 0x07ff07ff, /* dst_mask */
234 TRUE), /* pcrel_offset */
236 HOWTO (R_ARM_THM_PC8, /* type */
238 1, /* size (0 = byte, 1 = short, 2 = long) */
240 TRUE, /* pc_relative */
242 complain_overflow_signed,/* complain_on_overflow */
243 bfd_elf_generic_reloc, /* special_function */
244 "R_ARM_THM_PC8", /* name */
245 FALSE, /* partial_inplace */
246 0x000000ff, /* src_mask */
247 0x000000ff, /* dst_mask */
248 TRUE), /* pcrel_offset */
250 HOWTO (R_ARM_BREL_ADJ, /* type */
252 1, /* size (0 = byte, 1 = short, 2 = long) */
254 FALSE, /* pc_relative */
256 complain_overflow_signed,/* complain_on_overflow */
257 bfd_elf_generic_reloc, /* special_function */
258 "R_ARM_BREL_ADJ", /* name */
259 FALSE, /* partial_inplace */
260 0xffffffff, /* src_mask */
261 0xffffffff, /* dst_mask */
262 FALSE), /* pcrel_offset */
264 HOWTO (R_ARM_TLS_DESC, /* type */
266 2, /* size (0 = byte, 1 = short, 2 = long) */
268 FALSE, /* pc_relative */
270 complain_overflow_bitfield,/* complain_on_overflow */
271 bfd_elf_generic_reloc, /* special_function */
272 "R_ARM_TLS_DESC", /* name */
273 FALSE, /* partial_inplace */
274 0xffffffff, /* src_mask */
275 0xffffffff, /* dst_mask */
276 FALSE), /* pcrel_offset */
278 HOWTO (R_ARM_THM_SWI8, /* type */
280 0, /* size (0 = byte, 1 = short, 2 = long) */
282 FALSE, /* pc_relative */
284 complain_overflow_signed,/* complain_on_overflow */
285 bfd_elf_generic_reloc, /* special_function */
286 "R_ARM_SWI8", /* name */
287 FALSE, /* partial_inplace */
288 0x00000000, /* src_mask */
289 0x00000000, /* dst_mask */
290 FALSE), /* pcrel_offset */
292 /* BLX instruction for the ARM. */
293 HOWTO (R_ARM_XPC25, /* type */
295 2, /* size (0 = byte, 1 = short, 2 = long) */
297 TRUE, /* pc_relative */
299 complain_overflow_signed,/* complain_on_overflow */
300 bfd_elf_generic_reloc, /* special_function */
301 "R_ARM_XPC25", /* name */
302 FALSE, /* partial_inplace */
303 0x00ffffff, /* src_mask */
304 0x00ffffff, /* dst_mask */
305 TRUE), /* pcrel_offset */
307 /* BLX instruction for the Thumb. */
308 HOWTO (R_ARM_THM_XPC22, /* type */
310 2, /* size (0 = byte, 1 = short, 2 = long) */
312 TRUE, /* pc_relative */
314 complain_overflow_signed,/* complain_on_overflow */
315 bfd_elf_generic_reloc, /* special_function */
316 "R_ARM_THM_XPC22", /* name */
317 FALSE, /* partial_inplace */
318 0x07ff07ff, /* src_mask */
319 0x07ff07ff, /* dst_mask */
320 TRUE), /* pcrel_offset */
322 /* Dynamic TLS relocations. */
324 HOWTO (R_ARM_TLS_DTPMOD32, /* type */
326 2, /* size (0 = byte, 1 = short, 2 = long) */
328 FALSE, /* pc_relative */
330 complain_overflow_bitfield,/* complain_on_overflow */
331 bfd_elf_generic_reloc, /* special_function */
332 "R_ARM_TLS_DTPMOD32", /* name */
333 TRUE, /* partial_inplace */
334 0xffffffff, /* src_mask */
335 0xffffffff, /* dst_mask */
336 FALSE), /* pcrel_offset */
338 HOWTO (R_ARM_TLS_DTPOFF32, /* type */
340 2, /* size (0 = byte, 1 = short, 2 = long) */
342 FALSE, /* pc_relative */
344 complain_overflow_bitfield,/* complain_on_overflow */
345 bfd_elf_generic_reloc, /* special_function */
346 "R_ARM_TLS_DTPOFF32", /* name */
347 TRUE, /* partial_inplace */
348 0xffffffff, /* src_mask */
349 0xffffffff, /* dst_mask */
350 FALSE), /* pcrel_offset */
352 HOWTO (R_ARM_TLS_TPOFF32, /* type */
354 2, /* size (0 = byte, 1 = short, 2 = long) */
356 FALSE, /* pc_relative */
358 complain_overflow_bitfield,/* complain_on_overflow */
359 bfd_elf_generic_reloc, /* special_function */
360 "R_ARM_TLS_TPOFF32", /* name */
361 TRUE, /* partial_inplace */
362 0xffffffff, /* src_mask */
363 0xffffffff, /* dst_mask */
364 FALSE), /* pcrel_offset */
366 /* Relocs used in ARM Linux */
368 HOWTO (R_ARM_COPY, /* type */
370 2, /* size (0 = byte, 1 = short, 2 = long) */
372 FALSE, /* pc_relative */
374 complain_overflow_bitfield,/* complain_on_overflow */
375 bfd_elf_generic_reloc, /* special_function */
376 "R_ARM_COPY", /* name */
377 TRUE, /* partial_inplace */
378 0xffffffff, /* src_mask */
379 0xffffffff, /* dst_mask */
380 FALSE), /* pcrel_offset */
382 HOWTO (R_ARM_GLOB_DAT, /* type */
384 2, /* size (0 = byte, 1 = short, 2 = long) */
386 FALSE, /* pc_relative */
388 complain_overflow_bitfield,/* complain_on_overflow */
389 bfd_elf_generic_reloc, /* special_function */
390 "R_ARM_GLOB_DAT", /* name */
391 TRUE, /* partial_inplace */
392 0xffffffff, /* src_mask */
393 0xffffffff, /* dst_mask */
394 FALSE), /* pcrel_offset */
396 HOWTO (R_ARM_JUMP_SLOT, /* type */
398 2, /* size (0 = byte, 1 = short, 2 = long) */
400 FALSE, /* pc_relative */
402 complain_overflow_bitfield,/* complain_on_overflow */
403 bfd_elf_generic_reloc, /* special_function */
404 "R_ARM_JUMP_SLOT", /* name */
405 TRUE, /* partial_inplace */
406 0xffffffff, /* src_mask */
407 0xffffffff, /* dst_mask */
408 FALSE), /* pcrel_offset */
410 HOWTO (R_ARM_RELATIVE, /* type */
412 2, /* size (0 = byte, 1 = short, 2 = long) */
414 FALSE, /* pc_relative */
416 complain_overflow_bitfield,/* complain_on_overflow */
417 bfd_elf_generic_reloc, /* special_function */
418 "R_ARM_RELATIVE", /* name */
419 TRUE, /* partial_inplace */
420 0xffffffff, /* src_mask */
421 0xffffffff, /* dst_mask */
422 FALSE), /* pcrel_offset */
424 HOWTO (R_ARM_GOTOFF32, /* type */
426 2, /* size (0 = byte, 1 = short, 2 = long) */
428 FALSE, /* pc_relative */
430 complain_overflow_bitfield,/* complain_on_overflow */
431 bfd_elf_generic_reloc, /* special_function */
432 "R_ARM_GOTOFF32", /* name */
433 TRUE, /* partial_inplace */
434 0xffffffff, /* src_mask */
435 0xffffffff, /* dst_mask */
436 FALSE), /* pcrel_offset */
438 HOWTO (R_ARM_GOTPC, /* type */
440 2, /* size (0 = byte, 1 = short, 2 = long) */
442 TRUE, /* pc_relative */
444 complain_overflow_bitfield,/* complain_on_overflow */
445 bfd_elf_generic_reloc, /* special_function */
446 "R_ARM_GOTPC", /* name */
447 TRUE, /* partial_inplace */
448 0xffffffff, /* src_mask */
449 0xffffffff, /* dst_mask */
450 TRUE), /* pcrel_offset */
452 HOWTO (R_ARM_GOT32, /* type */
454 2, /* size (0 = byte, 1 = short, 2 = long) */
456 FALSE, /* pc_relative */
458 complain_overflow_bitfield,/* complain_on_overflow */
459 bfd_elf_generic_reloc, /* special_function */
460 "R_ARM_GOT32", /* name */
461 TRUE, /* partial_inplace */
462 0xffffffff, /* src_mask */
463 0xffffffff, /* dst_mask */
464 FALSE), /* pcrel_offset */
466 HOWTO (R_ARM_PLT32, /* type */
468 2, /* size (0 = byte, 1 = short, 2 = long) */
470 TRUE, /* pc_relative */
472 complain_overflow_bitfield,/* complain_on_overflow */
473 bfd_elf_generic_reloc, /* special_function */
474 "R_ARM_PLT32", /* name */
475 FALSE, /* partial_inplace */
476 0x00ffffff, /* src_mask */
477 0x00ffffff, /* dst_mask */
478 TRUE), /* pcrel_offset */
480 HOWTO (R_ARM_CALL, /* type */
482 2, /* size (0 = byte, 1 = short, 2 = long) */
484 TRUE, /* pc_relative */
486 complain_overflow_signed,/* complain_on_overflow */
487 bfd_elf_generic_reloc, /* special_function */
488 "R_ARM_CALL", /* name */
489 FALSE, /* partial_inplace */
490 0x00ffffff, /* src_mask */
491 0x00ffffff, /* dst_mask */
492 TRUE), /* pcrel_offset */
494 HOWTO (R_ARM_JUMP24, /* type */
496 2, /* size (0 = byte, 1 = short, 2 = long) */
498 TRUE, /* pc_relative */
500 complain_overflow_signed,/* complain_on_overflow */
501 bfd_elf_generic_reloc, /* special_function */
502 "R_ARM_JUMP24", /* name */
503 FALSE, /* partial_inplace */
504 0x00ffffff, /* src_mask */
505 0x00ffffff, /* dst_mask */
506 TRUE), /* pcrel_offset */
508 HOWTO (R_ARM_THM_JUMP24, /* type */
510 2, /* size (0 = byte, 1 = short, 2 = long) */
512 TRUE, /* pc_relative */
514 complain_overflow_signed,/* complain_on_overflow */
515 bfd_elf_generic_reloc, /* special_function */
516 "R_ARM_THM_JUMP24", /* name */
517 FALSE, /* partial_inplace */
518 0x07ff2fff, /* src_mask */
519 0x07ff2fff, /* dst_mask */
520 TRUE), /* pcrel_offset */
522 HOWTO (R_ARM_BASE_ABS, /* type */
524 2, /* size (0 = byte, 1 = short, 2 = long) */
526 FALSE, /* pc_relative */
528 complain_overflow_dont,/* complain_on_overflow */
529 bfd_elf_generic_reloc, /* special_function */
530 "R_ARM_BASE_ABS", /* name */
531 FALSE, /* partial_inplace */
532 0xffffffff, /* src_mask */
533 0xffffffff, /* dst_mask */
534 FALSE), /* pcrel_offset */
536 HOWTO (R_ARM_ALU_PCREL7_0, /* type */
538 2, /* size (0 = byte, 1 = short, 2 = long) */
540 TRUE, /* pc_relative */
542 complain_overflow_dont,/* complain_on_overflow */
543 bfd_elf_generic_reloc, /* special_function */
544 "R_ARM_ALU_PCREL_7_0", /* name */
545 FALSE, /* partial_inplace */
546 0x00000fff, /* src_mask */
547 0x00000fff, /* dst_mask */
548 TRUE), /* pcrel_offset */
550 HOWTO (R_ARM_ALU_PCREL15_8, /* type */
552 2, /* size (0 = byte, 1 = short, 2 = long) */
554 TRUE, /* pc_relative */
556 complain_overflow_dont,/* complain_on_overflow */
557 bfd_elf_generic_reloc, /* special_function */
558 "R_ARM_ALU_PCREL_15_8",/* name */
559 FALSE, /* partial_inplace */
560 0x00000fff, /* src_mask */
561 0x00000fff, /* dst_mask */
562 TRUE), /* pcrel_offset */
564 HOWTO (R_ARM_ALU_PCREL23_15, /* type */
566 2, /* size (0 = byte, 1 = short, 2 = long) */
568 TRUE, /* pc_relative */
570 complain_overflow_dont,/* complain_on_overflow */
571 bfd_elf_generic_reloc, /* special_function */
572 "R_ARM_ALU_PCREL_23_15",/* name */
573 FALSE, /* partial_inplace */
574 0x00000fff, /* src_mask */
575 0x00000fff, /* dst_mask */
576 TRUE), /* pcrel_offset */
578 HOWTO (R_ARM_LDR_SBREL_11_0, /* type */
580 2, /* size (0 = byte, 1 = short, 2 = long) */
582 FALSE, /* pc_relative */
584 complain_overflow_dont,/* complain_on_overflow */
585 bfd_elf_generic_reloc, /* special_function */
586 "R_ARM_LDR_SBREL_11_0",/* name */
587 FALSE, /* partial_inplace */
588 0x00000fff, /* src_mask */
589 0x00000fff, /* dst_mask */
590 FALSE), /* pcrel_offset */
592 HOWTO (R_ARM_ALU_SBREL_19_12, /* type */
594 2, /* size (0 = byte, 1 = short, 2 = long) */
596 FALSE, /* pc_relative */
598 complain_overflow_dont,/* complain_on_overflow */
599 bfd_elf_generic_reloc, /* special_function */
600 "R_ARM_ALU_SBREL_19_12",/* name */
601 FALSE, /* partial_inplace */
602 0x000ff000, /* src_mask */
603 0x000ff000, /* dst_mask */
604 FALSE), /* pcrel_offset */
606 HOWTO (R_ARM_ALU_SBREL_27_20, /* type */
608 2, /* size (0 = byte, 1 = short, 2 = long) */
610 FALSE, /* pc_relative */
612 complain_overflow_dont,/* complain_on_overflow */
613 bfd_elf_generic_reloc, /* special_function */
614 "R_ARM_ALU_SBREL_27_20",/* name */
615 FALSE, /* partial_inplace */
616 0x0ff00000, /* src_mask */
617 0x0ff00000, /* dst_mask */
618 FALSE), /* pcrel_offset */
620 HOWTO (R_ARM_TARGET1, /* type */
622 2, /* size (0 = byte, 1 = short, 2 = long) */
624 FALSE, /* pc_relative */
626 complain_overflow_dont,/* complain_on_overflow */
627 bfd_elf_generic_reloc, /* special_function */
628 "R_ARM_TARGET1", /* name */
629 FALSE, /* partial_inplace */
630 0xffffffff, /* src_mask */
631 0xffffffff, /* dst_mask */
632 FALSE), /* pcrel_offset */
634 HOWTO (R_ARM_ROSEGREL32, /* type */
636 2, /* size (0 = byte, 1 = short, 2 = long) */
638 FALSE, /* pc_relative */
640 complain_overflow_dont,/* complain_on_overflow */
641 bfd_elf_generic_reloc, /* special_function */
642 "R_ARM_ROSEGREL32", /* name */
643 FALSE, /* partial_inplace */
644 0xffffffff, /* src_mask */
645 0xffffffff, /* dst_mask */
646 FALSE), /* pcrel_offset */
648 HOWTO (R_ARM_V4BX, /* type */
650 2, /* size (0 = byte, 1 = short, 2 = long) */
652 FALSE, /* pc_relative */
654 complain_overflow_dont,/* complain_on_overflow */
655 bfd_elf_generic_reloc, /* special_function */
656 "R_ARM_V4BX", /* name */
657 FALSE, /* partial_inplace */
658 0xffffffff, /* src_mask */
659 0xffffffff, /* dst_mask */
660 FALSE), /* pcrel_offset */
662 HOWTO (R_ARM_TARGET2, /* type */
664 2, /* size (0 = byte, 1 = short, 2 = long) */
666 FALSE, /* pc_relative */
668 complain_overflow_signed,/* complain_on_overflow */
669 bfd_elf_generic_reloc, /* special_function */
670 "R_ARM_TARGET2", /* name */
671 FALSE, /* partial_inplace */
672 0xffffffff, /* src_mask */
673 0xffffffff, /* dst_mask */
674 TRUE), /* pcrel_offset */
676 HOWTO (R_ARM_PREL31, /* type */
678 2, /* size (0 = byte, 1 = short, 2 = long) */
680 TRUE, /* pc_relative */
682 complain_overflow_signed,/* complain_on_overflow */
683 bfd_elf_generic_reloc, /* special_function */
684 "R_ARM_PREL31", /* name */
685 FALSE, /* partial_inplace */
686 0x7fffffff, /* src_mask */
687 0x7fffffff, /* dst_mask */
688 TRUE), /* pcrel_offset */
690 HOWTO (R_ARM_MOVW_ABS_NC, /* type */
692 2, /* size (0 = byte, 1 = short, 2 = long) */
694 FALSE, /* pc_relative */
696 complain_overflow_dont,/* complain_on_overflow */
697 bfd_elf_generic_reloc, /* special_function */
698 "R_ARM_MOVW_ABS_NC", /* name */
699 FALSE, /* partial_inplace */
700 0x000f0fff, /* src_mask */
701 0x000f0fff, /* dst_mask */
702 FALSE), /* pcrel_offset */
704 HOWTO (R_ARM_MOVT_ABS, /* type */
706 2, /* size (0 = byte, 1 = short, 2 = long) */
708 FALSE, /* pc_relative */
710 complain_overflow_bitfield,/* complain_on_overflow */
711 bfd_elf_generic_reloc, /* special_function */
712 "R_ARM_MOVT_ABS", /* name */
713 FALSE, /* partial_inplace */
714 0x000f0fff, /* src_mask */
715 0x000f0fff, /* dst_mask */
716 FALSE), /* pcrel_offset */
718 HOWTO (R_ARM_MOVW_PREL_NC, /* type */
720 2, /* size (0 = byte, 1 = short, 2 = long) */
722 TRUE, /* pc_relative */
724 complain_overflow_dont,/* complain_on_overflow */
725 bfd_elf_generic_reloc, /* special_function */
726 "R_ARM_MOVW_PREL_NC", /* name */
727 FALSE, /* partial_inplace */
728 0x000f0fff, /* src_mask */
729 0x000f0fff, /* dst_mask */
730 TRUE), /* pcrel_offset */
732 HOWTO (R_ARM_MOVT_PREL, /* type */
734 2, /* size (0 = byte, 1 = short, 2 = long) */
736 TRUE, /* pc_relative */
738 complain_overflow_bitfield,/* complain_on_overflow */
739 bfd_elf_generic_reloc, /* special_function */
740 "R_ARM_MOVT_PREL", /* name */
741 FALSE, /* partial_inplace */
742 0x000f0fff, /* src_mask */
743 0x000f0fff, /* dst_mask */
744 TRUE), /* pcrel_offset */
746 HOWTO (R_ARM_THM_MOVW_ABS_NC, /* type */
748 2, /* size (0 = byte, 1 = short, 2 = long) */
750 FALSE, /* pc_relative */
752 complain_overflow_dont,/* complain_on_overflow */
753 bfd_elf_generic_reloc, /* special_function */
754 "R_ARM_THM_MOVW_ABS_NC",/* name */
755 FALSE, /* partial_inplace */
756 0x040f70ff, /* src_mask */
757 0x040f70ff, /* dst_mask */
758 FALSE), /* pcrel_offset */
760 HOWTO (R_ARM_THM_MOVT_ABS, /* type */
762 2, /* size (0 = byte, 1 = short, 2 = long) */
764 FALSE, /* pc_relative */
766 complain_overflow_bitfield,/* complain_on_overflow */
767 bfd_elf_generic_reloc, /* special_function */
768 "R_ARM_THM_MOVT_ABS", /* name */
769 FALSE, /* partial_inplace */
770 0x040f70ff, /* src_mask */
771 0x040f70ff, /* dst_mask */
772 FALSE), /* pcrel_offset */
774 HOWTO (R_ARM_THM_MOVW_PREL_NC,/* type */
776 2, /* size (0 = byte, 1 = short, 2 = long) */
778 TRUE, /* pc_relative */
780 complain_overflow_dont,/* complain_on_overflow */
781 bfd_elf_generic_reloc, /* special_function */
782 "R_ARM_THM_MOVW_PREL_NC",/* name */
783 FALSE, /* partial_inplace */
784 0x040f70ff, /* src_mask */
785 0x040f70ff, /* dst_mask */
786 TRUE), /* pcrel_offset */
788 HOWTO (R_ARM_THM_MOVT_PREL, /* type */
790 2, /* size (0 = byte, 1 = short, 2 = long) */
792 TRUE, /* pc_relative */
794 complain_overflow_bitfield,/* complain_on_overflow */
795 bfd_elf_generic_reloc, /* special_function */
796 "R_ARM_THM_MOVT_PREL", /* name */
797 FALSE, /* partial_inplace */
798 0x040f70ff, /* src_mask */
799 0x040f70ff, /* dst_mask */
800 TRUE), /* pcrel_offset */
802 HOWTO (R_ARM_THM_JUMP19, /* type */
804 2, /* size (0 = byte, 1 = short, 2 = long) */
806 TRUE, /* pc_relative */
808 complain_overflow_signed,/* complain_on_overflow */
809 bfd_elf_generic_reloc, /* special_function */
810 "R_ARM_THM_JUMP19", /* name */
811 FALSE, /* partial_inplace */
812 0x043f2fff, /* src_mask */
813 0x043f2fff, /* dst_mask */
814 TRUE), /* pcrel_offset */
816 HOWTO (R_ARM_THM_JUMP6, /* type */
818 1, /* size (0 = byte, 1 = short, 2 = long) */
820 TRUE, /* pc_relative */
822 complain_overflow_unsigned,/* complain_on_overflow */
823 bfd_elf_generic_reloc, /* special_function */
824 "R_ARM_THM_JUMP6", /* name */
825 FALSE, /* partial_inplace */
826 0x02f8, /* src_mask */
827 0x02f8, /* dst_mask */
828 TRUE), /* pcrel_offset */
830 /* These are declared as 13-bit signed relocations because we can
831 address -4095 .. 4095(base) by altering ADDW to SUBW or vice
833 HOWTO (R_ARM_THM_ALU_PREL_11_0,/* type */
835 2, /* size (0 = byte, 1 = short, 2 = long) */
837 TRUE, /* pc_relative */
839 complain_overflow_dont,/* complain_on_overflow */
840 bfd_elf_generic_reloc, /* special_function */
841 "R_ARM_THM_ALU_PREL_11_0",/* name */
842 FALSE, /* partial_inplace */
843 0xffffffff, /* src_mask */
844 0xffffffff, /* dst_mask */
845 TRUE), /* pcrel_offset */
847 HOWTO (R_ARM_THM_PC12, /* type */
849 2, /* size (0 = byte, 1 = short, 2 = long) */
851 TRUE, /* pc_relative */
853 complain_overflow_dont,/* complain_on_overflow */
854 bfd_elf_generic_reloc, /* special_function */
855 "R_ARM_THM_PC12", /* name */
856 FALSE, /* partial_inplace */
857 0xffffffff, /* src_mask */
858 0xffffffff, /* dst_mask */
859 TRUE), /* pcrel_offset */
861 HOWTO (R_ARM_ABS32_NOI, /* type */
863 2, /* size (0 = byte, 1 = short, 2 = long) */
865 FALSE, /* pc_relative */
867 complain_overflow_dont,/* complain_on_overflow */
868 bfd_elf_generic_reloc, /* special_function */
869 "R_ARM_ABS32_NOI", /* name */
870 FALSE, /* partial_inplace */
871 0xffffffff, /* src_mask */
872 0xffffffff, /* dst_mask */
873 FALSE), /* pcrel_offset */
875 HOWTO (R_ARM_REL32_NOI, /* type */
877 2, /* size (0 = byte, 1 = short, 2 = long) */
879 TRUE, /* pc_relative */
881 complain_overflow_dont,/* complain_on_overflow */
882 bfd_elf_generic_reloc, /* special_function */
883 "R_ARM_REL32_NOI", /* name */
884 FALSE, /* partial_inplace */
885 0xffffffff, /* src_mask */
886 0xffffffff, /* dst_mask */
887 FALSE), /* pcrel_offset */
889 /* Group relocations. */
891 HOWTO (R_ARM_ALU_PC_G0_NC, /* type */
893 2, /* size (0 = byte, 1 = short, 2 = long) */
895 TRUE, /* pc_relative */
897 complain_overflow_dont,/* complain_on_overflow */
898 bfd_elf_generic_reloc, /* special_function */
899 "R_ARM_ALU_PC_G0_NC", /* name */
900 FALSE, /* partial_inplace */
901 0xffffffff, /* src_mask */
902 0xffffffff, /* dst_mask */
903 TRUE), /* pcrel_offset */
905 HOWTO (R_ARM_ALU_PC_G0, /* type */
907 2, /* size (0 = byte, 1 = short, 2 = long) */
909 TRUE, /* pc_relative */
911 complain_overflow_dont,/* complain_on_overflow */
912 bfd_elf_generic_reloc, /* special_function */
913 "R_ARM_ALU_PC_G0", /* name */
914 FALSE, /* partial_inplace */
915 0xffffffff, /* src_mask */
916 0xffffffff, /* dst_mask */
917 TRUE), /* pcrel_offset */
919 HOWTO (R_ARM_ALU_PC_G1_NC, /* type */
921 2, /* size (0 = byte, 1 = short, 2 = long) */
923 TRUE, /* pc_relative */
925 complain_overflow_dont,/* complain_on_overflow */
926 bfd_elf_generic_reloc, /* special_function */
927 "R_ARM_ALU_PC_G1_NC", /* name */
928 FALSE, /* partial_inplace */
929 0xffffffff, /* src_mask */
930 0xffffffff, /* dst_mask */
931 TRUE), /* pcrel_offset */
933 HOWTO (R_ARM_ALU_PC_G1, /* type */
935 2, /* size (0 = byte, 1 = short, 2 = long) */
937 TRUE, /* pc_relative */
939 complain_overflow_dont,/* complain_on_overflow */
940 bfd_elf_generic_reloc, /* special_function */
941 "R_ARM_ALU_PC_G1", /* name */
942 FALSE, /* partial_inplace */
943 0xffffffff, /* src_mask */
944 0xffffffff, /* dst_mask */
945 TRUE), /* pcrel_offset */
947 HOWTO (R_ARM_ALU_PC_G2, /* type */
949 2, /* size (0 = byte, 1 = short, 2 = long) */
951 TRUE, /* pc_relative */
953 complain_overflow_dont,/* complain_on_overflow */
954 bfd_elf_generic_reloc, /* special_function */
955 "R_ARM_ALU_PC_G2", /* name */
956 FALSE, /* partial_inplace */
957 0xffffffff, /* src_mask */
958 0xffffffff, /* dst_mask */
959 TRUE), /* pcrel_offset */
961 HOWTO (R_ARM_LDR_PC_G1, /* type */
963 2, /* size (0 = byte, 1 = short, 2 = long) */
965 TRUE, /* pc_relative */
967 complain_overflow_dont,/* complain_on_overflow */
968 bfd_elf_generic_reloc, /* special_function */
969 "R_ARM_LDR_PC_G1", /* name */
970 FALSE, /* partial_inplace */
971 0xffffffff, /* src_mask */
972 0xffffffff, /* dst_mask */
973 TRUE), /* pcrel_offset */
975 HOWTO (R_ARM_LDR_PC_G2, /* type */
977 2, /* size (0 = byte, 1 = short, 2 = long) */
979 TRUE, /* pc_relative */
981 complain_overflow_dont,/* complain_on_overflow */
982 bfd_elf_generic_reloc, /* special_function */
983 "R_ARM_LDR_PC_G2", /* name */
984 FALSE, /* partial_inplace */
985 0xffffffff, /* src_mask */
986 0xffffffff, /* dst_mask */
987 TRUE), /* pcrel_offset */
989 HOWTO (R_ARM_LDRS_PC_G0, /* type */
991 2, /* size (0 = byte, 1 = short, 2 = long) */
993 TRUE, /* pc_relative */
995 complain_overflow_dont,/* complain_on_overflow */
996 bfd_elf_generic_reloc, /* special_function */
997 "R_ARM_LDRS_PC_G0", /* name */
998 FALSE, /* partial_inplace */
999 0xffffffff, /* src_mask */
1000 0xffffffff, /* dst_mask */
1001 TRUE), /* pcrel_offset */
1003 HOWTO (R_ARM_LDRS_PC_G1, /* type */
1005 2, /* size (0 = byte, 1 = short, 2 = long) */
1007 TRUE, /* pc_relative */
1009 complain_overflow_dont,/* complain_on_overflow */
1010 bfd_elf_generic_reloc, /* special_function */
1011 "R_ARM_LDRS_PC_G1", /* name */
1012 FALSE, /* partial_inplace */
1013 0xffffffff, /* src_mask */
1014 0xffffffff, /* dst_mask */
1015 TRUE), /* pcrel_offset */
1017 HOWTO (R_ARM_LDRS_PC_G2, /* type */
1019 2, /* size (0 = byte, 1 = short, 2 = long) */
1021 TRUE, /* pc_relative */
1023 complain_overflow_dont,/* complain_on_overflow */
1024 bfd_elf_generic_reloc, /* special_function */
1025 "R_ARM_LDRS_PC_G2", /* name */
1026 FALSE, /* partial_inplace */
1027 0xffffffff, /* src_mask */
1028 0xffffffff, /* dst_mask */
1029 TRUE), /* pcrel_offset */
1031 HOWTO (R_ARM_LDC_PC_G0, /* type */
1033 2, /* size (0 = byte, 1 = short, 2 = long) */
1035 TRUE, /* pc_relative */
1037 complain_overflow_dont,/* complain_on_overflow */
1038 bfd_elf_generic_reloc, /* special_function */
1039 "R_ARM_LDC_PC_G0", /* name */
1040 FALSE, /* partial_inplace */
1041 0xffffffff, /* src_mask */
1042 0xffffffff, /* dst_mask */
1043 TRUE), /* pcrel_offset */
1045 HOWTO (R_ARM_LDC_PC_G1, /* type */
1047 2, /* size (0 = byte, 1 = short, 2 = long) */
1049 TRUE, /* pc_relative */
1051 complain_overflow_dont,/* complain_on_overflow */
1052 bfd_elf_generic_reloc, /* special_function */
1053 "R_ARM_LDC_PC_G1", /* name */
1054 FALSE, /* partial_inplace */
1055 0xffffffff, /* src_mask */
1056 0xffffffff, /* dst_mask */
1057 TRUE), /* pcrel_offset */
1059 HOWTO (R_ARM_LDC_PC_G2, /* type */
1061 2, /* size (0 = byte, 1 = short, 2 = long) */
1063 TRUE, /* pc_relative */
1065 complain_overflow_dont,/* complain_on_overflow */
1066 bfd_elf_generic_reloc, /* special_function */
1067 "R_ARM_LDC_PC_G2", /* name */
1068 FALSE, /* partial_inplace */
1069 0xffffffff, /* src_mask */
1070 0xffffffff, /* dst_mask */
1071 TRUE), /* pcrel_offset */
1073 HOWTO (R_ARM_ALU_SB_G0_NC, /* type */
1075 2, /* size (0 = byte, 1 = short, 2 = long) */
1077 TRUE, /* pc_relative */
1079 complain_overflow_dont,/* complain_on_overflow */
1080 bfd_elf_generic_reloc, /* special_function */
1081 "R_ARM_ALU_SB_G0_NC", /* name */
1082 FALSE, /* partial_inplace */
1083 0xffffffff, /* src_mask */
1084 0xffffffff, /* dst_mask */
1085 TRUE), /* pcrel_offset */
1087 HOWTO (R_ARM_ALU_SB_G0, /* type */
1089 2, /* size (0 = byte, 1 = short, 2 = long) */
1091 TRUE, /* pc_relative */
1093 complain_overflow_dont,/* complain_on_overflow */
1094 bfd_elf_generic_reloc, /* special_function */
1095 "R_ARM_ALU_SB_G0", /* name */
1096 FALSE, /* partial_inplace */
1097 0xffffffff, /* src_mask */
1098 0xffffffff, /* dst_mask */
1099 TRUE), /* pcrel_offset */
1101 HOWTO (R_ARM_ALU_SB_G1_NC, /* type */
1103 2, /* size (0 = byte, 1 = short, 2 = long) */
1105 TRUE, /* pc_relative */
1107 complain_overflow_dont,/* complain_on_overflow */
1108 bfd_elf_generic_reloc, /* special_function */
1109 "R_ARM_ALU_SB_G1_NC", /* name */
1110 FALSE, /* partial_inplace */
1111 0xffffffff, /* src_mask */
1112 0xffffffff, /* dst_mask */
1113 TRUE), /* pcrel_offset */
1115 HOWTO (R_ARM_ALU_SB_G1, /* type */
1117 2, /* size (0 = byte, 1 = short, 2 = long) */
1119 TRUE, /* pc_relative */
1121 complain_overflow_dont,/* complain_on_overflow */
1122 bfd_elf_generic_reloc, /* special_function */
1123 "R_ARM_ALU_SB_G1", /* name */
1124 FALSE, /* partial_inplace */
1125 0xffffffff, /* src_mask */
1126 0xffffffff, /* dst_mask */
1127 TRUE), /* pcrel_offset */
1129 HOWTO (R_ARM_ALU_SB_G2, /* type */
1131 2, /* size (0 = byte, 1 = short, 2 = long) */
1133 TRUE, /* pc_relative */
1135 complain_overflow_dont,/* complain_on_overflow */
1136 bfd_elf_generic_reloc, /* special_function */
1137 "R_ARM_ALU_SB_G2", /* name */
1138 FALSE, /* partial_inplace */
1139 0xffffffff, /* src_mask */
1140 0xffffffff, /* dst_mask */
1141 TRUE), /* pcrel_offset */
1143 HOWTO (R_ARM_LDR_SB_G0, /* type */
1145 2, /* size (0 = byte, 1 = short, 2 = long) */
1147 TRUE, /* pc_relative */
1149 complain_overflow_dont,/* complain_on_overflow */
1150 bfd_elf_generic_reloc, /* special_function */
1151 "R_ARM_LDR_SB_G0", /* name */
1152 FALSE, /* partial_inplace */
1153 0xffffffff, /* src_mask */
1154 0xffffffff, /* dst_mask */
1155 TRUE), /* pcrel_offset */
1157 HOWTO (R_ARM_LDR_SB_G1, /* type */
1159 2, /* size (0 = byte, 1 = short, 2 = long) */
1161 TRUE, /* pc_relative */
1163 complain_overflow_dont,/* complain_on_overflow */
1164 bfd_elf_generic_reloc, /* special_function */
1165 "R_ARM_LDR_SB_G1", /* name */
1166 FALSE, /* partial_inplace */
1167 0xffffffff, /* src_mask */
1168 0xffffffff, /* dst_mask */
1169 TRUE), /* pcrel_offset */
1171 HOWTO (R_ARM_LDR_SB_G2, /* type */
1173 2, /* size (0 = byte, 1 = short, 2 = long) */
1175 TRUE, /* pc_relative */
1177 complain_overflow_dont,/* complain_on_overflow */
1178 bfd_elf_generic_reloc, /* special_function */
1179 "R_ARM_LDR_SB_G2", /* name */
1180 FALSE, /* partial_inplace */
1181 0xffffffff, /* src_mask */
1182 0xffffffff, /* dst_mask */
1183 TRUE), /* pcrel_offset */
1185 HOWTO (R_ARM_LDRS_SB_G0, /* type */
1187 2, /* size (0 = byte, 1 = short, 2 = long) */
1189 TRUE, /* pc_relative */
1191 complain_overflow_dont,/* complain_on_overflow */
1192 bfd_elf_generic_reloc, /* special_function */
1193 "R_ARM_LDRS_SB_G0", /* name */
1194 FALSE, /* partial_inplace */
1195 0xffffffff, /* src_mask */
1196 0xffffffff, /* dst_mask */
1197 TRUE), /* pcrel_offset */
1199 HOWTO (R_ARM_LDRS_SB_G1, /* type */
1201 2, /* size (0 = byte, 1 = short, 2 = long) */
1203 TRUE, /* pc_relative */
1205 complain_overflow_dont,/* complain_on_overflow */
1206 bfd_elf_generic_reloc, /* special_function */
1207 "R_ARM_LDRS_SB_G1", /* name */
1208 FALSE, /* partial_inplace */
1209 0xffffffff, /* src_mask */
1210 0xffffffff, /* dst_mask */
1211 TRUE), /* pcrel_offset */
1213 HOWTO (R_ARM_LDRS_SB_G2, /* type */
1215 2, /* size (0 = byte, 1 = short, 2 = long) */
1217 TRUE, /* pc_relative */
1219 complain_overflow_dont,/* complain_on_overflow */
1220 bfd_elf_generic_reloc, /* special_function */
1221 "R_ARM_LDRS_SB_G2", /* name */
1222 FALSE, /* partial_inplace */
1223 0xffffffff, /* src_mask */
1224 0xffffffff, /* dst_mask */
1225 TRUE), /* pcrel_offset */
1227 HOWTO (R_ARM_LDC_SB_G0, /* type */
1229 2, /* size (0 = byte, 1 = short, 2 = long) */
1231 TRUE, /* pc_relative */
1233 complain_overflow_dont,/* complain_on_overflow */
1234 bfd_elf_generic_reloc, /* special_function */
1235 "R_ARM_LDC_SB_G0", /* name */
1236 FALSE, /* partial_inplace */
1237 0xffffffff, /* src_mask */
1238 0xffffffff, /* dst_mask */
1239 TRUE), /* pcrel_offset */
1241 HOWTO (R_ARM_LDC_SB_G1, /* type */
1243 2, /* size (0 = byte, 1 = short, 2 = long) */
1245 TRUE, /* pc_relative */
1247 complain_overflow_dont,/* complain_on_overflow */
1248 bfd_elf_generic_reloc, /* special_function */
1249 "R_ARM_LDC_SB_G1", /* name */
1250 FALSE, /* partial_inplace */
1251 0xffffffff, /* src_mask */
1252 0xffffffff, /* dst_mask */
1253 TRUE), /* pcrel_offset */
1255 HOWTO (R_ARM_LDC_SB_G2, /* type */
1257 2, /* size (0 = byte, 1 = short, 2 = long) */
1259 TRUE, /* pc_relative */
1261 complain_overflow_dont,/* complain_on_overflow */
1262 bfd_elf_generic_reloc, /* special_function */
1263 "R_ARM_LDC_SB_G2", /* name */
1264 FALSE, /* partial_inplace */
1265 0xffffffff, /* src_mask */
1266 0xffffffff, /* dst_mask */
1267 TRUE), /* pcrel_offset */
1269 /* End of group relocations. */
1271 HOWTO (R_ARM_MOVW_BREL_NC, /* type */
1273 2, /* size (0 = byte, 1 = short, 2 = long) */
1275 FALSE, /* pc_relative */
1277 complain_overflow_dont,/* complain_on_overflow */
1278 bfd_elf_generic_reloc, /* special_function */
1279 "R_ARM_MOVW_BREL_NC", /* name */
1280 FALSE, /* partial_inplace */
1281 0x0000ffff, /* src_mask */
1282 0x0000ffff, /* dst_mask */
1283 FALSE), /* pcrel_offset */
1285 HOWTO (R_ARM_MOVT_BREL, /* type */
1287 2, /* size (0 = byte, 1 = short, 2 = long) */
1289 FALSE, /* pc_relative */
1291 complain_overflow_bitfield,/* complain_on_overflow */
1292 bfd_elf_generic_reloc, /* special_function */
1293 "R_ARM_MOVT_BREL", /* name */
1294 FALSE, /* partial_inplace */
1295 0x0000ffff, /* src_mask */
1296 0x0000ffff, /* dst_mask */
1297 FALSE), /* pcrel_offset */
1299 HOWTO (R_ARM_MOVW_BREL, /* type */
1301 2, /* size (0 = byte, 1 = short, 2 = long) */
1303 FALSE, /* pc_relative */
1305 complain_overflow_dont,/* complain_on_overflow */
1306 bfd_elf_generic_reloc, /* special_function */
1307 "R_ARM_MOVW_BREL", /* name */
1308 FALSE, /* partial_inplace */
1309 0x0000ffff, /* src_mask */
1310 0x0000ffff, /* dst_mask */
1311 FALSE), /* pcrel_offset */
1313 HOWTO (R_ARM_THM_MOVW_BREL_NC,/* type */
1315 2, /* size (0 = byte, 1 = short, 2 = long) */
1317 FALSE, /* pc_relative */
1319 complain_overflow_dont,/* complain_on_overflow */
1320 bfd_elf_generic_reloc, /* special_function */
1321 "R_ARM_THM_MOVW_BREL_NC",/* name */
1322 FALSE, /* partial_inplace */
1323 0x040f70ff, /* src_mask */
1324 0x040f70ff, /* dst_mask */
1325 FALSE), /* pcrel_offset */
1327 HOWTO (R_ARM_THM_MOVT_BREL, /* type */
1329 2, /* size (0 = byte, 1 = short, 2 = long) */
1331 FALSE, /* pc_relative */
1333 complain_overflow_bitfield,/* complain_on_overflow */
1334 bfd_elf_generic_reloc, /* special_function */
1335 "R_ARM_THM_MOVT_BREL", /* name */
1336 FALSE, /* partial_inplace */
1337 0x040f70ff, /* src_mask */
1338 0x040f70ff, /* dst_mask */
1339 FALSE), /* pcrel_offset */
1341 HOWTO (R_ARM_THM_MOVW_BREL, /* type */
1343 2, /* size (0 = byte, 1 = short, 2 = long) */
1345 FALSE, /* pc_relative */
1347 complain_overflow_dont,/* complain_on_overflow */
1348 bfd_elf_generic_reloc, /* special_function */
1349 "R_ARM_THM_MOVW_BREL", /* name */
1350 FALSE, /* partial_inplace */
1351 0x040f70ff, /* src_mask */
1352 0x040f70ff, /* dst_mask */
1353 FALSE), /* pcrel_offset */
1355 HOWTO (R_ARM_TLS_GOTDESC, /* type */
1357 2, /* size (0 = byte, 1 = short, 2 = long) */
1359 FALSE, /* pc_relative */
1361 complain_overflow_bitfield,/* complain_on_overflow */
1362 NULL, /* special_function */
1363 "R_ARM_TLS_GOTDESC", /* name */
1364 TRUE, /* partial_inplace */
1365 0xffffffff, /* src_mask */
1366 0xffffffff, /* dst_mask */
1367 FALSE), /* pcrel_offset */
1369 HOWTO (R_ARM_TLS_CALL, /* type */
1371 2, /* size (0 = byte, 1 = short, 2 = long) */
1373 FALSE, /* pc_relative */
1375 complain_overflow_dont,/* complain_on_overflow */
1376 bfd_elf_generic_reloc, /* special_function */
1377 "R_ARM_TLS_CALL", /* name */
1378 FALSE, /* partial_inplace */
1379 0x00ffffff, /* src_mask */
1380 0x00ffffff, /* dst_mask */
1381 FALSE), /* pcrel_offset */
1383 HOWTO (R_ARM_TLS_DESCSEQ, /* type */
1385 2, /* size (0 = byte, 1 = short, 2 = long) */
1387 FALSE, /* pc_relative */
1389 complain_overflow_bitfield,/* complain_on_overflow */
1390 bfd_elf_generic_reloc, /* special_function */
1391 "R_ARM_TLS_DESCSEQ", /* name */
1392 FALSE, /* partial_inplace */
1393 0x00000000, /* src_mask */
1394 0x00000000, /* dst_mask */
1395 FALSE), /* pcrel_offset */
1397 HOWTO (R_ARM_THM_TLS_CALL, /* type */
1399 2, /* size (0 = byte, 1 = short, 2 = long) */
1401 FALSE, /* pc_relative */
1403 complain_overflow_dont,/* complain_on_overflow */
1404 bfd_elf_generic_reloc, /* special_function */
1405 "R_ARM_THM_TLS_CALL", /* name */
1406 FALSE, /* partial_inplace */
1407 0x07ff07ff, /* src_mask */
1408 0x07ff07ff, /* dst_mask */
1409 FALSE), /* pcrel_offset */
1411 HOWTO (R_ARM_PLT32_ABS, /* type */
1413 2, /* size (0 = byte, 1 = short, 2 = long) */
1415 FALSE, /* pc_relative */
1417 complain_overflow_dont,/* complain_on_overflow */
1418 bfd_elf_generic_reloc, /* special_function */
1419 "R_ARM_PLT32_ABS", /* name */
1420 FALSE, /* partial_inplace */
1421 0xffffffff, /* src_mask */
1422 0xffffffff, /* dst_mask */
1423 FALSE), /* pcrel_offset */
1425 HOWTO (R_ARM_GOT_ABS, /* type */
1427 2, /* size (0 = byte, 1 = short, 2 = long) */
1429 FALSE, /* pc_relative */
1431 complain_overflow_dont,/* complain_on_overflow */
1432 bfd_elf_generic_reloc, /* special_function */
1433 "R_ARM_GOT_ABS", /* name */
1434 FALSE, /* partial_inplace */
1435 0xffffffff, /* src_mask */
1436 0xffffffff, /* dst_mask */
1437 FALSE), /* pcrel_offset */
1439 HOWTO (R_ARM_GOT_PREL, /* type */
1441 2, /* size (0 = byte, 1 = short, 2 = long) */
1443 TRUE, /* pc_relative */
1445 complain_overflow_dont, /* complain_on_overflow */
1446 bfd_elf_generic_reloc, /* special_function */
1447 "R_ARM_GOT_PREL", /* name */
1448 FALSE, /* partial_inplace */
1449 0xffffffff, /* src_mask */
1450 0xffffffff, /* dst_mask */
1451 TRUE), /* pcrel_offset */
1453 HOWTO (R_ARM_GOT_BREL12, /* type */
1455 2, /* size (0 = byte, 1 = short, 2 = long) */
1457 FALSE, /* pc_relative */
1459 complain_overflow_bitfield,/* complain_on_overflow */
1460 bfd_elf_generic_reloc, /* special_function */
1461 "R_ARM_GOT_BREL12", /* name */
1462 FALSE, /* partial_inplace */
1463 0x00000fff, /* src_mask */
1464 0x00000fff, /* dst_mask */
1465 FALSE), /* pcrel_offset */
1467 HOWTO (R_ARM_GOTOFF12, /* type */
1469 2, /* size (0 = byte, 1 = short, 2 = long) */
1471 FALSE, /* pc_relative */
1473 complain_overflow_bitfield,/* complain_on_overflow */
1474 bfd_elf_generic_reloc, /* special_function */
1475 "R_ARM_GOTOFF12", /* name */
1476 FALSE, /* partial_inplace */
1477 0x00000fff, /* src_mask */
1478 0x00000fff, /* dst_mask */
1479 FALSE), /* pcrel_offset */
1481 EMPTY_HOWTO (R_ARM_GOTRELAX), /* reserved for future GOT-load optimizations */
1483 /* GNU extension to record C++ vtable member usage */
1484 HOWTO (R_ARM_GNU_VTENTRY, /* type */
1486 2, /* size (0 = byte, 1 = short, 2 = long) */
1488 FALSE, /* pc_relative */
1490 complain_overflow_dont, /* complain_on_overflow */
1491 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
1492 "R_ARM_GNU_VTENTRY", /* name */
1493 FALSE, /* partial_inplace */
1496 FALSE), /* pcrel_offset */
1498 /* GNU extension to record C++ vtable hierarchy */
1499 HOWTO (R_ARM_GNU_VTINHERIT, /* type */
1501 2, /* size (0 = byte, 1 = short, 2 = long) */
1503 FALSE, /* pc_relative */
1505 complain_overflow_dont, /* complain_on_overflow */
1506 NULL, /* special_function */
1507 "R_ARM_GNU_VTINHERIT", /* name */
1508 FALSE, /* partial_inplace */
1511 FALSE), /* pcrel_offset */
1513 HOWTO (R_ARM_THM_JUMP11, /* type */
1515 1, /* size (0 = byte, 1 = short, 2 = long) */
1517 TRUE, /* pc_relative */
1519 complain_overflow_signed, /* complain_on_overflow */
1520 bfd_elf_generic_reloc, /* special_function */
1521 "R_ARM_THM_JUMP11", /* name */
1522 FALSE, /* partial_inplace */
1523 0x000007ff, /* src_mask */
1524 0x000007ff, /* dst_mask */
1525 TRUE), /* pcrel_offset */
1527 HOWTO (R_ARM_THM_JUMP8, /* type */
1529 1, /* size (0 = byte, 1 = short, 2 = long) */
1531 TRUE, /* pc_relative */
1533 complain_overflow_signed, /* complain_on_overflow */
1534 bfd_elf_generic_reloc, /* special_function */
1535 "R_ARM_THM_JUMP8", /* name */
1536 FALSE, /* partial_inplace */
1537 0x000000ff, /* src_mask */
1538 0x000000ff, /* dst_mask */
1539 TRUE), /* pcrel_offset */
1541 /* TLS relocations */
1542 HOWTO (R_ARM_TLS_GD32, /* type */
1544 2, /* size (0 = byte, 1 = short, 2 = long) */
1546 FALSE, /* pc_relative */
1548 complain_overflow_bitfield,/* complain_on_overflow */
1549 NULL, /* special_function */
1550 "R_ARM_TLS_GD32", /* name */
1551 TRUE, /* partial_inplace */
1552 0xffffffff, /* src_mask */
1553 0xffffffff, /* dst_mask */
1554 FALSE), /* pcrel_offset */
1556 HOWTO (R_ARM_TLS_LDM32, /* type */
1558 2, /* size (0 = byte, 1 = short, 2 = long) */
1560 FALSE, /* pc_relative */
1562 complain_overflow_bitfield,/* complain_on_overflow */
1563 bfd_elf_generic_reloc, /* special_function */
1564 "R_ARM_TLS_LDM32", /* name */
1565 TRUE, /* partial_inplace */
1566 0xffffffff, /* src_mask */
1567 0xffffffff, /* dst_mask */
1568 FALSE), /* pcrel_offset */
1570 HOWTO (R_ARM_TLS_LDO32, /* type */
1572 2, /* size (0 = byte, 1 = short, 2 = long) */
1574 FALSE, /* pc_relative */
1576 complain_overflow_bitfield,/* complain_on_overflow */
1577 bfd_elf_generic_reloc, /* special_function */
1578 "R_ARM_TLS_LDO32", /* name */
1579 TRUE, /* partial_inplace */
1580 0xffffffff, /* src_mask */
1581 0xffffffff, /* dst_mask */
1582 FALSE), /* pcrel_offset */
1584 HOWTO (R_ARM_TLS_IE32, /* type */
1586 2, /* size (0 = byte, 1 = short, 2 = long) */
1588 FALSE, /* pc_relative */
1590 complain_overflow_bitfield,/* complain_on_overflow */
1591 NULL, /* special_function */
1592 "R_ARM_TLS_IE32", /* name */
1593 TRUE, /* partial_inplace */
1594 0xffffffff, /* src_mask */
1595 0xffffffff, /* dst_mask */
1596 FALSE), /* pcrel_offset */
1598 HOWTO (R_ARM_TLS_LE32, /* type */
1600 2, /* size (0 = byte, 1 = short, 2 = long) */
1602 FALSE, /* pc_relative */
1604 complain_overflow_bitfield,/* complain_on_overflow */
1605 bfd_elf_generic_reloc, /* special_function */
1606 "R_ARM_TLS_LE32", /* name */
1607 TRUE, /* partial_inplace */
1608 0xffffffff, /* src_mask */
1609 0xffffffff, /* dst_mask */
1610 FALSE), /* pcrel_offset */
1612 HOWTO (R_ARM_TLS_LDO12, /* type */
1614 2, /* size (0 = byte, 1 = short, 2 = long) */
1616 FALSE, /* pc_relative */
1618 complain_overflow_bitfield,/* complain_on_overflow */
1619 bfd_elf_generic_reloc, /* special_function */
1620 "R_ARM_TLS_LDO12", /* name */
1621 FALSE, /* partial_inplace */
1622 0x00000fff, /* src_mask */
1623 0x00000fff, /* dst_mask */
1624 FALSE), /* pcrel_offset */
1626 HOWTO (R_ARM_TLS_LE12, /* type */
1628 2, /* size (0 = byte, 1 = short, 2 = long) */
1630 FALSE, /* pc_relative */
1632 complain_overflow_bitfield,/* complain_on_overflow */
1633 bfd_elf_generic_reloc, /* special_function */
1634 "R_ARM_TLS_LE12", /* name */
1635 FALSE, /* partial_inplace */
1636 0x00000fff, /* src_mask */
1637 0x00000fff, /* dst_mask */
1638 FALSE), /* pcrel_offset */
1640 HOWTO (R_ARM_TLS_IE12GP, /* type */
1642 2, /* size (0 = byte, 1 = short, 2 = long) */
1644 FALSE, /* pc_relative */
1646 complain_overflow_bitfield,/* complain_on_overflow */
1647 bfd_elf_generic_reloc, /* special_function */
1648 "R_ARM_TLS_IE12GP", /* name */
1649 FALSE, /* partial_inplace */
1650 0x00000fff, /* src_mask */
1651 0x00000fff, /* dst_mask */
1652 FALSE), /* pcrel_offset */
1672 HOWTO (R_ARM_THM_TLS_DESCSEQ, /* type */
1674 1, /* size (0 = byte, 1 = short, 2 = long) */
1676 FALSE, /* pc_relative */
1678 complain_overflow_bitfield,/* complain_on_overflow */
1679 bfd_elf_generic_reloc, /* special_function */
1680 "R_ARM_THM_TLS_DESCSEQ",/* name */
1681 FALSE, /* partial_inplace */
1682 0x00000000, /* src_mask */
1683 0x00000000, /* dst_mask */
1684 FALSE), /* pcrel_offset */
1687 /* 112-127 private relocations
1688 128 R_ARM_ME_TOO, obsolete
1689 129-255 unallocated in AAELF.
1691 249-255 extended, currently unused, relocations: */
1693 static reloc_howto_type elf32_arm_howto_table_2[4] =
1695 HOWTO (R_ARM_RREL32, /* type */
1697 0, /* size (0 = byte, 1 = short, 2 = long) */
1699 FALSE, /* pc_relative */
1701 complain_overflow_dont,/* complain_on_overflow */
1702 bfd_elf_generic_reloc, /* special_function */
1703 "R_ARM_RREL32", /* name */
1704 FALSE, /* partial_inplace */
1707 FALSE), /* pcrel_offset */
1709 HOWTO (R_ARM_RABS32, /* type */
1711 0, /* size (0 = byte, 1 = short, 2 = long) */
1713 FALSE, /* pc_relative */
1715 complain_overflow_dont,/* complain_on_overflow */
1716 bfd_elf_generic_reloc, /* special_function */
1717 "R_ARM_RABS32", /* name */
1718 FALSE, /* partial_inplace */
1721 FALSE), /* pcrel_offset */
1723 HOWTO (R_ARM_RPC24, /* type */
1725 0, /* size (0 = byte, 1 = short, 2 = long) */
1727 FALSE, /* pc_relative */
1729 complain_overflow_dont,/* complain_on_overflow */
1730 bfd_elf_generic_reloc, /* special_function */
1731 "R_ARM_RPC24", /* name */
1732 FALSE, /* partial_inplace */
1735 FALSE), /* pcrel_offset */
1737 HOWTO (R_ARM_RBASE, /* type */
1739 0, /* size (0 = byte, 1 = short, 2 = long) */
1741 FALSE, /* pc_relative */
1743 complain_overflow_dont,/* complain_on_overflow */
1744 bfd_elf_generic_reloc, /* special_function */
1745 "R_ARM_RBASE", /* name */
1746 FALSE, /* partial_inplace */
1749 FALSE) /* pcrel_offset */
1752 static reloc_howto_type *
1753 elf32_arm_howto_from_type (unsigned int r_type)
1755 if (r_type < ARRAY_SIZE (elf32_arm_howto_table_1))
1756 return &elf32_arm_howto_table_1[r_type];
1758 if (r_type >= R_ARM_RREL32
1759 && r_type < R_ARM_RREL32 + ARRAY_SIZE (elf32_arm_howto_table_2))
1760 return &elf32_arm_howto_table_2[r_type - R_ARM_RREL32];
1766 elf32_arm_info_to_howto (bfd * abfd ATTRIBUTE_UNUSED, arelent * bfd_reloc,
1767 Elf_Internal_Rela * elf_reloc)
1769 unsigned int r_type;
1771 r_type = ELF32_R_TYPE (elf_reloc->r_info);
1772 bfd_reloc->howto = elf32_arm_howto_from_type (r_type);
1775 struct elf32_arm_reloc_map
1777 bfd_reloc_code_real_type bfd_reloc_val;
1778 unsigned char elf_reloc_val;
1781 /* All entries in this list must also be present in elf32_arm_howto_table. */
1782 static const struct elf32_arm_reloc_map elf32_arm_reloc_map[] =
1784 {BFD_RELOC_NONE, R_ARM_NONE},
1785 {BFD_RELOC_ARM_PCREL_BRANCH, R_ARM_PC24},
1786 {BFD_RELOC_ARM_PCREL_CALL, R_ARM_CALL},
1787 {BFD_RELOC_ARM_PCREL_JUMP, R_ARM_JUMP24},
1788 {BFD_RELOC_ARM_PCREL_BLX, R_ARM_XPC25},
1789 {BFD_RELOC_THUMB_PCREL_BLX, R_ARM_THM_XPC22},
1790 {BFD_RELOC_32, R_ARM_ABS32},
1791 {BFD_RELOC_32_PCREL, R_ARM_REL32},
1792 {BFD_RELOC_8, R_ARM_ABS8},
1793 {BFD_RELOC_16, R_ARM_ABS16},
1794 {BFD_RELOC_ARM_OFFSET_IMM, R_ARM_ABS12},
1795 {BFD_RELOC_ARM_THUMB_OFFSET, R_ARM_THM_ABS5},
1796 {BFD_RELOC_THUMB_PCREL_BRANCH25, R_ARM_THM_JUMP24},
1797 {BFD_RELOC_THUMB_PCREL_BRANCH23, R_ARM_THM_CALL},
1798 {BFD_RELOC_THUMB_PCREL_BRANCH12, R_ARM_THM_JUMP11},
1799 {BFD_RELOC_THUMB_PCREL_BRANCH20, R_ARM_THM_JUMP19},
1800 {BFD_RELOC_THUMB_PCREL_BRANCH9, R_ARM_THM_JUMP8},
1801 {BFD_RELOC_THUMB_PCREL_BRANCH7, R_ARM_THM_JUMP6},
1802 {BFD_RELOC_ARM_GLOB_DAT, R_ARM_GLOB_DAT},
1803 {BFD_RELOC_ARM_JUMP_SLOT, R_ARM_JUMP_SLOT},
1804 {BFD_RELOC_ARM_RELATIVE, R_ARM_RELATIVE},
1805 {BFD_RELOC_ARM_GOTOFF, R_ARM_GOTOFF32},
1806 {BFD_RELOC_ARM_GOTPC, R_ARM_GOTPC},
1807 {BFD_RELOC_ARM_GOT_PREL, R_ARM_GOT_PREL},
1808 {BFD_RELOC_ARM_GOT32, R_ARM_GOT32},
1809 {BFD_RELOC_ARM_PLT32, R_ARM_PLT32},
1810 {BFD_RELOC_ARM_TARGET1, R_ARM_TARGET1},
1811 {BFD_RELOC_ARM_ROSEGREL32, R_ARM_ROSEGREL32},
1812 {BFD_RELOC_ARM_SBREL32, R_ARM_SBREL32},
1813 {BFD_RELOC_ARM_PREL31, R_ARM_PREL31},
1814 {BFD_RELOC_ARM_TARGET2, R_ARM_TARGET2},
1815 {BFD_RELOC_ARM_PLT32, R_ARM_PLT32},
1816 {BFD_RELOC_ARM_TLS_GOTDESC, R_ARM_TLS_GOTDESC},
1817 {BFD_RELOC_ARM_TLS_CALL, R_ARM_TLS_CALL},
1818 {BFD_RELOC_ARM_THM_TLS_CALL, R_ARM_THM_TLS_CALL},
1819 {BFD_RELOC_ARM_TLS_DESCSEQ, R_ARM_TLS_DESCSEQ},
1820 {BFD_RELOC_ARM_THM_TLS_DESCSEQ, R_ARM_THM_TLS_DESCSEQ},
1821 {BFD_RELOC_ARM_TLS_DESC, R_ARM_TLS_DESC},
1822 {BFD_RELOC_ARM_TLS_GD32, R_ARM_TLS_GD32},
1823 {BFD_RELOC_ARM_TLS_LDO32, R_ARM_TLS_LDO32},
1824 {BFD_RELOC_ARM_TLS_LDM32, R_ARM_TLS_LDM32},
1825 {BFD_RELOC_ARM_TLS_DTPMOD32, R_ARM_TLS_DTPMOD32},
1826 {BFD_RELOC_ARM_TLS_DTPOFF32, R_ARM_TLS_DTPOFF32},
1827 {BFD_RELOC_ARM_TLS_TPOFF32, R_ARM_TLS_TPOFF32},
1828 {BFD_RELOC_ARM_TLS_IE32, R_ARM_TLS_IE32},
1829 {BFD_RELOC_ARM_TLS_LE32, R_ARM_TLS_LE32},
1830 {BFD_RELOC_VTABLE_INHERIT, R_ARM_GNU_VTINHERIT},
1831 {BFD_RELOC_VTABLE_ENTRY, R_ARM_GNU_VTENTRY},
1832 {BFD_RELOC_ARM_MOVW, R_ARM_MOVW_ABS_NC},
1833 {BFD_RELOC_ARM_MOVT, R_ARM_MOVT_ABS},
1834 {BFD_RELOC_ARM_MOVW_PCREL, R_ARM_MOVW_PREL_NC},
1835 {BFD_RELOC_ARM_MOVT_PCREL, R_ARM_MOVT_PREL},
1836 {BFD_RELOC_ARM_THUMB_MOVW, R_ARM_THM_MOVW_ABS_NC},
1837 {BFD_RELOC_ARM_THUMB_MOVT, R_ARM_THM_MOVT_ABS},
1838 {BFD_RELOC_ARM_THUMB_MOVW_PCREL, R_ARM_THM_MOVW_PREL_NC},
1839 {BFD_RELOC_ARM_THUMB_MOVT_PCREL, R_ARM_THM_MOVT_PREL},
1840 {BFD_RELOC_ARM_ALU_PC_G0_NC, R_ARM_ALU_PC_G0_NC},
1841 {BFD_RELOC_ARM_ALU_PC_G0, R_ARM_ALU_PC_G0},
1842 {BFD_RELOC_ARM_ALU_PC_G1_NC, R_ARM_ALU_PC_G1_NC},
1843 {BFD_RELOC_ARM_ALU_PC_G1, R_ARM_ALU_PC_G1},
1844 {BFD_RELOC_ARM_ALU_PC_G2, R_ARM_ALU_PC_G2},
1845 {BFD_RELOC_ARM_LDR_PC_G0, R_ARM_LDR_PC_G0},
1846 {BFD_RELOC_ARM_LDR_PC_G1, R_ARM_LDR_PC_G1},
1847 {BFD_RELOC_ARM_LDR_PC_G2, R_ARM_LDR_PC_G2},
1848 {BFD_RELOC_ARM_LDRS_PC_G0, R_ARM_LDRS_PC_G0},
1849 {BFD_RELOC_ARM_LDRS_PC_G1, R_ARM_LDRS_PC_G1},
1850 {BFD_RELOC_ARM_LDRS_PC_G2, R_ARM_LDRS_PC_G2},
1851 {BFD_RELOC_ARM_LDC_PC_G0, R_ARM_LDC_PC_G0},
1852 {BFD_RELOC_ARM_LDC_PC_G1, R_ARM_LDC_PC_G1},
1853 {BFD_RELOC_ARM_LDC_PC_G2, R_ARM_LDC_PC_G2},
1854 {BFD_RELOC_ARM_ALU_SB_G0_NC, R_ARM_ALU_SB_G0_NC},
1855 {BFD_RELOC_ARM_ALU_SB_G0, R_ARM_ALU_SB_G0},
1856 {BFD_RELOC_ARM_ALU_SB_G1_NC, R_ARM_ALU_SB_G1_NC},
1857 {BFD_RELOC_ARM_ALU_SB_G1, R_ARM_ALU_SB_G1},
1858 {BFD_RELOC_ARM_ALU_SB_G2, R_ARM_ALU_SB_G2},
1859 {BFD_RELOC_ARM_LDR_SB_G0, R_ARM_LDR_SB_G0},
1860 {BFD_RELOC_ARM_LDR_SB_G1, R_ARM_LDR_SB_G1},
1861 {BFD_RELOC_ARM_LDR_SB_G2, R_ARM_LDR_SB_G2},
1862 {BFD_RELOC_ARM_LDRS_SB_G0, R_ARM_LDRS_SB_G0},
1863 {BFD_RELOC_ARM_LDRS_SB_G1, R_ARM_LDRS_SB_G1},
1864 {BFD_RELOC_ARM_LDRS_SB_G2, R_ARM_LDRS_SB_G2},
1865 {BFD_RELOC_ARM_LDC_SB_G0, R_ARM_LDC_SB_G0},
1866 {BFD_RELOC_ARM_LDC_SB_G1, R_ARM_LDC_SB_G1},
1867 {BFD_RELOC_ARM_LDC_SB_G2, R_ARM_LDC_SB_G2},
1868 {BFD_RELOC_ARM_V4BX, R_ARM_V4BX}
1871 static reloc_howto_type *
1872 elf32_arm_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1873 bfd_reloc_code_real_type code)
1877 for (i = 0; i < ARRAY_SIZE (elf32_arm_reloc_map); i ++)
1878 if (elf32_arm_reloc_map[i].bfd_reloc_val == code)
1879 return elf32_arm_howto_from_type (elf32_arm_reloc_map[i].elf_reloc_val);
1884 static reloc_howto_type *
1885 elf32_arm_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1890 for (i = 0; i < ARRAY_SIZE (elf32_arm_howto_table_1); i++)
1891 if (elf32_arm_howto_table_1[i].name != NULL
1892 && strcasecmp (elf32_arm_howto_table_1[i].name, r_name) == 0)
1893 return &elf32_arm_howto_table_1[i];
1895 for (i = 0; i < ARRAY_SIZE (elf32_arm_howto_table_2); i++)
1896 if (elf32_arm_howto_table_2[i].name != NULL
1897 && strcasecmp (elf32_arm_howto_table_2[i].name, r_name) == 0)
1898 return &elf32_arm_howto_table_2[i];
1903 /* Support for core dump NOTE sections. */
1906 elf32_arm_nabi_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
1911 switch (note->descsz)
1916 case 148: /* Linux/ARM 32-bit. */
1918 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
1921 elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 24);
1930 /* Make a ".reg/999" section. */
1931 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
1932 size, note->descpos + offset);
1936 elf32_arm_nabi_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
1938 switch (note->descsz)
1943 case 124: /* Linux/ARM elf_prpsinfo. */
1944 elf_tdata (abfd)->core_program
1945 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
1946 elf_tdata (abfd)->core_command
1947 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
1950 /* Note that for some reason, a spurious space is tacked
1951 onto the end of the args in some (at least one anyway)
1952 implementations, so strip it off if it exists. */
1954 char *command = elf_tdata (abfd)->core_command;
1955 int n = strlen (command);
1957 if (0 < n && command[n - 1] == ' ')
1958 command[n - 1] = '\0';
1964 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_vec
1965 #define TARGET_LITTLE_NAME "elf32-littlearm"
1966 #define TARGET_BIG_SYM bfd_elf32_bigarm_vec
1967 #define TARGET_BIG_NAME "elf32-bigarm"
1969 #define elf_backend_grok_prstatus elf32_arm_nabi_grok_prstatus
1970 #define elf_backend_grok_psinfo elf32_arm_nabi_grok_psinfo
1972 typedef unsigned long int insn32;
1973 typedef unsigned short int insn16;
1975 /* In lieu of proper flags, assume all EABIv4 or later objects are
1977 #define INTERWORK_FLAG(abfd) \
1978 (EF_ARM_EABI_VERSION (elf_elfheader (abfd)->e_flags) >= EF_ARM_EABI_VER4 \
1979 || (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK) \
1980 || ((abfd)->flags & BFD_LINKER_CREATED))
1982 /* The linker script knows the section names for placement.
1983 The entry_names are used to do simple name mangling on the stubs.
1984 Given a function name, and its type, the stub can be found. The
1985 name can be changed. The only requirement is the %s be present. */
1986 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
1987 #define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
1989 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
1990 #define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
1992 #define VFP11_ERRATUM_VENEER_SECTION_NAME ".vfp11_veneer"
1993 #define VFP11_ERRATUM_VENEER_ENTRY_NAME "__vfp11_veneer_%x"
1995 #define ARM_BX_GLUE_SECTION_NAME ".v4_bx"
1996 #define ARM_BX_GLUE_ENTRY_NAME "__bx_r%d"
1998 #define STUB_ENTRY_NAME "__%s_veneer"
2000 /* The name of the dynamic interpreter. This is put in the .interp
2002 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
2004 static const unsigned long tls_trampoline [] =
2006 0xe08e0000, /* add r0, lr, r0 */
2007 0xe5901004, /* ldr r1, [r0,#4] */
2008 0xe12fff11, /* bx r1 */
2011 static const unsigned long dl_tlsdesc_lazy_trampoline [] =
2013 0xe52d2004, /* push {r2} */
2014 0xe59f200c, /* ldr r2, [pc, #3f - . - 8] */
2015 0xe59f100c, /* ldr r1, [pc, #4f - . - 8] */
2016 0xe79f2002, /* 1: ldr r2, [pc, r2] */
2017 0xe081100f, /* 2: add r1, pc */
2018 0xe12fff12, /* bx r2 */
2019 0x00000014, /* 3: .word _GLOBAL_OFFSET_TABLE_ - 1b - 8
2020 + dl_tlsdesc_lazy_resolver(GOT) */
2021 0x00000018, /* 4: .word _GLOBAL_OFFSET_TABLE_ - 2b - 8 */
2024 #ifdef FOUR_WORD_PLT
2026 /* The first entry in a procedure linkage table looks like
2027 this. It is set up so that any shared library function that is
2028 called before the relocation has been set up calls the dynamic
2030 static const bfd_vma elf32_arm_plt0_entry [] =
2032 0xe52de004, /* str lr, [sp, #-4]! */
2033 0xe59fe010, /* ldr lr, [pc, #16] */
2034 0xe08fe00e, /* add lr, pc, lr */
2035 0xe5bef008, /* ldr pc, [lr, #8]! */
2038 /* Subsequent entries in a procedure linkage table look like
2040 static const bfd_vma elf32_arm_plt_entry [] =
2042 0xe28fc600, /* add ip, pc, #NN */
2043 0xe28cca00, /* add ip, ip, #NN */
2044 0xe5bcf000, /* ldr pc, [ip, #NN]! */
2045 0x00000000, /* unused */
2050 /* The first entry in a procedure linkage table looks like
2051 this. It is set up so that any shared library function that is
2052 called before the relocation has been set up calls the dynamic
2054 static const bfd_vma elf32_arm_plt0_entry [] =
2056 0xe52de004, /* str lr, [sp, #-4]! */
2057 0xe59fe004, /* ldr lr, [pc, #4] */
2058 0xe08fe00e, /* add lr, pc, lr */
2059 0xe5bef008, /* ldr pc, [lr, #8]! */
2060 0x00000000, /* &GOT[0] - . */
2063 /* Subsequent entries in a procedure linkage table look like
2065 static const bfd_vma elf32_arm_plt_entry [] =
2067 0xe28fc600, /* add ip, pc, #0xNN00000 */
2068 0xe28cca00, /* add ip, ip, #0xNN000 */
2069 0xe5bcf000, /* ldr pc, [ip, #0xNNN]! */
2074 /* The format of the first entry in the procedure linkage table
2075 for a VxWorks executable. */
2076 static const bfd_vma elf32_arm_vxworks_exec_plt0_entry[] =
2078 0xe52dc008, /* str ip,[sp,#-8]! */
2079 0xe59fc000, /* ldr ip,[pc] */
2080 0xe59cf008, /* ldr pc,[ip,#8] */
2081 0x00000000, /* .long _GLOBAL_OFFSET_TABLE_ */
2084 /* The format of subsequent entries in a VxWorks executable. */
2085 static const bfd_vma elf32_arm_vxworks_exec_plt_entry[] =
2087 0xe59fc000, /* ldr ip,[pc] */
2088 0xe59cf000, /* ldr pc,[ip] */
2089 0x00000000, /* .long @got */
2090 0xe59fc000, /* ldr ip,[pc] */
2091 0xea000000, /* b _PLT */
2092 0x00000000, /* .long @pltindex*sizeof(Elf32_Rela) */
2095 /* The format of entries in a VxWorks shared library. */
2096 static const bfd_vma elf32_arm_vxworks_shared_plt_entry[] =
2098 0xe59fc000, /* ldr ip,[pc] */
2099 0xe79cf009, /* ldr pc,[ip,r9] */
2100 0x00000000, /* .long @got */
2101 0xe59fc000, /* ldr ip,[pc] */
2102 0xe599f008, /* ldr pc,[r9,#8] */
2103 0x00000000, /* .long @pltindex*sizeof(Elf32_Rela) */
2106 /* An initial stub used if the PLT entry is referenced from Thumb code. */
2107 #define PLT_THUMB_STUB_SIZE 4
2108 static const bfd_vma elf32_arm_plt_thumb_stub [] =
2114 /* The entries in a PLT when using a DLL-based target with multiple
2116 static const bfd_vma elf32_arm_symbian_plt_entry [] =
2118 0xe51ff004, /* ldr pc, [pc, #-4] */
2119 0x00000000, /* dcd R_ARM_GLOB_DAT(X) */
2122 #define ARM_MAX_FWD_BRANCH_OFFSET ((((1 << 23) - 1) << 2) + 8)
2123 #define ARM_MAX_BWD_BRANCH_OFFSET ((-((1 << 23) << 2)) + 8)
2124 #define THM_MAX_FWD_BRANCH_OFFSET ((1 << 22) -2 + 4)
2125 #define THM_MAX_BWD_BRANCH_OFFSET (-(1 << 22) + 4)
2126 #define THM2_MAX_FWD_BRANCH_OFFSET (((1 << 24) - 2) + 4)
2127 #define THM2_MAX_BWD_BRANCH_OFFSET (-(1 << 24) + 4)
2137 #define THUMB16_INSN(X) {(X), THUMB16_TYPE, R_ARM_NONE, 0}
2138 /* A bit of a hack. A Thumb conditional branch, in which the proper condition
2139 is inserted in arm_build_one_stub(). */
2140 #define THUMB16_BCOND_INSN(X) {(X), THUMB16_TYPE, R_ARM_NONE, 1}
2141 #define THUMB32_INSN(X) {(X), THUMB32_TYPE, R_ARM_NONE, 0}
2142 #define THUMB32_B_INSN(X, Z) {(X), THUMB32_TYPE, R_ARM_THM_JUMP24, (Z)}
2143 #define ARM_INSN(X) {(X), ARM_TYPE, R_ARM_NONE, 0}
2144 #define ARM_REL_INSN(X, Z) {(X), ARM_TYPE, R_ARM_JUMP24, (Z)}
2145 #define DATA_WORD(X,Y,Z) {(X), DATA_TYPE, (Y), (Z)}
2150 enum stub_insn_type type;
2151 unsigned int r_type;
2155 /* Arm/Thumb -> Arm/Thumb long branch stub. On V5T and above, use blx
2156 to reach the stub if necessary. */
2157 static const insn_sequence elf32_arm_stub_long_branch_any_any[] =
2159 ARM_INSN(0xe51ff004), /* ldr pc, [pc, #-4] */
2160 DATA_WORD(0, R_ARM_ABS32, 0), /* dcd R_ARM_ABS32(X) */
2163 /* V4T Arm -> Thumb long branch stub. Used on V4T where blx is not
2165 static const insn_sequence elf32_arm_stub_long_branch_v4t_arm_thumb[] =
2167 ARM_INSN(0xe59fc000), /* ldr ip, [pc, #0] */
2168 ARM_INSN(0xe12fff1c), /* bx ip */
2169 DATA_WORD(0, R_ARM_ABS32, 0), /* dcd R_ARM_ABS32(X) */
2172 /* Thumb -> Thumb long branch stub. Used on M-profile architectures. */
2173 static const insn_sequence elf32_arm_stub_long_branch_thumb_only[] =
2175 THUMB16_INSN(0xb401), /* push {r0} */
2176 THUMB16_INSN(0x4802), /* ldr r0, [pc, #8] */
2177 THUMB16_INSN(0x4684), /* mov ip, r0 */
2178 THUMB16_INSN(0xbc01), /* pop {r0} */
2179 THUMB16_INSN(0x4760), /* bx ip */
2180 THUMB16_INSN(0xbf00), /* nop */
2181 DATA_WORD(0, R_ARM_ABS32, 0), /* dcd R_ARM_ABS32(X) */
2184 /* V4T Thumb -> Thumb long branch stub. Using the stack is not
2186 static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_thumb[] =
2188 THUMB16_INSN(0x4778), /* bx pc */
2189 THUMB16_INSN(0x46c0), /* nop */
2190 ARM_INSN(0xe59fc000), /* ldr ip, [pc, #0] */
2191 ARM_INSN(0xe12fff1c), /* bx ip */
2192 DATA_WORD(0, R_ARM_ABS32, 0), /* dcd R_ARM_ABS32(X) */
2195 /* V4T Thumb -> ARM long branch stub. Used on V4T where blx is not
2197 static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_arm[] =
2199 THUMB16_INSN(0x4778), /* bx pc */
2200 THUMB16_INSN(0x46c0), /* nop */
2201 ARM_INSN(0xe51ff004), /* ldr pc, [pc, #-4] */
2202 DATA_WORD(0, R_ARM_ABS32, 0), /* dcd R_ARM_ABS32(X) */
2205 /* V4T Thumb -> ARM short branch stub. Shorter variant of the above
2206 one, when the destination is close enough. */
2207 static const insn_sequence elf32_arm_stub_short_branch_v4t_thumb_arm[] =
2209 THUMB16_INSN(0x4778), /* bx pc */
2210 THUMB16_INSN(0x46c0), /* nop */
2211 ARM_REL_INSN(0xea000000, -8), /* b (X-8) */
2214 /* ARM/Thumb -> ARM long branch stub, PIC. On V5T and above, use
2215 blx to reach the stub if necessary. */
2216 static const insn_sequence elf32_arm_stub_long_branch_any_arm_pic[] =
2218 ARM_INSN(0xe59fc000), /* ldr ip, [pc] */
2219 ARM_INSN(0xe08ff00c), /* add pc, pc, ip */
2220 DATA_WORD(0, R_ARM_REL32, -4), /* dcd R_ARM_REL32(X-4) */
2223 /* ARM/Thumb -> Thumb long branch stub, PIC. On V5T and above, use
2224 blx to reach the stub if necessary. We can not add into pc;
2225 it is not guaranteed to mode switch (different in ARMv6 and
2227 static const insn_sequence elf32_arm_stub_long_branch_any_thumb_pic[] =
2229 ARM_INSN(0xe59fc004), /* ldr ip, [pc, #4] */
2230 ARM_INSN(0xe08fc00c), /* add ip, pc, ip */
2231 ARM_INSN(0xe12fff1c), /* bx ip */
2232 DATA_WORD(0, R_ARM_REL32, 0), /* dcd R_ARM_REL32(X) */
2235 /* V4T ARM -> ARM long branch stub, PIC. */
2236 static const insn_sequence elf32_arm_stub_long_branch_v4t_arm_thumb_pic[] =
2238 ARM_INSN(0xe59fc004), /* ldr ip, [pc, #4] */
2239 ARM_INSN(0xe08fc00c), /* add ip, pc, ip */
2240 ARM_INSN(0xe12fff1c), /* bx ip */
2241 DATA_WORD(0, R_ARM_REL32, 0), /* dcd R_ARM_REL32(X) */
2244 /* V4T Thumb -> ARM long branch stub, PIC. */
2245 static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_arm_pic[] =
2247 THUMB16_INSN(0x4778), /* bx pc */
2248 THUMB16_INSN(0x46c0), /* nop */
2249 ARM_INSN(0xe59fc000), /* ldr ip, [pc, #0] */
2250 ARM_INSN(0xe08cf00f), /* add pc, ip, pc */
2251 DATA_WORD(0, R_ARM_REL32, -4), /* dcd R_ARM_REL32(X) */
2254 /* Thumb -> Thumb long branch stub, PIC. Used on M-profile
2256 static const insn_sequence elf32_arm_stub_long_branch_thumb_only_pic[] =
2258 THUMB16_INSN(0xb401), /* push {r0} */
2259 THUMB16_INSN(0x4802), /* ldr r0, [pc, #8] */
2260 THUMB16_INSN(0x46fc), /* mov ip, pc */
2261 THUMB16_INSN(0x4484), /* add ip, r0 */
2262 THUMB16_INSN(0xbc01), /* pop {r0} */
2263 THUMB16_INSN(0x4760), /* bx ip */
2264 DATA_WORD(0, R_ARM_REL32, 4), /* dcd R_ARM_REL32(X) */
2267 /* V4T Thumb -> Thumb long branch stub, PIC. Using the stack is not
2269 static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_thumb_pic[] =
2271 THUMB16_INSN(0x4778), /* bx pc */
2272 THUMB16_INSN(0x46c0), /* nop */
2273 ARM_INSN(0xe59fc004), /* ldr ip, [pc, #4] */
2274 ARM_INSN(0xe08fc00c), /* add ip, pc, ip */
2275 ARM_INSN(0xe12fff1c), /* bx ip */
2276 DATA_WORD(0, R_ARM_REL32, 0), /* dcd R_ARM_REL32(X) */
2279 /* Thumb2/ARM -> TLS trampoline. Lowest common denominator, which is a
2280 long PIC stub. We can use r1 as a scratch -- and cannot use ip. */
2281 static const insn_sequence elf32_arm_stub_long_branch_any_tls_pic[] =
2283 ARM_INSN(0xe59f1000), /* ldr r1, [pc] */
2284 ARM_INSN(0xe08ff001), /* add pc, pc, r1 */
2285 DATA_WORD(0, R_ARM_REL32, -4), /* dcd R_ARM_REL32(X-4) */
2288 /* V4T Thumb -> TLS trampoline. lowest common denominator, which is a
2289 long PIC stub. We can use r1 as a scratch -- and cannot use ip. */
2290 static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_tls_pic[] =
2292 THUMB16_INSN(0x4778), /* bx pc */
2293 THUMB16_INSN(0x46c0), /* nop */
2294 ARM_INSN(0xe59f1000), /* ldr r1, [pc, #0] */
2295 ARM_INSN(0xe081f00f), /* add pc, r1, pc */
2296 DATA_WORD(0, R_ARM_REL32, -4), /* dcd R_ARM_REL32(X) */
2299 /* Cortex-A8 erratum-workaround stubs. */
2301 /* Stub used for conditional branches (which may be beyond +/-1MB away, so we
2302 can't use a conditional branch to reach this stub). */
2304 static const insn_sequence elf32_arm_stub_a8_veneer_b_cond[] =
2306 THUMB16_BCOND_INSN(0xd001), /* b<cond>.n true. */
2307 THUMB32_B_INSN(0xf000b800, -4), /* b.w insn_after_original_branch. */
2308 THUMB32_B_INSN(0xf000b800, -4) /* true: b.w original_branch_dest. */
2311 /* Stub used for b.w and bl.w instructions. */
2313 static const insn_sequence elf32_arm_stub_a8_veneer_b[] =
2315 THUMB32_B_INSN(0xf000b800, -4) /* b.w original_branch_dest. */
2318 static const insn_sequence elf32_arm_stub_a8_veneer_bl[] =
2320 THUMB32_B_INSN(0xf000b800, -4) /* b.w original_branch_dest. */
2323 /* Stub used for Thumb-2 blx.w instructions. We modified the original blx.w
2324 instruction (which switches to ARM mode) to point to this stub. Jump to the
2325 real destination using an ARM-mode branch. */
2327 static const insn_sequence elf32_arm_stub_a8_veneer_blx[] =
2329 ARM_REL_INSN(0xea000000, -8) /* b original_branch_dest. */
2332 /* Section name for stubs is the associated section name plus this
2334 #define STUB_SUFFIX ".stub"
2336 /* One entry per long/short branch stub defined above. */
2338 DEF_STUB(long_branch_any_any) \
2339 DEF_STUB(long_branch_v4t_arm_thumb) \
2340 DEF_STUB(long_branch_thumb_only) \
2341 DEF_STUB(long_branch_v4t_thumb_thumb) \
2342 DEF_STUB(long_branch_v4t_thumb_arm) \
2343 DEF_STUB(short_branch_v4t_thumb_arm) \
2344 DEF_STUB(long_branch_any_arm_pic) \
2345 DEF_STUB(long_branch_any_thumb_pic) \
2346 DEF_STUB(long_branch_v4t_thumb_thumb_pic) \
2347 DEF_STUB(long_branch_v4t_arm_thumb_pic) \
2348 DEF_STUB(long_branch_v4t_thumb_arm_pic) \
2349 DEF_STUB(long_branch_thumb_only_pic) \
2350 DEF_STUB(long_branch_any_tls_pic) \
2351 DEF_STUB(long_branch_v4t_thumb_tls_pic) \
2352 DEF_STUB(a8_veneer_b_cond) \
2353 DEF_STUB(a8_veneer_b) \
2354 DEF_STUB(a8_veneer_bl) \
2355 DEF_STUB(a8_veneer_blx)
2357 #define DEF_STUB(x) arm_stub_##x,
2358 enum elf32_arm_stub_type {
2361 /* Note the first a8_veneer type */
2362 arm_stub_a8_veneer_lwm = arm_stub_a8_veneer_b_cond
2368 const insn_sequence* template_sequence;
2372 #define DEF_STUB(x) {elf32_arm_stub_##x, ARRAY_SIZE(elf32_arm_stub_##x)},
2373 static const stub_def stub_definitions[] = {
2378 struct elf32_arm_stub_hash_entry
2380 /* Base hash table entry structure. */
2381 struct bfd_hash_entry root;
2383 /* The stub section. */
2386 /* Offset within stub_sec of the beginning of this stub. */
2387 bfd_vma stub_offset;
2389 /* Given the symbol's value and its section we can determine its final
2390 value when building the stubs (so the stub knows where to jump). */
2391 bfd_vma target_value;
2392 asection *target_section;
2394 /* Offset to apply to relocation referencing target_value. */
2395 bfd_vma target_addend;
2397 /* The instruction which caused this stub to be generated (only valid for
2398 Cortex-A8 erratum workaround stubs at present). */
2399 unsigned long orig_insn;
2401 /* The stub type. */
2402 enum elf32_arm_stub_type stub_type;
2403 /* Its encoding size in bytes. */
2406 const insn_sequence *stub_template;
2407 /* The size of the template (number of entries). */
2408 int stub_template_size;
2410 /* The symbol table entry, if any, that this was derived from. */
2411 struct elf32_arm_link_hash_entry *h;
2413 /* Destination symbol type (STT_ARM_TFUNC, ...) */
2414 unsigned char st_type;
2416 /* Where this stub is being called from, or, in the case of combined
2417 stub sections, the first input section in the group. */
2420 /* The name for the local symbol at the start of this stub. The
2421 stub name in the hash table has to be unique; this does not, so
2422 it can be friendlier. */
2426 /* Used to build a map of a section. This is required for mixed-endian
2429 typedef struct elf32_elf_section_map
2434 elf32_arm_section_map;
2436 /* Information about a VFP11 erratum veneer, or a branch to such a veneer. */
2440 VFP11_ERRATUM_BRANCH_TO_ARM_VENEER,
2441 VFP11_ERRATUM_BRANCH_TO_THUMB_VENEER,
2442 VFP11_ERRATUM_ARM_VENEER,
2443 VFP11_ERRATUM_THUMB_VENEER
2445 elf32_vfp11_erratum_type;
2447 typedef struct elf32_vfp11_erratum_list
2449 struct elf32_vfp11_erratum_list *next;
2455 struct elf32_vfp11_erratum_list *veneer;
2456 unsigned int vfp_insn;
2460 struct elf32_vfp11_erratum_list *branch;
2464 elf32_vfp11_erratum_type type;
2466 elf32_vfp11_erratum_list;
2471 INSERT_EXIDX_CANTUNWIND_AT_END
2473 arm_unwind_edit_type;
2475 /* A (sorted) list of edits to apply to an unwind table. */
2476 typedef struct arm_unwind_table_edit
2478 arm_unwind_edit_type type;
2479 /* Note: we sometimes want to insert an unwind entry corresponding to a
2480 section different from the one we're currently writing out, so record the
2481 (text) section this edit relates to here. */
2482 asection *linked_section;
2484 struct arm_unwind_table_edit *next;
2486 arm_unwind_table_edit;
2488 typedef struct _arm_elf_section_data
2490 /* Information about mapping symbols. */
2491 struct bfd_elf_section_data elf;
2492 unsigned int mapcount;
2493 unsigned int mapsize;
2494 elf32_arm_section_map *map;
2495 /* Information about CPU errata. */
2496 unsigned int erratumcount;
2497 elf32_vfp11_erratum_list *erratumlist;
2498 /* Information about unwind tables. */
2501 /* Unwind info attached to a text section. */
2504 asection *arm_exidx_sec;
2507 /* Unwind info attached to an .ARM.exidx section. */
2510 arm_unwind_table_edit *unwind_edit_list;
2511 arm_unwind_table_edit *unwind_edit_tail;
2515 _arm_elf_section_data;
2517 #define elf32_arm_section_data(sec) \
2518 ((_arm_elf_section_data *) elf_section_data (sec))
2520 /* A fix which might be required for Cortex-A8 Thumb-2 branch/TLB erratum.
2521 These fixes are subject to a relaxation procedure (in elf32_arm_size_stubs),
2522 so may be created multiple times: we use an array of these entries whilst
2523 relaxing which we can refresh easily, then create stubs for each potentially
2524 erratum-triggering instruction once we've settled on a solution. */
2526 struct a8_erratum_fix {
2531 unsigned long orig_insn;
2533 enum elf32_arm_stub_type stub_type;
2537 /* A table of relocs applied to branches which might trigger Cortex-A8
2540 struct a8_erratum_reloc {
2542 bfd_vma destination;
2543 struct elf32_arm_link_hash_entry *hash;
2544 const char *sym_name;
2545 unsigned int r_type;
2546 unsigned char st_type;
2547 bfd_boolean non_a8_stub;
2550 /* The size of the thread control block. */
2553 struct elf_arm_obj_tdata
2555 struct elf_obj_tdata root;
2557 /* tls_type for each local got entry. */
2558 char *local_got_tls_type;
2560 /* GOTPLT entries for TLS descriptors. */
2561 bfd_vma *local_tlsdesc_gotent;
2563 /* Zero to warn when linking objects with incompatible enum sizes. */
2564 int no_enum_size_warning;
2566 /* Zero to warn when linking objects with incompatible wchar_t sizes. */
2567 int no_wchar_size_warning;
2570 #define elf_arm_tdata(bfd) \
2571 ((struct elf_arm_obj_tdata *) (bfd)->tdata.any)
2573 #define elf32_arm_local_got_tls_type(bfd) \
2574 (elf_arm_tdata (bfd)->local_got_tls_type)
2576 #define elf32_arm_local_tlsdesc_gotent(bfd) \
2577 (elf_arm_tdata (bfd)->local_tlsdesc_gotent)
2579 #define is_arm_elf(bfd) \
2580 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2581 && elf_tdata (bfd) != NULL \
2582 && elf_object_id (bfd) == ARM_ELF_DATA)
2585 elf32_arm_mkobject (bfd *abfd)
2587 return bfd_elf_allocate_object (abfd, sizeof (struct elf_arm_obj_tdata),
2591 #define elf32_arm_hash_entry(ent) ((struct elf32_arm_link_hash_entry *)(ent))
2593 /* Arm ELF linker hash entry. */
2594 struct elf32_arm_link_hash_entry
2596 struct elf_link_hash_entry root;
2598 /* Track dynamic relocs copied for this symbol. */
2599 struct elf_dyn_relocs *dyn_relocs;
2601 /* We reference count Thumb references to a PLT entry separately,
2602 so that we can emit the Thumb trampoline only if needed. */
2603 bfd_signed_vma plt_thumb_refcount;
2605 /* Some references from Thumb code may be eliminated by BL->BLX
2606 conversion, so record them separately. */
2607 bfd_signed_vma plt_maybe_thumb_refcount;
2609 /* Since PLT entries have variable size if the Thumb prologue is
2610 used, we need to record the index into .got.plt instead of
2611 recomputing it from the PLT offset. */
2612 bfd_signed_vma plt_got_offset;
2614 #define GOT_UNKNOWN 0
2615 #define GOT_NORMAL 1
2616 #define GOT_TLS_GD 2
2617 #define GOT_TLS_IE 4
2618 #define GOT_TLS_GDESC 8
2619 #define GOT_TLS_GD_ANY_P(type) ((type & GOT_TLS_GD) || (type & GOT_TLS_GDESC))
2620 unsigned char tls_type;
2622 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
2623 starting at the end of the jump table. */
2624 bfd_vma tlsdesc_got;
2626 /* The symbol marking the real symbol location for exported thumb
2627 symbols with Arm stubs. */
2628 struct elf_link_hash_entry *export_glue;
2630 /* A pointer to the most recently used stub hash entry against this
2632 struct elf32_arm_stub_hash_entry *stub_cache;
2635 /* Traverse an arm ELF linker hash table. */
2636 #define elf32_arm_link_hash_traverse(table, func, info) \
2637 (elf_link_hash_traverse \
2639 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
2642 /* Get the ARM elf linker hash table from a link_info structure. */
2643 #define elf32_arm_hash_table(info) \
2644 (elf_hash_table_id ((struct elf_link_hash_table *) ((info)->hash)) \
2645 == ARM_ELF_DATA ? ((struct elf32_arm_link_hash_table *) ((info)->hash)) : NULL)
2647 #define arm_stub_hash_lookup(table, string, create, copy) \
2648 ((struct elf32_arm_stub_hash_entry *) \
2649 bfd_hash_lookup ((table), (string), (create), (copy)))
2651 /* Array to keep track of which stub sections have been created, and
2652 information on stub grouping. */
2655 /* This is the section to which stubs in the group will be
2658 /* The stub section. */
2662 #define elf32_arm_compute_jump_table_size(htab) \
2663 ((htab)->next_tls_desc_index * 4)
2665 /* ARM ELF linker hash table. */
2666 struct elf32_arm_link_hash_table
2668 /* The main hash table. */
2669 struct elf_link_hash_table root;
2671 /* The size in bytes of the section containing the Thumb-to-ARM glue. */
2672 bfd_size_type thumb_glue_size;
2674 /* The size in bytes of the section containing the ARM-to-Thumb glue. */
2675 bfd_size_type arm_glue_size;
2677 /* The size in bytes of section containing the ARMv4 BX veneers. */
2678 bfd_size_type bx_glue_size;
2680 /* Offsets of ARMv4 BX veneers. Bit1 set if present, and Bit0 set when
2681 veneer has been populated. */
2682 bfd_vma bx_glue_offset[15];
2684 /* The size in bytes of the section containing glue for VFP11 erratum
2686 bfd_size_type vfp11_erratum_glue_size;
2688 /* A table of fix locations for Cortex-A8 Thumb-2 branch/TLB erratum. This
2689 holds Cortex-A8 erratum fix locations between elf32_arm_size_stubs() and
2690 elf32_arm_write_section(). */
2691 struct a8_erratum_fix *a8_erratum_fixes;
2692 unsigned int num_a8_erratum_fixes;
2694 /* An arbitrary input BFD chosen to hold the glue sections. */
2695 bfd * bfd_of_glue_owner;
2697 /* Nonzero to output a BE8 image. */
2700 /* Zero if R_ARM_TARGET1 means R_ARM_ABS32.
2701 Nonzero if R_ARM_TARGET1 means R_ARM_REL32. */
2704 /* The relocation to use for R_ARM_TARGET2 relocations. */
2707 /* 0 = Ignore R_ARM_V4BX.
2708 1 = Convert BX to MOV PC.
2709 2 = Generate v4 interworing stubs. */
2712 /* Whether we should fix the Cortex-A8 Thumb-2 branch/TLB erratum. */
2715 /* Nonzero if the ARM/Thumb BLX instructions are available for use. */
2718 /* What sort of code sequences we should look for which may trigger the
2719 VFP11 denorm erratum. */
2720 bfd_arm_vfp11_fix vfp11_fix;
2722 /* Global counter for the number of fixes we have emitted. */
2723 int num_vfp11_fixes;
2725 /* Nonzero to force PIC branch veneers. */
2728 /* The number of bytes in the initial entry in the PLT. */
2729 bfd_size_type plt_header_size;
2731 /* The number of bytes in the subsequent PLT etries. */
2732 bfd_size_type plt_entry_size;
2734 /* True if the target system is VxWorks. */
2737 /* True if the target system is Symbian OS. */
2740 /* True if the target uses REL relocations. */
2743 /* The index of the next unused R_ARM_TLS_DESC slot in .rel.plt. */
2744 bfd_vma next_tls_desc_index;
2746 /* How many R_ARM_TLS_DESC relocations were generated so far. */
2747 bfd_vma num_tls_desc;
2749 /* Short-cuts to get to dynamic linker sections. */
2753 /* The (unloaded but important) VxWorks .rela.plt.unloaded section. */
2756 /* The offset into splt of the PLT entry for the TLS descriptor
2757 resolver. Special values are 0, if not necessary (or not found
2758 to be necessary yet), and -1 if needed but not determined
2760 bfd_vma dt_tlsdesc_plt;
2762 /* The offset into sgot of the GOT entry used by the PLT entry
2764 bfd_vma dt_tlsdesc_got;
2766 /* Offset in .plt section of tls_arm_trampoline. */
2767 bfd_vma tls_trampoline;
2769 /* Data for R_ARM_TLS_LDM32 relocations. */
2772 bfd_signed_vma refcount;
2776 /* Small local sym cache. */
2777 struct sym_cache sym_cache;
2779 /* For convenience in allocate_dynrelocs. */
2782 /* The amount of space used by the reserved portion of the sgotplt
2783 section, plus whatever space is used by the jump slots. */
2784 bfd_vma sgotplt_jump_table_size;
2786 /* The stub hash table. */
2787 struct bfd_hash_table stub_hash_table;
2789 /* Linker stub bfd. */
2792 /* Linker call-backs. */
2793 asection * (*add_stub_section) (const char *, asection *);
2794 void (*layout_sections_again) (void);
2796 /* Array to keep track of which stub sections have been created, and
2797 information on stub grouping. */
2798 struct map_stub *stub_group;
2800 /* Number of elements in stub_group. */
2803 /* Assorted information used by elf32_arm_size_stubs. */
2804 unsigned int bfd_count;
2806 asection **input_list;
2809 /* Create an entry in an ARM ELF linker hash table. */
2811 static struct bfd_hash_entry *
2812 elf32_arm_link_hash_newfunc (struct bfd_hash_entry * entry,
2813 struct bfd_hash_table * table,
2814 const char * string)
2816 struct elf32_arm_link_hash_entry * ret =
2817 (struct elf32_arm_link_hash_entry *) entry;
2819 /* Allocate the structure if it has not already been allocated by a
2822 ret = (struct elf32_arm_link_hash_entry *)
2823 bfd_hash_allocate (table, sizeof (struct elf32_arm_link_hash_entry));
2825 return (struct bfd_hash_entry *) ret;
2827 /* Call the allocation method of the superclass. */
2828 ret = ((struct elf32_arm_link_hash_entry *)
2829 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2833 ret->dyn_relocs = NULL;
2834 ret->tls_type = GOT_UNKNOWN;
2835 ret->tlsdesc_got = (bfd_vma) -1;
2836 ret->plt_thumb_refcount = 0;
2837 ret->plt_maybe_thumb_refcount = 0;
2838 ret->plt_got_offset = -1;
2839 ret->export_glue = NULL;
2841 ret->stub_cache = NULL;
2844 return (struct bfd_hash_entry *) ret;
2847 /* Initialize an entry in the stub hash table. */
2849 static struct bfd_hash_entry *
2850 stub_hash_newfunc (struct bfd_hash_entry *entry,
2851 struct bfd_hash_table *table,
2854 /* Allocate the structure if it has not already been allocated by a
2858 entry = (struct bfd_hash_entry *)
2859 bfd_hash_allocate (table, sizeof (struct elf32_arm_stub_hash_entry));
2864 /* Call the allocation method of the superclass. */
2865 entry = bfd_hash_newfunc (entry, table, string);
2868 struct elf32_arm_stub_hash_entry *eh;
2870 /* Initialize the local fields. */
2871 eh = (struct elf32_arm_stub_hash_entry *) entry;
2872 eh->stub_sec = NULL;
2873 eh->stub_offset = 0;
2874 eh->target_value = 0;
2875 eh->target_section = NULL;
2876 eh->target_addend = 0;
2878 eh->stub_type = arm_stub_none;
2880 eh->stub_template = NULL;
2881 eh->stub_template_size = 0;
2884 eh->output_name = NULL;
2890 /* Create .got, .gotplt, and .rel(a).got sections in DYNOBJ, and set up
2891 shortcuts to them in our hash table. */
2894 create_got_section (bfd *dynobj, struct bfd_link_info *info)
2896 struct elf32_arm_link_hash_table *htab;
2898 htab = elf32_arm_hash_table (info);
2902 /* BPABI objects never have a GOT, or associated sections. */
2903 if (htab->symbian_p)
2906 if (! _bfd_elf_create_got_section (dynobj, info))
2912 /* Create .plt, .rel(a).plt, .got, .got.plt, .rel(a).got, .dynbss, and
2913 .rel(a).bss sections in DYNOBJ, and set up shortcuts to them in our
2917 elf32_arm_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
2919 struct elf32_arm_link_hash_table *htab;
2921 htab = elf32_arm_hash_table (info);
2925 if (!htab->root.sgot && !create_got_section (dynobj, info))
2928 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
2931 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
2933 htab->srelbss = bfd_get_section_by_name (dynobj,
2934 RELOC_SECTION (htab, ".bss"));
2936 if (htab->vxworks_p)
2938 if (!elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2))
2943 htab->plt_header_size = 0;
2944 htab->plt_entry_size
2945 = 4 * ARRAY_SIZE (elf32_arm_vxworks_shared_plt_entry);
2949 htab->plt_header_size
2950 = 4 * ARRAY_SIZE (elf32_arm_vxworks_exec_plt0_entry);
2951 htab->plt_entry_size
2952 = 4 * ARRAY_SIZE (elf32_arm_vxworks_exec_plt_entry);
2956 if (!htab->root.splt
2957 || !htab->root.srelplt
2959 || (!info->shared && !htab->srelbss))
2965 /* Copy the extra info we tack onto an elf_link_hash_entry. */
2968 elf32_arm_copy_indirect_symbol (struct bfd_link_info *info,
2969 struct elf_link_hash_entry *dir,
2970 struct elf_link_hash_entry *ind)
2972 struct elf32_arm_link_hash_entry *edir, *eind;
2974 edir = (struct elf32_arm_link_hash_entry *) dir;
2975 eind = (struct elf32_arm_link_hash_entry *) ind;
2977 if (eind->dyn_relocs != NULL)
2979 if (edir->dyn_relocs != NULL)
2981 struct elf_dyn_relocs **pp;
2982 struct elf_dyn_relocs *p;
2984 /* Add reloc counts against the indirect sym to the direct sym
2985 list. Merge any entries against the same section. */
2986 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
2988 struct elf_dyn_relocs *q;
2990 for (q = edir->dyn_relocs; q != NULL; q = q->next)
2991 if (q->sec == p->sec)
2993 q->pc_count += p->pc_count;
2994 q->count += p->count;
3001 *pp = edir->dyn_relocs;
3004 edir->dyn_relocs = eind->dyn_relocs;
3005 eind->dyn_relocs = NULL;
3008 if (ind->root.type == bfd_link_hash_indirect)
3010 /* Copy over PLT info. */
3011 edir->plt_thumb_refcount += eind->plt_thumb_refcount;
3012 eind->plt_thumb_refcount = 0;
3013 edir->plt_maybe_thumb_refcount += eind->plt_maybe_thumb_refcount;
3014 eind->plt_maybe_thumb_refcount = 0;
3016 if (dir->got.refcount <= 0)
3018 edir->tls_type = eind->tls_type;
3019 eind->tls_type = GOT_UNKNOWN;
3023 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
3026 /* Create an ARM elf linker hash table. */
3028 static struct bfd_link_hash_table *
3029 elf32_arm_link_hash_table_create (bfd *abfd)
3031 struct elf32_arm_link_hash_table *ret;
3032 bfd_size_type amt = sizeof (struct elf32_arm_link_hash_table);
3034 ret = (struct elf32_arm_link_hash_table *) bfd_malloc (amt);
3038 if (!_bfd_elf_link_hash_table_init (& ret->root, abfd,
3039 elf32_arm_link_hash_newfunc,
3040 sizeof (struct elf32_arm_link_hash_entry),
3047 ret->sdynbss = NULL;
3048 ret->srelbss = NULL;
3049 ret->srelplt2 = NULL;
3050 ret->dt_tlsdesc_plt = 0;
3051 ret->dt_tlsdesc_got = 0;
3052 ret->tls_trampoline = 0;
3053 ret->next_tls_desc_index = 0;
3054 ret->num_tls_desc = 0;
3055 ret->thumb_glue_size = 0;
3056 ret->arm_glue_size = 0;
3057 ret->bx_glue_size = 0;
3058 memset (ret->bx_glue_offset, 0, sizeof (ret->bx_glue_offset));
3059 ret->vfp11_fix = BFD_ARM_VFP11_FIX_NONE;
3060 ret->vfp11_erratum_glue_size = 0;
3061 ret->num_vfp11_fixes = 0;
3062 ret->fix_cortex_a8 = 0;
3063 ret->bfd_of_glue_owner = NULL;
3064 ret->byteswap_code = 0;
3065 ret->target1_is_rel = 0;
3066 ret->target2_reloc = R_ARM_NONE;
3067 #ifdef FOUR_WORD_PLT
3068 ret->plt_header_size = 16;
3069 ret->plt_entry_size = 16;
3071 ret->plt_header_size = 20;
3072 ret->plt_entry_size = 12;
3079 ret->sym_cache.abfd = NULL;
3081 ret->tls_ldm_got.refcount = 0;
3082 ret->stub_bfd = NULL;
3083 ret->add_stub_section = NULL;
3084 ret->layout_sections_again = NULL;
3085 ret->stub_group = NULL;
3089 ret->input_list = NULL;
3091 if (!bfd_hash_table_init (&ret->stub_hash_table, stub_hash_newfunc,
3092 sizeof (struct elf32_arm_stub_hash_entry)))
3098 return &ret->root.root;
3101 /* Free the derived linker hash table. */
3104 elf32_arm_hash_table_free (struct bfd_link_hash_table *hash)
3106 struct elf32_arm_link_hash_table *ret
3107 = (struct elf32_arm_link_hash_table *) hash;
3109 bfd_hash_table_free (&ret->stub_hash_table);
3110 _bfd_generic_link_hash_table_free (hash);
3113 /* Determine if we're dealing with a Thumb only architecture. */
3116 using_thumb_only (struct elf32_arm_link_hash_table *globals)
3118 int arch = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
3122 if (arch == TAG_CPU_ARCH_V6_M || arch == TAG_CPU_ARCH_V6S_M)
3125 if (arch != TAG_CPU_ARCH_V7 && arch != TAG_CPU_ARCH_V7E_M)
3128 profile = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
3129 Tag_CPU_arch_profile);
3131 return profile == 'M';
3134 /* Determine if we're dealing with a Thumb-2 object. */
3137 using_thumb2 (struct elf32_arm_link_hash_table *globals)
3139 int arch = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
3141 return arch == TAG_CPU_ARCH_V6T2 || arch >= TAG_CPU_ARCH_V7;
3144 /* Determine what kind of NOPs are available. */
3147 arch_has_arm_nop (struct elf32_arm_link_hash_table *globals)
3149 const int arch = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
3151 return arch == TAG_CPU_ARCH_V6T2
3152 || arch == TAG_CPU_ARCH_V6K
3153 || arch == TAG_CPU_ARCH_V7
3154 || arch == TAG_CPU_ARCH_V7E_M;
3158 arch_has_thumb2_nop (struct elf32_arm_link_hash_table *globals)
3160 const int arch = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
3162 return (arch == TAG_CPU_ARCH_V6T2 || arch == TAG_CPU_ARCH_V7
3163 || arch == TAG_CPU_ARCH_V7E_M);
3167 arm_stub_is_thumb (enum elf32_arm_stub_type stub_type)
3171 case arm_stub_long_branch_thumb_only:
3172 case arm_stub_long_branch_v4t_thumb_arm:
3173 case arm_stub_short_branch_v4t_thumb_arm:
3174 case arm_stub_long_branch_v4t_thumb_arm_pic:
3175 case arm_stub_long_branch_thumb_only_pic:
3186 /* Determine the type of stub needed, if any, for a call. */
3188 static enum elf32_arm_stub_type
3189 arm_type_of_stub (struct bfd_link_info *info,
3190 asection *input_sec,
3191 const Elf_Internal_Rela *rel,
3192 int *actual_st_type,
3193 struct elf32_arm_link_hash_entry *hash,
3194 bfd_vma destination,
3200 bfd_signed_vma branch_offset;
3201 unsigned int r_type;
3202 struct elf32_arm_link_hash_table * globals;
3205 enum elf32_arm_stub_type stub_type = arm_stub_none;
3207 int st_type = *actual_st_type;
3209 /* We don't know the actual type of destination in case it is of
3210 type STT_SECTION: give up. */
3211 if (st_type == STT_SECTION)
3214 globals = elf32_arm_hash_table (info);
3215 if (globals == NULL)
3218 thumb_only = using_thumb_only (globals);
3220 thumb2 = using_thumb2 (globals);
3222 /* Determine where the call point is. */
3223 location = (input_sec->output_offset
3224 + input_sec->output_section->vma
3227 r_type = ELF32_R_TYPE (rel->r_info);
3229 /* Keep a simpler condition, for the sake of clarity. */
3230 if (globals->root.splt != NULL
3232 && hash->root.plt.offset != (bfd_vma) -1)
3236 /* Note when dealing with PLT entries: the main PLT stub is in
3237 ARM mode, so if the branch is in Thumb mode, another
3238 Thumb->ARM stub will be inserted later just before the ARM
3239 PLT stub. We don't take this extra distance into account
3240 here, because if a long branch stub is needed, we'll add a
3241 Thumb->Arm one and branch directly to the ARM PLT entry
3242 because it avoids spreading offset corrections in several
3245 destination = (globals->root.splt->output_section->vma
3246 + globals->root.splt->output_offset
3247 + hash->root.plt.offset);
3251 branch_offset = (bfd_signed_vma)(destination - location);
3253 if (r_type == R_ARM_THM_CALL || r_type == R_ARM_THM_JUMP24
3254 || r_type == R_ARM_THM_TLS_CALL)
3256 /* Handle cases where:
3257 - this call goes too far (different Thumb/Thumb2 max
3259 - it's a Thumb->Arm call and blx is not available, or it's a
3260 Thumb->Arm branch (not bl). A stub is needed in this case,
3261 but only if this call is not through a PLT entry. Indeed,
3262 PLT stubs handle mode switching already.
3265 && (branch_offset > THM_MAX_FWD_BRANCH_OFFSET
3266 || (branch_offset < THM_MAX_BWD_BRANCH_OFFSET)))
3268 && (branch_offset > THM2_MAX_FWD_BRANCH_OFFSET
3269 || (branch_offset < THM2_MAX_BWD_BRANCH_OFFSET)))
3270 || ((st_type != STT_ARM_TFUNC)
3271 && (((r_type == R_ARM_THM_CALL
3272 || r_type == R_ARM_THM_TLS_CALL) && !globals->use_blx)
3273 || (r_type == R_ARM_THM_JUMP24))
3276 if (st_type == STT_ARM_TFUNC)
3278 /* Thumb to thumb. */
3281 stub_type = (info->shared | globals->pic_veneer)
3283 ? ((globals->use_blx
3284 && (r_type ==R_ARM_THM_CALL))
3285 /* V5T and above. Stub starts with ARM code, so
3286 we must be able to switch mode before
3287 reaching it, which is only possible for 'bl'
3288 (ie R_ARM_THM_CALL relocation). */
3289 ? arm_stub_long_branch_any_thumb_pic
3290 /* On V4T, use Thumb code only. */
3291 : arm_stub_long_branch_v4t_thumb_thumb_pic)
3293 /* non-PIC stubs. */
3294 : ((globals->use_blx
3295 && (r_type ==R_ARM_THM_CALL))
3296 /* V5T and above. */
3297 ? arm_stub_long_branch_any_any
3299 : arm_stub_long_branch_v4t_thumb_thumb);
3303 stub_type = (info->shared | globals->pic_veneer)
3305 ? arm_stub_long_branch_thumb_only_pic
3307 : arm_stub_long_branch_thumb_only;
3314 && sym_sec->owner != NULL
3315 && !INTERWORK_FLAG (sym_sec->owner))
3317 (*_bfd_error_handler)
3318 (_("%B(%s): warning: interworking not enabled.\n"
3319 " first occurrence: %B: Thumb call to ARM"),
3320 sym_sec->owner, input_bfd, name);
3324 (info->shared | globals->pic_veneer)
3326 ? (r_type == R_ARM_THM_TLS_CALL
3328 ? (globals->use_blx ? arm_stub_long_branch_any_tls_pic
3329 : arm_stub_long_branch_v4t_thumb_tls_pic)
3330 : ((globals->use_blx && r_type == R_ARM_THM_CALL)
3331 /* V5T PIC and above. */
3332 ? arm_stub_long_branch_any_arm_pic
3334 : arm_stub_long_branch_v4t_thumb_arm_pic))
3336 /* non-PIC stubs. */
3337 : ((globals->use_blx && r_type == R_ARM_THM_CALL)
3338 /* V5T and above. */
3339 ? arm_stub_long_branch_any_any
3341 : arm_stub_long_branch_v4t_thumb_arm);
3343 /* Handle v4t short branches. */
3344 if ((stub_type == arm_stub_long_branch_v4t_thumb_arm)
3345 && (branch_offset <= THM_MAX_FWD_BRANCH_OFFSET)
3346 && (branch_offset >= THM_MAX_BWD_BRANCH_OFFSET))
3347 stub_type = arm_stub_short_branch_v4t_thumb_arm;
3351 else if (r_type == R_ARM_CALL
3352 || r_type == R_ARM_JUMP24
3353 || r_type == R_ARM_PLT32
3354 || r_type == R_ARM_TLS_CALL)
3356 if (st_type == STT_ARM_TFUNC)
3361 && sym_sec->owner != NULL
3362 && !INTERWORK_FLAG (sym_sec->owner))
3364 (*_bfd_error_handler)
3365 (_("%B(%s): warning: interworking not enabled.\n"
3366 " first occurrence: %B: ARM call to Thumb"),
3367 sym_sec->owner, input_bfd, name);
3370 /* We have an extra 2-bytes reach because of
3371 the mode change (bit 24 (H) of BLX encoding). */
3372 if (branch_offset > (ARM_MAX_FWD_BRANCH_OFFSET + 2)
3373 || (branch_offset < ARM_MAX_BWD_BRANCH_OFFSET)
3374 || (r_type == R_ARM_CALL && !globals->use_blx)
3375 || (r_type == R_ARM_JUMP24)
3376 || (r_type == R_ARM_PLT32))
3378 stub_type = (info->shared | globals->pic_veneer)
3380 ? ((globals->use_blx)
3381 /* V5T and above. */
3382 ? arm_stub_long_branch_any_thumb_pic
3384 : arm_stub_long_branch_v4t_arm_thumb_pic)
3386 /* non-PIC stubs. */
3387 : ((globals->use_blx)
3388 /* V5T and above. */
3389 ? arm_stub_long_branch_any_any
3391 : arm_stub_long_branch_v4t_arm_thumb);
3397 if (branch_offset > ARM_MAX_FWD_BRANCH_OFFSET
3398 || (branch_offset < ARM_MAX_BWD_BRANCH_OFFSET))
3401 (info->shared | globals->pic_veneer)
3403 ? (r_type == R_ARM_TLS_CALL
3405 ? arm_stub_long_branch_any_tls_pic
3406 : arm_stub_long_branch_any_arm_pic)
3407 /* non-PIC stubs. */
3408 : arm_stub_long_branch_any_any;
3413 /* If a stub is needed, record the actual destination type. */
3414 if (stub_type != arm_stub_none)
3415 *actual_st_type = st_type;
3420 /* Build a name for an entry in the stub hash table. */
3423 elf32_arm_stub_name (const asection *input_section,
3424 const asection *sym_sec,
3425 const struct elf32_arm_link_hash_entry *hash,
3426 const Elf_Internal_Rela *rel,
3427 enum elf32_arm_stub_type stub_type)
3434 len = 8 + 1 + strlen (hash->root.root.root.string) + 1 + 8 + 1 + 2 + 1;
3435 stub_name = (char *) bfd_malloc (len);
3436 if (stub_name != NULL)
3437 sprintf (stub_name, "%08x_%s+%x_%d",
3438 input_section->id & 0xffffffff,
3439 hash->root.root.root.string,
3440 (int) rel->r_addend & 0xffffffff,
3445 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1 + 2 + 1;
3446 stub_name = (char *) bfd_malloc (len);
3447 if (stub_name != NULL)
3448 sprintf (stub_name, "%08x_%x:%x+%x_%d",
3449 input_section->id & 0xffffffff,
3450 sym_sec->id & 0xffffffff,
3451 ELF32_R_TYPE (rel->r_info) == R_ARM_TLS_CALL
3452 || ELF32_R_TYPE (rel->r_info) == R_ARM_THM_TLS_CALL
3453 ? 0 : (int) ELF32_R_SYM (rel->r_info) & 0xffffffff,
3454 (int) rel->r_addend & 0xffffffff,
3461 /* Look up an entry in the stub hash. Stub entries are cached because
3462 creating the stub name takes a bit of time. */
3464 static struct elf32_arm_stub_hash_entry *
3465 elf32_arm_get_stub_entry (const asection *input_section,
3466 const asection *sym_sec,
3467 struct elf_link_hash_entry *hash,
3468 const Elf_Internal_Rela *rel,
3469 struct elf32_arm_link_hash_table *htab,
3470 enum elf32_arm_stub_type stub_type)
3472 struct elf32_arm_stub_hash_entry *stub_entry;
3473 struct elf32_arm_link_hash_entry *h = (struct elf32_arm_link_hash_entry *) hash;
3474 const asection *id_sec;
3476 if ((input_section->flags & SEC_CODE) == 0)
3479 /* If this input section is part of a group of sections sharing one
3480 stub section, then use the id of the first section in the group.
3481 Stub names need to include a section id, as there may well be
3482 more than one stub used to reach say, printf, and we need to
3483 distinguish between them. */
3484 id_sec = htab->stub_group[input_section->id].link_sec;
3486 if (h != NULL && h->stub_cache != NULL
3487 && h->stub_cache->h == h
3488 && h->stub_cache->id_sec == id_sec
3489 && h->stub_cache->stub_type == stub_type)
3491 stub_entry = h->stub_cache;
3497 stub_name = elf32_arm_stub_name (id_sec, sym_sec, h, rel, stub_type);
3498 if (stub_name == NULL)
3501 stub_entry = arm_stub_hash_lookup (&htab->stub_hash_table,
3502 stub_name, FALSE, FALSE);
3504 h->stub_cache = stub_entry;
3512 /* Find or create a stub section. Returns a pointer to the stub section, and
3513 the section to which the stub section will be attached (in *LINK_SEC_P).
3514 LINK_SEC_P may be NULL. */
3517 elf32_arm_create_or_find_stub_sec (asection **link_sec_p, asection *section,
3518 struct elf32_arm_link_hash_table *htab)
3523 link_sec = htab->stub_group[section->id].link_sec;
3524 stub_sec = htab->stub_group[section->id].stub_sec;
3525 if (stub_sec == NULL)
3527 stub_sec = htab->stub_group[link_sec->id].stub_sec;
3528 if (stub_sec == NULL)
3534 namelen = strlen (link_sec->name);
3535 len = namelen + sizeof (STUB_SUFFIX);
3536 s_name = (char *) bfd_alloc (htab->stub_bfd, len);
3540 memcpy (s_name, link_sec->name, namelen);
3541 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
3542 stub_sec = (*htab->add_stub_section) (s_name, link_sec);
3543 if (stub_sec == NULL)
3545 htab->stub_group[link_sec->id].stub_sec = stub_sec;
3547 htab->stub_group[section->id].stub_sec = stub_sec;
3551 *link_sec_p = link_sec;
3556 /* Add a new stub entry to the stub hash. Not all fields of the new
3557 stub entry are initialised. */
3559 static struct elf32_arm_stub_hash_entry *
3560 elf32_arm_add_stub (const char *stub_name,
3562 struct elf32_arm_link_hash_table *htab)
3566 struct elf32_arm_stub_hash_entry *stub_entry;
3568 stub_sec = elf32_arm_create_or_find_stub_sec (&link_sec, section, htab);
3569 if (stub_sec == NULL)
3572 /* Enter this entry into the linker stub hash table. */
3573 stub_entry = arm_stub_hash_lookup (&htab->stub_hash_table, stub_name,
3575 if (stub_entry == NULL)
3577 (*_bfd_error_handler) (_("%s: cannot create stub entry %s"),
3583 stub_entry->stub_sec = stub_sec;
3584 stub_entry->stub_offset = 0;
3585 stub_entry->id_sec = link_sec;
3590 /* Store an Arm insn into an output section not processed by
3591 elf32_arm_write_section. */
3594 put_arm_insn (struct elf32_arm_link_hash_table * htab,
3595 bfd * output_bfd, bfd_vma val, void * ptr)
3597 if (htab->byteswap_code != bfd_little_endian (output_bfd))
3598 bfd_putl32 (val, ptr);
3600 bfd_putb32 (val, ptr);
3603 /* Store a 16-bit Thumb insn into an output section not processed by
3604 elf32_arm_write_section. */
3607 put_thumb_insn (struct elf32_arm_link_hash_table * htab,
3608 bfd * output_bfd, bfd_vma val, void * ptr)
3610 if (htab->byteswap_code != bfd_little_endian (output_bfd))
3611 bfd_putl16 (val, ptr);
3613 bfd_putb16 (val, ptr);
3616 /* If it's possible to change R_TYPE to a more efficient access
3617 model, return the new reloc type. */
3620 elf32_arm_tls_transition (struct bfd_link_info *info, int r_type,
3621 struct elf_link_hash_entry *h)
3623 int is_local = (h == NULL);
3625 if (info->shared || (h && h->root.type == bfd_link_hash_undefweak))
3628 /* We do not support relaxations for Old TLS models. */
3631 case R_ARM_TLS_GOTDESC:
3632 case R_ARM_TLS_CALL:
3633 case R_ARM_THM_TLS_CALL:
3634 case R_ARM_TLS_DESCSEQ:
3635 case R_ARM_THM_TLS_DESCSEQ:
3636 return is_local ? R_ARM_TLS_LE32 : R_ARM_TLS_IE32;
3642 static bfd_reloc_status_type elf32_arm_final_link_relocate
3643 (reloc_howto_type *, bfd *, bfd *, asection *, bfd_byte *,
3644 Elf_Internal_Rela *, bfd_vma, struct bfd_link_info *, asection *,
3645 const char *, int, struct elf_link_hash_entry *, bfd_boolean *, char **);
3648 arm_stub_required_alignment (enum elf32_arm_stub_type stub_type)
3652 case arm_stub_a8_veneer_b_cond:
3653 case arm_stub_a8_veneer_b:
3654 case arm_stub_a8_veneer_bl:
3657 case arm_stub_long_branch_any_any:
3658 case arm_stub_long_branch_v4t_arm_thumb:
3659 case arm_stub_long_branch_thumb_only:
3660 case arm_stub_long_branch_v4t_thumb_thumb:
3661 case arm_stub_long_branch_v4t_thumb_arm:
3662 case arm_stub_short_branch_v4t_thumb_arm:
3663 case arm_stub_long_branch_any_arm_pic:
3664 case arm_stub_long_branch_any_thumb_pic:
3665 case arm_stub_long_branch_v4t_thumb_thumb_pic:
3666 case arm_stub_long_branch_v4t_arm_thumb_pic:
3667 case arm_stub_long_branch_v4t_thumb_arm_pic:
3668 case arm_stub_long_branch_thumb_only_pic:
3669 case arm_stub_long_branch_any_tls_pic:
3670 case arm_stub_long_branch_v4t_thumb_tls_pic:
3671 case arm_stub_a8_veneer_blx:
3675 abort (); /* Should be unreachable. */
3680 arm_build_one_stub (struct bfd_hash_entry *gen_entry,
3684 struct elf32_arm_stub_hash_entry *stub_entry;
3685 struct elf32_arm_link_hash_table *globals;
3686 struct bfd_link_info *info;
3693 const insn_sequence *template_sequence;
3695 int stub_reloc_idx[MAXRELOCS] = {-1, -1};
3696 int stub_reloc_offset[MAXRELOCS] = {0, 0};
3699 /* Massage our args to the form they really have. */
3700 stub_entry = (struct elf32_arm_stub_hash_entry *) gen_entry;
3701 info = (struct bfd_link_info *) in_arg;
3703 globals = elf32_arm_hash_table (info);
3704 if (globals == NULL)
3707 stub_sec = stub_entry->stub_sec;
3709 if ((globals->fix_cortex_a8 < 0)
3710 != (arm_stub_required_alignment (stub_entry->stub_type) == 2))
3711 /* We have to do less-strictly-aligned fixes last. */
3714 /* Make a note of the offset within the stubs for this entry. */
3715 stub_entry->stub_offset = stub_sec->size;
3716 loc = stub_sec->contents + stub_entry->stub_offset;
3718 stub_bfd = stub_sec->owner;
3720 /* This is the address of the stub destination. */
3721 sym_value = (stub_entry->target_value
3722 + stub_entry->target_section->output_offset
3723 + stub_entry->target_section->output_section->vma);
3725 template_sequence = stub_entry->stub_template;
3726 template_size = stub_entry->stub_template_size;
3729 for (i = 0; i < template_size; i++)
3731 switch (template_sequence[i].type)
3735 bfd_vma data = (bfd_vma) template_sequence[i].data;
3736 if (template_sequence[i].reloc_addend != 0)
3738 /* We've borrowed the reloc_addend field to mean we should
3739 insert a condition code into this (Thumb-1 branch)
3740 instruction. See THUMB16_BCOND_INSN. */
3741 BFD_ASSERT ((data & 0xff00) == 0xd000);
3742 data |= ((stub_entry->orig_insn >> 22) & 0xf) << 8;
3744 bfd_put_16 (stub_bfd, data, loc + size);
3750 bfd_put_16 (stub_bfd,
3751 (template_sequence[i].data >> 16) & 0xffff,
3753 bfd_put_16 (stub_bfd, template_sequence[i].data & 0xffff,
3755 if (template_sequence[i].r_type != R_ARM_NONE)
3757 stub_reloc_idx[nrelocs] = i;
3758 stub_reloc_offset[nrelocs++] = size;
3764 bfd_put_32 (stub_bfd, template_sequence[i].data,
3766 /* Handle cases where the target is encoded within the
3768 if (template_sequence[i].r_type == R_ARM_JUMP24)
3770 stub_reloc_idx[nrelocs] = i;
3771 stub_reloc_offset[nrelocs++] = size;
3777 bfd_put_32 (stub_bfd, template_sequence[i].data, loc + size);
3778 stub_reloc_idx[nrelocs] = i;
3779 stub_reloc_offset[nrelocs++] = size;
3789 stub_sec->size += size;
3791 /* Stub size has already been computed in arm_size_one_stub. Check
3793 BFD_ASSERT (size == stub_entry->stub_size);
3795 /* Destination is Thumb. Force bit 0 to 1 to reflect this. */
3796 if (stub_entry->st_type == STT_ARM_TFUNC)
3799 /* Assume there is at least one and at most MAXRELOCS entries to relocate
3801 BFD_ASSERT (nrelocs != 0 && nrelocs <= MAXRELOCS);
3803 for (i = 0; i < nrelocs; i++)
3804 if (template_sequence[stub_reloc_idx[i]].r_type == R_ARM_THM_JUMP24
3805 || template_sequence[stub_reloc_idx[i]].r_type == R_ARM_THM_JUMP19
3806 || template_sequence[stub_reloc_idx[i]].r_type == R_ARM_THM_CALL
3807 || template_sequence[stub_reloc_idx[i]].r_type == R_ARM_THM_XPC22)
3809 Elf_Internal_Rela rel;
3810 bfd_boolean unresolved_reloc;
3811 char *error_message;
3813 = (template_sequence[stub_reloc_idx[i]].r_type != R_ARM_THM_XPC22)
3814 ? STT_ARM_TFUNC : 0;
3815 bfd_vma points_to = sym_value + stub_entry->target_addend;
3817 rel.r_offset = stub_entry->stub_offset + stub_reloc_offset[i];
3818 rel.r_info = ELF32_R_INFO (0,
3819 template_sequence[stub_reloc_idx[i]].r_type);
3820 rel.r_addend = template_sequence[stub_reloc_idx[i]].reloc_addend;
3822 if (stub_entry->stub_type == arm_stub_a8_veneer_b_cond && i == 0)
3823 /* The first relocation in the elf32_arm_stub_a8_veneer_b_cond[]
3824 template should refer back to the instruction after the original
3826 points_to = sym_value;
3828 /* There may be unintended consequences if this is not true. */
3829 BFD_ASSERT (stub_entry->h == NULL);
3831 /* Note: _bfd_final_link_relocate doesn't handle these relocations
3832 properly. We should probably use this function unconditionally,
3833 rather than only for certain relocations listed in the enclosing
3834 conditional, for the sake of consistency. */
3835 elf32_arm_final_link_relocate (elf32_arm_howto_from_type
3836 (template_sequence[stub_reloc_idx[i]].r_type),
3837 stub_bfd, info->output_bfd, stub_sec, stub_sec->contents, &rel,
3838 points_to, info, stub_entry->target_section, "", sym_flags,
3839 (struct elf_link_hash_entry *) stub_entry->h, &unresolved_reloc,
3844 Elf_Internal_Rela rel;
3845 bfd_boolean unresolved_reloc;
3846 char *error_message;
3847 bfd_vma points_to = sym_value + stub_entry->target_addend
3848 + template_sequence[stub_reloc_idx[i]].reloc_addend;
3850 rel.r_offset = stub_entry->stub_offset + stub_reloc_offset[i];
3851 rel.r_info = ELF32_R_INFO (0,
3852 template_sequence[stub_reloc_idx[i]].r_type);
3855 elf32_arm_final_link_relocate (elf32_arm_howto_from_type
3856 (template_sequence[stub_reloc_idx[i]].r_type),
3857 stub_bfd, info->output_bfd, stub_sec, stub_sec->contents, &rel,
3858 points_to, info, stub_entry->target_section, "", stub_entry->st_type,
3859 (struct elf_link_hash_entry *) stub_entry->h, &unresolved_reloc,
3867 /* Calculate the template, template size and instruction size for a stub.
3868 Return value is the instruction size. */
3871 find_stub_size_and_template (enum elf32_arm_stub_type stub_type,
3872 const insn_sequence **stub_template,
3873 int *stub_template_size)
3875 const insn_sequence *template_sequence = NULL;
3876 int template_size = 0, i;
3879 template_sequence = stub_definitions[stub_type].template_sequence;
3881 *stub_template = template_sequence;
3883 template_size = stub_definitions[stub_type].template_size;
3884 if (stub_template_size)
3885 *stub_template_size = template_size;
3888 for (i = 0; i < template_size; i++)
3890 switch (template_sequence[i].type)
3911 /* As above, but don't actually build the stub. Just bump offset so
3912 we know stub section sizes. */
3915 arm_size_one_stub (struct bfd_hash_entry *gen_entry,
3916 void *in_arg ATTRIBUTE_UNUSED)
3918 struct elf32_arm_stub_hash_entry *stub_entry;
3919 const insn_sequence *template_sequence;
3920 int template_size, size;
3922 /* Massage our args to the form they really have. */
3923 stub_entry = (struct elf32_arm_stub_hash_entry *) gen_entry;
3925 BFD_ASSERT((stub_entry->stub_type > arm_stub_none)
3926 && stub_entry->stub_type < ARRAY_SIZE(stub_definitions));
3928 size = find_stub_size_and_template (stub_entry->stub_type, &template_sequence,
3931 stub_entry->stub_size = size;
3932 stub_entry->stub_template = template_sequence;
3933 stub_entry->stub_template_size = template_size;
3935 size = (size + 7) & ~7;
3936 stub_entry->stub_sec->size += size;
3941 /* External entry points for sizing and building linker stubs. */
3943 /* Set up various things so that we can make a list of input sections
3944 for each output section included in the link. Returns -1 on error,
3945 0 when no stubs will be needed, and 1 on success. */
3948 elf32_arm_setup_section_lists (bfd *output_bfd,
3949 struct bfd_link_info *info)
3952 unsigned int bfd_count;
3953 int top_id, top_index;
3955 asection **input_list, **list;
3957 struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
3961 if (! is_elf_hash_table (htab))
3964 /* Count the number of input BFDs and find the top input section id. */
3965 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
3967 input_bfd = input_bfd->link_next)
3970 for (section = input_bfd->sections;
3972 section = section->next)
3974 if (top_id < section->id)
3975 top_id = section->id;
3978 htab->bfd_count = bfd_count;
3980 amt = sizeof (struct map_stub) * (top_id + 1);
3981 htab->stub_group = (struct map_stub *) bfd_zmalloc (amt);
3982 if (htab->stub_group == NULL)
3984 htab->top_id = top_id;
3986 /* We can't use output_bfd->section_count here to find the top output
3987 section index as some sections may have been removed, and
3988 _bfd_strip_section_from_output doesn't renumber the indices. */
3989 for (section = output_bfd->sections, top_index = 0;
3991 section = section->next)
3993 if (top_index < section->index)
3994 top_index = section->index;
3997 htab->top_index = top_index;
3998 amt = sizeof (asection *) * (top_index + 1);
3999 input_list = (asection **) bfd_malloc (amt);
4000 htab->input_list = input_list;
4001 if (input_list == NULL)
4004 /* For sections we aren't interested in, mark their entries with a
4005 value we can check later. */
4006 list = input_list + top_index;
4008 *list = bfd_abs_section_ptr;
4009 while (list-- != input_list);
4011 for (section = output_bfd->sections;
4013 section = section->next)
4015 if ((section->flags & SEC_CODE) != 0)
4016 input_list[section->index] = NULL;
4022 /* The linker repeatedly calls this function for each input section,
4023 in the order that input sections are linked into output sections.
4024 Build lists of input sections to determine groupings between which
4025 we may insert linker stubs. */
4028 elf32_arm_next_input_section (struct bfd_link_info *info,
4031 struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
4036 if (isec->output_section->index <= htab->top_index)
4038 asection **list = htab->input_list + isec->output_section->index;
4040 if (*list != bfd_abs_section_ptr && (isec->flags & SEC_CODE) != 0)
4042 /* Steal the link_sec pointer for our list. */
4043 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
4044 /* This happens to make the list in reverse order,
4045 which we reverse later. */
4046 PREV_SEC (isec) = *list;
4052 /* See whether we can group stub sections together. Grouping stub
4053 sections may result in fewer stubs. More importantly, we need to
4054 put all .init* and .fini* stubs at the end of the .init or
4055 .fini output sections respectively, because glibc splits the
4056 _init and _fini functions into multiple parts. Putting a stub in
4057 the middle of a function is not a good idea. */
4060 group_sections (struct elf32_arm_link_hash_table *htab,
4061 bfd_size_type stub_group_size,
4062 bfd_boolean stubs_always_after_branch)
4064 asection **list = htab->input_list;
4068 asection *tail = *list;
4071 if (tail == bfd_abs_section_ptr)
4074 /* Reverse the list: we must avoid placing stubs at the
4075 beginning of the section because the beginning of the text
4076 section may be required for an interrupt vector in bare metal
4078 #define NEXT_SEC PREV_SEC
4080 while (tail != NULL)
4082 /* Pop from tail. */
4083 asection *item = tail;
4084 tail = PREV_SEC (item);
4087 NEXT_SEC (item) = head;
4091 while (head != NULL)
4095 bfd_vma stub_group_start = head->output_offset;
4096 bfd_vma end_of_next;
4099 while (NEXT_SEC (curr) != NULL)
4101 next = NEXT_SEC (curr);
4102 end_of_next = next->output_offset + next->size;
4103 if (end_of_next - stub_group_start >= stub_group_size)
4104 /* End of NEXT is too far from start, so stop. */
4106 /* Add NEXT to the group. */
4110 /* OK, the size from the start to the start of CURR is less
4111 than stub_group_size and thus can be handled by one stub
4112 section. (Or the head section is itself larger than
4113 stub_group_size, in which case we may be toast.)
4114 We should really be keeping track of the total size of
4115 stubs added here, as stubs contribute to the final output
4119 next = NEXT_SEC (head);
4120 /* Set up this stub group. */
4121 htab->stub_group[head->id].link_sec = curr;
4123 while (head != curr && (head = next) != NULL);
4125 /* But wait, there's more! Input sections up to stub_group_size
4126 bytes after the stub section can be handled by it too. */
4127 if (!stubs_always_after_branch)
4129 stub_group_start = curr->output_offset + curr->size;
4131 while (next != NULL)
4133 end_of_next = next->output_offset + next->size;
4134 if (end_of_next - stub_group_start >= stub_group_size)
4135 /* End of NEXT is too far from stubs, so stop. */
4137 /* Add NEXT to the stub group. */
4139 next = NEXT_SEC (head);
4140 htab->stub_group[head->id].link_sec = curr;
4146 while (list++ != htab->input_list + htab->top_index);
4148 free (htab->input_list);
4153 /* Comparison function for sorting/searching relocations relating to Cortex-A8
4157 a8_reloc_compare (const void *a, const void *b)
4159 const struct a8_erratum_reloc *ra = (const struct a8_erratum_reloc *) a;
4160 const struct a8_erratum_reloc *rb = (const struct a8_erratum_reloc *) b;
4162 if (ra->from < rb->from)
4164 else if (ra->from > rb->from)
4170 static struct elf_link_hash_entry *find_thumb_glue (struct bfd_link_info *,
4171 const char *, char **);
4173 /* Helper function to scan code for sequences which might trigger the Cortex-A8
4174 branch/TLB erratum. Fill in the table described by A8_FIXES_P,
4175 NUM_A8_FIXES_P, A8_FIX_TABLE_SIZE_P. Returns true if an error occurs, false
4179 cortex_a8_erratum_scan (bfd *input_bfd,
4180 struct bfd_link_info *info,
4181 struct a8_erratum_fix **a8_fixes_p,
4182 unsigned int *num_a8_fixes_p,
4183 unsigned int *a8_fix_table_size_p,
4184 struct a8_erratum_reloc *a8_relocs,
4185 unsigned int num_a8_relocs,
4186 unsigned prev_num_a8_fixes,
4187 bfd_boolean *stub_changed_p)
4190 struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
4191 struct a8_erratum_fix *a8_fixes = *a8_fixes_p;
4192 unsigned int num_a8_fixes = *num_a8_fixes_p;
4193 unsigned int a8_fix_table_size = *a8_fix_table_size_p;
4198 for (section = input_bfd->sections;
4200 section = section->next)
4202 bfd_byte *contents = NULL;
4203 struct _arm_elf_section_data *sec_data;
4207 if (elf_section_type (section) != SHT_PROGBITS
4208 || (elf_section_flags (section) & SHF_EXECINSTR) == 0
4209 || (section->flags & SEC_EXCLUDE) != 0
4210 || (section->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
4211 || (section->output_section == bfd_abs_section_ptr))
4214 base_vma = section->output_section->vma + section->output_offset;
4216 if (elf_section_data (section)->this_hdr.contents != NULL)
4217 contents = elf_section_data (section)->this_hdr.contents;
4218 else if (! bfd_malloc_and_get_section (input_bfd, section, &contents))
4221 sec_data = elf32_arm_section_data (section);
4223 for (span = 0; span < sec_data->mapcount; span++)
4225 unsigned int span_start = sec_data->map[span].vma;
4226 unsigned int span_end = (span == sec_data->mapcount - 1)
4227 ? section->size : sec_data->map[span + 1].vma;
4229 char span_type = sec_data->map[span].type;
4230 bfd_boolean last_was_32bit = FALSE, last_was_branch = FALSE;
4232 if (span_type != 't')
4235 /* Span is entirely within a single 4KB region: skip scanning. */
4236 if (((base_vma + span_start) & ~0xfff)
4237 == ((base_vma + span_end) & ~0xfff))
4240 /* Scan for 32-bit Thumb-2 branches which span two 4K regions, where:
4242 * The opcode is BLX.W, BL.W, B.W, Bcc.W
4243 * The branch target is in the same 4KB region as the
4244 first half of the branch.
4245 * The instruction before the branch is a 32-bit
4246 length non-branch instruction. */
4247 for (i = span_start; i < span_end;)
4249 unsigned int insn = bfd_getl16 (&contents[i]);
4250 bfd_boolean insn_32bit = FALSE, is_blx = FALSE, is_b = FALSE;
4251 bfd_boolean is_bl = FALSE, is_bcc = FALSE, is_32bit_branch;
4253 if ((insn & 0xe000) == 0xe000 && (insn & 0x1800) != 0x0000)
4258 /* Load the rest of the insn (in manual-friendly order). */
4259 insn = (insn << 16) | bfd_getl16 (&contents[i + 2]);
4261 /* Encoding T4: B<c>.W. */
4262 is_b = (insn & 0xf800d000) == 0xf0009000;
4263 /* Encoding T1: BL<c>.W. */
4264 is_bl = (insn & 0xf800d000) == 0xf000d000;
4265 /* Encoding T2: BLX<c>.W. */
4266 is_blx = (insn & 0xf800d000) == 0xf000c000;
4267 /* Encoding T3: B<c>.W (not permitted in IT block). */
4268 is_bcc = (insn & 0xf800d000) == 0xf0008000
4269 && (insn & 0x07f00000) != 0x03800000;
4272 is_32bit_branch = is_b || is_bl || is_blx || is_bcc;
4274 if (((base_vma + i) & 0xfff) == 0xffe
4278 && ! last_was_branch)
4280 bfd_signed_vma offset = 0;
4281 bfd_boolean force_target_arm = FALSE;
4282 bfd_boolean force_target_thumb = FALSE;
4284 enum elf32_arm_stub_type stub_type = arm_stub_none;
4285 struct a8_erratum_reloc key, *found;
4287 key.from = base_vma + i;
4288 found = (struct a8_erratum_reloc *)
4289 bsearch (&key, a8_relocs, num_a8_relocs,
4290 sizeof (struct a8_erratum_reloc),
4295 char *error_message = NULL;
4296 struct elf_link_hash_entry *entry;
4297 bfd_boolean use_plt = FALSE;
4299 /* We don't care about the error returned from this
4300 function, only if there is glue or not. */
4301 entry = find_thumb_glue (info, found->sym_name,
4305 found->non_a8_stub = TRUE;
4307 /* Keep a simpler condition, for the sake of clarity. */
4308 if (htab->root.splt != NULL && found->hash != NULL
4309 && found->hash->root.plt.offset != (bfd_vma) -1)
4312 if (found->r_type == R_ARM_THM_CALL)
4314 if (found->st_type != STT_ARM_TFUNC || use_plt)
4315 force_target_arm = TRUE;
4317 force_target_thumb = TRUE;
4321 /* Check if we have an offending branch instruction. */
4323 if (found && found->non_a8_stub)
4324 /* We've already made a stub for this instruction, e.g.
4325 it's a long branch or a Thumb->ARM stub. Assume that
4326 stub will suffice to work around the A8 erratum (see
4327 setting of always_after_branch above). */
4331 offset = (insn & 0x7ff) << 1;
4332 offset |= (insn & 0x3f0000) >> 4;
4333 offset |= (insn & 0x2000) ? 0x40000 : 0;
4334 offset |= (insn & 0x800) ? 0x80000 : 0;
4335 offset |= (insn & 0x4000000) ? 0x100000 : 0;
4336 if (offset & 0x100000)
4337 offset |= ~ ((bfd_signed_vma) 0xfffff);
4338 stub_type = arm_stub_a8_veneer_b_cond;
4340 else if (is_b || is_bl || is_blx)
4342 int s = (insn & 0x4000000) != 0;
4343 int j1 = (insn & 0x2000) != 0;
4344 int j2 = (insn & 0x800) != 0;
4348 offset = (insn & 0x7ff) << 1;
4349 offset |= (insn & 0x3ff0000) >> 4;
4353 if (offset & 0x1000000)
4354 offset |= ~ ((bfd_signed_vma) 0xffffff);
4357 offset &= ~ ((bfd_signed_vma) 3);
4359 stub_type = is_blx ? arm_stub_a8_veneer_blx :
4360 is_bl ? arm_stub_a8_veneer_bl : arm_stub_a8_veneer_b;
4363 if (stub_type != arm_stub_none)
4365 bfd_vma pc_for_insn = base_vma + i + 4;
4367 /* The original instruction is a BL, but the target is
4368 an ARM instruction. If we were not making a stub,
4369 the BL would have been converted to a BLX. Use the
4370 BLX stub instead in that case. */
4371 if (htab->use_blx && force_target_arm
4372 && stub_type == arm_stub_a8_veneer_bl)
4374 stub_type = arm_stub_a8_veneer_blx;
4378 /* Conversely, if the original instruction was
4379 BLX but the target is Thumb mode, use the BL
4381 else if (force_target_thumb
4382 && stub_type == arm_stub_a8_veneer_blx)
4384 stub_type = arm_stub_a8_veneer_bl;
4390 pc_for_insn &= ~ ((bfd_vma) 3);
4392 /* If we found a relocation, use the proper destination,
4393 not the offset in the (unrelocated) instruction.
4394 Note this is always done if we switched the stub type
4398 (bfd_signed_vma) (found->destination - pc_for_insn);
4400 target = pc_for_insn + offset;
4402 /* The BLX stub is ARM-mode code. Adjust the offset to
4403 take the different PC value (+8 instead of +4) into
4405 if (stub_type == arm_stub_a8_veneer_blx)
4408 if (((base_vma + i) & ~0xfff) == (target & ~0xfff))
4410 char *stub_name = NULL;
4412 if (num_a8_fixes == a8_fix_table_size)
4414 a8_fix_table_size *= 2;
4415 a8_fixes = (struct a8_erratum_fix *)
4416 bfd_realloc (a8_fixes,
4417 sizeof (struct a8_erratum_fix)
4418 * a8_fix_table_size);
4421 if (num_a8_fixes < prev_num_a8_fixes)
4423 /* If we're doing a subsequent scan,
4424 check if we've found the same fix as
4425 before, and try and reuse the stub
4427 stub_name = a8_fixes[num_a8_fixes].stub_name;
4428 if ((a8_fixes[num_a8_fixes].section != section)
4429 || (a8_fixes[num_a8_fixes].offset != i))
4433 *stub_changed_p = TRUE;
4439 stub_name = (char *) bfd_malloc (8 + 1 + 8 + 1);
4440 if (stub_name != NULL)
4441 sprintf (stub_name, "%x:%x", section->id, i);
4444 a8_fixes[num_a8_fixes].input_bfd = input_bfd;
4445 a8_fixes[num_a8_fixes].section = section;
4446 a8_fixes[num_a8_fixes].offset = i;
4447 a8_fixes[num_a8_fixes].addend = offset;
4448 a8_fixes[num_a8_fixes].orig_insn = insn;
4449 a8_fixes[num_a8_fixes].stub_name = stub_name;
4450 a8_fixes[num_a8_fixes].stub_type = stub_type;
4451 a8_fixes[num_a8_fixes].st_type =
4452 is_blx ? STT_FUNC : STT_ARM_TFUNC;
4459 i += insn_32bit ? 4 : 2;
4460 last_was_32bit = insn_32bit;
4461 last_was_branch = is_32bit_branch;
4465 if (elf_section_data (section)->this_hdr.contents == NULL)
4469 *a8_fixes_p = a8_fixes;
4470 *num_a8_fixes_p = num_a8_fixes;
4471 *a8_fix_table_size_p = a8_fix_table_size;
4476 /* Determine and set the size of the stub section for a final link.
4478 The basic idea here is to examine all the relocations looking for
4479 PC-relative calls to a target that is unreachable with a "bl"
4483 elf32_arm_size_stubs (bfd *output_bfd,
4485 struct bfd_link_info *info,
4486 bfd_signed_vma group_size,
4487 asection * (*add_stub_section) (const char *, asection *),
4488 void (*layout_sections_again) (void))
4490 bfd_size_type stub_group_size;
4491 bfd_boolean stubs_always_after_branch;
4492 struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
4493 struct a8_erratum_fix *a8_fixes = NULL;
4494 unsigned int num_a8_fixes = 0, a8_fix_table_size = 10;
4495 struct a8_erratum_reloc *a8_relocs = NULL;
4496 unsigned int num_a8_relocs = 0, a8_reloc_table_size = 10, i;
4501 if (htab->fix_cortex_a8)
4503 a8_fixes = (struct a8_erratum_fix *)
4504 bfd_zmalloc (sizeof (struct a8_erratum_fix) * a8_fix_table_size);
4505 a8_relocs = (struct a8_erratum_reloc *)
4506 bfd_zmalloc (sizeof (struct a8_erratum_reloc) * a8_reloc_table_size);
4509 /* Propagate mach to stub bfd, because it may not have been
4510 finalized when we created stub_bfd. */
4511 bfd_set_arch_mach (stub_bfd, bfd_get_arch (output_bfd),
4512 bfd_get_mach (output_bfd));
4514 /* Stash our params away. */
4515 htab->stub_bfd = stub_bfd;
4516 htab->add_stub_section = add_stub_section;
4517 htab->layout_sections_again = layout_sections_again;
4518 stubs_always_after_branch = group_size < 0;
4520 /* The Cortex-A8 erratum fix depends on stubs not being in the same 4K page
4521 as the first half of a 32-bit branch straddling two 4K pages. This is a
4522 crude way of enforcing that. */
4523 if (htab->fix_cortex_a8)
4524 stubs_always_after_branch = 1;
4527 stub_group_size = -group_size;
4529 stub_group_size = group_size;
4531 if (stub_group_size == 1)
4533 /* Default values. */
4534 /* Thumb branch range is +-4MB has to be used as the default
4535 maximum size (a given section can contain both ARM and Thumb
4536 code, so the worst case has to be taken into account).
4538 This value is 24K less than that, which allows for 2025
4539 12-byte stubs. If we exceed that, then we will fail to link.
4540 The user will have to relink with an explicit group size
4542 stub_group_size = 4170000;
4545 group_sections (htab, stub_group_size, stubs_always_after_branch);
4547 /* If we're applying the cortex A8 fix, we need to determine the
4548 program header size now, because we cannot change it later --
4549 that could alter section placements. Notice the A8 erratum fix
4550 ends up requiring the section addresses to remain unchanged
4551 modulo the page size. That's something we cannot represent
4552 inside BFD, and we don't want to force the section alignment to
4553 be the page size. */
4554 if (htab->fix_cortex_a8)
4555 (*htab->layout_sections_again) ();
4560 unsigned int bfd_indx;
4562 bfd_boolean stub_changed = FALSE;
4563 unsigned prev_num_a8_fixes = num_a8_fixes;
4566 for (input_bfd = info->input_bfds, bfd_indx = 0;
4568 input_bfd = input_bfd->link_next, bfd_indx++)
4570 Elf_Internal_Shdr *symtab_hdr;
4572 Elf_Internal_Sym *local_syms = NULL;
4576 /* We'll need the symbol table in a second. */
4577 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4578 if (symtab_hdr->sh_info == 0)
4581 /* Walk over each section attached to the input bfd. */
4582 for (section = input_bfd->sections;
4584 section = section->next)
4586 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
4588 /* If there aren't any relocs, then there's nothing more
4590 if ((section->flags & SEC_RELOC) == 0
4591 || section->reloc_count == 0
4592 || (section->flags & SEC_CODE) == 0)
4595 /* If this section is a link-once section that will be
4596 discarded, then don't create any stubs. */
4597 if (section->output_section == NULL
4598 || section->output_section->owner != output_bfd)
4601 /* Get the relocs. */
4603 = _bfd_elf_link_read_relocs (input_bfd, section, NULL,
4604 NULL, info->keep_memory);
4605 if (internal_relocs == NULL)
4606 goto error_ret_free_local;
4608 /* Now examine each relocation. */
4609 irela = internal_relocs;
4610 irelaend = irela + section->reloc_count;
4611 for (; irela < irelaend; irela++)
4613 unsigned int r_type, r_indx;
4614 enum elf32_arm_stub_type stub_type;
4615 struct elf32_arm_stub_hash_entry *stub_entry;
4618 bfd_vma destination;
4619 struct elf32_arm_link_hash_entry *hash;
4620 const char *sym_name;
4622 const asection *id_sec;
4624 bfd_boolean created_stub = FALSE;
4626 r_type = ELF32_R_TYPE (irela->r_info);
4627 r_indx = ELF32_R_SYM (irela->r_info);
4629 if (r_type >= (unsigned int) R_ARM_max)
4631 bfd_set_error (bfd_error_bad_value);
4632 error_ret_free_internal:
4633 if (elf_section_data (section)->relocs == NULL)
4634 free (internal_relocs);
4635 goto error_ret_free_local;
4639 if (r_indx >= symtab_hdr->sh_info)
4640 hash = elf32_arm_hash_entry
4641 (elf_sym_hashes (input_bfd)
4642 [r_indx - symtab_hdr->sh_info]);
4644 /* Only look for stubs on branch instructions, or
4645 non-relaxed TLSCALL */
4646 if ((r_type != (unsigned int) R_ARM_CALL)
4647 && (r_type != (unsigned int) R_ARM_THM_CALL)
4648 && (r_type != (unsigned int) R_ARM_JUMP24)
4649 && (r_type != (unsigned int) R_ARM_THM_JUMP19)
4650 && (r_type != (unsigned int) R_ARM_THM_XPC22)
4651 && (r_type != (unsigned int) R_ARM_THM_JUMP24)
4652 && (r_type != (unsigned int) R_ARM_PLT32)
4653 && !((r_type == (unsigned int) R_ARM_TLS_CALL
4654 || r_type == (unsigned int) R_ARM_THM_TLS_CALL)
4655 && r_type == elf32_arm_tls_transition
4656 (info, r_type, &hash->root)
4657 && ((hash ? hash->tls_type
4658 : (elf32_arm_local_got_tls_type
4659 (input_bfd)[r_indx]))
4660 & GOT_TLS_GDESC) != 0))
4663 /* Now determine the call target, its name, value,
4670 if (r_type == (unsigned int) R_ARM_TLS_CALL
4671 || r_type == (unsigned int) R_ARM_THM_TLS_CALL)
4673 /* A non-relaxed TLS call. The target is the
4674 plt-resident trampoline and nothing to do
4676 BFD_ASSERT (htab->tls_trampoline > 0);
4677 sym_sec = htab->root.splt;
4678 sym_value = htab->tls_trampoline;
4684 /* It's a local symbol. */
4685 Elf_Internal_Sym *sym;
4687 if (local_syms == NULL)
4690 = (Elf_Internal_Sym *) symtab_hdr->contents;
4691 if (local_syms == NULL)
4693 = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
4694 symtab_hdr->sh_info, 0,
4696 if (local_syms == NULL)
4697 goto error_ret_free_internal;
4700 sym = local_syms + r_indx;
4701 if (sym->st_shndx == SHN_UNDEF)
4702 sym_sec = bfd_und_section_ptr;
4703 else if (sym->st_shndx == SHN_ABS)
4704 sym_sec = bfd_abs_section_ptr;
4705 else if (sym->st_shndx == SHN_COMMON)
4706 sym_sec = bfd_com_section_ptr;
4709 bfd_section_from_elf_index (input_bfd, sym->st_shndx);
4712 /* This is an undefined symbol. It can never
4716 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
4717 sym_value = sym->st_value;
4718 destination = (sym_value + irela->r_addend
4719 + sym_sec->output_offset
4720 + sym_sec->output_section->vma);
4721 st_type = ELF_ST_TYPE (sym->st_info);
4723 = bfd_elf_string_from_elf_section (input_bfd,
4724 symtab_hdr->sh_link,
4729 /* It's an external symbol. */
4730 while (hash->root.root.type == bfd_link_hash_indirect
4731 || hash->root.root.type == bfd_link_hash_warning)
4732 hash = ((struct elf32_arm_link_hash_entry *)
4733 hash->root.root.u.i.link);
4735 if (hash->root.root.type == bfd_link_hash_defined
4736 || hash->root.root.type == bfd_link_hash_defweak)
4738 sym_sec = hash->root.root.u.def.section;
4739 sym_value = hash->root.root.u.def.value;
4741 struct elf32_arm_link_hash_table *globals =
4742 elf32_arm_hash_table (info);
4744 /* For a destination in a shared library,
4745 use the PLT stub as target address to
4746 decide whether a branch stub is
4749 && globals->root.splt != NULL
4751 && hash->root.plt.offset != (bfd_vma) -1)
4753 sym_sec = globals->root.splt;
4754 sym_value = hash->root.plt.offset;
4755 if (sym_sec->output_section != NULL)
4756 destination = (sym_value
4757 + sym_sec->output_offset
4758 + sym_sec->output_section->vma);
4760 else if (sym_sec->output_section != NULL)
4761 destination = (sym_value + irela->r_addend
4762 + sym_sec->output_offset
4763 + sym_sec->output_section->vma);
4765 else if ((hash->root.root.type == bfd_link_hash_undefined)
4766 || (hash->root.root.type == bfd_link_hash_undefweak))
4768 /* For a shared library, use the PLT stub as
4769 target address to decide whether a long
4770 branch stub is needed.
4771 For absolute code, they cannot be handled. */
4772 struct elf32_arm_link_hash_table *globals =
4773 elf32_arm_hash_table (info);
4776 && globals->root.splt != NULL
4778 && hash->root.plt.offset != (bfd_vma) -1)
4780 sym_sec = globals->root.splt;
4781 sym_value = hash->root.plt.offset;
4782 if (sym_sec->output_section != NULL)
4783 destination = (sym_value
4784 + sym_sec->output_offset
4785 + sym_sec->output_section->vma);
4792 bfd_set_error (bfd_error_bad_value);
4793 goto error_ret_free_internal;
4795 st_type = ELF_ST_TYPE (hash->root.type);
4796 sym_name = hash->root.root.root.string;
4801 /* Determine what (if any) linker stub is needed. */
4802 stub_type = arm_type_of_stub (info, section, irela,
4804 destination, sym_sec,
4805 input_bfd, sym_name);
4806 if (stub_type == arm_stub_none)
4809 /* Support for grouping stub sections. */
4810 id_sec = htab->stub_group[section->id].link_sec;
4812 /* Get the name of this stub. */
4813 stub_name = elf32_arm_stub_name (id_sec, sym_sec, hash,
4816 goto error_ret_free_internal;
4818 /* We've either created a stub for this reloc already,
4819 or we are about to. */
4820 created_stub = TRUE;
4822 stub_entry = arm_stub_hash_lookup
4823 (&htab->stub_hash_table, stub_name,
4825 if (stub_entry != NULL)
4827 /* The proper stub has already been created. */
4829 stub_entry->target_value = sym_value;
4833 stub_entry = elf32_arm_add_stub (stub_name, section,
4835 if (stub_entry == NULL)
4838 goto error_ret_free_internal;
4841 stub_entry->target_value = sym_value;
4842 stub_entry->target_section = sym_sec;
4843 stub_entry->stub_type = stub_type;
4844 stub_entry->h = hash;
4845 stub_entry->st_type = st_type;
4847 if (sym_name == NULL)
4848 sym_name = "unnamed";
4849 stub_entry->output_name = (char *)
4850 bfd_alloc (htab->stub_bfd,
4851 sizeof (THUMB2ARM_GLUE_ENTRY_NAME)
4852 + strlen (sym_name));
4853 if (stub_entry->output_name == NULL)
4856 goto error_ret_free_internal;
4859 /* For historical reasons, use the existing names for
4860 ARM-to-Thumb and Thumb-to-ARM stubs. */
4861 if ( ((r_type == (unsigned int) R_ARM_THM_CALL)
4862 || (r_type == (unsigned int) R_ARM_THM_JUMP24))
4863 && st_type != STT_ARM_TFUNC)
4864 sprintf (stub_entry->output_name,
4865 THUMB2ARM_GLUE_ENTRY_NAME, sym_name);
4866 else if ( ((r_type == (unsigned int) R_ARM_CALL)
4867 || (r_type == (unsigned int) R_ARM_JUMP24))
4868 && st_type == STT_ARM_TFUNC)
4869 sprintf (stub_entry->output_name,
4870 ARM2THUMB_GLUE_ENTRY_NAME, sym_name);
4872 sprintf (stub_entry->output_name, STUB_ENTRY_NAME,
4875 stub_changed = TRUE;
4879 /* Look for relocations which might trigger Cortex-A8
4881 if (htab->fix_cortex_a8
4882 && (r_type == (unsigned int) R_ARM_THM_JUMP24
4883 || r_type == (unsigned int) R_ARM_THM_JUMP19
4884 || r_type == (unsigned int) R_ARM_THM_CALL
4885 || r_type == (unsigned int) R_ARM_THM_XPC22))
4887 bfd_vma from = section->output_section->vma
4888 + section->output_offset
4891 if ((from & 0xfff) == 0xffe)
4893 /* Found a candidate. Note we haven't checked the
4894 destination is within 4K here: if we do so (and
4895 don't create an entry in a8_relocs) we can't tell
4896 that a branch should have been relocated when
4898 if (num_a8_relocs == a8_reloc_table_size)
4900 a8_reloc_table_size *= 2;
4901 a8_relocs = (struct a8_erratum_reloc *)
4902 bfd_realloc (a8_relocs,
4903 sizeof (struct a8_erratum_reloc)
4904 * a8_reloc_table_size);
4907 a8_relocs[num_a8_relocs].from = from;
4908 a8_relocs[num_a8_relocs].destination = destination;
4909 a8_relocs[num_a8_relocs].r_type = r_type;
4910 a8_relocs[num_a8_relocs].st_type = st_type;
4911 a8_relocs[num_a8_relocs].sym_name = sym_name;
4912 a8_relocs[num_a8_relocs].non_a8_stub = created_stub;
4913 a8_relocs[num_a8_relocs].hash = hash;
4920 /* We're done with the internal relocs, free them. */
4921 if (elf_section_data (section)->relocs == NULL)
4922 free (internal_relocs);
4925 if (htab->fix_cortex_a8)
4927 /* Sort relocs which might apply to Cortex-A8 erratum. */
4928 qsort (a8_relocs, num_a8_relocs,
4929 sizeof (struct a8_erratum_reloc),
4932 /* Scan for branches which might trigger Cortex-A8 erratum. */
4933 if (cortex_a8_erratum_scan (input_bfd, info, &a8_fixes,
4934 &num_a8_fixes, &a8_fix_table_size,
4935 a8_relocs, num_a8_relocs,
4936 prev_num_a8_fixes, &stub_changed)
4938 goto error_ret_free_local;
4942 if (prev_num_a8_fixes != num_a8_fixes)
4943 stub_changed = TRUE;
4948 /* OK, we've added some stubs. Find out the new size of the
4950 for (stub_sec = htab->stub_bfd->sections;
4952 stub_sec = stub_sec->next)
4954 /* Ignore non-stub sections. */
4955 if (!strstr (stub_sec->name, STUB_SUFFIX))
4961 bfd_hash_traverse (&htab->stub_hash_table, arm_size_one_stub, htab);
4963 /* Add Cortex-A8 erratum veneers to stub section sizes too. */
4964 if (htab->fix_cortex_a8)
4965 for (i = 0; i < num_a8_fixes; i++)
4967 stub_sec = elf32_arm_create_or_find_stub_sec (NULL,
4968 a8_fixes[i].section, htab);
4970 if (stub_sec == NULL)
4971 goto error_ret_free_local;
4974 += find_stub_size_and_template (a8_fixes[i].stub_type, NULL,
4979 /* Ask the linker to do its stuff. */
4980 (*htab->layout_sections_again) ();
4983 /* Add stubs for Cortex-A8 erratum fixes now. */
4984 if (htab->fix_cortex_a8)
4986 for (i = 0; i < num_a8_fixes; i++)
4988 struct elf32_arm_stub_hash_entry *stub_entry;
4989 char *stub_name = a8_fixes[i].stub_name;
4990 asection *section = a8_fixes[i].section;
4991 unsigned int section_id = a8_fixes[i].section->id;
4992 asection *link_sec = htab->stub_group[section_id].link_sec;
4993 asection *stub_sec = htab->stub_group[section_id].stub_sec;
4994 const insn_sequence *template_sequence;
4995 int template_size, size = 0;
4997 stub_entry = arm_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4999 if (stub_entry == NULL)
5001 (*_bfd_error_handler) (_("%s: cannot create stub entry %s"),
5007 stub_entry->stub_sec = stub_sec;
5008 stub_entry->stub_offset = 0;
5009 stub_entry->id_sec = link_sec;
5010 stub_entry->stub_type = a8_fixes[i].stub_type;
5011 stub_entry->target_section = a8_fixes[i].section;
5012 stub_entry->target_value = a8_fixes[i].offset;
5013 stub_entry->target_addend = a8_fixes[i].addend;
5014 stub_entry->orig_insn = a8_fixes[i].orig_insn;
5015 stub_entry->st_type = a8_fixes[i].st_type;
5017 size = find_stub_size_and_template (a8_fixes[i].stub_type,
5021 stub_entry->stub_size = size;
5022 stub_entry->stub_template = template_sequence;
5023 stub_entry->stub_template_size = template_size;
5026 /* Stash the Cortex-A8 erratum fix array for use later in
5027 elf32_arm_write_section(). */
5028 htab->a8_erratum_fixes = a8_fixes;
5029 htab->num_a8_erratum_fixes = num_a8_fixes;
5033 htab->a8_erratum_fixes = NULL;
5034 htab->num_a8_erratum_fixes = 0;
5038 error_ret_free_local:
5042 /* Build all the stubs associated with the current output file. The
5043 stubs are kept in a hash table attached to the main linker hash
5044 table. We also set up the .plt entries for statically linked PIC
5045 functions here. This function is called via arm_elf_finish in the
5049 elf32_arm_build_stubs (struct bfd_link_info *info)
5052 struct bfd_hash_table *table;
5053 struct elf32_arm_link_hash_table *htab;
5055 htab = elf32_arm_hash_table (info);
5059 for (stub_sec = htab->stub_bfd->sections;
5061 stub_sec = stub_sec->next)
5065 /* Ignore non-stub sections. */
5066 if (!strstr (stub_sec->name, STUB_SUFFIX))
5069 /* Allocate memory to hold the linker stubs. */
5070 size = stub_sec->size;
5071 stub_sec->contents = (unsigned char *) bfd_zalloc (htab->stub_bfd, size);
5072 if (stub_sec->contents == NULL && size != 0)
5077 /* Build the stubs as directed by the stub hash table. */
5078 table = &htab->stub_hash_table;
5079 bfd_hash_traverse (table, arm_build_one_stub, info);
5080 if (htab->fix_cortex_a8)
5082 /* Place the cortex a8 stubs last. */
5083 htab->fix_cortex_a8 = -1;
5084 bfd_hash_traverse (table, arm_build_one_stub, info);
5090 /* Locate the Thumb encoded calling stub for NAME. */
5092 static struct elf_link_hash_entry *
5093 find_thumb_glue (struct bfd_link_info *link_info,
5095 char **error_message)
5098 struct elf_link_hash_entry *hash;
5099 struct elf32_arm_link_hash_table *hash_table;
5101 /* We need a pointer to the armelf specific hash table. */
5102 hash_table = elf32_arm_hash_table (link_info);
5103 if (hash_table == NULL)
5106 tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
5107 + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
5109 BFD_ASSERT (tmp_name);
5111 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
5113 hash = elf_link_hash_lookup
5114 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
5117 && asprintf (error_message, _("unable to find THUMB glue '%s' for '%s'"),
5118 tmp_name, name) == -1)
5119 *error_message = (char *) bfd_errmsg (bfd_error_system_call);
5126 /* Locate the ARM encoded calling stub for NAME. */
5128 static struct elf_link_hash_entry *
5129 find_arm_glue (struct bfd_link_info *link_info,
5131 char **error_message)
5134 struct elf_link_hash_entry *myh;
5135 struct elf32_arm_link_hash_table *hash_table;
5137 /* We need a pointer to the elfarm specific hash table. */
5138 hash_table = elf32_arm_hash_table (link_info);
5139 if (hash_table == NULL)
5142 tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
5143 + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
5145 BFD_ASSERT (tmp_name);
5147 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
5149 myh = elf_link_hash_lookup
5150 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
5153 && asprintf (error_message, _("unable to find ARM glue '%s' for '%s'"),
5154 tmp_name, name) == -1)
5155 *error_message = (char *) bfd_errmsg (bfd_error_system_call);
5162 /* ARM->Thumb glue (static images):
5166 ldr r12, __func_addr
5169 .word func @ behave as if you saw a ARM_32 reloc.
5176 .word func @ behave as if you saw a ARM_32 reloc.
5178 (relocatable images)
5181 ldr r12, __func_offset
5187 #define ARM2THUMB_STATIC_GLUE_SIZE 12
5188 static const insn32 a2t1_ldr_insn = 0xe59fc000;
5189 static const insn32 a2t2_bx_r12_insn = 0xe12fff1c;
5190 static const insn32 a2t3_func_addr_insn = 0x00000001;
5192 #define ARM2THUMB_V5_STATIC_GLUE_SIZE 8
5193 static const insn32 a2t1v5_ldr_insn = 0xe51ff004;
5194 static const insn32 a2t2v5_func_addr_insn = 0x00000001;
5196 #define ARM2THUMB_PIC_GLUE_SIZE 16
5197 static const insn32 a2t1p_ldr_insn = 0xe59fc004;
5198 static const insn32 a2t2p_add_pc_insn = 0xe08cc00f;
5199 static const insn32 a2t3p_bx_r12_insn = 0xe12fff1c;
5201 /* Thumb->ARM: Thumb->(non-interworking aware) ARM
5205 __func_from_thumb: __func_from_thumb:
5207 nop ldr r6, __func_addr
5217 #define THUMB2ARM_GLUE_SIZE 8
5218 static const insn16 t2a1_bx_pc_insn = 0x4778;
5219 static const insn16 t2a2_noop_insn = 0x46c0;
5220 static const insn32 t2a3_b_insn = 0xea000000;
5222 #define VFP11_ERRATUM_VENEER_SIZE 8
5224 #define ARM_BX_VENEER_SIZE 12
5225 static const insn32 armbx1_tst_insn = 0xe3100001;
5226 static const insn32 armbx2_moveq_insn = 0x01a0f000;
5227 static const insn32 armbx3_bx_insn = 0xe12fff10;
5229 #ifndef ELFARM_NABI_C_INCLUDED
5231 arm_allocate_glue_section_space (bfd * abfd, bfd_size_type size, const char * name)
5234 bfd_byte * contents;
5238 /* Do not include empty glue sections in the output. */
5241 s = bfd_get_section_by_name (abfd, name);
5243 s->flags |= SEC_EXCLUDE;
5248 BFD_ASSERT (abfd != NULL);
5250 s = bfd_get_section_by_name (abfd, name);
5251 BFD_ASSERT (s != NULL);
5253 contents = (bfd_byte *) bfd_alloc (abfd, size);
5255 BFD_ASSERT (s->size == size);
5256 s->contents = contents;
5260 bfd_elf32_arm_allocate_interworking_sections (struct bfd_link_info * info)
5262 struct elf32_arm_link_hash_table * globals;
5264 globals = elf32_arm_hash_table (info);
5265 BFD_ASSERT (globals != NULL);
5267 arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
5268 globals->arm_glue_size,
5269 ARM2THUMB_GLUE_SECTION_NAME);
5271 arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
5272 globals->thumb_glue_size,
5273 THUMB2ARM_GLUE_SECTION_NAME);
5275 arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
5276 globals->vfp11_erratum_glue_size,
5277 VFP11_ERRATUM_VENEER_SECTION_NAME);
5279 arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
5280 globals->bx_glue_size,
5281 ARM_BX_GLUE_SECTION_NAME);
5286 /* Allocate space and symbols for calling a Thumb function from Arm mode.
5287 returns the symbol identifying the stub. */
5289 static struct elf_link_hash_entry *
5290 record_arm_to_thumb_glue (struct bfd_link_info * link_info,
5291 struct elf_link_hash_entry * h)
5293 const char * name = h->root.root.string;
5296 struct elf_link_hash_entry * myh;
5297 struct bfd_link_hash_entry * bh;
5298 struct elf32_arm_link_hash_table * globals;
5302 globals = elf32_arm_hash_table (link_info);
5303 BFD_ASSERT (globals != NULL);
5304 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
5306 s = bfd_get_section_by_name
5307 (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
5309 BFD_ASSERT (s != NULL);
5311 tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
5312 + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
5314 BFD_ASSERT (tmp_name);
5316 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
5318 myh = elf_link_hash_lookup
5319 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
5323 /* We've already seen this guy. */
5328 /* The only trick here is using hash_table->arm_glue_size as the value.
5329 Even though the section isn't allocated yet, this is where we will be
5330 putting it. The +1 on the value marks that the stub has not been
5331 output yet - not that it is a Thumb function. */
5333 val = globals->arm_glue_size + 1;
5334 _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner,
5335 tmp_name, BSF_GLOBAL, s, val,
5336 NULL, TRUE, FALSE, &bh);
5338 myh = (struct elf_link_hash_entry *) bh;
5339 myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
5340 myh->forced_local = 1;
5344 if (link_info->shared || globals->root.is_relocatable_executable
5345 || globals->pic_veneer)
5346 size = ARM2THUMB_PIC_GLUE_SIZE;
5347 else if (globals->use_blx)
5348 size = ARM2THUMB_V5_STATIC_GLUE_SIZE;
5350 size = ARM2THUMB_STATIC_GLUE_SIZE;
5353 globals->arm_glue_size += size;
5358 /* Allocate space for ARMv4 BX veneers. */
5361 record_arm_bx_glue (struct bfd_link_info * link_info, int reg)
5364 struct elf32_arm_link_hash_table *globals;
5366 struct elf_link_hash_entry *myh;
5367 struct bfd_link_hash_entry *bh;
5370 /* BX PC does not need a veneer. */
5374 globals = elf32_arm_hash_table (link_info);
5375 BFD_ASSERT (globals != NULL);
5376 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
5378 /* Check if this veneer has already been allocated. */
5379 if (globals->bx_glue_offset[reg])
5382 s = bfd_get_section_by_name
5383 (globals->bfd_of_glue_owner, ARM_BX_GLUE_SECTION_NAME);
5385 BFD_ASSERT (s != NULL);
5387 /* Add symbol for veneer. */
5389 bfd_malloc ((bfd_size_type) strlen (ARM_BX_GLUE_ENTRY_NAME) + 1);
5391 BFD_ASSERT (tmp_name);
5393 sprintf (tmp_name, ARM_BX_GLUE_ENTRY_NAME, reg);
5395 myh = elf_link_hash_lookup
5396 (&(globals)->root, tmp_name, FALSE, FALSE, FALSE);
5398 BFD_ASSERT (myh == NULL);
5401 val = globals->bx_glue_size;
5402 _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner,
5403 tmp_name, BSF_FUNCTION | BSF_LOCAL, s, val,
5404 NULL, TRUE, FALSE, &bh);
5406 myh = (struct elf_link_hash_entry *) bh;
5407 myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
5408 myh->forced_local = 1;
5410 s->size += ARM_BX_VENEER_SIZE;
5411 globals->bx_glue_offset[reg] = globals->bx_glue_size | 2;
5412 globals->bx_glue_size += ARM_BX_VENEER_SIZE;
5416 /* Add an entry to the code/data map for section SEC. */
5419 elf32_arm_section_map_add (asection *sec, char type, bfd_vma vma)
5421 struct _arm_elf_section_data *sec_data = elf32_arm_section_data (sec);
5422 unsigned int newidx;
5424 if (sec_data->map == NULL)
5426 sec_data->map = (elf32_arm_section_map *)
5427 bfd_malloc (sizeof (elf32_arm_section_map));
5428 sec_data->mapcount = 0;
5429 sec_data->mapsize = 1;
5432 newidx = sec_data->mapcount++;
5434 if (sec_data->mapcount > sec_data->mapsize)
5436 sec_data->mapsize *= 2;
5437 sec_data->map = (elf32_arm_section_map *)
5438 bfd_realloc_or_free (sec_data->map, sec_data->mapsize
5439 * sizeof (elf32_arm_section_map));
5444 sec_data->map[newidx].vma = vma;
5445 sec_data->map[newidx].type = type;
5450 /* Record information about a VFP11 denorm-erratum veneer. Only ARM-mode
5451 veneers are handled for now. */
5454 record_vfp11_erratum_veneer (struct bfd_link_info *link_info,
5455 elf32_vfp11_erratum_list *branch,
5457 asection *branch_sec,
5458 unsigned int offset)
5461 struct elf32_arm_link_hash_table *hash_table;
5463 struct elf_link_hash_entry *myh;
5464 struct bfd_link_hash_entry *bh;
5466 struct _arm_elf_section_data *sec_data;
5467 elf32_vfp11_erratum_list *newerr;
5469 hash_table = elf32_arm_hash_table (link_info);
5470 BFD_ASSERT (hash_table != NULL);
5471 BFD_ASSERT (hash_table->bfd_of_glue_owner != NULL);
5473 s = bfd_get_section_by_name
5474 (hash_table->bfd_of_glue_owner, VFP11_ERRATUM_VENEER_SECTION_NAME);
5476 sec_data = elf32_arm_section_data (s);
5478 BFD_ASSERT (s != NULL);
5480 tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen
5481 (VFP11_ERRATUM_VENEER_ENTRY_NAME) + 10);
5483 BFD_ASSERT (tmp_name);
5485 sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME,
5486 hash_table->num_vfp11_fixes);
5488 myh = elf_link_hash_lookup
5489 (&(hash_table)->root, tmp_name, FALSE, FALSE, FALSE);
5491 BFD_ASSERT (myh == NULL);
5494 val = hash_table->vfp11_erratum_glue_size;
5495 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
5496 tmp_name, BSF_FUNCTION | BSF_LOCAL, s, val,
5497 NULL, TRUE, FALSE, &bh);
5499 myh = (struct elf_link_hash_entry *) bh;
5500 myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
5501 myh->forced_local = 1;
5503 /* Link veneer back to calling location. */
5504 sec_data->erratumcount += 1;
5505 newerr = (elf32_vfp11_erratum_list *)
5506 bfd_zmalloc (sizeof (elf32_vfp11_erratum_list));
5508 newerr->type = VFP11_ERRATUM_ARM_VENEER;
5510 newerr->u.v.branch = branch;
5511 newerr->u.v.id = hash_table->num_vfp11_fixes;
5512 branch->u.b.veneer = newerr;
5514 newerr->next = sec_data->erratumlist;
5515 sec_data->erratumlist = newerr;
5517 /* A symbol for the return from the veneer. */
5518 sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME "_r",
5519 hash_table->num_vfp11_fixes);
5521 myh = elf_link_hash_lookup
5522 (&(hash_table)->root, tmp_name, FALSE, FALSE, FALSE);
5529 _bfd_generic_link_add_one_symbol (link_info, branch_bfd, tmp_name, BSF_LOCAL,
5530 branch_sec, val, NULL, TRUE, FALSE, &bh);
5532 myh = (struct elf_link_hash_entry *) bh;
5533 myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
5534 myh->forced_local = 1;
5538 /* Generate a mapping symbol for the veneer section, and explicitly add an
5539 entry for that symbol to the code/data map for the section. */
5540 if (hash_table->vfp11_erratum_glue_size == 0)
5543 /* FIXME: Creates an ARM symbol. Thumb mode will need attention if it
5544 ever requires this erratum fix. */
5545 _bfd_generic_link_add_one_symbol (link_info,
5546 hash_table->bfd_of_glue_owner, "$a",
5547 BSF_LOCAL, s, 0, NULL,
5550 myh = (struct elf_link_hash_entry *) bh;
5551 myh->type = ELF_ST_INFO (STB_LOCAL, STT_NOTYPE);
5552 myh->forced_local = 1;
5554 /* The elf32_arm_init_maps function only cares about symbols from input
5555 BFDs. We must make a note of this generated mapping symbol
5556 ourselves so that code byteswapping works properly in
5557 elf32_arm_write_section. */
5558 elf32_arm_section_map_add (s, 'a', 0);
5561 s->size += VFP11_ERRATUM_VENEER_SIZE;
5562 hash_table->vfp11_erratum_glue_size += VFP11_ERRATUM_VENEER_SIZE;
5563 hash_table->num_vfp11_fixes++;
5565 /* The offset of the veneer. */
5569 #define ARM_GLUE_SECTION_FLAGS \
5570 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE \
5571 | SEC_READONLY | SEC_LINKER_CREATED)
5573 /* Create a fake section for use by the ARM backend of the linker. */
5576 arm_make_glue_section (bfd * abfd, const char * name)
5580 sec = bfd_get_section_by_name (abfd, name);
5585 sec = bfd_make_section_with_flags (abfd, name, ARM_GLUE_SECTION_FLAGS);
5588 || !bfd_set_section_alignment (abfd, sec, 2))
5591 /* Set the gc mark to prevent the section from being removed by garbage
5592 collection, despite the fact that no relocs refer to this section. */
5598 /* Add the glue sections to ABFD. This function is called from the
5599 linker scripts in ld/emultempl/{armelf}.em. */
5602 bfd_elf32_arm_add_glue_sections_to_bfd (bfd *abfd,
5603 struct bfd_link_info *info)
5605 /* If we are only performing a partial
5606 link do not bother adding the glue. */
5607 if (info->relocatable)
5610 return arm_make_glue_section (abfd, ARM2THUMB_GLUE_SECTION_NAME)
5611 && arm_make_glue_section (abfd, THUMB2ARM_GLUE_SECTION_NAME)
5612 && arm_make_glue_section (abfd, VFP11_ERRATUM_VENEER_SECTION_NAME)
5613 && arm_make_glue_section (abfd, ARM_BX_GLUE_SECTION_NAME);
5616 /* Select a BFD to be used to hold the sections used by the glue code.
5617 This function is called from the linker scripts in ld/emultempl/
5621 bfd_elf32_arm_get_bfd_for_interworking (bfd *abfd, struct bfd_link_info *info)
5623 struct elf32_arm_link_hash_table *globals;
5625 /* If we are only performing a partial link
5626 do not bother getting a bfd to hold the glue. */
5627 if (info->relocatable)
5630 /* Make sure we don't attach the glue sections to a dynamic object. */
5631 BFD_ASSERT (!(abfd->flags & DYNAMIC));
5633 globals = elf32_arm_hash_table (info);
5634 BFD_ASSERT (globals != NULL);
5636 if (globals->bfd_of_glue_owner != NULL)
5639 /* Save the bfd for later use. */
5640 globals->bfd_of_glue_owner = abfd;
5646 check_use_blx (struct elf32_arm_link_hash_table *globals)
5648 if (bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
5650 globals->use_blx = 1;
5654 bfd_elf32_arm_process_before_allocation (bfd *abfd,
5655 struct bfd_link_info *link_info)
5657 Elf_Internal_Shdr *symtab_hdr;
5658 Elf_Internal_Rela *internal_relocs = NULL;
5659 Elf_Internal_Rela *irel, *irelend;
5660 bfd_byte *contents = NULL;
5663 struct elf32_arm_link_hash_table *globals;
5665 /* If we are only performing a partial link do not bother
5666 to construct any glue. */
5667 if (link_info->relocatable)
5670 /* Here we have a bfd that is to be included on the link. We have a
5671 hook to do reloc rummaging, before section sizes are nailed down. */
5672 globals = elf32_arm_hash_table (link_info);
5673 BFD_ASSERT (globals != NULL);
5675 check_use_blx (globals);
5677 if (globals->byteswap_code && !bfd_big_endian (abfd))
5679 _bfd_error_handler (_("%B: BE8 images only valid in big-endian mode."),
5684 /* PR 5398: If we have not decided to include any loadable sections in
5685 the output then we will not have a glue owner bfd. This is OK, it
5686 just means that there is nothing else for us to do here. */
5687 if (globals->bfd_of_glue_owner == NULL)
5690 /* Rummage around all the relocs and map the glue vectors. */
5691 sec = abfd->sections;
5696 for (; sec != NULL; sec = sec->next)
5698 if (sec->reloc_count == 0)
5701 if ((sec->flags & SEC_EXCLUDE) != 0)
5704 symtab_hdr = & elf_symtab_hdr (abfd);
5706 /* Load the relocs. */
5708 = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, FALSE);
5710 if (internal_relocs == NULL)
5713 irelend = internal_relocs + sec->reloc_count;
5714 for (irel = internal_relocs; irel < irelend; irel++)
5717 unsigned long r_index;
5719 struct elf_link_hash_entry *h;
5721 r_type = ELF32_R_TYPE (irel->r_info);
5722 r_index = ELF32_R_SYM (irel->r_info);
5724 /* These are the only relocation types we care about. */
5725 if ( r_type != R_ARM_PC24
5726 && (r_type != R_ARM_V4BX || globals->fix_v4bx < 2))
5729 /* Get the section contents if we haven't done so already. */
5730 if (contents == NULL)
5732 /* Get cached copy if it exists. */
5733 if (elf_section_data (sec)->this_hdr.contents != NULL)
5734 contents = elf_section_data (sec)->this_hdr.contents;
5737 /* Go get them off disk. */
5738 if (! bfd_malloc_and_get_section (abfd, sec, &contents))
5743 if (r_type == R_ARM_V4BX)
5747 reg = bfd_get_32 (abfd, contents + irel->r_offset) & 0xf;
5748 record_arm_bx_glue (link_info, reg);
5752 /* If the relocation is not against a symbol it cannot concern us. */
5755 /* We don't care about local symbols. */
5756 if (r_index < symtab_hdr->sh_info)
5759 /* This is an external symbol. */
5760 r_index -= symtab_hdr->sh_info;
5761 h = (struct elf_link_hash_entry *)
5762 elf_sym_hashes (abfd)[r_index];
5764 /* If the relocation is against a static symbol it must be within
5765 the current section and so cannot be a cross ARM/Thumb relocation. */
5769 /* If the call will go through a PLT entry then we do not need
5771 if (globals->root.splt != NULL && h->plt.offset != (bfd_vma) -1)
5777 /* This one is a call from arm code. We need to look up
5778 the target of the call. If it is a thumb target, we
5780 if (ELF_ST_TYPE (h->type) == STT_ARM_TFUNC)
5781 record_arm_to_thumb_glue (link_info, h);
5789 if (contents != NULL
5790 && elf_section_data (sec)->this_hdr.contents != contents)
5794 if (internal_relocs != NULL
5795 && elf_section_data (sec)->relocs != internal_relocs)
5796 free (internal_relocs);
5797 internal_relocs = NULL;
5803 if (contents != NULL
5804 && elf_section_data (sec)->this_hdr.contents != contents)
5806 if (internal_relocs != NULL
5807 && elf_section_data (sec)->relocs != internal_relocs)
5808 free (internal_relocs);
5815 /* Initialise maps of ARM/Thumb/data for input BFDs. */
5818 bfd_elf32_arm_init_maps (bfd *abfd)
5820 Elf_Internal_Sym *isymbuf;
5821 Elf_Internal_Shdr *hdr;
5822 unsigned int i, localsyms;
5824 /* PR 7093: Make sure that we are dealing with an arm elf binary. */
5825 if (! is_arm_elf (abfd))
5828 if ((abfd->flags & DYNAMIC) != 0)
5831 hdr = & elf_symtab_hdr (abfd);
5832 localsyms = hdr->sh_info;
5834 /* Obtain a buffer full of symbols for this BFD. The hdr->sh_info field
5835 should contain the number of local symbols, which should come before any
5836 global symbols. Mapping symbols are always local. */
5837 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, localsyms, 0, NULL, NULL,
5840 /* No internal symbols read? Skip this BFD. */
5841 if (isymbuf == NULL)
5844 for (i = 0; i < localsyms; i++)
5846 Elf_Internal_Sym *isym = &isymbuf[i];
5847 asection *sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
5851 && ELF_ST_BIND (isym->st_info) == STB_LOCAL)
5853 name = bfd_elf_string_from_elf_section (abfd,
5854 hdr->sh_link, isym->st_name);
5856 if (bfd_is_arm_special_symbol_name (name,
5857 BFD_ARM_SPECIAL_SYM_TYPE_MAP))
5858 elf32_arm_section_map_add (sec, name[1], isym->st_value);
5864 /* Auto-select enabling of Cortex-A8 erratum fix if the user didn't explicitly
5865 say what they wanted. */
5868 bfd_elf32_arm_set_cortex_a8_fix (bfd *obfd, struct bfd_link_info *link_info)
5870 struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
5871 obj_attribute *out_attr = elf_known_obj_attributes_proc (obfd);
5873 if (globals == NULL)
5876 if (globals->fix_cortex_a8 == -1)
5878 /* Turn on Cortex-A8 erratum workaround for ARMv7-A. */
5879 if (out_attr[Tag_CPU_arch].i == TAG_CPU_ARCH_V7
5880 && (out_attr[Tag_CPU_arch_profile].i == 'A'
5881 || out_attr[Tag_CPU_arch_profile].i == 0))
5882 globals->fix_cortex_a8 = 1;
5884 globals->fix_cortex_a8 = 0;
5890 bfd_elf32_arm_set_vfp11_fix (bfd *obfd, struct bfd_link_info *link_info)
5892 struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
5893 obj_attribute *out_attr = elf_known_obj_attributes_proc (obfd);
5895 if (globals == NULL)
5897 /* We assume that ARMv7+ does not need the VFP11 denorm erratum fix. */
5898 if (out_attr[Tag_CPU_arch].i >= TAG_CPU_ARCH_V7)
5900 switch (globals->vfp11_fix)
5902 case BFD_ARM_VFP11_FIX_DEFAULT:
5903 case BFD_ARM_VFP11_FIX_NONE:
5904 globals->vfp11_fix = BFD_ARM_VFP11_FIX_NONE;
5908 /* Give a warning, but do as the user requests anyway. */
5909 (*_bfd_error_handler) (_("%B: warning: selected VFP11 erratum "
5910 "workaround is not necessary for target architecture"), obfd);
5913 else if (globals->vfp11_fix == BFD_ARM_VFP11_FIX_DEFAULT)
5914 /* For earlier architectures, we might need the workaround, but do not
5915 enable it by default. If users is running with broken hardware, they
5916 must enable the erratum fix explicitly. */
5917 globals->vfp11_fix = BFD_ARM_VFP11_FIX_NONE;
5921 enum bfd_arm_vfp11_pipe
5929 /* Return a VFP register number. This is encoded as RX:X for single-precision
5930 registers, or X:RX for double-precision registers, where RX is the group of
5931 four bits in the instruction encoding and X is the single extension bit.
5932 RX and X fields are specified using their lowest (starting) bit. The return
5935 0...31: single-precision registers s0...s31
5936 32...63: double-precision registers d0...d31.
5938 Although X should be zero for VFP11 (encoding d0...d15 only), we might
5939 encounter VFP3 instructions, so we allow the full range for DP registers. */
5942 bfd_arm_vfp11_regno (unsigned int insn, bfd_boolean is_double, unsigned int rx,
5946 return (((insn >> rx) & 0xf) | (((insn >> x) & 1) << 4)) + 32;
5948 return (((insn >> rx) & 0xf) << 1) | ((insn >> x) & 1);
5951 /* Set bits in *WMASK according to a register number REG as encoded by
5952 bfd_arm_vfp11_regno(). Ignore d16-d31. */
5955 bfd_arm_vfp11_write_mask (unsigned int *wmask, unsigned int reg)
5960 *wmask |= 3 << ((reg - 32) * 2);
5963 /* Return TRUE if WMASK overwrites anything in REGS. */
5966 bfd_arm_vfp11_antidependency (unsigned int wmask, int *regs, int numregs)
5970 for (i = 0; i < numregs; i++)
5972 unsigned int reg = regs[i];
5974 if (reg < 32 && (wmask & (1 << reg)) != 0)
5982 if ((wmask & (3 << (reg * 2))) != 0)
5989 /* In this function, we're interested in two things: finding input registers
5990 for VFP data-processing instructions, and finding the set of registers which
5991 arbitrary VFP instructions may write to. We use a 32-bit unsigned int to
5992 hold the written set, so FLDM etc. are easy to deal with (we're only
5993 interested in 32 SP registers or 16 dp registers, due to the VFP version
5994 implemented by the chip in question). DP registers are marked by setting
5995 both SP registers in the write mask). */
5997 static enum bfd_arm_vfp11_pipe
5998 bfd_arm_vfp11_insn_decode (unsigned int insn, unsigned int *destmask, int *regs,
6001 enum bfd_arm_vfp11_pipe vpipe = VFP11_BAD;
6002 bfd_boolean is_double = ((insn & 0xf00) == 0xb00) ? 1 : 0;
6004 if ((insn & 0x0f000e10) == 0x0e000a00) /* A data-processing insn. */
6007 unsigned int fd = bfd_arm_vfp11_regno (insn, is_double, 12, 22);
6008 unsigned int fm = bfd_arm_vfp11_regno (insn, is_double, 0, 5);
6010 pqrs = ((insn & 0x00800000) >> 20)
6011 | ((insn & 0x00300000) >> 19)
6012 | ((insn & 0x00000040) >> 6);
6016 case 0: /* fmac[sd]. */
6017 case 1: /* fnmac[sd]. */
6018 case 2: /* fmsc[sd]. */
6019 case 3: /* fnmsc[sd]. */
6021 bfd_arm_vfp11_write_mask (destmask, fd);
6023 regs[1] = bfd_arm_vfp11_regno (insn, is_double, 16, 7); /* Fn. */
6028 case 4: /* fmul[sd]. */
6029 case 5: /* fnmul[sd]. */
6030 case 6: /* fadd[sd]. */
6031 case 7: /* fsub[sd]. */
6035 case 8: /* fdiv[sd]. */
6038 bfd_arm_vfp11_write_mask (destmask, fd);
6039 regs[0] = bfd_arm_vfp11_regno (insn, is_double, 16, 7); /* Fn. */
6044 case 15: /* extended opcode. */
6046 unsigned int extn = ((insn >> 15) & 0x1e)
6047 | ((insn >> 7) & 1);
6051 case 0: /* fcpy[sd]. */
6052 case 1: /* fabs[sd]. */
6053 case 2: /* fneg[sd]. */
6054 case 8: /* fcmp[sd]. */
6055 case 9: /* fcmpe[sd]. */
6056 case 10: /* fcmpz[sd]. */
6057 case 11: /* fcmpez[sd]. */
6058 case 16: /* fuito[sd]. */
6059 case 17: /* fsito[sd]. */
6060 case 24: /* ftoui[sd]. */
6061 case 25: /* ftouiz[sd]. */
6062 case 26: /* ftosi[sd]. */
6063 case 27: /* ftosiz[sd]. */
6064 /* These instructions will not bounce due to underflow. */
6069 case 3: /* fsqrt[sd]. */
6070 /* fsqrt cannot underflow, but it can (perhaps) overwrite
6071 registers to cause the erratum in previous instructions. */
6072 bfd_arm_vfp11_write_mask (destmask, fd);
6076 case 15: /* fcvt{ds,sd}. */
6080 bfd_arm_vfp11_write_mask (destmask, fd);
6082 /* Only FCVTSD can underflow. */
6083 if ((insn & 0x100) != 0)
6102 /* Two-register transfer. */
6103 else if ((insn & 0x0fe00ed0) == 0x0c400a10)
6105 unsigned int fm = bfd_arm_vfp11_regno (insn, is_double, 0, 5);
6107 if ((insn & 0x100000) == 0)
6110 bfd_arm_vfp11_write_mask (destmask, fm);
6113 bfd_arm_vfp11_write_mask (destmask, fm);
6114 bfd_arm_vfp11_write_mask (destmask, fm + 1);
6120 else if ((insn & 0x0e100e00) == 0x0c100a00) /* A load insn. */
6122 int fd = bfd_arm_vfp11_regno (insn, is_double, 12, 22);
6123 unsigned int puw = ((insn >> 21) & 0x1) | (((insn >> 23) & 3) << 1);
6127 case 0: /* Two-reg transfer. We should catch these above. */
6130 case 2: /* fldm[sdx]. */
6134 unsigned int i, offset = insn & 0xff;
6139 for (i = fd; i < fd + offset; i++)
6140 bfd_arm_vfp11_write_mask (destmask, i);
6144 case 4: /* fld[sd]. */
6146 bfd_arm_vfp11_write_mask (destmask, fd);
6155 /* Single-register transfer. Note L==0. */
6156 else if ((insn & 0x0f100e10) == 0x0e000a10)
6158 unsigned int opcode = (insn >> 21) & 7;
6159 unsigned int fn = bfd_arm_vfp11_regno (insn, is_double, 16, 7);
6163 case 0: /* fmsr/fmdlr. */
6164 case 1: /* fmdhr. */
6165 /* Mark fmdhr and fmdlr as writing to the whole of the DP
6166 destination register. I don't know if this is exactly right,
6167 but it is the conservative choice. */
6168 bfd_arm_vfp11_write_mask (destmask, fn);
6182 static int elf32_arm_compare_mapping (const void * a, const void * b);
6185 /* Look for potentially-troublesome code sequences which might trigger the
6186 VFP11 denormal/antidependency erratum. See, e.g., the ARM1136 errata sheet
6187 (available from ARM) for details of the erratum. A short version is
6188 described in ld.texinfo. */
6191 bfd_elf32_arm_vfp11_erratum_scan (bfd *abfd, struct bfd_link_info *link_info)
6194 bfd_byte *contents = NULL;
6196 int regs[3], numregs = 0;
6197 struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
6198 int use_vector = (globals->vfp11_fix == BFD_ARM_VFP11_FIX_VECTOR);
6200 if (globals == NULL)
6203 /* We use a simple FSM to match troublesome VFP11 instruction sequences.
6204 The states transition as follows:
6206 0 -> 1 (vector) or 0 -> 2 (scalar)
6207 A VFP FMAC-pipeline instruction has been seen. Fill
6208 regs[0]..regs[numregs-1] with its input operands. Remember this
6209 instruction in 'first_fmac'.
6212 Any instruction, except for a VFP instruction which overwrites
6217 A VFP instruction has been seen which overwrites any of regs[*].
6218 We must make a veneer! Reset state to 0 before examining next
6222 If we fail to match anything in state 2, reset to state 0 and reset
6223 the instruction pointer to the instruction after 'first_fmac'.
6225 If the VFP11 vector mode is in use, there must be at least two unrelated
6226 instructions between anti-dependent VFP11 instructions to properly avoid
6227 triggering the erratum, hence the use of the extra state 1. */
6229 /* If we are only performing a partial link do not bother
6230 to construct any glue. */
6231 if (link_info->relocatable)
6234 /* Skip if this bfd does not correspond to an ELF image. */
6235 if (! is_arm_elf (abfd))
6238 /* We should have chosen a fix type by the time we get here. */
6239 BFD_ASSERT (globals->vfp11_fix != BFD_ARM_VFP11_FIX_DEFAULT);
6241 if (globals->vfp11_fix == BFD_ARM_VFP11_FIX_NONE)
6244 /* Skip this BFD if it corresponds to an executable or dynamic object. */
6245 if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
6248 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6250 unsigned int i, span, first_fmac = 0, veneer_of_insn = 0;
6251 struct _arm_elf_section_data *sec_data;
6253 /* If we don't have executable progbits, we're not interested in this
6254 section. Also skip if section is to be excluded. */
6255 if (elf_section_type (sec) != SHT_PROGBITS
6256 || (elf_section_flags (sec) & SHF_EXECINSTR) == 0
6257 || (sec->flags & SEC_EXCLUDE) != 0
6258 || sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS
6259 || sec->output_section == bfd_abs_section_ptr
6260 || strcmp (sec->name, VFP11_ERRATUM_VENEER_SECTION_NAME) == 0)
6263 sec_data = elf32_arm_section_data (sec);
6265 if (sec_data->mapcount == 0)
6268 if (elf_section_data (sec)->this_hdr.contents != NULL)
6269 contents = elf_section_data (sec)->this_hdr.contents;
6270 else if (! bfd_malloc_and_get_section (abfd, sec, &contents))
6273 qsort (sec_data->map, sec_data->mapcount, sizeof (elf32_arm_section_map),
6274 elf32_arm_compare_mapping);
6276 for (span = 0; span < sec_data->mapcount; span++)
6278 unsigned int span_start = sec_data->map[span].vma;
6279 unsigned int span_end = (span == sec_data->mapcount - 1)
6280 ? sec->size : sec_data->map[span + 1].vma;
6281 char span_type = sec_data->map[span].type;
6283 /* FIXME: Only ARM mode is supported at present. We may need to
6284 support Thumb-2 mode also at some point. */
6285 if (span_type != 'a')
6288 for (i = span_start; i < span_end;)
6290 unsigned int next_i = i + 4;
6291 unsigned int insn = bfd_big_endian (abfd)
6292 ? (contents[i] << 24)
6293 | (contents[i + 1] << 16)
6294 | (contents[i + 2] << 8)
6296 : (contents[i + 3] << 24)
6297 | (contents[i + 2] << 16)
6298 | (contents[i + 1] << 8)
6300 unsigned int writemask = 0;
6301 enum bfd_arm_vfp11_pipe vpipe;
6306 vpipe = bfd_arm_vfp11_insn_decode (insn, &writemask, regs,
6308 /* I'm assuming the VFP11 erratum can trigger with denorm
6309 operands on either the FMAC or the DS pipeline. This might
6310 lead to slightly overenthusiastic veneer insertion. */
6311 if (vpipe == VFP11_FMAC || vpipe == VFP11_DS)
6313 state = use_vector ? 1 : 2;
6315 veneer_of_insn = insn;
6321 int other_regs[3], other_numregs;
6322 vpipe = bfd_arm_vfp11_insn_decode (insn, &writemask,
6325 if (vpipe != VFP11_BAD
6326 && bfd_arm_vfp11_antidependency (writemask, regs,
6336 int other_regs[3], other_numregs;
6337 vpipe = bfd_arm_vfp11_insn_decode (insn, &writemask,
6340 if (vpipe != VFP11_BAD
6341 && bfd_arm_vfp11_antidependency (writemask, regs,
6347 next_i = first_fmac + 4;
6353 abort (); /* Should be unreachable. */
6358 elf32_vfp11_erratum_list *newerr =(elf32_vfp11_erratum_list *)
6359 bfd_zmalloc (sizeof (elf32_vfp11_erratum_list));
6361 elf32_arm_section_data (sec)->erratumcount += 1;
6363 newerr->u.b.vfp_insn = veneer_of_insn;
6368 newerr->type = VFP11_ERRATUM_BRANCH_TO_ARM_VENEER;
6375 record_vfp11_erratum_veneer (link_info, newerr, abfd, sec,
6380 newerr->next = sec_data->erratumlist;
6381 sec_data->erratumlist = newerr;
6390 if (contents != NULL
6391 && elf_section_data (sec)->this_hdr.contents != contents)
6399 if (contents != NULL
6400 && elf_section_data (sec)->this_hdr.contents != contents)
6406 /* Find virtual-memory addresses for VFP11 erratum veneers and return locations
6407 after sections have been laid out, using specially-named symbols. */
6410 bfd_elf32_arm_vfp11_fix_veneer_locations (bfd *abfd,
6411 struct bfd_link_info *link_info)
6414 struct elf32_arm_link_hash_table *globals;
6417 if (link_info->relocatable)
6420 /* Skip if this bfd does not correspond to an ELF image. */
6421 if (! is_arm_elf (abfd))
6424 globals = elf32_arm_hash_table (link_info);
6425 if (globals == NULL)
6428 tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen
6429 (VFP11_ERRATUM_VENEER_ENTRY_NAME) + 10);
6431 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6433 struct _arm_elf_section_data *sec_data = elf32_arm_section_data (sec);
6434 elf32_vfp11_erratum_list *errnode = sec_data->erratumlist;
6436 for (; errnode != NULL; errnode = errnode->next)
6438 struct elf_link_hash_entry *myh;
6441 switch (errnode->type)
6443 case VFP11_ERRATUM_BRANCH_TO_ARM_VENEER:
6444 case VFP11_ERRATUM_BRANCH_TO_THUMB_VENEER:
6445 /* Find veneer symbol. */
6446 sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME,
6447 errnode->u.b.veneer->u.v.id);
6449 myh = elf_link_hash_lookup
6450 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
6453 (*_bfd_error_handler) (_("%B: unable to find VFP11 veneer "
6454 "`%s'"), abfd, tmp_name);
6456 vma = myh->root.u.def.section->output_section->vma
6457 + myh->root.u.def.section->output_offset
6458 + myh->root.u.def.value;
6460 errnode->u.b.veneer->vma = vma;
6463 case VFP11_ERRATUM_ARM_VENEER:
6464 case VFP11_ERRATUM_THUMB_VENEER:
6465 /* Find return location. */
6466 sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME "_r",
6469 myh = elf_link_hash_lookup
6470 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
6473 (*_bfd_error_handler) (_("%B: unable to find VFP11 veneer "
6474 "`%s'"), abfd, tmp_name);
6476 vma = myh->root.u.def.section->output_section->vma
6477 + myh->root.u.def.section->output_offset
6478 + myh->root.u.def.value;
6480 errnode->u.v.branch->vma = vma;
6493 /* Set target relocation values needed during linking. */
6496 bfd_elf32_arm_set_target_relocs (struct bfd *output_bfd,
6497 struct bfd_link_info *link_info,
6499 char * target2_type,
6502 bfd_arm_vfp11_fix vfp11_fix,
6503 int no_enum_warn, int no_wchar_warn,
6504 int pic_veneer, int fix_cortex_a8)
6506 struct elf32_arm_link_hash_table *globals;
6508 globals = elf32_arm_hash_table (link_info);
6509 if (globals == NULL)
6512 globals->target1_is_rel = target1_is_rel;
6513 if (strcmp (target2_type, "rel") == 0)
6514 globals->target2_reloc = R_ARM_REL32;
6515 else if (strcmp (target2_type, "abs") == 0)
6516 globals->target2_reloc = R_ARM_ABS32;
6517 else if (strcmp (target2_type, "got-rel") == 0)
6518 globals->target2_reloc = R_ARM_GOT_PREL;
6521 _bfd_error_handler (_("Invalid TARGET2 relocation type '%s'."),
6524 globals->fix_v4bx = fix_v4bx;
6525 globals->use_blx |= use_blx;
6526 globals->vfp11_fix = vfp11_fix;
6527 globals->pic_veneer = pic_veneer;
6528 globals->fix_cortex_a8 = fix_cortex_a8;
6530 BFD_ASSERT (is_arm_elf (output_bfd));
6531 elf_arm_tdata (output_bfd)->no_enum_size_warning = no_enum_warn;
6532 elf_arm_tdata (output_bfd)->no_wchar_size_warning = no_wchar_warn;
6535 /* Replace the target offset of a Thumb bl or b.w instruction. */
6538 insert_thumb_branch (bfd *abfd, long int offset, bfd_byte *insn)
6544 BFD_ASSERT ((offset & 1) == 0);
6546 upper = bfd_get_16 (abfd, insn);
6547 lower = bfd_get_16 (abfd, insn + 2);
6548 reloc_sign = (offset < 0) ? 1 : 0;
6549 upper = (upper & ~(bfd_vma) 0x7ff)
6550 | ((offset >> 12) & 0x3ff)
6551 | (reloc_sign << 10);
6552 lower = (lower & ~(bfd_vma) 0x2fff)
6553 | (((!((offset >> 23) & 1)) ^ reloc_sign) << 13)
6554 | (((!((offset >> 22) & 1)) ^ reloc_sign) << 11)
6555 | ((offset >> 1) & 0x7ff);
6556 bfd_put_16 (abfd, upper, insn);
6557 bfd_put_16 (abfd, lower, insn + 2);
6560 /* Thumb code calling an ARM function. */
6563 elf32_thumb_to_arm_stub (struct bfd_link_info * info,
6567 asection * input_section,
6568 bfd_byte * hit_data,
6571 bfd_signed_vma addend,
6573 char **error_message)
6577 long int ret_offset;
6578 struct elf_link_hash_entry * myh;
6579 struct elf32_arm_link_hash_table * globals;
6581 myh = find_thumb_glue (info, name, error_message);
6585 globals = elf32_arm_hash_table (info);
6586 BFD_ASSERT (globals != NULL);
6587 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
6589 my_offset = myh->root.u.def.value;
6591 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
6592 THUMB2ARM_GLUE_SECTION_NAME);
6594 BFD_ASSERT (s != NULL);
6595 BFD_ASSERT (s->contents != NULL);
6596 BFD_ASSERT (s->output_section != NULL);
6598 if ((my_offset & 0x01) == 0x01)
6601 && sym_sec->owner != NULL
6602 && !INTERWORK_FLAG (sym_sec->owner))
6604 (*_bfd_error_handler)
6605 (_("%B(%s): warning: interworking not enabled.\n"
6606 " first occurrence: %B: thumb call to arm"),
6607 sym_sec->owner, input_bfd, name);
6613 myh->root.u.def.value = my_offset;
6615 put_thumb_insn (globals, output_bfd, (bfd_vma) t2a1_bx_pc_insn,
6616 s->contents + my_offset);
6618 put_thumb_insn (globals, output_bfd, (bfd_vma) t2a2_noop_insn,
6619 s->contents + my_offset + 2);
6622 /* Address of destination of the stub. */
6623 ((bfd_signed_vma) val)
6625 /* Offset from the start of the current section
6626 to the start of the stubs. */
6628 /* Offset of the start of this stub from the start of the stubs. */
6630 /* Address of the start of the current section. */
6631 + s->output_section->vma)
6632 /* The branch instruction is 4 bytes into the stub. */
6634 /* ARM branches work from the pc of the instruction + 8. */
6637 put_arm_insn (globals, output_bfd,
6638 (bfd_vma) t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
6639 s->contents + my_offset + 4);
6642 BFD_ASSERT (my_offset <= globals->thumb_glue_size);
6644 /* Now go back and fix up the original BL insn to point to here. */
6646 /* Address of where the stub is located. */
6647 (s->output_section->vma + s->output_offset + my_offset)
6648 /* Address of where the BL is located. */
6649 - (input_section->output_section->vma + input_section->output_offset
6651 /* Addend in the relocation. */
6653 /* Biassing for PC-relative addressing. */
6656 insert_thumb_branch (input_bfd, ret_offset, hit_data - input_section->vma);
6661 /* Populate an Arm to Thumb stub. Returns the stub symbol. */
6663 static struct elf_link_hash_entry *
6664 elf32_arm_create_thumb_stub (struct bfd_link_info * info,
6671 char ** error_message)
6674 long int ret_offset;
6675 struct elf_link_hash_entry * myh;
6676 struct elf32_arm_link_hash_table * globals;
6678 myh = find_arm_glue (info, name, error_message);
6682 globals = elf32_arm_hash_table (info);
6683 BFD_ASSERT (globals != NULL);
6684 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
6686 my_offset = myh->root.u.def.value;
6688 if ((my_offset & 0x01) == 0x01)
6691 && sym_sec->owner != NULL
6692 && !INTERWORK_FLAG (sym_sec->owner))
6694 (*_bfd_error_handler)
6695 (_("%B(%s): warning: interworking not enabled.\n"
6696 " first occurrence: %B: arm call to thumb"),
6697 sym_sec->owner, input_bfd, name);
6701 myh->root.u.def.value = my_offset;
6703 if (info->shared || globals->root.is_relocatable_executable
6704 || globals->pic_veneer)
6706 /* For relocatable objects we can't use absolute addresses,
6707 so construct the address from a relative offset. */
6708 /* TODO: If the offset is small it's probably worth
6709 constructing the address with adds. */
6710 put_arm_insn (globals, output_bfd, (bfd_vma) a2t1p_ldr_insn,
6711 s->contents + my_offset);
6712 put_arm_insn (globals, output_bfd, (bfd_vma) a2t2p_add_pc_insn,
6713 s->contents + my_offset + 4);
6714 put_arm_insn (globals, output_bfd, (bfd_vma) a2t3p_bx_r12_insn,
6715 s->contents + my_offset + 8);
6716 /* Adjust the offset by 4 for the position of the add,
6717 and 8 for the pipeline offset. */
6718 ret_offset = (val - (s->output_offset
6719 + s->output_section->vma
6722 bfd_put_32 (output_bfd, ret_offset,
6723 s->contents + my_offset + 12);
6725 else if (globals->use_blx)
6727 put_arm_insn (globals, output_bfd, (bfd_vma) a2t1v5_ldr_insn,
6728 s->contents + my_offset);
6730 /* It's a thumb address. Add the low order bit. */
6731 bfd_put_32 (output_bfd, val | a2t2v5_func_addr_insn,
6732 s->contents + my_offset + 4);
6736 put_arm_insn (globals, output_bfd, (bfd_vma) a2t1_ldr_insn,
6737 s->contents + my_offset);
6739 put_arm_insn (globals, output_bfd, (bfd_vma) a2t2_bx_r12_insn,
6740 s->contents + my_offset + 4);
6742 /* It's a thumb address. Add the low order bit. */
6743 bfd_put_32 (output_bfd, val | a2t3_func_addr_insn,
6744 s->contents + my_offset + 8);
6750 BFD_ASSERT (my_offset <= globals->arm_glue_size);
6755 /* Arm code calling a Thumb function. */
6758 elf32_arm_to_thumb_stub (struct bfd_link_info * info,
6762 asection * input_section,
6763 bfd_byte * hit_data,
6766 bfd_signed_vma addend,
6768 char **error_message)
6770 unsigned long int tmp;
6773 long int ret_offset;
6774 struct elf_link_hash_entry * myh;
6775 struct elf32_arm_link_hash_table * globals;
6777 globals = elf32_arm_hash_table (info);
6778 BFD_ASSERT (globals != NULL);
6779 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
6781 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
6782 ARM2THUMB_GLUE_SECTION_NAME);
6783 BFD_ASSERT (s != NULL);
6784 BFD_ASSERT (s->contents != NULL);
6785 BFD_ASSERT (s->output_section != NULL);
6787 myh = elf32_arm_create_thumb_stub (info, name, input_bfd, output_bfd,
6788 sym_sec, val, s, error_message);
6792 my_offset = myh->root.u.def.value;
6793 tmp = bfd_get_32 (input_bfd, hit_data);
6794 tmp = tmp & 0xFF000000;
6796 /* Somehow these are both 4 too far, so subtract 8. */
6797 ret_offset = (s->output_offset
6799 + s->output_section->vma
6800 - (input_section->output_offset
6801 + input_section->output_section->vma
6805 tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
6807 bfd_put_32 (output_bfd, (bfd_vma) tmp, hit_data - input_section->vma);
6812 /* Populate Arm stub for an exported Thumb function. */
6815 elf32_arm_to_thumb_export_stub (struct elf_link_hash_entry *h, void * inf)
6817 struct bfd_link_info * info = (struct bfd_link_info *) inf;
6819 struct elf_link_hash_entry * myh;
6820 struct elf32_arm_link_hash_entry *eh;
6821 struct elf32_arm_link_hash_table * globals;
6824 char *error_message;
6826 eh = elf32_arm_hash_entry (h);
6827 /* Allocate stubs for exported Thumb functions on v4t. */
6828 if (eh->export_glue == NULL)
6831 globals = elf32_arm_hash_table (info);
6832 BFD_ASSERT (globals != NULL);
6833 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
6835 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
6836 ARM2THUMB_GLUE_SECTION_NAME);
6837 BFD_ASSERT (s != NULL);
6838 BFD_ASSERT (s->contents != NULL);
6839 BFD_ASSERT (s->output_section != NULL);
6841 sec = eh->export_glue->root.u.def.section;
6843 BFD_ASSERT (sec->output_section != NULL);
6845 val = eh->export_glue->root.u.def.value + sec->output_offset
6846 + sec->output_section->vma;
6848 myh = elf32_arm_create_thumb_stub (info, h->root.root.string,
6849 h->root.u.def.section->owner,
6850 globals->obfd, sec, val, s,
6856 /* Populate ARMv4 BX veneers. Returns the absolute adress of the veneer. */
6859 elf32_arm_bx_glue (struct bfd_link_info * info, int reg)
6864 struct elf32_arm_link_hash_table *globals;
6866 globals = elf32_arm_hash_table (info);
6867 BFD_ASSERT (globals != NULL);
6868 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
6870 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
6871 ARM_BX_GLUE_SECTION_NAME);
6872 BFD_ASSERT (s != NULL);
6873 BFD_ASSERT (s->contents != NULL);
6874 BFD_ASSERT (s->output_section != NULL);
6876 BFD_ASSERT (globals->bx_glue_offset[reg] & 2);
6878 glue_addr = globals->bx_glue_offset[reg] & ~(bfd_vma)3;
6880 if ((globals->bx_glue_offset[reg] & 1) == 0)
6882 p = s->contents + glue_addr;
6883 bfd_put_32 (globals->obfd, armbx1_tst_insn + (reg << 16), p);
6884 bfd_put_32 (globals->obfd, armbx2_moveq_insn + reg, p + 4);
6885 bfd_put_32 (globals->obfd, armbx3_bx_insn + reg, p + 8);
6886 globals->bx_glue_offset[reg] |= 1;
6889 return glue_addr + s->output_section->vma + s->output_offset;
6892 /* Generate Arm stubs for exported Thumb symbols. */
6894 elf32_arm_begin_write_processing (bfd *abfd ATTRIBUTE_UNUSED,
6895 struct bfd_link_info *link_info)
6897 struct elf32_arm_link_hash_table * globals;
6899 if (link_info == NULL)
6900 /* Ignore this if we are not called by the ELF backend linker. */
6903 globals = elf32_arm_hash_table (link_info);
6904 if (globals == NULL)
6907 /* If blx is available then exported Thumb symbols are OK and there is
6909 if (globals->use_blx)
6912 elf_link_hash_traverse (&globals->root, elf32_arm_to_thumb_export_stub,
6916 /* Some relocations map to different relocations depending on the
6917 target. Return the real relocation. */
6920 arm_real_reloc_type (struct elf32_arm_link_hash_table * globals,
6926 if (globals->target1_is_rel)
6932 return globals->target2_reloc;
6939 /* Return the base VMA address which should be subtracted from real addresses
6940 when resolving @dtpoff relocation.
6941 This is PT_TLS segment p_vaddr. */
6944 dtpoff_base (struct bfd_link_info *info)
6946 /* If tls_sec is NULL, we should have signalled an error already. */
6947 if (elf_hash_table (info)->tls_sec == NULL)
6949 return elf_hash_table (info)->tls_sec->vma;
6952 /* Return the relocation value for @tpoff relocation
6953 if STT_TLS virtual address is ADDRESS. */
6956 tpoff (struct bfd_link_info *info, bfd_vma address)
6958 struct elf_link_hash_table *htab = elf_hash_table (info);
6961 /* If tls_sec is NULL, we should have signalled an error already. */
6962 if (htab->tls_sec == NULL)
6964 base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power);
6965 return address - htab->tls_sec->vma + base;
6968 /* Perform an R_ARM_ABS12 relocation on the field pointed to by DATA.
6969 VALUE is the relocation value. */
6971 static bfd_reloc_status_type
6972 elf32_arm_abs12_reloc (bfd *abfd, void *data, bfd_vma value)
6975 return bfd_reloc_overflow;
6977 value |= bfd_get_32 (abfd, data) & 0xfffff000;
6978 bfd_put_32 (abfd, value, data);
6979 return bfd_reloc_ok;
6982 /* Handle TLS relaxations. Relaxing is possible for symbols that use
6983 R_ARM_GOTDESC, R_ARM_{,THM_}TLS_CALL or
6984 R_ARM_{,THM_}TLS_DESCSEQ relocations, during a static link.
6986 Return bfd_reloc_ok if we're done, bfd_reloc_continue if the caller
6987 is to then call final_link_relocate. Return other values in the
6991 static bfd_reloc_status_type
6992 elf32_arm_tls_relax (struct elf32_arm_link_hash_table *globals,
6993 bfd *input_bfd, asection *input_sec, bfd_byte *contents,
6994 Elf_Internal_Rela *rel, unsigned long is_local)
6998 switch (ELF32_R_TYPE (rel->r_info))
7001 return bfd_reloc_notsupported;
7003 case R_ARM_TLS_GOTDESC:
7008 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
7010 insn -= 5; /* THUMB */
7012 insn -= 8; /* ARM */
7014 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
7015 return bfd_reloc_continue;
7017 case R_ARM_THM_TLS_DESCSEQ:
7019 insn = bfd_get_16 (input_bfd, contents + rel->r_offset);
7020 if ((insn & 0xff78) == 0x4478) /* add rx, pc */
7024 bfd_put_16 (input_bfd, 0x46c0, contents + rel->r_offset);
7026 else if ((insn & 0xffc0) == 0x6840) /* ldr rx,[ry,#4] */
7030 bfd_put_16 (input_bfd, 0x46c0, contents + rel->r_offset);
7033 bfd_put_16 (input_bfd, insn & 0xf83f, contents + rel->r_offset);
7035 else if ((insn & 0xff87) == 0x4780) /* blx rx */
7039 bfd_put_16 (input_bfd, 0x46c0, contents + rel->r_offset);
7042 bfd_put_16 (input_bfd, 0x4600 | (insn & 0x78),
7043 contents + rel->r_offset);
7047 if ((insn & 0xf000) == 0xf000 || (insn & 0xf800) == 0xe800)
7048 /* It's a 32 bit instruction, fetch the rest of it for
7049 error generation. */
7051 | bfd_get_16 (input_bfd, contents + rel->r_offset + 2);
7052 (*_bfd_error_handler)
7053 (_("%B(%A+0x%lx):unexpected Thumb instruction '0x%x' in TLS trampoline"),
7054 input_bfd, input_sec, (unsigned long)rel->r_offset, insn);
7055 return bfd_reloc_notsupported;
7059 case R_ARM_TLS_DESCSEQ:
7061 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
7062 if ((insn & 0xffff0ff0) == 0xe08f0000) /* add rx,pc,ry */
7066 bfd_put_32 (input_bfd, 0xe1a00000 | (insn & 0xffff),
7067 contents + rel->r_offset);
7069 else if ((insn & 0xfff00fff) == 0xe5900004) /* ldr rx,[ry,#4]*/
7073 bfd_put_32 (input_bfd, 0xe1a00000, contents + rel->r_offset);
7076 bfd_put_32 (input_bfd, insn & 0xfffff000,
7077 contents + rel->r_offset);
7079 else if ((insn & 0xfffffff0) == 0xe12fff30) /* blx rx */
7083 bfd_put_32 (input_bfd, 0xe1a00000, contents + rel->r_offset);
7086 bfd_put_32 (input_bfd, 0xe1a00000 | (insn & 0xf),
7087 contents + rel->r_offset);
7091 (*_bfd_error_handler)
7092 (_("%B(%A+0x%lx):unexpected ARM instruction '0x%x' in TLS trampoline"),
7093 input_bfd, input_sec, (unsigned long)rel->r_offset, insn);
7094 return bfd_reloc_notsupported;
7098 case R_ARM_TLS_CALL:
7099 /* GD->IE relaxation, turn the instruction into 'nop' or
7100 'ldr r0, [pc,r0]' */
7101 insn = is_local ? 0xe1a00000 : 0xe79f0000;
7102 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
7105 case R_ARM_THM_TLS_CALL:
7106 /* GD->IE relaxation */
7108 /* add r0,pc; ldr r0, [r0] */
7110 else if (arch_has_thumb2_nop (globals))
7117 bfd_put_16 (input_bfd, insn >> 16, contents + rel->r_offset);
7118 bfd_put_16 (input_bfd, insn & 0xffff, contents + rel->r_offset + 2);
7121 return bfd_reloc_ok;
7124 /* For a given value of n, calculate the value of G_n as required to
7125 deal with group relocations. We return it in the form of an
7126 encoded constant-and-rotation, together with the final residual. If n is
7127 specified as less than zero, then final_residual is filled with the
7128 input value and no further action is performed. */
7131 calculate_group_reloc_mask (bfd_vma value, int n, bfd_vma *final_residual)
7135 bfd_vma encoded_g_n = 0;
7136 bfd_vma residual = value; /* Also known as Y_n. */
7138 for (current_n = 0; current_n <= n; current_n++)
7142 /* Calculate which part of the value to mask. */
7149 /* Determine the most significant bit in the residual and
7150 align the resulting value to a 2-bit boundary. */
7151 for (msb = 30; msb >= 0; msb -= 2)
7152 if (residual & (3 << msb))
7155 /* The desired shift is now (msb - 6), or zero, whichever
7162 /* Calculate g_n in 32-bit as well as encoded constant+rotation form. */
7163 g_n = residual & (0xff << shift);
7164 encoded_g_n = (g_n >> shift)
7165 | ((g_n <= 0xff ? 0 : (32 - shift) / 2) << 8);
7167 /* Calculate the residual for the next time around. */
7171 *final_residual = residual;
7176 /* Given an ARM instruction, determine whether it is an ADD or a SUB.
7177 Returns 1 if it is an ADD, -1 if it is a SUB, and 0 otherwise. */
7180 identify_add_or_sub (bfd_vma insn)
7182 int opcode = insn & 0x1e00000;
7184 if (opcode == 1 << 23) /* ADD */
7187 if (opcode == 1 << 22) /* SUB */
7193 /* Perform a relocation as part of a final link. */
7195 static bfd_reloc_status_type
7196 elf32_arm_final_link_relocate (reloc_howto_type * howto,
7199 asection * input_section,
7200 bfd_byte * contents,
7201 Elf_Internal_Rela * rel,
7203 struct bfd_link_info * info,
7205 const char * sym_name,
7207 struct elf_link_hash_entry * h,
7208 bfd_boolean * unresolved_reloc_p,
7209 char ** error_message)
7211 unsigned long r_type = howto->type;
7212 unsigned long r_symndx;
7213 bfd_byte * hit_data = contents + rel->r_offset;
7214 bfd_vma * local_got_offsets;
7215 bfd_vma * local_tlsdesc_gotents;
7216 asection * sgot = NULL;
7217 asection * splt = NULL;
7218 asection * sreloc = NULL;
7221 bfd_signed_vma signed_addend;
7222 struct elf32_arm_link_hash_table * globals;
7224 globals = elf32_arm_hash_table (info);
7225 if (globals == NULL)
7226 return bfd_reloc_notsupported;
7228 BFD_ASSERT (is_arm_elf (input_bfd));
7230 /* Some relocation types map to different relocations depending on the
7231 target. We pick the right one here. */
7232 r_type = arm_real_reloc_type (globals, r_type);
7234 /* It is possible to have linker relaxations on some TLS access
7235 models. Update our information here. */
7236 r_type = elf32_arm_tls_transition (info, r_type, h);
7238 if (r_type != howto->type)
7239 howto = elf32_arm_howto_from_type (r_type);
7241 /* If the start address has been set, then set the EF_ARM_HASENTRY
7242 flag. Setting this more than once is redundant, but the cost is
7243 not too high, and it keeps the code simple.
7245 The test is done here, rather than somewhere else, because the
7246 start address is only set just before the final link commences.
7248 Note - if the user deliberately sets a start address of 0, the
7249 flag will not be set. */
7250 if (bfd_get_start_address (output_bfd) != 0)
7251 elf_elfheader (output_bfd)->e_flags |= EF_ARM_HASENTRY;
7253 sgot = globals->root.sgot;
7254 splt = globals->root.splt;
7255 srelgot = globals->root.srelgot;
7256 local_got_offsets = elf_local_got_offsets (input_bfd);
7257 local_tlsdesc_gotents = elf32_arm_local_tlsdesc_gotent (input_bfd);
7259 r_symndx = ELF32_R_SYM (rel->r_info);
7261 if (globals->use_rel)
7263 addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask;
7265 if (addend & ((howto->src_mask + 1) >> 1))
7268 signed_addend &= ~ howto->src_mask;
7269 signed_addend |= addend;
7272 signed_addend = addend;
7275 addend = signed_addend = rel->r_addend;
7280 /* We don't need to find a value for this symbol. It's just a
7282 *unresolved_reloc_p = FALSE;
7283 return bfd_reloc_ok;
7286 if (!globals->vxworks_p)
7287 return elf32_arm_abs12_reloc (input_bfd, hit_data, value + addend);
7291 case R_ARM_ABS32_NOI:
7293 case R_ARM_REL32_NOI:
7299 /* Handle relocations which should use the PLT entry. ABS32/REL32
7300 will use the symbol's value, which may point to a PLT entry, but we
7301 don't need to handle that here. If we created a PLT entry, all
7302 branches in this object should go to it, except if the PLT is too
7303 far away, in which case a long branch stub should be inserted. */
7304 if ((r_type != R_ARM_ABS32 && r_type != R_ARM_REL32
7305 && r_type != R_ARM_ABS32_NOI && r_type != R_ARM_REL32_NOI
7306 && r_type != R_ARM_CALL
7307 && r_type != R_ARM_JUMP24
7308 && r_type != R_ARM_PLT32)
7311 && h->plt.offset != (bfd_vma) -1)
7313 /* If we've created a .plt section, and assigned a PLT entry to
7314 this function, it should not be known to bind locally. If
7315 it were, we would have cleared the PLT entry. */
7316 BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info, h));
7318 value = (splt->output_section->vma
7319 + splt->output_offset
7321 *unresolved_reloc_p = FALSE;
7322 return _bfd_final_link_relocate (howto, input_bfd, input_section,
7323 contents, rel->r_offset, value,
7327 /* When generating a shared object or relocatable executable, these
7328 relocations are copied into the output file to be resolved at
7330 if ((info->shared || globals->root.is_relocatable_executable)
7331 && (input_section->flags & SEC_ALLOC)
7332 && !(globals->vxworks_p
7333 && strcmp (input_section->output_section->name,
7335 && ((r_type != R_ARM_REL32 && r_type != R_ARM_REL32_NOI)
7336 || !SYMBOL_CALLS_LOCAL (info, h))
7337 && (!strstr (input_section->name, STUB_SUFFIX))
7339 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
7340 || h->root.type != bfd_link_hash_undefweak)
7341 && r_type != R_ARM_PC24
7342 && r_type != R_ARM_CALL
7343 && r_type != R_ARM_JUMP24
7344 && r_type != R_ARM_PREL31
7345 && r_type != R_ARM_PLT32)
7347 Elf_Internal_Rela outrel;
7349 bfd_boolean skip, relocate;
7351 *unresolved_reloc_p = FALSE;
7355 sreloc = _bfd_elf_get_dynamic_reloc_section (input_bfd, input_section,
7356 ! globals->use_rel);
7359 return bfd_reloc_notsupported;
7365 outrel.r_addend = addend;
7367 _bfd_elf_section_offset (output_bfd, info, input_section,
7369 if (outrel.r_offset == (bfd_vma) -1)
7371 else if (outrel.r_offset == (bfd_vma) -2)
7372 skip = TRUE, relocate = TRUE;
7373 outrel.r_offset += (input_section->output_section->vma
7374 + input_section->output_offset);
7377 memset (&outrel, 0, sizeof outrel);
7382 || !h->def_regular))
7383 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
7388 /* This symbol is local, or marked to become local. */
7389 if (sym_flags == STT_ARM_TFUNC)
7391 if (globals->symbian_p)
7395 /* On Symbian OS, the data segment and text segement
7396 can be relocated independently. Therefore, we
7397 must indicate the segment to which this
7398 relocation is relative. The BPABI allows us to
7399 use any symbol in the right segment; we just use
7400 the section symbol as it is convenient. (We
7401 cannot use the symbol given by "h" directly as it
7402 will not appear in the dynamic symbol table.)
7404 Note that the dynamic linker ignores the section
7405 symbol value, so we don't subtract osec->vma
7406 from the emitted reloc addend. */
7408 osec = sym_sec->output_section;
7410 osec = input_section->output_section;
7411 symbol = elf_section_data (osec)->dynindx;
7414 struct elf_link_hash_table *htab = elf_hash_table (info);
7416 if ((osec->flags & SEC_READONLY) == 0
7417 && htab->data_index_section != NULL)
7418 osec = htab->data_index_section;
7420 osec = htab->text_index_section;
7421 symbol = elf_section_data (osec)->dynindx;
7423 BFD_ASSERT (symbol != 0);
7426 /* On SVR4-ish systems, the dynamic loader cannot
7427 relocate the text and data segments independently,
7428 so the symbol does not matter. */
7430 outrel.r_info = ELF32_R_INFO (symbol, R_ARM_RELATIVE);
7431 if (globals->use_rel)
7434 outrel.r_addend += value;
7437 loc = sreloc->contents;
7438 loc += sreloc->reloc_count++ * RELOC_SIZE (globals);
7439 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
7441 /* If this reloc is against an external symbol, we do not want to
7442 fiddle with the addend. Otherwise, we need to include the symbol
7443 value so that it becomes an addend for the dynamic reloc. */
7445 return bfd_reloc_ok;
7447 return _bfd_final_link_relocate (howto, input_bfd, input_section,
7448 contents, rel->r_offset, value,
7451 else switch (r_type)
7454 return elf32_arm_abs12_reloc (input_bfd, hit_data, value + addend);
7456 case R_ARM_XPC25: /* Arm BLX instruction. */
7459 case R_ARM_PC24: /* Arm B/BL instruction. */
7462 struct elf32_arm_stub_hash_entry *stub_entry = NULL;
7464 if (r_type == R_ARM_XPC25)
7466 /* Check for Arm calling Arm function. */
7467 /* FIXME: Should we translate the instruction into a BL
7468 instruction instead ? */
7469 if (sym_flags != STT_ARM_TFUNC)
7470 (*_bfd_error_handler)
7471 (_("\%B: Warning: Arm BLX instruction targets Arm function '%s'."),
7473 h ? h->root.root.string : "(local)");
7475 else if (r_type == R_ARM_PC24)
7477 /* Check for Arm calling Thumb function. */
7478 if (sym_flags == STT_ARM_TFUNC)
7480 if (elf32_arm_to_thumb_stub (info, sym_name, input_bfd,
7481 output_bfd, input_section,
7482 hit_data, sym_sec, rel->r_offset,
7483 signed_addend, value,
7485 return bfd_reloc_ok;
7487 return bfd_reloc_dangerous;
7491 /* Check if a stub has to be inserted because the
7492 destination is too far or we are changing mode. */
7493 if ( r_type == R_ARM_CALL
7494 || r_type == R_ARM_JUMP24
7495 || r_type == R_ARM_PLT32)
7497 enum elf32_arm_stub_type stub_type = arm_stub_none;
7498 struct elf32_arm_link_hash_entry *hash;
7500 hash = (struct elf32_arm_link_hash_entry *) h;
7501 stub_type = arm_type_of_stub (info, input_section, rel,
7504 input_bfd, sym_name);
7506 if (stub_type != arm_stub_none)
7508 /* The target is out of reach, so redirect the
7509 branch to the local stub for this function. */
7511 stub_entry = elf32_arm_get_stub_entry (input_section,
7515 if (stub_entry != NULL)
7516 value = (stub_entry->stub_offset
7517 + stub_entry->stub_sec->output_offset
7518 + stub_entry->stub_sec->output_section->vma);
7522 /* If the call goes through a PLT entry, make sure to
7523 check distance to the right destination address. */
7526 && h->plt.offset != (bfd_vma) -1)
7528 value = (splt->output_section->vma
7529 + splt->output_offset
7531 *unresolved_reloc_p = FALSE;
7532 /* The PLT entry is in ARM mode, regardless of the
7534 sym_flags = STT_FUNC;
7539 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
7541 S is the address of the symbol in the relocation.
7542 P is address of the instruction being relocated.
7543 A is the addend (extracted from the instruction) in bytes.
7545 S is held in 'value'.
7546 P is the base address of the section containing the
7547 instruction plus the offset of the reloc into that
7549 (input_section->output_section->vma +
7550 input_section->output_offset +
7552 A is the addend, converted into bytes, ie:
7555 Note: None of these operations have knowledge of the pipeline
7556 size of the processor, thus it is up to the assembler to
7557 encode this information into the addend. */
7558 value -= (input_section->output_section->vma
7559 + input_section->output_offset);
7560 value -= rel->r_offset;
7561 if (globals->use_rel)
7562 value += (signed_addend << howto->size);
7564 /* RELA addends do not have to be adjusted by howto->size. */
7565 value += signed_addend;
7567 signed_addend = value;
7568 signed_addend >>= howto->rightshift;
7570 /* A branch to an undefined weak symbol is turned into a jump to
7571 the next instruction unless a PLT entry will be created.
7572 Do the same for local undefined symbols (but not for STN_UNDEF).
7573 The jump to the next instruction is optimized as a NOP depending
7574 on the architecture. */
7575 if (h ? (h->root.type == bfd_link_hash_undefweak
7576 && !(splt != NULL && h->plt.offset != (bfd_vma) -1))
7577 : r_symndx != STN_UNDEF && bfd_is_und_section (sym_sec))
7579 value = (bfd_get_32 (input_bfd, hit_data) & 0xf0000000);
7581 if (arch_has_arm_nop (globals))
7582 value |= 0x0320f000;
7584 value |= 0x01a00000; /* Using pre-UAL nop: mov r0, r0. */
7588 /* Perform a signed range check. */
7589 if ( signed_addend > ((bfd_signed_vma) (howto->dst_mask >> 1))
7590 || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1)))
7591 return bfd_reloc_overflow;
7593 addend = (value & 2);
7595 value = (signed_addend & howto->dst_mask)
7596 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
7598 if (r_type == R_ARM_CALL)
7600 /* Set the H bit in the BLX instruction. */
7601 if (sym_flags == STT_ARM_TFUNC)
7606 value &= ~(bfd_vma)(1 << 24);
7609 /* Select the correct instruction (BL or BLX). */
7610 /* Only if we are not handling a BL to a stub. In this
7611 case, mode switching is performed by the stub. */
7612 if (sym_flags == STT_ARM_TFUNC && !stub_entry)
7616 value &= ~(bfd_vma)(1 << 28);
7626 if (sym_flags == STT_ARM_TFUNC)
7630 case R_ARM_ABS32_NOI:
7636 if (sym_flags == STT_ARM_TFUNC)
7638 value -= (input_section->output_section->vma
7639 + input_section->output_offset + rel->r_offset);
7642 case R_ARM_REL32_NOI:
7644 value -= (input_section->output_section->vma
7645 + input_section->output_offset + rel->r_offset);
7649 value -= (input_section->output_section->vma
7650 + input_section->output_offset + rel->r_offset);
7651 value += signed_addend;
7652 if (! h || h->root.type != bfd_link_hash_undefweak)
7654 /* Check for overflow. */
7655 if ((value ^ (value >> 1)) & (1 << 30))
7656 return bfd_reloc_overflow;
7658 value &= 0x7fffffff;
7659 value |= (bfd_get_32 (input_bfd, hit_data) & 0x80000000);
7660 if (sym_flags == STT_ARM_TFUNC)
7665 bfd_put_32 (input_bfd, value, hit_data);
7666 return bfd_reloc_ok;
7671 /* There is no way to tell whether the user intended to use a signed or
7672 unsigned addend. When checking for overflow we accept either,
7673 as specified by the AAELF. */
7674 if ((long) value > 0xff || (long) value < -0x80)
7675 return bfd_reloc_overflow;
7677 bfd_put_8 (input_bfd, value, hit_data);
7678 return bfd_reloc_ok;
7683 /* See comment for R_ARM_ABS8. */
7684 if ((long) value > 0xffff || (long) value < -0x8000)
7685 return bfd_reloc_overflow;
7687 bfd_put_16 (input_bfd, value, hit_data);
7688 return bfd_reloc_ok;
7690 case R_ARM_THM_ABS5:
7691 /* Support ldr and str instructions for the thumb. */
7692 if (globals->use_rel)
7694 /* Need to refetch addend. */
7695 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
7696 /* ??? Need to determine shift amount from operand size. */
7697 addend >>= howto->rightshift;
7701 /* ??? Isn't value unsigned? */
7702 if ((long) value > 0x1f || (long) value < -0x10)
7703 return bfd_reloc_overflow;
7705 /* ??? Value needs to be properly shifted into place first. */
7706 value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
7707 bfd_put_16 (input_bfd, value, hit_data);
7708 return bfd_reloc_ok;
7710 case R_ARM_THM_ALU_PREL_11_0:
7711 /* Corresponds to: addw.w reg, pc, #offset (and similarly for subw). */
7714 bfd_signed_vma relocation;
7716 insn = (bfd_get_16 (input_bfd, hit_data) << 16)
7717 | bfd_get_16 (input_bfd, hit_data + 2);
7719 if (globals->use_rel)
7721 signed_addend = (insn & 0xff) | ((insn & 0x7000) >> 4)
7722 | ((insn & (1 << 26)) >> 15);
7723 if (insn & 0xf00000)
7724 signed_addend = -signed_addend;
7727 relocation = value + signed_addend;
7728 relocation -= (input_section->output_section->vma
7729 + input_section->output_offset
7732 value = abs (relocation);
7734 if (value >= 0x1000)
7735 return bfd_reloc_overflow;
7737 insn = (insn & 0xfb0f8f00) | (value & 0xff)
7738 | ((value & 0x700) << 4)
7739 | ((value & 0x800) << 15);
7743 bfd_put_16 (input_bfd, insn >> 16, hit_data);
7744 bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2);
7746 return bfd_reloc_ok;
7750 /* PR 10073: This reloc is not generated by the GNU toolchain,
7751 but it is supported for compatibility with third party libraries
7752 generated by other compilers, specifically the ARM/IAR. */
7755 bfd_signed_vma relocation;
7757 insn = bfd_get_16 (input_bfd, hit_data);
7759 if (globals->use_rel)
7760 addend = (insn & 0x00ff) << 2;
7762 relocation = value + addend;
7763 relocation -= (input_section->output_section->vma
7764 + input_section->output_offset
7767 value = abs (relocation);
7769 /* We do not check for overflow of this reloc. Although strictly
7770 speaking this is incorrect, it appears to be necessary in order
7771 to work with IAR generated relocs. Since GCC and GAS do not
7772 generate R_ARM_THM_PC8 relocs, the lack of a check should not be
7773 a problem for them. */
7776 insn = (insn & 0xff00) | (value >> 2);
7778 bfd_put_16 (input_bfd, insn, hit_data);
7780 return bfd_reloc_ok;
7783 case R_ARM_THM_PC12:
7784 /* Corresponds to: ldr.w reg, [pc, #offset]. */
7787 bfd_signed_vma relocation;
7789 insn = (bfd_get_16 (input_bfd, hit_data) << 16)
7790 | bfd_get_16 (input_bfd, hit_data + 2);
7792 if (globals->use_rel)
7794 signed_addend = insn & 0xfff;
7795 if (!(insn & (1 << 23)))
7796 signed_addend = -signed_addend;
7799 relocation = value + signed_addend;
7800 relocation -= (input_section->output_section->vma
7801 + input_section->output_offset
7804 value = abs (relocation);
7806 if (value >= 0x1000)
7807 return bfd_reloc_overflow;
7809 insn = (insn & 0xff7ff000) | value;
7810 if (relocation >= 0)
7813 bfd_put_16 (input_bfd, insn >> 16, hit_data);
7814 bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2);
7816 return bfd_reloc_ok;
7819 case R_ARM_THM_XPC22:
7820 case R_ARM_THM_CALL:
7821 case R_ARM_THM_JUMP24:
7822 /* Thumb BL (branch long instruction). */
7826 bfd_boolean overflow = FALSE;
7827 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
7828 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
7829 bfd_signed_vma reloc_signed_max;
7830 bfd_signed_vma reloc_signed_min;
7832 bfd_signed_vma signed_check;
7834 const int thumb2 = using_thumb2 (globals);
7836 /* A branch to an undefined weak symbol is turned into a jump to
7837 the next instruction unless a PLT entry will be created.
7838 The jump to the next instruction is optimized as a NOP.W for
7839 Thumb-2 enabled architectures. */
7840 if (h && h->root.type == bfd_link_hash_undefweak
7841 && !(splt != NULL && h->plt.offset != (bfd_vma) -1))
7843 if (arch_has_thumb2_nop (globals))
7845 bfd_put_16 (input_bfd, 0xf3af, hit_data);
7846 bfd_put_16 (input_bfd, 0x8000, hit_data + 2);
7850 bfd_put_16 (input_bfd, 0xe000, hit_data);
7851 bfd_put_16 (input_bfd, 0xbf00, hit_data + 2);
7853 return bfd_reloc_ok;
7856 /* Fetch the addend. We use the Thumb-2 encoding (backwards compatible
7857 with Thumb-1) involving the J1 and J2 bits. */
7858 if (globals->use_rel)
7860 bfd_vma s = (upper_insn & (1 << 10)) >> 10;
7861 bfd_vma upper = upper_insn & 0x3ff;
7862 bfd_vma lower = lower_insn & 0x7ff;
7863 bfd_vma j1 = (lower_insn & (1 << 13)) >> 13;
7864 bfd_vma j2 = (lower_insn & (1 << 11)) >> 11;
7865 bfd_vma i1 = j1 ^ s ? 0 : 1;
7866 bfd_vma i2 = j2 ^ s ? 0 : 1;
7868 addend = (i1 << 23) | (i2 << 22) | (upper << 12) | (lower << 1);
7870 addend = (addend | ((s ? 0 : 1) << 24)) - (1 << 24);
7872 signed_addend = addend;
7875 if (r_type == R_ARM_THM_XPC22)
7877 /* Check for Thumb to Thumb call. */
7878 /* FIXME: Should we translate the instruction into a BL
7879 instruction instead ? */
7880 if (sym_flags == STT_ARM_TFUNC)
7881 (*_bfd_error_handler)
7882 (_("%B: Warning: Thumb BLX instruction targets thumb function '%s'."),
7884 h ? h->root.root.string : "(local)");
7888 /* If it is not a call to Thumb, assume call to Arm.
7889 If it is a call relative to a section name, then it is not a
7890 function call at all, but rather a long jump. Calls through
7891 the PLT do not require stubs. */
7892 if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION
7893 && (h == NULL || splt == NULL
7894 || h->plt.offset == (bfd_vma) -1))
7896 if (globals->use_blx && r_type == R_ARM_THM_CALL)
7898 /* Convert BL to BLX. */
7899 lower_insn = (lower_insn & ~0x1000) | 0x0800;
7901 else if (( r_type != R_ARM_THM_CALL)
7902 && (r_type != R_ARM_THM_JUMP24))
7904 if (elf32_thumb_to_arm_stub
7905 (info, sym_name, input_bfd, output_bfd, input_section,
7906 hit_data, sym_sec, rel->r_offset, signed_addend, value,
7908 return bfd_reloc_ok;
7910 return bfd_reloc_dangerous;
7913 else if (sym_flags == STT_ARM_TFUNC && globals->use_blx
7914 && r_type == R_ARM_THM_CALL)
7916 /* Make sure this is a BL. */
7917 lower_insn |= 0x1800;
7921 enum elf32_arm_stub_type stub_type = arm_stub_none;
7922 if (r_type == R_ARM_THM_CALL || r_type == R_ARM_THM_JUMP24)
7924 /* Check if a stub has to be inserted because the destination
7926 struct elf32_arm_stub_hash_entry *stub_entry;
7927 struct elf32_arm_link_hash_entry *hash;
7929 hash = (struct elf32_arm_link_hash_entry *) h;
7931 stub_type = arm_type_of_stub (info, input_section, rel,
7932 &sym_flags, hash, value, sym_sec,
7933 input_bfd, sym_name);
7935 if (stub_type != arm_stub_none)
7937 /* The target is out of reach or we are changing modes, so
7938 redirect the branch to the local stub for this
7940 stub_entry = elf32_arm_get_stub_entry (input_section,
7944 if (stub_entry != NULL)
7945 value = (stub_entry->stub_offset
7946 + stub_entry->stub_sec->output_offset
7947 + stub_entry->stub_sec->output_section->vma);
7949 /* If this call becomes a call to Arm, force BLX. */
7950 if (globals->use_blx && (r_type == R_ARM_THM_CALL))
7953 && !arm_stub_is_thumb (stub_entry->stub_type))
7954 || (sym_flags != STT_ARM_TFUNC))
7955 lower_insn = (lower_insn & ~0x1000) | 0x0800;
7960 /* Handle calls via the PLT. */
7961 if (stub_type == arm_stub_none
7964 && h->plt.offset != (bfd_vma) -1)
7966 value = (splt->output_section->vma
7967 + splt->output_offset
7970 if (globals->use_blx && r_type == R_ARM_THM_CALL)
7972 /* If the Thumb BLX instruction is available, convert
7973 the BL to a BLX instruction to call the ARM-mode
7975 lower_insn = (lower_insn & ~0x1000) | 0x0800;
7976 sym_flags = STT_FUNC;
7980 /* Target the Thumb stub before the ARM PLT entry. */
7981 value -= PLT_THUMB_STUB_SIZE;
7982 sym_flags = STT_ARM_TFUNC;
7984 *unresolved_reloc_p = FALSE;
7987 relocation = value + signed_addend;
7989 relocation -= (input_section->output_section->vma
7990 + input_section->output_offset
7993 check = relocation >> howto->rightshift;
7995 /* If this is a signed value, the rightshift just dropped
7996 leading 1 bits (assuming twos complement). */
7997 if ((bfd_signed_vma) relocation >= 0)
7998 signed_check = check;
8000 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
8002 /* Calculate the permissable maximum and minimum values for
8003 this relocation according to whether we're relocating for
8005 bitsize = howto->bitsize;
8008 reloc_signed_max = (1 << (bitsize - 1)) - 1;
8009 reloc_signed_min = ~reloc_signed_max;
8011 /* Assumes two's complement. */
8012 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
8015 if ((lower_insn & 0x5000) == 0x4000)
8016 /* For a BLX instruction, make sure that the relocation is rounded up
8017 to a word boundary. This follows the semantics of the instruction
8018 which specifies that bit 1 of the target address will come from bit
8019 1 of the base address. */
8020 relocation = (relocation + 2) & ~ 3;
8022 /* Put RELOCATION back into the insn. Assumes two's complement.
8023 We use the Thumb-2 encoding, which is safe even if dealing with
8024 a Thumb-1 instruction by virtue of our overflow check above. */
8025 reloc_sign = (signed_check < 0) ? 1 : 0;
8026 upper_insn = (upper_insn & ~(bfd_vma) 0x7ff)
8027 | ((relocation >> 12) & 0x3ff)
8028 | (reloc_sign << 10);
8029 lower_insn = (lower_insn & ~(bfd_vma) 0x2fff)
8030 | (((!((relocation >> 23) & 1)) ^ reloc_sign) << 13)
8031 | (((!((relocation >> 22) & 1)) ^ reloc_sign) << 11)
8032 | ((relocation >> 1) & 0x7ff);
8034 /* Put the relocated value back in the object file: */
8035 bfd_put_16 (input_bfd, upper_insn, hit_data);
8036 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
8038 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
8042 case R_ARM_THM_JUMP19:
8043 /* Thumb32 conditional branch instruction. */
8046 bfd_boolean overflow = FALSE;
8047 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
8048 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
8049 bfd_signed_vma reloc_signed_max = 0xffffe;
8050 bfd_signed_vma reloc_signed_min = -0x100000;
8051 bfd_signed_vma signed_check;
8053 /* Need to refetch the addend, reconstruct the top three bits,
8054 and squish the two 11 bit pieces together. */
8055 if (globals->use_rel)
8057 bfd_vma S = (upper_insn & 0x0400) >> 10;
8058 bfd_vma upper = (upper_insn & 0x003f);
8059 bfd_vma J1 = (lower_insn & 0x2000) >> 13;
8060 bfd_vma J2 = (lower_insn & 0x0800) >> 11;
8061 bfd_vma lower = (lower_insn & 0x07ff);
8066 upper -= 0x0100; /* Sign extend. */
8068 addend = (upper << 12) | (lower << 1);
8069 signed_addend = addend;
8072 /* Handle calls via the PLT. */
8073 if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
8075 value = (splt->output_section->vma
8076 + splt->output_offset
8078 /* Target the Thumb stub before the ARM PLT entry. */
8079 value -= PLT_THUMB_STUB_SIZE;
8080 *unresolved_reloc_p = FALSE;
8083 /* ??? Should handle interworking? GCC might someday try to
8084 use this for tail calls. */
8086 relocation = value + signed_addend;
8087 relocation -= (input_section->output_section->vma
8088 + input_section->output_offset
8090 signed_check = (bfd_signed_vma) relocation;
8092 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
8095 /* Put RELOCATION back into the insn. */
8097 bfd_vma S = (relocation & 0x00100000) >> 20;
8098 bfd_vma J2 = (relocation & 0x00080000) >> 19;
8099 bfd_vma J1 = (relocation & 0x00040000) >> 18;
8100 bfd_vma hi = (relocation & 0x0003f000) >> 12;
8101 bfd_vma lo = (relocation & 0x00000ffe) >> 1;
8103 upper_insn = (upper_insn & 0xfbc0) | (S << 10) | hi;
8104 lower_insn = (lower_insn & 0xd000) | (J1 << 13) | (J2 << 11) | lo;
8107 /* Put the relocated value back in the object file: */
8108 bfd_put_16 (input_bfd, upper_insn, hit_data);
8109 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
8111 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
8114 case R_ARM_THM_JUMP11:
8115 case R_ARM_THM_JUMP8:
8116 case R_ARM_THM_JUMP6:
8117 /* Thumb B (branch) instruction). */
8119 bfd_signed_vma relocation;
8120 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
8121 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
8122 bfd_signed_vma signed_check;
8124 /* CZB cannot jump backward. */
8125 if (r_type == R_ARM_THM_JUMP6)
8126 reloc_signed_min = 0;
8128 if (globals->use_rel)
8130 /* Need to refetch addend. */
8131 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
8132 if (addend & ((howto->src_mask + 1) >> 1))
8135 signed_addend &= ~ howto->src_mask;
8136 signed_addend |= addend;
8139 signed_addend = addend;
8140 /* The value in the insn has been right shifted. We need to
8141 undo this, so that we can perform the address calculation
8142 in terms of bytes. */
8143 signed_addend <<= howto->rightshift;
8145 relocation = value + signed_addend;
8147 relocation -= (input_section->output_section->vma
8148 + input_section->output_offset
8151 relocation >>= howto->rightshift;
8152 signed_check = relocation;
8154 if (r_type == R_ARM_THM_JUMP6)
8155 relocation = ((relocation & 0x0020) << 4) | ((relocation & 0x001f) << 3);
8157 relocation &= howto->dst_mask;
8158 relocation |= (bfd_get_16 (input_bfd, hit_data) & (~ howto->dst_mask));
8160 bfd_put_16 (input_bfd, relocation, hit_data);
8162 /* Assumes two's complement. */
8163 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
8164 return bfd_reloc_overflow;
8166 return bfd_reloc_ok;
8169 case R_ARM_ALU_PCREL7_0:
8170 case R_ARM_ALU_PCREL15_8:
8171 case R_ARM_ALU_PCREL23_15:
8176 insn = bfd_get_32 (input_bfd, hit_data);
8177 if (globals->use_rel)
8179 /* Extract the addend. */
8180 addend = (insn & 0xff) << ((insn & 0xf00) >> 7);
8181 signed_addend = addend;
8183 relocation = value + signed_addend;
8185 relocation -= (input_section->output_section->vma
8186 + input_section->output_offset
8188 insn = (insn & ~0xfff)
8189 | ((howto->bitpos << 7) & 0xf00)
8190 | ((relocation >> howto->bitpos) & 0xff);
8191 bfd_put_32 (input_bfd, value, hit_data);
8193 return bfd_reloc_ok;
8195 case R_ARM_GNU_VTINHERIT:
8196 case R_ARM_GNU_VTENTRY:
8197 return bfd_reloc_ok;
8199 case R_ARM_GOTOFF32:
8200 /* Relocation is relative to the start of the
8201 global offset table. */
8203 BFD_ASSERT (sgot != NULL);
8205 return bfd_reloc_notsupported;
8207 /* If we are addressing a Thumb function, we need to adjust the
8208 address by one, so that attempts to call the function pointer will
8209 correctly interpret it as Thumb code. */
8210 if (sym_flags == STT_ARM_TFUNC)
8213 /* Note that sgot->output_offset is not involved in this
8214 calculation. We always want the start of .got. If we
8215 define _GLOBAL_OFFSET_TABLE in a different way, as is
8216 permitted by the ABI, we might have to change this
8218 value -= sgot->output_section->vma;
8219 return _bfd_final_link_relocate (howto, input_bfd, input_section,
8220 contents, rel->r_offset, value,
8224 /* Use global offset table as symbol value. */
8225 BFD_ASSERT (sgot != NULL);
8228 return bfd_reloc_notsupported;
8230 *unresolved_reloc_p = FALSE;
8231 value = sgot->output_section->vma;
8232 return _bfd_final_link_relocate (howto, input_bfd, input_section,
8233 contents, rel->r_offset, value,
8237 case R_ARM_GOT_PREL:
8238 /* Relocation is to the entry for this symbol in the
8239 global offset table. */
8241 return bfd_reloc_notsupported;
8248 off = h->got.offset;
8249 BFD_ASSERT (off != (bfd_vma) -1);
8250 dyn = globals->root.dynamic_sections_created;
8252 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
8254 && SYMBOL_REFERENCES_LOCAL (info, h))
8255 || (ELF_ST_VISIBILITY (h->other)
8256 && h->root.type == bfd_link_hash_undefweak))
8258 /* This is actually a static link, or it is a -Bsymbolic link
8259 and the symbol is defined locally. We must initialize this
8260 entry in the global offset table. Since the offset must
8261 always be a multiple of 4, we use the least significant bit
8262 to record whether we have initialized it already.
8264 When doing a dynamic link, we create a .rel(a).got relocation
8265 entry to initialize the value. This is done in the
8266 finish_dynamic_symbol routine. */
8271 /* If we are addressing a Thumb function, we need to
8272 adjust the address by one, so that attempts to
8273 call the function pointer will correctly
8274 interpret it as Thumb code. */
8275 if (sym_flags == STT_ARM_TFUNC)
8278 bfd_put_32 (output_bfd, value, sgot->contents + off);
8283 *unresolved_reloc_p = FALSE;
8285 value = sgot->output_offset + off;
8291 BFD_ASSERT (local_got_offsets != NULL &&
8292 local_got_offsets[r_symndx] != (bfd_vma) -1);
8294 off = local_got_offsets[r_symndx];
8296 /* The offset must always be a multiple of 4. We use the
8297 least significant bit to record whether we have already
8298 generated the necessary reloc. */
8303 /* If we are addressing a Thumb function, we need to
8304 adjust the address by one, so that attempts to
8305 call the function pointer will correctly
8306 interpret it as Thumb code. */
8307 if (sym_flags == STT_ARM_TFUNC)
8310 if (globals->use_rel)
8311 bfd_put_32 (output_bfd, value, sgot->contents + off);
8315 Elf_Internal_Rela outrel;
8318 BFD_ASSERT (srelgot != NULL);
8320 outrel.r_addend = addend + value;
8321 outrel.r_offset = (sgot->output_section->vma
8322 + sgot->output_offset
8324 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
8325 loc = srelgot->contents;
8326 loc += srelgot->reloc_count++ * RELOC_SIZE (globals);
8327 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
8330 local_got_offsets[r_symndx] |= 1;
8333 value = sgot->output_offset + off;
8335 if (r_type != R_ARM_GOT32)
8336 value += sgot->output_section->vma;
8338 return _bfd_final_link_relocate (howto, input_bfd, input_section,
8339 contents, rel->r_offset, value,
8342 case R_ARM_TLS_LDO32:
8343 value = value - dtpoff_base (info);
8345 return _bfd_final_link_relocate (howto, input_bfd, input_section,
8346 contents, rel->r_offset, value,
8349 case R_ARM_TLS_LDM32:
8356 off = globals->tls_ldm_got.offset;
8362 /* If we don't know the module number, create a relocation
8366 Elf_Internal_Rela outrel;
8369 if (srelgot == NULL)
8372 outrel.r_addend = 0;
8373 outrel.r_offset = (sgot->output_section->vma
8374 + sgot->output_offset + off);
8375 outrel.r_info = ELF32_R_INFO (0, R_ARM_TLS_DTPMOD32);
8377 if (globals->use_rel)
8378 bfd_put_32 (output_bfd, outrel.r_addend,
8379 sgot->contents + off);
8381 loc = srelgot->contents;
8382 loc += srelgot->reloc_count++ * RELOC_SIZE (globals);
8383 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
8386 bfd_put_32 (output_bfd, 1, sgot->contents + off);
8388 globals->tls_ldm_got.offset |= 1;
8391 value = sgot->output_section->vma + sgot->output_offset + off
8392 - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
8394 return _bfd_final_link_relocate (howto, input_bfd, input_section,
8395 contents, rel->r_offset, value,
8399 case R_ARM_TLS_CALL:
8400 case R_ARM_THM_TLS_CALL:
8401 case R_ARM_TLS_GD32:
8402 case R_ARM_TLS_IE32:
8403 case R_ARM_TLS_GOTDESC:
8404 case R_ARM_TLS_DESCSEQ:
8405 case R_ARM_THM_TLS_DESCSEQ:
8407 bfd_vma off, offplt;
8411 BFD_ASSERT (sgot != NULL);
8416 dyn = globals->root.dynamic_sections_created;
8417 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
8419 || !SYMBOL_REFERENCES_LOCAL (info, h)))
8421 *unresolved_reloc_p = FALSE;
8424 off = h->got.offset;
8425 offplt = elf32_arm_hash_entry (h)->tlsdesc_got;
8426 tls_type = ((struct elf32_arm_link_hash_entry *) h)->tls_type;
8430 BFD_ASSERT (local_got_offsets != NULL);
8431 off = local_got_offsets[r_symndx];
8432 offplt = local_tlsdesc_gotents[r_symndx];
8433 tls_type = elf32_arm_local_got_tls_type (input_bfd)[r_symndx];
8436 /* Linker relaxations happens from one of the
8437 R_ARM_{GOTDESC,CALL,DESCSEQ} relocations to IE or LE. */
8438 if (ELF32_R_TYPE(rel->r_info) != r_type)
8439 tls_type = GOT_TLS_IE;
8441 BFD_ASSERT (tls_type != GOT_UNKNOWN);
8447 bfd_boolean need_relocs = FALSE;
8448 Elf_Internal_Rela outrel;
8449 bfd_byte *loc = NULL;
8452 /* The GOT entries have not been initialized yet. Do it
8453 now, and emit any relocations. If both an IE GOT and a
8454 GD GOT are necessary, we emit the GD first. */
8456 if ((info->shared || indx != 0)
8458 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8459 || h->root.type != bfd_link_hash_undefweak))
8462 BFD_ASSERT (srelgot != NULL);
8465 if (tls_type & GOT_TLS_GDESC)
8467 /* We should have relaxed, unless this is an undefined
8469 BFD_ASSERT ((h && (h->root.type == bfd_link_hash_undefweak))
8471 BFD_ASSERT (globals->sgotplt_jump_table_size + offplt + 8
8472 <= globals->root.sgotplt->size);
8474 outrel.r_addend = 0;
8475 outrel.r_offset = (globals->root.sgotplt->output_section->vma
8476 + globals->root.sgotplt->output_offset
8478 + globals->sgotplt_jump_table_size);
8480 outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_DESC);
8481 sreloc = globals->root.srelplt;
8482 loc = sreloc->contents;
8483 loc += globals->next_tls_desc_index++ * RELOC_SIZE (globals);
8484 BFD_ASSERT (loc + RELOC_SIZE (globals)
8485 <= sreloc->contents + sreloc->size);
8487 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
8489 /* For globals, the first word in the relocation gets
8490 the relocation index and the top bit set, or zero,
8491 if we're binding now. For locals, it gets the
8492 symbol's offset in the tls section. */
8493 bfd_put_32 (output_bfd,
8494 !h ? value - elf_hash_table (info)->tls_sec->vma
8495 : info->flags & DF_BIND_NOW ? 0
8496 : 0x80000000 | ELF32_R_SYM (outrel.r_info),
8497 globals->root.sgotplt->contents + offplt +
8498 globals->sgotplt_jump_table_size);
8500 /* Second word in the relocation is always zero. */
8501 bfd_put_32 (output_bfd, 0,
8502 globals->root.sgotplt->contents + offplt +
8503 globals->sgotplt_jump_table_size + 4);
8505 if (tls_type & GOT_TLS_GD)
8509 outrel.r_addend = 0;
8510 outrel.r_offset = (sgot->output_section->vma
8511 + sgot->output_offset
8513 outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_DTPMOD32);
8515 if (globals->use_rel)
8516 bfd_put_32 (output_bfd, outrel.r_addend,
8517 sgot->contents + cur_off);
8518 loc = srelgot->contents;
8519 loc += srelgot->reloc_count++ * RELOC_SIZE (globals);
8521 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
8524 bfd_put_32 (output_bfd, value - dtpoff_base (info),
8525 sgot->contents + cur_off + 4);
8528 outrel.r_addend = 0;
8529 outrel.r_info = ELF32_R_INFO (indx,
8530 R_ARM_TLS_DTPOFF32);
8531 outrel.r_offset += 4;
8533 if (globals->use_rel)
8534 bfd_put_32 (output_bfd, outrel.r_addend,
8535 sgot->contents + cur_off + 4);
8537 loc = srelgot->contents;
8538 loc += srelgot->reloc_count++ * RELOC_SIZE (globals);
8540 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
8545 /* If we are not emitting relocations for a
8546 general dynamic reference, then we must be in a
8547 static link or an executable link with the
8548 symbol binding locally. Mark it as belonging
8549 to module 1, the executable. */
8550 bfd_put_32 (output_bfd, 1,
8551 sgot->contents + cur_off);
8552 bfd_put_32 (output_bfd, value - dtpoff_base (info),
8553 sgot->contents + cur_off + 4);
8559 if (tls_type & GOT_TLS_IE)
8564 outrel.r_addend = value - dtpoff_base (info);
8566 outrel.r_addend = 0;
8567 outrel.r_offset = (sgot->output_section->vma
8568 + sgot->output_offset
8570 outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_TPOFF32);
8572 if (globals->use_rel)
8573 bfd_put_32 (output_bfd, outrel.r_addend,
8574 sgot->contents + cur_off);
8576 loc = srelgot->contents;
8577 loc += srelgot->reloc_count++ * RELOC_SIZE (globals);
8579 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
8582 bfd_put_32 (output_bfd, tpoff (info, value),
8583 sgot->contents + cur_off);
8590 local_got_offsets[r_symndx] |= 1;
8593 if ((tls_type & GOT_TLS_GD) && r_type != R_ARM_TLS_GD32)
8595 else if (tls_type & GOT_TLS_GDESC)
8598 if (ELF32_R_TYPE(rel->r_info) == R_ARM_TLS_CALL
8599 || ELF32_R_TYPE(rel->r_info) == R_ARM_THM_TLS_CALL)
8601 bfd_signed_vma offset;
8602 enum elf32_arm_stub_type stub_type
8603 = arm_type_of_stub (info, input_section, rel, &sym_flags,
8604 (struct elf32_arm_link_hash_entry *)h,
8605 globals->tls_trampoline, globals->root.splt,
8606 input_bfd, sym_name);
8608 if (stub_type != arm_stub_none)
8610 struct elf32_arm_stub_hash_entry *stub_entry
8611 = elf32_arm_get_stub_entry
8612 (input_section, globals->root.splt, 0, rel,
8613 globals, stub_type);
8614 offset = (stub_entry->stub_offset
8615 + stub_entry->stub_sec->output_offset
8616 + stub_entry->stub_sec->output_section->vma);
8619 offset = (globals->root.splt->output_section->vma
8620 + globals->root.splt->output_offset
8621 + globals->tls_trampoline);
8623 if (ELF32_R_TYPE(rel->r_info) == R_ARM_TLS_CALL)
8627 offset -= (input_section->output_section->vma +
8628 input_section->output_offset + rel->r_offset + 8);
8632 value = inst | (globals->use_blx ? 0xfa000000 : 0xeb000000);
8636 /* Thumb blx encodes the offset in a complicated
8638 unsigned upper_insn, lower_insn;
8641 offset -= (input_section->output_section->vma +
8642 input_section->output_offset
8643 + rel->r_offset + 4);
8645 /* Round up the offset to a word boundary */
8646 offset = (offset + 2) & ~2;
8648 upper_insn = (0xf000
8649 | ((offset >> 12) & 0x3ff)
8651 lower_insn = (0xc000
8652 | (((!((offset >> 23) & 1)) ^ neg) << 13)
8653 | (((!((offset >> 22) & 1)) ^ neg) << 11)
8654 | ((offset >> 1) & 0x7ff));
8655 bfd_put_16 (input_bfd, upper_insn, hit_data);
8656 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
8657 return bfd_reloc_ok;
8660 /* These relocations needs special care, as besides the fact
8661 they point somewhere in .gotplt, the addend must be
8662 adjusted accordingly depending on the type of instruction
8664 else if ((r_type == R_ARM_TLS_GOTDESC) && (tls_type & GOT_TLS_GDESC))
8666 unsigned long data, insn;
8669 data = bfd_get_32 (input_bfd, hit_data);
8675 insn = bfd_get_16 (input_bfd, contents + rel->r_offset - data);
8676 if ((insn & 0xf000) == 0xf000 || (insn & 0xf800) == 0xe800)
8678 | bfd_get_16 (input_bfd,
8679 contents + rel->r_offset - data + 2);
8680 if ((insn & 0xf800c000) == 0xf000c000)
8683 else if ((insn & 0xffffff00) == 0x4400)
8688 (*_bfd_error_handler)
8689 (_("%B(%A+0x%lx):unexpected Thumb instruction '0x%x' referenced by TLS_GOTDESC"),
8690 input_bfd, input_section,
8691 (unsigned long)rel->r_offset, insn);
8692 return bfd_reloc_notsupported;
8697 insn = bfd_get_32 (input_bfd, contents + rel->r_offset - data);
8702 case 0xfa: /* blx */
8706 case 0xe0: /* add */
8711 (*_bfd_error_handler)
8712 (_("%B(%A+0x%lx):unexpected ARM instruction '0x%x' referenced by TLS_GOTDESC"),
8713 input_bfd, input_section,
8714 (unsigned long)rel->r_offset, insn);
8715 return bfd_reloc_notsupported;
8719 value += ((globals->root.sgotplt->output_section->vma
8720 + globals->root.sgotplt->output_offset + off)
8721 - (input_section->output_section->vma
8722 + input_section->output_offset
8724 + globals->sgotplt_jump_table_size);
8727 value = ((globals->root.sgot->output_section->vma
8728 + globals->root.sgot->output_offset + off)
8729 - (input_section->output_section->vma
8730 + input_section->output_offset + rel->r_offset));
8732 return _bfd_final_link_relocate (howto, input_bfd, input_section,
8733 contents, rel->r_offset, value,
8737 case R_ARM_TLS_LE32:
8740 (*_bfd_error_handler)
8741 (_("%B(%A+0x%lx): R_ARM_TLS_LE32 relocation not permitted in shared object"),
8742 input_bfd, input_section,
8743 (long) rel->r_offset, howto->name);
8744 return (bfd_reloc_status_type) FALSE;
8747 value = tpoff (info, value);
8749 return _bfd_final_link_relocate (howto, input_bfd, input_section,
8750 contents, rel->r_offset, value,
8754 if (globals->fix_v4bx)
8756 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
8758 /* Ensure that we have a BX instruction. */
8759 BFD_ASSERT ((insn & 0x0ffffff0) == 0x012fff10);
8761 if (globals->fix_v4bx == 2 && (insn & 0xf) != 0xf)
8763 /* Branch to veneer. */
8765 glue_addr = elf32_arm_bx_glue (info, insn & 0xf);
8766 glue_addr -= input_section->output_section->vma
8767 + input_section->output_offset
8768 + rel->r_offset + 8;
8769 insn = (insn & 0xf0000000) | 0x0a000000
8770 | ((glue_addr >> 2) & 0x00ffffff);
8774 /* Preserve Rm (lowest four bits) and the condition code
8775 (highest four bits). Other bits encode MOV PC,Rm. */
8776 insn = (insn & 0xf000000f) | 0x01a0f000;
8779 bfd_put_32 (input_bfd, insn, hit_data);
8781 return bfd_reloc_ok;
8783 case R_ARM_MOVW_ABS_NC:
8784 case R_ARM_MOVT_ABS:
8785 case R_ARM_MOVW_PREL_NC:
8786 case R_ARM_MOVT_PREL:
8787 /* Until we properly support segment-base-relative addressing then
8788 we assume the segment base to be zero, as for the group relocations.
8789 Thus R_ARM_MOVW_BREL_NC has the same semantics as R_ARM_MOVW_ABS_NC
8790 and R_ARM_MOVT_BREL has the same semantics as R_ARM_MOVT_ABS. */
8791 case R_ARM_MOVW_BREL_NC:
8792 case R_ARM_MOVW_BREL:
8793 case R_ARM_MOVT_BREL:
8795 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
8797 if (globals->use_rel)
8799 addend = ((insn >> 4) & 0xf000) | (insn & 0xfff);
8800 signed_addend = (addend ^ 0x8000) - 0x8000;
8803 value += signed_addend;
8805 if (r_type == R_ARM_MOVW_PREL_NC || r_type == R_ARM_MOVT_PREL)
8806 value -= (input_section->output_section->vma
8807 + input_section->output_offset + rel->r_offset);
8809 if (r_type == R_ARM_MOVW_BREL && value >= 0x10000)
8810 return bfd_reloc_overflow;
8812 if (sym_flags == STT_ARM_TFUNC)
8815 if (r_type == R_ARM_MOVT_ABS || r_type == R_ARM_MOVT_PREL
8816 || r_type == R_ARM_MOVT_BREL)
8820 insn |= value & 0xfff;
8821 insn |= (value & 0xf000) << 4;
8822 bfd_put_32 (input_bfd, insn, hit_data);
8824 return bfd_reloc_ok;
8826 case R_ARM_THM_MOVW_ABS_NC:
8827 case R_ARM_THM_MOVT_ABS:
8828 case R_ARM_THM_MOVW_PREL_NC:
8829 case R_ARM_THM_MOVT_PREL:
8830 /* Until we properly support segment-base-relative addressing then
8831 we assume the segment base to be zero, as for the above relocations.
8832 Thus R_ARM_THM_MOVW_BREL_NC has the same semantics as
8833 R_ARM_THM_MOVW_ABS_NC and R_ARM_THM_MOVT_BREL has the same semantics
8834 as R_ARM_THM_MOVT_ABS. */
8835 case R_ARM_THM_MOVW_BREL_NC:
8836 case R_ARM_THM_MOVW_BREL:
8837 case R_ARM_THM_MOVT_BREL:
8841 insn = bfd_get_16 (input_bfd, hit_data) << 16;
8842 insn |= bfd_get_16 (input_bfd, hit_data + 2);
8844 if (globals->use_rel)
8846 addend = ((insn >> 4) & 0xf000)
8847 | ((insn >> 15) & 0x0800)
8848 | ((insn >> 4) & 0x0700)
8850 signed_addend = (addend ^ 0x8000) - 0x8000;
8853 value += signed_addend;
8855 if (r_type == R_ARM_THM_MOVW_PREL_NC || r_type == R_ARM_THM_MOVT_PREL)
8856 value -= (input_section->output_section->vma
8857 + input_section->output_offset + rel->r_offset);
8859 if (r_type == R_ARM_THM_MOVW_BREL && value >= 0x10000)
8860 return bfd_reloc_overflow;
8862 if (sym_flags == STT_ARM_TFUNC)
8865 if (r_type == R_ARM_THM_MOVT_ABS || r_type == R_ARM_THM_MOVT_PREL
8866 || r_type == R_ARM_THM_MOVT_BREL)
8870 insn |= (value & 0xf000) << 4;
8871 insn |= (value & 0x0800) << 15;
8872 insn |= (value & 0x0700) << 4;
8873 insn |= (value & 0x00ff);
8875 bfd_put_16 (input_bfd, insn >> 16, hit_data);
8876 bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2);
8878 return bfd_reloc_ok;
8880 case R_ARM_ALU_PC_G0_NC:
8881 case R_ARM_ALU_PC_G1_NC:
8882 case R_ARM_ALU_PC_G0:
8883 case R_ARM_ALU_PC_G1:
8884 case R_ARM_ALU_PC_G2:
8885 case R_ARM_ALU_SB_G0_NC:
8886 case R_ARM_ALU_SB_G1_NC:
8887 case R_ARM_ALU_SB_G0:
8888 case R_ARM_ALU_SB_G1:
8889 case R_ARM_ALU_SB_G2:
8891 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
8892 bfd_vma pc = input_section->output_section->vma
8893 + input_section->output_offset + rel->r_offset;
8894 /* sb should be the origin of the *segment* containing the symbol.
8895 It is not clear how to obtain this OS-dependent value, so we
8896 make an arbitrary choice of zero. */
8900 bfd_signed_vma signed_value;
8903 /* Determine which group of bits to select. */
8906 case R_ARM_ALU_PC_G0_NC:
8907 case R_ARM_ALU_PC_G0:
8908 case R_ARM_ALU_SB_G0_NC:
8909 case R_ARM_ALU_SB_G0:
8913 case R_ARM_ALU_PC_G1_NC:
8914 case R_ARM_ALU_PC_G1:
8915 case R_ARM_ALU_SB_G1_NC:
8916 case R_ARM_ALU_SB_G1:
8920 case R_ARM_ALU_PC_G2:
8921 case R_ARM_ALU_SB_G2:
8929 /* If REL, extract the addend from the insn. If RELA, it will
8930 have already been fetched for us. */
8931 if (globals->use_rel)
8934 bfd_vma constant = insn & 0xff;
8935 bfd_vma rotation = (insn & 0xf00) >> 8;
8938 signed_addend = constant;
8941 /* Compensate for the fact that in the instruction, the
8942 rotation is stored in multiples of 2 bits. */
8945 /* Rotate "constant" right by "rotation" bits. */
8946 signed_addend = (constant >> rotation) |
8947 (constant << (8 * sizeof (bfd_vma) - rotation));
8950 /* Determine if the instruction is an ADD or a SUB.
8951 (For REL, this determines the sign of the addend.) */
8952 negative = identify_add_or_sub (insn);
8955 (*_bfd_error_handler)
8956 (_("%B(%A+0x%lx): Only ADD or SUB instructions are allowed for ALU group relocations"),
8957 input_bfd, input_section,
8958 (long) rel->r_offset, howto->name);
8959 return bfd_reloc_overflow;
8962 signed_addend *= negative;
8965 /* Compute the value (X) to go in the place. */
8966 if (r_type == R_ARM_ALU_PC_G0_NC
8967 || r_type == R_ARM_ALU_PC_G1_NC
8968 || r_type == R_ARM_ALU_PC_G0
8969 || r_type == R_ARM_ALU_PC_G1
8970 || r_type == R_ARM_ALU_PC_G2)
8972 signed_value = value - pc + signed_addend;
8974 /* Section base relative. */
8975 signed_value = value - sb + signed_addend;
8977 /* If the target symbol is a Thumb function, then set the
8978 Thumb bit in the address. */
8979 if (sym_flags == STT_ARM_TFUNC)
8982 /* Calculate the value of the relevant G_n, in encoded
8983 constant-with-rotation format. */
8984 g_n = calculate_group_reloc_mask (abs (signed_value), group,
8987 /* Check for overflow if required. */
8988 if ((r_type == R_ARM_ALU_PC_G0
8989 || r_type == R_ARM_ALU_PC_G1
8990 || r_type == R_ARM_ALU_PC_G2
8991 || r_type == R_ARM_ALU_SB_G0
8992 || r_type == R_ARM_ALU_SB_G1
8993 || r_type == R_ARM_ALU_SB_G2) && residual != 0)
8995 (*_bfd_error_handler)
8996 (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
8997 input_bfd, input_section,
8998 (long) rel->r_offset, abs (signed_value), howto->name);
8999 return bfd_reloc_overflow;
9002 /* Mask out the value and the ADD/SUB part of the opcode; take care
9003 not to destroy the S bit. */
9006 /* Set the opcode according to whether the value to go in the
9007 place is negative. */
9008 if (signed_value < 0)
9013 /* Encode the offset. */
9016 bfd_put_32 (input_bfd, insn, hit_data);
9018 return bfd_reloc_ok;
9020 case R_ARM_LDR_PC_G0:
9021 case R_ARM_LDR_PC_G1:
9022 case R_ARM_LDR_PC_G2:
9023 case R_ARM_LDR_SB_G0:
9024 case R_ARM_LDR_SB_G1:
9025 case R_ARM_LDR_SB_G2:
9027 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
9028 bfd_vma pc = input_section->output_section->vma
9029 + input_section->output_offset + rel->r_offset;
9030 bfd_vma sb = 0; /* See note above. */
9032 bfd_signed_vma signed_value;
9035 /* Determine which groups of bits to calculate. */
9038 case R_ARM_LDR_PC_G0:
9039 case R_ARM_LDR_SB_G0:
9043 case R_ARM_LDR_PC_G1:
9044 case R_ARM_LDR_SB_G1:
9048 case R_ARM_LDR_PC_G2:
9049 case R_ARM_LDR_SB_G2:
9057 /* If REL, extract the addend from the insn. If RELA, it will
9058 have already been fetched for us. */
9059 if (globals->use_rel)
9061 int negative = (insn & (1 << 23)) ? 1 : -1;
9062 signed_addend = negative * (insn & 0xfff);
9065 /* Compute the value (X) to go in the place. */
9066 if (r_type == R_ARM_LDR_PC_G0
9067 || r_type == R_ARM_LDR_PC_G1
9068 || r_type == R_ARM_LDR_PC_G2)
9070 signed_value = value - pc + signed_addend;
9072 /* Section base relative. */
9073 signed_value = value - sb + signed_addend;
9075 /* Calculate the value of the relevant G_{n-1} to obtain
9076 the residual at that stage. */
9077 calculate_group_reloc_mask (abs (signed_value), group - 1, &residual);
9079 /* Check for overflow. */
9080 if (residual >= 0x1000)
9082 (*_bfd_error_handler)
9083 (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
9084 input_bfd, input_section,
9085 (long) rel->r_offset, abs (signed_value), howto->name);
9086 return bfd_reloc_overflow;
9089 /* Mask out the value and U bit. */
9092 /* Set the U bit if the value to go in the place is non-negative. */
9093 if (signed_value >= 0)
9096 /* Encode the offset. */
9099 bfd_put_32 (input_bfd, insn, hit_data);
9101 return bfd_reloc_ok;
9103 case R_ARM_LDRS_PC_G0:
9104 case R_ARM_LDRS_PC_G1:
9105 case R_ARM_LDRS_PC_G2:
9106 case R_ARM_LDRS_SB_G0:
9107 case R_ARM_LDRS_SB_G1:
9108 case R_ARM_LDRS_SB_G2:
9110 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
9111 bfd_vma pc = input_section->output_section->vma
9112 + input_section->output_offset + rel->r_offset;
9113 bfd_vma sb = 0; /* See note above. */
9115 bfd_signed_vma signed_value;
9118 /* Determine which groups of bits to calculate. */
9121 case R_ARM_LDRS_PC_G0:
9122 case R_ARM_LDRS_SB_G0:
9126 case R_ARM_LDRS_PC_G1:
9127 case R_ARM_LDRS_SB_G1:
9131 case R_ARM_LDRS_PC_G2:
9132 case R_ARM_LDRS_SB_G2:
9140 /* If REL, extract the addend from the insn. If RELA, it will
9141 have already been fetched for us. */
9142 if (globals->use_rel)
9144 int negative = (insn & (1 << 23)) ? 1 : -1;
9145 signed_addend = negative * (((insn & 0xf00) >> 4) + (insn & 0xf));
9148 /* Compute the value (X) to go in the place. */
9149 if (r_type == R_ARM_LDRS_PC_G0
9150 || r_type == R_ARM_LDRS_PC_G1
9151 || r_type == R_ARM_LDRS_PC_G2)
9153 signed_value = value - pc + signed_addend;
9155 /* Section base relative. */
9156 signed_value = value - sb + signed_addend;
9158 /* Calculate the value of the relevant G_{n-1} to obtain
9159 the residual at that stage. */
9160 calculate_group_reloc_mask (abs (signed_value), group - 1, &residual);
9162 /* Check for overflow. */
9163 if (residual >= 0x100)
9165 (*_bfd_error_handler)
9166 (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
9167 input_bfd, input_section,
9168 (long) rel->r_offset, abs (signed_value), howto->name);
9169 return bfd_reloc_overflow;
9172 /* Mask out the value and U bit. */
9175 /* Set the U bit if the value to go in the place is non-negative. */
9176 if (signed_value >= 0)
9179 /* Encode the offset. */
9180 insn |= ((residual & 0xf0) << 4) | (residual & 0xf);
9182 bfd_put_32 (input_bfd, insn, hit_data);
9184 return bfd_reloc_ok;
9186 case R_ARM_LDC_PC_G0:
9187 case R_ARM_LDC_PC_G1:
9188 case R_ARM_LDC_PC_G2:
9189 case R_ARM_LDC_SB_G0:
9190 case R_ARM_LDC_SB_G1:
9191 case R_ARM_LDC_SB_G2:
9193 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
9194 bfd_vma pc = input_section->output_section->vma
9195 + input_section->output_offset + rel->r_offset;
9196 bfd_vma sb = 0; /* See note above. */
9198 bfd_signed_vma signed_value;
9201 /* Determine which groups of bits to calculate. */
9204 case R_ARM_LDC_PC_G0:
9205 case R_ARM_LDC_SB_G0:
9209 case R_ARM_LDC_PC_G1:
9210 case R_ARM_LDC_SB_G1:
9214 case R_ARM_LDC_PC_G2:
9215 case R_ARM_LDC_SB_G2:
9223 /* If REL, extract the addend from the insn. If RELA, it will
9224 have already been fetched for us. */
9225 if (globals->use_rel)
9227 int negative = (insn & (1 << 23)) ? 1 : -1;
9228 signed_addend = negative * ((insn & 0xff) << 2);
9231 /* Compute the value (X) to go in the place. */
9232 if (r_type == R_ARM_LDC_PC_G0
9233 || r_type == R_ARM_LDC_PC_G1
9234 || r_type == R_ARM_LDC_PC_G2)
9236 signed_value = value - pc + signed_addend;
9238 /* Section base relative. */
9239 signed_value = value - sb + signed_addend;
9241 /* Calculate the value of the relevant G_{n-1} to obtain
9242 the residual at that stage. */
9243 calculate_group_reloc_mask (abs (signed_value), group - 1, &residual);
9245 /* Check for overflow. (The absolute value to go in the place must be
9246 divisible by four and, after having been divided by four, must
9247 fit in eight bits.) */
9248 if ((residual & 0x3) != 0 || residual >= 0x400)
9250 (*_bfd_error_handler)
9251 (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
9252 input_bfd, input_section,
9253 (long) rel->r_offset, abs (signed_value), howto->name);
9254 return bfd_reloc_overflow;
9257 /* Mask out the value and U bit. */
9260 /* Set the U bit if the value to go in the place is non-negative. */
9261 if (signed_value >= 0)
9264 /* Encode the offset. */
9265 insn |= residual >> 2;
9267 bfd_put_32 (input_bfd, insn, hit_data);
9269 return bfd_reloc_ok;
9272 return bfd_reloc_notsupported;
9276 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
9278 arm_add_to_rel (bfd * abfd,
9280 reloc_howto_type * howto,
9281 bfd_signed_vma increment)
9283 bfd_signed_vma addend;
9285 if (howto->type == R_ARM_THM_CALL
9286 || howto->type == R_ARM_THM_JUMP24)
9288 int upper_insn, lower_insn;
9291 upper_insn = bfd_get_16 (abfd, address);
9292 lower_insn = bfd_get_16 (abfd, address + 2);
9293 upper = upper_insn & 0x7ff;
9294 lower = lower_insn & 0x7ff;
9296 addend = (upper << 12) | (lower << 1);
9297 addend += increment;
9300 upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
9301 lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
9303 bfd_put_16 (abfd, (bfd_vma) upper_insn, address);
9304 bfd_put_16 (abfd, (bfd_vma) lower_insn, address + 2);
9310 contents = bfd_get_32 (abfd, address);
9312 /* Get the (signed) value from the instruction. */
9313 addend = contents & howto->src_mask;
9314 if (addend & ((howto->src_mask + 1) >> 1))
9316 bfd_signed_vma mask;
9319 mask &= ~ howto->src_mask;
9323 /* Add in the increment, (which is a byte value). */
9324 switch (howto->type)
9327 addend += increment;
9334 addend <<= howto->size;
9335 addend += increment;
9337 /* Should we check for overflow here ? */
9339 /* Drop any undesired bits. */
9340 addend >>= howto->rightshift;
9344 contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
9346 bfd_put_32 (abfd, contents, address);
9350 #define IS_ARM_TLS_RELOC(R_TYPE) \
9351 ((R_TYPE) == R_ARM_TLS_GD32 \
9352 || (R_TYPE) == R_ARM_TLS_LDO32 \
9353 || (R_TYPE) == R_ARM_TLS_LDM32 \
9354 || (R_TYPE) == R_ARM_TLS_DTPOFF32 \
9355 || (R_TYPE) == R_ARM_TLS_DTPMOD32 \
9356 || (R_TYPE) == R_ARM_TLS_TPOFF32 \
9357 || (R_TYPE) == R_ARM_TLS_LE32 \
9358 || (R_TYPE) == R_ARM_TLS_IE32 \
9359 || IS_ARM_TLS_GNU_RELOC (R_TYPE))
9361 /* Specific set of relocations for the gnu tls dialect. */
9362 #define IS_ARM_TLS_GNU_RELOC(R_TYPE) \
9363 ((R_TYPE) == R_ARM_TLS_GOTDESC \
9364 || (R_TYPE) == R_ARM_TLS_CALL \
9365 || (R_TYPE) == R_ARM_THM_TLS_CALL \
9366 || (R_TYPE) == R_ARM_TLS_DESCSEQ \
9367 || (R_TYPE) == R_ARM_THM_TLS_DESCSEQ)
9369 /* Relocate an ARM ELF section. */
9372 elf32_arm_relocate_section (bfd * output_bfd,
9373 struct bfd_link_info * info,
9375 asection * input_section,
9376 bfd_byte * contents,
9377 Elf_Internal_Rela * relocs,
9378 Elf_Internal_Sym * local_syms,
9379 asection ** local_sections)
9381 Elf_Internal_Shdr *symtab_hdr;
9382 struct elf_link_hash_entry **sym_hashes;
9383 Elf_Internal_Rela *rel;
9384 Elf_Internal_Rela *relend;
9386 struct elf32_arm_link_hash_table * globals;
9388 globals = elf32_arm_hash_table (info);
9389 if (globals == NULL)
9392 symtab_hdr = & elf_symtab_hdr (input_bfd);
9393 sym_hashes = elf_sym_hashes (input_bfd);
9396 relend = relocs + input_section->reloc_count;
9397 for (; rel < relend; rel++)
9400 reloc_howto_type * howto;
9401 unsigned long r_symndx;
9402 Elf_Internal_Sym * sym;
9404 struct elf_link_hash_entry * h;
9406 bfd_reloc_status_type r;
9409 bfd_boolean unresolved_reloc = FALSE;
9410 char *error_message = NULL;
9412 r_symndx = ELF32_R_SYM (rel->r_info);
9413 r_type = ELF32_R_TYPE (rel->r_info);
9414 r_type = arm_real_reloc_type (globals, r_type);
9416 if ( r_type == R_ARM_GNU_VTENTRY
9417 || r_type == R_ARM_GNU_VTINHERIT)
9420 bfd_reloc.howto = elf32_arm_howto_from_type (r_type);
9421 howto = bfd_reloc.howto;
9427 if (r_symndx < symtab_hdr->sh_info)
9429 sym = local_syms + r_symndx;
9430 sym_type = ELF32_ST_TYPE (sym->st_info);
9431 sec = local_sections[r_symndx];
9433 /* An object file might have a reference to a local
9434 undefined symbol. This is a daft object file, but we
9435 should at least do something about it. V4BX & NONE
9436 relocations do not use the symbol and are explicitly
9437 allowed to use the undefined symbol, so allow those.
9438 Likewise for relocations against STN_UNDEF. */
9439 if (r_type != R_ARM_V4BX
9440 && r_type != R_ARM_NONE
9441 && r_symndx != STN_UNDEF
9442 && bfd_is_und_section (sec)
9443 && ELF_ST_BIND (sym->st_info) != STB_WEAK)
9445 if (!info->callbacks->undefined_symbol
9446 (info, bfd_elf_string_from_elf_section
9447 (input_bfd, symtab_hdr->sh_link, sym->st_name),
9448 input_bfd, input_section,
9449 rel->r_offset, TRUE))
9453 if (globals->use_rel)
9455 relocation = (sec->output_section->vma
9456 + sec->output_offset
9458 if (!info->relocatable
9459 && (sec->flags & SEC_MERGE)
9460 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
9463 bfd_vma addend, value;
9467 case R_ARM_MOVW_ABS_NC:
9468 case R_ARM_MOVT_ABS:
9469 value = bfd_get_32 (input_bfd, contents + rel->r_offset);
9470 addend = ((value & 0xf0000) >> 4) | (value & 0xfff);
9471 addend = (addend ^ 0x8000) - 0x8000;
9474 case R_ARM_THM_MOVW_ABS_NC:
9475 case R_ARM_THM_MOVT_ABS:
9476 value = bfd_get_16 (input_bfd, contents + rel->r_offset)
9478 value |= bfd_get_16 (input_bfd,
9479 contents + rel->r_offset + 2);
9480 addend = ((value & 0xf7000) >> 4) | (value & 0xff)
9481 | ((value & 0x04000000) >> 15);
9482 addend = (addend ^ 0x8000) - 0x8000;
9486 if (howto->rightshift
9487 || (howto->src_mask & (howto->src_mask + 1)))
9489 (*_bfd_error_handler)
9490 (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
9491 input_bfd, input_section,
9492 (long) rel->r_offset, howto->name);
9496 value = bfd_get_32 (input_bfd, contents + rel->r_offset);
9498 /* Get the (signed) value from the instruction. */
9499 addend = value & howto->src_mask;
9500 if (addend & ((howto->src_mask + 1) >> 1))
9502 bfd_signed_vma mask;
9505 mask &= ~ howto->src_mask;
9513 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
9515 addend += msec->output_section->vma + msec->output_offset;
9517 /* Cases here must match those in the preceeding
9518 switch statement. */
9521 case R_ARM_MOVW_ABS_NC:
9522 case R_ARM_MOVT_ABS:
9523 value = (value & 0xfff0f000) | ((addend & 0xf000) << 4)
9525 bfd_put_32 (input_bfd, value, contents + rel->r_offset);
9528 case R_ARM_THM_MOVW_ABS_NC:
9529 case R_ARM_THM_MOVT_ABS:
9530 value = (value & 0xfbf08f00) | ((addend & 0xf700) << 4)
9531 | (addend & 0xff) | ((addend & 0x0800) << 15);
9532 bfd_put_16 (input_bfd, value >> 16,
9533 contents + rel->r_offset);
9534 bfd_put_16 (input_bfd, value,
9535 contents + rel->r_offset + 2);
9539 value = (value & ~ howto->dst_mask)
9540 | (addend & howto->dst_mask);
9541 bfd_put_32 (input_bfd, value, contents + rel->r_offset);
9547 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
9553 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
9554 r_symndx, symtab_hdr, sym_hashes,
9556 unresolved_reloc, warned);
9561 if (sec != NULL && elf_discarded_section (sec))
9562 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
9563 rel, relend, howto, contents);
9565 if (info->relocatable)
9567 /* This is a relocatable link. We don't have to change
9568 anything, unless the reloc is against a section symbol,
9569 in which case we have to adjust according to where the
9570 section symbol winds up in the output section. */
9571 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
9573 if (globals->use_rel)
9574 arm_add_to_rel (input_bfd, contents + rel->r_offset,
9575 howto, (bfd_signed_vma) sec->output_offset);
9577 rel->r_addend += sec->output_offset;
9583 name = h->root.root.string;
9586 name = (bfd_elf_string_from_elf_section
9587 (input_bfd, symtab_hdr->sh_link, sym->st_name));
9588 if (name == NULL || *name == '\0')
9589 name = bfd_section_name (input_bfd, sec);
9592 if (r_symndx != STN_UNDEF
9593 && r_type != R_ARM_NONE
9595 || h->root.type == bfd_link_hash_defined
9596 || h->root.type == bfd_link_hash_defweak)
9597 && IS_ARM_TLS_RELOC (r_type) != (sym_type == STT_TLS))
9599 (*_bfd_error_handler)
9600 ((sym_type == STT_TLS
9601 ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
9602 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
9605 (long) rel->r_offset,
9610 /* We call elf32_arm_final_link_relocate unless we're completely
9611 done, i.e., the relaxation produced the final output we want,
9612 and we won't let anybody mess with it. Also, we have to do
9613 addend adjustments in case of a R_ARM_TLS_GOTDESC relocation
9614 both in relaxed and non-relaxed cases */
9615 if ((elf32_arm_tls_transition (info, r_type, h) != (unsigned)r_type)
9616 || (IS_ARM_TLS_GNU_RELOC (r_type)
9617 && !((h ? elf32_arm_hash_entry (h)->tls_type :
9618 elf32_arm_local_got_tls_type (input_bfd)[r_symndx])
9621 r = elf32_arm_tls_relax (globals, input_bfd, input_section,
9622 contents, rel, h == NULL);
9623 /* This may have been marked unresolved because it came from
9624 a shared library. But we've just dealt with that. */
9625 unresolved_reloc = 0;
9628 r = bfd_reloc_continue;
9630 if (r == bfd_reloc_continue)
9631 r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
9632 input_section, contents, rel,
9633 relocation, info, sec, name,
9634 (h ? ELF_ST_TYPE (h->type) :
9635 ELF_ST_TYPE (sym->st_info)), h,
9636 &unresolved_reloc, &error_message);
9638 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
9639 because such sections are not SEC_ALLOC and thus ld.so will
9640 not process them. */
9641 if (unresolved_reloc
9642 && !((input_section->flags & SEC_DEBUGGING) != 0
9645 (*_bfd_error_handler)
9646 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
9649 (long) rel->r_offset,
9651 h->root.root.string);
9655 if (r != bfd_reloc_ok)
9659 case bfd_reloc_overflow:
9660 /* If the overflowing reloc was to an undefined symbol,
9661 we have already printed one error message and there
9662 is no point complaining again. */
9664 h->root.type != bfd_link_hash_undefined)
9665 && (!((*info->callbacks->reloc_overflow)
9666 (info, (h ? &h->root : NULL), name, howto->name,
9667 (bfd_vma) 0, input_bfd, input_section,
9672 case bfd_reloc_undefined:
9673 if (!((*info->callbacks->undefined_symbol)
9674 (info, name, input_bfd, input_section,
9675 rel->r_offset, TRUE)))
9679 case bfd_reloc_outofrange:
9680 error_message = _("out of range");
9683 case bfd_reloc_notsupported:
9684 error_message = _("unsupported relocation");
9687 case bfd_reloc_dangerous:
9688 /* error_message should already be set. */
9692 error_message = _("unknown error");
9696 BFD_ASSERT (error_message != NULL);
9697 if (!((*info->callbacks->reloc_dangerous)
9698 (info, error_message, input_bfd, input_section,
9709 /* Add a new unwind edit to the list described by HEAD, TAIL. If TINDEX is zero,
9710 adds the edit to the start of the list. (The list must be built in order of
9711 ascending TINDEX: the function's callers are primarily responsible for
9712 maintaining that condition). */
9715 add_unwind_table_edit (arm_unwind_table_edit **head,
9716 arm_unwind_table_edit **tail,
9717 arm_unwind_edit_type type,
9718 asection *linked_section,
9719 unsigned int tindex)
9721 arm_unwind_table_edit *new_edit = (arm_unwind_table_edit *)
9722 xmalloc (sizeof (arm_unwind_table_edit));
9724 new_edit->type = type;
9725 new_edit->linked_section = linked_section;
9726 new_edit->index = tindex;
9730 new_edit->next = NULL;
9733 (*tail)->next = new_edit;
9742 new_edit->next = *head;
9751 static _arm_elf_section_data *get_arm_elf_section_data (asection *);
9753 /* Increase the size of EXIDX_SEC by ADJUST bytes. ADJUST mau be negative. */
9755 adjust_exidx_size(asection *exidx_sec, int adjust)
9759 if (!exidx_sec->rawsize)
9760 exidx_sec->rawsize = exidx_sec->size;
9762 bfd_set_section_size (exidx_sec->owner, exidx_sec, exidx_sec->size + adjust);
9763 out_sec = exidx_sec->output_section;
9764 /* Adjust size of output section. */
9765 bfd_set_section_size (out_sec->owner, out_sec, out_sec->size +adjust);
9768 /* Insert an EXIDX_CANTUNWIND marker at the end of a section. */
9770 insert_cantunwind_after(asection *text_sec, asection *exidx_sec)
9772 struct _arm_elf_section_data *exidx_arm_data;
9774 exidx_arm_data = get_arm_elf_section_data (exidx_sec);
9775 add_unwind_table_edit (
9776 &exidx_arm_data->u.exidx.unwind_edit_list,
9777 &exidx_arm_data->u.exidx.unwind_edit_tail,
9778 INSERT_EXIDX_CANTUNWIND_AT_END, text_sec, UINT_MAX);
9780 adjust_exidx_size(exidx_sec, 8);
9783 /* Scan .ARM.exidx tables, and create a list describing edits which should be
9784 made to those tables, such that:
9786 1. Regions without unwind data are marked with EXIDX_CANTUNWIND entries.
9787 2. Duplicate entries are merged together (EXIDX_CANTUNWIND, or unwind
9788 codes which have been inlined into the index).
9790 If MERGE_EXIDX_ENTRIES is false, duplicate entries are not merged.
9792 The edits are applied when the tables are written
9793 (in elf32_arm_write_section).
9797 elf32_arm_fix_exidx_coverage (asection **text_section_order,
9798 unsigned int num_text_sections,
9799 struct bfd_link_info *info,
9800 bfd_boolean merge_exidx_entries)
9803 unsigned int last_second_word = 0, i;
9804 asection *last_exidx_sec = NULL;
9805 asection *last_text_sec = NULL;
9806 int last_unwind_type = -1;
9808 /* Walk over all EXIDX sections, and create backlinks from the corrsponding
9810 for (inp = info->input_bfds; inp != NULL; inp = inp->link_next)
9814 for (sec = inp->sections; sec != NULL; sec = sec->next)
9816 struct bfd_elf_section_data *elf_sec = elf_section_data (sec);
9817 Elf_Internal_Shdr *hdr = &elf_sec->this_hdr;
9819 if (!hdr || hdr->sh_type != SHT_ARM_EXIDX)
9822 if (elf_sec->linked_to)
9824 Elf_Internal_Shdr *linked_hdr
9825 = &elf_section_data (elf_sec->linked_to)->this_hdr;
9826 struct _arm_elf_section_data *linked_sec_arm_data
9827 = get_arm_elf_section_data (linked_hdr->bfd_section);
9829 if (linked_sec_arm_data == NULL)
9832 /* Link this .ARM.exidx section back from the text section it
9834 linked_sec_arm_data->u.text.arm_exidx_sec = sec;
9839 /* Walk all text sections in order of increasing VMA. Eilminate duplicate
9840 index table entries (EXIDX_CANTUNWIND and inlined unwind opcodes),
9841 and add EXIDX_CANTUNWIND entries for sections with no unwind table data. */
9843 for (i = 0; i < num_text_sections; i++)
9845 asection *sec = text_section_order[i];
9846 asection *exidx_sec;
9847 struct _arm_elf_section_data *arm_data = get_arm_elf_section_data (sec);
9848 struct _arm_elf_section_data *exidx_arm_data;
9849 bfd_byte *contents = NULL;
9850 int deleted_exidx_bytes = 0;
9852 arm_unwind_table_edit *unwind_edit_head = NULL;
9853 arm_unwind_table_edit *unwind_edit_tail = NULL;
9854 Elf_Internal_Shdr *hdr;
9857 if (arm_data == NULL)
9860 exidx_sec = arm_data->u.text.arm_exidx_sec;
9861 if (exidx_sec == NULL)
9863 /* Section has no unwind data. */
9864 if (last_unwind_type == 0 || !last_exidx_sec)
9867 /* Ignore zero sized sections. */
9871 insert_cantunwind_after(last_text_sec, last_exidx_sec);
9872 last_unwind_type = 0;
9876 /* Skip /DISCARD/ sections. */
9877 if (bfd_is_abs_section (exidx_sec->output_section))
9880 hdr = &elf_section_data (exidx_sec)->this_hdr;
9881 if (hdr->sh_type != SHT_ARM_EXIDX)
9884 exidx_arm_data = get_arm_elf_section_data (exidx_sec);
9885 if (exidx_arm_data == NULL)
9888 ibfd = exidx_sec->owner;
9890 if (hdr->contents != NULL)
9891 contents = hdr->contents;
9892 else if (! bfd_malloc_and_get_section (ibfd, exidx_sec, &contents))
9896 for (j = 0; j < hdr->sh_size; j += 8)
9898 unsigned int second_word = bfd_get_32 (ibfd, contents + j + 4);
9902 /* An EXIDX_CANTUNWIND entry. */
9903 if (second_word == 1)
9905 if (last_unwind_type == 0)
9909 /* Inlined unwinding data. Merge if equal to previous. */
9910 else if ((second_word & 0x80000000) != 0)
9912 if (merge_exidx_entries
9913 && last_second_word == second_word && last_unwind_type == 1)
9916 last_second_word = second_word;
9918 /* Normal table entry. In theory we could merge these too,
9919 but duplicate entries are likely to be much less common. */
9925 add_unwind_table_edit (&unwind_edit_head, &unwind_edit_tail,
9926 DELETE_EXIDX_ENTRY, NULL, j / 8);
9928 deleted_exidx_bytes += 8;
9931 last_unwind_type = unwind_type;
9934 /* Free contents if we allocated it ourselves. */
9935 if (contents != hdr->contents)
9938 /* Record edits to be applied later (in elf32_arm_write_section). */
9939 exidx_arm_data->u.exidx.unwind_edit_list = unwind_edit_head;
9940 exidx_arm_data->u.exidx.unwind_edit_tail = unwind_edit_tail;
9942 if (deleted_exidx_bytes > 0)
9943 adjust_exidx_size(exidx_sec, -deleted_exidx_bytes);
9945 last_exidx_sec = exidx_sec;
9946 last_text_sec = sec;
9949 /* Add terminating CANTUNWIND entry. */
9950 if (last_exidx_sec && last_unwind_type != 0)
9951 insert_cantunwind_after(last_text_sec, last_exidx_sec);
9957 elf32_arm_output_glue_section (struct bfd_link_info *info, bfd *obfd,
9958 bfd *ibfd, const char *name)
9960 asection *sec, *osec;
9962 sec = bfd_get_section_by_name (ibfd, name);
9963 if (sec == NULL || (sec->flags & SEC_EXCLUDE) != 0)
9966 osec = sec->output_section;
9967 if (elf32_arm_write_section (obfd, info, sec, sec->contents))
9970 if (! bfd_set_section_contents (obfd, osec, sec->contents,
9971 sec->output_offset, sec->size))
9978 elf32_arm_final_link (bfd *abfd, struct bfd_link_info *info)
9980 struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (info);
9981 asection *sec, *osec;
9983 if (globals == NULL)
9986 /* Invoke the regular ELF backend linker to do all the work. */
9987 if (!bfd_elf_final_link (abfd, info))
9990 /* Process stub sections (eg BE8 encoding, ...). */
9991 struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
9993 for (i=0; i<htab->top_id; i++)
9995 sec = htab->stub_group[i].stub_sec;
9996 /* Only process it once, in its link_sec slot. */
9997 if (sec && i == htab->stub_group[i].link_sec->id)
9999 osec = sec->output_section;
10000 elf32_arm_write_section (abfd, info, sec, sec->contents);
10001 if (! bfd_set_section_contents (abfd, osec, sec->contents,
10002 sec->output_offset, sec->size))
10007 /* Write out any glue sections now that we have created all the
10009 if (globals->bfd_of_glue_owner != NULL)
10011 if (! elf32_arm_output_glue_section (info, abfd,
10012 globals->bfd_of_glue_owner,
10013 ARM2THUMB_GLUE_SECTION_NAME))
10016 if (! elf32_arm_output_glue_section (info, abfd,
10017 globals->bfd_of_glue_owner,
10018 THUMB2ARM_GLUE_SECTION_NAME))
10021 if (! elf32_arm_output_glue_section (info, abfd,
10022 globals->bfd_of_glue_owner,
10023 VFP11_ERRATUM_VENEER_SECTION_NAME))
10026 if (! elf32_arm_output_glue_section (info, abfd,
10027 globals->bfd_of_glue_owner,
10028 ARM_BX_GLUE_SECTION_NAME))
10035 /* Set the right machine number. */
10038 elf32_arm_object_p (bfd *abfd)
10042 mach = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
10044 if (mach != bfd_mach_arm_unknown)
10045 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
10047 else if (elf_elfheader (abfd)->e_flags & EF_ARM_MAVERICK_FLOAT)
10048 bfd_default_set_arch_mach (abfd, bfd_arch_arm, bfd_mach_arm_ep9312);
10051 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
10056 /* Function to keep ARM specific flags in the ELF header. */
10059 elf32_arm_set_private_flags (bfd *abfd, flagword flags)
10061 if (elf_flags_init (abfd)
10062 && elf_elfheader (abfd)->e_flags != flags)
10064 if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
10066 if (flags & EF_ARM_INTERWORK)
10067 (*_bfd_error_handler)
10068 (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
10072 (_("Warning: Clearing the interworking flag of %B due to outside request"),
10078 elf_elfheader (abfd)->e_flags = flags;
10079 elf_flags_init (abfd) = TRUE;
10085 /* Copy backend specific data from one object module to another. */
10088 elf32_arm_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
10091 flagword out_flags;
10093 if (! is_arm_elf (ibfd) || ! is_arm_elf (obfd))
10096 in_flags = elf_elfheader (ibfd)->e_flags;
10097 out_flags = elf_elfheader (obfd)->e_flags;
10099 if (elf_flags_init (obfd)
10100 && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
10101 && in_flags != out_flags)
10103 /* Cannot mix APCS26 and APCS32 code. */
10104 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
10107 /* Cannot mix float APCS and non-float APCS code. */
10108 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
10111 /* If the src and dest have different interworking flags
10112 then turn off the interworking bit. */
10113 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
10115 if (out_flags & EF_ARM_INTERWORK)
10117 (_("Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
10120 in_flags &= ~EF_ARM_INTERWORK;
10123 /* Likewise for PIC, though don't warn for this case. */
10124 if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC))
10125 in_flags &= ~EF_ARM_PIC;
10128 elf_elfheader (obfd)->e_flags = in_flags;
10129 elf_flags_init (obfd) = TRUE;
10131 /* Also copy the EI_OSABI field. */
10132 elf_elfheader (obfd)->e_ident[EI_OSABI] =
10133 elf_elfheader (ibfd)->e_ident[EI_OSABI];
10135 /* Copy object attributes. */
10136 _bfd_elf_copy_obj_attributes (ibfd, obfd);
10141 /* Values for Tag_ABI_PCS_R9_use. */
10150 /* Values for Tag_ABI_PCS_RW_data. */
10153 AEABI_PCS_RW_data_absolute,
10154 AEABI_PCS_RW_data_PCrel,
10155 AEABI_PCS_RW_data_SBrel,
10156 AEABI_PCS_RW_data_unused
10159 /* Values for Tag_ABI_enum_size. */
10165 AEABI_enum_forced_wide
10168 /* Determine whether an object attribute tag takes an integer, a
10172 elf32_arm_obj_attrs_arg_type (int tag)
10174 if (tag == Tag_compatibility)
10175 return ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL;
10176 else if (tag == Tag_nodefaults)
10177 return ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_NO_DEFAULT;
10178 else if (tag == Tag_CPU_raw_name || tag == Tag_CPU_name)
10179 return ATTR_TYPE_FLAG_STR_VAL;
10181 return ATTR_TYPE_FLAG_INT_VAL;
10183 return (tag & 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL : ATTR_TYPE_FLAG_INT_VAL;
10186 /* The ABI defines that Tag_conformance should be emitted first, and that
10187 Tag_nodefaults should be second (if either is defined). This sets those
10188 two positions, and bumps up the position of all the remaining tags to
10191 elf32_arm_obj_attrs_order (int num)
10193 if (num == LEAST_KNOWN_OBJ_ATTRIBUTE)
10194 return Tag_conformance;
10195 if (num == LEAST_KNOWN_OBJ_ATTRIBUTE + 1)
10196 return Tag_nodefaults;
10197 if ((num - 2) < Tag_nodefaults)
10199 if ((num - 1) < Tag_conformance)
10204 /* Attribute numbers >=64 (mod 128) can be safely ignored. */
10206 elf32_arm_obj_attrs_handle_unknown (bfd *abfd, int tag)
10208 if ((tag & 127) < 64)
10211 (_("%B: Unknown mandatory EABI object attribute %d"),
10213 bfd_set_error (bfd_error_bad_value);
10219 (_("Warning: %B: Unknown EABI object attribute %d"),
10225 /* Read the architecture from the Tag_also_compatible_with attribute, if any.
10226 Returns -1 if no architecture could be read. */
10229 get_secondary_compatible_arch (bfd *abfd)
10231 obj_attribute *attr =
10232 &elf_known_obj_attributes_proc (abfd)[Tag_also_compatible_with];
10234 /* Note: the tag and its argument below are uleb128 values, though
10235 currently-defined values fit in one byte for each. */
10237 && attr->s[0] == Tag_CPU_arch
10238 && (attr->s[1] & 128) != 128
10239 && attr->s[2] == 0)
10242 /* This tag is "safely ignorable", so don't complain if it looks funny. */
10246 /* Set, or unset, the architecture of the Tag_also_compatible_with attribute.
10247 The tag is removed if ARCH is -1. */
10250 set_secondary_compatible_arch (bfd *abfd, int arch)
10252 obj_attribute *attr =
10253 &elf_known_obj_attributes_proc (abfd)[Tag_also_compatible_with];
10261 /* Note: the tag and its argument below are uleb128 values, though
10262 currently-defined values fit in one byte for each. */
10264 attr->s = (char *) bfd_alloc (abfd, 3);
10265 attr->s[0] = Tag_CPU_arch;
10270 /* Combine two values for Tag_CPU_arch, taking secondary compatibility tags
10274 tag_cpu_arch_combine (bfd *ibfd, int oldtag, int *secondary_compat_out,
10275 int newtag, int secondary_compat)
10277 #define T(X) TAG_CPU_ARCH_##X
10278 int tagl, tagh, result;
10281 T(V6T2), /* PRE_V4. */
10283 T(V6T2), /* V4T. */
10284 T(V6T2), /* V5T. */
10285 T(V6T2), /* V5TE. */
10286 T(V6T2), /* V5TEJ. */
10289 T(V6T2) /* V6T2. */
10293 T(V6K), /* PRE_V4. */
10297 T(V6K), /* V5TE. */
10298 T(V6K), /* V5TEJ. */
10300 T(V6KZ), /* V6KZ. */
10306 T(V7), /* PRE_V4. */
10311 T(V7), /* V5TEJ. */
10324 T(V6K), /* V5TE. */
10325 T(V6K), /* V5TEJ. */
10327 T(V6KZ), /* V6KZ. */
10331 T(V6_M) /* V6_M. */
10333 const int v6s_m[] =
10339 T(V6K), /* V5TE. */
10340 T(V6K), /* V5TEJ. */
10342 T(V6KZ), /* V6KZ. */
10346 T(V6S_M), /* V6_M. */
10347 T(V6S_M) /* V6S_M. */
10349 const int v7e_m[] =
10353 T(V7E_M), /* V4T. */
10354 T(V7E_M), /* V5T. */
10355 T(V7E_M), /* V5TE. */
10356 T(V7E_M), /* V5TEJ. */
10357 T(V7E_M), /* V6. */
10358 T(V7E_M), /* V6KZ. */
10359 T(V7E_M), /* V6T2. */
10360 T(V7E_M), /* V6K. */
10361 T(V7E_M), /* V7. */
10362 T(V7E_M), /* V6_M. */
10363 T(V7E_M), /* V6S_M. */
10364 T(V7E_M) /* V7E_M. */
10366 const int v4t_plus_v6_m[] =
10372 T(V5TE), /* V5TE. */
10373 T(V5TEJ), /* V5TEJ. */
10375 T(V6KZ), /* V6KZ. */
10376 T(V6T2), /* V6T2. */
10379 T(V6_M), /* V6_M. */
10380 T(V6S_M), /* V6S_M. */
10381 T(V7E_M), /* V7E_M. */
10382 T(V4T_PLUS_V6_M) /* V4T plus V6_M. */
10384 const int *comb[] =
10392 /* Pseudo-architecture. */
10396 /* Check we've not got a higher architecture than we know about. */
10398 if (oldtag > MAX_TAG_CPU_ARCH || newtag > MAX_TAG_CPU_ARCH)
10400 _bfd_error_handler (_("error: %B: Unknown CPU architecture"), ibfd);
10404 /* Override old tag if we have a Tag_also_compatible_with on the output. */
10406 if ((oldtag == T(V6_M) && *secondary_compat_out == T(V4T))
10407 || (oldtag == T(V4T) && *secondary_compat_out == T(V6_M)))
10408 oldtag = T(V4T_PLUS_V6_M);
10410 /* And override the new tag if we have a Tag_also_compatible_with on the
10413 if ((newtag == T(V6_M) && secondary_compat == T(V4T))
10414 || (newtag == T(V4T) && secondary_compat == T(V6_M)))
10415 newtag = T(V4T_PLUS_V6_M);
10417 tagl = (oldtag < newtag) ? oldtag : newtag;
10418 result = tagh = (oldtag > newtag) ? oldtag : newtag;
10420 /* Architectures before V6KZ add features monotonically. */
10421 if (tagh <= TAG_CPU_ARCH_V6KZ)
10424 result = comb[tagh - T(V6T2)][tagl];
10426 /* Use Tag_CPU_arch == V4T and Tag_also_compatible_with (Tag_CPU_arch V6_M)
10427 as the canonical version. */
10428 if (result == T(V4T_PLUS_V6_M))
10431 *secondary_compat_out = T(V6_M);
10434 *secondary_compat_out = -1;
10438 _bfd_error_handler (_("error: %B: Conflicting CPU architectures %d/%d"),
10439 ibfd, oldtag, newtag);
10447 /* Merge EABI object attributes from IBFD into OBFD. Raise an error if there
10448 are conflicting attributes. */
10451 elf32_arm_merge_eabi_attributes (bfd *ibfd, bfd *obfd)
10453 obj_attribute *in_attr;
10454 obj_attribute *out_attr;
10455 /* Some tags have 0 = don't care, 1 = strong requirement,
10456 2 = weak requirement. */
10457 static const int order_021[3] = {0, 2, 1};
10459 bfd_boolean result = TRUE;
10461 /* Skip the linker stubs file. This preserves previous behavior
10462 of accepting unknown attributes in the first input file - but
10464 if (ibfd->flags & BFD_LINKER_CREATED)
10467 if (!elf_known_obj_attributes_proc (obfd)[0].i)
10469 /* This is the first object. Copy the attributes. */
10470 _bfd_elf_copy_obj_attributes (ibfd, obfd);
10472 out_attr = elf_known_obj_attributes_proc (obfd);
10474 /* Use the Tag_null value to indicate the attributes have been
10478 /* We do not output objects with Tag_MPextension_use_legacy - we move
10479 the attribute's value to Tag_MPextension_use. */
10480 if (out_attr[Tag_MPextension_use_legacy].i != 0)
10482 if (out_attr[Tag_MPextension_use].i != 0
10483 && out_attr[Tag_MPextension_use_legacy].i
10484 != out_attr[Tag_MPextension_use].i)
10487 (_("Error: %B has both the current and legacy "
10488 "Tag_MPextension_use attributes"), ibfd);
10492 out_attr[Tag_MPextension_use] =
10493 out_attr[Tag_MPextension_use_legacy];
10494 out_attr[Tag_MPextension_use_legacy].type = 0;
10495 out_attr[Tag_MPextension_use_legacy].i = 0;
10501 in_attr = elf_known_obj_attributes_proc (ibfd);
10502 out_attr = elf_known_obj_attributes_proc (obfd);
10503 /* This needs to happen before Tag_ABI_FP_number_model is merged. */
10504 if (in_attr[Tag_ABI_VFP_args].i != out_attr[Tag_ABI_VFP_args].i)
10506 /* Ignore mismatches if the object doesn't use floating point. */
10507 if (out_attr[Tag_ABI_FP_number_model].i == 0)
10508 out_attr[Tag_ABI_VFP_args].i = in_attr[Tag_ABI_VFP_args].i;
10509 else if (in_attr[Tag_ABI_FP_number_model].i != 0)
10512 (_("error: %B uses VFP register arguments, %B does not"),
10513 in_attr[Tag_ABI_VFP_args].i ? ibfd : obfd,
10514 in_attr[Tag_ABI_VFP_args].i ? obfd : ibfd);
10519 for (i = LEAST_KNOWN_OBJ_ATTRIBUTE; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
10521 /* Merge this attribute with existing attributes. */
10524 case Tag_CPU_raw_name:
10526 /* These are merged after Tag_CPU_arch. */
10529 case Tag_ABI_optimization_goals:
10530 case Tag_ABI_FP_optimization_goals:
10531 /* Use the first value seen. */
10536 int secondary_compat = -1, secondary_compat_out = -1;
10537 unsigned int saved_out_attr = out_attr[i].i;
10538 static const char *name_table[] = {
10539 /* These aren't real CPU names, but we can't guess
10540 that from the architecture version alone. */
10556 /* Merge Tag_CPU_arch and Tag_also_compatible_with. */
10557 secondary_compat = get_secondary_compatible_arch (ibfd);
10558 secondary_compat_out = get_secondary_compatible_arch (obfd);
10559 out_attr[i].i = tag_cpu_arch_combine (ibfd, out_attr[i].i,
10560 &secondary_compat_out,
10563 set_secondary_compatible_arch (obfd, secondary_compat_out);
10565 /* Merge Tag_CPU_name and Tag_CPU_raw_name. */
10566 if (out_attr[i].i == saved_out_attr)
10567 ; /* Leave the names alone. */
10568 else if (out_attr[i].i == in_attr[i].i)
10570 /* The output architecture has been changed to match the
10571 input architecture. Use the input names. */
10572 out_attr[Tag_CPU_name].s = in_attr[Tag_CPU_name].s
10573 ? _bfd_elf_attr_strdup (obfd, in_attr[Tag_CPU_name].s)
10575 out_attr[Tag_CPU_raw_name].s = in_attr[Tag_CPU_raw_name].s
10576 ? _bfd_elf_attr_strdup (obfd, in_attr[Tag_CPU_raw_name].s)
10581 out_attr[Tag_CPU_name].s = NULL;
10582 out_attr[Tag_CPU_raw_name].s = NULL;
10585 /* If we still don't have a value for Tag_CPU_name,
10586 make one up now. Tag_CPU_raw_name remains blank. */
10587 if (out_attr[Tag_CPU_name].s == NULL
10588 && out_attr[i].i < ARRAY_SIZE (name_table))
10589 out_attr[Tag_CPU_name].s =
10590 _bfd_elf_attr_strdup (obfd, name_table[out_attr[i].i]);
10594 case Tag_ARM_ISA_use:
10595 case Tag_THUMB_ISA_use:
10596 case Tag_WMMX_arch:
10597 case Tag_Advanced_SIMD_arch:
10598 /* ??? Do Advanced_SIMD (NEON) and WMMX conflict? */
10599 case Tag_ABI_FP_rounding:
10600 case Tag_ABI_FP_exceptions:
10601 case Tag_ABI_FP_user_exceptions:
10602 case Tag_ABI_FP_number_model:
10603 case Tag_FP_HP_extension:
10604 case Tag_CPU_unaligned_access:
10606 case Tag_MPextension_use:
10607 /* Use the largest value specified. */
10608 if (in_attr[i].i > out_attr[i].i)
10609 out_attr[i].i = in_attr[i].i;
10612 case Tag_ABI_align_preserved:
10613 case Tag_ABI_PCS_RO_data:
10614 /* Use the smallest value specified. */
10615 if (in_attr[i].i < out_attr[i].i)
10616 out_attr[i].i = in_attr[i].i;
10619 case Tag_ABI_align_needed:
10620 if ((in_attr[i].i > 0 || out_attr[i].i > 0)
10621 && (in_attr[Tag_ABI_align_preserved].i == 0
10622 || out_attr[Tag_ABI_align_preserved].i == 0))
10624 /* This error message should be enabled once all non-conformant
10625 binaries in the toolchain have had the attributes set
10628 (_("error: %B: 8-byte data alignment conflicts with %B"),
10632 /* Fall through. */
10633 case Tag_ABI_FP_denormal:
10634 case Tag_ABI_PCS_GOT_use:
10635 /* Use the "greatest" from the sequence 0, 2, 1, or the largest
10636 value if greater than 2 (for future-proofing). */
10637 if ((in_attr[i].i > 2 && in_attr[i].i > out_attr[i].i)
10638 || (in_attr[i].i <= 2 && out_attr[i].i <= 2
10639 && order_021[in_attr[i].i] > order_021[out_attr[i].i]))
10640 out_attr[i].i = in_attr[i].i;
10643 case Tag_Virtualization_use:
10644 /* The virtualization tag effectively stores two bits of
10645 information: the intended use of TrustZone (in bit 0), and the
10646 intended use of Virtualization (in bit 1). */
10647 if (out_attr[i].i == 0)
10648 out_attr[i].i = in_attr[i].i;
10649 else if (in_attr[i].i != 0
10650 && in_attr[i].i != out_attr[i].i)
10652 if (in_attr[i].i <= 3 && out_attr[i].i <= 3)
10657 (_("error: %B: unable to merge virtualization attributes "
10665 case Tag_CPU_arch_profile:
10666 if (out_attr[i].i != in_attr[i].i)
10668 /* 0 will merge with anything.
10669 'A' and 'S' merge to 'A'.
10670 'R' and 'S' merge to 'R'.
10671 'M' and 'A|R|S' is an error. */
10672 if (out_attr[i].i == 0
10673 || (out_attr[i].i == 'S'
10674 && (in_attr[i].i == 'A' || in_attr[i].i == 'R')))
10675 out_attr[i].i = in_attr[i].i;
10676 else if (in_attr[i].i == 0
10677 || (in_attr[i].i == 'S'
10678 && (out_attr[i].i == 'A' || out_attr[i].i == 'R')))
10679 ; /* Do nothing. */
10683 (_("error: %B: Conflicting architecture profiles %c/%c"),
10685 in_attr[i].i ? in_attr[i].i : '0',
10686 out_attr[i].i ? out_attr[i].i : '0');
10693 /* Tag_ABI_HardFP_use is handled along with Tag_FP_arch since
10694 the meaning of Tag_ABI_HardFP_use depends on Tag_FP_arch
10695 when it's 0. It might mean absence of FP hardware if
10696 Tag_FP_arch is zero, otherwise it is effectively SP + DP. */
10698 static const struct
10702 } vfp_versions[7] =
10716 /* If the output has no requirement about FP hardware,
10717 follow the requirement of the input. */
10718 if (out_attr[i].i == 0)
10720 BFD_ASSERT (out_attr[Tag_ABI_HardFP_use].i == 0);
10721 out_attr[i].i = in_attr[i].i;
10722 out_attr[Tag_ABI_HardFP_use].i
10723 = in_attr[Tag_ABI_HardFP_use].i;
10726 /* If the input has no requirement about FP hardware, do
10728 else if (in_attr[i].i == 0)
10730 BFD_ASSERT (in_attr[Tag_ABI_HardFP_use].i == 0);
10734 /* Both the input and the output have nonzero Tag_FP_arch.
10735 So Tag_ABI_HardFP_use is (SP & DP) when it's zero. */
10737 /* If both the input and the output have zero Tag_ABI_HardFP_use,
10739 if (in_attr[Tag_ABI_HardFP_use].i == 0
10740 && out_attr[Tag_ABI_HardFP_use].i == 0)
10742 /* If the input and the output have different Tag_ABI_HardFP_use,
10743 the combination of them is 3 (SP & DP). */
10744 else if (in_attr[Tag_ABI_HardFP_use].i
10745 != out_attr[Tag_ABI_HardFP_use].i)
10746 out_attr[Tag_ABI_HardFP_use].i = 3;
10748 /* Now we can handle Tag_FP_arch. */
10750 /* Values greater than 6 aren't defined, so just pick the
10752 if (in_attr[i].i > 6 && in_attr[i].i > out_attr[i].i)
10754 out_attr[i] = in_attr[i];
10757 /* The output uses the superset of input features
10758 (ISA version) and registers. */
10759 ver = vfp_versions[in_attr[i].i].ver;
10760 if (ver < vfp_versions[out_attr[i].i].ver)
10761 ver = vfp_versions[out_attr[i].i].ver;
10762 regs = vfp_versions[in_attr[i].i].regs;
10763 if (regs < vfp_versions[out_attr[i].i].regs)
10764 regs = vfp_versions[out_attr[i].i].regs;
10765 /* This assumes all possible supersets are also a valid
10767 for (newval = 6; newval > 0; newval--)
10769 if (regs == vfp_versions[newval].regs
10770 && ver == vfp_versions[newval].ver)
10773 out_attr[i].i = newval;
10776 case Tag_PCS_config:
10777 if (out_attr[i].i == 0)
10778 out_attr[i].i = in_attr[i].i;
10779 else if (in_attr[i].i != 0 && out_attr[i].i != 0)
10781 /* It's sometimes ok to mix different configs, so this is only
10784 (_("Warning: %B: Conflicting platform configuration"), ibfd);
10787 case Tag_ABI_PCS_R9_use:
10788 if (in_attr[i].i != out_attr[i].i
10789 && out_attr[i].i != AEABI_R9_unused
10790 && in_attr[i].i != AEABI_R9_unused)
10793 (_("error: %B: Conflicting use of R9"), ibfd);
10796 if (out_attr[i].i == AEABI_R9_unused)
10797 out_attr[i].i = in_attr[i].i;
10799 case Tag_ABI_PCS_RW_data:
10800 if (in_attr[i].i == AEABI_PCS_RW_data_SBrel
10801 && out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_SB
10802 && out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_unused)
10805 (_("error: %B: SB relative addressing conflicts with use of R9"),
10809 /* Use the smallest value specified. */
10810 if (in_attr[i].i < out_attr[i].i)
10811 out_attr[i].i = in_attr[i].i;
10813 case Tag_ABI_PCS_wchar_t:
10814 if (out_attr[i].i && in_attr[i].i && out_attr[i].i != in_attr[i].i
10815 && !elf_arm_tdata (obfd)->no_wchar_size_warning)
10818 (_("warning: %B uses %u-byte wchar_t yet the output is to use %u-byte wchar_t; use of wchar_t values across objects may fail"),
10819 ibfd, in_attr[i].i, out_attr[i].i);
10821 else if (in_attr[i].i && !out_attr[i].i)
10822 out_attr[i].i = in_attr[i].i;
10824 case Tag_ABI_enum_size:
10825 if (in_attr[i].i != AEABI_enum_unused)
10827 if (out_attr[i].i == AEABI_enum_unused
10828 || out_attr[i].i == AEABI_enum_forced_wide)
10830 /* The existing object is compatible with anything.
10831 Use whatever requirements the new object has. */
10832 out_attr[i].i = in_attr[i].i;
10834 else if (in_attr[i].i != AEABI_enum_forced_wide
10835 && out_attr[i].i != in_attr[i].i
10836 && !elf_arm_tdata (obfd)->no_enum_size_warning)
10838 static const char *aeabi_enum_names[] =
10839 { "", "variable-size", "32-bit", "" };
10840 const char *in_name =
10841 in_attr[i].i < ARRAY_SIZE(aeabi_enum_names)
10842 ? aeabi_enum_names[in_attr[i].i]
10844 const char *out_name =
10845 out_attr[i].i < ARRAY_SIZE(aeabi_enum_names)
10846 ? aeabi_enum_names[out_attr[i].i]
10849 (_("warning: %B uses %s enums yet the output is to use %s enums; use of enum values across objects may fail"),
10850 ibfd, in_name, out_name);
10854 case Tag_ABI_VFP_args:
10857 case Tag_ABI_WMMX_args:
10858 if (in_attr[i].i != out_attr[i].i)
10861 (_("error: %B uses iWMMXt register arguments, %B does not"),
10866 case Tag_compatibility:
10867 /* Merged in target-independent code. */
10869 case Tag_ABI_HardFP_use:
10870 /* This is handled along with Tag_FP_arch. */
10872 case Tag_ABI_FP_16bit_format:
10873 if (in_attr[i].i != 0 && out_attr[i].i != 0)
10875 if (in_attr[i].i != out_attr[i].i)
10878 (_("error: fp16 format mismatch between %B and %B"),
10883 if (in_attr[i].i != 0)
10884 out_attr[i].i = in_attr[i].i;
10888 /* This tag is set to zero if we can use UDIV and SDIV in Thumb
10889 mode on a v7-M or v7-R CPU; to one if we can not use UDIV or
10890 SDIV at all; and to two if we can use UDIV or SDIV on a v7-A
10891 CPU. We will merge as follows: If the input attribute's value
10892 is one then the output attribute's value remains unchanged. If
10893 the input attribute's value is zero or two then if the output
10894 attribute's value is one the output value is set to the input
10895 value, otherwise the output value must be the same as the
10897 if (in_attr[i].i != 1 && out_attr[i].i != 1)
10899 if (in_attr[i].i != out_attr[i].i)
10902 (_("DIV usage mismatch between %B and %B"),
10908 if (in_attr[i].i != 1)
10909 out_attr[i].i = in_attr[i].i;
10913 case Tag_MPextension_use_legacy:
10914 /* We don't output objects with Tag_MPextension_use_legacy - we
10915 move the value to Tag_MPextension_use. */
10916 if (in_attr[i].i != 0 && in_attr[Tag_MPextension_use].i != 0)
10918 if (in_attr[Tag_MPextension_use].i != in_attr[i].i)
10921 (_("%B has has both the current and legacy "
10922 "Tag_MPextension_use attributes"),
10928 if (in_attr[i].i > out_attr[Tag_MPextension_use].i)
10929 out_attr[Tag_MPextension_use] = in_attr[i];
10933 case Tag_nodefaults:
10934 /* This tag is set if it exists, but the value is unused (and is
10935 typically zero). We don't actually need to do anything here -
10936 the merge happens automatically when the type flags are merged
10939 case Tag_also_compatible_with:
10940 /* Already done in Tag_CPU_arch. */
10942 case Tag_conformance:
10943 /* Keep the attribute if it matches. Throw it away otherwise.
10944 No attribute means no claim to conform. */
10945 if (!in_attr[i].s || !out_attr[i].s
10946 || strcmp (in_attr[i].s, out_attr[i].s) != 0)
10947 out_attr[i].s = NULL;
10952 = result && _bfd_elf_merge_unknown_attribute_low (ibfd, obfd, i);
10955 /* If out_attr was copied from in_attr then it won't have a type yet. */
10956 if (in_attr[i].type && !out_attr[i].type)
10957 out_attr[i].type = in_attr[i].type;
10960 /* Merge Tag_compatibility attributes and any common GNU ones. */
10961 if (!_bfd_elf_merge_object_attributes (ibfd, obfd))
10964 /* Check for any attributes not known on ARM. */
10965 result &= _bfd_elf_merge_unknown_attribute_list (ibfd, obfd);
10971 /* Return TRUE if the two EABI versions are incompatible. */
10974 elf32_arm_versions_compatible (unsigned iver, unsigned over)
10976 /* v4 and v5 are the same spec before and after it was released,
10977 so allow mixing them. */
10978 if ((iver == EF_ARM_EABI_VER4 && over == EF_ARM_EABI_VER5)
10979 || (iver == EF_ARM_EABI_VER5 && over == EF_ARM_EABI_VER4))
10982 return (iver == over);
10985 /* Merge backend specific data from an object file to the output
10986 object file when linking. */
10989 elf32_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd);
10991 /* Display the flags field. */
10994 elf32_arm_print_private_bfd_data (bfd *abfd, void * ptr)
10996 FILE * file = (FILE *) ptr;
10997 unsigned long flags;
10999 BFD_ASSERT (abfd != NULL && ptr != NULL);
11001 /* Print normal ELF private data. */
11002 _bfd_elf_print_private_bfd_data (abfd, ptr);
11004 flags = elf_elfheader (abfd)->e_flags;
11005 /* Ignore init flag - it may not be set, despite the flags field
11006 containing valid data. */
11008 /* xgettext:c-format */
11009 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
11011 switch (EF_ARM_EABI_VERSION (flags))
11013 case EF_ARM_EABI_UNKNOWN:
11014 /* The following flag bits are GNU extensions and not part of the
11015 official ARM ELF extended ABI. Hence they are only decoded if
11016 the EABI version is not set. */
11017 if (flags & EF_ARM_INTERWORK)
11018 fprintf (file, _(" [interworking enabled]"));
11020 if (flags & EF_ARM_APCS_26)
11021 fprintf (file, " [APCS-26]");
11023 fprintf (file, " [APCS-32]");
11025 if (flags & EF_ARM_VFP_FLOAT)
11026 fprintf (file, _(" [VFP float format]"));
11027 else if (flags & EF_ARM_MAVERICK_FLOAT)
11028 fprintf (file, _(" [Maverick float format]"));
11030 fprintf (file, _(" [FPA float format]"));
11032 if (flags & EF_ARM_APCS_FLOAT)
11033 fprintf (file, _(" [floats passed in float registers]"));
11035 if (flags & EF_ARM_PIC)
11036 fprintf (file, _(" [position independent]"));
11038 if (flags & EF_ARM_NEW_ABI)
11039 fprintf (file, _(" [new ABI]"));
11041 if (flags & EF_ARM_OLD_ABI)
11042 fprintf (file, _(" [old ABI]"));
11044 if (flags & EF_ARM_SOFT_FLOAT)
11045 fprintf (file, _(" [software FP]"));
11047 flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT
11048 | EF_ARM_PIC | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI
11049 | EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT
11050 | EF_ARM_MAVERICK_FLOAT);
11053 case EF_ARM_EABI_VER1:
11054 fprintf (file, _(" [Version1 EABI]"));
11056 if (flags & EF_ARM_SYMSARESORTED)
11057 fprintf (file, _(" [sorted symbol table]"));
11059 fprintf (file, _(" [unsorted symbol table]"));
11061 flags &= ~ EF_ARM_SYMSARESORTED;
11064 case EF_ARM_EABI_VER2:
11065 fprintf (file, _(" [Version2 EABI]"));
11067 if (flags & EF_ARM_SYMSARESORTED)
11068 fprintf (file, _(" [sorted symbol table]"));
11070 fprintf (file, _(" [unsorted symbol table]"));
11072 if (flags & EF_ARM_DYNSYMSUSESEGIDX)
11073 fprintf (file, _(" [dynamic symbols use segment index]"));
11075 if (flags & EF_ARM_MAPSYMSFIRST)
11076 fprintf (file, _(" [mapping symbols precede others]"));
11078 flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX
11079 | EF_ARM_MAPSYMSFIRST);
11082 case EF_ARM_EABI_VER3:
11083 fprintf (file, _(" [Version3 EABI]"));
11086 case EF_ARM_EABI_VER4:
11087 fprintf (file, _(" [Version4 EABI]"));
11090 case EF_ARM_EABI_VER5:
11091 fprintf (file, _(" [Version5 EABI]"));
11093 if (flags & EF_ARM_BE8)
11094 fprintf (file, _(" [BE8]"));
11096 if (flags & EF_ARM_LE8)
11097 fprintf (file, _(" [LE8]"));
11099 flags &= ~(EF_ARM_LE8 | EF_ARM_BE8);
11103 fprintf (file, _(" <EABI version unrecognised>"));
11107 flags &= ~ EF_ARM_EABIMASK;
11109 if (flags & EF_ARM_RELEXEC)
11110 fprintf (file, _(" [relocatable executable]"));
11112 if (flags & EF_ARM_HASENTRY)
11113 fprintf (file, _(" [has entry point]"));
11115 flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
11118 fprintf (file, _("<Unrecognised flag bits set>"));
11120 fputc ('\n', file);
11126 elf32_arm_get_symbol_type (Elf_Internal_Sym * elf_sym, int type)
11128 switch (ELF_ST_TYPE (elf_sym->st_info))
11130 case STT_ARM_TFUNC:
11131 return ELF_ST_TYPE (elf_sym->st_info);
11133 case STT_ARM_16BIT:
11134 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
11135 This allows us to distinguish between data used by Thumb instructions
11136 and non-data (which is probably code) inside Thumb regions of an
11138 if (type != STT_OBJECT && type != STT_TLS)
11139 return ELF_ST_TYPE (elf_sym->st_info);
11150 elf32_arm_gc_mark_hook (asection *sec,
11151 struct bfd_link_info *info,
11152 Elf_Internal_Rela *rel,
11153 struct elf_link_hash_entry *h,
11154 Elf_Internal_Sym *sym)
11157 switch (ELF32_R_TYPE (rel->r_info))
11159 case R_ARM_GNU_VTINHERIT:
11160 case R_ARM_GNU_VTENTRY:
11164 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
11167 /* Update the got entry reference counts for the section being removed. */
11170 elf32_arm_gc_sweep_hook (bfd * abfd,
11171 struct bfd_link_info * info,
11173 const Elf_Internal_Rela * relocs)
11175 Elf_Internal_Shdr *symtab_hdr;
11176 struct elf_link_hash_entry **sym_hashes;
11177 bfd_signed_vma *local_got_refcounts;
11178 const Elf_Internal_Rela *rel, *relend;
11179 struct elf32_arm_link_hash_table * globals;
11181 if (info->relocatable)
11184 globals = elf32_arm_hash_table (info);
11185 if (globals == NULL)
11188 elf_section_data (sec)->local_dynrel = NULL;
11190 symtab_hdr = & elf_symtab_hdr (abfd);
11191 sym_hashes = elf_sym_hashes (abfd);
11192 local_got_refcounts = elf_local_got_refcounts (abfd);
11194 check_use_blx (globals);
11196 relend = relocs + sec->reloc_count;
11197 for (rel = relocs; rel < relend; rel++)
11199 unsigned long r_symndx;
11200 struct elf_link_hash_entry *h = NULL;
11203 r_symndx = ELF32_R_SYM (rel->r_info);
11204 if (r_symndx >= symtab_hdr->sh_info)
11206 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
11207 while (h->root.type == bfd_link_hash_indirect
11208 || h->root.type == bfd_link_hash_warning)
11209 h = (struct elf_link_hash_entry *) h->root.u.i.link;
11212 r_type = ELF32_R_TYPE (rel->r_info);
11213 r_type = arm_real_reloc_type (globals, r_type);
11217 case R_ARM_GOT_PREL:
11218 case R_ARM_TLS_GD32:
11219 case R_ARM_TLS_IE32:
11222 if (h->got.refcount > 0)
11223 h->got.refcount -= 1;
11225 else if (local_got_refcounts != NULL)
11227 if (local_got_refcounts[r_symndx] > 0)
11228 local_got_refcounts[r_symndx] -= 1;
11232 case R_ARM_TLS_LDM32:
11233 globals->tls_ldm_got.refcount -= 1;
11237 case R_ARM_ABS32_NOI:
11239 case R_ARM_REL32_NOI:
11245 case R_ARM_THM_CALL:
11246 case R_ARM_THM_JUMP24:
11247 case R_ARM_THM_JUMP19:
11248 case R_ARM_MOVW_ABS_NC:
11249 case R_ARM_MOVT_ABS:
11250 case R_ARM_MOVW_PREL_NC:
11251 case R_ARM_MOVT_PREL:
11252 case R_ARM_THM_MOVW_ABS_NC:
11253 case R_ARM_THM_MOVT_ABS:
11254 case R_ARM_THM_MOVW_PREL_NC:
11255 case R_ARM_THM_MOVT_PREL:
11256 /* Should the interworking branches be here also? */
11260 struct elf32_arm_link_hash_entry *eh;
11261 struct elf_dyn_relocs **pp;
11262 struct elf_dyn_relocs *p;
11264 eh = (struct elf32_arm_link_hash_entry *) h;
11266 if (h->plt.refcount > 0)
11268 h->plt.refcount -= 1;
11269 if (r_type == R_ARM_THM_CALL)
11270 eh->plt_maybe_thumb_refcount--;
11272 if (r_type == R_ARM_THM_JUMP24
11273 || r_type == R_ARM_THM_JUMP19)
11274 eh->plt_thumb_refcount--;
11277 if (r_type == R_ARM_ABS32
11278 || r_type == R_ARM_REL32
11279 || r_type == R_ARM_ABS32_NOI
11280 || r_type == R_ARM_REL32_NOI)
11281 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
11285 if (ELF32_R_TYPE (rel->r_info) == R_ARM_REL32
11286 || ELF32_R_TYPE (rel->r_info) == R_ARM_REL32_NOI)
11303 /* Look through the relocs for a section during the first phase. */
11306 elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info,
11307 asection *sec, const Elf_Internal_Rela *relocs)
11309 Elf_Internal_Shdr *symtab_hdr;
11310 struct elf_link_hash_entry **sym_hashes;
11311 const Elf_Internal_Rela *rel;
11312 const Elf_Internal_Rela *rel_end;
11315 struct elf32_arm_link_hash_table *htab;
11316 bfd_boolean needs_plt;
11317 unsigned long nsyms;
11319 if (info->relocatable)
11322 BFD_ASSERT (is_arm_elf (abfd));
11324 htab = elf32_arm_hash_table (info);
11330 /* Create dynamic sections for relocatable executables so that we can
11331 copy relocations. */
11332 if (htab->root.is_relocatable_executable
11333 && ! htab->root.dynamic_sections_created)
11335 if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
11339 dynobj = elf_hash_table (info)->dynobj;
11340 symtab_hdr = & elf_symtab_hdr (abfd);
11341 sym_hashes = elf_sym_hashes (abfd);
11342 nsyms = NUM_SHDR_ENTRIES (symtab_hdr);
11344 rel_end = relocs + sec->reloc_count;
11345 for (rel = relocs; rel < rel_end; rel++)
11347 struct elf_link_hash_entry *h;
11348 struct elf32_arm_link_hash_entry *eh;
11349 unsigned long r_symndx;
11352 r_symndx = ELF32_R_SYM (rel->r_info);
11353 r_type = ELF32_R_TYPE (rel->r_info);
11354 r_type = arm_real_reloc_type (htab, r_type);
11356 if (r_symndx >= nsyms
11357 /* PR 9934: It is possible to have relocations that do not
11358 refer to symbols, thus it is also possible to have an
11359 object file containing relocations but no symbol table. */
11360 && (r_symndx > STN_UNDEF || nsyms > 0))
11362 (*_bfd_error_handler) (_("%B: bad symbol index: %d"), abfd,
11367 if (nsyms == 0 || r_symndx < symtab_hdr->sh_info)
11371 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
11372 while (h->root.type == bfd_link_hash_indirect
11373 || h->root.type == bfd_link_hash_warning)
11374 h = (struct elf_link_hash_entry *) h->root.u.i.link;
11377 eh = (struct elf32_arm_link_hash_entry *) h;
11379 /* Could be done earlier, if h were already available. */
11380 r_type = elf32_arm_tls_transition (info, r_type, h);
11384 case R_ARM_GOT_PREL:
11385 case R_ARM_TLS_GD32:
11386 case R_ARM_TLS_IE32:
11387 case R_ARM_TLS_GOTDESC:
11388 case R_ARM_TLS_DESCSEQ:
11389 case R_ARM_THM_TLS_DESCSEQ:
11390 case R_ARM_TLS_CALL:
11391 case R_ARM_THM_TLS_CALL:
11392 /* This symbol requires a global offset table entry. */
11394 int tls_type, old_tls_type;
11398 case R_ARM_TLS_GD32: tls_type = GOT_TLS_GD; break;
11400 case R_ARM_TLS_IE32: tls_type = GOT_TLS_IE; break;
11402 case R_ARM_TLS_GOTDESC:
11403 case R_ARM_TLS_CALL: case R_ARM_THM_TLS_CALL:
11404 case R_ARM_TLS_DESCSEQ: case R_ARM_THM_TLS_DESCSEQ:
11405 tls_type = GOT_TLS_GDESC; break;
11407 default: tls_type = GOT_NORMAL; break;
11413 old_tls_type = elf32_arm_hash_entry (h)->tls_type;
11417 bfd_signed_vma *local_got_refcounts;
11419 /* This is a global offset table entry for a local symbol. */
11420 local_got_refcounts = elf_local_got_refcounts (abfd);
11421 if (local_got_refcounts == NULL)
11423 bfd_size_type size;
11425 size = symtab_hdr->sh_info;
11426 size *= (sizeof (bfd_signed_vma)
11427 + sizeof (bfd_vma) + sizeof (char));
11428 local_got_refcounts = (bfd_signed_vma *)
11429 bfd_zalloc (abfd, size);
11430 if (local_got_refcounts == NULL)
11432 elf_local_got_refcounts (abfd) = local_got_refcounts;
11433 elf32_arm_local_tlsdesc_gotent (abfd)
11434 = (bfd_vma *) (local_got_refcounts
11435 + symtab_hdr->sh_info);
11436 elf32_arm_local_got_tls_type (abfd)
11437 = (char *) (elf32_arm_local_tlsdesc_gotent (abfd)
11438 + symtab_hdr->sh_info);
11440 local_got_refcounts[r_symndx] += 1;
11441 old_tls_type = elf32_arm_local_got_tls_type (abfd) [r_symndx];
11444 /* If a variable is accessed with both tls methods, two
11445 slots may be created. */
11446 if (GOT_TLS_GD_ANY_P (old_tls_type)
11447 && GOT_TLS_GD_ANY_P (tls_type))
11448 tls_type |= old_tls_type;
11450 /* We will already have issued an error message if there
11451 is a TLS/non-TLS mismatch, based on the symbol
11452 type. So just combine any TLS types needed. */
11453 if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
11454 && tls_type != GOT_NORMAL)
11455 tls_type |= old_tls_type;
11457 /* If the symbol is accessed in both IE and GDESC
11458 method, we're able to relax. Turn off the GDESC flag,
11459 without messing up with any other kind of tls types
11460 that may be involved */
11461 if ((tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_GDESC))
11462 tls_type &= ~GOT_TLS_GDESC;
11464 if (old_tls_type != tls_type)
11467 elf32_arm_hash_entry (h)->tls_type = tls_type;
11469 elf32_arm_local_got_tls_type (abfd) [r_symndx] = tls_type;
11472 /* Fall through. */
11474 case R_ARM_TLS_LDM32:
11475 if (r_type == R_ARM_TLS_LDM32)
11476 htab->tls_ldm_got.refcount++;
11477 /* Fall through. */
11479 case R_ARM_GOTOFF32:
11481 if (htab->root.sgot == NULL)
11483 if (htab->root.dynobj == NULL)
11484 htab->root.dynobj = abfd;
11485 if (!create_got_section (htab->root.dynobj, info))
11491 /* VxWorks uses dynamic R_ARM_ABS12 relocations for
11492 ldr __GOTT_INDEX__ offsets. */
11493 if (!htab->vxworks_p)
11495 /* Fall through. */
11502 case R_ARM_THM_CALL:
11503 case R_ARM_THM_JUMP24:
11504 case R_ARM_THM_JUMP19:
11508 case R_ARM_MOVW_ABS_NC:
11509 case R_ARM_MOVT_ABS:
11510 case R_ARM_THM_MOVW_ABS_NC:
11511 case R_ARM_THM_MOVT_ABS:
11514 (*_bfd_error_handler)
11515 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
11516 abfd, elf32_arm_howto_table_1[r_type].name,
11517 (h) ? h->root.root.string : "a local symbol");
11518 bfd_set_error (bfd_error_bad_value);
11522 /* Fall through. */
11524 case R_ARM_ABS32_NOI:
11526 case R_ARM_REL32_NOI:
11527 case R_ARM_MOVW_PREL_NC:
11528 case R_ARM_MOVT_PREL:
11529 case R_ARM_THM_MOVW_PREL_NC:
11530 case R_ARM_THM_MOVT_PREL:
11534 /* Should the interworking branches be listed here? */
11537 /* If this reloc is in a read-only section, we might
11538 need a copy reloc. We can't check reliably at this
11539 stage whether the section is read-only, as input
11540 sections have not yet been mapped to output sections.
11541 Tentatively set the flag for now, and correct in
11542 adjust_dynamic_symbol. */
11544 h->non_got_ref = 1;
11546 /* We may need a .plt entry if the function this reloc
11547 refers to is in a different object. We can't tell for
11548 sure yet, because something later might force the
11553 /* If we create a PLT entry, this relocation will reference
11554 it, even if it's an ABS32 relocation. */
11555 h->plt.refcount += 1;
11557 /* It's too early to use htab->use_blx here, so we have to
11558 record possible blx references separately from
11559 relocs that definitely need a thumb stub. */
11561 if (r_type == R_ARM_THM_CALL)
11562 eh->plt_maybe_thumb_refcount += 1;
11564 if (r_type == R_ARM_THM_JUMP24
11565 || r_type == R_ARM_THM_JUMP19)
11566 eh->plt_thumb_refcount += 1;
11569 /* If we are creating a shared library or relocatable executable,
11570 and this is a reloc against a global symbol, or a non PC
11571 relative reloc against a local symbol, then we need to copy
11572 the reloc into the shared library. However, if we are linking
11573 with -Bsymbolic, we do not need to copy a reloc against a
11574 global symbol which is defined in an object we are
11575 including in the link (i.e., DEF_REGULAR is set). At
11576 this point we have not seen all the input files, so it is
11577 possible that DEF_REGULAR is not set now but will be set
11578 later (it is never cleared). We account for that
11579 possibility below by storing information in the
11580 dyn_relocs field of the hash table entry. */
11581 if ((info->shared || htab->root.is_relocatable_executable)
11582 && (sec->flags & SEC_ALLOC) != 0
11583 && ((r_type == R_ARM_ABS32 || r_type == R_ARM_ABS32_NOI)
11584 || (h != NULL && ! h->needs_plt
11585 && (! info->symbolic || ! h->def_regular))))
11587 struct elf_dyn_relocs *p, **head;
11589 /* When creating a shared object, we must copy these
11590 reloc types into the output file. We create a reloc
11591 section in dynobj and make room for this reloc. */
11592 if (sreloc == NULL)
11594 sreloc = _bfd_elf_make_dynamic_reloc_section
11595 (sec, dynobj, 2, abfd, ! htab->use_rel);
11597 if (sreloc == NULL)
11600 /* BPABI objects never have dynamic relocations mapped. */
11601 if (htab->symbian_p)
11605 flags = bfd_get_section_flags (dynobj, sreloc);
11606 flags &= ~(SEC_LOAD | SEC_ALLOC);
11607 bfd_set_section_flags (dynobj, sreloc, flags);
11611 /* If this is a global symbol, we count the number of
11612 relocations we need for this symbol. */
11615 head = &((struct elf32_arm_link_hash_entry *) h)->dyn_relocs;
11619 /* Track dynamic relocs needed for local syms too.
11620 We really need local syms available to do this
11621 easily. Oh well. */
11624 Elf_Internal_Sym *isym;
11626 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
11631 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
11635 vpp = &elf_section_data (s)->local_dynrel;
11636 head = (struct elf_dyn_relocs **) vpp;
11640 if (p == NULL || p->sec != sec)
11642 bfd_size_type amt = sizeof *p;
11644 p = (struct elf_dyn_relocs *)
11645 bfd_alloc (htab->root.dynobj, amt);
11655 if (r_type == R_ARM_REL32 || r_type == R_ARM_REL32_NOI)
11661 /* This relocation describes the C++ object vtable hierarchy.
11662 Reconstruct it for later use during GC. */
11663 case R_ARM_GNU_VTINHERIT:
11664 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
11668 /* This relocation describes which C++ vtable entries are actually
11669 used. Record for later use during GC. */
11670 case R_ARM_GNU_VTENTRY:
11671 BFD_ASSERT (h != NULL);
11673 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
11682 /* Unwinding tables are not referenced directly. This pass marks them as
11683 required if the corresponding code section is marked. */
11686 elf32_arm_gc_mark_extra_sections (struct bfd_link_info *info,
11687 elf_gc_mark_hook_fn gc_mark_hook)
11690 Elf_Internal_Shdr **elf_shdrp;
11693 /* Marking EH data may cause additional code sections to be marked,
11694 requiring multiple passes. */
11699 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
11703 if (! is_arm_elf (sub))
11706 elf_shdrp = elf_elfsections (sub);
11707 for (o = sub->sections; o != NULL; o = o->next)
11709 Elf_Internal_Shdr *hdr;
11711 hdr = &elf_section_data (o)->this_hdr;
11712 if (hdr->sh_type == SHT_ARM_EXIDX
11714 && hdr->sh_link < elf_numsections (sub)
11716 && elf_shdrp[hdr->sh_link]->bfd_section->gc_mark)
11719 if (!_bfd_elf_gc_mark (info, o, gc_mark_hook))
11729 /* Treat mapping symbols as special target symbols. */
11732 elf32_arm_is_target_special_symbol (bfd * abfd ATTRIBUTE_UNUSED, asymbol * sym)
11734 return bfd_is_arm_special_symbol_name (sym->name,
11735 BFD_ARM_SPECIAL_SYM_TYPE_ANY);
11738 /* This is a copy of elf_find_function() from elf.c except that
11739 ARM mapping symbols are ignored when looking for function names
11740 and STT_ARM_TFUNC is considered to a function type. */
11743 arm_elf_find_function (bfd * abfd ATTRIBUTE_UNUSED,
11744 asection * section,
11745 asymbol ** symbols,
11747 const char ** filename_ptr,
11748 const char ** functionname_ptr)
11750 const char * filename = NULL;
11751 asymbol * func = NULL;
11752 bfd_vma low_func = 0;
11755 for (p = symbols; *p != NULL; p++)
11757 elf_symbol_type *q;
11759 q = (elf_symbol_type *) *p;
11761 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
11766 filename = bfd_asymbol_name (&q->symbol);
11769 case STT_ARM_TFUNC:
11771 /* Skip mapping symbols. */
11772 if ((q->symbol.flags & BSF_LOCAL)
11773 && bfd_is_arm_special_symbol_name (q->symbol.name,
11774 BFD_ARM_SPECIAL_SYM_TYPE_ANY))
11776 /* Fall through. */
11777 if (bfd_get_section (&q->symbol) == section
11778 && q->symbol.value >= low_func
11779 && q->symbol.value <= offset)
11781 func = (asymbol *) q;
11782 low_func = q->symbol.value;
11792 *filename_ptr = filename;
11793 if (functionname_ptr)
11794 *functionname_ptr = bfd_asymbol_name (func);
11800 /* Find the nearest line to a particular section and offset, for error
11801 reporting. This code is a duplicate of the code in elf.c, except
11802 that it uses arm_elf_find_function. */
11805 elf32_arm_find_nearest_line (bfd * abfd,
11806 asection * section,
11807 asymbol ** symbols,
11809 const char ** filename_ptr,
11810 const char ** functionname_ptr,
11811 unsigned int * line_ptr)
11813 bfd_boolean found = FALSE;
11815 /* We skip _bfd_dwarf1_find_nearest_line since no known ARM toolchain uses it. */
11817 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
11818 filename_ptr, functionname_ptr,
11820 & elf_tdata (abfd)->dwarf2_find_line_info))
11822 if (!*functionname_ptr)
11823 arm_elf_find_function (abfd, section, symbols, offset,
11824 *filename_ptr ? NULL : filename_ptr,
11830 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
11831 & found, filename_ptr,
11832 functionname_ptr, line_ptr,
11833 & elf_tdata (abfd)->line_info))
11836 if (found && (*functionname_ptr || *line_ptr))
11839 if (symbols == NULL)
11842 if (! arm_elf_find_function (abfd, section, symbols, offset,
11843 filename_ptr, functionname_ptr))
11851 elf32_arm_find_inliner_info (bfd * abfd,
11852 const char ** filename_ptr,
11853 const char ** functionname_ptr,
11854 unsigned int * line_ptr)
11857 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
11858 functionname_ptr, line_ptr,
11859 & elf_tdata (abfd)->dwarf2_find_line_info);
11863 /* Adjust a symbol defined by a dynamic object and referenced by a
11864 regular object. The current definition is in some section of the
11865 dynamic object, but we're not including those sections. We have to
11866 change the definition to something the rest of the link can
11870 elf32_arm_adjust_dynamic_symbol (struct bfd_link_info * info,
11871 struct elf_link_hash_entry * h)
11875 struct elf32_arm_link_hash_entry * eh;
11876 struct elf32_arm_link_hash_table *globals;
11878 globals = elf32_arm_hash_table (info);
11879 if (globals == NULL)
11882 dynobj = elf_hash_table (info)->dynobj;
11884 /* Make sure we know what is going on here. */
11885 BFD_ASSERT (dynobj != NULL
11887 || h->u.weakdef != NULL
11890 && !h->def_regular)));
11892 eh = (struct elf32_arm_link_hash_entry *) h;
11894 /* If this is a function, put it in the procedure linkage table. We
11895 will fill in the contents of the procedure linkage table later,
11896 when we know the address of the .got section. */
11897 if (h->type == STT_FUNC || h->type == STT_ARM_TFUNC
11900 if (h->plt.refcount <= 0
11901 || SYMBOL_CALLS_LOCAL (info, h)
11902 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
11903 && h->root.type == bfd_link_hash_undefweak))
11905 /* This case can occur if we saw a PLT32 reloc in an input
11906 file, but the symbol was never referred to by a dynamic
11907 object, or if all references were garbage collected. In
11908 such a case, we don't actually need to build a procedure
11909 linkage table, and we can just do a PC24 reloc instead. */
11910 h->plt.offset = (bfd_vma) -1;
11911 eh->plt_thumb_refcount = 0;
11912 eh->plt_maybe_thumb_refcount = 0;
11920 /* It's possible that we incorrectly decided a .plt reloc was
11921 needed for an R_ARM_PC24 or similar reloc to a non-function sym
11922 in check_relocs. We can't decide accurately between function
11923 and non-function syms in check-relocs; Objects loaded later in
11924 the link may change h->type. So fix it now. */
11925 h->plt.offset = (bfd_vma) -1;
11926 eh->plt_thumb_refcount = 0;
11927 eh->plt_maybe_thumb_refcount = 0;
11930 /* If this is a weak symbol, and there is a real definition, the
11931 processor independent code will have arranged for us to see the
11932 real definition first, and we can just use the same value. */
11933 if (h->u.weakdef != NULL)
11935 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
11936 || h->u.weakdef->root.type == bfd_link_hash_defweak);
11937 h->root.u.def.section = h->u.weakdef->root.u.def.section;
11938 h->root.u.def.value = h->u.weakdef->root.u.def.value;
11942 /* If there are no non-GOT references, we do not need a copy
11944 if (!h->non_got_ref)
11947 /* This is a reference to a symbol defined by a dynamic object which
11948 is not a function. */
11950 /* If we are creating a shared library, we must presume that the
11951 only references to the symbol are via the global offset table.
11952 For such cases we need not do anything here; the relocations will
11953 be handled correctly by relocate_section. Relocatable executables
11954 can reference data in shared objects directly, so we don't need to
11955 do anything here. */
11956 if (info->shared || globals->root.is_relocatable_executable)
11961 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
11962 h->root.root.string);
11966 /* We must allocate the symbol in our .dynbss section, which will
11967 become part of the .bss section of the executable. There will be
11968 an entry for this symbol in the .dynsym section. The dynamic
11969 object will contain position independent code, so all references
11970 from the dynamic object to this symbol will go through the global
11971 offset table. The dynamic linker will use the .dynsym entry to
11972 determine the address it must put in the global offset table, so
11973 both the dynamic object and the regular object will refer to the
11974 same memory location for the variable. */
11975 s = bfd_get_section_by_name (dynobj, ".dynbss");
11976 BFD_ASSERT (s != NULL);
11978 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
11979 copy the initial value out of the dynamic object and into the
11980 runtime process image. We need to remember the offset into the
11981 .rel(a).bss section we are going to use. */
11982 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
11986 srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (globals, ".bss"));
11987 BFD_ASSERT (srel != NULL);
11988 srel->size += RELOC_SIZE (globals);
11992 return _bfd_elf_adjust_dynamic_copy (h, s);
11995 /* Allocate space in .plt, .got and associated reloc sections for
11999 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
12001 struct bfd_link_info *info;
12002 struct elf32_arm_link_hash_table *htab;
12003 struct elf32_arm_link_hash_entry *eh;
12004 struct elf_dyn_relocs *p;
12005 bfd_signed_vma thumb_refs;
12007 eh = (struct elf32_arm_link_hash_entry *) h;
12009 if (h->root.type == bfd_link_hash_indirect)
12012 if (h->root.type == bfd_link_hash_warning)
12013 /* When warning symbols are created, they **replace** the "real"
12014 entry in the hash table, thus we never get to see the real
12015 symbol in a hash traversal. So look at it now. */
12016 h = (struct elf_link_hash_entry *) h->root.u.i.link;
12018 info = (struct bfd_link_info *) inf;
12019 htab = elf32_arm_hash_table (info);
12023 if (htab->root.dynamic_sections_created
12024 && h->plt.refcount > 0)
12026 /* Make sure this symbol is output as a dynamic symbol.
12027 Undefined weak syms won't yet be marked as dynamic. */
12028 if (h->dynindx == -1
12029 && !h->forced_local)
12031 if (! bfd_elf_link_record_dynamic_symbol (info, h))
12036 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
12038 asection *s = htab->root.splt;
12040 /* If this is the first .plt entry, make room for the special
12043 s->size += htab->plt_header_size;
12045 h->plt.offset = s->size;
12047 /* If we will insert a Thumb trampoline before this PLT, leave room
12049 thumb_refs = eh->plt_thumb_refcount;
12050 if (!htab->use_blx)
12051 thumb_refs += eh->plt_maybe_thumb_refcount;
12053 if (thumb_refs > 0)
12055 h->plt.offset += PLT_THUMB_STUB_SIZE;
12056 s->size += PLT_THUMB_STUB_SIZE;
12059 /* If this symbol is not defined in a regular file, and we are
12060 not generating a shared library, then set the symbol to this
12061 location in the .plt. This is required to make function
12062 pointers compare as equal between the normal executable and
12063 the shared library. */
12065 && !h->def_regular)
12067 h->root.u.def.section = s;
12068 h->root.u.def.value = h->plt.offset;
12070 /* Make sure the function is not marked as Thumb, in case
12071 it is the target of an ABS32 relocation, which will
12072 point to the PLT entry. */
12073 if (ELF_ST_TYPE (h->type) == STT_ARM_TFUNC)
12074 h->type = ELF_ST_INFO (ELF_ST_BIND (h->type), STT_FUNC);
12077 /* Make room for this entry. */
12078 s->size += htab->plt_entry_size;
12080 if (!htab->symbian_p)
12082 /* We also need to make an entry in the .got.plt section, which
12083 will be placed in the .got section by the linker script. */
12084 eh->plt_got_offset = (htab->root.sgotplt->size
12085 - 8 * htab->num_tls_desc);
12086 htab->root.sgotplt->size += 4;
12089 /* We also need to make an entry in the .rel(a).plt section. */
12090 htab->root.srelplt->size += RELOC_SIZE (htab);
12091 htab->next_tls_desc_index++;
12093 /* VxWorks executables have a second set of relocations for
12094 each PLT entry. They go in a separate relocation section,
12095 which is processed by the kernel loader. */
12096 if (htab->vxworks_p && !info->shared)
12098 /* There is a relocation for the initial PLT entry:
12099 an R_ARM_32 relocation for _GLOBAL_OFFSET_TABLE_. */
12100 if (h->plt.offset == htab->plt_header_size)
12101 htab->srelplt2->size += RELOC_SIZE (htab);
12103 /* There are two extra relocations for each subsequent
12104 PLT entry: an R_ARM_32 relocation for the GOT entry,
12105 and an R_ARM_32 relocation for the PLT entry. */
12106 htab->srelplt2->size += RELOC_SIZE (htab) * 2;
12111 h->plt.offset = (bfd_vma) -1;
12117 h->plt.offset = (bfd_vma) -1;
12121 eh = (struct elf32_arm_link_hash_entry *) h;
12122 eh->tlsdesc_got = (bfd_vma) -1;
12124 if (h->got.refcount > 0)
12128 int tls_type = elf32_arm_hash_entry (h)->tls_type;
12131 /* Make sure this symbol is output as a dynamic symbol.
12132 Undefined weak syms won't yet be marked as dynamic. */
12133 if (h->dynindx == -1
12134 && !h->forced_local)
12136 if (! bfd_elf_link_record_dynamic_symbol (info, h))
12140 if (!htab->symbian_p)
12142 s = htab->root.sgot;
12143 h->got.offset = s->size;
12145 if (tls_type == GOT_UNKNOWN)
12148 if (tls_type == GOT_NORMAL)
12149 /* Non-TLS symbols need one GOT slot. */
12153 if (tls_type & GOT_TLS_GDESC)
12155 /* R_ARM_TLS_DESC needs 2 GOT slots. */
12157 = (htab->root.sgotplt->size
12158 - elf32_arm_compute_jump_table_size (htab));
12159 htab->root.sgotplt->size += 8;
12160 h->got.offset = (bfd_vma) -2;
12161 /* plt_got_offset needs to know there's a TLS_DESC
12162 reloc in the middle of .got.plt. */
12163 htab->num_tls_desc++;
12166 if (tls_type & GOT_TLS_GD)
12168 /* R_ARM_TLS_GD32 needs 2 consecutive GOT slots. If
12169 the symbol is both GD and GDESC, got.offset may
12170 have been overwritten. */
12171 h->got.offset = s->size;
12175 if (tls_type & GOT_TLS_IE)
12176 /* R_ARM_TLS_IE32 needs one GOT slot. */
12180 dyn = htab->root.dynamic_sections_created;
12183 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
12185 || !SYMBOL_REFERENCES_LOCAL (info, h)))
12188 if (tls_type != GOT_NORMAL
12189 && (info->shared || indx != 0)
12190 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
12191 || h->root.type != bfd_link_hash_undefweak))
12193 if (tls_type & GOT_TLS_IE)
12194 htab->root.srelgot->size += RELOC_SIZE (htab);
12196 if (tls_type & GOT_TLS_GD)
12197 htab->root.srelgot->size += RELOC_SIZE (htab);
12199 if (tls_type & GOT_TLS_GDESC)
12201 htab->root.srelplt->size += RELOC_SIZE (htab);
12202 /* GDESC needs a trampoline to jump to. */
12203 htab->tls_trampoline = -1;
12206 /* Only GD needs it. GDESC just emits one relocation per
12208 if ((tls_type & GOT_TLS_GD) && indx != 0)
12209 htab->root.srelgot->size += RELOC_SIZE (htab);
12211 else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
12212 || h->root.type != bfd_link_hash_undefweak)
12214 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
12215 htab->root.srelgot->size += RELOC_SIZE (htab);
12219 h->got.offset = (bfd_vma) -1;
12221 /* Allocate stubs for exported Thumb functions on v4t. */
12222 if (!htab->use_blx && h->dynindx != -1
12224 && ELF_ST_TYPE (h->type) == STT_ARM_TFUNC
12225 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
12227 struct elf_link_hash_entry * th;
12228 struct bfd_link_hash_entry * bh;
12229 struct elf_link_hash_entry * myh;
12233 /* Create a new symbol to regist the real location of the function. */
12234 s = h->root.u.def.section;
12235 sprintf (name, "__real_%s", h->root.root.string);
12236 _bfd_generic_link_add_one_symbol (info, s->owner,
12237 name, BSF_GLOBAL, s,
12238 h->root.u.def.value,
12239 NULL, TRUE, FALSE, &bh);
12241 myh = (struct elf_link_hash_entry *) bh;
12242 myh->type = ELF_ST_INFO (STB_LOCAL, STT_ARM_TFUNC);
12243 myh->forced_local = 1;
12244 eh->export_glue = myh;
12245 th = record_arm_to_thumb_glue (info, h);
12246 /* Point the symbol at the stub. */
12247 h->type = ELF_ST_INFO (ELF_ST_BIND (h->type), STT_FUNC);
12248 h->root.u.def.section = th->root.u.def.section;
12249 h->root.u.def.value = th->root.u.def.value & ~1;
12252 if (eh->dyn_relocs == NULL)
12255 /* In the shared -Bsymbolic case, discard space allocated for
12256 dynamic pc-relative relocs against symbols which turn out to be
12257 defined in regular objects. For the normal shared case, discard
12258 space for pc-relative relocs that have become local due to symbol
12259 visibility changes. */
12261 if (info->shared || htab->root.is_relocatable_executable)
12263 /* The only relocs that use pc_count are R_ARM_REL32 and
12264 R_ARM_REL32_NOI, which will appear on something like
12265 ".long foo - .". We want calls to protected symbols to resolve
12266 directly to the function rather than going via the plt. If people
12267 want function pointer comparisons to work as expected then they
12268 should avoid writing assembly like ".long foo - .". */
12269 if (SYMBOL_CALLS_LOCAL (info, h))
12271 struct elf_dyn_relocs **pp;
12273 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
12275 p->count -= p->pc_count;
12284 if (htab->vxworks_p)
12286 struct elf_dyn_relocs **pp;
12288 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
12290 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
12297 /* Also discard relocs on undefined weak syms with non-default
12299 if (eh->dyn_relocs != NULL
12300 && h->root.type == bfd_link_hash_undefweak)
12302 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
12303 eh->dyn_relocs = NULL;
12305 /* Make sure undefined weak symbols are output as a dynamic
12307 else if (h->dynindx == -1
12308 && !h->forced_local)
12310 if (! bfd_elf_link_record_dynamic_symbol (info, h))
12315 else if (htab->root.is_relocatable_executable && h->dynindx == -1
12316 && h->root.type == bfd_link_hash_new)
12318 /* Output absolute symbols so that we can create relocations
12319 against them. For normal symbols we output a relocation
12320 against the section that contains them. */
12321 if (! bfd_elf_link_record_dynamic_symbol (info, h))
12328 /* For the non-shared case, discard space for relocs against
12329 symbols which turn out to need copy relocs or are not
12332 if (!h->non_got_ref
12333 && ((h->def_dynamic
12334 && !h->def_regular)
12335 || (htab->root.dynamic_sections_created
12336 && (h->root.type == bfd_link_hash_undefweak
12337 || h->root.type == bfd_link_hash_undefined))))
12339 /* Make sure this symbol is output as a dynamic symbol.
12340 Undefined weak syms won't yet be marked as dynamic. */
12341 if (h->dynindx == -1
12342 && !h->forced_local)
12344 if (! bfd_elf_link_record_dynamic_symbol (info, h))
12348 /* If that succeeded, we know we'll be keeping all the
12350 if (h->dynindx != -1)
12354 eh->dyn_relocs = NULL;
12359 /* Finally, allocate space. */
12360 for (p = eh->dyn_relocs; p != NULL; p = p->next)
12362 asection *sreloc = elf_section_data (p->sec)->sreloc;
12363 sreloc->size += p->count * RELOC_SIZE (htab);
12369 /* Find any dynamic relocs that apply to read-only sections. */
12372 elf32_arm_readonly_dynrelocs (struct elf_link_hash_entry * h, void * inf)
12374 struct elf32_arm_link_hash_entry * eh;
12375 struct elf_dyn_relocs * p;
12377 if (h->root.type == bfd_link_hash_warning)
12378 h = (struct elf_link_hash_entry *) h->root.u.i.link;
12380 eh = (struct elf32_arm_link_hash_entry *) h;
12381 for (p = eh->dyn_relocs; p != NULL; p = p->next)
12383 asection *s = p->sec;
12385 if (s != NULL && (s->flags & SEC_READONLY) != 0)
12387 struct bfd_link_info *info = (struct bfd_link_info *) inf;
12389 info->flags |= DF_TEXTREL;
12391 /* Not an error, just cut short the traversal. */
12399 bfd_elf32_arm_set_byteswap_code (struct bfd_link_info *info,
12402 struct elf32_arm_link_hash_table *globals;
12404 globals = elf32_arm_hash_table (info);
12405 if (globals == NULL)
12408 globals->byteswap_code = byteswap_code;
12411 /* Set the sizes of the dynamic sections. */
12414 elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
12415 struct bfd_link_info * info)
12420 bfd_boolean relocs;
12422 struct elf32_arm_link_hash_table *htab;
12424 htab = elf32_arm_hash_table (info);
12428 dynobj = elf_hash_table (info)->dynobj;
12429 BFD_ASSERT (dynobj != NULL);
12430 check_use_blx (htab);
12432 if (elf_hash_table (info)->dynamic_sections_created)
12434 /* Set the contents of the .interp section to the interpreter. */
12435 if (info->executable)
12437 s = bfd_get_section_by_name (dynobj, ".interp");
12438 BFD_ASSERT (s != NULL);
12439 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
12440 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
12444 /* Set up .got offsets for local syms, and space for local dynamic
12446 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
12448 bfd_signed_vma *local_got;
12449 bfd_signed_vma *end_local_got;
12450 char *local_tls_type;
12451 bfd_vma *local_tlsdesc_gotent;
12452 bfd_size_type locsymcount;
12453 Elf_Internal_Shdr *symtab_hdr;
12455 bfd_boolean is_vxworks = htab->vxworks_p;
12457 if (! is_arm_elf (ibfd))
12460 for (s = ibfd->sections; s != NULL; s = s->next)
12462 struct elf_dyn_relocs *p;
12464 for (p = (struct elf_dyn_relocs *)
12465 elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
12467 if (!bfd_is_abs_section (p->sec)
12468 && bfd_is_abs_section (p->sec->output_section))
12470 /* Input section has been discarded, either because
12471 it is a copy of a linkonce section or due to
12472 linker script /DISCARD/, so we'll be discarding
12475 else if (is_vxworks
12476 && strcmp (p->sec->output_section->name,
12479 /* Relocations in vxworks .tls_vars sections are
12480 handled specially by the loader. */
12482 else if (p->count != 0)
12484 srel = elf_section_data (p->sec)->sreloc;
12485 srel->size += p->count * RELOC_SIZE (htab);
12486 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
12487 info->flags |= DF_TEXTREL;
12492 local_got = elf_local_got_refcounts (ibfd);
12496 symtab_hdr = & elf_symtab_hdr (ibfd);
12497 locsymcount = symtab_hdr->sh_info;
12498 end_local_got = local_got + locsymcount;
12499 local_tls_type = elf32_arm_local_got_tls_type (ibfd);
12500 local_tlsdesc_gotent = elf32_arm_local_tlsdesc_gotent (ibfd);
12501 s = htab->root.sgot;
12502 srel = htab->root.srelgot;
12503 for (; local_got < end_local_got;
12504 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
12506 *local_tlsdesc_gotent = (bfd_vma) -1;
12507 if (*local_got > 0)
12509 *local_got = s->size;
12510 if (*local_tls_type & GOT_TLS_GD)
12511 /* TLS_GD relocs need an 8-byte structure in the GOT. */
12513 if (*local_tls_type & GOT_TLS_GDESC)
12515 *local_tlsdesc_gotent = htab->root.sgotplt->size
12516 - elf32_arm_compute_jump_table_size (htab);
12517 htab->root.sgotplt->size += 8;
12518 *local_got = (bfd_vma) -2;
12519 /* plt_got_offset needs to know there's a TLS_DESC
12520 reloc in the middle of .got.plt. */
12521 htab->num_tls_desc++;
12523 if (*local_tls_type & GOT_TLS_IE)
12526 if (*local_tls_type & GOT_NORMAL)
12528 /* If the symbol is both GD and GDESC, *local_got
12529 may have been overwritten. */
12530 *local_got = s->size;
12534 if ((info->shared && !(*local_tls_type & GOT_TLS_GDESC))
12535 || *local_tls_type & GOT_TLS_GD)
12536 srel->size += RELOC_SIZE (htab);
12538 if (info->shared && *local_tls_type & GOT_TLS_GDESC)
12540 htab->root.srelplt->size += RELOC_SIZE (htab);
12541 htab->tls_trampoline = -1;
12545 *local_got = (bfd_vma) -1;
12549 if (htab->tls_ldm_got.refcount > 0)
12551 /* Allocate two GOT entries and one dynamic relocation (if necessary)
12552 for R_ARM_TLS_LDM32 relocations. */
12553 htab->tls_ldm_got.offset = htab->root.sgot->size;
12554 htab->root.sgot->size += 8;
12556 htab->root.srelgot->size += RELOC_SIZE (htab);
12559 htab->tls_ldm_got.offset = -1;
12561 /* Allocate global sym .plt and .got entries, and space for global
12562 sym dynamic relocs. */
12563 elf_link_hash_traverse (& htab->root, allocate_dynrelocs, info);
12565 /* Here we rummage through the found bfds to collect glue information. */
12566 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
12568 if (! is_arm_elf (ibfd))
12571 /* Initialise mapping tables for code/data. */
12572 bfd_elf32_arm_init_maps (ibfd);
12574 if (!bfd_elf32_arm_process_before_allocation (ibfd, info)
12575 || !bfd_elf32_arm_vfp11_erratum_scan (ibfd, info))
12576 /* xgettext:c-format */
12577 _bfd_error_handler (_("Errors encountered processing file %s"),
12581 /* Allocate space for the glue sections now that we've sized them. */
12582 bfd_elf32_arm_allocate_interworking_sections (info);
12584 /* For every jump slot reserved in the sgotplt, reloc_count is
12585 incremented. However, when we reserve space for TLS descriptors,
12586 it's not incremented, so in order to compute the space reserved
12587 for them, it suffices to multiply the reloc count by the jump
12589 if (htab->root.srelplt)
12590 htab->sgotplt_jump_table_size = elf32_arm_compute_jump_table_size(htab);
12592 if (htab->tls_trampoline)
12594 if (htab->root.splt->size == 0)
12595 htab->root.splt->size += htab->plt_header_size;
12597 htab->tls_trampoline = htab->root.splt->size;
12598 htab->root.splt->size += htab->plt_entry_size;
12600 /* If we're not using lazy TLS relocations, don't generate the
12601 PLT and GOT entries they require. */
12602 if (!(info->flags & DF_BIND_NOW))
12604 htab->dt_tlsdesc_got = htab->root.sgot->size;
12605 htab->root.sgot->size += 4;
12607 htab->dt_tlsdesc_plt = htab->root.splt->size;
12608 htab->root.splt->size += 4 * ARRAY_SIZE (dl_tlsdesc_lazy_trampoline);
12612 /* The check_relocs and adjust_dynamic_symbol entry points have
12613 determined the sizes of the various dynamic sections. Allocate
12614 memory for them. */
12617 for (s = dynobj->sections; s != NULL; s = s->next)
12621 if ((s->flags & SEC_LINKER_CREATED) == 0)
12624 /* It's OK to base decisions on the section name, because none
12625 of the dynobj section names depend upon the input files. */
12626 name = bfd_get_section_name (dynobj, s);
12628 if (strcmp (name, ".plt") == 0)
12630 /* Remember whether there is a PLT. */
12631 plt = s->size != 0;
12633 else if (CONST_STRNEQ (name, ".rel"))
12637 /* Remember whether there are any reloc sections other
12638 than .rel(a).plt and .rela.plt.unloaded. */
12639 if (s != htab->root.srelplt && s != htab->srelplt2)
12642 /* We use the reloc_count field as a counter if we need
12643 to copy relocs into the output file. */
12644 s->reloc_count = 0;
12647 else if (! CONST_STRNEQ (name, ".got")
12648 && strcmp (name, ".dynbss") != 0)
12650 /* It's not one of our sections, so don't allocate space. */
12656 /* If we don't need this section, strip it from the
12657 output file. This is mostly to handle .rel(a).bss and
12658 .rel(a).plt. We must create both sections in
12659 create_dynamic_sections, because they must be created
12660 before the linker maps input sections to output
12661 sections. The linker does that before
12662 adjust_dynamic_symbol is called, and it is that
12663 function which decides whether anything needs to go
12664 into these sections. */
12665 s->flags |= SEC_EXCLUDE;
12669 if ((s->flags & SEC_HAS_CONTENTS) == 0)
12672 /* Allocate memory for the section contents. */
12673 s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
12674 if (s->contents == NULL)
12678 if (elf_hash_table (info)->dynamic_sections_created)
12680 /* Add some entries to the .dynamic section. We fill in the
12681 values later, in elf32_arm_finish_dynamic_sections, but we
12682 must add the entries now so that we get the correct size for
12683 the .dynamic section. The DT_DEBUG entry is filled in by the
12684 dynamic linker and used by the debugger. */
12685 #define add_dynamic_entry(TAG, VAL) \
12686 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
12688 if (info->executable)
12690 if (!add_dynamic_entry (DT_DEBUG, 0))
12696 if ( !add_dynamic_entry (DT_PLTGOT, 0)
12697 || !add_dynamic_entry (DT_PLTRELSZ, 0)
12698 || !add_dynamic_entry (DT_PLTREL,
12699 htab->use_rel ? DT_REL : DT_RELA)
12700 || !add_dynamic_entry (DT_JMPREL, 0))
12703 if (htab->dt_tlsdesc_plt &&
12704 (!add_dynamic_entry (DT_TLSDESC_PLT,0)
12705 || !add_dynamic_entry (DT_TLSDESC_GOT,0)))
12713 if (!add_dynamic_entry (DT_REL, 0)
12714 || !add_dynamic_entry (DT_RELSZ, 0)
12715 || !add_dynamic_entry (DT_RELENT, RELOC_SIZE (htab)))
12720 if (!add_dynamic_entry (DT_RELA, 0)
12721 || !add_dynamic_entry (DT_RELASZ, 0)
12722 || !add_dynamic_entry (DT_RELAENT, RELOC_SIZE (htab)))
12727 /* If any dynamic relocs apply to a read-only section,
12728 then we need a DT_TEXTREL entry. */
12729 if ((info->flags & DF_TEXTREL) == 0)
12730 elf_link_hash_traverse (& htab->root, elf32_arm_readonly_dynrelocs,
12733 if ((info->flags & DF_TEXTREL) != 0)
12735 if (!add_dynamic_entry (DT_TEXTREL, 0))
12738 if (htab->vxworks_p
12739 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
12742 #undef add_dynamic_entry
12747 /* Size sections even though they're not dynamic. We use it to setup
12748 _TLS_MODULE_BASE_, if needed. */
12751 elf32_arm_always_size_sections (bfd *output_bfd,
12752 struct bfd_link_info *info)
12756 if (info->relocatable)
12759 tls_sec = elf_hash_table (info)->tls_sec;
12763 struct elf_link_hash_entry *tlsbase;
12765 tlsbase = elf_link_hash_lookup
12766 (elf_hash_table (info), "_TLS_MODULE_BASE_", TRUE, TRUE, FALSE);
12770 struct bfd_link_hash_entry *bh = NULL;
12771 const struct elf_backend_data *bed
12772 = get_elf_backend_data (output_bfd);
12774 if (!(_bfd_generic_link_add_one_symbol
12775 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
12776 tls_sec, 0, NULL, FALSE,
12777 bed->collect, &bh)))
12780 tlsbase->type = STT_TLS;
12781 tlsbase = (struct elf_link_hash_entry *)bh;
12782 tlsbase->def_regular = 1;
12783 tlsbase->other = STV_HIDDEN;
12784 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
12790 /* Finish up dynamic symbol handling. We set the contents of various
12791 dynamic sections here. */
12794 elf32_arm_finish_dynamic_symbol (bfd * output_bfd,
12795 struct bfd_link_info * info,
12796 struct elf_link_hash_entry * h,
12797 Elf_Internal_Sym * sym)
12799 struct elf32_arm_link_hash_table *htab;
12800 struct elf32_arm_link_hash_entry *eh;
12802 htab = elf32_arm_hash_table (info);
12806 eh = (struct elf32_arm_link_hash_entry *) h;
12808 if (h->plt.offset != (bfd_vma) -1)
12814 Elf_Internal_Rela rel;
12816 /* This symbol has an entry in the procedure linkage table. Set
12819 BFD_ASSERT (h->dynindx != -1);
12821 splt = htab->root.splt;
12822 srel = htab->root.srelplt;
12823 BFD_ASSERT (splt != NULL && srel != NULL);
12825 /* Fill in the entry in the procedure linkage table. */
12826 if (htab->symbian_p)
12828 put_arm_insn (htab, output_bfd,
12829 elf32_arm_symbian_plt_entry[0],
12830 splt->contents + h->plt.offset);
12831 bfd_put_32 (output_bfd,
12832 elf32_arm_symbian_plt_entry[1],
12833 splt->contents + h->plt.offset + 4);
12835 /* Fill in the entry in the .rel.plt section. */
12836 rel.r_offset = (splt->output_section->vma
12837 + splt->output_offset
12838 + h->plt.offset + 4);
12839 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
12841 /* Get the index in the procedure linkage table which
12842 corresponds to this symbol. This is the index of this symbol
12843 in all the symbols for which we are making plt entries. The
12844 first entry in the procedure linkage table is reserved. */
12845 plt_index = ((h->plt.offset - htab->plt_header_size)
12846 / htab->plt_entry_size);
12850 bfd_vma got_offset, got_address, plt_address;
12851 bfd_vma got_displacement;
12855 sgot = htab->root.sgotplt;
12856 BFD_ASSERT (sgot != NULL);
12858 /* Get the offset into the .got.plt table of the entry that
12859 corresponds to this function. */
12860 got_offset = eh->plt_got_offset;
12862 /* Get the index in the procedure linkage table which
12863 corresponds to this symbol. This is the index of this symbol
12864 in all the symbols for which we are making plt entries. The
12865 first three entries in .got.plt are reserved; after that
12866 symbols appear in the same order as in .plt. */
12867 plt_index = (got_offset - 12) / 4;
12869 /* Calculate the address of the GOT entry. */
12870 got_address = (sgot->output_section->vma
12871 + sgot->output_offset
12874 /* ...and the address of the PLT entry. */
12875 plt_address = (splt->output_section->vma
12876 + splt->output_offset
12879 ptr = splt->contents + h->plt.offset;
12880 if (htab->vxworks_p && info->shared)
12885 for (i = 0; i != htab->plt_entry_size / 4; i++, ptr += 4)
12887 val = elf32_arm_vxworks_shared_plt_entry[i];
12889 val |= got_address - sgot->output_section->vma;
12891 val |= plt_index * RELOC_SIZE (htab);
12892 if (i == 2 || i == 5)
12893 bfd_put_32 (output_bfd, val, ptr);
12895 put_arm_insn (htab, output_bfd, val, ptr);
12898 else if (htab->vxworks_p)
12903 for (i = 0; i != htab->plt_entry_size / 4; i++, ptr += 4)
12905 val = elf32_arm_vxworks_exec_plt_entry[i];
12907 val |= got_address;
12909 val |= 0xffffff & -((h->plt.offset + i * 4 + 8) >> 2);
12911 val |= plt_index * RELOC_SIZE (htab);
12912 if (i == 2 || i == 5)
12913 bfd_put_32 (output_bfd, val, ptr);
12915 put_arm_insn (htab, output_bfd, val, ptr);
12918 loc = (htab->srelplt2->contents
12919 + (plt_index * 2 + 1) * RELOC_SIZE (htab));
12921 /* Create the .rela.plt.unloaded R_ARM_ABS32 relocation
12922 referencing the GOT for this PLT entry. */
12923 rel.r_offset = plt_address + 8;
12924 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
12925 rel.r_addend = got_offset;
12926 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
12927 loc += RELOC_SIZE (htab);
12929 /* Create the R_ARM_ABS32 relocation referencing the
12930 beginning of the PLT for this GOT entry. */
12931 rel.r_offset = got_address;
12932 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_ARM_ABS32);
12934 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
12938 bfd_signed_vma thumb_refs;
12939 /* Calculate the displacement between the PLT slot and the
12940 entry in the GOT. The eight-byte offset accounts for the
12941 value produced by adding to pc in the first instruction
12942 of the PLT stub. */
12943 got_displacement = got_address - (plt_address + 8);
12945 BFD_ASSERT ((got_displacement & 0xf0000000) == 0);
12947 thumb_refs = eh->plt_thumb_refcount;
12948 if (!htab->use_blx)
12949 thumb_refs += eh->plt_maybe_thumb_refcount;
12951 if (thumb_refs > 0)
12953 put_thumb_insn (htab, output_bfd,
12954 elf32_arm_plt_thumb_stub[0], ptr - 4);
12955 put_thumb_insn (htab, output_bfd,
12956 elf32_arm_plt_thumb_stub[1], ptr - 2);
12959 put_arm_insn (htab, output_bfd,
12960 elf32_arm_plt_entry[0]
12961 | ((got_displacement & 0x0ff00000) >> 20),
12963 put_arm_insn (htab, output_bfd,
12964 elf32_arm_plt_entry[1]
12965 | ((got_displacement & 0x000ff000) >> 12),
12967 put_arm_insn (htab, output_bfd,
12968 elf32_arm_plt_entry[2]
12969 | (got_displacement & 0x00000fff),
12971 #ifdef FOUR_WORD_PLT
12972 bfd_put_32 (output_bfd, elf32_arm_plt_entry[3], ptr + 12);
12976 /* Fill in the entry in the global offset table. */
12977 bfd_put_32 (output_bfd,
12978 (splt->output_section->vma
12979 + splt->output_offset),
12980 sgot->contents + got_offset);
12982 /* Fill in the entry in the .rel(a).plt section. */
12984 rel.r_offset = got_address;
12985 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
12988 loc = srel->contents + plt_index * RELOC_SIZE (htab);
12989 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
12991 if (!h->def_regular)
12993 /* Mark the symbol as undefined, rather than as defined in
12994 the .plt section. Leave the value alone. */
12995 sym->st_shndx = SHN_UNDEF;
12996 /* If the symbol is weak, we do need to clear the value.
12997 Otherwise, the PLT entry would provide a definition for
12998 the symbol even if the symbol wasn't defined anywhere,
12999 and so the symbol would never be NULL. */
13000 if (!h->ref_regular_nonweak)
13005 if (h->got.offset != (bfd_vma) -1
13006 && (! GOT_TLS_GD_ANY_P (elf32_arm_hash_entry (h)->tls_type))
13007 && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_IE) == 0)
13011 Elf_Internal_Rela rel;
13015 /* This symbol has an entry in the global offset table. Set it
13017 sgot = htab->root.sgot;
13018 srel = htab->root.srelgot;
13019 BFD_ASSERT (sgot != NULL && srel != NULL);
13021 offset = (h->got.offset & ~(bfd_vma) 1);
13023 rel.r_offset = (sgot->output_section->vma
13024 + sgot->output_offset
13027 /* If this is a static link, or it is a -Bsymbolic link and the
13028 symbol is defined locally or was forced to be local because
13029 of a version file, we just want to emit a RELATIVE reloc.
13030 The entry in the global offset table will already have been
13031 initialized in the relocate_section function. */
13033 && SYMBOL_REFERENCES_LOCAL (info, h))
13035 BFD_ASSERT ((h->got.offset & 1) != 0);
13036 rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
13037 if (!htab->use_rel)
13039 rel.r_addend = bfd_get_32 (output_bfd, sgot->contents + offset);
13040 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset);
13045 BFD_ASSERT ((h->got.offset & 1) == 0);
13046 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset);
13047 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
13050 loc = srel->contents + srel->reloc_count++ * RELOC_SIZE (htab);
13051 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
13057 Elf_Internal_Rela rel;
13060 /* This symbol needs a copy reloc. Set it up. */
13061 BFD_ASSERT (h->dynindx != -1
13062 && (h->root.type == bfd_link_hash_defined
13063 || h->root.type == bfd_link_hash_defweak));
13066 BFD_ASSERT (s != NULL);
13069 rel.r_offset = (h->root.u.def.value
13070 + h->root.u.def.section->output_section->vma
13071 + h->root.u.def.section->output_offset);
13072 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
13073 loc = s->contents + s->reloc_count++ * RELOC_SIZE (htab);
13074 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
13077 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. On VxWorks,
13078 the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: it is relative
13079 to the ".got" section. */
13080 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
13081 || (!htab->vxworks_p && h == htab->root.hgot))
13082 sym->st_shndx = SHN_ABS;
13088 arm_put_trampoline (struct elf32_arm_link_hash_table *htab, bfd *output_bfd,
13090 const unsigned long *template, unsigned count)
13094 for (ix = 0; ix != count; ix++)
13096 unsigned long insn = template[ix];
13098 /* Emit mov pc,rx if bx is not permitted. */
13099 if (htab->fix_v4bx == 1 && (insn & 0x0ffffff0) == 0x012fff10)
13100 insn = (insn & 0xf000000f) | 0x01a0f000;
13101 put_arm_insn (htab, output_bfd, insn, (char *)contents + ix*4);
13105 /* Finish up the dynamic sections. */
13108 elf32_arm_finish_dynamic_sections (bfd * output_bfd, struct bfd_link_info * info)
13113 struct elf32_arm_link_hash_table *htab;
13115 htab = elf32_arm_hash_table (info);
13119 dynobj = elf_hash_table (info)->dynobj;
13121 sgot = htab->root.sgotplt;
13122 BFD_ASSERT (htab->symbian_p || sgot != NULL);
13123 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
13125 if (elf_hash_table (info)->dynamic_sections_created)
13128 Elf32_External_Dyn *dyncon, *dynconend;
13130 splt = htab->root.splt;
13131 BFD_ASSERT (splt != NULL && sdyn != NULL);
13133 dyncon = (Elf32_External_Dyn *) sdyn->contents;
13134 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
13136 for (; dyncon < dynconend; dyncon++)
13138 Elf_Internal_Dyn dyn;
13142 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
13149 if (htab->vxworks_p
13150 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
13151 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
13156 goto get_vma_if_bpabi;
13159 goto get_vma_if_bpabi;
13162 goto get_vma_if_bpabi;
13164 name = ".gnu.version";
13165 goto get_vma_if_bpabi;
13167 name = ".gnu.version_d";
13168 goto get_vma_if_bpabi;
13170 name = ".gnu.version_r";
13171 goto get_vma_if_bpabi;
13177 name = RELOC_SECTION (htab, ".plt");
13179 s = bfd_get_section_by_name (output_bfd, name);
13180 BFD_ASSERT (s != NULL);
13181 if (!htab->symbian_p)
13182 dyn.d_un.d_ptr = s->vma;
13184 /* In the BPABI, tags in the PT_DYNAMIC section point
13185 at the file offset, not the memory address, for the
13186 convenience of the post linker. */
13187 dyn.d_un.d_ptr = s->filepos;
13188 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
13192 if (htab->symbian_p)
13197 s = htab->root.srelplt;
13198 BFD_ASSERT (s != NULL);
13199 dyn.d_un.d_val = s->size;
13200 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
13205 if (!htab->symbian_p)
13207 /* My reading of the SVR4 ABI indicates that the
13208 procedure linkage table relocs (DT_JMPREL) should be
13209 included in the overall relocs (DT_REL). This is
13210 what Solaris does. However, UnixWare can not handle
13211 that case. Therefore, we override the DT_RELSZ entry
13212 here to make it not include the JMPREL relocs. Since
13213 the linker script arranges for .rel(a).plt to follow all
13214 other relocation sections, we don't have to worry
13215 about changing the DT_REL entry. */
13216 s = htab->root.srelplt;
13218 dyn.d_un.d_val -= s->size;
13219 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
13222 /* Fall through. */
13226 /* In the BPABI, the DT_REL tag must point at the file
13227 offset, not the VMA, of the first relocation
13228 section. So, we use code similar to that in
13229 elflink.c, but do not check for SHF_ALLOC on the
13230 relcoation section, since relocations sections are
13231 never allocated under the BPABI. The comments above
13232 about Unixware notwithstanding, we include all of the
13233 relocations here. */
13234 if (htab->symbian_p)
13237 type = ((dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
13238 ? SHT_REL : SHT_RELA);
13239 dyn.d_un.d_val = 0;
13240 for (i = 1; i < elf_numsections (output_bfd); i++)
13242 Elf_Internal_Shdr *hdr
13243 = elf_elfsections (output_bfd)[i];
13244 if (hdr->sh_type == type)
13246 if (dyn.d_tag == DT_RELSZ
13247 || dyn.d_tag == DT_RELASZ)
13248 dyn.d_un.d_val += hdr->sh_size;
13249 else if ((ufile_ptr) hdr->sh_offset
13250 <= dyn.d_un.d_val - 1)
13251 dyn.d_un.d_val = hdr->sh_offset;
13254 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
13258 case DT_TLSDESC_PLT:
13259 s = htab->root.splt;
13260 dyn.d_un.d_ptr = (s->output_section->vma + s->output_offset
13261 + htab->dt_tlsdesc_plt);
13262 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
13265 case DT_TLSDESC_GOT:
13266 s = htab->root.sgot;
13267 dyn.d_un.d_ptr = (s->output_section->vma + s->output_offset
13268 + htab->dt_tlsdesc_got);
13269 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
13272 /* Set the bottom bit of DT_INIT/FINI if the
13273 corresponding function is Thumb. */
13275 name = info->init_function;
13278 name = info->fini_function;
13280 /* If it wasn't set by elf_bfd_final_link
13281 then there is nothing to adjust. */
13282 if (dyn.d_un.d_val != 0)
13284 struct elf_link_hash_entry * eh;
13286 eh = elf_link_hash_lookup (elf_hash_table (info), name,
13287 FALSE, FALSE, TRUE);
13289 && ELF_ST_TYPE (eh->type) == STT_ARM_TFUNC)
13291 dyn.d_un.d_val |= 1;
13292 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
13299 /* Fill in the first entry in the procedure linkage table. */
13300 if (splt->size > 0 && htab->plt_header_size)
13302 const bfd_vma *plt0_entry;
13303 bfd_vma got_address, plt_address, got_displacement;
13305 /* Calculate the addresses of the GOT and PLT. */
13306 got_address = sgot->output_section->vma + sgot->output_offset;
13307 plt_address = splt->output_section->vma + splt->output_offset;
13309 if (htab->vxworks_p)
13311 /* The VxWorks GOT is relocated by the dynamic linker.
13312 Therefore, we must emit relocations rather than simply
13313 computing the values now. */
13314 Elf_Internal_Rela rel;
13316 plt0_entry = elf32_arm_vxworks_exec_plt0_entry;
13317 put_arm_insn (htab, output_bfd, plt0_entry[0],
13318 splt->contents + 0);
13319 put_arm_insn (htab, output_bfd, plt0_entry[1],
13320 splt->contents + 4);
13321 put_arm_insn (htab, output_bfd, plt0_entry[2],
13322 splt->contents + 8);
13323 bfd_put_32 (output_bfd, got_address, splt->contents + 12);
13325 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_. */
13326 rel.r_offset = plt_address + 12;
13327 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
13329 SWAP_RELOC_OUT (htab) (output_bfd, &rel,
13330 htab->srelplt2->contents);
13334 got_displacement = got_address - (plt_address + 16);
13336 plt0_entry = elf32_arm_plt0_entry;
13337 put_arm_insn (htab, output_bfd, plt0_entry[0],
13338 splt->contents + 0);
13339 put_arm_insn (htab, output_bfd, plt0_entry[1],
13340 splt->contents + 4);
13341 put_arm_insn (htab, output_bfd, plt0_entry[2],
13342 splt->contents + 8);
13343 put_arm_insn (htab, output_bfd, plt0_entry[3],
13344 splt->contents + 12);
13346 #ifdef FOUR_WORD_PLT
13347 /* The displacement value goes in the otherwise-unused
13348 last word of the second entry. */
13349 bfd_put_32 (output_bfd, got_displacement, splt->contents + 28);
13351 bfd_put_32 (output_bfd, got_displacement, splt->contents + 16);
13356 /* UnixWare sets the entsize of .plt to 4, although that doesn't
13357 really seem like the right value. */
13358 if (splt->output_section->owner == output_bfd)
13359 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
13361 if (htab->dt_tlsdesc_plt)
13363 bfd_vma got_address
13364 = sgot->output_section->vma + sgot->output_offset;
13365 bfd_vma gotplt_address = (htab->root.sgot->output_section->vma
13366 + htab->root.sgot->output_offset);
13367 bfd_vma plt_address
13368 = splt->output_section->vma + splt->output_offset;
13370 arm_put_trampoline (htab, output_bfd,
13371 splt->contents + htab->dt_tlsdesc_plt,
13372 dl_tlsdesc_lazy_trampoline, 6);
13374 bfd_put_32 (output_bfd,
13375 gotplt_address + htab->dt_tlsdesc_got
13376 - (plt_address + htab->dt_tlsdesc_plt)
13377 - dl_tlsdesc_lazy_trampoline[6],
13378 splt->contents + htab->dt_tlsdesc_plt + 24);
13379 bfd_put_32 (output_bfd,
13380 got_address - (plt_address + htab->dt_tlsdesc_plt)
13381 - dl_tlsdesc_lazy_trampoline[7],
13382 splt->contents + htab->dt_tlsdesc_plt + 24 + 4);
13385 if (htab->tls_trampoline)
13387 arm_put_trampoline (htab, output_bfd,
13388 splt->contents + htab->tls_trampoline,
13389 tls_trampoline, 3);
13390 #ifdef FOUR_WORD_PLT
13391 bfd_put_32 (output_bfd, 0x00000000,
13392 splt->contents + htab->tls_trampoline + 12);
13396 if (htab->vxworks_p && !info->shared && htab->root.splt->size > 0)
13398 /* Correct the .rel(a).plt.unloaded relocations. They will have
13399 incorrect symbol indexes. */
13403 num_plts = ((htab->root.splt->size - htab->plt_header_size)
13404 / htab->plt_entry_size);
13405 p = htab->srelplt2->contents + RELOC_SIZE (htab);
13407 for (; num_plts; num_plts--)
13409 Elf_Internal_Rela rel;
13411 SWAP_RELOC_IN (htab) (output_bfd, p, &rel);
13412 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
13413 SWAP_RELOC_OUT (htab) (output_bfd, &rel, p);
13414 p += RELOC_SIZE (htab);
13416 SWAP_RELOC_IN (htab) (output_bfd, p, &rel);
13417 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_ARM_ABS32);
13418 SWAP_RELOC_OUT (htab) (output_bfd, &rel, p);
13419 p += RELOC_SIZE (htab);
13424 /* Fill in the first three entries in the global offset table. */
13427 if (sgot->size > 0)
13430 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
13432 bfd_put_32 (output_bfd,
13433 sdyn->output_section->vma + sdyn->output_offset,
13435 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
13436 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
13439 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
13446 elf32_arm_post_process_headers (bfd * abfd, struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
13448 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
13449 struct elf32_arm_link_hash_table *globals;
13451 i_ehdrp = elf_elfheader (abfd);
13453 if (EF_ARM_EABI_VERSION (i_ehdrp->e_flags) == EF_ARM_EABI_UNKNOWN)
13454 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_ARM;
13456 i_ehdrp->e_ident[EI_OSABI] = 0;
13457 i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
13461 globals = elf32_arm_hash_table (link_info);
13462 if (globals != NULL && globals->byteswap_code)
13463 i_ehdrp->e_flags |= EF_ARM_BE8;
13467 static enum elf_reloc_type_class
13468 elf32_arm_reloc_type_class (const Elf_Internal_Rela *rela)
13470 switch ((int) ELF32_R_TYPE (rela->r_info))
13472 case R_ARM_RELATIVE:
13473 return reloc_class_relative;
13474 case R_ARM_JUMP_SLOT:
13475 return reloc_class_plt;
13477 return reloc_class_copy;
13479 return reloc_class_normal;
13483 /* Set the right machine number for an Arm ELF file. */
13486 elf32_arm_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
13488 if (hdr->sh_type == SHT_NOTE)
13489 *flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_CONTENTS;
13495 elf32_arm_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
13497 bfd_arm_update_notes (abfd, ARM_NOTE_SECTION);
13500 /* Return TRUE if this is an unwinding table entry. */
13503 is_arm_elf_unwind_section_name (bfd * abfd ATTRIBUTE_UNUSED, const char * name)
13505 return (CONST_STRNEQ (name, ELF_STRING_ARM_unwind)
13506 || CONST_STRNEQ (name, ELF_STRING_ARM_unwind_once));
13510 /* Set the type and flags for an ARM section. We do this by
13511 the section name, which is a hack, but ought to work. */
13514 elf32_arm_fake_sections (bfd * abfd, Elf_Internal_Shdr * hdr, asection * sec)
13518 name = bfd_get_section_name (abfd, sec);
13520 if (is_arm_elf_unwind_section_name (abfd, name))
13522 hdr->sh_type = SHT_ARM_EXIDX;
13523 hdr->sh_flags |= SHF_LINK_ORDER;
13528 /* Handle an ARM specific section when reading an object file. This is
13529 called when bfd_section_from_shdr finds a section with an unknown
13533 elf32_arm_section_from_shdr (bfd *abfd,
13534 Elf_Internal_Shdr * hdr,
13538 /* There ought to be a place to keep ELF backend specific flags, but
13539 at the moment there isn't one. We just keep track of the
13540 sections by their name, instead. Fortunately, the ABI gives
13541 names for all the ARM specific sections, so we will probably get
13543 switch (hdr->sh_type)
13545 case SHT_ARM_EXIDX:
13546 case SHT_ARM_PREEMPTMAP:
13547 case SHT_ARM_ATTRIBUTES:
13554 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
13560 static _arm_elf_section_data *
13561 get_arm_elf_section_data (asection * sec)
13563 if (sec && sec->owner && is_arm_elf (sec->owner))
13564 return elf32_arm_section_data (sec);
13572 struct bfd_link_info *info;
13575 int (*func) (void *, const char *, Elf_Internal_Sym *,
13576 asection *, struct elf_link_hash_entry *);
13577 } output_arch_syminfo;
13579 enum map_symbol_type
13587 /* Output a single mapping symbol. */
13590 elf32_arm_output_map_sym (output_arch_syminfo *osi,
13591 enum map_symbol_type type,
13594 static const char *names[3] = {"$a", "$t", "$d"};
13595 Elf_Internal_Sym sym;
13597 sym.st_value = osi->sec->output_section->vma
13598 + osi->sec->output_offset
13602 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_NOTYPE);
13603 sym.st_shndx = osi->sec_shndx;
13604 elf32_arm_section_map_add (osi->sec, names[type][1], offset);
13605 return osi->func (osi->finfo, names[type], &sym, osi->sec, NULL) == 1;
13609 /* Output mapping symbols for PLT entries associated with H. */
13612 elf32_arm_output_plt_map (struct elf_link_hash_entry *h, void *inf)
13614 output_arch_syminfo *osi = (output_arch_syminfo *) inf;
13615 struct elf32_arm_link_hash_table *htab;
13616 struct elf32_arm_link_hash_entry *eh;
13619 if (h->root.type == bfd_link_hash_indirect)
13622 if (h->root.type == bfd_link_hash_warning)
13623 /* When warning symbols are created, they **replace** the "real"
13624 entry in the hash table, thus we never get to see the real
13625 symbol in a hash traversal. So look at it now. */
13626 h = (struct elf_link_hash_entry *) h->root.u.i.link;
13628 if (h->plt.offset == (bfd_vma) -1)
13631 htab = elf32_arm_hash_table (osi->info);
13635 eh = (struct elf32_arm_link_hash_entry *) h;
13636 addr = h->plt.offset;
13637 if (htab->symbian_p)
13639 if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
13641 if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 4))
13644 else if (htab->vxworks_p)
13646 if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
13648 if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 8))
13650 if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr + 12))
13652 if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 20))
13657 bfd_signed_vma thumb_refs;
13659 thumb_refs = eh->plt_thumb_refcount;
13660 if (!htab->use_blx)
13661 thumb_refs += eh->plt_maybe_thumb_refcount;
13663 if (thumb_refs > 0)
13665 if (!elf32_arm_output_map_sym (osi, ARM_MAP_THUMB, addr - 4))
13668 #ifdef FOUR_WORD_PLT
13669 if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
13671 if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 12))
13674 /* A three-word PLT with no Thumb thunk contains only Arm code,
13675 so only need to output a mapping symbol for the first PLT entry and
13676 entries with thumb thunks. */
13677 if (thumb_refs > 0 || addr == 20)
13679 if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
13688 /* Output a single local symbol for a generated stub. */
13691 elf32_arm_output_stub_sym (output_arch_syminfo *osi, const char *name,
13692 bfd_vma offset, bfd_vma size)
13694 Elf_Internal_Sym sym;
13696 sym.st_value = osi->sec->output_section->vma
13697 + osi->sec->output_offset
13699 sym.st_size = size;
13701 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
13702 sym.st_shndx = osi->sec_shndx;
13703 return osi->func (osi->finfo, name, &sym, osi->sec, NULL) == 1;
13707 arm_map_one_stub (struct bfd_hash_entry * gen_entry,
13710 struct elf32_arm_stub_hash_entry *stub_entry;
13711 asection *stub_sec;
13714 output_arch_syminfo *osi;
13715 const insn_sequence *template_sequence;
13716 enum stub_insn_type prev_type;
13719 enum map_symbol_type sym_type;
13721 /* Massage our args to the form they really have. */
13722 stub_entry = (struct elf32_arm_stub_hash_entry *) gen_entry;
13723 osi = (output_arch_syminfo *) in_arg;
13725 stub_sec = stub_entry->stub_sec;
13727 /* Ensure this stub is attached to the current section being
13729 if (stub_sec != osi->sec)
13732 addr = (bfd_vma) stub_entry->stub_offset;
13733 stub_name = stub_entry->output_name;
13735 template_sequence = stub_entry->stub_template;
13736 switch (template_sequence[0].type)
13739 if (!elf32_arm_output_stub_sym (osi, stub_name, addr, stub_entry->stub_size))
13744 if (!elf32_arm_output_stub_sym (osi, stub_name, addr | 1,
13745 stub_entry->stub_size))
13753 prev_type = DATA_TYPE;
13755 for (i = 0; i < stub_entry->stub_template_size; i++)
13757 switch (template_sequence[i].type)
13760 sym_type = ARM_MAP_ARM;
13765 sym_type = ARM_MAP_THUMB;
13769 sym_type = ARM_MAP_DATA;
13777 if (template_sequence[i].type != prev_type)
13779 prev_type = template_sequence[i].type;
13780 if (!elf32_arm_output_map_sym (osi, sym_type, addr + size))
13784 switch (template_sequence[i].type)
13808 /* Output mapping symbols for linker generated sections,
13809 and for those data-only sections that do not have a
13813 elf32_arm_output_arch_local_syms (bfd *output_bfd,
13814 struct bfd_link_info *info,
13816 int (*func) (void *, const char *,
13817 Elf_Internal_Sym *,
13819 struct elf_link_hash_entry *))
13821 output_arch_syminfo osi;
13822 struct elf32_arm_link_hash_table *htab;
13824 bfd_size_type size;
13827 htab = elf32_arm_hash_table (info);
13831 check_use_blx (htab);
13837 /* Add a $d mapping symbol to data-only sections that
13838 don't have any mapping symbol. This may result in (harmless) redundant
13839 mapping symbols. */
13840 for (input_bfd = info->input_bfds;
13842 input_bfd = input_bfd->link_next)
13844 if ((input_bfd->flags & (BFD_LINKER_CREATED | HAS_SYMS)) == HAS_SYMS)
13845 for (osi.sec = input_bfd->sections;
13847 osi.sec = osi.sec->next)
13849 if (osi.sec->output_section != NULL
13850 && ((osi.sec->output_section->flags & (SEC_ALLOC | SEC_CODE))
13852 && (osi.sec->flags & (SEC_HAS_CONTENTS | SEC_LINKER_CREATED))
13853 == SEC_HAS_CONTENTS
13854 && get_arm_elf_section_data (osi.sec) != NULL
13855 && get_arm_elf_section_data (osi.sec)->mapcount == 0
13856 && osi.sec->size > 0)
13858 osi.sec_shndx = _bfd_elf_section_from_bfd_section
13859 (output_bfd, osi.sec->output_section);
13860 if (osi.sec_shndx != (int)SHN_BAD)
13861 elf32_arm_output_map_sym (&osi, ARM_MAP_DATA, 0);
13866 /* ARM->Thumb glue. */
13867 if (htab->arm_glue_size > 0)
13869 osi.sec = bfd_get_section_by_name (htab->bfd_of_glue_owner,
13870 ARM2THUMB_GLUE_SECTION_NAME);
13872 osi.sec_shndx = _bfd_elf_section_from_bfd_section
13873 (output_bfd, osi.sec->output_section);
13874 if (info->shared || htab->root.is_relocatable_executable
13875 || htab->pic_veneer)
13876 size = ARM2THUMB_PIC_GLUE_SIZE;
13877 else if (htab->use_blx)
13878 size = ARM2THUMB_V5_STATIC_GLUE_SIZE;
13880 size = ARM2THUMB_STATIC_GLUE_SIZE;
13882 for (offset = 0; offset < htab->arm_glue_size; offset += size)
13884 elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, offset);
13885 elf32_arm_output_map_sym (&osi, ARM_MAP_DATA, offset + size - 4);
13889 /* Thumb->ARM glue. */
13890 if (htab->thumb_glue_size > 0)
13892 osi.sec = bfd_get_section_by_name (htab->bfd_of_glue_owner,
13893 THUMB2ARM_GLUE_SECTION_NAME);
13895 osi.sec_shndx = _bfd_elf_section_from_bfd_section
13896 (output_bfd, osi.sec->output_section);
13897 size = THUMB2ARM_GLUE_SIZE;
13899 for (offset = 0; offset < htab->thumb_glue_size; offset += size)
13901 elf32_arm_output_map_sym (&osi, ARM_MAP_THUMB, offset);
13902 elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, offset + 4);
13906 /* ARMv4 BX veneers. */
13907 if (htab->bx_glue_size > 0)
13909 osi.sec = bfd_get_section_by_name (htab->bfd_of_glue_owner,
13910 ARM_BX_GLUE_SECTION_NAME);
13912 osi.sec_shndx = _bfd_elf_section_from_bfd_section
13913 (output_bfd, osi.sec->output_section);
13915 elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, 0);
13918 /* Long calls stubs. */
13919 if (htab->stub_bfd && htab->stub_bfd->sections)
13921 asection* stub_sec;
13923 for (stub_sec = htab->stub_bfd->sections;
13925 stub_sec = stub_sec->next)
13927 /* Ignore non-stub sections. */
13928 if (!strstr (stub_sec->name, STUB_SUFFIX))
13931 osi.sec = stub_sec;
13933 osi.sec_shndx = _bfd_elf_section_from_bfd_section
13934 (output_bfd, osi.sec->output_section);
13936 bfd_hash_traverse (&htab->stub_hash_table, arm_map_one_stub, &osi);
13940 /* Finally, output mapping symbols for the PLT. */
13941 if (!htab->root.splt || htab->root.splt->size == 0)
13944 osi.sec = htab->root.splt;
13945 osi.sec_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
13946 osi.sec->output_section);
13947 /* Output mapping symbols for the plt header. SymbianOS does not have a
13949 if (htab->vxworks_p)
13951 /* VxWorks shared libraries have no PLT header. */
13954 if (!elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, 0))
13956 if (!elf32_arm_output_map_sym (&osi, ARM_MAP_DATA, 12))
13960 else if (!htab->symbian_p)
13962 if (!elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, 0))
13964 #ifndef FOUR_WORD_PLT
13965 if (!elf32_arm_output_map_sym (&osi, ARM_MAP_DATA, 16))
13970 if (htab->dt_tlsdesc_plt != 0)
13972 /* Mapping symbols for the lazy tls trampoline. */
13973 if (!elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, htab->dt_tlsdesc_plt))
13976 if (!elf32_arm_output_map_sym (&osi, ARM_MAP_DATA,
13977 htab->dt_tlsdesc_plt + 24))
13980 if (htab->tls_trampoline != 0)
13982 /* Mapping symbols for the tls trampoline. */
13983 if (!elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, htab->tls_trampoline))
13985 #ifdef FOUR_WORD_PLT
13986 if (!elf32_arm_output_map_sym (&osi, ARM_MAP_DATA,
13987 htab->tls_trampoline + 12))
13992 elf_link_hash_traverse (&htab->root, elf32_arm_output_plt_map, (void *) &osi);
13996 /* Allocate target specific section data. */
13999 elf32_arm_new_section_hook (bfd *abfd, asection *sec)
14001 if (!sec->used_by_bfd)
14003 _arm_elf_section_data *sdata;
14004 bfd_size_type amt = sizeof (*sdata);
14006 sdata = (_arm_elf_section_data *) bfd_zalloc (abfd, amt);
14009 sec->used_by_bfd = sdata;
14012 return _bfd_elf_new_section_hook (abfd, sec);
14016 /* Used to order a list of mapping symbols by address. */
14019 elf32_arm_compare_mapping (const void * a, const void * b)
14021 const elf32_arm_section_map *amap = (const elf32_arm_section_map *) a;
14022 const elf32_arm_section_map *bmap = (const elf32_arm_section_map *) b;
14024 if (amap->vma > bmap->vma)
14026 else if (amap->vma < bmap->vma)
14028 else if (amap->type > bmap->type)
14029 /* Ensure results do not depend on the host qsort for objects with
14030 multiple mapping symbols at the same address by sorting on type
14033 else if (amap->type < bmap->type)
14039 /* Add OFFSET to lower 31 bits of ADDR, leaving other bits unmodified. */
14041 static unsigned long
14042 offset_prel31 (unsigned long addr, bfd_vma offset)
14044 return (addr & ~0x7ffffffful) | ((addr + offset) & 0x7ffffffful);
14047 /* Copy an .ARM.exidx table entry, adding OFFSET to (applied) PREL31
14051 copy_exidx_entry (bfd *output_bfd, bfd_byte *to, bfd_byte *from, bfd_vma offset)
14053 unsigned long first_word = bfd_get_32 (output_bfd, from);
14054 unsigned long second_word = bfd_get_32 (output_bfd, from + 4);
14056 /* High bit of first word is supposed to be zero. */
14057 if ((first_word & 0x80000000ul) == 0)
14058 first_word = offset_prel31 (first_word, offset);
14060 /* If the high bit of the first word is clear, and the bit pattern is not 0x1
14061 (EXIDX_CANTUNWIND), this is an offset to an .ARM.extab entry. */
14062 if ((second_word != 0x1) && ((second_word & 0x80000000ul) == 0))
14063 second_word = offset_prel31 (second_word, offset);
14065 bfd_put_32 (output_bfd, first_word, to);
14066 bfd_put_32 (output_bfd, second_word, to + 4);
14069 /* Data for make_branch_to_a8_stub(). */
14071 struct a8_branch_to_stub_data {
14072 asection *writing_section;
14073 bfd_byte *contents;
14077 /* Helper to insert branches to Cortex-A8 erratum stubs in the right
14078 places for a particular section. */
14081 make_branch_to_a8_stub (struct bfd_hash_entry *gen_entry,
14084 struct elf32_arm_stub_hash_entry *stub_entry;
14085 struct a8_branch_to_stub_data *data;
14086 bfd_byte *contents;
14087 unsigned long branch_insn;
14088 bfd_vma veneered_insn_loc, veneer_entry_loc;
14089 bfd_signed_vma branch_offset;
14091 unsigned int target;
14093 stub_entry = (struct elf32_arm_stub_hash_entry *) gen_entry;
14094 data = (struct a8_branch_to_stub_data *) in_arg;
14096 if (stub_entry->target_section != data->writing_section
14097 || stub_entry->stub_type < arm_stub_a8_veneer_lwm)
14100 contents = data->contents;
14102 veneered_insn_loc = stub_entry->target_section->output_section->vma
14103 + stub_entry->target_section->output_offset
14104 + stub_entry->target_value;
14106 veneer_entry_loc = stub_entry->stub_sec->output_section->vma
14107 + stub_entry->stub_sec->output_offset
14108 + stub_entry->stub_offset;
14110 if (stub_entry->stub_type == arm_stub_a8_veneer_blx)
14111 veneered_insn_loc &= ~3u;
14113 branch_offset = veneer_entry_loc - veneered_insn_loc - 4;
14115 abfd = stub_entry->target_section->owner;
14116 target = stub_entry->target_value;
14118 /* We attempt to avoid this condition by setting stubs_always_after_branch
14119 in elf32_arm_size_stubs if we've enabled the Cortex-A8 erratum workaround.
14120 This check is just to be on the safe side... */
14121 if ((veneered_insn_loc & ~0xfff) == (veneer_entry_loc & ~0xfff))
14123 (*_bfd_error_handler) (_("%B: error: Cortex-A8 erratum stub is "
14124 "allocated in unsafe location"), abfd);
14128 switch (stub_entry->stub_type)
14130 case arm_stub_a8_veneer_b:
14131 case arm_stub_a8_veneer_b_cond:
14132 branch_insn = 0xf0009000;
14135 case arm_stub_a8_veneer_blx:
14136 branch_insn = 0xf000e800;
14139 case arm_stub_a8_veneer_bl:
14141 unsigned int i1, j1, i2, j2, s;
14143 branch_insn = 0xf000d000;
14146 if (branch_offset < -16777216 || branch_offset > 16777214)
14148 /* There's not much we can do apart from complain if this
14150 (*_bfd_error_handler) (_("%B: error: Cortex-A8 erratum stub out "
14151 "of range (input file too large)"), abfd);
14155 /* i1 = not(j1 eor s), so:
14157 j1 = (not i1) eor s. */
14159 branch_insn |= (branch_offset >> 1) & 0x7ff;
14160 branch_insn |= ((branch_offset >> 12) & 0x3ff) << 16;
14161 i2 = (branch_offset >> 22) & 1;
14162 i1 = (branch_offset >> 23) & 1;
14163 s = (branch_offset >> 24) & 1;
14166 branch_insn |= j2 << 11;
14167 branch_insn |= j1 << 13;
14168 branch_insn |= s << 26;
14177 bfd_put_16 (abfd, (branch_insn >> 16) & 0xffff, &contents[target]);
14178 bfd_put_16 (abfd, branch_insn & 0xffff, &contents[target + 2]);
14183 /* Do code byteswapping. Return FALSE afterwards so that the section is
14184 written out as normal. */
14187 elf32_arm_write_section (bfd *output_bfd,
14188 struct bfd_link_info *link_info,
14190 bfd_byte *contents)
14192 unsigned int mapcount, errcount;
14193 _arm_elf_section_data *arm_data;
14194 struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
14195 elf32_arm_section_map *map;
14196 elf32_vfp11_erratum_list *errnode;
14199 bfd_vma offset = sec->output_section->vma + sec->output_offset;
14203 if (globals == NULL)
14206 /* If this section has not been allocated an _arm_elf_section_data
14207 structure then we cannot record anything. */
14208 arm_data = get_arm_elf_section_data (sec);
14209 if (arm_data == NULL)
14212 mapcount = arm_data->mapcount;
14213 map = arm_data->map;
14214 errcount = arm_data->erratumcount;
14218 unsigned int endianflip = bfd_big_endian (output_bfd) ? 3 : 0;
14220 for (errnode = arm_data->erratumlist; errnode != 0;
14221 errnode = errnode->next)
14223 bfd_vma target = errnode->vma - offset;
14225 switch (errnode->type)
14227 case VFP11_ERRATUM_BRANCH_TO_ARM_VENEER:
14229 bfd_vma branch_to_veneer;
14230 /* Original condition code of instruction, plus bit mask for
14231 ARM B instruction. */
14232 unsigned int insn = (errnode->u.b.vfp_insn & 0xf0000000)
14235 /* The instruction is before the label. */
14238 /* Above offset included in -4 below. */
14239 branch_to_veneer = errnode->u.b.veneer->vma
14240 - errnode->vma - 4;
14242 if ((signed) branch_to_veneer < -(1 << 25)
14243 || (signed) branch_to_veneer >= (1 << 25))
14244 (*_bfd_error_handler) (_("%B: error: VFP11 veneer out of "
14245 "range"), output_bfd);
14247 insn |= (branch_to_veneer >> 2) & 0xffffff;
14248 contents[endianflip ^ target] = insn & 0xff;
14249 contents[endianflip ^ (target + 1)] = (insn >> 8) & 0xff;
14250 contents[endianflip ^ (target + 2)] = (insn >> 16) & 0xff;
14251 contents[endianflip ^ (target + 3)] = (insn >> 24) & 0xff;
14255 case VFP11_ERRATUM_ARM_VENEER:
14257 bfd_vma branch_from_veneer;
14260 /* Take size of veneer into account. */
14261 branch_from_veneer = errnode->u.v.branch->vma
14262 - errnode->vma - 12;
14264 if ((signed) branch_from_veneer < -(1 << 25)
14265 || (signed) branch_from_veneer >= (1 << 25))
14266 (*_bfd_error_handler) (_("%B: error: VFP11 veneer out of "
14267 "range"), output_bfd);
14269 /* Original instruction. */
14270 insn = errnode->u.v.branch->u.b.vfp_insn;
14271 contents[endianflip ^ target] = insn & 0xff;
14272 contents[endianflip ^ (target + 1)] = (insn >> 8) & 0xff;
14273 contents[endianflip ^ (target + 2)] = (insn >> 16) & 0xff;
14274 contents[endianflip ^ (target + 3)] = (insn >> 24) & 0xff;
14276 /* Branch back to insn after original insn. */
14277 insn = 0xea000000 | ((branch_from_veneer >> 2) & 0xffffff);
14278 contents[endianflip ^ (target + 4)] = insn & 0xff;
14279 contents[endianflip ^ (target + 5)] = (insn >> 8) & 0xff;
14280 contents[endianflip ^ (target + 6)] = (insn >> 16) & 0xff;
14281 contents[endianflip ^ (target + 7)] = (insn >> 24) & 0xff;
14291 if (arm_data->elf.this_hdr.sh_type == SHT_ARM_EXIDX)
14293 arm_unwind_table_edit *edit_node
14294 = arm_data->u.exidx.unwind_edit_list;
14295 /* Now, sec->size is the size of the section we will write. The original
14296 size (before we merged duplicate entries and inserted EXIDX_CANTUNWIND
14297 markers) was sec->rawsize. (This isn't the case if we perform no
14298 edits, then rawsize will be zero and we should use size). */
14299 bfd_byte *edited_contents = (bfd_byte *) bfd_malloc (sec->size);
14300 unsigned int input_size = sec->rawsize ? sec->rawsize : sec->size;
14301 unsigned int in_index, out_index;
14302 bfd_vma add_to_offsets = 0;
14304 for (in_index = 0, out_index = 0; in_index * 8 < input_size || edit_node;)
14308 unsigned int edit_index = edit_node->index;
14310 if (in_index < edit_index && in_index * 8 < input_size)
14312 copy_exidx_entry (output_bfd, edited_contents + out_index * 8,
14313 contents + in_index * 8, add_to_offsets);
14317 else if (in_index == edit_index
14318 || (in_index * 8 >= input_size
14319 && edit_index == UINT_MAX))
14321 switch (edit_node->type)
14323 case DELETE_EXIDX_ENTRY:
14325 add_to_offsets += 8;
14328 case INSERT_EXIDX_CANTUNWIND_AT_END:
14330 asection *text_sec = edit_node->linked_section;
14331 bfd_vma text_offset = text_sec->output_section->vma
14332 + text_sec->output_offset
14334 bfd_vma exidx_offset = offset + out_index * 8;
14335 unsigned long prel31_offset;
14337 /* Note: this is meant to be equivalent to an
14338 R_ARM_PREL31 relocation. These synthetic
14339 EXIDX_CANTUNWIND markers are not relocated by the
14340 usual BFD method. */
14341 prel31_offset = (text_offset - exidx_offset)
14344 /* First address we can't unwind. */
14345 bfd_put_32 (output_bfd, prel31_offset,
14346 &edited_contents[out_index * 8]);
14348 /* Code for EXIDX_CANTUNWIND. */
14349 bfd_put_32 (output_bfd, 0x1,
14350 &edited_contents[out_index * 8 + 4]);
14353 add_to_offsets -= 8;
14358 edit_node = edit_node->next;
14363 /* No more edits, copy remaining entries verbatim. */
14364 copy_exidx_entry (output_bfd, edited_contents + out_index * 8,
14365 contents + in_index * 8, add_to_offsets);
14371 if (!(sec->flags & SEC_EXCLUDE) && !(sec->flags & SEC_NEVER_LOAD))
14372 bfd_set_section_contents (output_bfd, sec->output_section,
14374 (file_ptr) sec->output_offset, sec->size);
14379 /* Fix code to point to Cortex-A8 erratum stubs. */
14380 if (globals->fix_cortex_a8)
14382 struct a8_branch_to_stub_data data;
14384 data.writing_section = sec;
14385 data.contents = contents;
14387 bfd_hash_traverse (&globals->stub_hash_table, make_branch_to_a8_stub,
14394 if (globals->byteswap_code)
14396 qsort (map, mapcount, sizeof (* map), elf32_arm_compare_mapping);
14399 for (i = 0; i < mapcount; i++)
14401 if (i == mapcount - 1)
14404 end = map[i + 1].vma;
14406 switch (map[i].type)
14409 /* Byte swap code words. */
14410 while (ptr + 3 < end)
14412 tmp = contents[ptr];
14413 contents[ptr] = contents[ptr + 3];
14414 contents[ptr + 3] = tmp;
14415 tmp = contents[ptr + 1];
14416 contents[ptr + 1] = contents[ptr + 2];
14417 contents[ptr + 2] = tmp;
14423 /* Byte swap code halfwords. */
14424 while (ptr + 1 < end)
14426 tmp = contents[ptr];
14427 contents[ptr] = contents[ptr + 1];
14428 contents[ptr + 1] = tmp;
14434 /* Leave data alone. */
14442 arm_data->mapcount = -1;
14443 arm_data->mapsize = 0;
14444 arm_data->map = NULL;
14449 /* Display STT_ARM_TFUNC symbols as functions. */
14452 elf32_arm_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
14455 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
14457 if (ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_ARM_TFUNC)
14458 elfsym->symbol.flags |= BSF_FUNCTION;
14462 /* Mangle thumb function symbols as we read them in. */
14465 elf32_arm_swap_symbol_in (bfd * abfd,
14468 Elf_Internal_Sym *dst)
14470 if (!bfd_elf32_swap_symbol_in (abfd, psrc, pshn, dst))
14473 /* New EABI objects mark thumb function symbols by setting the low bit of
14474 the address. Turn these into STT_ARM_TFUNC. */
14475 if ((ELF_ST_TYPE (dst->st_info) == STT_FUNC)
14476 && (dst->st_value & 1))
14478 dst->st_info = ELF_ST_INFO (ELF_ST_BIND (dst->st_info), STT_ARM_TFUNC);
14479 dst->st_value &= ~(bfd_vma) 1;
14485 /* Mangle thumb function symbols as we write them out. */
14488 elf32_arm_swap_symbol_out (bfd *abfd,
14489 const Elf_Internal_Sym *src,
14493 Elf_Internal_Sym newsym;
14495 /* We convert STT_ARM_TFUNC symbols into STT_FUNC with the low bit
14496 of the address set, as per the new EABI. We do this unconditionally
14497 because objcopy does not set the elf header flags until after
14498 it writes out the symbol table. */
14499 if (ELF_ST_TYPE (src->st_info) == STT_ARM_TFUNC)
14502 newsym.st_info = ELF_ST_INFO (ELF_ST_BIND (src->st_info), STT_FUNC);
14503 if (newsym.st_shndx != SHN_UNDEF)
14505 /* Do this only for defined symbols. At link type, the static
14506 linker will simulate the work of dynamic linker of resolving
14507 symbols and will carry over the thumbness of found symbols to
14508 the output symbol table. It's not clear how it happens, but
14509 the thumbness of undefined symbols can well be different at
14510 runtime, and writing '1' for them will be confusing for users
14511 and possibly for dynamic linker itself.
14513 newsym.st_value |= 1;
14518 bfd_elf32_swap_symbol_out (abfd, src, cdst, shndx);
14521 /* Add the PT_ARM_EXIDX program header. */
14524 elf32_arm_modify_segment_map (bfd *abfd,
14525 struct bfd_link_info *info ATTRIBUTE_UNUSED)
14527 struct elf_segment_map *m;
14530 sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
14531 if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
14533 /* If there is already a PT_ARM_EXIDX header, then we do not
14534 want to add another one. This situation arises when running
14535 "strip"; the input binary already has the header. */
14536 m = elf_tdata (abfd)->segment_map;
14537 while (m && m->p_type != PT_ARM_EXIDX)
14541 m = (struct elf_segment_map *)
14542 bfd_zalloc (abfd, sizeof (struct elf_segment_map));
14545 m->p_type = PT_ARM_EXIDX;
14547 m->sections[0] = sec;
14549 m->next = elf_tdata (abfd)->segment_map;
14550 elf_tdata (abfd)->segment_map = m;
14557 /* We may add a PT_ARM_EXIDX program header. */
14560 elf32_arm_additional_program_headers (bfd *abfd,
14561 struct bfd_link_info *info ATTRIBUTE_UNUSED)
14565 sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
14566 if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
14572 /* We have two function types: STT_FUNC and STT_ARM_TFUNC. */
14575 elf32_arm_is_function_type (unsigned int type)
14577 return (type == STT_FUNC) || (type == STT_ARM_TFUNC);
14580 /* We use this to override swap_symbol_in and swap_symbol_out. */
14581 const struct elf_size_info elf32_arm_size_info =
14583 sizeof (Elf32_External_Ehdr),
14584 sizeof (Elf32_External_Phdr),
14585 sizeof (Elf32_External_Shdr),
14586 sizeof (Elf32_External_Rel),
14587 sizeof (Elf32_External_Rela),
14588 sizeof (Elf32_External_Sym),
14589 sizeof (Elf32_External_Dyn),
14590 sizeof (Elf_External_Note),
14594 ELFCLASS32, EV_CURRENT,
14595 bfd_elf32_write_out_phdrs,
14596 bfd_elf32_write_shdrs_and_ehdr,
14597 bfd_elf32_checksum_contents,
14598 bfd_elf32_write_relocs,
14599 elf32_arm_swap_symbol_in,
14600 elf32_arm_swap_symbol_out,
14601 bfd_elf32_slurp_reloc_table,
14602 bfd_elf32_slurp_symbol_table,
14603 bfd_elf32_swap_dyn_in,
14604 bfd_elf32_swap_dyn_out,
14605 bfd_elf32_swap_reloc_in,
14606 bfd_elf32_swap_reloc_out,
14607 bfd_elf32_swap_reloca_in,
14608 bfd_elf32_swap_reloca_out
14611 #define ELF_ARCH bfd_arch_arm
14612 #define ELF_TARGET_ID ARM_ELF_DATA
14613 #define ELF_MACHINE_CODE EM_ARM
14614 #ifdef __QNXTARGET__
14615 #define ELF_MAXPAGESIZE 0x1000
14617 #define ELF_MAXPAGESIZE 0x8000
14619 #define ELF_MINPAGESIZE 0x1000
14620 #define ELF_COMMONPAGESIZE 0x1000
14622 #define bfd_elf32_mkobject elf32_arm_mkobject
14624 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
14625 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
14626 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
14627 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
14628 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
14629 #define bfd_elf32_bfd_link_hash_table_free elf32_arm_hash_table_free
14630 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
14631 #define bfd_elf32_bfd_reloc_name_lookup elf32_arm_reloc_name_lookup
14632 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
14633 #define bfd_elf32_find_inliner_info elf32_arm_find_inliner_info
14634 #define bfd_elf32_new_section_hook elf32_arm_new_section_hook
14635 #define bfd_elf32_bfd_is_target_special_symbol elf32_arm_is_target_special_symbol
14636 #define bfd_elf32_bfd_final_link elf32_arm_final_link
14638 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
14639 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
14640 #define elf_backend_gc_mark_extra_sections elf32_arm_gc_mark_extra_sections
14641 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
14642 #define elf_backend_check_relocs elf32_arm_check_relocs
14643 #define elf_backend_relocate_section elf32_arm_relocate_section
14644 #define elf_backend_write_section elf32_arm_write_section
14645 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
14646 #define elf_backend_create_dynamic_sections elf32_arm_create_dynamic_sections
14647 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
14648 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
14649 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
14650 #define elf_backend_always_size_sections elf32_arm_always_size_sections
14651 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
14652 #define elf_backend_post_process_headers elf32_arm_post_process_headers
14653 #define elf_backend_reloc_type_class elf32_arm_reloc_type_class
14654 #define elf_backend_object_p elf32_arm_object_p
14655 #define elf_backend_section_flags elf32_arm_section_flags
14656 #define elf_backend_fake_sections elf32_arm_fake_sections
14657 #define elf_backend_section_from_shdr elf32_arm_section_from_shdr
14658 #define elf_backend_final_write_processing elf32_arm_final_write_processing
14659 #define elf_backend_copy_indirect_symbol elf32_arm_copy_indirect_symbol
14660 #define elf_backend_symbol_processing elf32_arm_symbol_processing
14661 #define elf_backend_size_info elf32_arm_size_info
14662 #define elf_backend_modify_segment_map elf32_arm_modify_segment_map
14663 #define elf_backend_additional_program_headers elf32_arm_additional_program_headers
14664 #define elf_backend_output_arch_local_syms elf32_arm_output_arch_local_syms
14665 #define elf_backend_begin_write_processing elf32_arm_begin_write_processing
14666 #define elf_backend_is_function_type elf32_arm_is_function_type
14668 #define elf_backend_can_refcount 1
14669 #define elf_backend_can_gc_sections 1
14670 #define elf_backend_plt_readonly 1
14671 #define elf_backend_want_got_plt 1
14672 #define elf_backend_want_plt_sym 0
14673 #define elf_backend_may_use_rel_p 1
14674 #define elf_backend_may_use_rela_p 0
14675 #define elf_backend_default_use_rela_p 0
14677 #define elf_backend_got_header_size 12
14679 #undef elf_backend_obj_attrs_vendor
14680 #define elf_backend_obj_attrs_vendor "aeabi"
14681 #undef elf_backend_obj_attrs_section
14682 #define elf_backend_obj_attrs_section ".ARM.attributes"
14683 #undef elf_backend_obj_attrs_arg_type
14684 #define elf_backend_obj_attrs_arg_type elf32_arm_obj_attrs_arg_type
14685 #undef elf_backend_obj_attrs_section_type
14686 #define elf_backend_obj_attrs_section_type SHT_ARM_ATTRIBUTES
14687 #define elf_backend_obj_attrs_order elf32_arm_obj_attrs_order
14688 #define elf_backend_obj_attrs_handle_unknown elf32_arm_obj_attrs_handle_unknown
14690 #include "elf32-target.h"
14692 /* VxWorks Targets. */
14694 #undef TARGET_LITTLE_SYM
14695 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_vxworks_vec
14696 #undef TARGET_LITTLE_NAME
14697 #define TARGET_LITTLE_NAME "elf32-littlearm-vxworks"
14698 #undef TARGET_BIG_SYM
14699 #define TARGET_BIG_SYM bfd_elf32_bigarm_vxworks_vec
14700 #undef TARGET_BIG_NAME
14701 #define TARGET_BIG_NAME "elf32-bigarm-vxworks"
14703 /* Like elf32_arm_link_hash_table_create -- but overrides
14704 appropriately for VxWorks. */
14706 static struct bfd_link_hash_table *
14707 elf32_arm_vxworks_link_hash_table_create (bfd *abfd)
14709 struct bfd_link_hash_table *ret;
14711 ret = elf32_arm_link_hash_table_create (abfd);
14714 struct elf32_arm_link_hash_table *htab
14715 = (struct elf32_arm_link_hash_table *) ret;
14717 htab->vxworks_p = 1;
14723 elf32_arm_vxworks_final_write_processing (bfd *abfd, bfd_boolean linker)
14725 elf32_arm_final_write_processing (abfd, linker);
14726 elf_vxworks_final_write_processing (abfd, linker);
14730 #define elf32_bed elf32_arm_vxworks_bed
14732 #undef bfd_elf32_bfd_link_hash_table_create
14733 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_vxworks_link_hash_table_create
14734 #undef elf_backend_add_symbol_hook
14735 #define elf_backend_add_symbol_hook elf_vxworks_add_symbol_hook
14736 #undef elf_backend_final_write_processing
14737 #define elf_backend_final_write_processing elf32_arm_vxworks_final_write_processing
14738 #undef elf_backend_emit_relocs
14739 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
14741 #undef elf_backend_may_use_rel_p
14742 #define elf_backend_may_use_rel_p 0
14743 #undef elf_backend_may_use_rela_p
14744 #define elf_backend_may_use_rela_p 1
14745 #undef elf_backend_default_use_rela_p
14746 #define elf_backend_default_use_rela_p 1
14747 #undef elf_backend_want_plt_sym
14748 #define elf_backend_want_plt_sym 1
14749 #undef ELF_MAXPAGESIZE
14750 #define ELF_MAXPAGESIZE 0x1000
14752 #include "elf32-target.h"
14755 /* Merge backend specific data from an object file to the output
14756 object file when linking. */
14759 elf32_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
14761 flagword out_flags;
14763 bfd_boolean flags_compatible = TRUE;
14766 /* Check if we have the same endianess. */
14767 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
14770 if (! is_arm_elf (ibfd) || ! is_arm_elf (obfd))
14773 if (!elf32_arm_merge_eabi_attributes (ibfd, obfd))
14776 /* The input BFD must have had its flags initialised. */
14777 /* The following seems bogus to me -- The flags are initialized in
14778 the assembler but I don't think an elf_flags_init field is
14779 written into the object. */
14780 /* BFD_ASSERT (elf_flags_init (ibfd)); */
14782 in_flags = elf_elfheader (ibfd)->e_flags;
14783 out_flags = elf_elfheader (obfd)->e_flags;
14785 /* In theory there is no reason why we couldn't handle this. However
14786 in practice it isn't even close to working and there is no real
14787 reason to want it. */
14788 if (EF_ARM_EABI_VERSION (in_flags) >= EF_ARM_EABI_VER4
14789 && !(ibfd->flags & DYNAMIC)
14790 && (in_flags & EF_ARM_BE8))
14792 _bfd_error_handler (_("error: %B is already in final BE8 format"),
14797 if (!elf_flags_init (obfd))
14799 /* If the input is the default architecture and had the default
14800 flags then do not bother setting the flags for the output
14801 architecture, instead allow future merges to do this. If no
14802 future merges ever set these flags then they will retain their
14803 uninitialised values, which surprise surprise, correspond
14804 to the default values. */
14805 if (bfd_get_arch_info (ibfd)->the_default
14806 && elf_elfheader (ibfd)->e_flags == 0)
14809 elf_flags_init (obfd) = TRUE;
14810 elf_elfheader (obfd)->e_flags = in_flags;
14812 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
14813 && bfd_get_arch_info (obfd)->the_default)
14814 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
14819 /* Determine what should happen if the input ARM architecture
14820 does not match the output ARM architecture. */
14821 if (! bfd_arm_merge_machines (ibfd, obfd))
14824 /* Identical flags must be compatible. */
14825 if (in_flags == out_flags)
14828 /* Check to see if the input BFD actually contains any sections. If
14829 not, its flags may not have been initialised either, but it
14830 cannot actually cause any incompatiblity. Do not short-circuit
14831 dynamic objects; their section list may be emptied by
14832 elf_link_add_object_symbols.
14834 Also check to see if there are no code sections in the input.
14835 In this case there is no need to check for code specific flags.
14836 XXX - do we need to worry about floating-point format compatability
14837 in data sections ? */
14838 if (!(ibfd->flags & DYNAMIC))
14840 bfd_boolean null_input_bfd = TRUE;
14841 bfd_boolean only_data_sections = TRUE;
14843 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
14845 /* Ignore synthetic glue sections. */
14846 if (strcmp (sec->name, ".glue_7")
14847 && strcmp (sec->name, ".glue_7t"))
14849 if ((bfd_get_section_flags (ibfd, sec)
14850 & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
14851 == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
14852 only_data_sections = FALSE;
14854 null_input_bfd = FALSE;
14859 if (null_input_bfd || only_data_sections)
14863 /* Complain about various flag mismatches. */
14864 if (!elf32_arm_versions_compatible (EF_ARM_EABI_VERSION (in_flags),
14865 EF_ARM_EABI_VERSION (out_flags)))
14868 (_("error: Source object %B has EABI version %d, but target %B has EABI version %d"),
14870 (in_flags & EF_ARM_EABIMASK) >> 24,
14871 (out_flags & EF_ARM_EABIMASK) >> 24);
14875 /* Not sure what needs to be checked for EABI versions >= 1. */
14876 /* VxWorks libraries do not use these flags. */
14877 if (get_elf_backend_data (obfd) != &elf32_arm_vxworks_bed
14878 && get_elf_backend_data (ibfd) != &elf32_arm_vxworks_bed
14879 && EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
14881 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
14884 (_("error: %B is compiled for APCS-%d, whereas target %B uses APCS-%d"),
14886 in_flags & EF_ARM_APCS_26 ? 26 : 32,
14887 out_flags & EF_ARM_APCS_26 ? 26 : 32);
14888 flags_compatible = FALSE;
14891 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
14893 if (in_flags & EF_ARM_APCS_FLOAT)
14895 (_("error: %B passes floats in float registers, whereas %B passes them in integer registers"),
14899 (_("error: %B passes floats in integer registers, whereas %B passes them in float registers"),
14902 flags_compatible = FALSE;
14905 if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT))
14907 if (in_flags & EF_ARM_VFP_FLOAT)
14909 (_("error: %B uses VFP instructions, whereas %B does not"),
14913 (_("error: %B uses FPA instructions, whereas %B does not"),
14916 flags_compatible = FALSE;
14919 if ((in_flags & EF_ARM_MAVERICK_FLOAT) != (out_flags & EF_ARM_MAVERICK_FLOAT))
14921 if (in_flags & EF_ARM_MAVERICK_FLOAT)
14923 (_("error: %B uses Maverick instructions, whereas %B does not"),
14927 (_("error: %B does not use Maverick instructions, whereas %B does"),
14930 flags_compatible = FALSE;
14933 #ifdef EF_ARM_SOFT_FLOAT
14934 if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
14936 /* We can allow interworking between code that is VFP format
14937 layout, and uses either soft float or integer regs for
14938 passing floating point arguments and results. We already
14939 know that the APCS_FLOAT flags match; similarly for VFP
14941 if ((in_flags & EF_ARM_APCS_FLOAT) != 0
14942 || (in_flags & EF_ARM_VFP_FLOAT) == 0)
14944 if (in_flags & EF_ARM_SOFT_FLOAT)
14946 (_("error: %B uses software FP, whereas %B uses hardware FP"),
14950 (_("error: %B uses hardware FP, whereas %B uses software FP"),
14953 flags_compatible = FALSE;
14958 /* Interworking mismatch is only a warning. */
14959 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
14961 if (in_flags & EF_ARM_INTERWORK)
14964 (_("Warning: %B supports interworking, whereas %B does not"),
14970 (_("Warning: %B does not support interworking, whereas %B does"),
14976 return flags_compatible;
14980 /* Symbian OS Targets. */
14982 #undef TARGET_LITTLE_SYM
14983 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_symbian_vec
14984 #undef TARGET_LITTLE_NAME
14985 #define TARGET_LITTLE_NAME "elf32-littlearm-symbian"
14986 #undef TARGET_BIG_SYM
14987 #define TARGET_BIG_SYM bfd_elf32_bigarm_symbian_vec
14988 #undef TARGET_BIG_NAME
14989 #define TARGET_BIG_NAME "elf32-bigarm-symbian"
14991 /* Like elf32_arm_link_hash_table_create -- but overrides
14992 appropriately for Symbian OS. */
14994 static struct bfd_link_hash_table *
14995 elf32_arm_symbian_link_hash_table_create (bfd *abfd)
14997 struct bfd_link_hash_table *ret;
14999 ret = elf32_arm_link_hash_table_create (abfd);
15002 struct elf32_arm_link_hash_table *htab
15003 = (struct elf32_arm_link_hash_table *)ret;
15004 /* There is no PLT header for Symbian OS. */
15005 htab->plt_header_size = 0;
15006 /* The PLT entries are each one instruction and one word. */
15007 htab->plt_entry_size = 4 * ARRAY_SIZE (elf32_arm_symbian_plt_entry);
15008 htab->symbian_p = 1;
15009 /* Symbian uses armv5t or above, so use_blx is always true. */
15011 htab->root.is_relocatable_executable = 1;
15016 static const struct bfd_elf_special_section
15017 elf32_arm_symbian_special_sections[] =
15019 /* In a BPABI executable, the dynamic linking sections do not go in
15020 the loadable read-only segment. The post-linker may wish to
15021 refer to these sections, but they are not part of the final
15023 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC, 0 },
15024 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB, 0 },
15025 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM, 0 },
15026 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS, 0 },
15027 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH, 0 },
15028 /* These sections do not need to be writable as the SymbianOS
15029 postlinker will arrange things so that no dynamic relocation is
15031 { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY, SHF_ALLOC },
15032 { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY, SHF_ALLOC },
15033 { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY, SHF_ALLOC },
15034 { NULL, 0, 0, 0, 0 }
15038 elf32_arm_symbian_begin_write_processing (bfd *abfd,
15039 struct bfd_link_info *link_info)
15041 /* BPABI objects are never loaded directly by an OS kernel; they are
15042 processed by a postlinker first, into an OS-specific format. If
15043 the D_PAGED bit is set on the file, BFD will align segments on
15044 page boundaries, so that an OS can directly map the file. With
15045 BPABI objects, that just results in wasted space. In addition,
15046 because we clear the D_PAGED bit, map_sections_to_segments will
15047 recognize that the program headers should not be mapped into any
15048 loadable segment. */
15049 abfd->flags &= ~D_PAGED;
15050 elf32_arm_begin_write_processing (abfd, link_info);
15054 elf32_arm_symbian_modify_segment_map (bfd *abfd,
15055 struct bfd_link_info *info)
15057 struct elf_segment_map *m;
15060 /* BPABI shared libraries and executables should have a PT_DYNAMIC
15061 segment. However, because the .dynamic section is not marked
15062 with SEC_LOAD, the generic ELF code will not create such a
15064 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
15067 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
15068 if (m->p_type == PT_DYNAMIC)
15073 m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
15074 m->next = elf_tdata (abfd)->segment_map;
15075 elf_tdata (abfd)->segment_map = m;
15079 /* Also call the generic arm routine. */
15080 return elf32_arm_modify_segment_map (abfd, info);
15083 /* Return address for Ith PLT stub in section PLT, for relocation REL
15084 or (bfd_vma) -1 if it should not be included. */
15087 elf32_arm_symbian_plt_sym_val (bfd_vma i, const asection *plt,
15088 const arelent *rel ATTRIBUTE_UNUSED)
15090 return plt->vma + 4 * ARRAY_SIZE (elf32_arm_symbian_plt_entry) * i;
15095 #define elf32_bed elf32_arm_symbian_bed
15097 /* The dynamic sections are not allocated on SymbianOS; the postlinker
15098 will process them and then discard them. */
15099 #undef ELF_DYNAMIC_SEC_FLAGS
15100 #define ELF_DYNAMIC_SEC_FLAGS \
15101 (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED)
15103 #undef elf_backend_add_symbol_hook
15104 #undef elf_backend_emit_relocs
15106 #undef bfd_elf32_bfd_link_hash_table_create
15107 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_symbian_link_hash_table_create
15108 #undef elf_backend_special_sections
15109 #define elf_backend_special_sections elf32_arm_symbian_special_sections
15110 #undef elf_backend_begin_write_processing
15111 #define elf_backend_begin_write_processing elf32_arm_symbian_begin_write_processing
15112 #undef elf_backend_final_write_processing
15113 #define elf_backend_final_write_processing elf32_arm_final_write_processing
15115 #undef elf_backend_modify_segment_map
15116 #define elf_backend_modify_segment_map elf32_arm_symbian_modify_segment_map
15118 /* There is no .got section for BPABI objects, and hence no header. */
15119 #undef elf_backend_got_header_size
15120 #define elf_backend_got_header_size 0
15122 /* Similarly, there is no .got.plt section. */
15123 #undef elf_backend_want_got_plt
15124 #define elf_backend_want_got_plt 0
15126 #undef elf_backend_plt_sym_val
15127 #define elf_backend_plt_sym_val elf32_arm_symbian_plt_sym_val
15129 #undef elf_backend_may_use_rel_p
15130 #define elf_backend_may_use_rel_p 1
15131 #undef elf_backend_may_use_rela_p
15132 #define elf_backend_may_use_rela_p 0
15133 #undef elf_backend_default_use_rela_p
15134 #define elf_backend_default_use_rela_p 0
15135 #undef elf_backend_want_plt_sym
15136 #define elf_backend_want_plt_sym 0
15137 #undef ELF_MAXPAGESIZE
15138 #define ELF_MAXPAGESIZE 0x8000
15140 #include "elf32-target.h"