1 /* 32-bit ELF support for ARM
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
3 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 2 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, MA 02110-1301, USA. */
23 #include "libiberty.h"
26 #include "elf-vxworks.h"
30 #define NUM_ELEM(a) (sizeof (a) / (sizeof (a)[0]))
33 /* Return the relocation section associated with NAME. HTAB is the
34 bfd's elf32_arm_link_hash_entry. */
35 #define RELOC_SECTION(HTAB, NAME) \
36 ((HTAB)->use_rel ? ".rel" NAME : ".rela" NAME)
38 /* Return size of a relocation entry. HTAB is the bfd's
39 elf32_arm_link_hash_entry. */
40 #define RELOC_SIZE(HTAB) \
42 ? sizeof (Elf32_External_Rel) \
43 : sizeof (Elf32_External_Rela))
45 /* Return function to swap relocations in. HTAB is the bfd's
46 elf32_arm_link_hash_entry. */
47 #define SWAP_RELOC_IN(HTAB) \
49 ? bfd_elf32_swap_reloc_in \
50 : bfd_elf32_swap_reloca_in)
52 /* Return function to swap relocations out. HTAB is the bfd's
53 elf32_arm_link_hash_entry. */
54 #define SWAP_RELOC_OUT(HTAB) \
56 ? bfd_elf32_swap_reloc_out \
57 : bfd_elf32_swap_reloca_out)
59 #define elf_info_to_howto 0
60 #define elf_info_to_howto_rel elf32_arm_info_to_howto
62 #define ARM_ELF_ABI_VERSION 0
63 #define ARM_ELF_OS_ABI_VERSION ELFOSABI_ARM
65 static const struct elf_backend_data elf32_arm_vxworks_bed;
67 /* Note: code such as elf32_arm_reloc_type_lookup expect to use e.g.
68 R_ARM_PC24 as an index into this, and find the R_ARM_PC24 HOWTO
71 static reloc_howto_type elf32_arm_howto_table_1[] =
74 HOWTO (R_ARM_NONE, /* type */
76 0, /* size (0 = byte, 1 = short, 2 = long) */
78 FALSE, /* pc_relative */
80 complain_overflow_dont,/* complain_on_overflow */
81 bfd_elf_generic_reloc, /* special_function */
82 "R_ARM_NONE", /* name */
83 FALSE, /* partial_inplace */
86 FALSE), /* pcrel_offset */
88 HOWTO (R_ARM_PC24, /* type */
90 2, /* size (0 = byte, 1 = short, 2 = long) */
92 TRUE, /* pc_relative */
94 complain_overflow_signed,/* complain_on_overflow */
95 bfd_elf_generic_reloc, /* special_function */
96 "R_ARM_PC24", /* name */
97 FALSE, /* partial_inplace */
98 0x00ffffff, /* src_mask */
99 0x00ffffff, /* dst_mask */
100 TRUE), /* pcrel_offset */
102 /* 32 bit absolute */
103 HOWTO (R_ARM_ABS32, /* type */
105 2, /* size (0 = byte, 1 = short, 2 = long) */
107 FALSE, /* pc_relative */
109 complain_overflow_bitfield,/* complain_on_overflow */
110 bfd_elf_generic_reloc, /* special_function */
111 "R_ARM_ABS32", /* name */
112 FALSE, /* partial_inplace */
113 0xffffffff, /* src_mask */
114 0xffffffff, /* dst_mask */
115 FALSE), /* pcrel_offset */
117 /* standard 32bit pc-relative reloc */
118 HOWTO (R_ARM_REL32, /* type */
120 2, /* size (0 = byte, 1 = short, 2 = long) */
122 TRUE, /* pc_relative */
124 complain_overflow_bitfield,/* complain_on_overflow */
125 bfd_elf_generic_reloc, /* special_function */
126 "R_ARM_REL32", /* name */
127 FALSE, /* partial_inplace */
128 0xffffffff, /* src_mask */
129 0xffffffff, /* dst_mask */
130 TRUE), /* pcrel_offset */
132 /* 8 bit absolute - R_ARM_LDR_PC_G0 in AAELF */
133 HOWTO (R_ARM_LDR_PC_G0, /* type */
135 0, /* size (0 = byte, 1 = short, 2 = long) */
137 TRUE, /* pc_relative */
139 complain_overflow_dont,/* complain_on_overflow */
140 bfd_elf_generic_reloc, /* special_function */
141 "R_ARM_LDR_PC_G0", /* name */
142 FALSE, /* partial_inplace */
143 0xffffffff, /* src_mask */
144 0xffffffff, /* dst_mask */
145 TRUE), /* pcrel_offset */
147 /* 16 bit absolute */
148 HOWTO (R_ARM_ABS16, /* type */
150 1, /* size (0 = byte, 1 = short, 2 = long) */
152 FALSE, /* pc_relative */
154 complain_overflow_bitfield,/* complain_on_overflow */
155 bfd_elf_generic_reloc, /* special_function */
156 "R_ARM_ABS16", /* name */
157 FALSE, /* partial_inplace */
158 0x0000ffff, /* src_mask */
159 0x0000ffff, /* dst_mask */
160 FALSE), /* pcrel_offset */
162 /* 12 bit absolute */
163 HOWTO (R_ARM_ABS12, /* type */
165 2, /* size (0 = byte, 1 = short, 2 = long) */
167 FALSE, /* pc_relative */
169 complain_overflow_bitfield,/* complain_on_overflow */
170 bfd_elf_generic_reloc, /* special_function */
171 "R_ARM_ABS12", /* name */
172 FALSE, /* partial_inplace */
173 0x00000fff, /* src_mask */
174 0x00000fff, /* dst_mask */
175 FALSE), /* pcrel_offset */
177 HOWTO (R_ARM_THM_ABS5, /* type */
179 1, /* size (0 = byte, 1 = short, 2 = long) */
181 FALSE, /* pc_relative */
183 complain_overflow_bitfield,/* complain_on_overflow */
184 bfd_elf_generic_reloc, /* special_function */
185 "R_ARM_THM_ABS5", /* name */
186 FALSE, /* partial_inplace */
187 0x000007e0, /* src_mask */
188 0x000007e0, /* dst_mask */
189 FALSE), /* pcrel_offset */
192 HOWTO (R_ARM_ABS8, /* type */
194 0, /* size (0 = byte, 1 = short, 2 = long) */
196 FALSE, /* pc_relative */
198 complain_overflow_bitfield,/* complain_on_overflow */
199 bfd_elf_generic_reloc, /* special_function */
200 "R_ARM_ABS8", /* name */
201 FALSE, /* partial_inplace */
202 0x000000ff, /* src_mask */
203 0x000000ff, /* dst_mask */
204 FALSE), /* pcrel_offset */
206 HOWTO (R_ARM_SBREL32, /* type */
208 2, /* size (0 = byte, 1 = short, 2 = long) */
210 FALSE, /* pc_relative */
212 complain_overflow_dont,/* complain_on_overflow */
213 bfd_elf_generic_reloc, /* special_function */
214 "R_ARM_SBREL32", /* name */
215 FALSE, /* partial_inplace */
216 0xffffffff, /* src_mask */
217 0xffffffff, /* dst_mask */
218 FALSE), /* pcrel_offset */
220 HOWTO (R_ARM_THM_CALL, /* type */
222 2, /* size (0 = byte, 1 = short, 2 = long) */
224 TRUE, /* pc_relative */
226 complain_overflow_signed,/* complain_on_overflow */
227 bfd_elf_generic_reloc, /* special_function */
228 "R_ARM_THM_CALL", /* name */
229 FALSE, /* partial_inplace */
230 0x07ff07ff, /* src_mask */
231 0x07ff07ff, /* dst_mask */
232 TRUE), /* pcrel_offset */
234 HOWTO (R_ARM_THM_PC8, /* type */
236 1, /* size (0 = byte, 1 = short, 2 = long) */
238 TRUE, /* pc_relative */
240 complain_overflow_signed,/* complain_on_overflow */
241 bfd_elf_generic_reloc, /* special_function */
242 "R_ARM_THM_PC8", /* name */
243 FALSE, /* partial_inplace */
244 0x000000ff, /* src_mask */
245 0x000000ff, /* dst_mask */
246 TRUE), /* pcrel_offset */
248 HOWTO (R_ARM_BREL_ADJ, /* type */
250 1, /* size (0 = byte, 1 = short, 2 = long) */
252 FALSE, /* pc_relative */
254 complain_overflow_signed,/* complain_on_overflow */
255 bfd_elf_generic_reloc, /* special_function */
256 "R_ARM_BREL_ADJ", /* name */
257 FALSE, /* partial_inplace */
258 0xffffffff, /* src_mask */
259 0xffffffff, /* dst_mask */
260 FALSE), /* pcrel_offset */
262 HOWTO (R_ARM_SWI24, /* type */
264 0, /* size (0 = byte, 1 = short, 2 = long) */
266 FALSE, /* pc_relative */
268 complain_overflow_signed,/* complain_on_overflow */
269 bfd_elf_generic_reloc, /* special_function */
270 "R_ARM_SWI24", /* name */
271 FALSE, /* partial_inplace */
272 0x00000000, /* src_mask */
273 0x00000000, /* dst_mask */
274 FALSE), /* pcrel_offset */
276 HOWTO (R_ARM_THM_SWI8, /* type */
278 0, /* size (0 = byte, 1 = short, 2 = long) */
280 FALSE, /* pc_relative */
282 complain_overflow_signed,/* complain_on_overflow */
283 bfd_elf_generic_reloc, /* special_function */
284 "R_ARM_SWI8", /* name */
285 FALSE, /* partial_inplace */
286 0x00000000, /* src_mask */
287 0x00000000, /* dst_mask */
288 FALSE), /* pcrel_offset */
290 /* BLX instruction for the ARM. */
291 HOWTO (R_ARM_XPC25, /* type */
293 2, /* size (0 = byte, 1 = short, 2 = long) */
295 TRUE, /* pc_relative */
297 complain_overflow_signed,/* complain_on_overflow */
298 bfd_elf_generic_reloc, /* special_function */
299 "R_ARM_XPC25", /* name */
300 FALSE, /* partial_inplace */
301 0x00ffffff, /* src_mask */
302 0x00ffffff, /* dst_mask */
303 TRUE), /* pcrel_offset */
305 /* BLX instruction for the Thumb. */
306 HOWTO (R_ARM_THM_XPC22, /* type */
308 2, /* size (0 = byte, 1 = short, 2 = long) */
310 TRUE, /* pc_relative */
312 complain_overflow_signed,/* complain_on_overflow */
313 bfd_elf_generic_reloc, /* special_function */
314 "R_ARM_THM_XPC22", /* name */
315 FALSE, /* partial_inplace */
316 0x07ff07ff, /* src_mask */
317 0x07ff07ff, /* dst_mask */
318 TRUE), /* pcrel_offset */
320 /* Dynamic TLS relocations. */
322 HOWTO (R_ARM_TLS_DTPMOD32, /* type */
324 2, /* size (0 = byte, 1 = short, 2 = long) */
326 FALSE, /* pc_relative */
328 complain_overflow_bitfield,/* complain_on_overflow */
329 bfd_elf_generic_reloc, /* special_function */
330 "R_ARM_TLS_DTPMOD32", /* name */
331 TRUE, /* partial_inplace */
332 0xffffffff, /* src_mask */
333 0xffffffff, /* dst_mask */
334 FALSE), /* pcrel_offset */
336 HOWTO (R_ARM_TLS_DTPOFF32, /* type */
338 2, /* size (0 = byte, 1 = short, 2 = long) */
340 FALSE, /* pc_relative */
342 complain_overflow_bitfield,/* complain_on_overflow */
343 bfd_elf_generic_reloc, /* special_function */
344 "R_ARM_TLS_DTPOFF32", /* name */
345 TRUE, /* partial_inplace */
346 0xffffffff, /* src_mask */
347 0xffffffff, /* dst_mask */
348 FALSE), /* pcrel_offset */
350 HOWTO (R_ARM_TLS_TPOFF32, /* type */
352 2, /* size (0 = byte, 1 = short, 2 = long) */
354 FALSE, /* pc_relative */
356 complain_overflow_bitfield,/* complain_on_overflow */
357 bfd_elf_generic_reloc, /* special_function */
358 "R_ARM_TLS_TPOFF32", /* name */
359 TRUE, /* partial_inplace */
360 0xffffffff, /* src_mask */
361 0xffffffff, /* dst_mask */
362 FALSE), /* pcrel_offset */
364 /* Relocs used in ARM Linux */
366 HOWTO (R_ARM_COPY, /* type */
368 2, /* size (0 = byte, 1 = short, 2 = long) */
370 FALSE, /* pc_relative */
372 complain_overflow_bitfield,/* complain_on_overflow */
373 bfd_elf_generic_reloc, /* special_function */
374 "R_ARM_COPY", /* name */
375 TRUE, /* partial_inplace */
376 0xffffffff, /* src_mask */
377 0xffffffff, /* dst_mask */
378 FALSE), /* pcrel_offset */
380 HOWTO (R_ARM_GLOB_DAT, /* type */
382 2, /* size (0 = byte, 1 = short, 2 = long) */
384 FALSE, /* pc_relative */
386 complain_overflow_bitfield,/* complain_on_overflow */
387 bfd_elf_generic_reloc, /* special_function */
388 "R_ARM_GLOB_DAT", /* name */
389 TRUE, /* partial_inplace */
390 0xffffffff, /* src_mask */
391 0xffffffff, /* dst_mask */
392 FALSE), /* pcrel_offset */
394 HOWTO (R_ARM_JUMP_SLOT, /* type */
396 2, /* size (0 = byte, 1 = short, 2 = long) */
398 FALSE, /* pc_relative */
400 complain_overflow_bitfield,/* complain_on_overflow */
401 bfd_elf_generic_reloc, /* special_function */
402 "R_ARM_JUMP_SLOT", /* name */
403 TRUE, /* partial_inplace */
404 0xffffffff, /* src_mask */
405 0xffffffff, /* dst_mask */
406 FALSE), /* pcrel_offset */
408 HOWTO (R_ARM_RELATIVE, /* type */
410 2, /* size (0 = byte, 1 = short, 2 = long) */
412 FALSE, /* pc_relative */
414 complain_overflow_bitfield,/* complain_on_overflow */
415 bfd_elf_generic_reloc, /* special_function */
416 "R_ARM_RELATIVE", /* name */
417 TRUE, /* partial_inplace */
418 0xffffffff, /* src_mask */
419 0xffffffff, /* dst_mask */
420 FALSE), /* pcrel_offset */
422 HOWTO (R_ARM_GOTOFF32, /* type */
424 2, /* size (0 = byte, 1 = short, 2 = long) */
426 FALSE, /* pc_relative */
428 complain_overflow_bitfield,/* complain_on_overflow */
429 bfd_elf_generic_reloc, /* special_function */
430 "R_ARM_GOTOFF32", /* name */
431 TRUE, /* partial_inplace */
432 0xffffffff, /* src_mask */
433 0xffffffff, /* dst_mask */
434 FALSE), /* pcrel_offset */
436 HOWTO (R_ARM_GOTPC, /* type */
438 2, /* size (0 = byte, 1 = short, 2 = long) */
440 TRUE, /* pc_relative */
442 complain_overflow_bitfield,/* complain_on_overflow */
443 bfd_elf_generic_reloc, /* special_function */
444 "R_ARM_GOTPC", /* name */
445 TRUE, /* partial_inplace */
446 0xffffffff, /* src_mask */
447 0xffffffff, /* dst_mask */
448 TRUE), /* pcrel_offset */
450 HOWTO (R_ARM_GOT32, /* type */
452 2, /* size (0 = byte, 1 = short, 2 = long) */
454 FALSE, /* pc_relative */
456 complain_overflow_bitfield,/* complain_on_overflow */
457 bfd_elf_generic_reloc, /* special_function */
458 "R_ARM_GOT32", /* name */
459 TRUE, /* partial_inplace */
460 0xffffffff, /* src_mask */
461 0xffffffff, /* dst_mask */
462 FALSE), /* pcrel_offset */
464 HOWTO (R_ARM_PLT32, /* type */
466 2, /* size (0 = byte, 1 = short, 2 = long) */
468 TRUE, /* pc_relative */
470 complain_overflow_bitfield,/* complain_on_overflow */
471 bfd_elf_generic_reloc, /* special_function */
472 "R_ARM_PLT32", /* name */
473 FALSE, /* partial_inplace */
474 0x00ffffff, /* src_mask */
475 0x00ffffff, /* dst_mask */
476 TRUE), /* pcrel_offset */
478 HOWTO (R_ARM_CALL, /* type */
480 2, /* size (0 = byte, 1 = short, 2 = long) */
482 TRUE, /* pc_relative */
484 complain_overflow_signed,/* complain_on_overflow */
485 bfd_elf_generic_reloc, /* special_function */
486 "R_ARM_CALL", /* name */
487 FALSE, /* partial_inplace */
488 0x00ffffff, /* src_mask */
489 0x00ffffff, /* dst_mask */
490 TRUE), /* pcrel_offset */
492 HOWTO (R_ARM_JUMP24, /* type */
494 2, /* size (0 = byte, 1 = short, 2 = long) */
496 TRUE, /* pc_relative */
498 complain_overflow_signed,/* complain_on_overflow */
499 bfd_elf_generic_reloc, /* special_function */
500 "R_ARM_JUMP24", /* name */
501 FALSE, /* partial_inplace */
502 0x00ffffff, /* src_mask */
503 0x00ffffff, /* dst_mask */
504 TRUE), /* pcrel_offset */
506 HOWTO (R_ARM_THM_JUMP24, /* type */
508 2, /* size (0 = byte, 1 = short, 2 = long) */
510 TRUE, /* pc_relative */
512 complain_overflow_signed,/* complain_on_overflow */
513 bfd_elf_generic_reloc, /* special_function */
514 "R_ARM_THM_JUMP24", /* name */
515 FALSE, /* partial_inplace */
516 0x07ff2fff, /* src_mask */
517 0x07ff2fff, /* dst_mask */
518 TRUE), /* pcrel_offset */
520 HOWTO (R_ARM_BASE_ABS, /* type */
522 2, /* size (0 = byte, 1 = short, 2 = long) */
524 FALSE, /* pc_relative */
526 complain_overflow_dont,/* complain_on_overflow */
527 bfd_elf_generic_reloc, /* special_function */
528 "R_ARM_BASE_ABS", /* name */
529 FALSE, /* partial_inplace */
530 0xffffffff, /* src_mask */
531 0xffffffff, /* dst_mask */
532 FALSE), /* pcrel_offset */
534 HOWTO (R_ARM_ALU_PCREL7_0, /* type */
536 2, /* size (0 = byte, 1 = short, 2 = long) */
538 TRUE, /* pc_relative */
540 complain_overflow_dont,/* complain_on_overflow */
541 bfd_elf_generic_reloc, /* special_function */
542 "R_ARM_ALU_PCREL_7_0", /* name */
543 FALSE, /* partial_inplace */
544 0x00000fff, /* src_mask */
545 0x00000fff, /* dst_mask */
546 TRUE), /* pcrel_offset */
548 HOWTO (R_ARM_ALU_PCREL15_8, /* type */
550 2, /* size (0 = byte, 1 = short, 2 = long) */
552 TRUE, /* pc_relative */
554 complain_overflow_dont,/* complain_on_overflow */
555 bfd_elf_generic_reloc, /* special_function */
556 "R_ARM_ALU_PCREL_15_8",/* name */
557 FALSE, /* partial_inplace */
558 0x00000fff, /* src_mask */
559 0x00000fff, /* dst_mask */
560 TRUE), /* pcrel_offset */
562 HOWTO (R_ARM_ALU_PCREL23_15, /* type */
564 2, /* size (0 = byte, 1 = short, 2 = long) */
566 TRUE, /* pc_relative */
568 complain_overflow_dont,/* complain_on_overflow */
569 bfd_elf_generic_reloc, /* special_function */
570 "R_ARM_ALU_PCREL_23_15",/* name */
571 FALSE, /* partial_inplace */
572 0x00000fff, /* src_mask */
573 0x00000fff, /* dst_mask */
574 TRUE), /* pcrel_offset */
576 HOWTO (R_ARM_LDR_SBREL_11_0, /* type */
578 2, /* size (0 = byte, 1 = short, 2 = long) */
580 FALSE, /* pc_relative */
582 complain_overflow_dont,/* complain_on_overflow */
583 bfd_elf_generic_reloc, /* special_function */
584 "R_ARM_LDR_SBREL_11_0",/* name */
585 FALSE, /* partial_inplace */
586 0x00000fff, /* src_mask */
587 0x00000fff, /* dst_mask */
588 FALSE), /* pcrel_offset */
590 HOWTO (R_ARM_ALU_SBREL_19_12, /* type */
592 2, /* size (0 = byte, 1 = short, 2 = long) */
594 FALSE, /* pc_relative */
596 complain_overflow_dont,/* complain_on_overflow */
597 bfd_elf_generic_reloc, /* special_function */
598 "R_ARM_ALU_SBREL_19_12",/* name */
599 FALSE, /* partial_inplace */
600 0x000ff000, /* src_mask */
601 0x000ff000, /* dst_mask */
602 FALSE), /* pcrel_offset */
604 HOWTO (R_ARM_ALU_SBREL_27_20, /* type */
606 2, /* size (0 = byte, 1 = short, 2 = long) */
608 FALSE, /* pc_relative */
610 complain_overflow_dont,/* complain_on_overflow */
611 bfd_elf_generic_reloc, /* special_function */
612 "R_ARM_ALU_SBREL_27_20",/* name */
613 FALSE, /* partial_inplace */
614 0x0ff00000, /* src_mask */
615 0x0ff00000, /* dst_mask */
616 FALSE), /* pcrel_offset */
618 HOWTO (R_ARM_TARGET1, /* type */
620 2, /* size (0 = byte, 1 = short, 2 = long) */
622 FALSE, /* pc_relative */
624 complain_overflow_dont,/* complain_on_overflow */
625 bfd_elf_generic_reloc, /* special_function */
626 "R_ARM_TARGET1", /* name */
627 FALSE, /* partial_inplace */
628 0xffffffff, /* src_mask */
629 0xffffffff, /* dst_mask */
630 FALSE), /* pcrel_offset */
632 HOWTO (R_ARM_ROSEGREL32, /* type */
634 2, /* size (0 = byte, 1 = short, 2 = long) */
636 FALSE, /* pc_relative */
638 complain_overflow_dont,/* complain_on_overflow */
639 bfd_elf_generic_reloc, /* special_function */
640 "R_ARM_ROSEGREL32", /* name */
641 FALSE, /* partial_inplace */
642 0xffffffff, /* src_mask */
643 0xffffffff, /* dst_mask */
644 FALSE), /* pcrel_offset */
646 HOWTO (R_ARM_V4BX, /* type */
648 2, /* size (0 = byte, 1 = short, 2 = long) */
650 FALSE, /* pc_relative */
652 complain_overflow_dont,/* complain_on_overflow */
653 bfd_elf_generic_reloc, /* special_function */
654 "R_ARM_V4BX", /* name */
655 FALSE, /* partial_inplace */
656 0xffffffff, /* src_mask */
657 0xffffffff, /* dst_mask */
658 FALSE), /* pcrel_offset */
660 HOWTO (R_ARM_TARGET2, /* type */
662 2, /* size (0 = byte, 1 = short, 2 = long) */
664 FALSE, /* pc_relative */
666 complain_overflow_signed,/* complain_on_overflow */
667 bfd_elf_generic_reloc, /* special_function */
668 "R_ARM_TARGET2", /* name */
669 FALSE, /* partial_inplace */
670 0xffffffff, /* src_mask */
671 0xffffffff, /* dst_mask */
672 TRUE), /* pcrel_offset */
674 HOWTO (R_ARM_PREL31, /* type */
676 2, /* size (0 = byte, 1 = short, 2 = long) */
678 TRUE, /* pc_relative */
680 complain_overflow_signed,/* complain_on_overflow */
681 bfd_elf_generic_reloc, /* special_function */
682 "R_ARM_PREL31", /* name */
683 FALSE, /* partial_inplace */
684 0x7fffffff, /* src_mask */
685 0x7fffffff, /* dst_mask */
686 TRUE), /* pcrel_offset */
688 HOWTO (R_ARM_MOVW_ABS_NC, /* type */
690 2, /* size (0 = byte, 1 = short, 2 = long) */
692 FALSE, /* pc_relative */
694 complain_overflow_dont,/* complain_on_overflow */
695 bfd_elf_generic_reloc, /* special_function */
696 "R_ARM_MOVW_ABS_NC", /* name */
697 FALSE, /* partial_inplace */
698 0x0000ffff, /* src_mask */
699 0x0000ffff, /* dst_mask */
700 FALSE), /* pcrel_offset */
702 HOWTO (R_ARM_MOVT_ABS, /* type */
704 2, /* size (0 = byte, 1 = short, 2 = long) */
706 FALSE, /* pc_relative */
708 complain_overflow_bitfield,/* complain_on_overflow */
709 bfd_elf_generic_reloc, /* special_function */
710 "R_ARM_MOVT_ABS", /* name */
711 FALSE, /* partial_inplace */
712 0x0000ffff, /* src_mask */
713 0x0000ffff, /* dst_mask */
714 FALSE), /* pcrel_offset */
716 HOWTO (R_ARM_MOVW_PREL_NC, /* type */
718 2, /* size (0 = byte, 1 = short, 2 = long) */
720 TRUE, /* pc_relative */
722 complain_overflow_dont,/* complain_on_overflow */
723 bfd_elf_generic_reloc, /* special_function */
724 "R_ARM_MOVW_PREL_NC", /* name */
725 FALSE, /* partial_inplace */
726 0x0000ffff, /* src_mask */
727 0x0000ffff, /* dst_mask */
728 TRUE), /* pcrel_offset */
730 HOWTO (R_ARM_MOVT_PREL, /* type */
732 2, /* size (0 = byte, 1 = short, 2 = long) */
734 TRUE, /* pc_relative */
736 complain_overflow_bitfield,/* complain_on_overflow */
737 bfd_elf_generic_reloc, /* special_function */
738 "R_ARM_MOVT_PREL", /* name */
739 FALSE, /* partial_inplace */
740 0x0000ffff, /* src_mask */
741 0x0000ffff, /* dst_mask */
742 TRUE), /* pcrel_offset */
744 HOWTO (R_ARM_THM_MOVW_ABS_NC, /* type */
746 2, /* size (0 = byte, 1 = short, 2 = long) */
748 FALSE, /* pc_relative */
750 complain_overflow_dont,/* complain_on_overflow */
751 bfd_elf_generic_reloc, /* special_function */
752 "R_ARM_THM_MOVW_ABS_NC",/* name */
753 FALSE, /* partial_inplace */
754 0x040f70ff, /* src_mask */
755 0x040f70ff, /* dst_mask */
756 FALSE), /* pcrel_offset */
758 HOWTO (R_ARM_THM_MOVT_ABS, /* type */
760 2, /* size (0 = byte, 1 = short, 2 = long) */
762 FALSE, /* pc_relative */
764 complain_overflow_bitfield,/* complain_on_overflow */
765 bfd_elf_generic_reloc, /* special_function */
766 "R_ARM_THM_MOVT_ABS", /* name */
767 FALSE, /* partial_inplace */
768 0x040f70ff, /* src_mask */
769 0x040f70ff, /* dst_mask */
770 FALSE), /* pcrel_offset */
772 HOWTO (R_ARM_THM_MOVW_PREL_NC,/* type */
774 2, /* size (0 = byte, 1 = short, 2 = long) */
776 TRUE, /* pc_relative */
778 complain_overflow_dont,/* complain_on_overflow */
779 bfd_elf_generic_reloc, /* special_function */
780 "R_ARM_THM_MOVW_PREL_NC",/* name */
781 FALSE, /* partial_inplace */
782 0x040f70ff, /* src_mask */
783 0x040f70ff, /* dst_mask */
784 TRUE), /* pcrel_offset */
786 HOWTO (R_ARM_THM_MOVT_PREL, /* type */
788 2, /* size (0 = byte, 1 = short, 2 = long) */
790 TRUE, /* pc_relative */
792 complain_overflow_bitfield,/* complain_on_overflow */
793 bfd_elf_generic_reloc, /* special_function */
794 "R_ARM_THM_MOVT_PREL", /* name */
795 FALSE, /* partial_inplace */
796 0x040f70ff, /* src_mask */
797 0x040f70ff, /* dst_mask */
798 TRUE), /* pcrel_offset */
800 HOWTO (R_ARM_THM_JUMP19, /* type */
802 2, /* size (0 = byte, 1 = short, 2 = long) */
804 TRUE, /* pc_relative */
806 complain_overflow_signed,/* complain_on_overflow */
807 bfd_elf_generic_reloc, /* special_function */
808 "R_ARM_THM_JUMP19", /* name */
809 FALSE, /* partial_inplace */
810 0x043f2fff, /* src_mask */
811 0x043f2fff, /* dst_mask */
812 TRUE), /* pcrel_offset */
814 HOWTO (R_ARM_THM_JUMP6, /* type */
816 1, /* size (0 = byte, 1 = short, 2 = long) */
818 TRUE, /* pc_relative */
820 complain_overflow_unsigned,/* complain_on_overflow */
821 bfd_elf_generic_reloc, /* special_function */
822 "R_ARM_THM_JUMP6", /* name */
823 FALSE, /* partial_inplace */
824 0x02f8, /* src_mask */
825 0x02f8, /* dst_mask */
826 TRUE), /* pcrel_offset */
828 /* These are declared as 13-bit signed relocations because we can
829 address -4095 .. 4095(base) by altering ADDW to SUBW or vice
831 HOWTO (R_ARM_THM_ALU_PREL_11_0,/* type */
833 2, /* size (0 = byte, 1 = short, 2 = long) */
835 TRUE, /* pc_relative */
837 complain_overflow_dont,/* complain_on_overflow */
838 bfd_elf_generic_reloc, /* special_function */
839 "R_ARM_THM_ALU_PREL_11_0",/* name */
840 FALSE, /* partial_inplace */
841 0xffffffff, /* src_mask */
842 0xffffffff, /* dst_mask */
843 TRUE), /* pcrel_offset */
845 HOWTO (R_ARM_THM_PC12, /* type */
847 2, /* size (0 = byte, 1 = short, 2 = long) */
849 TRUE, /* pc_relative */
851 complain_overflow_dont,/* complain_on_overflow */
852 bfd_elf_generic_reloc, /* special_function */
853 "R_ARM_THM_PC12", /* name */
854 FALSE, /* partial_inplace */
855 0xffffffff, /* src_mask */
856 0xffffffff, /* dst_mask */
857 TRUE), /* pcrel_offset */
859 HOWTO (R_ARM_ABS32_NOI, /* type */
861 2, /* size (0 = byte, 1 = short, 2 = long) */
863 FALSE, /* pc_relative */
865 complain_overflow_dont,/* complain_on_overflow */
866 bfd_elf_generic_reloc, /* special_function */
867 "R_ARM_ABS32_NOI", /* name */
868 FALSE, /* partial_inplace */
869 0xffffffff, /* src_mask */
870 0xffffffff, /* dst_mask */
871 FALSE), /* pcrel_offset */
873 HOWTO (R_ARM_REL32_NOI, /* type */
875 2, /* size (0 = byte, 1 = short, 2 = long) */
877 TRUE, /* pc_relative */
879 complain_overflow_dont,/* complain_on_overflow */
880 bfd_elf_generic_reloc, /* special_function */
881 "R_ARM_REL32_NOI", /* name */
882 FALSE, /* partial_inplace */
883 0xffffffff, /* src_mask */
884 0xffffffff, /* dst_mask */
885 FALSE), /* pcrel_offset */
887 /* Group relocations. */
889 HOWTO (R_ARM_ALU_PC_G0_NC, /* type */
891 2, /* size (0 = byte, 1 = short, 2 = long) */
893 TRUE, /* pc_relative */
895 complain_overflow_dont,/* complain_on_overflow */
896 bfd_elf_generic_reloc, /* special_function */
897 "R_ARM_ALU_PC_G0_NC", /* name */
898 FALSE, /* partial_inplace */
899 0xffffffff, /* src_mask */
900 0xffffffff, /* dst_mask */
901 TRUE), /* pcrel_offset */
903 HOWTO (R_ARM_ALU_PC_G0, /* type */
905 2, /* size (0 = byte, 1 = short, 2 = long) */
907 TRUE, /* pc_relative */
909 complain_overflow_dont,/* complain_on_overflow */
910 bfd_elf_generic_reloc, /* special_function */
911 "R_ARM_ALU_PC_G0", /* name */
912 FALSE, /* partial_inplace */
913 0xffffffff, /* src_mask */
914 0xffffffff, /* dst_mask */
915 TRUE), /* pcrel_offset */
917 HOWTO (R_ARM_ALU_PC_G1_NC, /* type */
919 2, /* size (0 = byte, 1 = short, 2 = long) */
921 TRUE, /* pc_relative */
923 complain_overflow_dont,/* complain_on_overflow */
924 bfd_elf_generic_reloc, /* special_function */
925 "R_ARM_ALU_PC_G1_NC", /* name */
926 FALSE, /* partial_inplace */
927 0xffffffff, /* src_mask */
928 0xffffffff, /* dst_mask */
929 TRUE), /* pcrel_offset */
931 HOWTO (R_ARM_ALU_PC_G1, /* type */
933 2, /* size (0 = byte, 1 = short, 2 = long) */
935 TRUE, /* pc_relative */
937 complain_overflow_dont,/* complain_on_overflow */
938 bfd_elf_generic_reloc, /* special_function */
939 "R_ARM_ALU_PC_G1", /* name */
940 FALSE, /* partial_inplace */
941 0xffffffff, /* src_mask */
942 0xffffffff, /* dst_mask */
943 TRUE), /* pcrel_offset */
945 HOWTO (R_ARM_ALU_PC_G2, /* type */
947 2, /* size (0 = byte, 1 = short, 2 = long) */
949 TRUE, /* pc_relative */
951 complain_overflow_dont,/* complain_on_overflow */
952 bfd_elf_generic_reloc, /* special_function */
953 "R_ARM_ALU_PC_G2", /* name */
954 FALSE, /* partial_inplace */
955 0xffffffff, /* src_mask */
956 0xffffffff, /* dst_mask */
957 TRUE), /* pcrel_offset */
959 HOWTO (R_ARM_LDR_PC_G1, /* type */
961 2, /* size (0 = byte, 1 = short, 2 = long) */
963 TRUE, /* pc_relative */
965 complain_overflow_dont,/* complain_on_overflow */
966 bfd_elf_generic_reloc, /* special_function */
967 "R_ARM_LDR_PC_G1", /* name */
968 FALSE, /* partial_inplace */
969 0xffffffff, /* src_mask */
970 0xffffffff, /* dst_mask */
971 TRUE), /* pcrel_offset */
973 HOWTO (R_ARM_LDR_PC_G2, /* type */
975 2, /* size (0 = byte, 1 = short, 2 = long) */
977 TRUE, /* pc_relative */
979 complain_overflow_dont,/* complain_on_overflow */
980 bfd_elf_generic_reloc, /* special_function */
981 "R_ARM_LDR_PC_G2", /* name */
982 FALSE, /* partial_inplace */
983 0xffffffff, /* src_mask */
984 0xffffffff, /* dst_mask */
985 TRUE), /* pcrel_offset */
987 HOWTO (R_ARM_LDRS_PC_G0, /* type */
989 2, /* size (0 = byte, 1 = short, 2 = long) */
991 TRUE, /* pc_relative */
993 complain_overflow_dont,/* complain_on_overflow */
994 bfd_elf_generic_reloc, /* special_function */
995 "R_ARM_LDRS_PC_G0", /* name */
996 FALSE, /* partial_inplace */
997 0xffffffff, /* src_mask */
998 0xffffffff, /* dst_mask */
999 TRUE), /* pcrel_offset */
1001 HOWTO (R_ARM_LDRS_PC_G1, /* type */
1003 2, /* size (0 = byte, 1 = short, 2 = long) */
1005 TRUE, /* pc_relative */
1007 complain_overflow_dont,/* complain_on_overflow */
1008 bfd_elf_generic_reloc, /* special_function */
1009 "R_ARM_LDRS_PC_G1", /* name */
1010 FALSE, /* partial_inplace */
1011 0xffffffff, /* src_mask */
1012 0xffffffff, /* dst_mask */
1013 TRUE), /* pcrel_offset */
1015 HOWTO (R_ARM_LDRS_PC_G2, /* type */
1017 2, /* size (0 = byte, 1 = short, 2 = long) */
1019 TRUE, /* pc_relative */
1021 complain_overflow_dont,/* complain_on_overflow */
1022 bfd_elf_generic_reloc, /* special_function */
1023 "R_ARM_LDRS_PC_G2", /* name */
1024 FALSE, /* partial_inplace */
1025 0xffffffff, /* src_mask */
1026 0xffffffff, /* dst_mask */
1027 TRUE), /* pcrel_offset */
1029 HOWTO (R_ARM_LDC_PC_G0, /* type */
1031 2, /* size (0 = byte, 1 = short, 2 = long) */
1033 TRUE, /* pc_relative */
1035 complain_overflow_dont,/* complain_on_overflow */
1036 bfd_elf_generic_reloc, /* special_function */
1037 "R_ARM_LDC_PC_G0", /* name */
1038 FALSE, /* partial_inplace */
1039 0xffffffff, /* src_mask */
1040 0xffffffff, /* dst_mask */
1041 TRUE), /* pcrel_offset */
1043 HOWTO (R_ARM_LDC_PC_G1, /* type */
1045 2, /* size (0 = byte, 1 = short, 2 = long) */
1047 TRUE, /* pc_relative */
1049 complain_overflow_dont,/* complain_on_overflow */
1050 bfd_elf_generic_reloc, /* special_function */
1051 "R_ARM_LDC_PC_G1", /* name */
1052 FALSE, /* partial_inplace */
1053 0xffffffff, /* src_mask */
1054 0xffffffff, /* dst_mask */
1055 TRUE), /* pcrel_offset */
1057 HOWTO (R_ARM_LDC_PC_G2, /* type */
1059 2, /* size (0 = byte, 1 = short, 2 = long) */
1061 TRUE, /* pc_relative */
1063 complain_overflow_dont,/* complain_on_overflow */
1064 bfd_elf_generic_reloc, /* special_function */
1065 "R_ARM_LDC_PC_G2", /* name */
1066 FALSE, /* partial_inplace */
1067 0xffffffff, /* src_mask */
1068 0xffffffff, /* dst_mask */
1069 TRUE), /* pcrel_offset */
1071 HOWTO (R_ARM_ALU_SB_G0_NC, /* type */
1073 2, /* size (0 = byte, 1 = short, 2 = long) */
1075 TRUE, /* pc_relative */
1077 complain_overflow_dont,/* complain_on_overflow */
1078 bfd_elf_generic_reloc, /* special_function */
1079 "R_ARM_ALU_SB_G0_NC", /* name */
1080 FALSE, /* partial_inplace */
1081 0xffffffff, /* src_mask */
1082 0xffffffff, /* dst_mask */
1083 TRUE), /* pcrel_offset */
1085 HOWTO (R_ARM_ALU_SB_G0, /* type */
1087 2, /* size (0 = byte, 1 = short, 2 = long) */
1089 TRUE, /* pc_relative */
1091 complain_overflow_dont,/* complain_on_overflow */
1092 bfd_elf_generic_reloc, /* special_function */
1093 "R_ARM_ALU_SB_G0", /* name */
1094 FALSE, /* partial_inplace */
1095 0xffffffff, /* src_mask */
1096 0xffffffff, /* dst_mask */
1097 TRUE), /* pcrel_offset */
1099 HOWTO (R_ARM_ALU_SB_G1_NC, /* type */
1101 2, /* size (0 = byte, 1 = short, 2 = long) */
1103 TRUE, /* pc_relative */
1105 complain_overflow_dont,/* complain_on_overflow */
1106 bfd_elf_generic_reloc, /* special_function */
1107 "R_ARM_ALU_SB_G1_NC", /* name */
1108 FALSE, /* partial_inplace */
1109 0xffffffff, /* src_mask */
1110 0xffffffff, /* dst_mask */
1111 TRUE), /* pcrel_offset */
1113 HOWTO (R_ARM_ALU_SB_G1, /* type */
1115 2, /* size (0 = byte, 1 = short, 2 = long) */
1117 TRUE, /* pc_relative */
1119 complain_overflow_dont,/* complain_on_overflow */
1120 bfd_elf_generic_reloc, /* special_function */
1121 "R_ARM_ALU_SB_G1", /* name */
1122 FALSE, /* partial_inplace */
1123 0xffffffff, /* src_mask */
1124 0xffffffff, /* dst_mask */
1125 TRUE), /* pcrel_offset */
1127 HOWTO (R_ARM_ALU_SB_G2, /* type */
1129 2, /* size (0 = byte, 1 = short, 2 = long) */
1131 TRUE, /* pc_relative */
1133 complain_overflow_dont,/* complain_on_overflow */
1134 bfd_elf_generic_reloc, /* special_function */
1135 "R_ARM_ALU_SB_G2", /* name */
1136 FALSE, /* partial_inplace */
1137 0xffffffff, /* src_mask */
1138 0xffffffff, /* dst_mask */
1139 TRUE), /* pcrel_offset */
1141 HOWTO (R_ARM_LDR_SB_G0, /* type */
1143 2, /* size (0 = byte, 1 = short, 2 = long) */
1145 TRUE, /* pc_relative */
1147 complain_overflow_dont,/* complain_on_overflow */
1148 bfd_elf_generic_reloc, /* special_function */
1149 "R_ARM_LDR_SB_G0", /* name */
1150 FALSE, /* partial_inplace */
1151 0xffffffff, /* src_mask */
1152 0xffffffff, /* dst_mask */
1153 TRUE), /* pcrel_offset */
1155 HOWTO (R_ARM_LDR_SB_G1, /* type */
1157 2, /* size (0 = byte, 1 = short, 2 = long) */
1159 TRUE, /* pc_relative */
1161 complain_overflow_dont,/* complain_on_overflow */
1162 bfd_elf_generic_reloc, /* special_function */
1163 "R_ARM_LDR_SB_G1", /* name */
1164 FALSE, /* partial_inplace */
1165 0xffffffff, /* src_mask */
1166 0xffffffff, /* dst_mask */
1167 TRUE), /* pcrel_offset */
1169 HOWTO (R_ARM_LDR_SB_G2, /* type */
1171 2, /* size (0 = byte, 1 = short, 2 = long) */
1173 TRUE, /* pc_relative */
1175 complain_overflow_dont,/* complain_on_overflow */
1176 bfd_elf_generic_reloc, /* special_function */
1177 "R_ARM_LDR_SB_G2", /* name */
1178 FALSE, /* partial_inplace */
1179 0xffffffff, /* src_mask */
1180 0xffffffff, /* dst_mask */
1181 TRUE), /* pcrel_offset */
1183 HOWTO (R_ARM_LDRS_SB_G0, /* type */
1185 2, /* size (0 = byte, 1 = short, 2 = long) */
1187 TRUE, /* pc_relative */
1189 complain_overflow_dont,/* complain_on_overflow */
1190 bfd_elf_generic_reloc, /* special_function */
1191 "R_ARM_LDRS_SB_G0", /* name */
1192 FALSE, /* partial_inplace */
1193 0xffffffff, /* src_mask */
1194 0xffffffff, /* dst_mask */
1195 TRUE), /* pcrel_offset */
1197 HOWTO (R_ARM_LDRS_SB_G1, /* type */
1199 2, /* size (0 = byte, 1 = short, 2 = long) */
1201 TRUE, /* pc_relative */
1203 complain_overflow_dont,/* complain_on_overflow */
1204 bfd_elf_generic_reloc, /* special_function */
1205 "R_ARM_LDRS_SB_G1", /* name */
1206 FALSE, /* partial_inplace */
1207 0xffffffff, /* src_mask */
1208 0xffffffff, /* dst_mask */
1209 TRUE), /* pcrel_offset */
1211 HOWTO (R_ARM_LDRS_SB_G2, /* type */
1213 2, /* size (0 = byte, 1 = short, 2 = long) */
1215 TRUE, /* pc_relative */
1217 complain_overflow_dont,/* complain_on_overflow */
1218 bfd_elf_generic_reloc, /* special_function */
1219 "R_ARM_LDRS_SB_G2", /* name */
1220 FALSE, /* partial_inplace */
1221 0xffffffff, /* src_mask */
1222 0xffffffff, /* dst_mask */
1223 TRUE), /* pcrel_offset */
1225 HOWTO (R_ARM_LDC_SB_G0, /* type */
1227 2, /* size (0 = byte, 1 = short, 2 = long) */
1229 TRUE, /* pc_relative */
1231 complain_overflow_dont,/* complain_on_overflow */
1232 bfd_elf_generic_reloc, /* special_function */
1233 "R_ARM_LDC_SB_G0", /* name */
1234 FALSE, /* partial_inplace */
1235 0xffffffff, /* src_mask */
1236 0xffffffff, /* dst_mask */
1237 TRUE), /* pcrel_offset */
1239 HOWTO (R_ARM_LDC_SB_G1, /* type */
1241 2, /* size (0 = byte, 1 = short, 2 = long) */
1243 TRUE, /* pc_relative */
1245 complain_overflow_dont,/* complain_on_overflow */
1246 bfd_elf_generic_reloc, /* special_function */
1247 "R_ARM_LDC_SB_G1", /* name */
1248 FALSE, /* partial_inplace */
1249 0xffffffff, /* src_mask */
1250 0xffffffff, /* dst_mask */
1251 TRUE), /* pcrel_offset */
1253 HOWTO (R_ARM_LDC_SB_G2, /* type */
1255 2, /* size (0 = byte, 1 = short, 2 = long) */
1257 TRUE, /* pc_relative */
1259 complain_overflow_dont,/* complain_on_overflow */
1260 bfd_elf_generic_reloc, /* special_function */
1261 "R_ARM_LDC_SB_G2", /* name */
1262 FALSE, /* partial_inplace */
1263 0xffffffff, /* src_mask */
1264 0xffffffff, /* dst_mask */
1265 TRUE), /* pcrel_offset */
1267 /* End of group relocations. */
1269 HOWTO (R_ARM_MOVW_BREL_NC, /* type */
1271 2, /* size (0 = byte, 1 = short, 2 = long) */
1273 FALSE, /* pc_relative */
1275 complain_overflow_dont,/* complain_on_overflow */
1276 bfd_elf_generic_reloc, /* special_function */
1277 "R_ARM_MOVW_BREL_NC", /* name */
1278 FALSE, /* partial_inplace */
1279 0x0000ffff, /* src_mask */
1280 0x0000ffff, /* dst_mask */
1281 FALSE), /* pcrel_offset */
1283 HOWTO (R_ARM_MOVT_BREL, /* type */
1285 2, /* size (0 = byte, 1 = short, 2 = long) */
1287 FALSE, /* pc_relative */
1289 complain_overflow_bitfield,/* complain_on_overflow */
1290 bfd_elf_generic_reloc, /* special_function */
1291 "R_ARM_MOVT_BREL", /* name */
1292 FALSE, /* partial_inplace */
1293 0x0000ffff, /* src_mask */
1294 0x0000ffff, /* dst_mask */
1295 FALSE), /* pcrel_offset */
1297 HOWTO (R_ARM_MOVW_BREL, /* type */
1299 2, /* size (0 = byte, 1 = short, 2 = long) */
1301 FALSE, /* pc_relative */
1303 complain_overflow_dont,/* complain_on_overflow */
1304 bfd_elf_generic_reloc, /* special_function */
1305 "R_ARM_MOVW_BREL", /* name */
1306 FALSE, /* partial_inplace */
1307 0x0000ffff, /* src_mask */
1308 0x0000ffff, /* dst_mask */
1309 FALSE), /* pcrel_offset */
1311 HOWTO (R_ARM_THM_MOVW_BREL_NC,/* type */
1313 2, /* size (0 = byte, 1 = short, 2 = long) */
1315 FALSE, /* pc_relative */
1317 complain_overflow_dont,/* complain_on_overflow */
1318 bfd_elf_generic_reloc, /* special_function */
1319 "R_ARM_THM_MOVW_BREL_NC",/* name */
1320 FALSE, /* partial_inplace */
1321 0x040f70ff, /* src_mask */
1322 0x040f70ff, /* dst_mask */
1323 FALSE), /* pcrel_offset */
1325 HOWTO (R_ARM_THM_MOVT_BREL, /* type */
1327 2, /* size (0 = byte, 1 = short, 2 = long) */
1329 FALSE, /* pc_relative */
1331 complain_overflow_bitfield,/* complain_on_overflow */
1332 bfd_elf_generic_reloc, /* special_function */
1333 "R_ARM_THM_MOVT_BREL", /* name */
1334 FALSE, /* partial_inplace */
1335 0x040f70ff, /* src_mask */
1336 0x040f70ff, /* dst_mask */
1337 FALSE), /* pcrel_offset */
1339 HOWTO (R_ARM_THM_MOVW_BREL, /* type */
1341 2, /* size (0 = byte, 1 = short, 2 = long) */
1343 FALSE, /* pc_relative */
1345 complain_overflow_dont,/* complain_on_overflow */
1346 bfd_elf_generic_reloc, /* special_function */
1347 "R_ARM_THM_MOVW_BREL", /* name */
1348 FALSE, /* partial_inplace */
1349 0x040f70ff, /* src_mask */
1350 0x040f70ff, /* dst_mask */
1351 FALSE), /* pcrel_offset */
1353 EMPTY_HOWTO (90), /* unallocated */
1358 HOWTO (R_ARM_PLT32_ABS, /* type */
1360 2, /* size (0 = byte, 1 = short, 2 = long) */
1362 FALSE, /* pc_relative */
1364 complain_overflow_dont,/* complain_on_overflow */
1365 bfd_elf_generic_reloc, /* special_function */
1366 "R_ARM_PLT32_ABS", /* name */
1367 FALSE, /* partial_inplace */
1368 0xffffffff, /* src_mask */
1369 0xffffffff, /* dst_mask */
1370 FALSE), /* pcrel_offset */
1372 HOWTO (R_ARM_GOT_ABS, /* type */
1374 2, /* size (0 = byte, 1 = short, 2 = long) */
1376 FALSE, /* pc_relative */
1378 complain_overflow_dont,/* complain_on_overflow */
1379 bfd_elf_generic_reloc, /* special_function */
1380 "R_ARM_GOT_ABS", /* name */
1381 FALSE, /* partial_inplace */
1382 0xffffffff, /* src_mask */
1383 0xffffffff, /* dst_mask */
1384 FALSE), /* pcrel_offset */
1386 HOWTO (R_ARM_GOT_PREL, /* type */
1388 2, /* size (0 = byte, 1 = short, 2 = long) */
1390 TRUE, /* pc_relative */
1392 complain_overflow_dont, /* complain_on_overflow */
1393 bfd_elf_generic_reloc, /* special_function */
1394 "R_ARM_GOT_PREL", /* name */
1395 FALSE, /* partial_inplace */
1396 0xffffffff, /* src_mask */
1397 0xffffffff, /* dst_mask */
1398 TRUE), /* pcrel_offset */
1400 HOWTO (R_ARM_GOT_BREL12, /* type */
1402 2, /* size (0 = byte, 1 = short, 2 = long) */
1404 FALSE, /* pc_relative */
1406 complain_overflow_bitfield,/* complain_on_overflow */
1407 bfd_elf_generic_reloc, /* special_function */
1408 "R_ARM_GOT_BREL12", /* name */
1409 FALSE, /* partial_inplace */
1410 0x00000fff, /* src_mask */
1411 0x00000fff, /* dst_mask */
1412 FALSE), /* pcrel_offset */
1414 HOWTO (R_ARM_GOTOFF12, /* type */
1416 2, /* size (0 = byte, 1 = short, 2 = long) */
1418 FALSE, /* pc_relative */
1420 complain_overflow_bitfield,/* complain_on_overflow */
1421 bfd_elf_generic_reloc, /* special_function */
1422 "R_ARM_GOTOFF12", /* name */
1423 FALSE, /* partial_inplace */
1424 0x00000fff, /* src_mask */
1425 0x00000fff, /* dst_mask */
1426 FALSE), /* pcrel_offset */
1428 EMPTY_HOWTO (R_ARM_GOTRELAX), /* reserved for future GOT-load optimizations */
1430 /* GNU extension to record C++ vtable member usage */
1431 HOWTO (R_ARM_GNU_VTENTRY, /* type */
1433 2, /* size (0 = byte, 1 = short, 2 = long) */
1435 FALSE, /* pc_relative */
1437 complain_overflow_dont, /* complain_on_overflow */
1438 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
1439 "R_ARM_GNU_VTENTRY", /* name */
1440 FALSE, /* partial_inplace */
1443 FALSE), /* pcrel_offset */
1445 /* GNU extension to record C++ vtable hierarchy */
1446 HOWTO (R_ARM_GNU_VTINHERIT, /* type */
1448 2, /* size (0 = byte, 1 = short, 2 = long) */
1450 FALSE, /* pc_relative */
1452 complain_overflow_dont, /* complain_on_overflow */
1453 NULL, /* special_function */
1454 "R_ARM_GNU_VTINHERIT", /* name */
1455 FALSE, /* partial_inplace */
1458 FALSE), /* pcrel_offset */
1460 HOWTO (R_ARM_THM_JUMP11, /* type */
1462 1, /* size (0 = byte, 1 = short, 2 = long) */
1464 TRUE, /* pc_relative */
1466 complain_overflow_signed, /* complain_on_overflow */
1467 bfd_elf_generic_reloc, /* special_function */
1468 "R_ARM_THM_JUMP11", /* name */
1469 FALSE, /* partial_inplace */
1470 0x000007ff, /* src_mask */
1471 0x000007ff, /* dst_mask */
1472 TRUE), /* pcrel_offset */
1474 HOWTO (R_ARM_THM_JUMP8, /* type */
1476 1, /* size (0 = byte, 1 = short, 2 = long) */
1478 TRUE, /* pc_relative */
1480 complain_overflow_signed, /* complain_on_overflow */
1481 bfd_elf_generic_reloc, /* special_function */
1482 "R_ARM_THM_JUMP8", /* name */
1483 FALSE, /* partial_inplace */
1484 0x000000ff, /* src_mask */
1485 0x000000ff, /* dst_mask */
1486 TRUE), /* pcrel_offset */
1488 /* TLS relocations */
1489 HOWTO (R_ARM_TLS_GD32, /* type */
1491 2, /* size (0 = byte, 1 = short, 2 = long) */
1493 FALSE, /* pc_relative */
1495 complain_overflow_bitfield,/* complain_on_overflow */
1496 NULL, /* special_function */
1497 "R_ARM_TLS_GD32", /* name */
1498 TRUE, /* partial_inplace */
1499 0xffffffff, /* src_mask */
1500 0xffffffff, /* dst_mask */
1501 FALSE), /* pcrel_offset */
1503 HOWTO (R_ARM_TLS_LDM32, /* type */
1505 2, /* size (0 = byte, 1 = short, 2 = long) */
1507 FALSE, /* pc_relative */
1509 complain_overflow_bitfield,/* complain_on_overflow */
1510 bfd_elf_generic_reloc, /* special_function */
1511 "R_ARM_TLS_LDM32", /* name */
1512 TRUE, /* partial_inplace */
1513 0xffffffff, /* src_mask */
1514 0xffffffff, /* dst_mask */
1515 FALSE), /* pcrel_offset */
1517 HOWTO (R_ARM_TLS_LDO32, /* type */
1519 2, /* size (0 = byte, 1 = short, 2 = long) */
1521 FALSE, /* pc_relative */
1523 complain_overflow_bitfield,/* complain_on_overflow */
1524 bfd_elf_generic_reloc, /* special_function */
1525 "R_ARM_TLS_LDO32", /* name */
1526 TRUE, /* partial_inplace */
1527 0xffffffff, /* src_mask */
1528 0xffffffff, /* dst_mask */
1529 FALSE), /* pcrel_offset */
1531 HOWTO (R_ARM_TLS_IE32, /* type */
1533 2, /* size (0 = byte, 1 = short, 2 = long) */
1535 FALSE, /* pc_relative */
1537 complain_overflow_bitfield,/* complain_on_overflow */
1538 NULL, /* special_function */
1539 "R_ARM_TLS_IE32", /* name */
1540 TRUE, /* partial_inplace */
1541 0xffffffff, /* src_mask */
1542 0xffffffff, /* dst_mask */
1543 FALSE), /* pcrel_offset */
1545 HOWTO (R_ARM_TLS_LE32, /* type */
1547 2, /* size (0 = byte, 1 = short, 2 = long) */
1549 FALSE, /* pc_relative */
1551 complain_overflow_bitfield,/* complain_on_overflow */
1552 bfd_elf_generic_reloc, /* special_function */
1553 "R_ARM_TLS_LE32", /* name */
1554 TRUE, /* partial_inplace */
1555 0xffffffff, /* src_mask */
1556 0xffffffff, /* dst_mask */
1557 FALSE), /* pcrel_offset */
1559 HOWTO (R_ARM_TLS_LDO12, /* type */
1561 2, /* size (0 = byte, 1 = short, 2 = long) */
1563 FALSE, /* pc_relative */
1565 complain_overflow_bitfield,/* complain_on_overflow */
1566 bfd_elf_generic_reloc, /* special_function */
1567 "R_ARM_TLS_LDO12", /* name */
1568 FALSE, /* partial_inplace */
1569 0x00000fff, /* src_mask */
1570 0x00000fff, /* dst_mask */
1571 FALSE), /* pcrel_offset */
1573 HOWTO (R_ARM_TLS_LE12, /* type */
1575 2, /* size (0 = byte, 1 = short, 2 = long) */
1577 FALSE, /* pc_relative */
1579 complain_overflow_bitfield,/* complain_on_overflow */
1580 bfd_elf_generic_reloc, /* special_function */
1581 "R_ARM_TLS_LE12", /* name */
1582 FALSE, /* partial_inplace */
1583 0x00000fff, /* src_mask */
1584 0x00000fff, /* dst_mask */
1585 FALSE), /* pcrel_offset */
1587 HOWTO (R_ARM_TLS_IE12GP, /* type */
1589 2, /* size (0 = byte, 1 = short, 2 = long) */
1591 FALSE, /* pc_relative */
1593 complain_overflow_bitfield,/* complain_on_overflow */
1594 bfd_elf_generic_reloc, /* special_function */
1595 "R_ARM_TLS_IE12GP", /* name */
1596 FALSE, /* partial_inplace */
1597 0x00000fff, /* src_mask */
1598 0x00000fff, /* dst_mask */
1599 FALSE), /* pcrel_offset */
1602 /* 112-127 private relocations
1603 128 R_ARM_ME_TOO, obsolete
1604 129-255 unallocated in AAELF.
1606 249-255 extended, currently unused, relocations: */
1608 static reloc_howto_type elf32_arm_howto_table_2[4] =
1610 HOWTO (R_ARM_RREL32, /* type */
1612 0, /* size (0 = byte, 1 = short, 2 = long) */
1614 FALSE, /* pc_relative */
1616 complain_overflow_dont,/* complain_on_overflow */
1617 bfd_elf_generic_reloc, /* special_function */
1618 "R_ARM_RREL32", /* name */
1619 FALSE, /* partial_inplace */
1622 FALSE), /* pcrel_offset */
1624 HOWTO (R_ARM_RABS32, /* type */
1626 0, /* size (0 = byte, 1 = short, 2 = long) */
1628 FALSE, /* pc_relative */
1630 complain_overflow_dont,/* complain_on_overflow */
1631 bfd_elf_generic_reloc, /* special_function */
1632 "R_ARM_RABS32", /* name */
1633 FALSE, /* partial_inplace */
1636 FALSE), /* pcrel_offset */
1638 HOWTO (R_ARM_RPC24, /* type */
1640 0, /* size (0 = byte, 1 = short, 2 = long) */
1642 FALSE, /* pc_relative */
1644 complain_overflow_dont,/* complain_on_overflow */
1645 bfd_elf_generic_reloc, /* special_function */
1646 "R_ARM_RPC24", /* name */
1647 FALSE, /* partial_inplace */
1650 FALSE), /* pcrel_offset */
1652 HOWTO (R_ARM_RBASE, /* type */
1654 0, /* size (0 = byte, 1 = short, 2 = long) */
1656 FALSE, /* pc_relative */
1658 complain_overflow_dont,/* complain_on_overflow */
1659 bfd_elf_generic_reloc, /* special_function */
1660 "R_ARM_RBASE", /* name */
1661 FALSE, /* partial_inplace */
1664 FALSE) /* pcrel_offset */
1667 static reloc_howto_type *
1668 elf32_arm_howto_from_type (unsigned int r_type)
1670 if (r_type < NUM_ELEM (elf32_arm_howto_table_1))
1671 return &elf32_arm_howto_table_1[r_type];
1673 if (r_type >= R_ARM_RREL32
1674 && r_type < R_ARM_RREL32 + NUM_ELEM (elf32_arm_howto_table_2))
1675 return &elf32_arm_howto_table_2[r_type - R_ARM_RREL32];
1681 elf32_arm_info_to_howto (bfd * abfd ATTRIBUTE_UNUSED, arelent * bfd_reloc,
1682 Elf_Internal_Rela * elf_reloc)
1684 unsigned int r_type;
1686 r_type = ELF32_R_TYPE (elf_reloc->r_info);
1687 bfd_reloc->howto = elf32_arm_howto_from_type (r_type);
1690 struct elf32_arm_reloc_map
1692 bfd_reloc_code_real_type bfd_reloc_val;
1693 unsigned char elf_reloc_val;
1696 /* All entries in this list must also be present in elf32_arm_howto_table. */
1697 static const struct elf32_arm_reloc_map elf32_arm_reloc_map[] =
1699 {BFD_RELOC_NONE, R_ARM_NONE},
1700 {BFD_RELOC_ARM_PCREL_BRANCH, R_ARM_PC24},
1701 {BFD_RELOC_ARM_PCREL_CALL, R_ARM_CALL},
1702 {BFD_RELOC_ARM_PCREL_JUMP, R_ARM_JUMP24},
1703 {BFD_RELOC_ARM_PCREL_BLX, R_ARM_XPC25},
1704 {BFD_RELOC_THUMB_PCREL_BLX, R_ARM_THM_XPC22},
1705 {BFD_RELOC_32, R_ARM_ABS32},
1706 {BFD_RELOC_32_PCREL, R_ARM_REL32},
1707 {BFD_RELOC_8, R_ARM_ABS8},
1708 {BFD_RELOC_16, R_ARM_ABS16},
1709 {BFD_RELOC_ARM_OFFSET_IMM, R_ARM_ABS12},
1710 {BFD_RELOC_ARM_THUMB_OFFSET, R_ARM_THM_ABS5},
1711 {BFD_RELOC_THUMB_PCREL_BRANCH25, R_ARM_THM_JUMP24},
1712 {BFD_RELOC_THUMB_PCREL_BRANCH23, R_ARM_THM_CALL},
1713 {BFD_RELOC_THUMB_PCREL_BRANCH12, R_ARM_THM_JUMP11},
1714 {BFD_RELOC_THUMB_PCREL_BRANCH20, R_ARM_THM_JUMP19},
1715 {BFD_RELOC_THUMB_PCREL_BRANCH9, R_ARM_THM_JUMP8},
1716 {BFD_RELOC_THUMB_PCREL_BRANCH7, R_ARM_THM_JUMP6},
1717 {BFD_RELOC_ARM_GLOB_DAT, R_ARM_GLOB_DAT},
1718 {BFD_RELOC_ARM_JUMP_SLOT, R_ARM_JUMP_SLOT},
1719 {BFD_RELOC_ARM_RELATIVE, R_ARM_RELATIVE},
1720 {BFD_RELOC_ARM_GOTOFF, R_ARM_GOTOFF32},
1721 {BFD_RELOC_ARM_GOTPC, R_ARM_GOTPC},
1722 {BFD_RELOC_ARM_GOT32, R_ARM_GOT32},
1723 {BFD_RELOC_ARM_PLT32, R_ARM_PLT32},
1724 {BFD_RELOC_ARM_TARGET1, R_ARM_TARGET1},
1725 {BFD_RELOC_ARM_ROSEGREL32, R_ARM_ROSEGREL32},
1726 {BFD_RELOC_ARM_SBREL32, R_ARM_SBREL32},
1727 {BFD_RELOC_ARM_PREL31, R_ARM_PREL31},
1728 {BFD_RELOC_ARM_TARGET2, R_ARM_TARGET2},
1729 {BFD_RELOC_ARM_PLT32, R_ARM_PLT32},
1730 {BFD_RELOC_ARM_TLS_GD32, R_ARM_TLS_GD32},
1731 {BFD_RELOC_ARM_TLS_LDO32, R_ARM_TLS_LDO32},
1732 {BFD_RELOC_ARM_TLS_LDM32, R_ARM_TLS_LDM32},
1733 {BFD_RELOC_ARM_TLS_DTPMOD32, R_ARM_TLS_DTPMOD32},
1734 {BFD_RELOC_ARM_TLS_DTPOFF32, R_ARM_TLS_DTPOFF32},
1735 {BFD_RELOC_ARM_TLS_TPOFF32, R_ARM_TLS_TPOFF32},
1736 {BFD_RELOC_ARM_TLS_IE32, R_ARM_TLS_IE32},
1737 {BFD_RELOC_ARM_TLS_LE32, R_ARM_TLS_LE32},
1738 {BFD_RELOC_VTABLE_INHERIT, R_ARM_GNU_VTINHERIT},
1739 {BFD_RELOC_VTABLE_ENTRY, R_ARM_GNU_VTENTRY},
1740 {BFD_RELOC_ARM_MOVW, R_ARM_MOVW_ABS_NC},
1741 {BFD_RELOC_ARM_MOVT, R_ARM_MOVT_ABS},
1742 {BFD_RELOC_ARM_MOVW_PCREL, R_ARM_MOVW_PREL_NC},
1743 {BFD_RELOC_ARM_MOVT_PCREL, R_ARM_MOVT_PREL},
1744 {BFD_RELOC_ARM_THUMB_MOVW, R_ARM_THM_MOVW_ABS_NC},
1745 {BFD_RELOC_ARM_THUMB_MOVT, R_ARM_THM_MOVT_ABS},
1746 {BFD_RELOC_ARM_THUMB_MOVW_PCREL, R_ARM_THM_MOVW_PREL_NC},
1747 {BFD_RELOC_ARM_THUMB_MOVT_PCREL, R_ARM_THM_MOVT_PREL},
1748 {BFD_RELOC_ARM_ALU_PC_G0_NC, R_ARM_ALU_PC_G0_NC},
1749 {BFD_RELOC_ARM_ALU_PC_G0, R_ARM_ALU_PC_G0},
1750 {BFD_RELOC_ARM_ALU_PC_G1_NC, R_ARM_ALU_PC_G1_NC},
1751 {BFD_RELOC_ARM_ALU_PC_G1, R_ARM_ALU_PC_G1},
1752 {BFD_RELOC_ARM_ALU_PC_G2, R_ARM_ALU_PC_G2},
1753 {BFD_RELOC_ARM_LDR_PC_G0, R_ARM_LDR_PC_G0},
1754 {BFD_RELOC_ARM_LDR_PC_G1, R_ARM_LDR_PC_G1},
1755 {BFD_RELOC_ARM_LDR_PC_G2, R_ARM_LDR_PC_G2},
1756 {BFD_RELOC_ARM_LDRS_PC_G0, R_ARM_LDRS_PC_G0},
1757 {BFD_RELOC_ARM_LDRS_PC_G1, R_ARM_LDRS_PC_G1},
1758 {BFD_RELOC_ARM_LDRS_PC_G2, R_ARM_LDRS_PC_G2},
1759 {BFD_RELOC_ARM_LDC_PC_G0, R_ARM_LDC_PC_G0},
1760 {BFD_RELOC_ARM_LDC_PC_G1, R_ARM_LDC_PC_G1},
1761 {BFD_RELOC_ARM_LDC_PC_G2, R_ARM_LDC_PC_G2},
1762 {BFD_RELOC_ARM_ALU_SB_G0_NC, R_ARM_ALU_SB_G0_NC},
1763 {BFD_RELOC_ARM_ALU_SB_G0, R_ARM_ALU_SB_G0},
1764 {BFD_RELOC_ARM_ALU_SB_G1_NC, R_ARM_ALU_SB_G1_NC},
1765 {BFD_RELOC_ARM_ALU_SB_G1, R_ARM_ALU_SB_G1},
1766 {BFD_RELOC_ARM_ALU_SB_G2, R_ARM_ALU_SB_G2},
1767 {BFD_RELOC_ARM_LDR_SB_G0, R_ARM_LDR_SB_G0},
1768 {BFD_RELOC_ARM_LDR_SB_G1, R_ARM_LDR_SB_G1},
1769 {BFD_RELOC_ARM_LDR_SB_G2, R_ARM_LDR_SB_G2},
1770 {BFD_RELOC_ARM_LDRS_SB_G0, R_ARM_LDRS_SB_G0},
1771 {BFD_RELOC_ARM_LDRS_SB_G1, R_ARM_LDRS_SB_G1},
1772 {BFD_RELOC_ARM_LDRS_SB_G2, R_ARM_LDRS_SB_G2},
1773 {BFD_RELOC_ARM_LDC_SB_G0, R_ARM_LDC_SB_G0},
1774 {BFD_RELOC_ARM_LDC_SB_G1, R_ARM_LDC_SB_G1},
1775 {BFD_RELOC_ARM_LDC_SB_G2, R_ARM_LDC_SB_G2}
1778 static reloc_howto_type *
1779 elf32_arm_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1780 bfd_reloc_code_real_type code)
1783 for (i = 0; i < NUM_ELEM (elf32_arm_reloc_map); i ++)
1784 if (elf32_arm_reloc_map[i].bfd_reloc_val == code)
1785 return elf32_arm_howto_from_type (elf32_arm_reloc_map[i].elf_reloc_val);
1790 /* Support for core dump NOTE sections */
1792 elf32_arm_nabi_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
1797 switch (note->descsz)
1802 case 148: /* Linux/ARM 32-bit*/
1804 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
1807 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
1816 /* Make a ".reg/999" section. */
1817 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
1818 size, note->descpos + offset);
1822 elf32_arm_nabi_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
1824 switch (note->descsz)
1829 case 124: /* Linux/ARM elf_prpsinfo */
1830 elf_tdata (abfd)->core_program
1831 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
1832 elf_tdata (abfd)->core_command
1833 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
1836 /* Note that for some reason, a spurious space is tacked
1837 onto the end of the args in some (at least one anyway)
1838 implementations, so strip it off if it exists. */
1841 char *command = elf_tdata (abfd)->core_command;
1842 int n = strlen (command);
1844 if (0 < n && command[n - 1] == ' ')
1845 command[n - 1] = '\0';
1851 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_vec
1852 #define TARGET_LITTLE_NAME "elf32-littlearm"
1853 #define TARGET_BIG_SYM bfd_elf32_bigarm_vec
1854 #define TARGET_BIG_NAME "elf32-bigarm"
1856 #define elf_backend_grok_prstatus elf32_arm_nabi_grok_prstatus
1857 #define elf_backend_grok_psinfo elf32_arm_nabi_grok_psinfo
1859 typedef unsigned long int insn32;
1860 typedef unsigned short int insn16;
1862 /* In lieu of proper flags, assume all EABIv4 or later objects are
1864 #define INTERWORK_FLAG(abfd) \
1865 (EF_ARM_EABI_VERSION (elf_elfheader (abfd)->e_flags) >= EF_ARM_EABI_VER4 \
1866 || (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK))
1868 /* The linker script knows the section names for placement.
1869 The entry_names are used to do simple name mangling on the stubs.
1870 Given a function name, and its type, the stub can be found. The
1871 name can be changed. The only requirement is the %s be present. */
1872 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
1873 #define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
1875 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
1876 #define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
1878 /* The name of the dynamic interpreter. This is put in the .interp
1880 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
1882 #ifdef FOUR_WORD_PLT
1884 /* The first entry in a procedure linkage table looks like
1885 this. It is set up so that any shared library function that is
1886 called before the relocation has been set up calls the dynamic
1888 static const bfd_vma elf32_arm_plt0_entry [] =
1890 0xe52de004, /* str lr, [sp, #-4]! */
1891 0xe59fe010, /* ldr lr, [pc, #16] */
1892 0xe08fe00e, /* add lr, pc, lr */
1893 0xe5bef008, /* ldr pc, [lr, #8]! */
1896 /* Subsequent entries in a procedure linkage table look like
1898 static const bfd_vma elf32_arm_plt_entry [] =
1900 0xe28fc600, /* add ip, pc, #NN */
1901 0xe28cca00, /* add ip, ip, #NN */
1902 0xe5bcf000, /* ldr pc, [ip, #NN]! */
1903 0x00000000, /* unused */
1908 /* The first entry in a procedure linkage table looks like
1909 this. It is set up so that any shared library function that is
1910 called before the relocation has been set up calls the dynamic
1912 static const bfd_vma elf32_arm_plt0_entry [] =
1914 0xe52de004, /* str lr, [sp, #-4]! */
1915 0xe59fe004, /* ldr lr, [pc, #4] */
1916 0xe08fe00e, /* add lr, pc, lr */
1917 0xe5bef008, /* ldr pc, [lr, #8]! */
1918 0x00000000, /* &GOT[0] - . */
1921 /* Subsequent entries in a procedure linkage table look like
1923 static const bfd_vma elf32_arm_plt_entry [] =
1925 0xe28fc600, /* add ip, pc, #0xNN00000 */
1926 0xe28cca00, /* add ip, ip, #0xNN000 */
1927 0xe5bcf000, /* ldr pc, [ip, #0xNNN]! */
1932 /* The format of the first entry in the procedure linkage table
1933 for a VxWorks executable. */
1934 static const bfd_vma elf32_arm_vxworks_exec_plt0_entry[] =
1936 0xe52dc008, /* str ip,[sp,#-8]! */
1937 0xe59fc000, /* ldr ip,[pc] */
1938 0xe59cf008, /* ldr pc,[ip,#8] */
1939 0x00000000, /* .long _GLOBAL_OFFSET_TABLE_ */
1942 /* The format of subsequent entries in a VxWorks executable. */
1943 static const bfd_vma elf32_arm_vxworks_exec_plt_entry[] =
1945 0xe59fc000, /* ldr ip,[pc] */
1946 0xe59cf000, /* ldr pc,[ip] */
1947 0x00000000, /* .long @got */
1948 0xe59fc000, /* ldr ip,[pc] */
1949 0xea000000, /* b _PLT */
1950 0x00000000, /* .long @pltindex*sizeof(Elf32_Rela) */
1953 /* The format of entries in a VxWorks shared library. */
1954 static const bfd_vma elf32_arm_vxworks_shared_plt_entry[] =
1956 0xe59fc000, /* ldr ip,[pc] */
1957 0xe79cf009, /* ldr pc,[ip,r9] */
1958 0x00000000, /* .long @got */
1959 0xe59fc000, /* ldr ip,[pc] */
1960 0xe599f008, /* ldr pc,[r9,#8] */
1961 0x00000000, /* .long @pltindex*sizeof(Elf32_Rela) */
1964 /* An initial stub used if the PLT entry is referenced from Thumb code. */
1965 #define PLT_THUMB_STUB_SIZE 4
1966 static const bfd_vma elf32_arm_plt_thumb_stub [] =
1972 /* The entries in a PLT when using a DLL-based target with multiple
1974 static const bfd_vma elf32_arm_symbian_plt_entry [] =
1976 0xe51ff004, /* ldr pc, [pc, #-4] */
1977 0x00000000, /* dcd R_ARM_GLOB_DAT(X) */
1980 /* Used to build a map of a section. This is required for mixed-endian
1983 typedef struct elf32_elf_section_map
1988 elf32_arm_section_map;
1990 typedef struct _arm_elf_section_data
1992 struct bfd_elf_section_data elf;
1993 unsigned int mapcount;
1994 elf32_arm_section_map *map;
1996 _arm_elf_section_data;
1998 #define elf32_arm_section_data(sec) \
1999 ((_arm_elf_section_data *) elf_section_data (sec))
2001 /* The size of the thread control block. */
2004 #define NUM_KNOWN_ATTRIBUTES 32
2006 typedef struct aeabi_attribute
2013 typedef struct aeabi_attribute_list
2015 struct aeabi_attribute_list *next;
2017 aeabi_attribute attr;
2018 } aeabi_attribute_list;
2020 struct elf32_arm_obj_tdata
2022 struct elf_obj_tdata root;
2024 /* tls_type for each local got entry. */
2025 char *local_got_tls_type;
2027 aeabi_attribute known_eabi_attributes[NUM_KNOWN_ATTRIBUTES];
2028 aeabi_attribute_list *other_eabi_attributes;
2031 #define elf32_arm_tdata(abfd) \
2032 ((struct elf32_arm_obj_tdata *) (abfd)->tdata.any)
2034 #define elf32_arm_local_got_tls_type(abfd) \
2035 (elf32_arm_tdata (abfd)->local_got_tls_type)
2038 elf32_arm_mkobject (bfd *abfd)
2040 bfd_size_type amt = sizeof (struct elf32_arm_obj_tdata);
2041 abfd->tdata.any = bfd_zalloc (abfd, amt);
2042 if (abfd->tdata.any == NULL)
2047 /* The ARM linker needs to keep track of the number of relocs that it
2048 decides to copy in check_relocs for each symbol. This is so that
2049 it can discard PC relative relocs if it doesn't need them when
2050 linking with -Bsymbolic. We store the information in a field
2051 extending the regular ELF linker hash table. */
2053 /* This structure keeps track of the number of relocs we have copied
2054 for a given symbol. */
2055 struct elf32_arm_relocs_copied
2058 struct elf32_arm_relocs_copied * next;
2059 /* A section in dynobj. */
2061 /* Number of relocs copied in this section. */
2062 bfd_size_type count;
2063 /* Number of PC-relative relocs copied in this section. */
2064 bfd_size_type pc_count;
2067 #define elf32_arm_hash_entry(ent) ((struct elf32_arm_link_hash_entry *)(ent))
2069 /* Arm ELF linker hash entry. */
2070 struct elf32_arm_link_hash_entry
2072 struct elf_link_hash_entry root;
2074 /* Number of PC relative relocs copied for this symbol. */
2075 struct elf32_arm_relocs_copied * relocs_copied;
2077 /* We reference count Thumb references to a PLT entry separately,
2078 so that we can emit the Thumb trampoline only if needed. */
2079 bfd_signed_vma plt_thumb_refcount;
2081 /* Since PLT entries have variable size if the Thumb prologue is
2082 used, we need to record the index into .got.plt instead of
2083 recomputing it from the PLT offset. */
2084 bfd_signed_vma plt_got_offset;
2086 #define GOT_UNKNOWN 0
2087 #define GOT_NORMAL 1
2088 #define GOT_TLS_GD 2
2089 #define GOT_TLS_IE 4
2090 unsigned char tls_type;
2092 /* The symbol marking the real symbol location for exported thumb
2093 symbols with Arm stubs. */
2094 struct elf_link_hash_entry *export_glue;
2097 /* Traverse an arm ELF linker hash table. */
2098 #define elf32_arm_link_hash_traverse(table, func, info) \
2099 (elf_link_hash_traverse \
2101 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
2104 /* Get the ARM elf linker hash table from a link_info structure. */
2105 #define elf32_arm_hash_table(info) \
2106 ((struct elf32_arm_link_hash_table *) ((info)->hash))
2108 /* ARM ELF linker hash table. */
2109 struct elf32_arm_link_hash_table
2111 /* The main hash table. */
2112 struct elf_link_hash_table root;
2114 /* The size in bytes of the section containing the Thumb-to-ARM glue. */
2115 bfd_size_type thumb_glue_size;
2117 /* The size in bytes of the section containing the ARM-to-Thumb glue. */
2118 bfd_size_type arm_glue_size;
2120 /* An arbitrary input BFD chosen to hold the glue sections. */
2121 bfd * bfd_of_glue_owner;
2123 /* Nonzero to output a BE8 image. */
2126 /* Zero if R_ARM_TARGET1 means R_ARM_ABS32.
2127 Nonzero if R_ARM_TARGET1 means R_ARM_REL32. */
2130 /* The relocation to use for R_ARM_TARGET2 relocations. */
2133 /* Nonzero to fix BX instructions for ARMv4 targets. */
2136 /* Nonzero if the ARM/Thumb BLX instructions are available for use. */
2139 /* The number of bytes in the initial entry in the PLT. */
2140 bfd_size_type plt_header_size;
2142 /* The number of bytes in the subsequent PLT etries. */
2143 bfd_size_type plt_entry_size;
2145 /* True if the target system is VxWorks. */
2148 /* True if the target system is Symbian OS. */
2151 /* True if the target uses REL relocations. */
2154 /* Short-cuts to get to dynamic linker sections. */
2163 /* The (unloaded but important) VxWorks .rela.plt.unloaded section. */
2166 /* Data for R_ARM_TLS_LDM32 relocations. */
2168 bfd_signed_vma refcount;
2172 /* Small local sym to section mapping cache. */
2173 struct sym_sec_cache sym_sec;
2175 /* For convenience in allocate_dynrelocs. */
2179 /* Create an entry in an ARM ELF linker hash table. */
2181 static struct bfd_hash_entry *
2182 elf32_arm_link_hash_newfunc (struct bfd_hash_entry * entry,
2183 struct bfd_hash_table * table,
2184 const char * string)
2186 struct elf32_arm_link_hash_entry * ret =
2187 (struct elf32_arm_link_hash_entry *) entry;
2189 /* Allocate the structure if it has not already been allocated by a
2191 if (ret == (struct elf32_arm_link_hash_entry *) NULL)
2192 ret = bfd_hash_allocate (table, sizeof (struct elf32_arm_link_hash_entry));
2194 return (struct bfd_hash_entry *) ret;
2196 /* Call the allocation method of the superclass. */
2197 ret = ((struct elf32_arm_link_hash_entry *)
2198 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2202 ret->relocs_copied = NULL;
2203 ret->tls_type = GOT_UNKNOWN;
2204 ret->plt_thumb_refcount = 0;
2205 ret->plt_got_offset = -1;
2206 ret->export_glue = NULL;
2209 return (struct bfd_hash_entry *) ret;
2212 /* Return true if NAME is the name of the relocation section associated
2216 reloc_section_p (struct elf32_arm_link_hash_table *htab,
2217 const char *name, asection *s)
2220 return strncmp (name, ".rel", 4) == 0 && strcmp (s->name, name + 4) == 0;
2222 return strncmp (name, ".rela", 5) == 0 && strcmp (s->name, name + 5) == 0;
2225 /* Create .got, .gotplt, and .rel(a).got sections in DYNOBJ, and set up
2226 shortcuts to them in our hash table. */
2229 create_got_section (bfd *dynobj, struct bfd_link_info *info)
2231 struct elf32_arm_link_hash_table *htab;
2233 htab = elf32_arm_hash_table (info);
2234 /* BPABI objects never have a GOT, or associated sections. */
2235 if (htab->symbian_p)
2238 if (! _bfd_elf_create_got_section (dynobj, info))
2241 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
2242 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
2243 if (!htab->sgot || !htab->sgotplt)
2246 htab->srelgot = bfd_make_section_with_flags (dynobj,
2247 RELOC_SECTION (htab, ".got"),
2248 (SEC_ALLOC | SEC_LOAD
2251 | SEC_LINKER_CREATED
2253 if (htab->srelgot == NULL
2254 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
2259 /* Create .plt, .rel(a).plt, .got, .got.plt, .rel(a).got, .dynbss, and
2260 .rel(a).bss sections in DYNOBJ, and set up shortcuts to them in our
2264 elf32_arm_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
2266 struct elf32_arm_link_hash_table *htab;
2268 htab = elf32_arm_hash_table (info);
2269 if (!htab->sgot && !create_got_section (dynobj, info))
2272 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
2275 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
2276 htab->srelplt = bfd_get_section_by_name (dynobj,
2277 RELOC_SECTION (htab, ".plt"));
2278 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
2280 htab->srelbss = bfd_get_section_by_name (dynobj,
2281 RELOC_SECTION (htab, ".bss"));
2283 if (htab->vxworks_p)
2285 if (!elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2))
2290 htab->plt_header_size = 0;
2291 htab->plt_entry_size
2292 = 4 * ARRAY_SIZE (elf32_arm_vxworks_shared_plt_entry);
2296 htab->plt_header_size
2297 = 4 * ARRAY_SIZE (elf32_arm_vxworks_exec_plt0_entry);
2298 htab->plt_entry_size
2299 = 4 * ARRAY_SIZE (elf32_arm_vxworks_exec_plt_entry);
2306 || (!info->shared && !htab->srelbss))
2312 /* Copy the extra info we tack onto an elf_link_hash_entry. */
2315 elf32_arm_copy_indirect_symbol (struct bfd_link_info *info,
2316 struct elf_link_hash_entry *dir,
2317 struct elf_link_hash_entry *ind)
2319 struct elf32_arm_link_hash_entry *edir, *eind;
2321 edir = (struct elf32_arm_link_hash_entry *) dir;
2322 eind = (struct elf32_arm_link_hash_entry *) ind;
2324 if (eind->relocs_copied != NULL)
2326 if (edir->relocs_copied != NULL)
2328 struct elf32_arm_relocs_copied **pp;
2329 struct elf32_arm_relocs_copied *p;
2331 /* Add reloc counts against the indirect sym to the direct sym
2332 list. Merge any entries against the same section. */
2333 for (pp = &eind->relocs_copied; (p = *pp) != NULL; )
2335 struct elf32_arm_relocs_copied *q;
2337 for (q = edir->relocs_copied; q != NULL; q = q->next)
2338 if (q->section == p->section)
2340 q->pc_count += p->pc_count;
2341 q->count += p->count;
2348 *pp = edir->relocs_copied;
2351 edir->relocs_copied = eind->relocs_copied;
2352 eind->relocs_copied = NULL;
2355 /* Copy over PLT info. */
2356 edir->plt_thumb_refcount += eind->plt_thumb_refcount;
2357 eind->plt_thumb_refcount = 0;
2359 if (ind->root.type == bfd_link_hash_indirect
2360 && dir->got.refcount <= 0)
2362 edir->tls_type = eind->tls_type;
2363 eind->tls_type = GOT_UNKNOWN;
2366 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2369 /* Create an ARM elf linker hash table. */
2371 static struct bfd_link_hash_table *
2372 elf32_arm_link_hash_table_create (bfd *abfd)
2374 struct elf32_arm_link_hash_table *ret;
2375 bfd_size_type amt = sizeof (struct elf32_arm_link_hash_table);
2377 ret = bfd_malloc (amt);
2381 if (!_bfd_elf_link_hash_table_init (& ret->root, abfd,
2382 elf32_arm_link_hash_newfunc,
2383 sizeof (struct elf32_arm_link_hash_entry)))
2390 ret->sgotplt = NULL;
2391 ret->srelgot = NULL;
2393 ret->srelplt = NULL;
2394 ret->sdynbss = NULL;
2395 ret->srelbss = NULL;
2396 ret->srelplt2 = NULL;
2397 ret->thumb_glue_size = 0;
2398 ret->arm_glue_size = 0;
2399 ret->bfd_of_glue_owner = NULL;
2400 ret->byteswap_code = 0;
2401 ret->target1_is_rel = 0;
2402 ret->target2_reloc = R_ARM_NONE;
2403 #ifdef FOUR_WORD_PLT
2404 ret->plt_header_size = 16;
2405 ret->plt_entry_size = 16;
2407 ret->plt_header_size = 20;
2408 ret->plt_entry_size = 12;
2415 ret->sym_sec.abfd = NULL;
2417 ret->tls_ldm_got.refcount = 0;
2419 return &ret->root.root;
2422 /* Locate the Thumb encoded calling stub for NAME. */
2424 static struct elf_link_hash_entry *
2425 find_thumb_glue (struct bfd_link_info *link_info,
2430 struct elf_link_hash_entry *hash;
2431 struct elf32_arm_link_hash_table *hash_table;
2433 /* We need a pointer to the armelf specific hash table. */
2434 hash_table = elf32_arm_hash_table (link_info);
2436 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
2437 + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
2439 BFD_ASSERT (tmp_name);
2441 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
2443 hash = elf_link_hash_lookup
2444 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
2447 /* xgettext:c-format */
2448 (*_bfd_error_handler) (_("%B: unable to find THUMB glue '%s' for `%s'"),
2449 input_bfd, tmp_name, name);
2456 /* Locate the ARM encoded calling stub for NAME. */
2458 static struct elf_link_hash_entry *
2459 find_arm_glue (struct bfd_link_info *link_info,
2464 struct elf_link_hash_entry *myh;
2465 struct elf32_arm_link_hash_table *hash_table;
2467 /* We need a pointer to the elfarm specific hash table. */
2468 hash_table = elf32_arm_hash_table (link_info);
2470 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
2471 + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
2473 BFD_ASSERT (tmp_name);
2475 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
2477 myh = elf_link_hash_lookup
2478 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
2481 /* xgettext:c-format */
2482 (*_bfd_error_handler) (_("%B: unable to find ARM glue '%s' for `%s'"),
2483 input_bfd, tmp_name, name);
2490 /* ARM->Thumb glue (static images):
2494 ldr r12, __func_addr
2497 .word func @ behave as if you saw a ARM_32 reloc.
2499 (relocatable images)
2502 ldr r12, __func_offset
2509 #define ARM2THUMB_STATIC_GLUE_SIZE 12
2510 static const insn32 a2t1_ldr_insn = 0xe59fc000;
2511 static const insn32 a2t2_bx_r12_insn = 0xe12fff1c;
2512 static const insn32 a2t3_func_addr_insn = 0x00000001;
2514 #define ARM2THUMB_PIC_GLUE_SIZE 16
2515 static const insn32 a2t1p_ldr_insn = 0xe59fc004;
2516 static const insn32 a2t2p_add_pc_insn = 0xe08cc00f;
2517 static const insn32 a2t3p_bx_r12_insn = 0xe12fff1c;
2519 /* Thumb->ARM: Thumb->(non-interworking aware) ARM
2523 __func_from_thumb: __func_from_thumb:
2525 nop ldr r6, __func_addr
2527 __func_change_to_arm: bx r6
2529 __func_back_to_thumb:
2535 #define THUMB2ARM_GLUE_SIZE 8
2536 static const insn16 t2a1_bx_pc_insn = 0x4778;
2537 static const insn16 t2a2_noop_insn = 0x46c0;
2538 static const insn32 t2a3_b_insn = 0xea000000;
2540 #ifndef ELFARM_NABI_C_INCLUDED
2542 bfd_elf32_arm_allocate_interworking_sections (struct bfd_link_info * info)
2546 struct elf32_arm_link_hash_table * globals;
2548 globals = elf32_arm_hash_table (info);
2550 BFD_ASSERT (globals != NULL);
2552 if (globals->arm_glue_size != 0)
2554 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2556 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
2557 ARM2THUMB_GLUE_SECTION_NAME);
2559 BFD_ASSERT (s != NULL);
2561 foo = bfd_alloc (globals->bfd_of_glue_owner, globals->arm_glue_size);
2563 s->size = globals->arm_glue_size;
2567 if (globals->thumb_glue_size != 0)
2569 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2571 s = bfd_get_section_by_name
2572 (globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
2574 BFD_ASSERT (s != NULL);
2576 foo = bfd_alloc (globals->bfd_of_glue_owner, globals->thumb_glue_size);
2578 s->size = globals->thumb_glue_size;
2585 /* Allocate space and symbols for calling a Thumb function from Arm mode.
2586 returns the symbol identifying teh stub. */
2587 static struct elf_link_hash_entry *
2588 record_arm_to_thumb_glue (struct bfd_link_info * link_info,
2589 struct elf_link_hash_entry * h)
2591 const char * name = h->root.root.string;
2594 struct elf_link_hash_entry * myh;
2595 struct bfd_link_hash_entry * bh;
2596 struct elf32_arm_link_hash_table * globals;
2599 globals = elf32_arm_hash_table (link_info);
2601 BFD_ASSERT (globals != NULL);
2602 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2604 s = bfd_get_section_by_name
2605 (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
2607 BFD_ASSERT (s != NULL);
2609 tmp_name = bfd_malloc ((bfd_size_type) strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
2611 BFD_ASSERT (tmp_name);
2613 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
2615 myh = elf_link_hash_lookup
2616 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
2620 /* We've already seen this guy. */
2625 /* The only trick here is using hash_table->arm_glue_size as the value.
2626 Even though the section isn't allocated yet, this is where we will be
2629 val = globals->arm_glue_size + 1;
2630 _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner,
2631 tmp_name, BSF_GLOBAL, s, val,
2632 NULL, TRUE, FALSE, &bh);
2634 myh = (struct elf_link_hash_entry *) bh;
2635 myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
2636 myh->forced_local = 1;
2640 if ((link_info->shared || globals->root.is_relocatable_executable))
2641 globals->arm_glue_size += ARM2THUMB_PIC_GLUE_SIZE;
2643 globals->arm_glue_size += ARM2THUMB_STATIC_GLUE_SIZE;
2649 record_thumb_to_arm_glue (struct bfd_link_info *link_info,
2650 struct elf_link_hash_entry *h)
2652 const char *name = h->root.root.string;
2655 struct elf_link_hash_entry *myh;
2656 struct bfd_link_hash_entry *bh;
2657 struct elf32_arm_link_hash_table *hash_table;
2660 hash_table = elf32_arm_hash_table (link_info);
2662 BFD_ASSERT (hash_table != NULL);
2663 BFD_ASSERT (hash_table->bfd_of_glue_owner != NULL);
2665 s = bfd_get_section_by_name
2666 (hash_table->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
2668 BFD_ASSERT (s != NULL);
2670 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
2671 + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
2673 BFD_ASSERT (tmp_name);
2675 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
2677 myh = elf_link_hash_lookup
2678 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
2682 /* We've already seen this guy. */
2688 val = hash_table->thumb_glue_size + 1;
2689 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
2690 tmp_name, BSF_GLOBAL, s, val,
2691 NULL, TRUE, FALSE, &bh);
2693 /* If we mark it 'Thumb', the disassembler will do a better job. */
2694 myh = (struct elf_link_hash_entry *) bh;
2695 myh->type = ELF_ST_INFO (STB_LOCAL, STT_ARM_TFUNC);
2696 myh->forced_local = 1;
2700 #define CHANGE_TO_ARM "__%s_change_to_arm"
2701 #define BACK_FROM_ARM "__%s_back_from_arm"
2703 /* Allocate another symbol to mark where we switch to Arm mode. */
2704 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
2705 + strlen (CHANGE_TO_ARM) + 1);
2707 BFD_ASSERT (tmp_name);
2709 sprintf (tmp_name, CHANGE_TO_ARM, name);
2712 val = hash_table->thumb_glue_size + 4,
2713 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
2714 tmp_name, BSF_LOCAL, s, val,
2715 NULL, TRUE, FALSE, &bh);
2719 hash_table->thumb_glue_size += THUMB2ARM_GLUE_SIZE;
2724 /* Add the glue sections to ABFD. This function is called from the
2725 linker scripts in ld/emultempl/{armelf}.em. */
2728 bfd_elf32_arm_add_glue_sections_to_bfd (bfd *abfd,
2729 struct bfd_link_info *info)
2734 /* If we are only performing a partial
2735 link do not bother adding the glue. */
2736 if (info->relocatable)
2739 sec = bfd_get_section_by_name (abfd, ARM2THUMB_GLUE_SECTION_NAME);
2743 /* Note: we do not include the flag SEC_LINKER_CREATED, as this
2744 will prevent elf_link_input_bfd() from processing the contents
2746 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE | SEC_READONLY;
2748 sec = bfd_make_section_with_flags (abfd,
2749 ARM2THUMB_GLUE_SECTION_NAME,
2753 || !bfd_set_section_alignment (abfd, sec, 2))
2756 /* Set the gc mark to prevent the section from being removed by garbage
2757 collection, despite the fact that no relocs refer to this section. */
2761 sec = bfd_get_section_by_name (abfd, THUMB2ARM_GLUE_SECTION_NAME);
2765 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2766 | SEC_CODE | SEC_READONLY;
2768 sec = bfd_make_section_with_flags (abfd,
2769 THUMB2ARM_GLUE_SECTION_NAME,
2773 || !bfd_set_section_alignment (abfd, sec, 2))
2782 /* Select a BFD to be used to hold the sections used by the glue code.
2783 This function is called from the linker scripts in ld/emultempl/
2787 bfd_elf32_arm_get_bfd_for_interworking (bfd *abfd, struct bfd_link_info *info)
2789 struct elf32_arm_link_hash_table *globals;
2791 /* If we are only performing a partial link
2792 do not bother getting a bfd to hold the glue. */
2793 if (info->relocatable)
2796 /* Make sure we don't attach the glue sections to a dynamic object. */
2797 BFD_ASSERT (!(abfd->flags & DYNAMIC));
2799 globals = elf32_arm_hash_table (info);
2801 BFD_ASSERT (globals != NULL);
2803 if (globals->bfd_of_glue_owner != NULL)
2806 /* Save the bfd for later use. */
2807 globals->bfd_of_glue_owner = abfd;
2812 static void check_use_blx(struct elf32_arm_link_hash_table *globals)
2814 if (elf32_arm_get_eabi_attr_int (globals->obfd, Tag_CPU_arch) > 2)
2815 globals->use_blx = 1;
2819 bfd_elf32_arm_process_before_allocation (bfd *abfd,
2820 struct bfd_link_info *link_info,
2823 Elf_Internal_Shdr *symtab_hdr;
2824 Elf_Internal_Rela *internal_relocs = NULL;
2825 Elf_Internal_Rela *irel, *irelend;
2826 bfd_byte *contents = NULL;
2829 struct elf32_arm_link_hash_table *globals;
2831 /* If we are only performing a partial link do not bother
2832 to construct any glue. */
2833 if (link_info->relocatable)
2836 /* Here we have a bfd that is to be included on the link. We have a hook
2837 to do reloc rummaging, before section sizes are nailed down. */
2838 globals = elf32_arm_hash_table (link_info);
2839 check_use_blx (globals);
2841 BFD_ASSERT (globals != NULL);
2842 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2844 if (byteswap_code && !bfd_big_endian (abfd))
2846 _bfd_error_handler (_("%B: BE8 images only valid in big-endian mode."),
2850 globals->byteswap_code = byteswap_code;
2852 /* Rummage around all the relocs and map the glue vectors. */
2853 sec = abfd->sections;
2858 for (; sec != NULL; sec = sec->next)
2860 if (sec->reloc_count == 0)
2863 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2865 /* Load the relocs. */
2867 = _bfd_elf_link_read_relocs (abfd, sec, (void *) NULL,
2868 (Elf_Internal_Rela *) NULL, FALSE);
2870 if (internal_relocs == NULL)
2873 irelend = internal_relocs + sec->reloc_count;
2874 for (irel = internal_relocs; irel < irelend; irel++)
2877 unsigned long r_index;
2879 struct elf_link_hash_entry *h;
2881 r_type = ELF32_R_TYPE (irel->r_info);
2882 r_index = ELF32_R_SYM (irel->r_info);
2884 /* These are the only relocation types we care about. */
2885 if ( r_type != R_ARM_PC24
2886 && r_type != R_ARM_PLT32
2887 && r_type != R_ARM_CALL
2888 && r_type != R_ARM_JUMP24
2889 && r_type != R_ARM_THM_CALL)
2892 /* Get the section contents if we haven't done so already. */
2893 if (contents == NULL)
2895 /* Get cached copy if it exists. */
2896 if (elf_section_data (sec)->this_hdr.contents != NULL)
2897 contents = elf_section_data (sec)->this_hdr.contents;
2900 /* Go get them off disk. */
2901 if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2906 /* If the relocation is not against a symbol it cannot concern us. */
2909 /* We don't care about local symbols. */
2910 if (r_index < symtab_hdr->sh_info)
2913 /* This is an external symbol. */
2914 r_index -= symtab_hdr->sh_info;
2915 h = (struct elf_link_hash_entry *)
2916 elf_sym_hashes (abfd)[r_index];
2918 /* If the relocation is against a static symbol it must be within
2919 the current section and so cannot be a cross ARM/Thumb relocation. */
2923 /* If the call will go through a PLT entry then we do not need
2925 if (globals->splt != NULL && h->plt.offset != (bfd_vma) -1)
2934 /* This one is a call from arm code. We need to look up
2935 the target of the call. If it is a thumb target, we
2937 if (ELF_ST_TYPE(h->type) == STT_ARM_TFUNC
2938 && !(r_type == R_ARM_CALL && globals->use_blx))
2939 record_arm_to_thumb_glue (link_info, h);
2942 case R_ARM_THM_CALL:
2943 /* This one is a call from thumb code. We look
2944 up the target of the call. If it is not a thumb
2945 target, we insert glue. */
2946 if (ELF_ST_TYPE (h->type) != STT_ARM_TFUNC && !globals->use_blx)
2947 record_thumb_to_arm_glue (link_info, h);
2955 if (contents != NULL
2956 && elf_section_data (sec)->this_hdr.contents != contents)
2960 if (internal_relocs != NULL
2961 && elf_section_data (sec)->relocs != internal_relocs)
2962 free (internal_relocs);
2963 internal_relocs = NULL;
2969 if (contents != NULL
2970 && elf_section_data (sec)->this_hdr.contents != contents)
2972 if (internal_relocs != NULL
2973 && elf_section_data (sec)->relocs != internal_relocs)
2974 free (internal_relocs);
2981 /* Set target relocation values needed during linking. */
2984 bfd_elf32_arm_set_target_relocs (struct bfd_link_info *link_info,
2986 char * target2_type,
2990 struct elf32_arm_link_hash_table *globals;
2992 globals = elf32_arm_hash_table (link_info);
2994 globals->target1_is_rel = target1_is_rel;
2995 if (strcmp (target2_type, "rel") == 0)
2996 globals->target2_reloc = R_ARM_REL32;
2997 else if (strcmp (target2_type, "abs") == 0)
2998 globals->target2_reloc = R_ARM_ABS32;
2999 else if (strcmp (target2_type, "got-rel") == 0)
3000 globals->target2_reloc = R_ARM_GOT_PREL;
3003 _bfd_error_handler (_("Invalid TARGET2 relocation type '%s'."),
3006 globals->fix_v4bx = fix_v4bx;
3007 globals->use_blx |= use_blx;
3010 /* The thumb form of a long branch is a bit finicky, because the offset
3011 encoding is split over two fields, each in it's own instruction. They
3012 can occur in any order. So given a thumb form of long branch, and an
3013 offset, insert the offset into the thumb branch and return finished
3016 It takes two thumb instructions to encode the target address. Each has
3017 11 bits to invest. The upper 11 bits are stored in one (identified by
3018 H-0.. see below), the lower 11 bits are stored in the other (identified
3021 Combine together and shifted left by 1 (it's a half word address) and
3025 H-0, upper address-0 = 000
3027 H-1, lower address-0 = 800
3029 They can be ordered either way, but the arm tools I've seen always put
3030 the lower one first. It probably doesn't matter. krk@cygnus.com
3032 XXX: Actually the order does matter. The second instruction (H-1)
3033 moves the computed address into the PC, so it must be the second one
3034 in the sequence. The problem, however is that whilst little endian code
3035 stores the instructions in HI then LOW order, big endian code does the
3036 reverse. nickc@cygnus.com. */
3038 #define LOW_HI_ORDER 0xF800F000
3039 #define HI_LOW_ORDER 0xF000F800
3042 insert_thumb_branch (insn32 br_insn, int rel_off)
3044 unsigned int low_bits;
3045 unsigned int high_bits;
3047 BFD_ASSERT ((rel_off & 1) != 1);
3049 rel_off >>= 1; /* Half word aligned address. */
3050 low_bits = rel_off & 0x000007FF; /* The bottom 11 bits. */
3051 high_bits = (rel_off >> 11) & 0x000007FF; /* The top 11 bits. */
3053 if ((br_insn & LOW_HI_ORDER) == LOW_HI_ORDER)
3054 br_insn = LOW_HI_ORDER | (low_bits << 16) | high_bits;
3055 else if ((br_insn & HI_LOW_ORDER) == HI_LOW_ORDER)
3056 br_insn = HI_LOW_ORDER | (high_bits << 16) | low_bits;
3058 /* FIXME: abort is probably not the right call. krk@cygnus.com */
3059 abort (); /* Error - not a valid branch instruction form. */
3065 /* Store an Arm insn into an output section not processed by
3066 elf32_arm_write_section. */
3069 put_arm_insn (struct elf32_arm_link_hash_table *htab,
3070 bfd * output_bfd, bfd_vma val, void * ptr)
3072 if (htab->byteswap_code != bfd_little_endian (output_bfd))
3073 bfd_putl32 (val, ptr);
3075 bfd_putb32 (val, ptr);
3079 /* Store a 16-bit Thumb insn into an output section not processed by
3080 elf32_arm_write_section. */
3083 put_thumb_insn (struct elf32_arm_link_hash_table *htab,
3084 bfd * output_bfd, bfd_vma val, void * ptr)
3086 if (htab->byteswap_code != bfd_little_endian (output_bfd))
3087 bfd_putl16 (val, ptr);
3089 bfd_putb16 (val, ptr);
3093 /* Thumb code calling an ARM function. */
3096 elf32_thumb_to_arm_stub (struct bfd_link_info * info,
3100 asection * input_section,
3101 bfd_byte * hit_data,
3104 bfd_signed_vma addend,
3109 unsigned long int tmp;
3110 long int ret_offset;
3111 struct elf_link_hash_entry * myh;
3112 struct elf32_arm_link_hash_table * globals;
3114 myh = find_thumb_glue (info, name, input_bfd);
3118 globals = elf32_arm_hash_table (info);
3120 BFD_ASSERT (globals != NULL);
3121 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
3123 my_offset = myh->root.u.def.value;
3125 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
3126 THUMB2ARM_GLUE_SECTION_NAME);
3128 BFD_ASSERT (s != NULL);
3129 BFD_ASSERT (s->contents != NULL);
3130 BFD_ASSERT (s->output_section != NULL);
3132 if ((my_offset & 0x01) == 0x01)
3135 && sym_sec->owner != NULL
3136 && !INTERWORK_FLAG (sym_sec->owner))
3138 (*_bfd_error_handler)
3139 (_("%B(%s): warning: interworking not enabled.\n"
3140 " first occurrence: %B: thumb call to arm"),
3141 sym_sec->owner, input_bfd, name);
3147 myh->root.u.def.value = my_offset;
3149 put_thumb_insn (globals, output_bfd, (bfd_vma) t2a1_bx_pc_insn,
3150 s->contents + my_offset);
3152 put_thumb_insn (globals, output_bfd, (bfd_vma) t2a2_noop_insn,
3153 s->contents + my_offset + 2);
3156 /* Address of destination of the stub. */
3157 ((bfd_signed_vma) val)
3159 /* Offset from the start of the current section
3160 to the start of the stubs. */
3162 /* Offset of the start of this stub from the start of the stubs. */
3164 /* Address of the start of the current section. */
3165 + s->output_section->vma)
3166 /* The branch instruction is 4 bytes into the stub. */
3168 /* ARM branches work from the pc of the instruction + 8. */
3171 put_arm_insn (globals, output_bfd,
3172 (bfd_vma) t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
3173 s->contents + my_offset + 4);
3176 BFD_ASSERT (my_offset <= globals->thumb_glue_size);
3178 /* Now go back and fix up the original BL insn to point to here. */
3180 /* Address of where the stub is located. */
3181 (s->output_section->vma + s->output_offset + my_offset)
3182 /* Address of where the BL is located. */
3183 - (input_section->output_section->vma + input_section->output_offset
3185 /* Addend in the relocation. */
3187 /* Biassing for PC-relative addressing. */
3190 tmp = bfd_get_32 (input_bfd, hit_data
3191 - input_section->vma);
3193 bfd_put_32 (output_bfd,
3194 (bfd_vma) insert_thumb_branch (tmp, ret_offset),
3195 hit_data - input_section->vma);
3200 /* Populate an Arm to Thumb stub. Returns the stub symbol. */
3202 static struct elf_link_hash_entry *
3203 elf32_arm_create_thumb_stub (struct bfd_link_info * info,
3212 long int ret_offset;
3213 struct elf_link_hash_entry * myh;
3214 struct elf32_arm_link_hash_table * globals;
3216 myh = find_arm_glue (info, name, input_bfd);
3220 globals = elf32_arm_hash_table (info);
3222 BFD_ASSERT (globals != NULL);
3223 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
3225 my_offset = myh->root.u.def.value;
3227 if ((my_offset & 0x01) == 0x01)
3230 && sym_sec->owner != NULL
3231 && !INTERWORK_FLAG (sym_sec->owner))
3233 (*_bfd_error_handler)
3234 (_("%B(%s): warning: interworking not enabled.\n"
3235 " first occurrence: %B: arm call to thumb"),
3236 sym_sec->owner, input_bfd, name);
3240 myh->root.u.def.value = my_offset;
3242 if ((info->shared || globals->root.is_relocatable_executable))
3244 /* For relocatable objects we can't use absolute addresses,
3245 so construct the address from a relative offset. */
3246 /* TODO: If the offset is small it's probably worth
3247 constructing the address with adds. */
3248 put_arm_insn (globals, output_bfd, (bfd_vma) a2t1p_ldr_insn,
3249 s->contents + my_offset);
3250 put_arm_insn (globals, output_bfd, (bfd_vma) a2t2p_add_pc_insn,
3251 s->contents + my_offset + 4);
3252 put_arm_insn (globals, output_bfd, (bfd_vma) a2t3p_bx_r12_insn,
3253 s->contents + my_offset + 8);
3254 /* Adjust the offset by 4 for the position of the add,
3255 and 8 for the pipeline offset. */
3256 ret_offset = (val - (s->output_offset
3257 + s->output_section->vma
3260 bfd_put_32 (output_bfd, ret_offset,
3261 s->contents + my_offset + 12);
3265 put_arm_insn (globals, output_bfd, (bfd_vma) a2t1_ldr_insn,
3266 s->contents + my_offset);
3268 put_arm_insn (globals, output_bfd, (bfd_vma) a2t2_bx_r12_insn,
3269 s->contents + my_offset + 4);
3271 /* It's a thumb address. Add the low order bit. */
3272 bfd_put_32 (output_bfd, val | a2t3_func_addr_insn,
3273 s->contents + my_offset + 8);
3277 BFD_ASSERT (my_offset <= globals->arm_glue_size);
3282 /* Arm code calling a Thumb function. */
3285 elf32_arm_to_thumb_stub (struct bfd_link_info * info,
3289 asection * input_section,
3290 bfd_byte * hit_data,
3293 bfd_signed_vma addend,
3296 unsigned long int tmp;
3299 long int ret_offset;
3300 struct elf_link_hash_entry * myh;
3301 struct elf32_arm_link_hash_table * globals;
3303 globals = elf32_arm_hash_table (info);
3305 BFD_ASSERT (globals != NULL);
3306 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
3308 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
3309 ARM2THUMB_GLUE_SECTION_NAME);
3310 BFD_ASSERT (s != NULL);
3311 BFD_ASSERT (s->contents != NULL);
3312 BFD_ASSERT (s->output_section != NULL);
3314 myh = elf32_arm_create_thumb_stub (info, name, input_bfd, output_bfd,
3319 my_offset = myh->root.u.def.value;
3320 tmp = bfd_get_32 (input_bfd, hit_data);
3321 tmp = tmp & 0xFF000000;
3323 /* Somehow these are both 4 too far, so subtract 8. */
3324 ret_offset = (s->output_offset
3326 + s->output_section->vma
3327 - (input_section->output_offset
3328 + input_section->output_section->vma
3332 tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
3334 bfd_put_32 (output_bfd, (bfd_vma) tmp, hit_data - input_section->vma);
3339 /* Populate Arm stub for an exported Thumb function. */
3342 elf32_arm_to_thumb_export_stub (struct elf_link_hash_entry *h, void * inf)
3344 struct bfd_link_info * info = (struct bfd_link_info *) inf;
3346 struct elf_link_hash_entry * myh;
3347 struct elf32_arm_link_hash_entry *eh;
3348 struct elf32_arm_link_hash_table * globals;
3352 eh = elf32_arm_hash_entry(h);
3353 /* Allocate stubs for exported Thumb functions on v4t. */
3354 if (eh->export_glue == NULL)
3357 globals = elf32_arm_hash_table (info);
3359 BFD_ASSERT (globals != NULL);
3360 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
3362 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
3363 ARM2THUMB_GLUE_SECTION_NAME);
3364 BFD_ASSERT (s != NULL);
3365 BFD_ASSERT (s->contents != NULL);
3366 BFD_ASSERT (s->output_section != NULL);
3368 sec = eh->export_glue->root.u.def.section;
3369 val = eh->export_glue->root.u.def.value + sec->output_offset
3370 + sec->output_section->vma;
3371 myh = elf32_arm_create_thumb_stub (info, h->root.root.string,
3372 h->root.u.def.section->owner,
3373 globals->obfd, sec, val, s);
3378 /* Generate Arm stubs for exported Thumb symbols. */
3380 elf32_arm_begin_write_processing (bfd *abfd ATTRIBUTE_UNUSED,
3381 struct bfd_link_info *link_info)
3383 struct elf32_arm_link_hash_table * globals;
3388 globals = elf32_arm_hash_table (link_info);
3389 if (globals->use_blx)
3392 elf_link_hash_traverse (&globals->root, elf32_arm_to_thumb_export_stub,
3396 /* Some relocations map to different relocations depending on the
3397 target. Return the real relocation. */
3399 arm_real_reloc_type (struct elf32_arm_link_hash_table * globals,
3405 if (globals->target1_is_rel)
3411 return globals->target2_reloc;
3418 /* Return the base VMA address which should be subtracted from real addresses
3419 when resolving @dtpoff relocation.
3420 This is PT_TLS segment p_vaddr. */
3423 dtpoff_base (struct bfd_link_info *info)
3425 /* If tls_sec is NULL, we should have signalled an error already. */
3426 if (elf_hash_table (info)->tls_sec == NULL)
3428 return elf_hash_table (info)->tls_sec->vma;
3431 /* Return the relocation value for @tpoff relocation
3432 if STT_TLS virtual address is ADDRESS. */
3435 tpoff (struct bfd_link_info *info, bfd_vma address)
3437 struct elf_link_hash_table *htab = elf_hash_table (info);
3440 /* If tls_sec is NULL, we should have signalled an error already. */
3441 if (htab->tls_sec == NULL)
3443 base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power);
3444 return address - htab->tls_sec->vma + base;
3447 /* Perform an R_ARM_ABS12 relocation on the field pointed to by DATA.
3448 VALUE is the relocation value. */
3450 static bfd_reloc_status_type
3451 elf32_arm_abs12_reloc (bfd *abfd, void *data, bfd_vma value)
3454 return bfd_reloc_overflow;
3456 value |= bfd_get_32 (abfd, data) & 0xfffff000;
3457 bfd_put_32 (abfd, value, data);
3458 return bfd_reloc_ok;
3461 /* For a given value of n, calculate the value of G_n as required to
3462 deal with group relocations. We return it in the form of an
3463 encoded constant-and-rotation, together with the final residual. If n is
3464 specified as less than zero, then final_residual is filled with the
3465 input value and no further action is performed. */
3468 calculate_group_reloc_mask (bfd_vma value, int n, bfd_vma *final_residual)
3472 bfd_vma encoded_g_n = 0;
3473 bfd_vma residual = value; /* Also known as Y_n. */
3475 for (current_n = 0; current_n <= n; current_n++)
3479 /* Calculate which part of the value to mask. */
3486 /* Determine the most significant bit in the residual and
3487 align the resulting value to a 2-bit boundary. */
3488 for (msb = 30; msb >= 0; msb -= 2)
3489 if (residual & (3 << msb))
3492 /* The desired shift is now (msb - 6), or zero, whichever
3499 /* Calculate g_n in 32-bit as well as encoded constant+rotation form. */
3500 g_n = residual & (0xff << shift);
3501 encoded_g_n = (g_n >> shift)
3502 | ((g_n <= 0xff ? 0 : (32 - shift) / 2) << 8);
3504 /* Calculate the residual for the next time around. */
3508 *final_residual = residual;
3513 /* Given an ARM instruction, determine whether it is an ADD or a SUB.
3514 Returns 1 if it is an ADD, -1 if it is a SUB, and 0 otherwise. */
3516 identify_add_or_sub(bfd_vma insn)
3518 int opcode = insn & 0x1e00000;
3520 if (opcode == 1 << 23) /* ADD */
3523 if (opcode == 1 << 22) /* SUB */
3529 /* Determine if we're dealing with a Thumb-2 object. */
3531 static int using_thumb2 (struct elf32_arm_link_hash_table *globals)
3533 int arch = elf32_arm_get_eabi_attr_int (globals->obfd, Tag_CPU_arch);
3534 return arch == TAG_CPU_ARCH_V6T2 || arch >= TAG_CPU_ARCH_V7;
3537 /* Perform a relocation as part of a final link. */
3539 static bfd_reloc_status_type
3540 elf32_arm_final_link_relocate (reloc_howto_type * howto,
3543 asection * input_section,
3544 bfd_byte * contents,
3545 Elf_Internal_Rela * rel,
3547 struct bfd_link_info * info,
3549 const char * sym_name,
3551 struct elf_link_hash_entry * h,
3552 bfd_boolean * unresolved_reloc_p)
3554 unsigned long r_type = howto->type;
3555 unsigned long r_symndx;
3556 bfd_byte * hit_data = contents + rel->r_offset;
3557 bfd * dynobj = NULL;
3558 Elf_Internal_Shdr * symtab_hdr;
3559 struct elf_link_hash_entry ** sym_hashes;
3560 bfd_vma * local_got_offsets;
3561 asection * sgot = NULL;
3562 asection * splt = NULL;
3563 asection * sreloc = NULL;
3565 bfd_signed_vma signed_addend;
3566 struct elf32_arm_link_hash_table * globals;
3568 globals = elf32_arm_hash_table (info);
3570 /* Some relocation type map to different relocations depending on the
3571 target. We pick the right one here. */
3572 r_type = arm_real_reloc_type (globals, r_type);
3573 if (r_type != howto->type)
3574 howto = elf32_arm_howto_from_type (r_type);
3576 /* If the start address has been set, then set the EF_ARM_HASENTRY
3577 flag. Setting this more than once is redundant, but the cost is
3578 not too high, and it keeps the code simple.
3580 The test is done here, rather than somewhere else, because the
3581 start address is only set just before the final link commences.
3583 Note - if the user deliberately sets a start address of 0, the
3584 flag will not be set. */
3585 if (bfd_get_start_address (output_bfd) != 0)
3586 elf_elfheader (output_bfd)->e_flags |= EF_ARM_HASENTRY;
3588 dynobj = elf_hash_table (info)->dynobj;
3591 sgot = bfd_get_section_by_name (dynobj, ".got");
3592 splt = bfd_get_section_by_name (dynobj, ".plt");
3594 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
3595 sym_hashes = elf_sym_hashes (input_bfd);
3596 local_got_offsets = elf_local_got_offsets (input_bfd);
3597 r_symndx = ELF32_R_SYM (rel->r_info);
3599 if (globals->use_rel)
3601 addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask;
3603 if (addend & ((howto->src_mask + 1) >> 1))
3606 signed_addend &= ~ howto->src_mask;
3607 signed_addend |= addend;
3610 signed_addend = addend;
3613 addend = signed_addend = rel->r_addend;
3618 /* We don't need to find a value for this symbol. It's just a
3620 *unresolved_reloc_p = FALSE;
3621 return bfd_reloc_ok;
3624 if (!globals->vxworks_p)
3625 return elf32_arm_abs12_reloc (input_bfd, hit_data, value + addend);
3629 case R_ARM_ABS32_NOI:
3631 case R_ARM_REL32_NOI:
3637 /* r_symndx will be zero only for relocs against symbols
3638 from removed linkonce sections, or sections discarded by
3641 return bfd_reloc_ok;
3643 /* Handle relocations which should use the PLT entry. ABS32/REL32
3644 will use the symbol's value, which may point to a PLT entry, but we
3645 don't need to handle that here. If we created a PLT entry, all
3646 branches in this object should go to it. */
3647 if ((r_type != R_ARM_ABS32 && r_type != R_ARM_REL32
3648 && r_type != R_ARM_ABS32_NOI && r_type != R_ARM_REL32_NOI)
3651 && h->plt.offset != (bfd_vma) -1)
3653 /* If we've created a .plt section, and assigned a PLT entry to
3654 this function, it should not be known to bind locally. If
3655 it were, we would have cleared the PLT entry. */
3656 BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info, h));
3658 value = (splt->output_section->vma
3659 + splt->output_offset
3661 *unresolved_reloc_p = FALSE;
3662 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3663 contents, rel->r_offset, value,
3667 /* When generating a shared object or relocatable executable, these
3668 relocations are copied into the output file to be resolved at
3670 if ((info->shared || globals->root.is_relocatable_executable)
3671 && (input_section->flags & SEC_ALLOC)
3672 && ((r_type != R_ARM_REL32 && r_type != R_ARM_REL32_NOI)
3673 || !SYMBOL_CALLS_LOCAL (info, h))
3675 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3676 || h->root.type != bfd_link_hash_undefweak)
3677 && r_type != R_ARM_PC24
3678 && r_type != R_ARM_CALL
3679 && r_type != R_ARM_JUMP24
3680 && r_type != R_ARM_PREL31
3681 && r_type != R_ARM_PLT32)
3683 Elf_Internal_Rela outrel;
3685 bfd_boolean skip, relocate;
3687 *unresolved_reloc_p = FALSE;
3693 name = (bfd_elf_string_from_elf_section
3695 elf_elfheader (input_bfd)->e_shstrndx,
3696 elf_section_data (input_section)->rel_hdr.sh_name));
3698 return bfd_reloc_notsupported;
3700 BFD_ASSERT (reloc_section_p (globals, name, input_section));
3702 sreloc = bfd_get_section_by_name (dynobj, name);
3703 BFD_ASSERT (sreloc != NULL);
3709 outrel.r_addend = addend;
3711 _bfd_elf_section_offset (output_bfd, info, input_section,
3713 if (outrel.r_offset == (bfd_vma) -1)
3715 else if (outrel.r_offset == (bfd_vma) -2)
3716 skip = TRUE, relocate = TRUE;
3717 outrel.r_offset += (input_section->output_section->vma
3718 + input_section->output_offset);
3721 memset (&outrel, 0, sizeof outrel);
3726 || !h->def_regular))
3727 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3732 /* This symbol is local, or marked to become local. */
3733 if (sym_flags == STT_ARM_TFUNC)
3735 if (globals->symbian_p)
3737 /* On Symbian OS, the data segment and text segement
3738 can be relocated independently. Therefore, we
3739 must indicate the segment to which this
3740 relocation is relative. The BPABI allows us to
3741 use any symbol in the right segment; we just use
3742 the section symbol as it is convenient. (We
3743 cannot use the symbol given by "h" directly as it
3744 will not appear in the dynamic symbol table.) */
3746 symbol = elf_section_data (sym_sec->output_section)->dynindx;
3748 symbol = elf_section_data (input_section->output_section)->dynindx;
3749 BFD_ASSERT (symbol != 0);
3752 /* On SVR4-ish systems, the dynamic loader cannot
3753 relocate the text and data segments independently,
3754 so the symbol does not matter. */
3756 outrel.r_info = ELF32_R_INFO (symbol, R_ARM_RELATIVE);
3757 if (globals->use_rel)
3760 outrel.r_addend += value;
3763 loc = sreloc->contents;
3764 loc += sreloc->reloc_count++ * RELOC_SIZE (globals);
3765 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
3767 /* If this reloc is against an external symbol, we do not want to
3768 fiddle with the addend. Otherwise, we need to include the symbol
3769 value so that it becomes an addend for the dynamic reloc. */
3771 return bfd_reloc_ok;
3773 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3774 contents, rel->r_offset, value,
3777 else switch (r_type)
3780 return elf32_arm_abs12_reloc (input_bfd, hit_data, value + addend);
3782 case R_ARM_XPC25: /* Arm BLX instruction. */
3785 case R_ARM_PC24: /* Arm B/BL instruction */
3787 if (r_type == R_ARM_XPC25)
3789 /* Check for Arm calling Arm function. */
3790 /* FIXME: Should we translate the instruction into a BL
3791 instruction instead ? */
3792 if (sym_flags != STT_ARM_TFUNC)
3793 (*_bfd_error_handler)
3794 (_("\%B: Warning: Arm BLX instruction targets Arm function '%s'."),
3796 h ? h->root.root.string : "(local)");
3798 else if (r_type != R_ARM_CALL || !globals->use_blx)
3800 /* Check for Arm calling Thumb function. */
3801 if (sym_flags == STT_ARM_TFUNC)
3803 elf32_arm_to_thumb_stub (info, sym_name, input_bfd,
3804 output_bfd, input_section,
3805 hit_data, sym_sec, rel->r_offset,
3806 signed_addend, value);
3807 return bfd_reloc_ok;
3811 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
3813 S is the address of the symbol in the relocation.
3814 P is address of the instruction being relocated.
3815 A is the addend (extracted from the instruction) in bytes.
3817 S is held in 'value'.
3818 P is the base address of the section containing the
3819 instruction plus the offset of the reloc into that
3821 (input_section->output_section->vma +
3822 input_section->output_offset +
3824 A is the addend, converted into bytes, ie:
3827 Note: None of these operations have knowledge of the pipeline
3828 size of the processor, thus it is up to the assembler to
3829 encode this information into the addend. */
3830 value -= (input_section->output_section->vma
3831 + input_section->output_offset);
3832 value -= rel->r_offset;
3833 if (globals->use_rel)
3834 value += (signed_addend << howto->size);
3836 /* RELA addends do not have to be adjusted by howto->size. */
3837 value += signed_addend;
3839 signed_addend = value;
3840 signed_addend >>= howto->rightshift;
3842 /* It is not an error for an undefined weak reference to be
3843 out of range. Any program that branches to such a symbol
3844 is going to crash anyway, so there is no point worrying
3845 about getting the destination exactly right. */
3846 if (! h || h->root.type != bfd_link_hash_undefweak)
3848 /* Perform a signed range check. */
3849 if ( signed_addend > ((bfd_signed_vma) (howto->dst_mask >> 1))
3850 || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1)))
3851 return bfd_reloc_overflow;
3854 addend = (value & 2);
3856 value = (signed_addend & howto->dst_mask)
3857 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
3859 /* Set the H bit in the BLX instruction. */
3860 if (sym_flags == STT_ARM_TFUNC)
3865 value &= ~(bfd_vma)(1 << 24);
3867 if (r_type == R_ARM_CALL)
3869 /* Select the correct instruction (BL or BLX). */
3870 if (sym_flags == STT_ARM_TFUNC)
3874 value &= ~(bfd_vma)(1 << 28);
3882 if (sym_flags == STT_ARM_TFUNC)
3886 case R_ARM_ABS32_NOI:
3892 if (sym_flags == STT_ARM_TFUNC)
3894 value -= (input_section->output_section->vma
3895 + input_section->output_offset + rel->r_offset);
3898 case R_ARM_REL32_NOI:
3900 value -= (input_section->output_section->vma
3901 + input_section->output_offset + rel->r_offset);
3905 value -= (input_section->output_section->vma
3906 + input_section->output_offset + rel->r_offset);
3907 value += signed_addend;
3908 if (! h || h->root.type != bfd_link_hash_undefweak)
3910 /* Check for overflow */
3911 if ((value ^ (value >> 1)) & (1 << 30))
3912 return bfd_reloc_overflow;
3914 value &= 0x7fffffff;
3915 value |= (bfd_get_32 (input_bfd, hit_data) & 0x80000000);
3916 if (sym_flags == STT_ARM_TFUNC)
3921 bfd_put_32 (input_bfd, value, hit_data);
3922 return bfd_reloc_ok;
3926 if ((long) value > 0x7f || (long) value < -0x80)
3927 return bfd_reloc_overflow;
3929 bfd_put_8 (input_bfd, value, hit_data);
3930 return bfd_reloc_ok;
3935 if ((long) value > 0x7fff || (long) value < -0x8000)
3936 return bfd_reloc_overflow;
3938 bfd_put_16 (input_bfd, value, hit_data);
3939 return bfd_reloc_ok;
3941 case R_ARM_THM_ABS5:
3942 /* Support ldr and str instructions for the thumb. */
3943 if (globals->use_rel)
3945 /* Need to refetch addend. */
3946 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
3947 /* ??? Need to determine shift amount from operand size. */
3948 addend >>= howto->rightshift;
3952 /* ??? Isn't value unsigned? */
3953 if ((long) value > 0x1f || (long) value < -0x10)
3954 return bfd_reloc_overflow;
3956 /* ??? Value needs to be properly shifted into place first. */
3957 value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
3958 bfd_put_16 (input_bfd, value, hit_data);
3959 return bfd_reloc_ok;
3961 case R_ARM_THM_ALU_PREL_11_0:
3962 /* Corresponds to: addw.w reg, pc, #offset (and similarly for subw). */
3965 bfd_signed_vma relocation;
3967 insn = (bfd_get_16 (input_bfd, hit_data) << 16)
3968 | bfd_get_16 (input_bfd, hit_data + 2);
3970 if (globals->use_rel)
3972 signed_addend = (insn & 0xff) | ((insn & 0x7000) >> 4)
3973 | ((insn & (1 << 26)) >> 15);
3974 if (insn & 0xf00000)
3975 signed_addend = -signed_addend;
3978 relocation = value + signed_addend;
3979 relocation -= (input_section->output_section->vma
3980 + input_section->output_offset
3983 value = abs (relocation);
3985 if (value >= 0x1000)
3986 return bfd_reloc_overflow;
3988 insn = (insn & 0xfb0f8f00) | (value & 0xff)
3989 | ((value & 0x700) << 4)
3990 | ((value & 0x800) << 15);
3994 bfd_put_16 (input_bfd, insn >> 16, hit_data);
3995 bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2);
3997 return bfd_reloc_ok;
4000 case R_ARM_THM_PC12:
4001 /* Corresponds to: ldr.w reg, [pc, #offset]. */
4004 bfd_signed_vma relocation;
4006 insn = (bfd_get_16 (input_bfd, hit_data) << 16)
4007 | bfd_get_16 (input_bfd, hit_data + 2);
4009 if (globals->use_rel)
4011 signed_addend = insn & 0xfff;
4012 if (!(insn & (1 << 23)))
4013 signed_addend = -signed_addend;
4016 relocation = value + signed_addend;
4017 relocation -= (input_section->output_section->vma
4018 + input_section->output_offset
4021 value = abs (relocation);
4023 if (value >= 0x1000)
4024 return bfd_reloc_overflow;
4026 insn = (insn & 0xff7ff000) | value;
4027 if (relocation >= 0)
4030 bfd_put_16 (input_bfd, insn >> 16, hit_data);
4031 bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2);
4033 return bfd_reloc_ok;
4036 case R_ARM_THM_XPC22:
4037 case R_ARM_THM_CALL:
4038 /* Thumb BL (branch long instruction). */
4042 bfd_boolean overflow = FALSE;
4043 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
4044 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
4045 bfd_signed_vma reloc_signed_max;
4046 bfd_signed_vma reloc_signed_min;
4048 bfd_signed_vma signed_check;
4050 int thumb2 = using_thumb2 (globals);
4052 /* Fetch the addend. We use the Thumb-2 encoding (backwards compatible
4053 with Thumb-1) involving the J1 and J2 bits. */
4054 if (globals->use_rel)
4056 bfd_vma s = (upper_insn & (1 << 10)) >> 10;
4057 bfd_vma upper = upper_insn & 0x3ff;
4058 bfd_vma lower = lower_insn & 0x7ff;
4059 bfd_vma j1 = (lower_insn & (1 << 13)) >> 13;
4060 bfd_vma j2 = (lower_insn & (1 << 11)) >> 11;
4061 bfd_vma i1 = j1 ^ s ? 0 : 1;
4062 bfd_vma i2 = j2 ^ s ? 0 : 1;
4064 addend = (i1 << 23) | (i2 << 22) | (upper << 12) | (lower << 1);
4066 addend = (addend | ((s ? 0 : 1) << 24)) - (1 << 24);
4068 signed_addend = addend;
4071 if (r_type == R_ARM_THM_XPC22)
4073 /* Check for Thumb to Thumb call. */
4074 /* FIXME: Should we translate the instruction into a BL
4075 instruction instead ? */
4076 if (sym_flags == STT_ARM_TFUNC)
4077 (*_bfd_error_handler)
4078 (_("%B: Warning: Thumb BLX instruction targets thumb function '%s'."),
4080 h ? h->root.root.string : "(local)");
4084 /* If it is not a call to Thumb, assume call to Arm.
4085 If it is a call relative to a section name, then it is not a
4086 function call at all, but rather a long jump. Calls through
4087 the PLT do not require stubs. */
4088 if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION
4089 && (h == NULL || splt == NULL
4090 || h->plt.offset == (bfd_vma) -1))
4092 if (globals->use_blx)
4094 /* Convert BL to BLX. */
4095 lower_insn = (lower_insn & ~0x1000) | 0x0800;
4097 else if (elf32_thumb_to_arm_stub
4098 (info, sym_name, input_bfd, output_bfd, input_section,
4099 hit_data, sym_sec, rel->r_offset, signed_addend, value))
4100 return bfd_reloc_ok;
4102 return bfd_reloc_dangerous;
4104 else if (sym_flags == STT_ARM_TFUNC && globals->use_blx)
4106 /* Make sure this is a BL. */
4107 lower_insn |= 0x1800;
4111 /* Handle calls via the PLT. */
4112 if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
4114 value = (splt->output_section->vma
4115 + splt->output_offset
4117 if (globals->use_blx)
4119 /* If the Thumb BLX instruction is available, convert the
4120 BL to a BLX instruction to call the ARM-mode PLT entry. */
4121 lower_insn = (lower_insn & ~0x1000) | 0x0800;
4124 /* Target the Thumb stub before the ARM PLT entry. */
4125 value -= PLT_THUMB_STUB_SIZE;
4126 *unresolved_reloc_p = FALSE;
4129 relocation = value + signed_addend;
4131 relocation -= (input_section->output_section->vma
4132 + input_section->output_offset
4135 check = relocation >> howto->rightshift;
4137 /* If this is a signed value, the rightshift just dropped
4138 leading 1 bits (assuming twos complement). */
4139 if ((bfd_signed_vma) relocation >= 0)
4140 signed_check = check;
4142 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
4144 /* Calculate the permissable maximum and minimum values for
4145 this relocation according to whether we're relocating for
4147 bitsize = howto->bitsize;
4150 reloc_signed_max = ((1 << (bitsize - 1)) - 1) >> howto->rightshift;
4151 reloc_signed_min = ~reloc_signed_max;
4153 /* Assumes two's complement. */
4154 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
4157 if ((lower_insn & 0x1800) == 0x0800)
4158 /* For a BLX instruction, make sure that the relocation is rounded up
4159 to a word boundary. This follows the semantics of the instruction
4160 which specifies that bit 1 of the target address will come from bit
4161 1 of the base address. */
4162 relocation = (relocation + 2) & ~ 3;
4164 /* Put RELOCATION back into the insn. Assumes two's complement.
4165 We use the Thumb-2 encoding, which is safe even if dealing with
4166 a Thumb-1 instruction by virtue of our overflow check above. */
4167 reloc_sign = (signed_check < 0) ? 1 : 0;
4168 upper_insn = (upper_insn & ~(bfd_vma) 0x7ff)
4169 | ((relocation >> 12) & 0x3ff)
4170 | (reloc_sign << 10);
4171 lower_insn = (lower_insn & ~(bfd_vma) 0x2fff)
4172 | (((!((relocation >> 23) & 1)) ^ reloc_sign) << 13)
4173 | (((!((relocation >> 22) & 1)) ^ reloc_sign) << 11)
4174 | ((relocation >> 1) & 0x7ff);
4176 /* Put the relocated value back in the object file: */
4177 bfd_put_16 (input_bfd, upper_insn, hit_data);
4178 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
4180 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
4184 case R_ARM_THM_JUMP24:
4185 /* Thumb32 unconditional branch instruction. */
4188 bfd_boolean overflow = FALSE;
4189 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
4190 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
4191 bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
4192 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
4194 bfd_signed_vma signed_check;
4196 /* Need to refetch the addend, reconstruct the top three bits, and glue the
4197 two pieces together. */
4198 if (globals->use_rel)
4200 bfd_vma S = (upper_insn & 0x0400) >> 10;
4201 bfd_vma hi = (upper_insn & 0x03ff);
4202 bfd_vma I1 = (lower_insn & 0x2000) >> 13;
4203 bfd_vma I2 = (lower_insn & 0x0800) >> 11;
4204 bfd_vma lo = (lower_insn & 0x07ff);
4210 signed_addend = (S << 24) | (I1 << 23) | (I2 << 22) | (hi << 12) | (lo << 1);
4211 signed_addend -= (1 << 24); /* Sign extend. */
4214 /* ??? Should handle interworking? GCC might someday try to
4215 use this for tail calls. */
4217 relocation = value + signed_addend;
4218 relocation -= (input_section->output_section->vma
4219 + input_section->output_offset
4222 check = relocation >> howto->rightshift;
4224 /* If this is a signed value, the rightshift just dropped
4225 leading 1 bits (assuming twos complement). */
4226 if ((bfd_signed_vma) relocation >= 0)
4227 signed_check = check;
4229 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
4231 /* Assumes two's complement. */
4232 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
4235 /* Put RELOCATION back into the insn. */
4237 bfd_vma S = (relocation & 0x01000000) >> 24;
4238 bfd_vma I1 = (relocation & 0x00800000) >> 23;
4239 bfd_vma I2 = (relocation & 0x00400000) >> 22;
4240 bfd_vma hi = (relocation & 0x003ff000) >> 12;
4241 bfd_vma lo = (relocation & 0x00000ffe) >> 1;
4246 upper_insn = (upper_insn & (bfd_vma) 0xf800) | (S << 10) | hi;
4247 lower_insn = (lower_insn & (bfd_vma) 0xd000) | (I1 << 13) | (I2 << 11) | lo;
4250 /* Put the relocated value back in the object file: */
4251 bfd_put_16 (input_bfd, upper_insn, hit_data);
4252 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
4254 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
4257 case R_ARM_THM_JUMP19:
4258 /* Thumb32 conditional branch instruction. */
4261 bfd_boolean overflow = FALSE;
4262 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
4263 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
4264 bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
4265 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
4267 bfd_signed_vma signed_check;
4269 /* Need to refetch the addend, reconstruct the top three bits,
4270 and squish the two 11 bit pieces together. */
4271 if (globals->use_rel)
4273 bfd_vma S = (upper_insn & 0x0400) >> 10;
4274 bfd_vma upper = (upper_insn & 0x001f);
4275 bfd_vma J1 = (lower_insn & 0x2000) >> 13;
4276 bfd_vma J2 = (lower_insn & 0x0800) >> 11;
4277 bfd_vma lower = (lower_insn & 0x07ff);
4282 upper -= 0x0100; /* Sign extend. */
4284 addend = (upper << 12) | (lower << 1);
4285 signed_addend = addend;
4288 /* ??? Should handle interworking? GCC might someday try to
4289 use this for tail calls. */
4291 relocation = value + signed_addend;
4292 relocation -= (input_section->output_section->vma
4293 + input_section->output_offset
4296 check = relocation >> howto->rightshift;
4298 /* If this is a signed value, the rightshift just dropped
4299 leading 1 bits (assuming twos complement). */
4300 if ((bfd_signed_vma) relocation >= 0)
4301 signed_check = check;
4303 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
4305 /* Assumes two's complement. */
4306 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
4309 /* Put RELOCATION back into the insn. */
4311 bfd_vma S = (relocation & 0x00100000) >> 20;
4312 bfd_vma J2 = (relocation & 0x00080000) >> 19;
4313 bfd_vma J1 = (relocation & 0x00040000) >> 18;
4314 bfd_vma hi = (relocation & 0x0003f000) >> 12;
4315 bfd_vma lo = (relocation & 0x00000ffe) >> 1;
4317 upper_insn = (upper_insn & 0xfb30) | (S << 10) | hi;
4318 lower_insn = (lower_insn & 0xd000) | (J1 << 13) | (J2 << 11) | lo;
4321 /* Put the relocated value back in the object file: */
4322 bfd_put_16 (input_bfd, upper_insn, hit_data);
4323 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
4325 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
4328 case R_ARM_THM_JUMP11:
4329 case R_ARM_THM_JUMP8:
4330 case R_ARM_THM_JUMP6:
4331 /* Thumb B (branch) instruction). */
4333 bfd_signed_vma relocation;
4334 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
4335 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
4336 bfd_signed_vma signed_check;
4338 /* CZB cannot jump backward. */
4339 if (r_type == R_ARM_THM_JUMP6)
4340 reloc_signed_min = 0;
4342 if (globals->use_rel)
4344 /* Need to refetch addend. */
4345 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
4346 if (addend & ((howto->src_mask + 1) >> 1))
4349 signed_addend &= ~ howto->src_mask;
4350 signed_addend |= addend;
4353 signed_addend = addend;
4354 /* The value in the insn has been right shifted. We need to
4355 undo this, so that we can perform the address calculation
4356 in terms of bytes. */
4357 signed_addend <<= howto->rightshift;
4359 relocation = value + signed_addend;
4361 relocation -= (input_section->output_section->vma
4362 + input_section->output_offset
4365 relocation >>= howto->rightshift;
4366 signed_check = relocation;
4368 if (r_type == R_ARM_THM_JUMP6)
4369 relocation = ((relocation & 0x0020) << 4) | ((relocation & 0x001f) << 3);
4371 relocation &= howto->dst_mask;
4372 relocation |= (bfd_get_16 (input_bfd, hit_data) & (~ howto->dst_mask));
4374 bfd_put_16 (input_bfd, relocation, hit_data);
4376 /* Assumes two's complement. */
4377 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
4378 return bfd_reloc_overflow;
4380 return bfd_reloc_ok;
4383 case R_ARM_ALU_PCREL7_0:
4384 case R_ARM_ALU_PCREL15_8:
4385 case R_ARM_ALU_PCREL23_15:
4390 insn = bfd_get_32 (input_bfd, hit_data);
4391 if (globals->use_rel)
4393 /* Extract the addend. */
4394 addend = (insn & 0xff) << ((insn & 0xf00) >> 7);
4395 signed_addend = addend;
4397 relocation = value + signed_addend;
4399 relocation -= (input_section->output_section->vma
4400 + input_section->output_offset
4402 insn = (insn & ~0xfff)
4403 | ((howto->bitpos << 7) & 0xf00)
4404 | ((relocation >> howto->bitpos) & 0xff);
4405 bfd_put_32 (input_bfd, value, hit_data);
4407 return bfd_reloc_ok;
4409 case R_ARM_GNU_VTINHERIT:
4410 case R_ARM_GNU_VTENTRY:
4411 return bfd_reloc_ok;
4413 case R_ARM_GOTOFF32:
4414 /* Relocation is relative to the start of the
4415 global offset table. */
4417 BFD_ASSERT (sgot != NULL);
4419 return bfd_reloc_notsupported;
4421 /* If we are addressing a Thumb function, we need to adjust the
4422 address by one, so that attempts to call the function pointer will
4423 correctly interpret it as Thumb code. */
4424 if (sym_flags == STT_ARM_TFUNC)
4427 /* Note that sgot->output_offset is not involved in this
4428 calculation. We always want the start of .got. If we
4429 define _GLOBAL_OFFSET_TABLE in a different way, as is
4430 permitted by the ABI, we might have to change this
4432 value -= sgot->output_section->vma;
4433 return _bfd_final_link_relocate (howto, input_bfd, input_section,
4434 contents, rel->r_offset, value,
4438 /* Use global offset table as symbol value. */
4439 BFD_ASSERT (sgot != NULL);
4442 return bfd_reloc_notsupported;
4444 *unresolved_reloc_p = FALSE;
4445 value = sgot->output_section->vma;
4446 return _bfd_final_link_relocate (howto, input_bfd, input_section,
4447 contents, rel->r_offset, value,
4451 case R_ARM_GOT_PREL:
4452 /* Relocation is to the entry for this symbol in the
4453 global offset table. */
4455 return bfd_reloc_notsupported;
4462 off = h->got.offset;
4463 BFD_ASSERT (off != (bfd_vma) -1);
4464 dyn = globals->root.dynamic_sections_created;
4466 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
4468 && SYMBOL_REFERENCES_LOCAL (info, h))
4469 || (ELF_ST_VISIBILITY (h->other)
4470 && h->root.type == bfd_link_hash_undefweak))
4472 /* This is actually a static link, or it is a -Bsymbolic link
4473 and the symbol is defined locally. We must initialize this
4474 entry in the global offset table. Since the offset must
4475 always be a multiple of 4, we use the least significant bit
4476 to record whether we have initialized it already.
4478 When doing a dynamic link, we create a .rel(a).got relocation
4479 entry to initialize the value. This is done in the
4480 finish_dynamic_symbol routine. */
4485 /* If we are addressing a Thumb function, we need to
4486 adjust the address by one, so that attempts to
4487 call the function pointer will correctly
4488 interpret it as Thumb code. */
4489 if (sym_flags == STT_ARM_TFUNC)
4492 bfd_put_32 (output_bfd, value, sgot->contents + off);
4497 *unresolved_reloc_p = FALSE;
4499 value = sgot->output_offset + off;
4505 BFD_ASSERT (local_got_offsets != NULL &&
4506 local_got_offsets[r_symndx] != (bfd_vma) -1);
4508 off = local_got_offsets[r_symndx];
4510 /* The offset must always be a multiple of 4. We use the
4511 least significant bit to record whether we have already
4512 generated the necessary reloc. */
4517 /* If we are addressing a Thumb function, we need to
4518 adjust the address by one, so that attempts to
4519 call the function pointer will correctly
4520 interpret it as Thumb code. */
4521 if (sym_flags == STT_ARM_TFUNC)
4524 if (globals->use_rel)
4525 bfd_put_32 (output_bfd, value, sgot->contents + off);
4530 Elf_Internal_Rela outrel;
4533 srelgot = (bfd_get_section_by_name
4534 (dynobj, RELOC_SECTION (globals, ".got")));
4535 BFD_ASSERT (srelgot != NULL);
4537 outrel.r_addend = addend + value;
4538 outrel.r_offset = (sgot->output_section->vma
4539 + sgot->output_offset
4541 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
4542 loc = srelgot->contents;
4543 loc += srelgot->reloc_count++ * RELOC_SIZE (globals);
4544 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
4547 local_got_offsets[r_symndx] |= 1;
4550 value = sgot->output_offset + off;
4552 if (r_type != R_ARM_GOT32)
4553 value += sgot->output_section->vma;
4555 return _bfd_final_link_relocate (howto, input_bfd, input_section,
4556 contents, rel->r_offset, value,
4559 case R_ARM_TLS_LDO32:
4560 value = value - dtpoff_base (info);
4562 return _bfd_final_link_relocate (howto, input_bfd, input_section,
4563 contents, rel->r_offset, value,
4566 case R_ARM_TLS_LDM32:
4570 if (globals->sgot == NULL)
4573 off = globals->tls_ldm_got.offset;
4579 /* If we don't know the module number, create a relocation
4583 Elf_Internal_Rela outrel;
4586 if (globals->srelgot == NULL)
4589 outrel.r_addend = 0;
4590 outrel.r_offset = (globals->sgot->output_section->vma
4591 + globals->sgot->output_offset + off);
4592 outrel.r_info = ELF32_R_INFO (0, R_ARM_TLS_DTPMOD32);
4594 if (globals->use_rel)
4595 bfd_put_32 (output_bfd, outrel.r_addend,
4596 globals->sgot->contents + off);
4598 loc = globals->srelgot->contents;
4599 loc += globals->srelgot->reloc_count++ * RELOC_SIZE (globals);
4600 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
4603 bfd_put_32 (output_bfd, 1, globals->sgot->contents + off);
4605 globals->tls_ldm_got.offset |= 1;
4608 value = globals->sgot->output_section->vma + globals->sgot->output_offset + off
4609 - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
4611 return _bfd_final_link_relocate (howto, input_bfd, input_section,
4612 contents, rel->r_offset, value,
4616 case R_ARM_TLS_GD32:
4617 case R_ARM_TLS_IE32:
4623 if (globals->sgot == NULL)
4630 dyn = globals->root.dynamic_sections_created;
4631 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
4633 || !SYMBOL_REFERENCES_LOCAL (info, h)))
4635 *unresolved_reloc_p = FALSE;
4638 off = h->got.offset;
4639 tls_type = ((struct elf32_arm_link_hash_entry *) h)->tls_type;
4643 if (local_got_offsets == NULL)
4645 off = local_got_offsets[r_symndx];
4646 tls_type = elf32_arm_local_got_tls_type (input_bfd)[r_symndx];
4649 if (tls_type == GOT_UNKNOWN)
4656 bfd_boolean need_relocs = FALSE;
4657 Elf_Internal_Rela outrel;
4658 bfd_byte *loc = NULL;
4661 /* The GOT entries have not been initialized yet. Do it
4662 now, and emit any relocations. If both an IE GOT and a
4663 GD GOT are necessary, we emit the GD first. */
4665 if ((info->shared || indx != 0)
4667 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4668 || h->root.type != bfd_link_hash_undefweak))
4671 if (globals->srelgot == NULL)
4673 loc = globals->srelgot->contents;
4674 loc += globals->srelgot->reloc_count * RELOC_SIZE (globals);
4677 if (tls_type & GOT_TLS_GD)
4681 outrel.r_addend = 0;
4682 outrel.r_offset = (globals->sgot->output_section->vma
4683 + globals->sgot->output_offset
4685 outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_DTPMOD32);
4687 if (globals->use_rel)
4688 bfd_put_32 (output_bfd, outrel.r_addend,
4689 globals->sgot->contents + cur_off);
4691 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
4692 globals->srelgot->reloc_count++;
4693 loc += RELOC_SIZE (globals);
4696 bfd_put_32 (output_bfd, value - dtpoff_base (info),
4697 globals->sgot->contents + cur_off + 4);
4700 outrel.r_addend = 0;
4701 outrel.r_info = ELF32_R_INFO (indx,
4702 R_ARM_TLS_DTPOFF32);
4703 outrel.r_offset += 4;
4705 if (globals->use_rel)
4706 bfd_put_32 (output_bfd, outrel.r_addend,
4707 globals->sgot->contents + cur_off + 4);
4710 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
4711 globals->srelgot->reloc_count++;
4712 loc += RELOC_SIZE (globals);
4717 /* If we are not emitting relocations for a
4718 general dynamic reference, then we must be in a
4719 static link or an executable link with the
4720 symbol binding locally. Mark it as belonging
4721 to module 1, the executable. */
4722 bfd_put_32 (output_bfd, 1,
4723 globals->sgot->contents + cur_off);
4724 bfd_put_32 (output_bfd, value - dtpoff_base (info),
4725 globals->sgot->contents + cur_off + 4);
4731 if (tls_type & GOT_TLS_IE)
4736 outrel.r_addend = value - dtpoff_base (info);
4738 outrel.r_addend = 0;
4739 outrel.r_offset = (globals->sgot->output_section->vma
4740 + globals->sgot->output_offset
4742 outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_TPOFF32);
4744 if (globals->use_rel)
4745 bfd_put_32 (output_bfd, outrel.r_addend,
4746 globals->sgot->contents + cur_off);
4748 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
4749 globals->srelgot->reloc_count++;
4750 loc += RELOC_SIZE (globals);
4753 bfd_put_32 (output_bfd, tpoff (info, value),
4754 globals->sgot->contents + cur_off);
4761 local_got_offsets[r_symndx] |= 1;
4764 if ((tls_type & GOT_TLS_GD) && r_type != R_ARM_TLS_GD32)
4766 value = globals->sgot->output_section->vma + globals->sgot->output_offset + off
4767 - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
4769 return _bfd_final_link_relocate (howto, input_bfd, input_section,
4770 contents, rel->r_offset, value,
4774 case R_ARM_TLS_LE32:
4777 (*_bfd_error_handler)
4778 (_("%B(%A+0x%lx): R_ARM_TLS_LE32 relocation not permitted in shared object"),
4779 input_bfd, input_section,
4780 (long) rel->r_offset, howto->name);
4784 value = tpoff (info, value);
4786 return _bfd_final_link_relocate (howto, input_bfd, input_section,
4787 contents, rel->r_offset, value,
4791 if (globals->fix_v4bx)
4793 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
4795 /* Ensure that we have a BX instruction. */
4796 BFD_ASSERT ((insn & 0x0ffffff0) == 0x012fff10);
4798 /* Preserve Rm (lowest four bits) and the condition code
4799 (highest four bits). Other bits encode MOV PC,Rm. */
4800 insn = (insn & 0xf000000f) | 0x01a0f000;
4802 bfd_put_32 (input_bfd, insn, hit_data);
4804 return bfd_reloc_ok;
4806 case R_ARM_MOVW_ABS_NC:
4807 case R_ARM_MOVT_ABS:
4808 case R_ARM_MOVW_PREL_NC:
4809 case R_ARM_MOVT_PREL:
4810 /* Until we properly support segment-base-relative addressing then
4811 we assume the segment base to be zero, as for the group relocations.
4812 Thus R_ARM_MOVW_BREL_NC has the same semantics as R_ARM_MOVW_ABS_NC
4813 and R_ARM_MOVT_BREL has the same semantics as R_ARM_MOVT_ABS. */
4814 case R_ARM_MOVW_BREL_NC:
4815 case R_ARM_MOVW_BREL:
4816 case R_ARM_MOVT_BREL:
4818 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
4820 if (globals->use_rel)
4822 addend = ((insn >> 4) & 0xf000) | (insn & 0xfff);
4823 signed_addend = (addend ^ 0x10000) - 0x10000;
4826 value += signed_addend;
4828 if (r_type == R_ARM_MOVW_PREL_NC || r_type == R_ARM_MOVT_PREL)
4829 value -= (input_section->output_section->vma
4830 + input_section->output_offset + rel->r_offset);
4832 if (r_type == R_ARM_MOVW_BREL && value >= 0x10000)
4833 return bfd_reloc_overflow;
4835 if (sym_flags == STT_ARM_TFUNC)
4838 if (r_type == R_ARM_MOVT_ABS || r_type == R_ARM_MOVT_PREL
4839 || r_type == R_ARM_MOVT_BREL)
4843 insn |= value & 0xfff;
4844 insn |= (value & 0xf000) << 4;
4845 bfd_put_32 (input_bfd, insn, hit_data);
4847 return bfd_reloc_ok;
4849 case R_ARM_THM_MOVW_ABS_NC:
4850 case R_ARM_THM_MOVT_ABS:
4851 case R_ARM_THM_MOVW_PREL_NC:
4852 case R_ARM_THM_MOVT_PREL:
4853 /* Until we properly support segment-base-relative addressing then
4854 we assume the segment base to be zero, as for the above relocations.
4855 Thus R_ARM_THM_MOVW_BREL_NC has the same semantics as
4856 R_ARM_THM_MOVW_ABS_NC and R_ARM_THM_MOVT_BREL has the same semantics
4857 as R_ARM_THM_MOVT_ABS. */
4858 case R_ARM_THM_MOVW_BREL_NC:
4859 case R_ARM_THM_MOVW_BREL:
4860 case R_ARM_THM_MOVT_BREL:
4864 insn = bfd_get_16 (input_bfd, hit_data) << 16;
4865 insn |= bfd_get_16 (input_bfd, hit_data + 2);
4867 if (globals->use_rel)
4869 addend = ((insn >> 4) & 0xf000)
4870 | ((insn >> 15) & 0x0800)
4871 | ((insn >> 4) & 0x0700)
4873 signed_addend = (addend ^ 0x10000) - 0x10000;
4876 value += signed_addend;
4878 if (r_type == R_ARM_THM_MOVW_PREL_NC || r_type == R_ARM_THM_MOVT_PREL)
4879 value -= (input_section->output_section->vma
4880 + input_section->output_offset + rel->r_offset);
4882 if (r_type == R_ARM_THM_MOVW_BREL && value >= 0x10000)
4883 return bfd_reloc_overflow;
4885 if (sym_flags == STT_ARM_TFUNC)
4888 if (r_type == R_ARM_THM_MOVT_ABS || r_type == R_ARM_THM_MOVT_PREL
4889 || r_type == R_ARM_THM_MOVT_BREL)
4893 insn |= (value & 0xf000) << 4;
4894 insn |= (value & 0x0800) << 15;
4895 insn |= (value & 0x0700) << 4;
4896 insn |= (value & 0x00ff);
4898 bfd_put_16 (input_bfd, insn >> 16, hit_data);
4899 bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2);
4901 return bfd_reloc_ok;
4903 case R_ARM_ALU_PC_G0_NC:
4904 case R_ARM_ALU_PC_G1_NC:
4905 case R_ARM_ALU_PC_G0:
4906 case R_ARM_ALU_PC_G1:
4907 case R_ARM_ALU_PC_G2:
4908 case R_ARM_ALU_SB_G0_NC:
4909 case R_ARM_ALU_SB_G1_NC:
4910 case R_ARM_ALU_SB_G0:
4911 case R_ARM_ALU_SB_G1:
4912 case R_ARM_ALU_SB_G2:
4914 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
4915 bfd_vma pc = input_section->output_section->vma
4916 + input_section->output_offset + rel->r_offset;
4917 /* sb should be the origin of the *segment* containing the symbol.
4918 It is not clear how to obtain this OS-dependent value, so we
4919 make an arbitrary choice of zero. */
4923 bfd_signed_vma signed_value;
4926 /* Determine which group of bits to select. */
4929 case R_ARM_ALU_PC_G0_NC:
4930 case R_ARM_ALU_PC_G0:
4931 case R_ARM_ALU_SB_G0_NC:
4932 case R_ARM_ALU_SB_G0:
4936 case R_ARM_ALU_PC_G1_NC:
4937 case R_ARM_ALU_PC_G1:
4938 case R_ARM_ALU_SB_G1_NC:
4939 case R_ARM_ALU_SB_G1:
4943 case R_ARM_ALU_PC_G2:
4944 case R_ARM_ALU_SB_G2:
4952 /* If REL, extract the addend from the insn. If RELA, it will
4953 have already been fetched for us. */
4954 if (globals->use_rel)
4957 bfd_vma constant = insn & 0xff;
4958 bfd_vma rotation = (insn & 0xf00) >> 8;
4961 signed_addend = constant;
4964 /* Compensate for the fact that in the instruction, the
4965 rotation is stored in multiples of 2 bits. */
4968 /* Rotate "constant" right by "rotation" bits. */
4969 signed_addend = (constant >> rotation) |
4970 (constant << (8 * sizeof (bfd_vma) - rotation));
4973 /* Determine if the instruction is an ADD or a SUB.
4974 (For REL, this determines the sign of the addend.) */
4975 negative = identify_add_or_sub (insn);
4978 (*_bfd_error_handler)
4979 (_("%B(%A+0x%lx): Only ADD or SUB instructions are allowed for ALU group relocations"),
4980 input_bfd, input_section,
4981 (long) rel->r_offset, howto->name);
4982 return bfd_reloc_overflow;
4985 signed_addend *= negative;
4988 /* Compute the value (X) to go in the place. */
4989 if (r_type == R_ARM_ALU_PC_G0_NC
4990 || r_type == R_ARM_ALU_PC_G1_NC
4991 || r_type == R_ARM_ALU_PC_G0
4992 || r_type == R_ARM_ALU_PC_G1
4993 || r_type == R_ARM_ALU_PC_G2)
4995 signed_value = value - pc + signed_addend;
4997 /* Section base relative. */
4998 signed_value = value - sb + signed_addend;
5000 /* If the target symbol is a Thumb function, then set the
5001 Thumb bit in the address. */
5002 if (sym_flags == STT_ARM_TFUNC)
5005 /* Calculate the value of the relevant G_n, in encoded
5006 constant-with-rotation format. */
5007 g_n = calculate_group_reloc_mask (abs (signed_value), group,
5010 /* Check for overflow if required. */
5011 if ((r_type == R_ARM_ALU_PC_G0
5012 || r_type == R_ARM_ALU_PC_G1
5013 || r_type == R_ARM_ALU_PC_G2
5014 || r_type == R_ARM_ALU_SB_G0
5015 || r_type == R_ARM_ALU_SB_G1
5016 || r_type == R_ARM_ALU_SB_G2) && residual != 0)
5018 (*_bfd_error_handler)
5019 (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
5020 input_bfd, input_section,
5021 (long) rel->r_offset, abs (signed_value), howto->name);
5022 return bfd_reloc_overflow;
5025 /* Mask out the value and the ADD/SUB part of the opcode; take care
5026 not to destroy the S bit. */
5029 /* Set the opcode according to whether the value to go in the
5030 place is negative. */
5031 if (signed_value < 0)
5036 /* Encode the offset. */
5039 bfd_put_32 (input_bfd, insn, hit_data);
5041 return bfd_reloc_ok;
5043 case R_ARM_LDR_PC_G0:
5044 case R_ARM_LDR_PC_G1:
5045 case R_ARM_LDR_PC_G2:
5046 case R_ARM_LDR_SB_G0:
5047 case R_ARM_LDR_SB_G1:
5048 case R_ARM_LDR_SB_G2:
5050 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
5051 bfd_vma pc = input_section->output_section->vma
5052 + input_section->output_offset + rel->r_offset;
5053 bfd_vma sb = 0; /* See note above. */
5055 bfd_signed_vma signed_value;
5058 /* Determine which groups of bits to calculate. */
5061 case R_ARM_LDR_PC_G0:
5062 case R_ARM_LDR_SB_G0:
5066 case R_ARM_LDR_PC_G1:
5067 case R_ARM_LDR_SB_G1:
5071 case R_ARM_LDR_PC_G2:
5072 case R_ARM_LDR_SB_G2:
5080 /* If REL, extract the addend from the insn. If RELA, it will
5081 have already been fetched for us. */
5082 if (globals->use_rel)
5084 int negative = (insn & (1 << 23)) ? 1 : -1;
5085 signed_addend = negative * (insn & 0xfff);
5088 /* Compute the value (X) to go in the place. */
5089 if (r_type == R_ARM_LDR_PC_G0
5090 || r_type == R_ARM_LDR_PC_G1
5091 || r_type == R_ARM_LDR_PC_G2)
5093 signed_value = value - pc + signed_addend;
5095 /* Section base relative. */
5096 signed_value = value - sb + signed_addend;
5098 /* Calculate the value of the relevant G_{n-1} to obtain
5099 the residual at that stage. */
5100 calculate_group_reloc_mask (abs (signed_value), group - 1, &residual);
5102 /* Check for overflow. */
5103 if (residual >= 0x1000)
5105 (*_bfd_error_handler)
5106 (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
5107 input_bfd, input_section,
5108 (long) rel->r_offset, abs (signed_value), howto->name);
5109 return bfd_reloc_overflow;
5112 /* Mask out the value and U bit. */
5115 /* Set the U bit if the value to go in the place is non-negative. */
5116 if (signed_value >= 0)
5119 /* Encode the offset. */
5122 bfd_put_32 (input_bfd, insn, hit_data);
5124 return bfd_reloc_ok;
5126 case R_ARM_LDRS_PC_G0:
5127 case R_ARM_LDRS_PC_G1:
5128 case R_ARM_LDRS_PC_G2:
5129 case R_ARM_LDRS_SB_G0:
5130 case R_ARM_LDRS_SB_G1:
5131 case R_ARM_LDRS_SB_G2:
5133 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
5134 bfd_vma pc = input_section->output_section->vma
5135 + input_section->output_offset + rel->r_offset;
5136 bfd_vma sb = 0; /* See note above. */
5138 bfd_signed_vma signed_value;
5141 /* Determine which groups of bits to calculate. */
5144 case R_ARM_LDRS_PC_G0:
5145 case R_ARM_LDRS_SB_G0:
5149 case R_ARM_LDRS_PC_G1:
5150 case R_ARM_LDRS_SB_G1:
5154 case R_ARM_LDRS_PC_G2:
5155 case R_ARM_LDRS_SB_G2:
5163 /* If REL, extract the addend from the insn. If RELA, it will
5164 have already been fetched for us. */
5165 if (globals->use_rel)
5167 int negative = (insn & (1 << 23)) ? 1 : -1;
5168 signed_addend = negative * (((insn & 0xf00) >> 4) + (insn & 0xf));
5171 /* Compute the value (X) to go in the place. */
5172 if (r_type == R_ARM_LDRS_PC_G0
5173 || r_type == R_ARM_LDRS_PC_G1
5174 || r_type == R_ARM_LDRS_PC_G2)
5176 signed_value = value - pc + signed_addend;
5178 /* Section base relative. */
5179 signed_value = value - sb + signed_addend;
5181 /* Calculate the value of the relevant G_{n-1} to obtain
5182 the residual at that stage. */
5183 calculate_group_reloc_mask (abs (signed_value), group - 1, &residual);
5185 /* Check for overflow. */
5186 if (residual >= 0x100)
5188 (*_bfd_error_handler)
5189 (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
5190 input_bfd, input_section,
5191 (long) rel->r_offset, abs (signed_value), howto->name);
5192 return bfd_reloc_overflow;
5195 /* Mask out the value and U bit. */
5198 /* Set the U bit if the value to go in the place is non-negative. */
5199 if (signed_value >= 0)
5202 /* Encode the offset. */
5203 insn |= ((residual & 0xf0) << 4) | (residual & 0xf);
5205 bfd_put_32 (input_bfd, insn, hit_data);
5207 return bfd_reloc_ok;
5209 case R_ARM_LDC_PC_G0:
5210 case R_ARM_LDC_PC_G1:
5211 case R_ARM_LDC_PC_G2:
5212 case R_ARM_LDC_SB_G0:
5213 case R_ARM_LDC_SB_G1:
5214 case R_ARM_LDC_SB_G2:
5216 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
5217 bfd_vma pc = input_section->output_section->vma
5218 + input_section->output_offset + rel->r_offset;
5219 bfd_vma sb = 0; /* See note above. */
5221 bfd_signed_vma signed_value;
5224 /* Determine which groups of bits to calculate. */
5227 case R_ARM_LDC_PC_G0:
5228 case R_ARM_LDC_SB_G0:
5232 case R_ARM_LDC_PC_G1:
5233 case R_ARM_LDC_SB_G1:
5237 case R_ARM_LDC_PC_G2:
5238 case R_ARM_LDC_SB_G2:
5246 /* If REL, extract the addend from the insn. If RELA, it will
5247 have already been fetched for us. */
5248 if (globals->use_rel)
5250 int negative = (insn & (1 << 23)) ? 1 : -1;
5251 signed_addend = negative * ((insn & 0xff) << 2);
5254 /* Compute the value (X) to go in the place. */
5255 if (r_type == R_ARM_LDC_PC_G0
5256 || r_type == R_ARM_LDC_PC_G1
5257 || r_type == R_ARM_LDC_PC_G2)
5259 signed_value = value - pc + signed_addend;
5261 /* Section base relative. */
5262 signed_value = value - sb + signed_addend;
5264 /* Calculate the value of the relevant G_{n-1} to obtain
5265 the residual at that stage. */
5266 calculate_group_reloc_mask (abs (signed_value), group - 1, &residual);
5268 /* Check for overflow. (The absolute value to go in the place must be
5269 divisible by four and, after having been divided by four, must
5270 fit in eight bits.) */
5271 if ((residual & 0x3) != 0 || residual >= 0x400)
5273 (*_bfd_error_handler)
5274 (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
5275 input_bfd, input_section,
5276 (long) rel->r_offset, abs (signed_value), howto->name);
5277 return bfd_reloc_overflow;
5280 /* Mask out the value and U bit. */
5283 /* Set the U bit if the value to go in the place is non-negative. */
5284 if (signed_value >= 0)
5287 /* Encode the offset. */
5288 insn |= residual >> 2;
5290 bfd_put_32 (input_bfd, insn, hit_data);
5292 return bfd_reloc_ok;
5295 return bfd_reloc_notsupported;
5301 uleb128_size (unsigned int i)
5313 /* Return TRUE if the attribute has the default value (0/""). */
5315 is_default_attr (aeabi_attribute *attr)
5317 if ((attr->type & 1) && attr->i != 0)
5319 if ((attr->type & 2) && attr->s && *attr->s)
5325 /* Return the size of a single attribute. */
5327 eabi_attr_size(int tag, aeabi_attribute *attr)
5331 if (is_default_attr (attr))
5334 size = uleb128_size (tag);
5336 size += uleb128_size (attr->i);
5338 size += strlen ((char *)attr->s) + 1;
5342 /* Returns the size of the eabi object attributess section. */
5344 elf32_arm_eabi_attr_size (bfd *abfd)
5347 aeabi_attribute *attr;
5348 aeabi_attribute_list *list;
5351 attr = elf32_arm_tdata (abfd)->known_eabi_attributes;
5352 size = 16; /* 'A' <size> "aeabi" 0x1 <size>. */
5353 for (i = 4; i < NUM_KNOWN_ATTRIBUTES; i++)
5354 size += eabi_attr_size (i, &attr[i]);
5356 for (list = elf32_arm_tdata (abfd)->other_eabi_attributes;
5359 size += eabi_attr_size (list->tag, &list->attr);
5365 write_uleb128 (bfd_byte *p, unsigned int val)
5380 /* Write attribute ATTR to butter P, and return a pointer to the following
5383 write_eabi_attribute (bfd_byte *p, int tag, aeabi_attribute *attr)
5385 /* Suppress default entries. */
5386 if (is_default_attr(attr))
5389 p = write_uleb128 (p, tag);
5391 p = write_uleb128 (p, attr->i);
5396 len = strlen (attr->s) + 1;
5397 memcpy (p, attr->s, len);
5404 /* Write the contents of the eabi attributes section to p. */
5406 elf32_arm_set_eabi_attr_contents (bfd *abfd, bfd_byte *contents, bfd_vma size)
5409 aeabi_attribute *attr;
5410 aeabi_attribute_list *list;
5415 bfd_put_32 (abfd, size - 1, p);
5417 memcpy (p, "aeabi", 6);
5420 bfd_put_32 (abfd, size - 11, p);
5423 attr = elf32_arm_tdata (abfd)->known_eabi_attributes;
5424 for (i = 4; i < NUM_KNOWN_ATTRIBUTES; i++)
5425 p = write_eabi_attribute (p, i, &attr[i]);
5427 for (list = elf32_arm_tdata (abfd)->other_eabi_attributes;
5430 p = write_eabi_attribute (p, list->tag, &list->attr);
5433 /* Override final_link to handle EABI object attribute sections. */
5436 elf32_arm_bfd_final_link (bfd *abfd, struct bfd_link_info *info)
5439 struct bfd_link_order *p;
5440 asection *attr_section = NULL;
5444 /* elf32_arm_merge_private_bfd_data will already have merged the
5445 object attributes. Remove the input sections from the link, and set
5446 the contents of the output secton. */
5447 for (o = abfd->sections; o != NULL; o = o->next)
5449 if (strcmp (o->name, ".ARM.attributes") == 0)
5451 for (p = o->map_head.link_order; p != NULL; p = p->next)
5453 asection *input_section;
5455 if (p->type != bfd_indirect_link_order)
5457 input_section = p->u.indirect.section;
5458 /* Hack: reset the SEC_HAS_CONTENTS flag so that
5459 elf_link_input_bfd ignores this section. */
5460 input_section->flags &= ~SEC_HAS_CONTENTS;
5463 size = elf32_arm_eabi_attr_size (abfd);
5464 bfd_set_section_size (abfd, o, size);
5466 /* Skip this section later on. */
5467 o->map_head.link_order = NULL;
5470 /* Invoke the ELF linker to do all the work. */
5471 if (!bfd_elf_final_link (abfd, info))
5476 contents = bfd_malloc(size);
5477 if (contents == NULL)
5479 elf32_arm_set_eabi_attr_contents (abfd, contents, size);
5480 bfd_set_section_contents (abfd, attr_section, contents, 0, size);
5487 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
5489 arm_add_to_rel (bfd * abfd,
5491 reloc_howto_type * howto,
5492 bfd_signed_vma increment)
5494 bfd_signed_vma addend;
5496 if (howto->type == R_ARM_THM_CALL)
5498 int upper_insn, lower_insn;
5501 upper_insn = bfd_get_16 (abfd, address);
5502 lower_insn = bfd_get_16 (abfd, address + 2);
5503 upper = upper_insn & 0x7ff;
5504 lower = lower_insn & 0x7ff;
5506 addend = (upper << 12) | (lower << 1);
5507 addend += increment;
5510 upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
5511 lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
5513 bfd_put_16 (abfd, (bfd_vma) upper_insn, address);
5514 bfd_put_16 (abfd, (bfd_vma) lower_insn, address + 2);
5520 contents = bfd_get_32 (abfd, address);
5522 /* Get the (signed) value from the instruction. */
5523 addend = contents & howto->src_mask;
5524 if (addend & ((howto->src_mask + 1) >> 1))
5526 bfd_signed_vma mask;
5529 mask &= ~ howto->src_mask;
5533 /* Add in the increment, (which is a byte value). */
5534 switch (howto->type)
5537 addend += increment;
5544 addend <<= howto->size;
5545 addend += increment;
5547 /* Should we check for overflow here ? */
5549 /* Drop any undesired bits. */
5550 addend >>= howto->rightshift;
5554 contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
5556 bfd_put_32 (abfd, contents, address);
5560 #define IS_ARM_TLS_RELOC(R_TYPE) \
5561 ((R_TYPE) == R_ARM_TLS_GD32 \
5562 || (R_TYPE) == R_ARM_TLS_LDO32 \
5563 || (R_TYPE) == R_ARM_TLS_LDM32 \
5564 || (R_TYPE) == R_ARM_TLS_DTPOFF32 \
5565 || (R_TYPE) == R_ARM_TLS_DTPMOD32 \
5566 || (R_TYPE) == R_ARM_TLS_TPOFF32 \
5567 || (R_TYPE) == R_ARM_TLS_LE32 \
5568 || (R_TYPE) == R_ARM_TLS_IE32)
5570 /* Relocate an ARM ELF section. */
5572 elf32_arm_relocate_section (bfd * output_bfd,
5573 struct bfd_link_info * info,
5575 asection * input_section,
5576 bfd_byte * contents,
5577 Elf_Internal_Rela * relocs,
5578 Elf_Internal_Sym * local_syms,
5579 asection ** local_sections)
5581 Elf_Internal_Shdr *symtab_hdr;
5582 struct elf_link_hash_entry **sym_hashes;
5583 Elf_Internal_Rela *rel;
5584 Elf_Internal_Rela *relend;
5586 struct elf32_arm_link_hash_table * globals;
5588 globals = elf32_arm_hash_table (info);
5589 if (info->relocatable && !globals->use_rel)
5592 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
5593 sym_hashes = elf_sym_hashes (input_bfd);
5596 relend = relocs + input_section->reloc_count;
5597 for (; rel < relend; rel++)
5600 reloc_howto_type * howto;
5601 unsigned long r_symndx;
5602 Elf_Internal_Sym * sym;
5604 struct elf_link_hash_entry * h;
5606 bfd_reloc_status_type r;
5609 bfd_boolean unresolved_reloc = FALSE;
5611 r_symndx = ELF32_R_SYM (rel->r_info);
5612 r_type = ELF32_R_TYPE (rel->r_info);
5613 r_type = arm_real_reloc_type (globals, r_type);
5615 if ( r_type == R_ARM_GNU_VTENTRY
5616 || r_type == R_ARM_GNU_VTINHERIT)
5619 bfd_reloc.howto = elf32_arm_howto_from_type (r_type);
5620 howto = bfd_reloc.howto;
5622 if (info->relocatable && globals->use_rel)
5624 /* This is a relocatable link. We don't have to change
5625 anything, unless the reloc is against a section symbol,
5626 in which case we have to adjust according to where the
5627 section symbol winds up in the output section. */
5628 if (r_symndx < symtab_hdr->sh_info)
5630 sym = local_syms + r_symndx;
5631 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5633 sec = local_sections[r_symndx];
5634 arm_add_to_rel (input_bfd, contents + rel->r_offset,
5636 (bfd_signed_vma) (sec->output_offset
5644 /* This is a final link. */
5649 if (r_symndx < symtab_hdr->sh_info)
5651 sym = local_syms + r_symndx;
5652 sym_type = ELF32_ST_TYPE (sym->st_info);
5653 sec = local_sections[r_symndx];
5654 if (globals->use_rel)
5656 relocation = (sec->output_section->vma
5657 + sec->output_offset
5659 if ((sec->flags & SEC_MERGE)
5660 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5663 bfd_vma addend, value;
5665 if (howto->rightshift)
5667 (*_bfd_error_handler)
5668 (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
5669 input_bfd, input_section,
5670 (long) rel->r_offset, howto->name);
5674 value = bfd_get_32 (input_bfd, contents + rel->r_offset);
5676 /* Get the (signed) value from the instruction. */
5677 addend = value & howto->src_mask;
5678 if (addend & ((howto->src_mask + 1) >> 1))
5680 bfd_signed_vma mask;
5683 mask &= ~ howto->src_mask;
5688 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
5690 addend += msec->output_section->vma + msec->output_offset;
5691 value = (value & ~ howto->dst_mask) | (addend & howto->dst_mask);
5692 bfd_put_32 (input_bfd, value, contents + rel->r_offset);
5696 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
5702 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
5703 r_symndx, symtab_hdr, sym_hashes,
5705 unresolved_reloc, warned);
5711 name = h->root.root.string;
5714 name = (bfd_elf_string_from_elf_section
5715 (input_bfd, symtab_hdr->sh_link, sym->st_name));
5716 if (name == NULL || *name == '\0')
5717 name = bfd_section_name (input_bfd, sec);
5721 && r_type != R_ARM_NONE
5723 || h->root.type == bfd_link_hash_defined
5724 || h->root.type == bfd_link_hash_defweak)
5725 && IS_ARM_TLS_RELOC (r_type) != (sym_type == STT_TLS))
5727 (*_bfd_error_handler)
5728 ((sym_type == STT_TLS
5729 ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
5730 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
5733 (long) rel->r_offset,
5738 r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
5739 input_section, contents, rel,
5740 relocation, info, sec, name,
5741 (h ? ELF_ST_TYPE (h->type) :
5742 ELF_ST_TYPE (sym->st_info)), h,
5745 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5746 because such sections are not SEC_ALLOC and thus ld.so will
5747 not process them. */
5748 if (unresolved_reloc
5749 && !((input_section->flags & SEC_DEBUGGING) != 0
5752 (*_bfd_error_handler)
5753 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5756 (long) rel->r_offset,
5758 h->root.root.string);
5762 if (r != bfd_reloc_ok)
5764 const char * msg = (const char *) 0;
5768 case bfd_reloc_overflow:
5769 /* If the overflowing reloc was to an undefined symbol,
5770 we have already printed one error message and there
5771 is no point complaining again. */
5773 h->root.type != bfd_link_hash_undefined)
5774 && (!((*info->callbacks->reloc_overflow)
5775 (info, (h ? &h->root : NULL), name, howto->name,
5776 (bfd_vma) 0, input_bfd, input_section,
5781 case bfd_reloc_undefined:
5782 if (!((*info->callbacks->undefined_symbol)
5783 (info, name, input_bfd, input_section,
5784 rel->r_offset, TRUE)))
5788 case bfd_reloc_outofrange:
5789 msg = _("internal error: out of range error");
5792 case bfd_reloc_notsupported:
5793 msg = _("internal error: unsupported relocation error");
5796 case bfd_reloc_dangerous:
5797 msg = _("internal error: dangerous error");
5801 msg = _("internal error: unknown error");
5805 if (!((*info->callbacks->warning)
5806 (info, msg, name, input_bfd, input_section,
5817 /* Allocate/find an object attribute. */
5818 static aeabi_attribute *
5819 elf32_arm_new_eabi_attr (bfd *abfd, int tag)
5821 aeabi_attribute *attr;
5822 aeabi_attribute_list *list;
5823 aeabi_attribute_list *p;
5824 aeabi_attribute_list **lastp;
5827 if (tag < NUM_KNOWN_ATTRIBUTES)
5829 /* Knwon tags are preallocated. */
5830 attr = &elf32_arm_tdata (abfd)->known_eabi_attributes[tag];
5834 /* Create a new tag. */
5835 list = (aeabi_attribute_list *)
5836 bfd_alloc (abfd, sizeof (aeabi_attribute_list));
5837 memset (list, 0, sizeof (aeabi_attribute_list));
5839 /* Keep the tag list in order. */
5840 lastp = &elf32_arm_tdata (abfd)->other_eabi_attributes;
5841 for (p = *lastp; p; p = p->next)
5847 list->next = *lastp;
5856 elf32_arm_get_eabi_attr_int (bfd *abfd, int tag)
5858 aeabi_attribute_list *p;
5860 if (tag < NUM_KNOWN_ATTRIBUTES)
5862 /* Knwon tags are preallocated. */
5863 return elf32_arm_tdata (abfd)->known_eabi_attributes[tag].i;
5867 for (p = elf32_arm_tdata (abfd)->other_eabi_attributes;
5881 elf32_arm_add_eabi_attr_int (bfd *abfd, int tag, unsigned int i)
5883 aeabi_attribute *attr;
5885 attr = elf32_arm_new_eabi_attr (abfd, tag);
5891 attr_strdup (bfd *abfd, const char * s)
5896 len = strlen (s) + 1;
5897 p = (char *)bfd_alloc(abfd, len);
5898 return memcpy (p, s, len);
5902 elf32_arm_add_eabi_attr_string (bfd *abfd, int tag, const char *s)
5904 aeabi_attribute *attr;
5906 attr = elf32_arm_new_eabi_attr (abfd, tag);
5908 attr->s = attr_strdup (abfd, s);
5912 elf32_arm_add_eabi_attr_compat (bfd *abfd, unsigned int i, const char *s)
5914 aeabi_attribute_list *list;
5915 aeabi_attribute_list *p;
5916 aeabi_attribute_list **lastp;
5918 list = (aeabi_attribute_list *)
5919 bfd_alloc (abfd, sizeof (aeabi_attribute_list));
5920 memset (list, 0, sizeof (aeabi_attribute_list));
5921 list->tag = Tag_compatibility;
5922 list->attr.type = 3;
5924 list->attr.s = attr_strdup (abfd, s);
5926 lastp = &elf32_arm_tdata (abfd)->other_eabi_attributes;
5927 for (p = *lastp; p; p = p->next)
5930 if (p->tag != Tag_compatibility)
5932 cmp = strcmp(s, p->attr.s);
5933 if (cmp < 0 || (cmp == 0 && i < p->attr.i))
5937 list->next = *lastp;
5941 /* Set the right machine number. */
5944 elf32_arm_object_p (bfd *abfd)
5948 mach = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
5950 if (mach != bfd_mach_arm_unknown)
5951 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
5953 else if (elf_elfheader (abfd)->e_flags & EF_ARM_MAVERICK_FLOAT)
5954 bfd_default_set_arch_mach (abfd, bfd_arch_arm, bfd_mach_arm_ep9312);
5957 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
5962 /* Function to keep ARM specific flags in the ELF header. */
5965 elf32_arm_set_private_flags (bfd *abfd, flagword flags)
5967 if (elf_flags_init (abfd)
5968 && elf_elfheader (abfd)->e_flags != flags)
5970 if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
5972 if (flags & EF_ARM_INTERWORK)
5973 (*_bfd_error_handler)
5974 (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
5978 (_("Warning: Clearing the interworking flag of %B due to outside request"),
5984 elf_elfheader (abfd)->e_flags = flags;
5985 elf_flags_init (abfd) = TRUE;
5991 /* Copy the eabi object attribute from IBFD to OBFD. */
5993 copy_eabi_attributes (bfd *ibfd, bfd *obfd)
5995 aeabi_attribute *in_attr;
5996 aeabi_attribute *out_attr;
5997 aeabi_attribute_list *list;
6000 in_attr = elf32_arm_tdata (ibfd)->known_eabi_attributes;
6001 out_attr = elf32_arm_tdata (obfd)->known_eabi_attributes;
6002 for (i = 4; i < NUM_KNOWN_ATTRIBUTES; i++)
6004 out_attr->i = in_attr->i;
6005 if (in_attr->s && *in_attr->s)
6006 out_attr->s = attr_strdup (obfd, in_attr->s);
6011 for (list = elf32_arm_tdata (ibfd)->other_eabi_attributes;
6015 in_attr = &list->attr;
6016 switch (in_attr->type)
6019 elf32_arm_add_eabi_attr_int (obfd, list->tag, in_attr->i);
6022 elf32_arm_add_eabi_attr_string (obfd, list->tag, in_attr->s);
6025 elf32_arm_add_eabi_attr_compat (obfd, in_attr->i, in_attr->s);
6034 /* Copy backend specific data from one object module to another. */
6037 elf32_arm_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
6042 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6043 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6046 in_flags = elf_elfheader (ibfd)->e_flags;
6047 out_flags = elf_elfheader (obfd)->e_flags;
6049 if (elf_flags_init (obfd)
6050 && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
6051 && in_flags != out_flags)
6053 /* Cannot mix APCS26 and APCS32 code. */
6054 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
6057 /* Cannot mix float APCS and non-float APCS code. */
6058 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
6061 /* If the src and dest have different interworking flags
6062 then turn off the interworking bit. */
6063 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
6065 if (out_flags & EF_ARM_INTERWORK)
6067 (_("Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
6070 in_flags &= ~EF_ARM_INTERWORK;
6073 /* Likewise for PIC, though don't warn for this case. */
6074 if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC))
6075 in_flags &= ~EF_ARM_PIC;
6078 elf_elfheader (obfd)->e_flags = in_flags;
6079 elf_flags_init (obfd) = TRUE;
6081 /* Also copy the EI_OSABI field. */
6082 elf_elfheader (obfd)->e_ident[EI_OSABI] =
6083 elf_elfheader (ibfd)->e_ident[EI_OSABI];
6085 /* Copy EABI object attributes. */
6086 copy_eabi_attributes (ibfd, obfd);
6091 /* Values for Tag_ABI_PCS_R9_use. */
6100 /* Values for Tag_ABI_PCS_RW_data. */
6103 AEABI_PCS_RW_data_absolute,
6104 AEABI_PCS_RW_data_PCrel,
6105 AEABI_PCS_RW_data_SBrel,
6106 AEABI_PCS_RW_data_unused
6109 /* Values for Tag_ABI_enum_size. */
6115 AEABI_enum_forced_wide
6118 /* Merge EABI object attributes from IBFD into OBFD. Raise an error if there
6119 are conflicting attributes. */
6121 elf32_arm_merge_eabi_attributes (bfd *ibfd, bfd *obfd)
6123 aeabi_attribute *in_attr;
6124 aeabi_attribute *out_attr;
6125 aeabi_attribute_list *in_list;
6126 aeabi_attribute_list *out_list;
6127 /* Some tags have 0 = don't care, 1 = strong requirement,
6128 2 = weak requirement. */
6129 static const int order_312[3] = {3, 1, 2};
6132 if (!elf32_arm_tdata (ibfd)->known_eabi_attributes[0].i)
6134 /* This is the first object. Copy the attributes. */
6135 copy_eabi_attributes (ibfd, obfd);
6139 /* Use the Tag_null value to indicate the attributes have been
6141 elf32_arm_tdata (ibfd)->known_eabi_attributes[0].i = 1;
6143 in_attr = elf32_arm_tdata (ibfd)->known_eabi_attributes;
6144 out_attr = elf32_arm_tdata (obfd)->known_eabi_attributes;
6145 /* This needs to happen before Tag_ABI_FP_number_model is merged. */
6146 if (in_attr[Tag_ABI_VFP_args].i != out_attr[Tag_ABI_VFP_args].i)
6148 /* Ignore mismatches if teh object doesn't use floating point. */
6149 if (out_attr[Tag_ABI_FP_number_model].i == 0)
6150 out_attr[Tag_ABI_VFP_args].i = in_attr[Tag_ABI_VFP_args].i;
6151 else if (in_attr[Tag_ABI_FP_number_model].i != 0)
6154 (_("ERROR: %B uses VFP register arguments, %B does not"),
6160 for (i = 4; i < NUM_KNOWN_ATTRIBUTES; i++)
6162 /* Merge this attribute with existing attributes. */
6165 case Tag_CPU_raw_name:
6167 /* Use whichever has the greatest architecture requirements. */
6168 if (in_attr[Tag_CPU_arch].i > out_attr[Tag_CPU_arch].i)
6169 out_attr[i].s = attr_strdup(obfd, in_attr[i].s);
6172 case Tag_ABI_optimization_goals:
6173 case Tag_ABI_FP_optimization_goals:
6174 /* Use the first value seen. */
6178 case Tag_ARM_ISA_use:
6179 case Tag_THUMB_ISA_use:
6183 /* ??? Do NEON and WMMX conflict? */
6184 case Tag_ABI_FP_rounding:
6185 case Tag_ABI_FP_denormal:
6186 case Tag_ABI_FP_exceptions:
6187 case Tag_ABI_FP_user_exceptions:
6188 case Tag_ABI_FP_number_model:
6189 case Tag_ABI_align8_preserved:
6190 case Tag_ABI_HardFP_use:
6191 /* Use the largest value specified. */
6192 if (in_attr[i].i > out_attr[i].i)
6193 out_attr[i].i = in_attr[i].i;
6196 case Tag_CPU_arch_profile:
6197 /* Warn if conflicting architecture profiles used. */
6198 if (out_attr[i].i && in_attr[i].i && in_attr[i].i != out_attr[i].i)
6201 (_("ERROR: %B: Conflicting architecture profiles %c/%c"),
6202 ibfd, in_attr[i].i, out_attr[i].i);
6206 out_attr[i].i = in_attr[i].i;
6208 case Tag_PCS_config:
6209 if (out_attr[i].i == 0)
6210 out_attr[i].i = in_attr[i].i;
6211 else if (in_attr[i].i != 0 && out_attr[i].i != 0)
6213 /* It's sometimes ok to mix different configs, so this is only
6216 (_("Warning: %B: Conflicting platform configuration"), ibfd);
6219 case Tag_ABI_PCS_R9_use:
6220 if (out_attr[i].i != AEABI_R9_unused
6221 && in_attr[i].i != AEABI_R9_unused)
6224 (_("ERROR: %B: Conflicting use of R9"), ibfd);
6227 if (out_attr[i].i == AEABI_R9_unused)
6228 out_attr[i].i = in_attr[i].i;
6230 case Tag_ABI_PCS_RW_data:
6231 if (in_attr[i].i == AEABI_PCS_RW_data_SBrel
6232 && out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_SB
6233 && out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_unused)
6236 (_("ERROR: %B: SB relative addressing conflicts with use of R9"),
6240 /* Use the smallest value specified. */
6241 if (in_attr[i].i < out_attr[i].i)
6242 out_attr[i].i = in_attr[i].i;
6244 case Tag_ABI_PCS_RO_data:
6245 /* Use the smallest value specified. */
6246 if (in_attr[i].i < out_attr[i].i)
6247 out_attr[i].i = in_attr[i].i;
6249 case Tag_ABI_PCS_GOT_use:
6250 if (in_attr[i].i > 2 || out_attr[i].i > 2
6251 || order_312[in_attr[i].i] < order_312[out_attr[i].i])
6252 out_attr[i].i = in_attr[i].i;
6254 case Tag_ABI_PCS_wchar_t:
6255 if (out_attr[i].i && in_attr[i].i && out_attr[i].i != in_attr[i].i)
6258 (_("ERROR: %B: Conflicting definitions of wchar_t"), ibfd);
6262 out_attr[i].i = in_attr[i].i;
6264 case Tag_ABI_align8_needed:
6265 /* ??? Check against Tag_ABI_align8_preserved. */
6266 if (in_attr[i].i > 2 || out_attr[i].i > 2
6267 || order_312[in_attr[i].i] < order_312[out_attr[i].i])
6268 out_attr[i].i = in_attr[i].i;
6270 case Tag_ABI_enum_size:
6271 if (in_attr[i].i != AEABI_enum_unused)
6273 if (out_attr[i].i == AEABI_enum_unused
6274 || out_attr[i].i == AEABI_enum_forced_wide)
6276 /* The existing object is compatible with anything.
6277 Use whatever requirements the new object has. */
6278 out_attr[i].i = in_attr[i].i;
6280 else if (in_attr[i].i != AEABI_enum_forced_wide
6281 && out_attr[i].i != in_attr[i].i)
6284 (_("ERROR: %B: Conflicting enum sizes"), ibfd);
6288 case Tag_ABI_VFP_args:
6291 case Tag_ABI_WMMX_args:
6292 if (in_attr[i].i != out_attr[i].i)
6295 (_("ERROR: %B uses iWMMXt register arguments, %B does not"),
6300 default: /* All known attributes should be explicitly covered. */
6305 in_list = elf32_arm_tdata (ibfd)->other_eabi_attributes;
6306 out_list = elf32_arm_tdata (ibfd)->other_eabi_attributes;
6307 while (in_list && in_list->tag == Tag_compatibility)
6309 in_attr = &in_list->attr;
6310 if (in_attr->i == 0)
6312 if (in_attr->i == 1)
6315 (_("ERROR: %B: Must be processed by '%s' toolchain"),
6319 if (!out_list || out_list->tag != Tag_compatibility
6320 || strcmp (in_attr->s, out_list->attr.s) != 0)
6322 /* Add this compatibility tag to the output. */
6323 elf32_arm_add_eabi_attr_compat (obfd, in_attr->i, in_attr->s);
6326 out_attr = &out_list->attr;
6327 /* Check all the input tags with the same identifier. */
6330 if (out_list->tag != Tag_compatibility
6331 || in_attr->i != out_attr->i
6332 || strcmp (in_attr->s, out_attr->s) != 0)
6335 (_("ERROR: %B: Incompatible object tag '%s':%d"),
6336 ibfd, in_attr->s, in_attr->i);
6339 in_list = in_list->next;
6340 if (in_list->tag != Tag_compatibility
6341 || strcmp (in_attr->s, in_list->attr.s) != 0)
6343 in_attr = &in_list->attr;
6344 out_list = out_list->next;
6346 out_attr = &out_list->attr;
6349 /* Check the output doesn't have extra tags with this identifier. */
6350 if (out_list && out_list->tag == Tag_compatibility
6351 && strcmp (in_attr->s, out_list->attr.s) == 0)
6354 (_("ERROR: %B: Incompatible object tag '%s':%d"),
6355 ibfd, in_attr->s, out_list->attr.i);
6360 for (; in_list; in_list = in_list->next)
6362 if ((in_list->tag & 128) < 64)
6365 (_("Warning: %B: Unknown EABI object attribute %d"),
6366 ibfd, in_list->tag);
6374 /* Return TRUE if the two EABI versions are incompatible. */
6377 elf32_arm_versions_compatible (unsigned iver, unsigned over)
6379 /* v4 and v5 are the same spec before and after it was released,
6380 so allow mixing them. */
6381 if ((iver == EF_ARM_EABI_VER4 && over == EF_ARM_EABI_VER5)
6382 || (iver == EF_ARM_EABI_VER5 && over == EF_ARM_EABI_VER4))
6385 return (iver == over);
6388 /* Merge backend specific data from an object file to the output
6389 object file when linking. */
6392 elf32_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
6396 bfd_boolean flags_compatible = TRUE;
6399 /* Check if we have the same endianess. */
6400 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
6403 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6404 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6407 if (!elf32_arm_merge_eabi_attributes (ibfd, obfd))
6410 /* The input BFD must have had its flags initialised. */
6411 /* The following seems bogus to me -- The flags are initialized in
6412 the assembler but I don't think an elf_flags_init field is
6413 written into the object. */
6414 /* BFD_ASSERT (elf_flags_init (ibfd)); */
6416 in_flags = elf_elfheader (ibfd)->e_flags;
6417 out_flags = elf_elfheader (obfd)->e_flags;
6419 if (!elf_flags_init (obfd))
6421 /* If the input is the default architecture and had the default
6422 flags then do not bother setting the flags for the output
6423 architecture, instead allow future merges to do this. If no
6424 future merges ever set these flags then they will retain their
6425 uninitialised values, which surprise surprise, correspond
6426 to the default values. */
6427 if (bfd_get_arch_info (ibfd)->the_default
6428 && elf_elfheader (ibfd)->e_flags == 0)
6431 elf_flags_init (obfd) = TRUE;
6432 elf_elfheader (obfd)->e_flags = in_flags;
6434 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
6435 && bfd_get_arch_info (obfd)->the_default)
6436 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
6441 /* Determine what should happen if the input ARM architecture
6442 does not match the output ARM architecture. */
6443 if (! bfd_arm_merge_machines (ibfd, obfd))
6446 /* Identical flags must be compatible. */
6447 if (in_flags == out_flags)
6450 /* Check to see if the input BFD actually contains any sections. If
6451 not, its flags may not have been initialised either, but it
6452 cannot actually cause any incompatiblity. Do not short-circuit
6453 dynamic objects; their section list may be emptied by
6454 elf_link_add_object_symbols.
6456 Also check to see if there are no code sections in the input.
6457 In this case there is no need to check for code specific flags.
6458 XXX - do we need to worry about floating-point format compatability
6459 in data sections ? */
6460 if (!(ibfd->flags & DYNAMIC))
6462 bfd_boolean null_input_bfd = TRUE;
6463 bfd_boolean only_data_sections = TRUE;
6465 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
6467 /* Ignore synthetic glue sections. */
6468 if (strcmp (sec->name, ".glue_7")
6469 && strcmp (sec->name, ".glue_7t"))
6471 if ((bfd_get_section_flags (ibfd, sec)
6472 & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
6473 == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
6474 only_data_sections = FALSE;
6476 null_input_bfd = FALSE;
6481 if (null_input_bfd || only_data_sections)
6485 /* Complain about various flag mismatches. */
6486 if (!elf32_arm_versions_compatible (EF_ARM_EABI_VERSION (in_flags),
6487 EF_ARM_EABI_VERSION (out_flags)))
6490 (_("ERROR: Source object %B has EABI version %d, but target %B has EABI version %d"),
6492 (in_flags & EF_ARM_EABIMASK) >> 24,
6493 (out_flags & EF_ARM_EABIMASK) >> 24);
6497 /* Not sure what needs to be checked for EABI versions >= 1. */
6498 /* VxWorks libraries do not use these flags. */
6499 if (get_elf_backend_data (obfd) != &elf32_arm_vxworks_bed
6500 && get_elf_backend_data (ibfd) != &elf32_arm_vxworks_bed
6501 && EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
6503 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
6506 (_("ERROR: %B is compiled for APCS-%d, whereas target %B uses APCS-%d"),
6508 in_flags & EF_ARM_APCS_26 ? 26 : 32,
6509 out_flags & EF_ARM_APCS_26 ? 26 : 32);
6510 flags_compatible = FALSE;
6513 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
6515 if (in_flags & EF_ARM_APCS_FLOAT)
6517 (_("ERROR: %B passes floats in float registers, whereas %B passes them in integer registers"),
6521 (_("ERROR: %B passes floats in integer registers, whereas %B passes them in float registers"),
6524 flags_compatible = FALSE;
6527 if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT))
6529 if (in_flags & EF_ARM_VFP_FLOAT)
6531 (_("ERROR: %B uses VFP instructions, whereas %B does not"),
6535 (_("ERROR: %B uses FPA instructions, whereas %B does not"),
6538 flags_compatible = FALSE;
6541 if ((in_flags & EF_ARM_MAVERICK_FLOAT) != (out_flags & EF_ARM_MAVERICK_FLOAT))
6543 if (in_flags & EF_ARM_MAVERICK_FLOAT)
6545 (_("ERROR: %B uses Maverick instructions, whereas %B does not"),
6549 (_("ERROR: %B does not use Maverick instructions, whereas %B does"),
6552 flags_compatible = FALSE;
6555 #ifdef EF_ARM_SOFT_FLOAT
6556 if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
6558 /* We can allow interworking between code that is VFP format
6559 layout, and uses either soft float or integer regs for
6560 passing floating point arguments and results. We already
6561 know that the APCS_FLOAT flags match; similarly for VFP
6563 if ((in_flags & EF_ARM_APCS_FLOAT) != 0
6564 || (in_flags & EF_ARM_VFP_FLOAT) == 0)
6566 if (in_flags & EF_ARM_SOFT_FLOAT)
6568 (_("ERROR: %B uses software FP, whereas %B uses hardware FP"),
6572 (_("ERROR: %B uses hardware FP, whereas %B uses software FP"),
6575 flags_compatible = FALSE;
6580 /* Interworking mismatch is only a warning. */
6581 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
6583 if (in_flags & EF_ARM_INTERWORK)
6586 (_("Warning: %B supports interworking, whereas %B does not"),
6592 (_("Warning: %B does not support interworking, whereas %B does"),
6598 return flags_compatible;
6601 /* Display the flags field. */
6604 elf32_arm_print_private_bfd_data (bfd *abfd, void * ptr)
6606 FILE * file = (FILE *) ptr;
6607 unsigned long flags;
6609 BFD_ASSERT (abfd != NULL && ptr != NULL);
6611 /* Print normal ELF private data. */
6612 _bfd_elf_print_private_bfd_data (abfd, ptr);
6614 flags = elf_elfheader (abfd)->e_flags;
6615 /* Ignore init flag - it may not be set, despite the flags field
6616 containing valid data. */
6618 /* xgettext:c-format */
6619 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
6621 switch (EF_ARM_EABI_VERSION (flags))
6623 case EF_ARM_EABI_UNKNOWN:
6624 /* The following flag bits are GNU extensions and not part of the
6625 official ARM ELF extended ABI. Hence they are only decoded if
6626 the EABI version is not set. */
6627 if (flags & EF_ARM_INTERWORK)
6628 fprintf (file, _(" [interworking enabled]"));
6630 if (flags & EF_ARM_APCS_26)
6631 fprintf (file, " [APCS-26]");
6633 fprintf (file, " [APCS-32]");
6635 if (flags & EF_ARM_VFP_FLOAT)
6636 fprintf (file, _(" [VFP float format]"));
6637 else if (flags & EF_ARM_MAVERICK_FLOAT)
6638 fprintf (file, _(" [Maverick float format]"));
6640 fprintf (file, _(" [FPA float format]"));
6642 if (flags & EF_ARM_APCS_FLOAT)
6643 fprintf (file, _(" [floats passed in float registers]"));
6645 if (flags & EF_ARM_PIC)
6646 fprintf (file, _(" [position independent]"));
6648 if (flags & EF_ARM_NEW_ABI)
6649 fprintf (file, _(" [new ABI]"));
6651 if (flags & EF_ARM_OLD_ABI)
6652 fprintf (file, _(" [old ABI]"));
6654 if (flags & EF_ARM_SOFT_FLOAT)
6655 fprintf (file, _(" [software FP]"));
6657 flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT
6658 | EF_ARM_PIC | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI
6659 | EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT
6660 | EF_ARM_MAVERICK_FLOAT);
6663 case EF_ARM_EABI_VER1:
6664 fprintf (file, _(" [Version1 EABI]"));
6666 if (flags & EF_ARM_SYMSARESORTED)
6667 fprintf (file, _(" [sorted symbol table]"));
6669 fprintf (file, _(" [unsorted symbol table]"));
6671 flags &= ~ EF_ARM_SYMSARESORTED;
6674 case EF_ARM_EABI_VER2:
6675 fprintf (file, _(" [Version2 EABI]"));
6677 if (flags & EF_ARM_SYMSARESORTED)
6678 fprintf (file, _(" [sorted symbol table]"));
6680 fprintf (file, _(" [unsorted symbol table]"));
6682 if (flags & EF_ARM_DYNSYMSUSESEGIDX)
6683 fprintf (file, _(" [dynamic symbols use segment index]"));
6685 if (flags & EF_ARM_MAPSYMSFIRST)
6686 fprintf (file, _(" [mapping symbols precede others]"));
6688 flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX
6689 | EF_ARM_MAPSYMSFIRST);
6692 case EF_ARM_EABI_VER3:
6693 fprintf (file, _(" [Version3 EABI]"));
6696 case EF_ARM_EABI_VER4:
6697 fprintf (file, _(" [Version4 EABI]"));
6700 case EF_ARM_EABI_VER5:
6701 fprintf (file, _(" [Version5 EABI]"));
6703 if (flags & EF_ARM_BE8)
6704 fprintf (file, _(" [BE8]"));
6706 if (flags & EF_ARM_LE8)
6707 fprintf (file, _(" [LE8]"));
6709 flags &= ~(EF_ARM_LE8 | EF_ARM_BE8);
6713 fprintf (file, _(" <EABI version unrecognised>"));
6717 flags &= ~ EF_ARM_EABIMASK;
6719 if (flags & EF_ARM_RELEXEC)
6720 fprintf (file, _(" [relocatable executable]"));
6722 if (flags & EF_ARM_HASENTRY)
6723 fprintf (file, _(" [has entry point]"));
6725 flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
6728 fprintf (file, _("<Unrecognised flag bits set>"));
6736 elf32_arm_get_symbol_type (Elf_Internal_Sym * elf_sym, int type)
6738 switch (ELF_ST_TYPE (elf_sym->st_info))
6741 return ELF_ST_TYPE (elf_sym->st_info);
6744 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
6745 This allows us to distinguish between data used by Thumb instructions
6746 and non-data (which is probably code) inside Thumb regions of an
6748 if (type != STT_OBJECT && type != STT_TLS)
6749 return ELF_ST_TYPE (elf_sym->st_info);
6760 elf32_arm_gc_mark_hook (asection * sec,
6761 struct bfd_link_info * info ATTRIBUTE_UNUSED,
6762 Elf_Internal_Rela * rel,
6763 struct elf_link_hash_entry * h,
6764 Elf_Internal_Sym * sym)
6768 switch (ELF32_R_TYPE (rel->r_info))
6770 case R_ARM_GNU_VTINHERIT:
6771 case R_ARM_GNU_VTENTRY:
6775 switch (h->root.type)
6777 case bfd_link_hash_defined:
6778 case bfd_link_hash_defweak:
6779 return h->root.u.def.section;
6781 case bfd_link_hash_common:
6782 return h->root.u.c.p->section;
6790 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6795 /* Update the got entry reference counts for the section being removed. */
6798 elf32_arm_gc_sweep_hook (bfd * abfd,
6799 struct bfd_link_info * info,
6801 const Elf_Internal_Rela * relocs)
6803 Elf_Internal_Shdr *symtab_hdr;
6804 struct elf_link_hash_entry **sym_hashes;
6805 bfd_signed_vma *local_got_refcounts;
6806 const Elf_Internal_Rela *rel, *relend;
6807 struct elf32_arm_link_hash_table * globals;
6809 globals = elf32_arm_hash_table (info);
6811 elf_section_data (sec)->local_dynrel = NULL;
6813 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6814 sym_hashes = elf_sym_hashes (abfd);
6815 local_got_refcounts = elf_local_got_refcounts (abfd);
6817 relend = relocs + sec->reloc_count;
6818 for (rel = relocs; rel < relend; rel++)
6820 unsigned long r_symndx;
6821 struct elf_link_hash_entry *h = NULL;
6824 r_symndx = ELF32_R_SYM (rel->r_info);
6825 if (r_symndx >= symtab_hdr->sh_info)
6827 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6828 while (h->root.type == bfd_link_hash_indirect
6829 || h->root.type == bfd_link_hash_warning)
6830 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6833 r_type = ELF32_R_TYPE (rel->r_info);
6834 r_type = arm_real_reloc_type (globals, r_type);
6838 case R_ARM_GOT_PREL:
6839 case R_ARM_TLS_GD32:
6840 case R_ARM_TLS_IE32:
6843 if (h->got.refcount > 0)
6844 h->got.refcount -= 1;
6846 else if (local_got_refcounts != NULL)
6848 if (local_got_refcounts[r_symndx] > 0)
6849 local_got_refcounts[r_symndx] -= 1;
6853 case R_ARM_TLS_LDM32:
6854 elf32_arm_hash_table (info)->tls_ldm_got.refcount -= 1;
6858 case R_ARM_ABS32_NOI:
6860 case R_ARM_REL32_NOI:
6866 case R_ARM_THM_CALL:
6867 case R_ARM_MOVW_ABS_NC:
6868 case R_ARM_MOVT_ABS:
6869 case R_ARM_MOVW_PREL_NC:
6870 case R_ARM_MOVT_PREL:
6871 case R_ARM_THM_MOVW_ABS_NC:
6872 case R_ARM_THM_MOVT_ABS:
6873 case R_ARM_THM_MOVW_PREL_NC:
6874 case R_ARM_THM_MOVT_PREL:
6875 /* Should the interworking branches be here also? */
6879 struct elf32_arm_link_hash_entry *eh;
6880 struct elf32_arm_relocs_copied **pp;
6881 struct elf32_arm_relocs_copied *p;
6883 eh = (struct elf32_arm_link_hash_entry *) h;
6885 if (h->plt.refcount > 0)
6887 h->plt.refcount -= 1;
6888 if (ELF32_R_TYPE (rel->r_info) == R_ARM_THM_CALL)
6889 eh->plt_thumb_refcount--;
6892 if (r_type == R_ARM_ABS32
6893 || r_type == R_ARM_REL32
6894 || r_type == R_ARM_ABS32_NOI
6895 || r_type == R_ARM_REL32_NOI)
6897 for (pp = &eh->relocs_copied; (p = *pp) != NULL;
6899 if (p->section == sec)
6902 if (ELF32_R_TYPE (rel->r_info) == R_ARM_REL32
6903 || ELF32_R_TYPE (rel->r_info) == R_ARM_REL32_NOI)
6921 /* Look through the relocs for a section during the first phase. */
6924 elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info,
6925 asection *sec, const Elf_Internal_Rela *relocs)
6927 Elf_Internal_Shdr *symtab_hdr;
6928 struct elf_link_hash_entry **sym_hashes;
6929 struct elf_link_hash_entry **sym_hashes_end;
6930 const Elf_Internal_Rela *rel;
6931 const Elf_Internal_Rela *rel_end;
6934 bfd_vma *local_got_offsets;
6935 struct elf32_arm_link_hash_table *htab;
6937 if (info->relocatable)
6940 htab = elf32_arm_hash_table (info);
6943 /* Create dynamic sections for relocatable executables so that we can
6944 copy relocations. */
6945 if (htab->root.is_relocatable_executable
6946 && ! htab->root.dynamic_sections_created)
6948 if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
6952 dynobj = elf_hash_table (info)->dynobj;
6953 local_got_offsets = elf_local_got_offsets (abfd);
6955 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6956 sym_hashes = elf_sym_hashes (abfd);
6957 sym_hashes_end = sym_hashes
6958 + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
6960 if (!elf_bad_symtab (abfd))
6961 sym_hashes_end -= symtab_hdr->sh_info;
6963 rel_end = relocs + sec->reloc_count;
6964 for (rel = relocs; rel < rel_end; rel++)
6966 struct elf_link_hash_entry *h;
6967 struct elf32_arm_link_hash_entry *eh;
6968 unsigned long r_symndx;
6971 r_symndx = ELF32_R_SYM (rel->r_info);
6972 r_type = ELF32_R_TYPE (rel->r_info);
6973 r_type = arm_real_reloc_type (htab, r_type);
6975 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
6977 (*_bfd_error_handler) (_("%B: bad symbol index: %d"), abfd,
6982 if (r_symndx < symtab_hdr->sh_info)
6986 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6987 while (h->root.type == bfd_link_hash_indirect
6988 || h->root.type == bfd_link_hash_warning)
6989 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6992 eh = (struct elf32_arm_link_hash_entry *) h;
6997 case R_ARM_GOT_PREL:
6998 case R_ARM_TLS_GD32:
6999 case R_ARM_TLS_IE32:
7000 /* This symbol requires a global offset table entry. */
7002 int tls_type, old_tls_type;
7006 case R_ARM_TLS_GD32: tls_type = GOT_TLS_GD; break;
7007 case R_ARM_TLS_IE32: tls_type = GOT_TLS_IE; break;
7008 default: tls_type = GOT_NORMAL; break;
7014 old_tls_type = elf32_arm_hash_entry (h)->tls_type;
7018 bfd_signed_vma *local_got_refcounts;
7020 /* This is a global offset table entry for a local symbol. */
7021 local_got_refcounts = elf_local_got_refcounts (abfd);
7022 if (local_got_refcounts == NULL)
7026 size = symtab_hdr->sh_info;
7027 size *= (sizeof (bfd_signed_vma) + sizeof(char));
7028 local_got_refcounts = bfd_zalloc (abfd, size);
7029 if (local_got_refcounts == NULL)
7031 elf_local_got_refcounts (abfd) = local_got_refcounts;
7032 elf32_arm_local_got_tls_type (abfd)
7033 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
7035 local_got_refcounts[r_symndx] += 1;
7036 old_tls_type = elf32_arm_local_got_tls_type (abfd) [r_symndx];
7039 /* We will already have issued an error message if there is a
7040 TLS / non-TLS mismatch, based on the symbol type. We don't
7041 support any linker relaxations. So just combine any TLS
7043 if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
7044 && tls_type != GOT_NORMAL)
7045 tls_type |= old_tls_type;
7047 if (old_tls_type != tls_type)
7050 elf32_arm_hash_entry (h)->tls_type = tls_type;
7052 elf32_arm_local_got_tls_type (abfd) [r_symndx] = tls_type;
7057 case R_ARM_TLS_LDM32:
7058 if (r_type == R_ARM_TLS_LDM32)
7059 htab->tls_ldm_got.refcount++;
7062 case R_ARM_GOTOFF32:
7064 if (htab->sgot == NULL)
7066 if (htab->root.dynobj == NULL)
7067 htab->root.dynobj = abfd;
7068 if (!create_got_section (htab->root.dynobj, info))
7074 /* VxWorks uses dynamic R_ARM_ABS12 relocations for
7075 ldr __GOTT_INDEX__ offsets. */
7076 if (!htab->vxworks_p)
7081 case R_ARM_ABS32_NOI:
7083 case R_ARM_REL32_NOI:
7089 case R_ARM_THM_CALL:
7090 case R_ARM_MOVW_ABS_NC:
7091 case R_ARM_MOVT_ABS:
7092 case R_ARM_MOVW_PREL_NC:
7093 case R_ARM_MOVT_PREL:
7094 case R_ARM_THM_MOVW_ABS_NC:
7095 case R_ARM_THM_MOVT_ABS:
7096 case R_ARM_THM_MOVW_PREL_NC:
7097 case R_ARM_THM_MOVT_PREL:
7098 /* Should the interworking branches be listed here? */
7101 /* If this reloc is in a read-only section, we might
7102 need a copy reloc. We can't check reliably at this
7103 stage whether the section is read-only, as input
7104 sections have not yet been mapped to output sections.
7105 Tentatively set the flag for now, and correct in
7106 adjust_dynamic_symbol. */
7110 /* We may need a .plt entry if the function this reloc
7111 refers to is in a different object. We can't tell for
7112 sure yet, because something later might force the
7114 if (r_type != R_ARM_ABS32
7115 && r_type != R_ARM_REL32
7116 && r_type != R_ARM_ABS32_NOI
7117 && r_type != R_ARM_REL32_NOI)
7120 /* If we create a PLT entry, this relocation will reference
7121 it, even if it's an ABS32 relocation. */
7122 h->plt.refcount += 1;
7124 if (r_type == R_ARM_THM_CALL)
7125 eh->plt_thumb_refcount += 1;
7128 /* If we are creating a shared library or relocatable executable,
7129 and this is a reloc against a global symbol, or a non PC
7130 relative reloc against a local symbol, then we need to copy
7131 the reloc into the shared library. However, if we are linking
7132 with -Bsymbolic, we do not need to copy a reloc against a
7133 global symbol which is defined in an object we are
7134 including in the link (i.e., DEF_REGULAR is set). At
7135 this point we have not seen all the input files, so it is
7136 possible that DEF_REGULAR is not set now but will be set
7137 later (it is never cleared). We account for that
7138 possibility below by storing information in the
7139 relocs_copied field of the hash table entry. */
7140 if ((info->shared || htab->root.is_relocatable_executable)
7141 && (sec->flags & SEC_ALLOC) != 0
7142 && ((r_type == R_ARM_ABS32 || r_type == R_ARM_ABS32_NOI)
7143 || (h != NULL && ! h->needs_plt
7144 && (! info->symbolic || ! h->def_regular))))
7146 struct elf32_arm_relocs_copied *p, **head;
7148 /* When creating a shared object, we must copy these
7149 reloc types into the output file. We create a reloc
7150 section in dynobj and make room for this reloc. */
7155 name = (bfd_elf_string_from_elf_section
7157 elf_elfheader (abfd)->e_shstrndx,
7158 elf_section_data (sec)->rel_hdr.sh_name));
7162 BFD_ASSERT (reloc_section_p (htab, name, sec));
7164 sreloc = bfd_get_section_by_name (dynobj, name);
7169 flags = (SEC_HAS_CONTENTS | SEC_READONLY
7170 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
7171 if ((sec->flags & SEC_ALLOC) != 0
7172 /* BPABI objects never have dynamic
7173 relocations mapped. */
7174 && !htab->symbian_p)
7175 flags |= SEC_ALLOC | SEC_LOAD;
7176 sreloc = bfd_make_section_with_flags (dynobj,
7180 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
7184 elf_section_data (sec)->sreloc = sreloc;
7187 /* If this is a global symbol, we count the number of
7188 relocations we need for this symbol. */
7191 head = &((struct elf32_arm_link_hash_entry *) h)->relocs_copied;
7195 /* Track dynamic relocs needed for local syms too.
7196 We really need local syms available to do this
7202 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
7207 vpp = &elf_section_data (s)->local_dynrel;
7208 head = (struct elf32_arm_relocs_copied **) vpp;
7212 if (p == NULL || p->section != sec)
7214 bfd_size_type amt = sizeof *p;
7216 p = bfd_alloc (htab->root.dynobj, amt);
7226 if (r_type == R_ARM_REL32 || r_type == R_ARM_REL32_NOI)
7232 /* This relocation describes the C++ object vtable hierarchy.
7233 Reconstruct it for later use during GC. */
7234 case R_ARM_GNU_VTINHERIT:
7235 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
7239 /* This relocation describes which C++ vtable entries are actually
7240 used. Record for later use during GC. */
7241 case R_ARM_GNU_VTENTRY:
7242 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
7251 /* Treat mapping symbols as special target symbols. */
7254 elf32_arm_is_target_special_symbol (bfd * abfd ATTRIBUTE_UNUSED, asymbol * sym)
7256 return bfd_is_arm_special_symbol_name (sym->name,
7257 BFD_ARM_SPECIAL_SYM_TYPE_ANY);
7260 /* This is a copy of elf_find_function() from elf.c except that
7261 ARM mapping symbols are ignored when looking for function names
7262 and STT_ARM_TFUNC is considered to a function type. */
7265 arm_elf_find_function (bfd * abfd ATTRIBUTE_UNUSED,
7269 const char ** filename_ptr,
7270 const char ** functionname_ptr)
7272 const char * filename = NULL;
7273 asymbol * func = NULL;
7274 bfd_vma low_func = 0;
7277 for (p = symbols; *p != NULL; p++)
7281 q = (elf_symbol_type *) *p;
7283 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
7288 filename = bfd_asymbol_name (&q->symbol);
7293 /* Skip mapping symbols. */
7294 if ((q->symbol.flags & BSF_LOCAL)
7295 && bfd_is_arm_special_symbol_name (q->symbol.name,
7296 BFD_ARM_SPECIAL_SYM_TYPE_ANY))
7299 if (bfd_get_section (&q->symbol) == section
7300 && q->symbol.value >= low_func
7301 && q->symbol.value <= offset)
7303 func = (asymbol *) q;
7304 low_func = q->symbol.value;
7314 *filename_ptr = filename;
7315 if (functionname_ptr)
7316 *functionname_ptr = bfd_asymbol_name (func);
7322 /* Find the nearest line to a particular section and offset, for error
7323 reporting. This code is a duplicate of the code in elf.c, except
7324 that it uses arm_elf_find_function. */
7327 elf32_arm_find_nearest_line (bfd * abfd,
7331 const char ** filename_ptr,
7332 const char ** functionname_ptr,
7333 unsigned int * line_ptr)
7335 bfd_boolean found = FALSE;
7337 /* We skip _bfd_dwarf1_find_nearest_line since no known ARM toolchain uses it. */
7339 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
7340 filename_ptr, functionname_ptr,
7342 & elf_tdata (abfd)->dwarf2_find_line_info))
7344 if (!*functionname_ptr)
7345 arm_elf_find_function (abfd, section, symbols, offset,
7346 *filename_ptr ? NULL : filename_ptr,
7352 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
7353 & found, filename_ptr,
7354 functionname_ptr, line_ptr,
7355 & elf_tdata (abfd)->line_info))
7358 if (found && (*functionname_ptr || *line_ptr))
7361 if (symbols == NULL)
7364 if (! arm_elf_find_function (abfd, section, symbols, offset,
7365 filename_ptr, functionname_ptr))
7373 elf32_arm_find_inliner_info (bfd * abfd,
7374 const char ** filename_ptr,
7375 const char ** functionname_ptr,
7376 unsigned int * line_ptr)
7379 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
7380 functionname_ptr, line_ptr,
7381 & elf_tdata (abfd)->dwarf2_find_line_info);
7385 /* Adjust a symbol defined by a dynamic object and referenced by a
7386 regular object. The current definition is in some section of the
7387 dynamic object, but we're not including those sections. We have to
7388 change the definition to something the rest of the link can
7392 elf32_arm_adjust_dynamic_symbol (struct bfd_link_info * info,
7393 struct elf_link_hash_entry * h)
7397 unsigned int power_of_two;
7398 struct elf32_arm_link_hash_entry * eh;
7399 struct elf32_arm_link_hash_table *globals;
7401 globals = elf32_arm_hash_table (info);
7402 dynobj = elf_hash_table (info)->dynobj;
7404 /* Make sure we know what is going on here. */
7405 BFD_ASSERT (dynobj != NULL
7407 || h->u.weakdef != NULL
7410 && !h->def_regular)));
7412 eh = (struct elf32_arm_link_hash_entry *) h;
7414 /* If this is a function, put it in the procedure linkage table. We
7415 will fill in the contents of the procedure linkage table later,
7416 when we know the address of the .got section. */
7417 if (h->type == STT_FUNC || h->type == STT_ARM_TFUNC
7420 if (h->plt.refcount <= 0
7421 || SYMBOL_CALLS_LOCAL (info, h)
7422 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7423 && h->root.type == bfd_link_hash_undefweak))
7425 /* This case can occur if we saw a PLT32 reloc in an input
7426 file, but the symbol was never referred to by a dynamic
7427 object, or if all references were garbage collected. In
7428 such a case, we don't actually need to build a procedure
7429 linkage table, and we can just do a PC24 reloc instead. */
7430 h->plt.offset = (bfd_vma) -1;
7431 eh->plt_thumb_refcount = 0;
7439 /* It's possible that we incorrectly decided a .plt reloc was
7440 needed for an R_ARM_PC24 or similar reloc to a non-function sym
7441 in check_relocs. We can't decide accurately between function
7442 and non-function syms in check-relocs; Objects loaded later in
7443 the link may change h->type. So fix it now. */
7444 h->plt.offset = (bfd_vma) -1;
7445 eh->plt_thumb_refcount = 0;
7448 /* If this is a weak symbol, and there is a real definition, the
7449 processor independent code will have arranged for us to see the
7450 real definition first, and we can just use the same value. */
7451 if (h->u.weakdef != NULL)
7453 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7454 || h->u.weakdef->root.type == bfd_link_hash_defweak);
7455 h->root.u.def.section = h->u.weakdef->root.u.def.section;
7456 h->root.u.def.value = h->u.weakdef->root.u.def.value;
7460 /* If there are no non-GOT references, we do not need a copy
7462 if (!h->non_got_ref)
7465 /* This is a reference to a symbol defined by a dynamic object which
7466 is not a function. */
7468 /* If we are creating a shared library, we must presume that the
7469 only references to the symbol are via the global offset table.
7470 For such cases we need not do anything here; the relocations will
7471 be handled correctly by relocate_section. Relocatable executables
7472 can reference data in shared objects directly, so we don't need to
7473 do anything here. */
7474 if (info->shared || globals->root.is_relocatable_executable)
7479 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
7480 h->root.root.string);
7484 /* We must allocate the symbol in our .dynbss section, which will
7485 become part of the .bss section of the executable. There will be
7486 an entry for this symbol in the .dynsym section. The dynamic
7487 object will contain position independent code, so all references
7488 from the dynamic object to this symbol will go through the global
7489 offset table. The dynamic linker will use the .dynsym entry to
7490 determine the address it must put in the global offset table, so
7491 both the dynamic object and the regular object will refer to the
7492 same memory location for the variable. */
7493 s = bfd_get_section_by_name (dynobj, ".dynbss");
7494 BFD_ASSERT (s != NULL);
7496 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
7497 copy the initial value out of the dynamic object and into the
7498 runtime process image. We need to remember the offset into the
7499 .rel(a).bss section we are going to use. */
7500 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
7504 srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (globals, ".bss"));
7505 BFD_ASSERT (srel != NULL);
7506 srel->size += RELOC_SIZE (globals);
7510 /* We need to figure out the alignment required for this symbol. I
7511 have no idea how ELF linkers handle this. */
7512 power_of_two = bfd_log2 (h->size);
7513 if (power_of_two > 3)
7516 /* Apply the required alignment. */
7517 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
7518 if (power_of_two > bfd_get_section_alignment (dynobj, s))
7520 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
7524 /* Define the symbol as being at this point in the section. */
7525 h->root.u.def.section = s;
7526 h->root.u.def.value = s->size;
7528 /* Increment the section size to make room for the symbol. */
7534 /* Allocate space in .plt, .got and associated reloc sections for
7538 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
7540 struct bfd_link_info *info;
7541 struct elf32_arm_link_hash_table *htab;
7542 struct elf32_arm_link_hash_entry *eh;
7543 struct elf32_arm_relocs_copied *p;
7545 eh = (struct elf32_arm_link_hash_entry *) h;
7547 if (h->root.type == bfd_link_hash_indirect)
7550 if (h->root.type == bfd_link_hash_warning)
7551 /* When warning symbols are created, they **replace** the "real"
7552 entry in the hash table, thus we never get to see the real
7553 symbol in a hash traversal. So look at it now. */
7554 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7556 info = (struct bfd_link_info *) inf;
7557 htab = elf32_arm_hash_table (info);
7559 if (htab->root.dynamic_sections_created
7560 && h->plt.refcount > 0)
7562 /* Make sure this symbol is output as a dynamic symbol.
7563 Undefined weak syms won't yet be marked as dynamic. */
7564 if (h->dynindx == -1
7565 && !h->forced_local)
7567 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7572 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
7574 asection *s = htab->splt;
7576 /* If this is the first .plt entry, make room for the special
7579 s->size += htab->plt_header_size;
7581 h->plt.offset = s->size;
7583 /* If we will insert a Thumb trampoline before this PLT, leave room
7585 if (!htab->use_blx && eh->plt_thumb_refcount > 0)
7587 h->plt.offset += PLT_THUMB_STUB_SIZE;
7588 s->size += PLT_THUMB_STUB_SIZE;
7591 /* If this symbol is not defined in a regular file, and we are
7592 not generating a shared library, then set the symbol to this
7593 location in the .plt. This is required to make function
7594 pointers compare as equal between the normal executable and
7595 the shared library. */
7599 h->root.u.def.section = s;
7600 h->root.u.def.value = h->plt.offset;
7602 /* Make sure the function is not marked as Thumb, in case
7603 it is the target of an ABS32 relocation, which will
7604 point to the PLT entry. */
7605 if (ELF_ST_TYPE (h->type) == STT_ARM_TFUNC)
7606 h->type = ELF_ST_INFO (ELF_ST_BIND (h->type), STT_FUNC);
7609 /* Make room for this entry. */
7610 s->size += htab->plt_entry_size;
7612 if (!htab->symbian_p)
7614 /* We also need to make an entry in the .got.plt section, which
7615 will be placed in the .got section by the linker script. */
7616 eh->plt_got_offset = htab->sgotplt->size;
7617 htab->sgotplt->size += 4;
7620 /* We also need to make an entry in the .rel(a).plt section. */
7621 htab->srelplt->size += RELOC_SIZE (htab);
7623 /* VxWorks executables have a second set of relocations for
7624 each PLT entry. They go in a separate relocation section,
7625 which is processed by the kernel loader. */
7626 if (htab->vxworks_p && !info->shared)
7628 /* There is a relocation for the initial PLT entry:
7629 an R_ARM_32 relocation for _GLOBAL_OFFSET_TABLE_. */
7630 if (h->plt.offset == htab->plt_header_size)
7631 htab->srelplt2->size += RELOC_SIZE (htab);
7633 /* There are two extra relocations for each subsequent
7634 PLT entry: an R_ARM_32 relocation for the GOT entry,
7635 and an R_ARM_32 relocation for the PLT entry. */
7636 htab->srelplt2->size += RELOC_SIZE (htab) * 2;
7641 h->plt.offset = (bfd_vma) -1;
7647 h->plt.offset = (bfd_vma) -1;
7651 if (h->got.refcount > 0)
7655 int tls_type = elf32_arm_hash_entry (h)->tls_type;
7658 /* Make sure this symbol is output as a dynamic symbol.
7659 Undefined weak syms won't yet be marked as dynamic. */
7660 if (h->dynindx == -1
7661 && !h->forced_local)
7663 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7667 if (!htab->symbian_p)
7670 h->got.offset = s->size;
7672 if (tls_type == GOT_UNKNOWN)
7675 if (tls_type == GOT_NORMAL)
7676 /* Non-TLS symbols need one GOT slot. */
7680 if (tls_type & GOT_TLS_GD)
7681 /* R_ARM_TLS_GD32 needs 2 consecutive GOT slots. */
7683 if (tls_type & GOT_TLS_IE)
7684 /* R_ARM_TLS_IE32 needs one GOT slot. */
7688 dyn = htab->root.dynamic_sections_created;
7691 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
7693 || !SYMBOL_REFERENCES_LOCAL (info, h)))
7696 if (tls_type != GOT_NORMAL
7697 && (info->shared || indx != 0)
7698 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
7699 || h->root.type != bfd_link_hash_undefweak))
7701 if (tls_type & GOT_TLS_IE)
7702 htab->srelgot->size += RELOC_SIZE (htab);
7704 if (tls_type & GOT_TLS_GD)
7705 htab->srelgot->size += RELOC_SIZE (htab);
7707 if ((tls_type & GOT_TLS_GD) && indx != 0)
7708 htab->srelgot->size += RELOC_SIZE (htab);
7710 else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
7711 || h->root.type != bfd_link_hash_undefweak)
7713 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
7714 htab->srelgot->size += RELOC_SIZE (htab);
7718 h->got.offset = (bfd_vma) -1;
7720 /* Allocate stubs for exported Thumb functions on v4t. */
7721 if (!htab->use_blx && h->dynindx != -1
7722 && ELF_ST_TYPE (h->type) == STT_ARM_TFUNC
7723 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
7725 struct elf_link_hash_entry * th;
7726 struct bfd_link_hash_entry * bh;
7727 struct elf_link_hash_entry * myh;
7731 /* Create a new symbol to regist the real location of the function. */
7732 s = h->root.u.def.section;
7733 sprintf(name, "__real_%s", h->root.root.string);
7734 _bfd_generic_link_add_one_symbol (info, s->owner,
7735 name, BSF_GLOBAL, s,
7736 h->root.u.def.value,
7737 NULL, TRUE, FALSE, &bh);
7739 myh = (struct elf_link_hash_entry *) bh;
7740 myh->type = ELF_ST_INFO (STB_LOCAL, STT_ARM_TFUNC);
7741 myh->forced_local = 1;
7742 eh->export_glue = myh;
7743 th = record_arm_to_thumb_glue (info, h);
7744 /* Point the symbol at the stub. */
7745 h->type = ELF_ST_INFO (ELF_ST_BIND (h->type), STT_FUNC);
7746 h->root.u.def.section = th->root.u.def.section;
7747 h->root.u.def.value = th->root.u.def.value & ~1;
7750 if (eh->relocs_copied == NULL)
7753 /* In the shared -Bsymbolic case, discard space allocated for
7754 dynamic pc-relative relocs against symbols which turn out to be
7755 defined in regular objects. For the normal shared case, discard
7756 space for pc-relative relocs that have become local due to symbol
7757 visibility changes. */
7759 if (info->shared || htab->root.is_relocatable_executable)
7761 /* The only relocs that use pc_count are R_ARM_REL32 and
7762 R_ARM_REL32_NOI, which will appear on something like
7763 ".long foo - .". We want calls to protected symbols to resolve
7764 directly to the function rather than going via the plt. If people
7765 want function pointer comparisons to work as expected then they
7766 should avoid writing assembly like ".long foo - .". */
7767 if (SYMBOL_CALLS_LOCAL (info, h))
7769 struct elf32_arm_relocs_copied **pp;
7771 for (pp = &eh->relocs_copied; (p = *pp) != NULL; )
7773 p->count -= p->pc_count;
7782 /* Also discard relocs on undefined weak syms with non-default
7784 if (eh->relocs_copied != NULL
7785 && h->root.type == bfd_link_hash_undefweak)
7787 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
7788 eh->relocs_copied = NULL;
7790 /* Make sure undefined weak symbols are output as a dynamic
7792 else if (h->dynindx == -1
7793 && !h->forced_local)
7795 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7800 else if (htab->root.is_relocatable_executable && h->dynindx == -1
7801 && h->root.type == bfd_link_hash_new)
7803 /* Output absolute symbols so that we can create relocations
7804 against them. For normal symbols we output a relocation
7805 against the section that contains them. */
7806 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7813 /* For the non-shared case, discard space for relocs against
7814 symbols which turn out to need copy relocs or are not
7820 || (htab->root.dynamic_sections_created
7821 && (h->root.type == bfd_link_hash_undefweak
7822 || h->root.type == bfd_link_hash_undefined))))
7824 /* Make sure this symbol is output as a dynamic symbol.
7825 Undefined weak syms won't yet be marked as dynamic. */
7826 if (h->dynindx == -1
7827 && !h->forced_local)
7829 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7833 /* If that succeeded, we know we'll be keeping all the
7835 if (h->dynindx != -1)
7839 eh->relocs_copied = NULL;
7844 /* Finally, allocate space. */
7845 for (p = eh->relocs_copied; p != NULL; p = p->next)
7847 asection *sreloc = elf_section_data (p->section)->sreloc;
7848 sreloc->size += p->count * RELOC_SIZE (htab);
7854 /* Find any dynamic relocs that apply to read-only sections. */
7857 elf32_arm_readonly_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
7859 struct elf32_arm_link_hash_entry *eh;
7860 struct elf32_arm_relocs_copied *p;
7862 if (h->root.type == bfd_link_hash_warning)
7863 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7865 eh = (struct elf32_arm_link_hash_entry *) h;
7866 for (p = eh->relocs_copied; p != NULL; p = p->next)
7868 asection *s = p->section;
7870 if (s != NULL && (s->flags & SEC_READONLY) != 0)
7872 struct bfd_link_info *info = (struct bfd_link_info *) inf;
7874 info->flags |= DF_TEXTREL;
7876 /* Not an error, just cut short the traversal. */
7883 /* Set the sizes of the dynamic sections. */
7886 elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
7887 struct bfd_link_info * info)
7894 struct elf32_arm_link_hash_table *htab;
7896 htab = elf32_arm_hash_table (info);
7897 dynobj = elf_hash_table (info)->dynobj;
7898 BFD_ASSERT (dynobj != NULL);
7899 check_use_blx (htab);
7901 if (elf_hash_table (info)->dynamic_sections_created)
7903 /* Set the contents of the .interp section to the interpreter. */
7904 if (info->executable)
7906 s = bfd_get_section_by_name (dynobj, ".interp");
7907 BFD_ASSERT (s != NULL);
7908 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
7909 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
7913 /* Set up .got offsets for local syms, and space for local dynamic
7915 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7917 bfd_signed_vma *local_got;
7918 bfd_signed_vma *end_local_got;
7919 char *local_tls_type;
7920 bfd_size_type locsymcount;
7921 Elf_Internal_Shdr *symtab_hdr;
7924 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
7927 for (s = ibfd->sections; s != NULL; s = s->next)
7929 struct elf32_arm_relocs_copied *p;
7931 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
7933 if (!bfd_is_abs_section (p->section)
7934 && bfd_is_abs_section (p->section->output_section))
7936 /* Input section has been discarded, either because
7937 it is a copy of a linkonce section or due to
7938 linker script /DISCARD/, so we'll be discarding
7941 else if (p->count != 0)
7943 srel = elf_section_data (p->section)->sreloc;
7944 srel->size += p->count * RELOC_SIZE (htab);
7945 if ((p->section->output_section->flags & SEC_READONLY) != 0)
7946 info->flags |= DF_TEXTREL;
7951 local_got = elf_local_got_refcounts (ibfd);
7955 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
7956 locsymcount = symtab_hdr->sh_info;
7957 end_local_got = local_got + locsymcount;
7958 local_tls_type = elf32_arm_local_got_tls_type (ibfd);
7960 srel = htab->srelgot;
7961 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
7965 *local_got = s->size;
7966 if (*local_tls_type & GOT_TLS_GD)
7967 /* TLS_GD relocs need an 8-byte structure in the GOT. */
7969 if (*local_tls_type & GOT_TLS_IE)
7971 if (*local_tls_type == GOT_NORMAL)
7974 if (info->shared || *local_tls_type == GOT_TLS_GD)
7975 srel->size += RELOC_SIZE (htab);
7978 *local_got = (bfd_vma) -1;
7982 if (htab->tls_ldm_got.refcount > 0)
7984 /* Allocate two GOT entries and one dynamic relocation (if necessary)
7985 for R_ARM_TLS_LDM32 relocations. */
7986 htab->tls_ldm_got.offset = htab->sgot->size;
7987 htab->sgot->size += 8;
7989 htab->srelgot->size += RELOC_SIZE (htab);
7992 htab->tls_ldm_got.offset = -1;
7994 /* Allocate global sym .plt and .got entries, and space for global
7995 sym dynamic relocs. */
7996 elf_link_hash_traverse (& htab->root, allocate_dynrelocs, info);
7998 /* The check_relocs and adjust_dynamic_symbol entry points have
7999 determined the sizes of the various dynamic sections. Allocate
8003 for (s = dynobj->sections; s != NULL; s = s->next)
8007 if ((s->flags & SEC_LINKER_CREATED) == 0)
8010 /* It's OK to base decisions on the section name, because none
8011 of the dynobj section names depend upon the input files. */
8012 name = bfd_get_section_name (dynobj, s);
8014 if (strcmp (name, ".plt") == 0)
8016 /* Remember whether there is a PLT. */
8019 else if (strncmp (name, ".rel", 4) == 0)
8023 /* Remember whether there are any reloc sections other
8024 than .rel(a).plt and .rela.plt.unloaded. */
8025 if (s != htab->srelplt && s != htab->srelplt2)
8028 /* We use the reloc_count field as a counter if we need
8029 to copy relocs into the output file. */
8033 else if (strncmp (name, ".got", 4) != 0
8034 && strcmp (name, ".dynbss") != 0)
8036 /* It's not one of our sections, so don't allocate space. */
8042 /* If we don't need this section, strip it from the
8043 output file. This is mostly to handle .rel(a).bss and
8044 .rel(a).plt. We must create both sections in
8045 create_dynamic_sections, because they must be created
8046 before the linker maps input sections to output
8047 sections. The linker does that before
8048 adjust_dynamic_symbol is called, and it is that
8049 function which decides whether anything needs to go
8050 into these sections. */
8051 s->flags |= SEC_EXCLUDE;
8055 if ((s->flags & SEC_HAS_CONTENTS) == 0)
8058 /* Allocate memory for the section contents. */
8059 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
8060 if (s->contents == NULL)
8064 if (elf_hash_table (info)->dynamic_sections_created)
8066 /* Add some entries to the .dynamic section. We fill in the
8067 values later, in elf32_arm_finish_dynamic_sections, but we
8068 must add the entries now so that we get the correct size for
8069 the .dynamic section. The DT_DEBUG entry is filled in by the
8070 dynamic linker and used by the debugger. */
8071 #define add_dynamic_entry(TAG, VAL) \
8072 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
8074 if (info->executable)
8076 if (!add_dynamic_entry (DT_DEBUG, 0))
8082 if ( !add_dynamic_entry (DT_PLTGOT, 0)
8083 || !add_dynamic_entry (DT_PLTRELSZ, 0)
8084 || !add_dynamic_entry (DT_PLTREL,
8085 htab->use_rel ? DT_REL : DT_RELA)
8086 || !add_dynamic_entry (DT_JMPREL, 0))
8094 if (!add_dynamic_entry (DT_REL, 0)
8095 || !add_dynamic_entry (DT_RELSZ, 0)
8096 || !add_dynamic_entry (DT_RELENT, RELOC_SIZE (htab)))
8101 if (!add_dynamic_entry (DT_RELA, 0)
8102 || !add_dynamic_entry (DT_RELASZ, 0)
8103 || !add_dynamic_entry (DT_RELAENT, RELOC_SIZE (htab)))
8108 /* If any dynamic relocs apply to a read-only section,
8109 then we need a DT_TEXTREL entry. */
8110 if ((info->flags & DF_TEXTREL) == 0)
8111 elf_link_hash_traverse (&htab->root, elf32_arm_readonly_dynrelocs,
8114 if ((info->flags & DF_TEXTREL) != 0)
8116 if (!add_dynamic_entry (DT_TEXTREL, 0))
8120 #undef add_dynamic_entry
8125 /* Finish up dynamic symbol handling. We set the contents of various
8126 dynamic sections here. */
8129 elf32_arm_finish_dynamic_symbol (bfd * output_bfd, struct bfd_link_info * info,
8130 struct elf_link_hash_entry * h, Elf_Internal_Sym * sym)
8133 struct elf32_arm_link_hash_table *htab;
8134 struct elf32_arm_link_hash_entry *eh;
8136 dynobj = elf_hash_table (info)->dynobj;
8137 htab = elf32_arm_hash_table (info);
8138 eh = (struct elf32_arm_link_hash_entry *) h;
8140 if (h->plt.offset != (bfd_vma) -1)
8146 Elf_Internal_Rela rel;
8148 /* This symbol has an entry in the procedure linkage table. Set
8151 BFD_ASSERT (h->dynindx != -1);
8153 splt = bfd_get_section_by_name (dynobj, ".plt");
8154 srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (htab, ".plt"));
8155 BFD_ASSERT (splt != NULL && srel != NULL);
8157 /* Fill in the entry in the procedure linkage table. */
8158 if (htab->symbian_p)
8160 put_arm_insn (htab, output_bfd,
8161 elf32_arm_symbian_plt_entry[0],
8162 splt->contents + h->plt.offset);
8163 bfd_put_32 (output_bfd,
8164 elf32_arm_symbian_plt_entry[1],
8165 splt->contents + h->plt.offset + 4);
8167 /* Fill in the entry in the .rel.plt section. */
8168 rel.r_offset = (splt->output_section->vma
8169 + splt->output_offset
8170 + h->plt.offset + 4);
8171 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
8173 /* Get the index in the procedure linkage table which
8174 corresponds to this symbol. This is the index of this symbol
8175 in all the symbols for which we are making plt entries. The
8176 first entry in the procedure linkage table is reserved. */
8177 plt_index = ((h->plt.offset - htab->plt_header_size)
8178 / htab->plt_entry_size);
8182 bfd_vma got_offset, got_address, plt_address;
8183 bfd_vma got_displacement;
8187 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
8188 BFD_ASSERT (sgot != NULL);
8190 /* Get the offset into the .got.plt table of the entry that
8191 corresponds to this function. */
8192 got_offset = eh->plt_got_offset;
8194 /* Get the index in the procedure linkage table which
8195 corresponds to this symbol. This is the index of this symbol
8196 in all the symbols for which we are making plt entries. The
8197 first three entries in .got.plt are reserved; after that
8198 symbols appear in the same order as in .plt. */
8199 plt_index = (got_offset - 12) / 4;
8201 /* Calculate the address of the GOT entry. */
8202 got_address = (sgot->output_section->vma
8203 + sgot->output_offset
8206 /* ...and the address of the PLT entry. */
8207 plt_address = (splt->output_section->vma
8208 + splt->output_offset
8211 ptr = htab->splt->contents + h->plt.offset;
8212 if (htab->vxworks_p && info->shared)
8217 for (i = 0; i != htab->plt_entry_size / 4; i++, ptr += 4)
8219 val = elf32_arm_vxworks_shared_plt_entry[i];
8221 val |= got_address - sgot->output_section->vma;
8223 val |= plt_index * RELOC_SIZE (htab);
8224 if (i == 2 || i == 5)
8225 bfd_put_32 (output_bfd, val, ptr);
8227 put_arm_insn (htab, output_bfd, val, ptr);
8230 else if (htab->vxworks_p)
8235 for (i = 0; i != htab->plt_entry_size / 4; i++)
8237 val = elf32_arm_vxworks_exec_plt_entry[i];
8241 val |= 0xffffff & -((h->plt.offset + i * 4 + 8) >> 2);
8243 val |= plt_index * RELOC_SIZE (htab);
8244 if (i == 2 || i == 5)
8245 bfd_put_32 (output_bfd, val, ptr);
8247 put_arm_insn (htab, output_bfd, val, ptr);
8250 loc = (htab->srelplt2->contents
8251 + (plt_index * 2 + 1) * RELOC_SIZE (htab));
8253 /* Create the .rela.plt.unloaded R_ARM_ABS32 relocation
8254 referencing the GOT for this PLT entry. */
8255 rel.r_offset = plt_address + 8;
8256 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
8257 rel.r_addend = got_offset;
8258 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
8259 loc += RELOC_SIZE (htab);
8261 /* Create the R_ARM_ABS32 relocation referencing the
8262 beginning of the PLT for this GOT entry. */
8263 rel.r_offset = got_address;
8264 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_ARM_ABS32);
8266 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
8270 /* Calculate the displacement between the PLT slot and the
8271 entry in the GOT. The eight-byte offset accounts for the
8272 value produced by adding to pc in the first instruction
8274 got_displacement = got_address - (plt_address + 8);
8276 BFD_ASSERT ((got_displacement & 0xf0000000) == 0);
8278 if (!htab->use_blx && eh->plt_thumb_refcount > 0)
8280 put_thumb_insn (htab, output_bfd,
8281 elf32_arm_plt_thumb_stub[0], ptr - 4);
8282 put_thumb_insn (htab, output_bfd,
8283 elf32_arm_plt_thumb_stub[1], ptr - 2);
8286 put_arm_insn (htab, output_bfd,
8287 elf32_arm_plt_entry[0]
8288 | ((got_displacement & 0x0ff00000) >> 20),
8290 put_arm_insn (htab, output_bfd,
8291 elf32_arm_plt_entry[1]
8292 | ((got_displacement & 0x000ff000) >> 12),
8294 put_arm_insn (htab, output_bfd,
8295 elf32_arm_plt_entry[2]
8296 | (got_displacement & 0x00000fff),
8298 #ifdef FOUR_WORD_PLT
8299 bfd_put_32 (output_bfd, elf32_arm_plt_entry[3], ptr + 12);
8303 /* Fill in the entry in the global offset table. */
8304 bfd_put_32 (output_bfd,
8305 (splt->output_section->vma
8306 + splt->output_offset),
8307 sgot->contents + got_offset);
8309 /* Fill in the entry in the .rel(a).plt section. */
8311 rel.r_offset = got_address;
8312 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
8315 loc = srel->contents + plt_index * RELOC_SIZE (htab);
8316 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
8318 if (!h->def_regular)
8320 /* Mark the symbol as undefined, rather than as defined in
8321 the .plt section. Leave the value alone. */
8322 sym->st_shndx = SHN_UNDEF;
8323 /* If the symbol is weak, we do need to clear the value.
8324 Otherwise, the PLT entry would provide a definition for
8325 the symbol even if the symbol wasn't defined anywhere,
8326 and so the symbol would never be NULL. */
8327 if (!h->ref_regular_nonweak)
8332 if (h->got.offset != (bfd_vma) -1
8333 && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_GD) == 0
8334 && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_IE) == 0)
8338 Elf_Internal_Rela rel;
8342 /* This symbol has an entry in the global offset table. Set it
8344 sgot = bfd_get_section_by_name (dynobj, ".got");
8345 srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (htab, ".got"));
8346 BFD_ASSERT (sgot != NULL && srel != NULL);
8348 offset = (h->got.offset & ~(bfd_vma) 1);
8350 rel.r_offset = (sgot->output_section->vma
8351 + sgot->output_offset
8354 /* If this is a static link, or it is a -Bsymbolic link and the
8355 symbol is defined locally or was forced to be local because
8356 of a version file, we just want to emit a RELATIVE reloc.
8357 The entry in the global offset table will already have been
8358 initialized in the relocate_section function. */
8360 && SYMBOL_REFERENCES_LOCAL (info, h))
8362 BFD_ASSERT((h->got.offset & 1) != 0);
8363 rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
8366 rel.r_addend = bfd_get_32 (output_bfd, sgot->contents + offset);
8367 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset);
8372 BFD_ASSERT((h->got.offset & 1) == 0);
8373 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset);
8374 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
8377 loc = srel->contents + srel->reloc_count++ * RELOC_SIZE (htab);
8378 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
8384 Elf_Internal_Rela rel;
8387 /* This symbol needs a copy reloc. Set it up. */
8388 BFD_ASSERT (h->dynindx != -1
8389 && (h->root.type == bfd_link_hash_defined
8390 || h->root.type == bfd_link_hash_defweak));
8392 s = bfd_get_section_by_name (h->root.u.def.section->owner,
8393 RELOC_SECTION (htab, ".bss"));
8394 BFD_ASSERT (s != NULL);
8397 rel.r_offset = (h->root.u.def.value
8398 + h->root.u.def.section->output_section->vma
8399 + h->root.u.def.section->output_offset);
8400 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
8401 loc = s->contents + s->reloc_count++ * RELOC_SIZE (htab);
8402 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
8405 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. On VxWorks,
8406 the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: it is relative
8407 to the ".got" section. */
8408 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
8409 || (!htab->vxworks_p && h == htab->root.hgot))
8410 sym->st_shndx = SHN_ABS;
8415 /* Finish up the dynamic sections. */
8418 elf32_arm_finish_dynamic_sections (bfd * output_bfd, struct bfd_link_info * info)
8424 dynobj = elf_hash_table (info)->dynobj;
8426 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
8427 BFD_ASSERT (elf32_arm_hash_table (info)->symbian_p || sgot != NULL);
8428 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
8430 if (elf_hash_table (info)->dynamic_sections_created)
8433 Elf32_External_Dyn *dyncon, *dynconend;
8434 struct elf32_arm_link_hash_table *htab;
8436 htab = elf32_arm_hash_table (info);
8437 splt = bfd_get_section_by_name (dynobj, ".plt");
8438 BFD_ASSERT (splt != NULL && sdyn != NULL);
8440 dyncon = (Elf32_External_Dyn *) sdyn->contents;
8441 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
8443 for (; dyncon < dynconend; dyncon++)
8445 Elf_Internal_Dyn dyn;
8449 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
8460 goto get_vma_if_bpabi;
8463 goto get_vma_if_bpabi;
8466 goto get_vma_if_bpabi;
8468 name = ".gnu.version";
8469 goto get_vma_if_bpabi;
8471 name = ".gnu.version_d";
8472 goto get_vma_if_bpabi;
8474 name = ".gnu.version_r";
8475 goto get_vma_if_bpabi;
8481 name = RELOC_SECTION (htab, ".plt");
8483 s = bfd_get_section_by_name (output_bfd, name);
8484 BFD_ASSERT (s != NULL);
8485 if (!htab->symbian_p)
8486 dyn.d_un.d_ptr = s->vma;
8488 /* In the BPABI, tags in the PT_DYNAMIC section point
8489 at the file offset, not the memory address, for the
8490 convenience of the post linker. */
8491 dyn.d_un.d_ptr = s->filepos;
8492 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
8496 if (htab->symbian_p)
8501 s = bfd_get_section_by_name (output_bfd,
8502 RELOC_SECTION (htab, ".plt"));
8503 BFD_ASSERT (s != NULL);
8504 dyn.d_un.d_val = s->size;
8505 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
8510 if (!htab->symbian_p)
8512 /* My reading of the SVR4 ABI indicates that the
8513 procedure linkage table relocs (DT_JMPREL) should be
8514 included in the overall relocs (DT_REL). This is
8515 what Solaris does. However, UnixWare can not handle
8516 that case. Therefore, we override the DT_RELSZ entry
8517 here to make it not include the JMPREL relocs. Since
8518 the linker script arranges for .rel(a).plt to follow all
8519 other relocation sections, we don't have to worry
8520 about changing the DT_REL entry. */
8521 s = bfd_get_section_by_name (output_bfd,
8522 RELOC_SECTION (htab, ".plt"));
8524 dyn.d_un.d_val -= s->size;
8525 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
8532 /* In the BPABI, the DT_REL tag must point at the file
8533 offset, not the VMA, of the first relocation
8534 section. So, we use code similar to that in
8535 elflink.c, but do not check for SHF_ALLOC on the
8536 relcoation section, since relocations sections are
8537 never allocated under the BPABI. The comments above
8538 about Unixware notwithstanding, we include all of the
8539 relocations here. */
8540 if (htab->symbian_p)
8543 type = ((dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
8544 ? SHT_REL : SHT_RELA);
8546 for (i = 1; i < elf_numsections (output_bfd); i++)
8548 Elf_Internal_Shdr *hdr
8549 = elf_elfsections (output_bfd)[i];
8550 if (hdr->sh_type == type)
8552 if (dyn.d_tag == DT_RELSZ
8553 || dyn.d_tag == DT_RELASZ)
8554 dyn.d_un.d_val += hdr->sh_size;
8555 else if ((ufile_ptr) hdr->sh_offset
8556 <= dyn.d_un.d_val - 1)
8557 dyn.d_un.d_val = hdr->sh_offset;
8560 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
8564 /* Set the bottom bit of DT_INIT/FINI if the
8565 corresponding function is Thumb. */
8567 name = info->init_function;
8570 name = info->fini_function;
8572 /* If it wasn't set by elf_bfd_final_link
8573 then there is nothing to adjust. */
8574 if (dyn.d_un.d_val != 0)
8576 struct elf_link_hash_entry * eh;
8578 eh = elf_link_hash_lookup (elf_hash_table (info), name,
8579 FALSE, FALSE, TRUE);
8580 if (eh != (struct elf_link_hash_entry *) NULL
8581 && ELF_ST_TYPE (eh->type) == STT_ARM_TFUNC)
8583 dyn.d_un.d_val |= 1;
8584 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
8591 /* Fill in the first entry in the procedure linkage table. */
8592 if (splt->size > 0 && elf32_arm_hash_table (info)->plt_header_size)
8594 const bfd_vma *plt0_entry;
8595 bfd_vma got_address, plt_address, got_displacement;
8597 /* Calculate the addresses of the GOT and PLT. */
8598 got_address = sgot->output_section->vma + sgot->output_offset;
8599 plt_address = splt->output_section->vma + splt->output_offset;
8601 if (htab->vxworks_p)
8603 /* The VxWorks GOT is relocated by the dynamic linker.
8604 Therefore, we must emit relocations rather than simply
8605 computing the values now. */
8606 Elf_Internal_Rela rel;
8608 plt0_entry = elf32_arm_vxworks_exec_plt0_entry;
8609 put_arm_insn (htab, output_bfd, plt0_entry[0],
8610 splt->contents + 0);
8611 put_arm_insn (htab, output_bfd, plt0_entry[1],
8612 splt->contents + 4);
8613 put_arm_insn (htab, output_bfd, plt0_entry[2],
8614 splt->contents + 8);
8615 bfd_put_32 (output_bfd, got_address, splt->contents + 12);
8617 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_. */
8618 rel.r_offset = plt_address + 12;
8619 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
8621 SWAP_RELOC_OUT (htab) (output_bfd, &rel,
8622 htab->srelplt2->contents);
8626 got_displacement = got_address - (plt_address + 16);
8628 plt0_entry = elf32_arm_plt0_entry;
8629 put_arm_insn (htab, output_bfd, plt0_entry[0],
8630 splt->contents + 0);
8631 put_arm_insn (htab, output_bfd, plt0_entry[1],
8632 splt->contents + 4);
8633 put_arm_insn (htab, output_bfd, plt0_entry[2],
8634 splt->contents + 8);
8635 put_arm_insn (htab, output_bfd, plt0_entry[3],
8636 splt->contents + 12);
8638 #ifdef FOUR_WORD_PLT
8639 /* The displacement value goes in the otherwise-unused
8640 last word of the second entry. */
8641 bfd_put_32 (output_bfd, got_displacement, splt->contents + 28);
8643 bfd_put_32 (output_bfd, got_displacement, splt->contents + 16);
8648 /* UnixWare sets the entsize of .plt to 4, although that doesn't
8649 really seem like the right value. */
8650 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
8652 if (htab->vxworks_p && !info->shared && htab->splt->size > 0)
8654 /* Correct the .rel(a).plt.unloaded relocations. They will have
8655 incorrect symbol indexes. */
8659 num_plts = ((htab->splt->size - htab->plt_header_size)
8660 / htab->plt_entry_size);
8661 p = htab->srelplt2->contents + RELOC_SIZE (htab);
8663 for (; num_plts; num_plts--)
8665 Elf_Internal_Rela rel;
8667 SWAP_RELOC_IN (htab) (output_bfd, p, &rel);
8668 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
8669 SWAP_RELOC_OUT (htab) (output_bfd, &rel, p);
8670 p += RELOC_SIZE (htab);
8672 SWAP_RELOC_IN (htab) (output_bfd, p, &rel);
8673 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_ARM_ABS32);
8674 SWAP_RELOC_OUT (htab) (output_bfd, &rel, p);
8675 p += RELOC_SIZE (htab);
8680 /* Fill in the first three entries in the global offset table. */
8686 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
8688 bfd_put_32 (output_bfd,
8689 sdyn->output_section->vma + sdyn->output_offset,
8691 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
8692 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
8695 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
8702 elf32_arm_post_process_headers (bfd * abfd, struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
8704 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
8705 struct elf32_arm_link_hash_table *globals;
8707 i_ehdrp = elf_elfheader (abfd);
8709 if (EF_ARM_EABI_VERSION (i_ehdrp->e_flags) == EF_ARM_EABI_UNKNOWN)
8710 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_ARM;
8712 i_ehdrp->e_ident[EI_OSABI] = 0;
8713 i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
8717 globals = elf32_arm_hash_table (link_info);
8718 if (globals->byteswap_code)
8719 i_ehdrp->e_flags |= EF_ARM_BE8;
8723 static enum elf_reloc_type_class
8724 elf32_arm_reloc_type_class (const Elf_Internal_Rela *rela)
8726 switch ((int) ELF32_R_TYPE (rela->r_info))
8728 case R_ARM_RELATIVE:
8729 return reloc_class_relative;
8730 case R_ARM_JUMP_SLOT:
8731 return reloc_class_plt;
8733 return reloc_class_copy;
8735 return reloc_class_normal;
8739 /* Set the right machine number for an Arm ELF file. */
8742 elf32_arm_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
8744 if (hdr->sh_type == SHT_NOTE)
8745 *flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_CONTENTS;
8751 elf32_arm_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
8753 bfd_arm_update_notes (abfd, ARM_NOTE_SECTION);
8756 /* Return TRUE if this is an unwinding table entry. */
8759 is_arm_elf_unwind_section_name (bfd * abfd ATTRIBUTE_UNUSED, const char * name)
8763 len1 = sizeof (ELF_STRING_ARM_unwind) - 1;
8764 len2 = sizeof (ELF_STRING_ARM_unwind_once) - 1;
8765 return (strncmp (name, ELF_STRING_ARM_unwind, len1) == 0
8766 || strncmp (name, ELF_STRING_ARM_unwind_once, len2) == 0);
8770 /* Set the type and flags for an ARM section. We do this by
8771 the section name, which is a hack, but ought to work. */
8774 elf32_arm_fake_sections (bfd * abfd, Elf_Internal_Shdr * hdr, asection * sec)
8778 name = bfd_get_section_name (abfd, sec);
8780 if (is_arm_elf_unwind_section_name (abfd, name))
8782 hdr->sh_type = SHT_ARM_EXIDX;
8783 hdr->sh_flags |= SHF_LINK_ORDER;
8785 else if (strcmp(name, ".ARM.attributes") == 0)
8787 hdr->sh_type = SHT_ARM_ATTRIBUTES;
8792 /* Parse an Arm EABI attributes section. */
8794 elf32_arm_parse_attributes (bfd *abfd, Elf_Internal_Shdr * hdr)
8800 contents = bfd_malloc (hdr->sh_size);
8803 if (!bfd_get_section_contents (abfd, hdr->bfd_section, contents, 0,
8812 len = hdr->sh_size - 1;
8816 bfd_vma section_len;
8818 section_len = bfd_get_32 (abfd, p);
8820 if (section_len > len)
8823 namelen = strlen ((char *)p) + 1;
8824 section_len -= namelen + 4;
8825 if (strcmp((char *)p, "aeabi") != 0)
8827 /* Vendor section. Ignore it. */
8828 p += namelen + section_len;
8833 while (section_len > 0)
8838 bfd_vma subsection_len;
8841 tag = read_unsigned_leb128 (abfd, p, &n);
8843 subsection_len = bfd_get_32 (abfd, p);
8845 if (subsection_len > section_len)
8846 subsection_len = section_len;
8847 section_len -= subsection_len;
8848 subsection_len -= n + 4;
8849 end = p + subsection_len;
8855 bfd_boolean is_string;
8857 tag = read_unsigned_leb128 (abfd, p, &n);
8859 if (tag == 4 || tag == 5)
8864 is_string = (tag & 1) != 0;
8865 if (tag == Tag_compatibility)
8867 val = read_unsigned_leb128 (abfd, p, &n);
8869 elf32_arm_add_eabi_attr_compat (abfd, val,
8871 p += strlen ((char *)p) + 1;
8875 elf32_arm_add_eabi_attr_string (abfd, tag,
8877 p += strlen ((char *)p) + 1;
8881 val = read_unsigned_leb128 (abfd, p, &n);
8883 elf32_arm_add_eabi_attr_int (abfd, tag, val);
8889 /* Don't have anywhere convenient to attach these.
8890 Fall through for now. */
8892 /* Ignore things we don't kow about. */
8893 p += subsection_len;
8904 /* Handle an ARM specific section when reading an object file. This is
8905 called when bfd_section_from_shdr finds a section with an unknown
8909 elf32_arm_section_from_shdr (bfd *abfd,
8910 Elf_Internal_Shdr * hdr,
8914 /* There ought to be a place to keep ELF backend specific flags, but
8915 at the moment there isn't one. We just keep track of the
8916 sections by their name, instead. Fortunately, the ABI gives
8917 names for all the ARM specific sections, so we will probably get
8919 switch (hdr->sh_type)
8922 case SHT_ARM_PREEMPTMAP:
8923 case SHT_ARM_ATTRIBUTES:
8930 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
8933 if (hdr->sh_type == SHT_ARM_ATTRIBUTES)
8934 elf32_arm_parse_attributes(abfd, hdr);
8938 /* A structure used to record a list of sections, independently
8939 of the next and prev fields in the asection structure. */
8940 typedef struct section_list
8943 struct section_list * next;
8944 struct section_list * prev;
8948 /* Unfortunately we need to keep a list of sections for which
8949 an _arm_elf_section_data structure has been allocated. This
8950 is because it is possible for functions like elf32_arm_write_section
8951 to be called on a section which has had an elf_data_structure
8952 allocated for it (and so the used_by_bfd field is valid) but
8953 for which the ARM extended version of this structure - the
8954 _arm_elf_section_data structure - has not been allocated. */
8955 static section_list * sections_with_arm_elf_section_data = NULL;
8958 record_section_with_arm_elf_section_data (asection * sec)
8960 struct section_list * entry;
8962 entry = bfd_malloc (sizeof (* entry));
8966 entry->next = sections_with_arm_elf_section_data;
8968 if (entry->next != NULL)
8969 entry->next->prev = entry;
8970 sections_with_arm_elf_section_data = entry;
8973 static struct section_list *
8974 find_arm_elf_section_entry (asection * sec)
8976 struct section_list * entry;
8977 static struct section_list * last_entry = NULL;
8979 /* This is a short cut for the typical case where the sections are added
8980 to the sections_with_arm_elf_section_data list in forward order and
8981 then looked up here in backwards order. This makes a real difference
8982 to the ld-srec/sec64k.exp linker test. */
8983 entry = sections_with_arm_elf_section_data;
8984 if (last_entry != NULL)
8986 if (last_entry->sec == sec)
8988 else if (last_entry->next != NULL
8989 && last_entry->next->sec == sec)
8990 entry = last_entry->next;
8993 for (; entry; entry = entry->next)
8994 if (entry->sec == sec)
8998 /* Record the entry prior to this one - it is the entry we are most
8999 likely to want to locate next time. Also this way if we have been
9000 called from unrecord_section_with_arm_elf_section_data() we will not
9001 be caching a pointer that is about to be freed. */
9002 last_entry = entry->prev;
9007 static _arm_elf_section_data *
9008 get_arm_elf_section_data (asection * sec)
9010 struct section_list * entry;
9012 entry = find_arm_elf_section_entry (sec);
9015 return elf32_arm_section_data (entry->sec);
9021 unrecord_section_with_arm_elf_section_data (asection * sec)
9023 struct section_list * entry;
9025 entry = find_arm_elf_section_entry (sec);
9029 if (entry->prev != NULL)
9030 entry->prev->next = entry->next;
9031 if (entry->next != NULL)
9032 entry->next->prev = entry->prev;
9033 if (entry == sections_with_arm_elf_section_data)
9034 sections_with_arm_elf_section_data = entry->next;
9039 /* Called for each symbol. Builds a section map based on mapping symbols.
9040 Does not alter any of the symbols. */
9043 elf32_arm_output_symbol_hook (struct bfd_link_info *info,
9045 Elf_Internal_Sym *elfsym,
9046 asection *input_sec,
9047 struct elf_link_hash_entry *h)
9050 elf32_arm_section_map *map;
9051 elf32_arm_section_map *newmap;
9052 _arm_elf_section_data *arm_data;
9053 struct elf32_arm_link_hash_table *globals;
9055 globals = elf32_arm_hash_table (info);
9056 if (globals->vxworks_p
9057 && !elf_vxworks_link_output_symbol_hook (info, name, elfsym,
9061 /* Only do this on final link. */
9062 if (info->relocatable)
9065 /* Only build a map if we need to byteswap code. */
9066 if (!globals->byteswap_code)
9069 /* We only want mapping symbols. */
9070 if (!bfd_is_arm_special_symbol_name (name, BFD_ARM_SPECIAL_SYM_TYPE_MAP))
9073 /* If this section has not been allocated an _arm_elf_section_data
9074 structure then we cannot record anything. */
9075 arm_data = get_arm_elf_section_data (input_sec);
9076 if (arm_data == NULL)
9079 mapcount = arm_data->mapcount + 1;
9080 map = arm_data->map;
9082 /* TODO: This may be inefficient, but we probably don't usually have many
9083 mapping symbols per section. */
9084 newmap = bfd_realloc (map, mapcount * sizeof (* map));
9087 arm_data->map = newmap;
9088 arm_data->mapcount = mapcount;
9090 newmap[mapcount - 1].vma = elfsym->st_value;
9091 newmap[mapcount - 1].type = name[1];
9100 struct bfd_link_info *info;
9103 bfd_boolean (*func) (void *, const char *, Elf_Internal_Sym *,
9104 asection *, struct elf_link_hash_entry *);
9105 } output_arch_syminfo;
9107 enum map_symbol_type
9115 /* Output a single PLT mapping symbol. */
9118 elf32_arm_ouput_plt_map_sym (output_arch_syminfo *osi,
9119 enum map_symbol_type type,
9122 static const char *names[3] = {"$a", "$t", "$d"};
9123 struct elf32_arm_link_hash_table *htab;
9124 Elf_Internal_Sym sym;
9126 htab = elf32_arm_hash_table (osi->info);
9127 sym.st_value = osi->plt_offset + offset;
9130 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_NOTYPE);
9131 sym.st_shndx = osi->plt_shndx;
9132 if (!osi->func (osi->finfo, names[type], &sym, htab->splt, NULL))
9138 /* Output mapping symbols for PLT entries associated with H. */
9141 elf32_arm_output_plt_map (struct elf_link_hash_entry *h, void *inf)
9143 output_arch_syminfo *osi = (output_arch_syminfo *) inf;
9144 struct elf32_arm_link_hash_table *htab;
9145 struct elf32_arm_link_hash_entry *eh;
9148 htab = elf32_arm_hash_table (osi->info);
9150 if (h->root.type == bfd_link_hash_indirect)
9153 if (h->root.type == bfd_link_hash_warning)
9154 /* When warning symbols are created, they **replace** the "real"
9155 entry in the hash table, thus we never get to see the real
9156 symbol in a hash traversal. So look at it now. */
9157 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9159 if (h->plt.offset == (bfd_vma) -1)
9162 eh = (struct elf32_arm_link_hash_entry *) h;
9163 addr = h->plt.offset;
9164 if (htab->symbian_p)
9166 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_ARM, addr))
9168 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_DATA, addr + 4))
9171 else if (htab->vxworks_p)
9173 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_ARM, addr))
9175 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_DATA, addr + 8))
9177 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_ARM, addr + 12))
9179 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_DATA, addr + 20))
9184 bfd_boolean thumb_stub;
9186 thumb_stub = eh->plt_thumb_refcount > 0 && !htab->use_blx;
9189 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_THUMB, addr - 4))
9192 #ifdef FOUR_WORD_PLT
9193 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_ARM, addr))
9195 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_DATA, addr + 12))
9198 /* A three-word PLT with no Thumb thunk contains only Arm code,
9199 so only need to output a mapping symbol for the first PLT entry and
9200 entries with thumb thunks. */
9201 if (thumb_stub || addr == 20)
9203 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_ARM, addr))
9213 /* Output mapping symbols for the PLT. */
9216 elf32_arm_output_arch_local_syms (bfd *output_bfd,
9217 struct bfd_link_info *info,
9218 void *finfo, bfd_boolean (*func) (void *, const char *,
9221 struct elf_link_hash_entry *))
9223 output_arch_syminfo osi;
9224 struct elf32_arm_link_hash_table *htab;
9226 htab = elf32_arm_hash_table (info);
9227 if (!htab->splt || htab->splt->size == 0)
9230 check_use_blx(htab);
9234 osi.plt_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
9235 htab->splt->output_section);
9236 osi.plt_offset = htab->splt->output_section->vma;
9238 /* Output mapping symbols for the plt header. SymbianOS does not have a
9240 if (htab->vxworks_p)
9242 /* VxWorks shared libraries have no PLT header. */
9245 if (!elf32_arm_ouput_plt_map_sym (&osi, ARM_MAP_ARM, 0))
9247 if (!elf32_arm_ouput_plt_map_sym (&osi, ARM_MAP_DATA, 12))
9251 else if (!htab->symbian_p)
9253 if (!elf32_arm_ouput_plt_map_sym (&osi, ARM_MAP_ARM, 0))
9255 #ifndef FOUR_WORD_PLT
9256 if (!elf32_arm_ouput_plt_map_sym (&osi, ARM_MAP_DATA, 16))
9261 elf_link_hash_traverse (&htab->root, elf32_arm_output_plt_map, (void *) &osi);
9265 /* Allocate target specific section data. */
9268 elf32_arm_new_section_hook (bfd *abfd, asection *sec)
9270 _arm_elf_section_data *sdata;
9271 bfd_size_type amt = sizeof (*sdata);
9273 sdata = bfd_zalloc (abfd, amt);
9276 sec->used_by_bfd = sdata;
9278 record_section_with_arm_elf_section_data (sec);
9280 return _bfd_elf_new_section_hook (abfd, sec);
9284 /* Used to order a list of mapping symbols by address. */
9287 elf32_arm_compare_mapping (const void * a, const void * b)
9289 return ((const elf32_arm_section_map *) a)->vma
9290 > ((const elf32_arm_section_map *) b)->vma;
9294 /* Do code byteswapping. Return FALSE afterwards so that the section is
9295 written out as normal. */
9298 elf32_arm_write_section (bfd *output_bfd ATTRIBUTE_UNUSED, asection *sec,
9302 _arm_elf_section_data *arm_data;
9303 elf32_arm_section_map *map;
9310 /* If this section has not been allocated an _arm_elf_section_data
9311 structure then we cannot record anything. */
9312 arm_data = get_arm_elf_section_data (sec);
9313 if (arm_data == NULL)
9316 mapcount = arm_data->mapcount;
9317 map = arm_data->map;
9322 qsort (map, mapcount, sizeof (* map), elf32_arm_compare_mapping);
9324 offset = sec->output_section->vma + sec->output_offset;
9325 ptr = map[0].vma - offset;
9326 for (i = 0; i < mapcount; i++)
9328 if (i == mapcount - 1)
9331 end = map[i + 1].vma - offset;
9333 switch (map[i].type)
9336 /* Byte swap code words. */
9337 while (ptr + 3 < end)
9339 tmp = contents[ptr];
9340 contents[ptr] = contents[ptr + 3];
9341 contents[ptr + 3] = tmp;
9342 tmp = contents[ptr + 1];
9343 contents[ptr + 1] = contents[ptr + 2];
9344 contents[ptr + 2] = tmp;
9350 /* Byte swap code halfwords. */
9351 while (ptr + 1 < end)
9353 tmp = contents[ptr];
9354 contents[ptr] = contents[ptr + 1];
9355 contents[ptr + 1] = tmp;
9361 /* Leave data alone. */
9368 arm_data->mapcount = 0;
9369 arm_data->map = NULL;
9370 unrecord_section_with_arm_elf_section_data (sec);
9376 unrecord_section_via_map_over_sections (bfd * abfd ATTRIBUTE_UNUSED,
9378 void * ignore ATTRIBUTE_UNUSED)
9380 unrecord_section_with_arm_elf_section_data (sec);
9384 elf32_arm_close_and_cleanup (bfd * abfd)
9386 bfd_map_over_sections (abfd, unrecord_section_via_map_over_sections, NULL);
9388 return _bfd_elf_close_and_cleanup (abfd);
9391 /* Display STT_ARM_TFUNC symbols as functions. */
9394 elf32_arm_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
9397 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
9399 if (ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_ARM_TFUNC)
9400 elfsym->symbol.flags |= BSF_FUNCTION;
9404 /* Mangle thumb function symbols as we read them in. */
9407 elf32_arm_swap_symbol_in (bfd * abfd,
9410 Elf_Internal_Sym *dst)
9412 bfd_elf32_swap_symbol_in (abfd, psrc, pshn, dst);
9414 /* New EABI objects mark thumb function symbols by setting the low bit of
9415 the address. Turn these into STT_ARM_TFUNC. */
9416 if (ELF_ST_TYPE (dst->st_info) == STT_FUNC
9417 && (dst->st_value & 1))
9419 dst->st_info = ELF_ST_INFO (ELF_ST_BIND (dst->st_info), STT_ARM_TFUNC);
9420 dst->st_value &= ~(bfd_vma) 1;
9425 /* Mangle thumb function symbols as we write them out. */
9428 elf32_arm_swap_symbol_out (bfd *abfd,
9429 const Elf_Internal_Sym *src,
9433 Elf_Internal_Sym newsym;
9435 /* We convert STT_ARM_TFUNC symbols into STT_FUNC with the low bit
9436 of the address set, as per the new EABI. We do this unconditionally
9437 because objcopy does not set the elf header flags until after
9438 it writes out the symbol table. */
9439 if (ELF_ST_TYPE (src->st_info) == STT_ARM_TFUNC)
9442 newsym.st_info = ELF_ST_INFO (ELF_ST_BIND (src->st_info), STT_FUNC);
9443 if (newsym.st_shndx != SHN_UNDEF)
9445 /* Do this only for defined symbols. At link type, the static
9446 linker will simulate the work of dynamic linker of resolving
9447 symbols and will carry over the thumbness of found symbols to
9448 the output symbol table. It's not clear how it happens, but
9449 the thumbness of underfined symbols can well be different at
9450 runtime, and writing '1' for them will be confusing for users
9451 and possibly for dynamic linker itself.
9453 newsym.st_value |= 1;
9458 bfd_elf32_swap_symbol_out (abfd, src, cdst, shndx);
9461 /* Add the PT_ARM_EXIDX program header. */
9464 elf32_arm_modify_segment_map (bfd *abfd,
9465 struct bfd_link_info *info ATTRIBUTE_UNUSED)
9467 struct elf_segment_map *m;
9470 sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
9471 if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
9473 /* If there is already a PT_ARM_EXIDX header, then we do not
9474 want to add another one. This situation arises when running
9475 "strip"; the input binary already has the header. */
9476 m = elf_tdata (abfd)->segment_map;
9477 while (m && m->p_type != PT_ARM_EXIDX)
9481 m = bfd_zalloc (abfd, sizeof (struct elf_segment_map));
9484 m->p_type = PT_ARM_EXIDX;
9486 m->sections[0] = sec;
9488 m->next = elf_tdata (abfd)->segment_map;
9489 elf_tdata (abfd)->segment_map = m;
9496 /* We may add a PT_ARM_EXIDX program header. */
9499 elf32_arm_additional_program_headers (bfd *abfd)
9503 sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
9504 if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
9510 /* We use this to override swap_symbol_in and swap_symbol_out. */
9511 const struct elf_size_info elf32_arm_size_info = {
9512 sizeof (Elf32_External_Ehdr),
9513 sizeof (Elf32_External_Phdr),
9514 sizeof (Elf32_External_Shdr),
9515 sizeof (Elf32_External_Rel),
9516 sizeof (Elf32_External_Rela),
9517 sizeof (Elf32_External_Sym),
9518 sizeof (Elf32_External_Dyn),
9519 sizeof (Elf_External_Note),
9523 ELFCLASS32, EV_CURRENT,
9524 bfd_elf32_write_out_phdrs,
9525 bfd_elf32_write_shdrs_and_ehdr,
9526 bfd_elf32_write_relocs,
9527 elf32_arm_swap_symbol_in,
9528 elf32_arm_swap_symbol_out,
9529 bfd_elf32_slurp_reloc_table,
9530 bfd_elf32_slurp_symbol_table,
9531 bfd_elf32_swap_dyn_in,
9532 bfd_elf32_swap_dyn_out,
9533 bfd_elf32_swap_reloc_in,
9534 bfd_elf32_swap_reloc_out,
9535 bfd_elf32_swap_reloca_in,
9536 bfd_elf32_swap_reloca_out
9539 #define ELF_ARCH bfd_arch_arm
9540 #define ELF_MACHINE_CODE EM_ARM
9541 #ifdef __QNXTARGET__
9542 #define ELF_MAXPAGESIZE 0x1000
9544 #define ELF_MAXPAGESIZE 0x8000
9546 #define ELF_MINPAGESIZE 0x1000
9548 #define bfd_elf32_mkobject elf32_arm_mkobject
9550 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
9551 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
9552 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
9553 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
9554 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
9555 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
9556 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
9557 #define bfd_elf32_find_inliner_info elf32_arm_find_inliner_info
9558 #define bfd_elf32_new_section_hook elf32_arm_new_section_hook
9559 #define bfd_elf32_bfd_is_target_special_symbol elf32_arm_is_target_special_symbol
9560 #define bfd_elf32_close_and_cleanup elf32_arm_close_and_cleanup
9561 #define bfd_elf32_bfd_final_link elf32_arm_bfd_final_link
9563 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
9564 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
9565 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
9566 #define elf_backend_check_relocs elf32_arm_check_relocs
9567 #define elf_backend_relocate_section elf32_arm_relocate_section
9568 #define elf_backend_write_section elf32_arm_write_section
9569 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
9570 #define elf_backend_create_dynamic_sections elf32_arm_create_dynamic_sections
9571 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
9572 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
9573 #define elf_backend_link_output_symbol_hook elf32_arm_output_symbol_hook
9574 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
9575 #define elf_backend_post_process_headers elf32_arm_post_process_headers
9576 #define elf_backend_reloc_type_class elf32_arm_reloc_type_class
9577 #define elf_backend_object_p elf32_arm_object_p
9578 #define elf_backend_section_flags elf32_arm_section_flags
9579 #define elf_backend_fake_sections elf32_arm_fake_sections
9580 #define elf_backend_section_from_shdr elf32_arm_section_from_shdr
9581 #define elf_backend_final_write_processing elf32_arm_final_write_processing
9582 #define elf_backend_copy_indirect_symbol elf32_arm_copy_indirect_symbol
9583 #define elf_backend_symbol_processing elf32_arm_symbol_processing
9584 #define elf_backend_size_info elf32_arm_size_info
9585 #define elf_backend_modify_segment_map elf32_arm_modify_segment_map
9586 #define elf_backend_additional_program_headers \
9587 elf32_arm_additional_program_headers
9588 #define elf_backend_output_arch_local_syms \
9589 elf32_arm_output_arch_local_syms
9590 #define elf_backend_begin_write_processing \
9591 elf32_arm_begin_write_processing
9593 #define elf_backend_can_refcount 1
9594 #define elf_backend_can_gc_sections 1
9595 #define elf_backend_plt_readonly 1
9596 #define elf_backend_want_got_plt 1
9597 #define elf_backend_want_plt_sym 0
9598 #define elf_backend_may_use_rel_p 1
9599 #define elf_backend_may_use_rela_p 0
9600 #define elf_backend_default_use_rela_p 0
9601 #define elf_backend_rela_normal 0
9603 #define elf_backend_got_header_size 12
9605 #include "elf32-target.h"
9607 /* VxWorks Targets */
9609 #undef TARGET_LITTLE_SYM
9610 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_vxworks_vec
9611 #undef TARGET_LITTLE_NAME
9612 #define TARGET_LITTLE_NAME "elf32-littlearm-vxworks"
9613 #undef TARGET_BIG_SYM
9614 #define TARGET_BIG_SYM bfd_elf32_bigarm_vxworks_vec
9615 #undef TARGET_BIG_NAME
9616 #define TARGET_BIG_NAME "elf32-bigarm-vxworks"
9618 /* Like elf32_arm_link_hash_table_create -- but overrides
9619 appropriately for VxWorks. */
9620 static struct bfd_link_hash_table *
9621 elf32_arm_vxworks_link_hash_table_create (bfd *abfd)
9623 struct bfd_link_hash_table *ret;
9625 ret = elf32_arm_link_hash_table_create (abfd);
9628 struct elf32_arm_link_hash_table *htab
9629 = (struct elf32_arm_link_hash_table *) ret;
9631 htab->vxworks_p = 1;
9637 elf32_arm_vxworks_final_write_processing (bfd *abfd, bfd_boolean linker)
9639 elf32_arm_final_write_processing (abfd, linker);
9640 elf_vxworks_final_write_processing (abfd, linker);
9644 #define elf32_bed elf32_arm_vxworks_bed
9646 #undef bfd_elf32_bfd_link_hash_table_create
9647 #define bfd_elf32_bfd_link_hash_table_create \
9648 elf32_arm_vxworks_link_hash_table_create
9649 #undef elf_backend_add_symbol_hook
9650 #define elf_backend_add_symbol_hook \
9651 elf_vxworks_add_symbol_hook
9652 #undef elf_backend_final_write_processing
9653 #define elf_backend_final_write_processing \
9654 elf32_arm_vxworks_final_write_processing
9655 #undef elf_backend_emit_relocs
9656 #define elf_backend_emit_relocs \
9657 elf_vxworks_emit_relocs
9659 #undef elf_backend_may_use_rel_p
9660 #define elf_backend_may_use_rel_p 0
9661 #undef elf_backend_may_use_rela_p
9662 #define elf_backend_may_use_rela_p 1
9663 #undef elf_backend_default_use_rela_p
9664 #define elf_backend_default_use_rela_p 1
9665 #undef elf_backend_rela_normal
9666 #define elf_backend_rela_normal 1
9667 #undef elf_backend_want_plt_sym
9668 #define elf_backend_want_plt_sym 1
9669 #undef ELF_MAXPAGESIZE
9670 #define ELF_MAXPAGESIZE 0x1000
9672 #include "elf32-target.h"
9675 /* Symbian OS Targets */
9677 #undef TARGET_LITTLE_SYM
9678 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_symbian_vec
9679 #undef TARGET_LITTLE_NAME
9680 #define TARGET_LITTLE_NAME "elf32-littlearm-symbian"
9681 #undef TARGET_BIG_SYM
9682 #define TARGET_BIG_SYM bfd_elf32_bigarm_symbian_vec
9683 #undef TARGET_BIG_NAME
9684 #define TARGET_BIG_NAME "elf32-bigarm-symbian"
9686 /* Like elf32_arm_link_hash_table_create -- but overrides
9687 appropriately for Symbian OS. */
9688 static struct bfd_link_hash_table *
9689 elf32_arm_symbian_link_hash_table_create (bfd *abfd)
9691 struct bfd_link_hash_table *ret;
9693 ret = elf32_arm_link_hash_table_create (abfd);
9696 struct elf32_arm_link_hash_table *htab
9697 = (struct elf32_arm_link_hash_table *)ret;
9698 /* There is no PLT header for Symbian OS. */
9699 htab->plt_header_size = 0;
9700 /* The PLT entries are each three instructions. */
9701 htab->plt_entry_size = 4 * NUM_ELEM (elf32_arm_symbian_plt_entry);
9702 htab->symbian_p = 1;
9703 /* Symbian uses armv5t or above, so use_blx is always true. */
9705 htab->root.is_relocatable_executable = 1;
9710 static const struct bfd_elf_special_section
9711 elf32_arm_symbian_special_sections[] =
9713 /* In a BPABI executable, the dynamic linking sections do not go in
9714 the loadable read-only segment. The post-linker may wish to
9715 refer to these sections, but they are not part of the final
9717 { ".dynamic", 8, 0, SHT_DYNAMIC, 0 },
9718 { ".dynstr", 7, 0, SHT_STRTAB, 0 },
9719 { ".dynsym", 7, 0, SHT_DYNSYM, 0 },
9720 { ".got", 4, 0, SHT_PROGBITS, 0 },
9721 { ".hash", 5, 0, SHT_HASH, 0 },
9722 /* These sections do not need to be writable as the SymbianOS
9723 postlinker will arrange things so that no dynamic relocation is
9725 { ".init_array", 11, 0, SHT_INIT_ARRAY, SHF_ALLOC },
9726 { ".fini_array", 11, 0, SHT_FINI_ARRAY, SHF_ALLOC },
9727 { ".preinit_array", 14, 0, SHT_PREINIT_ARRAY, SHF_ALLOC },
9728 { NULL, 0, 0, 0, 0 }
9732 elf32_arm_symbian_begin_write_processing (bfd *abfd,
9733 struct bfd_link_info *link_info)
9735 /* BPABI objects are never loaded directly by an OS kernel; they are
9736 processed by a postlinker first, into an OS-specific format. If
9737 the D_PAGED bit is set on the file, BFD will align segments on
9738 page boundaries, so that an OS can directly map the file. With
9739 BPABI objects, that just results in wasted space. In addition,
9740 because we clear the D_PAGED bit, map_sections_to_segments will
9741 recognize that the program headers should not be mapped into any
9742 loadable segment. */
9743 abfd->flags &= ~D_PAGED;
9744 elf32_arm_begin_write_processing(abfd, link_info);
9748 elf32_arm_symbian_modify_segment_map (bfd *abfd,
9749 struct bfd_link_info *info)
9751 struct elf_segment_map *m;
9754 /* BPABI shared libraries and executables should have a PT_DYNAMIC
9755 segment. However, because the .dynamic section is not marked
9756 with SEC_LOAD, the generic ELF code will not create such a
9758 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
9761 m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
9762 m->next = elf_tdata (abfd)->segment_map;
9763 elf_tdata (abfd)->segment_map = m;
9766 /* Also call the generic arm routine. */
9767 return elf32_arm_modify_segment_map (abfd, info);
9771 #define elf32_bed elf32_arm_symbian_bed
9773 /* The dynamic sections are not allocated on SymbianOS; the postlinker
9774 will process them and then discard them. */
9775 #undef ELF_DYNAMIC_SEC_FLAGS
9776 #define ELF_DYNAMIC_SEC_FLAGS \
9777 (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED)
9779 #undef bfd_elf32_bfd_link_hash_table_create
9780 #define bfd_elf32_bfd_link_hash_table_create \
9781 elf32_arm_symbian_link_hash_table_create
9782 #undef elf_backend_add_symbol_hook
9784 #undef elf_backend_special_sections
9785 #define elf_backend_special_sections elf32_arm_symbian_special_sections
9787 #undef elf_backend_begin_write_processing
9788 #define elf_backend_begin_write_processing \
9789 elf32_arm_symbian_begin_write_processing
9790 #undef elf_backend_final_write_processing
9791 #define elf_backend_final_write_processing \
9792 elf32_arm_final_write_processing
9793 #undef elf_backend_emit_relocs
9795 #undef elf_backend_modify_segment_map
9796 #define elf_backend_modify_segment_map elf32_arm_symbian_modify_segment_map
9798 /* There is no .got section for BPABI objects, and hence no header. */
9799 #undef elf_backend_got_header_size
9800 #define elf_backend_got_header_size 0
9802 /* Similarly, there is no .got.plt section. */
9803 #undef elf_backend_want_got_plt
9804 #define elf_backend_want_got_plt 0
9806 #undef elf_backend_may_use_rel_p
9807 #define elf_backend_may_use_rel_p 1
9808 #undef elf_backend_may_use_rela_p
9809 #define elf_backend_may_use_rela_p 0
9810 #undef elf_backend_default_use_rela_p
9811 #define elf_backend_default_use_rela_p 0
9812 #undef elf_backend_rela_normal
9813 #define elf_backend_rela_normal 0
9814 #undef elf_backend_want_plt_sym
9815 #define elf_backend_want_plt_sym 0
9816 #undef ELF_MAXPAGESIZE
9817 #define ELF_MAXPAGESIZE 0x8000
9819 #include "elf32-target.h"
projects / external / binutils.git / blob