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_PC13, /* type */
135 0, /* size (0 = byte, 1 = short, 2 = long) */
137 FALSE, /* pc_relative */
139 complain_overflow_bitfield,/* complain_on_overflow */
140 bfd_elf_generic_reloc, /* special_function */
141 "R_ARM_PC13", /* name */
142 FALSE, /* partial_inplace */
143 0x000000ff, /* src_mask */
144 0x000000ff, /* dst_mask */
145 FALSE), /* 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 /* FIXME: Has two more bits of offset in Thumb32. */
221 HOWTO (R_ARM_THM_CALL, /* type */
223 2, /* size (0 = byte, 1 = short, 2 = long) */
225 TRUE, /* pc_relative */
227 complain_overflow_signed,/* complain_on_overflow */
228 bfd_elf_generic_reloc, /* special_function */
229 "R_ARM_THM_CALL", /* name */
230 FALSE, /* partial_inplace */
231 0x07ff07ff, /* src_mask */
232 0x07ff07ff, /* dst_mask */
233 TRUE), /* pcrel_offset */
235 HOWTO (R_ARM_THM_PC8, /* type */
237 1, /* size (0 = byte, 1 = short, 2 = long) */
239 TRUE, /* pc_relative */
241 complain_overflow_signed,/* complain_on_overflow */
242 bfd_elf_generic_reloc, /* special_function */
243 "R_ARM_THM_PC8", /* name */
244 FALSE, /* partial_inplace */
245 0x000000ff, /* src_mask */
246 0x000000ff, /* dst_mask */
247 TRUE), /* pcrel_offset */
249 HOWTO (R_ARM_BREL_ADJ, /* type */
251 1, /* size (0 = byte, 1 = short, 2 = long) */
253 FALSE, /* pc_relative */
255 complain_overflow_signed,/* complain_on_overflow */
256 bfd_elf_generic_reloc, /* special_function */
257 "R_ARM_BREL_ADJ", /* name */
258 FALSE, /* partial_inplace */
259 0xffffffff, /* src_mask */
260 0xffffffff, /* dst_mask */
261 FALSE), /* pcrel_offset */
263 HOWTO (R_ARM_SWI24, /* type */
265 0, /* size (0 = byte, 1 = short, 2 = long) */
267 FALSE, /* pc_relative */
269 complain_overflow_signed,/* complain_on_overflow */
270 bfd_elf_generic_reloc, /* special_function */
271 "R_ARM_SWI24", /* name */
272 FALSE, /* partial_inplace */
273 0x00000000, /* src_mask */
274 0x00000000, /* dst_mask */
275 FALSE), /* pcrel_offset */
277 HOWTO (R_ARM_THM_SWI8, /* type */
279 0, /* size (0 = byte, 1 = short, 2 = long) */
281 FALSE, /* pc_relative */
283 complain_overflow_signed,/* complain_on_overflow */
284 bfd_elf_generic_reloc, /* special_function */
285 "R_ARM_SWI8", /* name */
286 FALSE, /* partial_inplace */
287 0x00000000, /* src_mask */
288 0x00000000, /* dst_mask */
289 FALSE), /* pcrel_offset */
291 /* BLX instruction for the ARM. */
292 HOWTO (R_ARM_XPC25, /* type */
294 2, /* size (0 = byte, 1 = short, 2 = long) */
296 TRUE, /* pc_relative */
298 complain_overflow_signed,/* complain_on_overflow */
299 bfd_elf_generic_reloc, /* special_function */
300 "R_ARM_XPC25", /* name */
301 FALSE, /* partial_inplace */
302 0x00ffffff, /* src_mask */
303 0x00ffffff, /* dst_mask */
304 TRUE), /* pcrel_offset */
306 /* BLX instruction for the Thumb. */
307 HOWTO (R_ARM_THM_XPC22, /* type */
309 2, /* size (0 = byte, 1 = short, 2 = long) */
311 TRUE, /* pc_relative */
313 complain_overflow_signed,/* complain_on_overflow */
314 bfd_elf_generic_reloc, /* special_function */
315 "R_ARM_THM_XPC22", /* name */
316 FALSE, /* partial_inplace */
317 0x07ff07ff, /* src_mask */
318 0x07ff07ff, /* dst_mask */
319 TRUE), /* pcrel_offset */
321 /* Dynamic TLS relocations. */
323 HOWTO (R_ARM_TLS_DTPMOD32, /* type */
325 2, /* size (0 = byte, 1 = short, 2 = long) */
327 FALSE, /* pc_relative */
329 complain_overflow_bitfield,/* complain_on_overflow */
330 bfd_elf_generic_reloc, /* special_function */
331 "R_ARM_TLS_DTPMOD32", /* name */
332 TRUE, /* partial_inplace */
333 0xffffffff, /* src_mask */
334 0xffffffff, /* dst_mask */
335 FALSE), /* pcrel_offset */
337 HOWTO (R_ARM_TLS_DTPOFF32, /* type */
339 2, /* size (0 = byte, 1 = short, 2 = long) */
341 FALSE, /* pc_relative */
343 complain_overflow_bitfield,/* complain_on_overflow */
344 bfd_elf_generic_reloc, /* special_function */
345 "R_ARM_TLS_DTPOFF32", /* name */
346 TRUE, /* partial_inplace */
347 0xffffffff, /* src_mask */
348 0xffffffff, /* dst_mask */
349 FALSE), /* pcrel_offset */
351 HOWTO (R_ARM_TLS_TPOFF32, /* type */
353 2, /* size (0 = byte, 1 = short, 2 = long) */
355 FALSE, /* pc_relative */
357 complain_overflow_bitfield,/* complain_on_overflow */
358 bfd_elf_generic_reloc, /* special_function */
359 "R_ARM_TLS_TPOFF32", /* name */
360 TRUE, /* partial_inplace */
361 0xffffffff, /* src_mask */
362 0xffffffff, /* dst_mask */
363 FALSE), /* pcrel_offset */
365 /* Relocs used in ARM Linux */
367 HOWTO (R_ARM_COPY, /* type */
369 2, /* size (0 = byte, 1 = short, 2 = long) */
371 FALSE, /* pc_relative */
373 complain_overflow_bitfield,/* complain_on_overflow */
374 bfd_elf_generic_reloc, /* special_function */
375 "R_ARM_COPY", /* name */
376 TRUE, /* partial_inplace */
377 0xffffffff, /* src_mask */
378 0xffffffff, /* dst_mask */
379 FALSE), /* pcrel_offset */
381 HOWTO (R_ARM_GLOB_DAT, /* type */
383 2, /* size (0 = byte, 1 = short, 2 = long) */
385 FALSE, /* pc_relative */
387 complain_overflow_bitfield,/* complain_on_overflow */
388 bfd_elf_generic_reloc, /* special_function */
389 "R_ARM_GLOB_DAT", /* name */
390 TRUE, /* partial_inplace */
391 0xffffffff, /* src_mask */
392 0xffffffff, /* dst_mask */
393 FALSE), /* pcrel_offset */
395 HOWTO (R_ARM_JUMP_SLOT, /* type */
397 2, /* size (0 = byte, 1 = short, 2 = long) */
399 FALSE, /* pc_relative */
401 complain_overflow_bitfield,/* complain_on_overflow */
402 bfd_elf_generic_reloc, /* special_function */
403 "R_ARM_JUMP_SLOT", /* name */
404 TRUE, /* partial_inplace */
405 0xffffffff, /* src_mask */
406 0xffffffff, /* dst_mask */
407 FALSE), /* pcrel_offset */
409 HOWTO (R_ARM_RELATIVE, /* type */
411 2, /* size (0 = byte, 1 = short, 2 = long) */
413 FALSE, /* pc_relative */
415 complain_overflow_bitfield,/* complain_on_overflow */
416 bfd_elf_generic_reloc, /* special_function */
417 "R_ARM_RELATIVE", /* name */
418 TRUE, /* partial_inplace */
419 0xffffffff, /* src_mask */
420 0xffffffff, /* dst_mask */
421 FALSE), /* pcrel_offset */
423 HOWTO (R_ARM_GOTOFF32, /* type */
425 2, /* size (0 = byte, 1 = short, 2 = long) */
427 FALSE, /* pc_relative */
429 complain_overflow_bitfield,/* complain_on_overflow */
430 bfd_elf_generic_reloc, /* special_function */
431 "R_ARM_GOTOFF32", /* name */
432 TRUE, /* partial_inplace */
433 0xffffffff, /* src_mask */
434 0xffffffff, /* dst_mask */
435 FALSE), /* pcrel_offset */
437 HOWTO (R_ARM_GOTPC, /* type */
439 2, /* size (0 = byte, 1 = short, 2 = long) */
441 TRUE, /* pc_relative */
443 complain_overflow_bitfield,/* complain_on_overflow */
444 bfd_elf_generic_reloc, /* special_function */
445 "R_ARM_GOTPC", /* name */
446 TRUE, /* partial_inplace */
447 0xffffffff, /* src_mask */
448 0xffffffff, /* dst_mask */
449 TRUE), /* pcrel_offset */
451 HOWTO (R_ARM_GOT32, /* type */
453 2, /* size (0 = byte, 1 = short, 2 = long) */
455 FALSE, /* pc_relative */
457 complain_overflow_bitfield,/* complain_on_overflow */
458 bfd_elf_generic_reloc, /* special_function */
459 "R_ARM_GOT32", /* name */
460 TRUE, /* partial_inplace */
461 0xffffffff, /* src_mask */
462 0xffffffff, /* dst_mask */
463 FALSE), /* pcrel_offset */
465 HOWTO (R_ARM_PLT32, /* type */
467 2, /* size (0 = byte, 1 = short, 2 = long) */
469 TRUE, /* pc_relative */
471 complain_overflow_bitfield,/* complain_on_overflow */
472 bfd_elf_generic_reloc, /* special_function */
473 "R_ARM_PLT32", /* name */
474 FALSE, /* partial_inplace */
475 0x00ffffff, /* src_mask */
476 0x00ffffff, /* dst_mask */
477 TRUE), /* pcrel_offset */
479 HOWTO (R_ARM_CALL, /* type */
481 2, /* size (0 = byte, 1 = short, 2 = long) */
483 TRUE, /* pc_relative */
485 complain_overflow_signed,/* complain_on_overflow */
486 bfd_elf_generic_reloc, /* special_function */
487 "R_ARM_CALL", /* name */
488 FALSE, /* partial_inplace */
489 0x00ffffff, /* src_mask */
490 0x00ffffff, /* dst_mask */
491 TRUE), /* pcrel_offset */
493 HOWTO (R_ARM_JUMP24, /* type */
495 2, /* size (0 = byte, 1 = short, 2 = long) */
497 TRUE, /* pc_relative */
499 complain_overflow_signed,/* complain_on_overflow */
500 bfd_elf_generic_reloc, /* special_function */
501 "R_ARM_JUMP24", /* name */
502 FALSE, /* partial_inplace */
503 0x00ffffff, /* src_mask */
504 0x00ffffff, /* dst_mask */
505 TRUE), /* pcrel_offset */
507 HOWTO (R_ARM_THM_JUMP24, /* type */
509 2, /* size (0 = byte, 1 = short, 2 = long) */
511 TRUE, /* pc_relative */
513 complain_overflow_signed,/* complain_on_overflow */
514 bfd_elf_generic_reloc, /* special_function */
515 "R_ARM_THM_JUMP24", /* name */
516 FALSE, /* partial_inplace */
517 0x07ff2fff, /* src_mask */
518 0x07ff2fff, /* dst_mask */
519 TRUE), /* pcrel_offset */
521 HOWTO (R_ARM_BASE_ABS, /* type */
523 2, /* size (0 = byte, 1 = short, 2 = long) */
525 FALSE, /* pc_relative */
527 complain_overflow_dont,/* complain_on_overflow */
528 bfd_elf_generic_reloc, /* special_function */
529 "R_ARM_BASE_ABS", /* name */
530 FALSE, /* partial_inplace */
531 0xffffffff, /* src_mask */
532 0xffffffff, /* dst_mask */
533 FALSE), /* pcrel_offset */
535 HOWTO (R_ARM_ALU_PCREL7_0, /* type */
537 2, /* size (0 = byte, 1 = short, 2 = long) */
539 TRUE, /* pc_relative */
541 complain_overflow_dont,/* complain_on_overflow */
542 bfd_elf_generic_reloc, /* special_function */
543 "R_ARM_ALU_PCREL_7_0", /* name */
544 FALSE, /* partial_inplace */
545 0x00000fff, /* src_mask */
546 0x00000fff, /* dst_mask */
547 TRUE), /* pcrel_offset */
549 HOWTO (R_ARM_ALU_PCREL15_8, /* type */
551 2, /* size (0 = byte, 1 = short, 2 = long) */
553 TRUE, /* pc_relative */
555 complain_overflow_dont,/* complain_on_overflow */
556 bfd_elf_generic_reloc, /* special_function */
557 "R_ARM_ALU_PCREL_15_8",/* name */
558 FALSE, /* partial_inplace */
559 0x00000fff, /* src_mask */
560 0x00000fff, /* dst_mask */
561 TRUE), /* pcrel_offset */
563 HOWTO (R_ARM_ALU_PCREL23_15, /* type */
565 2, /* size (0 = byte, 1 = short, 2 = long) */
567 TRUE, /* pc_relative */
569 complain_overflow_dont,/* complain_on_overflow */
570 bfd_elf_generic_reloc, /* special_function */
571 "R_ARM_ALU_PCREL_23_15",/* name */
572 FALSE, /* partial_inplace */
573 0x00000fff, /* src_mask */
574 0x00000fff, /* dst_mask */
575 TRUE), /* pcrel_offset */
577 HOWTO (R_ARM_LDR_SBREL_11_0, /* type */
579 2, /* size (0 = byte, 1 = short, 2 = long) */
581 FALSE, /* pc_relative */
583 complain_overflow_dont,/* complain_on_overflow */
584 bfd_elf_generic_reloc, /* special_function */
585 "R_ARM_LDR_SBREL_11_0",/* name */
586 FALSE, /* partial_inplace */
587 0x00000fff, /* src_mask */
588 0x00000fff, /* dst_mask */
589 FALSE), /* pcrel_offset */
591 HOWTO (R_ARM_ALU_SBREL_19_12, /* type */
593 2, /* size (0 = byte, 1 = short, 2 = long) */
595 FALSE, /* pc_relative */
597 complain_overflow_dont,/* complain_on_overflow */
598 bfd_elf_generic_reloc, /* special_function */
599 "R_ARM_ALU_SBREL_19_12",/* name */
600 FALSE, /* partial_inplace */
601 0x000ff000, /* src_mask */
602 0x000ff000, /* dst_mask */
603 FALSE), /* pcrel_offset */
605 HOWTO (R_ARM_ALU_SBREL_27_20, /* type */
607 2, /* size (0 = byte, 1 = short, 2 = long) */
609 FALSE, /* pc_relative */
611 complain_overflow_dont,/* complain_on_overflow */
612 bfd_elf_generic_reloc, /* special_function */
613 "R_ARM_ALU_SBREL_27_20",/* name */
614 FALSE, /* partial_inplace */
615 0x0ff00000, /* src_mask */
616 0x0ff00000, /* dst_mask */
617 FALSE), /* pcrel_offset */
619 HOWTO (R_ARM_TARGET1, /* type */
621 2, /* size (0 = byte, 1 = short, 2 = long) */
623 FALSE, /* pc_relative */
625 complain_overflow_dont,/* complain_on_overflow */
626 bfd_elf_generic_reloc, /* special_function */
627 "R_ARM_TARGET1", /* name */
628 FALSE, /* partial_inplace */
629 0xffffffff, /* src_mask */
630 0xffffffff, /* dst_mask */
631 FALSE), /* pcrel_offset */
633 HOWTO (R_ARM_ROSEGREL32, /* type */
635 2, /* size (0 = byte, 1 = short, 2 = long) */
637 FALSE, /* pc_relative */
639 complain_overflow_dont,/* complain_on_overflow */
640 bfd_elf_generic_reloc, /* special_function */
641 "R_ARM_ROSEGREL32", /* name */
642 FALSE, /* partial_inplace */
643 0xffffffff, /* src_mask */
644 0xffffffff, /* dst_mask */
645 FALSE), /* pcrel_offset */
647 HOWTO (R_ARM_V4BX, /* type */
649 2, /* size (0 = byte, 1 = short, 2 = long) */
651 FALSE, /* pc_relative */
653 complain_overflow_dont,/* complain_on_overflow */
654 bfd_elf_generic_reloc, /* special_function */
655 "R_ARM_V4BX", /* name */
656 FALSE, /* partial_inplace */
657 0xffffffff, /* src_mask */
658 0xffffffff, /* dst_mask */
659 FALSE), /* pcrel_offset */
661 HOWTO (R_ARM_TARGET2, /* type */
663 2, /* size (0 = byte, 1 = short, 2 = long) */
665 FALSE, /* pc_relative */
667 complain_overflow_signed,/* complain_on_overflow */
668 bfd_elf_generic_reloc, /* special_function */
669 "R_ARM_TARGET2", /* name */
670 FALSE, /* partial_inplace */
671 0xffffffff, /* src_mask */
672 0xffffffff, /* dst_mask */
673 TRUE), /* pcrel_offset */
675 HOWTO (R_ARM_PREL31, /* type */
677 2, /* size (0 = byte, 1 = short, 2 = long) */
679 TRUE, /* pc_relative */
681 complain_overflow_signed,/* complain_on_overflow */
682 bfd_elf_generic_reloc, /* special_function */
683 "R_ARM_PREL31", /* name */
684 FALSE, /* partial_inplace */
685 0x7fffffff, /* src_mask */
686 0x7fffffff, /* dst_mask */
687 TRUE), /* pcrel_offset */
689 HOWTO (R_ARM_MOVW_ABS_NC, /* type */
691 2, /* size (0 = byte, 1 = short, 2 = long) */
693 FALSE, /* pc_relative */
695 complain_overflow_dont,/* complain_on_overflow */
696 bfd_elf_generic_reloc, /* special_function */
697 "R_ARM_MOVW_ABS_NC", /* name */
698 FALSE, /* partial_inplace */
699 0x0000ffff, /* src_mask */
700 0x0000ffff, /* dst_mask */
701 FALSE), /* pcrel_offset */
703 HOWTO (R_ARM_MOVT_ABS, /* type */
705 2, /* size (0 = byte, 1 = short, 2 = long) */
707 FALSE, /* pc_relative */
709 complain_overflow_bitfield,/* complain_on_overflow */
710 bfd_elf_generic_reloc, /* special_function */
711 "R_ARM_MOVT_ABS", /* name */
712 FALSE, /* partial_inplace */
713 0x0000ffff, /* src_mask */
714 0x0000ffff, /* dst_mask */
715 FALSE), /* pcrel_offset */
717 HOWTO (R_ARM_MOVW_PREL_NC, /* type */
719 2, /* size (0 = byte, 1 = short, 2 = long) */
721 TRUE, /* pc_relative */
723 complain_overflow_dont,/* complain_on_overflow */
724 bfd_elf_generic_reloc, /* special_function */
725 "R_ARM_MOVW_PREL_NC", /* name */
726 FALSE, /* partial_inplace */
727 0x0000ffff, /* src_mask */
728 0x0000ffff, /* dst_mask */
729 TRUE), /* pcrel_offset */
731 HOWTO (R_ARM_MOVT_PREL, /* type */
733 2, /* size (0 = byte, 1 = short, 2 = long) */
735 TRUE, /* pc_relative */
737 complain_overflow_bitfield,/* complain_on_overflow */
738 bfd_elf_generic_reloc, /* special_function */
739 "R_ARM_MOVT_PREL", /* name */
740 FALSE, /* partial_inplace */
741 0x0000ffff, /* src_mask */
742 0x0000ffff, /* dst_mask */
743 TRUE), /* pcrel_offset */
745 HOWTO (R_ARM_THM_MOVW_ABS_NC, /* type */
747 2, /* size (0 = byte, 1 = short, 2 = long) */
749 FALSE, /* pc_relative */
751 complain_overflow_dont,/* complain_on_overflow */
752 bfd_elf_generic_reloc, /* special_function */
753 "R_ARM_THM_MOVW_ABS_NC",/* name */
754 FALSE, /* partial_inplace */
755 0x040f70ff, /* src_mask */
756 0x040f70ff, /* dst_mask */
757 FALSE), /* pcrel_offset */
759 HOWTO (R_ARM_THM_MOVT_ABS, /* type */
761 2, /* size (0 = byte, 1 = short, 2 = long) */
763 FALSE, /* pc_relative */
765 complain_overflow_bitfield,/* complain_on_overflow */
766 bfd_elf_generic_reloc, /* special_function */
767 "R_ARM_THM_MOVT_ABS", /* name */
768 FALSE, /* partial_inplace */
769 0x040f70ff, /* src_mask */
770 0x040f70ff, /* dst_mask */
771 FALSE), /* pcrel_offset */
773 HOWTO (R_ARM_THM_MOVW_PREL_NC,/* type */
775 2, /* size (0 = byte, 1 = short, 2 = long) */
777 TRUE, /* pc_relative */
779 complain_overflow_dont,/* complain_on_overflow */
780 bfd_elf_generic_reloc, /* special_function */
781 "R_ARM_THM_MOVW_PREL_NC",/* name */
782 FALSE, /* partial_inplace */
783 0x040f70ff, /* src_mask */
784 0x040f70ff, /* dst_mask */
785 TRUE), /* pcrel_offset */
787 HOWTO (R_ARM_THM_MOVT_PREL, /* type */
789 2, /* size (0 = byte, 1 = short, 2 = long) */
791 TRUE, /* pc_relative */
793 complain_overflow_bitfield,/* complain_on_overflow */
794 bfd_elf_generic_reloc, /* special_function */
795 "R_ARM_THM_MOVT_PREL", /* name */
796 FALSE, /* partial_inplace */
797 0x040f70ff, /* src_mask */
798 0x040f70ff, /* dst_mask */
799 TRUE), /* pcrel_offset */
801 HOWTO (R_ARM_THM_JUMP19, /* type */
803 2, /* size (0 = byte, 1 = short, 2 = long) */
805 TRUE, /* pc_relative */
807 complain_overflow_signed,/* complain_on_overflow */
808 bfd_elf_generic_reloc, /* special_function */
809 "R_ARM_THM_JUMP19", /* name */
810 FALSE, /* partial_inplace */
811 0x043f2fff, /* src_mask */
812 0x043f2fff, /* dst_mask */
813 TRUE), /* pcrel_offset */
815 HOWTO (R_ARM_THM_JUMP6, /* type */
817 1, /* size (0 = byte, 1 = short, 2 = long) */
819 TRUE, /* pc_relative */
821 complain_overflow_unsigned,/* complain_on_overflow */
822 bfd_elf_generic_reloc, /* special_function */
823 "R_ARM_THM_JUMP6", /* name */
824 FALSE, /* partial_inplace */
825 0x02f8, /* src_mask */
826 0x02f8, /* dst_mask */
827 TRUE), /* pcrel_offset */
829 /* These are declared as 13-bit signed relocations because we can
830 address -4095 .. 4095(base) by altering ADDW to SUBW or vice
832 HOWTO (R_ARM_THM_ALU_PREL_11_0,/* type */
834 2, /* size (0 = byte, 1 = short, 2 = long) */
836 TRUE, /* pc_relative */
838 complain_overflow_signed,/* complain_on_overflow */
839 bfd_elf_generic_reloc, /* special_function */
840 "R_ARM_THM_ALU_PREL_11_0",/* name */
841 FALSE, /* partial_inplace */
842 0x040070ff, /* src_mask */
843 0x040070ff, /* dst_mask */
844 TRUE), /* pcrel_offset */
846 HOWTO (R_ARM_THM_PC12, /* type */
848 2, /* size (0 = byte, 1 = short, 2 = long) */
850 TRUE, /* pc_relative */
852 complain_overflow_signed,/* complain_on_overflow */
853 bfd_elf_generic_reloc, /* special_function */
854 "R_ARM_THM_PC12", /* name */
855 FALSE, /* partial_inplace */
856 0x040070ff, /* src_mask */
857 0x040070ff, /* dst_mask */
858 TRUE), /* pcrel_offset */
860 HOWTO (R_ARM_ABS32_NOI, /* type */
862 2, /* size (0 = byte, 1 = short, 2 = long) */
864 FALSE, /* pc_relative */
866 complain_overflow_dont,/* complain_on_overflow */
867 bfd_elf_generic_reloc, /* special_function */
868 "R_ARM_ABS32_NOI", /* name */
869 FALSE, /* partial_inplace */
870 0xffffffff, /* src_mask */
871 0xffffffff, /* dst_mask */
872 FALSE), /* pcrel_offset */
874 HOWTO (R_ARM_REL32_NOI, /* type */
876 2, /* size (0 = byte, 1 = short, 2 = long) */
878 TRUE, /* pc_relative */
880 complain_overflow_dont,/* complain_on_overflow */
881 bfd_elf_generic_reloc, /* special_function */
882 "R_ARM_REL32_NOI", /* name */
883 FALSE, /* partial_inplace */
884 0xffffffff, /* src_mask */
885 0xffffffff, /* dst_mask */
886 FALSE), /* pcrel_offset */
889 /* Relocations 57 .. 83 are the "group relocations" which we do not
892 static reloc_howto_type elf32_arm_howto_table_2[] =
894 HOWTO (R_ARM_MOVW_BREL_NC, /* type */
896 2, /* size (0 = byte, 1 = short, 2 = long) */
898 FALSE, /* pc_relative */
900 complain_overflow_dont,/* complain_on_overflow */
901 bfd_elf_generic_reloc, /* special_function */
902 "R_ARM_MOVW_BREL_NC", /* name */
903 FALSE, /* partial_inplace */
904 0x0000ffff, /* src_mask */
905 0x0000ffff, /* dst_mask */
906 FALSE), /* pcrel_offset */
908 HOWTO (R_ARM_MOVT_BREL, /* type */
910 2, /* size (0 = byte, 1 = short, 2 = long) */
912 FALSE, /* pc_relative */
914 complain_overflow_bitfield,/* complain_on_overflow */
915 bfd_elf_generic_reloc, /* special_function */
916 "R_ARM_MOVT_BREL", /* name */
917 FALSE, /* partial_inplace */
918 0x0000ffff, /* src_mask */
919 0x0000ffff, /* dst_mask */
920 FALSE), /* pcrel_offset */
922 HOWTO (R_ARM_MOVW_BREL, /* type */
924 2, /* size (0 = byte, 1 = short, 2 = long) */
926 FALSE, /* pc_relative */
928 complain_overflow_dont,/* complain_on_overflow */
929 bfd_elf_generic_reloc, /* special_function */
930 "R_ARM_MOVW_BREL", /* name */
931 FALSE, /* partial_inplace */
932 0x0000ffff, /* src_mask */
933 0x0000ffff, /* dst_mask */
934 FALSE), /* pcrel_offset */
936 HOWTO (R_ARM_THM_MOVW_BREL_NC,/* type */
938 2, /* size (0 = byte, 1 = short, 2 = long) */
940 FALSE, /* pc_relative */
942 complain_overflow_dont,/* complain_on_overflow */
943 bfd_elf_generic_reloc, /* special_function */
944 "R_ARM_THM_MOVW_BREL_NC",/* name */
945 FALSE, /* partial_inplace */
946 0x040f70ff, /* src_mask */
947 0x040f70ff, /* dst_mask */
948 FALSE), /* pcrel_offset */
950 HOWTO (R_ARM_THM_MOVT_BREL, /* type */
952 2, /* size (0 = byte, 1 = short, 2 = long) */
954 FALSE, /* pc_relative */
956 complain_overflow_bitfield,/* complain_on_overflow */
957 bfd_elf_generic_reloc, /* special_function */
958 "R_ARM_THM_MOVT_BREL", /* name */
959 FALSE, /* partial_inplace */
960 0x040f70ff, /* src_mask */
961 0x040f70ff, /* dst_mask */
962 FALSE), /* pcrel_offset */
964 HOWTO (R_ARM_THM_MOVW_BREL, /* type */
966 2, /* size (0 = byte, 1 = short, 2 = long) */
968 FALSE, /* pc_relative */
970 complain_overflow_dont,/* complain_on_overflow */
971 bfd_elf_generic_reloc, /* special_function */
972 "R_ARM_THM_MOVW_BREL", /* name */
973 FALSE, /* partial_inplace */
974 0x040f70ff, /* src_mask */
975 0x040f70ff, /* dst_mask */
976 FALSE), /* pcrel_offset */
978 EMPTY_HOWTO (90), /* unallocated */
983 HOWTO (R_ARM_PLT32_ABS, /* type */
985 2, /* size (0 = byte, 1 = short, 2 = long) */
987 FALSE, /* pc_relative */
989 complain_overflow_dont,/* complain_on_overflow */
990 bfd_elf_generic_reloc, /* special_function */
991 "R_ARM_PLT32_ABS", /* name */
992 FALSE, /* partial_inplace */
993 0xffffffff, /* src_mask */
994 0xffffffff, /* dst_mask */
995 FALSE), /* pcrel_offset */
997 HOWTO (R_ARM_GOT_ABS, /* type */
999 2, /* size (0 = byte, 1 = short, 2 = long) */
1001 FALSE, /* pc_relative */
1003 complain_overflow_dont,/* complain_on_overflow */
1004 bfd_elf_generic_reloc, /* special_function */
1005 "R_ARM_GOT_ABS", /* name */
1006 FALSE, /* partial_inplace */
1007 0xffffffff, /* src_mask */
1008 0xffffffff, /* dst_mask */
1009 FALSE), /* pcrel_offset */
1011 HOWTO (R_ARM_GOT_PREL, /* type */
1013 2, /* size (0 = byte, 1 = short, 2 = long) */
1015 TRUE, /* pc_relative */
1017 complain_overflow_dont, /* complain_on_overflow */
1018 bfd_elf_generic_reloc, /* special_function */
1019 "R_ARM_GOT_PREL", /* name */
1020 FALSE, /* partial_inplace */
1021 0xffffffff, /* src_mask */
1022 0xffffffff, /* dst_mask */
1023 TRUE), /* pcrel_offset */
1025 HOWTO (R_ARM_GOT_BREL12, /* type */
1027 2, /* size (0 = byte, 1 = short, 2 = long) */
1029 FALSE, /* pc_relative */
1031 complain_overflow_bitfield,/* complain_on_overflow */
1032 bfd_elf_generic_reloc, /* special_function */
1033 "R_ARM_GOT_BREL12", /* name */
1034 FALSE, /* partial_inplace */
1035 0x00000fff, /* src_mask */
1036 0x00000fff, /* dst_mask */
1037 FALSE), /* pcrel_offset */
1039 HOWTO (R_ARM_GOTOFF12, /* type */
1041 2, /* size (0 = byte, 1 = short, 2 = long) */
1043 FALSE, /* pc_relative */
1045 complain_overflow_bitfield,/* complain_on_overflow */
1046 bfd_elf_generic_reloc, /* special_function */
1047 "R_ARM_GOTOFF12", /* name */
1048 FALSE, /* partial_inplace */
1049 0x00000fff, /* src_mask */
1050 0x00000fff, /* dst_mask */
1051 FALSE), /* pcrel_offset */
1053 EMPTY_HOWTO (R_ARM_GOTRELAX), /* reserved for future GOT-load optimizations */
1055 /* GNU extension to record C++ vtable member usage */
1056 HOWTO (R_ARM_GNU_VTENTRY, /* type */
1058 2, /* size (0 = byte, 1 = short, 2 = long) */
1060 FALSE, /* pc_relative */
1062 complain_overflow_dont, /* complain_on_overflow */
1063 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
1064 "R_ARM_GNU_VTENTRY", /* name */
1065 FALSE, /* partial_inplace */
1068 FALSE), /* pcrel_offset */
1070 /* GNU extension to record C++ vtable hierarchy */
1071 HOWTO (R_ARM_GNU_VTINHERIT, /* type */
1073 2, /* size (0 = byte, 1 = short, 2 = long) */
1075 FALSE, /* pc_relative */
1077 complain_overflow_dont, /* complain_on_overflow */
1078 NULL, /* special_function */
1079 "R_ARM_GNU_VTINHERIT", /* name */
1080 FALSE, /* partial_inplace */
1083 FALSE), /* pcrel_offset */
1085 HOWTO (R_ARM_THM_JUMP11, /* type */
1087 1, /* size (0 = byte, 1 = short, 2 = long) */
1089 TRUE, /* pc_relative */
1091 complain_overflow_signed, /* complain_on_overflow */
1092 bfd_elf_generic_reloc, /* special_function */
1093 "R_ARM_THM_JUMP11", /* name */
1094 FALSE, /* partial_inplace */
1095 0x000007ff, /* src_mask */
1096 0x000007ff, /* dst_mask */
1097 TRUE), /* pcrel_offset */
1099 HOWTO (R_ARM_THM_JUMP8, /* type */
1101 1, /* size (0 = byte, 1 = short, 2 = long) */
1103 TRUE, /* pc_relative */
1105 complain_overflow_signed, /* complain_on_overflow */
1106 bfd_elf_generic_reloc, /* special_function */
1107 "R_ARM_THM_JUMP8", /* name */
1108 FALSE, /* partial_inplace */
1109 0x000000ff, /* src_mask */
1110 0x000000ff, /* dst_mask */
1111 TRUE), /* pcrel_offset */
1113 /* TLS relocations */
1114 HOWTO (R_ARM_TLS_GD32, /* type */
1116 2, /* size (0 = byte, 1 = short, 2 = long) */
1118 FALSE, /* pc_relative */
1120 complain_overflow_bitfield,/* complain_on_overflow */
1121 NULL, /* special_function */
1122 "R_ARM_TLS_GD32", /* name */
1123 TRUE, /* partial_inplace */
1124 0xffffffff, /* src_mask */
1125 0xffffffff, /* dst_mask */
1126 FALSE), /* pcrel_offset */
1128 HOWTO (R_ARM_TLS_LDM32, /* type */
1130 2, /* size (0 = byte, 1 = short, 2 = long) */
1132 FALSE, /* pc_relative */
1134 complain_overflow_bitfield,/* complain_on_overflow */
1135 bfd_elf_generic_reloc, /* special_function */
1136 "R_ARM_TLS_LDM32", /* name */
1137 TRUE, /* partial_inplace */
1138 0xffffffff, /* src_mask */
1139 0xffffffff, /* dst_mask */
1140 FALSE), /* pcrel_offset */
1142 HOWTO (R_ARM_TLS_LDO32, /* type */
1144 2, /* size (0 = byte, 1 = short, 2 = long) */
1146 FALSE, /* pc_relative */
1148 complain_overflow_bitfield,/* complain_on_overflow */
1149 bfd_elf_generic_reloc, /* special_function */
1150 "R_ARM_TLS_LDO32", /* name */
1151 TRUE, /* partial_inplace */
1152 0xffffffff, /* src_mask */
1153 0xffffffff, /* dst_mask */
1154 FALSE), /* pcrel_offset */
1156 HOWTO (R_ARM_TLS_IE32, /* type */
1158 2, /* size (0 = byte, 1 = short, 2 = long) */
1160 FALSE, /* pc_relative */
1162 complain_overflow_bitfield,/* complain_on_overflow */
1163 NULL, /* special_function */
1164 "R_ARM_TLS_IE32", /* name */
1165 TRUE, /* partial_inplace */
1166 0xffffffff, /* src_mask */
1167 0xffffffff, /* dst_mask */
1168 FALSE), /* pcrel_offset */
1170 HOWTO (R_ARM_TLS_LE32, /* type */
1172 2, /* size (0 = byte, 1 = short, 2 = long) */
1174 FALSE, /* pc_relative */
1176 complain_overflow_bitfield,/* complain_on_overflow */
1177 bfd_elf_generic_reloc, /* special_function */
1178 "R_ARM_TLS_LE32", /* name */
1179 TRUE, /* partial_inplace */
1180 0xffffffff, /* src_mask */
1181 0xffffffff, /* dst_mask */
1182 FALSE), /* pcrel_offset */
1184 HOWTO (R_ARM_TLS_LDO12, /* type */
1186 2, /* size (0 = byte, 1 = short, 2 = long) */
1188 FALSE, /* pc_relative */
1190 complain_overflow_bitfield,/* complain_on_overflow */
1191 bfd_elf_generic_reloc, /* special_function */
1192 "R_ARM_TLS_LDO12", /* name */
1193 FALSE, /* partial_inplace */
1194 0x00000fff, /* src_mask */
1195 0x00000fff, /* dst_mask */
1196 FALSE), /* pcrel_offset */
1198 HOWTO (R_ARM_TLS_LE12, /* type */
1200 2, /* size (0 = byte, 1 = short, 2 = long) */
1202 FALSE, /* pc_relative */
1204 complain_overflow_bitfield,/* complain_on_overflow */
1205 bfd_elf_generic_reloc, /* special_function */
1206 "R_ARM_TLS_LE12", /* name */
1207 FALSE, /* partial_inplace */
1208 0x00000fff, /* src_mask */
1209 0x00000fff, /* dst_mask */
1210 FALSE), /* pcrel_offset */
1212 HOWTO (R_ARM_TLS_IE12GP, /* type */
1214 2, /* size (0 = byte, 1 = short, 2 = long) */
1216 FALSE, /* pc_relative */
1218 complain_overflow_bitfield,/* complain_on_overflow */
1219 bfd_elf_generic_reloc, /* special_function */
1220 "R_ARM_TLS_IE12GP", /* name */
1221 FALSE, /* partial_inplace */
1222 0x00000fff, /* src_mask */
1223 0x00000fff, /* dst_mask */
1224 FALSE), /* pcrel_offset */
1227 /* 112-127 private relocations
1228 128 R_ARM_ME_TOO, obsolete
1229 129-255 unallocated in AAELF.
1231 249-255 extended, currently unused, relocations: */
1233 static reloc_howto_type elf32_arm_howto_table_3[4] =
1235 HOWTO (R_ARM_RREL32, /* type */
1237 0, /* size (0 = byte, 1 = short, 2 = long) */
1239 FALSE, /* pc_relative */
1241 complain_overflow_dont,/* complain_on_overflow */
1242 bfd_elf_generic_reloc, /* special_function */
1243 "R_ARM_RREL32", /* name */
1244 FALSE, /* partial_inplace */
1247 FALSE), /* pcrel_offset */
1249 HOWTO (R_ARM_RABS32, /* type */
1251 0, /* size (0 = byte, 1 = short, 2 = long) */
1253 FALSE, /* pc_relative */
1255 complain_overflow_dont,/* complain_on_overflow */
1256 bfd_elf_generic_reloc, /* special_function */
1257 "R_ARM_RABS32", /* name */
1258 FALSE, /* partial_inplace */
1261 FALSE), /* pcrel_offset */
1263 HOWTO (R_ARM_RPC24, /* type */
1265 0, /* size (0 = byte, 1 = short, 2 = long) */
1267 FALSE, /* pc_relative */
1269 complain_overflow_dont,/* complain_on_overflow */
1270 bfd_elf_generic_reloc, /* special_function */
1271 "R_ARM_RPC24", /* name */
1272 FALSE, /* partial_inplace */
1275 FALSE), /* pcrel_offset */
1277 HOWTO (R_ARM_RBASE, /* type */
1279 0, /* size (0 = byte, 1 = short, 2 = long) */
1281 FALSE, /* pc_relative */
1283 complain_overflow_dont,/* complain_on_overflow */
1284 bfd_elf_generic_reloc, /* special_function */
1285 "R_ARM_RBASE", /* name */
1286 FALSE, /* partial_inplace */
1289 FALSE) /* pcrel_offset */
1292 static reloc_howto_type *
1293 elf32_arm_howto_from_type (unsigned int r_type)
1295 if (r_type < NUM_ELEM (elf32_arm_howto_table_1))
1296 return &elf32_arm_howto_table_1[r_type];
1298 if (r_type >= R_ARM_MOVW_BREL_NC
1299 && r_type < R_ARM_MOVW_BREL_NC + NUM_ELEM (elf32_arm_howto_table_2))
1300 return &elf32_arm_howto_table_2[r_type - R_ARM_MOVW_BREL_NC];
1302 if (r_type >= R_ARM_RREL32
1303 && r_type < R_ARM_RREL32 + NUM_ELEM (elf32_arm_howto_table_2))
1304 return &elf32_arm_howto_table_3[r_type - R_ARM_RREL32];
1310 elf32_arm_info_to_howto (bfd * abfd ATTRIBUTE_UNUSED, arelent * bfd_reloc,
1311 Elf_Internal_Rela * elf_reloc)
1313 unsigned int r_type;
1315 r_type = ELF32_R_TYPE (elf_reloc->r_info);
1316 bfd_reloc->howto = elf32_arm_howto_from_type (r_type);
1319 struct elf32_arm_reloc_map
1321 bfd_reloc_code_real_type bfd_reloc_val;
1322 unsigned char elf_reloc_val;
1325 /* All entries in this list must also be present in elf32_arm_howto_table. */
1326 static const struct elf32_arm_reloc_map elf32_arm_reloc_map[] =
1328 {BFD_RELOC_NONE, R_ARM_NONE},
1329 {BFD_RELOC_ARM_PCREL_BRANCH, R_ARM_PC24},
1330 {BFD_RELOC_ARM_PCREL_CALL, R_ARM_CALL},
1331 {BFD_RELOC_ARM_PCREL_JUMP, R_ARM_JUMP24},
1332 {BFD_RELOC_ARM_PCREL_BLX, R_ARM_XPC25},
1333 {BFD_RELOC_THUMB_PCREL_BLX, R_ARM_THM_XPC22},
1334 {BFD_RELOC_32, R_ARM_ABS32},
1335 {BFD_RELOC_32_PCREL, R_ARM_REL32},
1336 {BFD_RELOC_8, R_ARM_ABS8},
1337 {BFD_RELOC_16, R_ARM_ABS16},
1338 {BFD_RELOC_ARM_OFFSET_IMM, R_ARM_ABS12},
1339 {BFD_RELOC_ARM_THUMB_OFFSET, R_ARM_THM_ABS5},
1340 {BFD_RELOC_THUMB_PCREL_BRANCH25, R_ARM_THM_JUMP24},
1341 {BFD_RELOC_THUMB_PCREL_BRANCH23, R_ARM_THM_CALL},
1342 {BFD_RELOC_THUMB_PCREL_BRANCH12, R_ARM_THM_JUMP11},
1343 {BFD_RELOC_THUMB_PCREL_BRANCH20, R_ARM_THM_JUMP19},
1344 {BFD_RELOC_THUMB_PCREL_BRANCH9, R_ARM_THM_JUMP8},
1345 {BFD_RELOC_THUMB_PCREL_BRANCH7, R_ARM_THM_JUMP6},
1346 {BFD_RELOC_ARM_GLOB_DAT, R_ARM_GLOB_DAT},
1347 {BFD_RELOC_ARM_JUMP_SLOT, R_ARM_JUMP_SLOT},
1348 {BFD_RELOC_ARM_RELATIVE, R_ARM_RELATIVE},
1349 {BFD_RELOC_ARM_GOTOFF, R_ARM_GOTOFF32},
1350 {BFD_RELOC_ARM_GOTPC, R_ARM_GOTPC},
1351 {BFD_RELOC_ARM_GOT32, R_ARM_GOT32},
1352 {BFD_RELOC_ARM_PLT32, R_ARM_PLT32},
1353 {BFD_RELOC_ARM_TARGET1, R_ARM_TARGET1},
1354 {BFD_RELOC_ARM_ROSEGREL32, R_ARM_ROSEGREL32},
1355 {BFD_RELOC_ARM_SBREL32, R_ARM_SBREL32},
1356 {BFD_RELOC_ARM_PREL31, R_ARM_PREL31},
1357 {BFD_RELOC_ARM_TARGET2, R_ARM_TARGET2},
1358 {BFD_RELOC_ARM_PLT32, R_ARM_PLT32},
1359 {BFD_RELOC_ARM_TLS_GD32, R_ARM_TLS_GD32},
1360 {BFD_RELOC_ARM_TLS_LDO32, R_ARM_TLS_LDO32},
1361 {BFD_RELOC_ARM_TLS_LDM32, R_ARM_TLS_LDM32},
1362 {BFD_RELOC_ARM_TLS_DTPMOD32, R_ARM_TLS_DTPMOD32},
1363 {BFD_RELOC_ARM_TLS_DTPOFF32, R_ARM_TLS_DTPOFF32},
1364 {BFD_RELOC_ARM_TLS_TPOFF32, R_ARM_TLS_TPOFF32},
1365 {BFD_RELOC_ARM_TLS_IE32, R_ARM_TLS_IE32},
1366 {BFD_RELOC_ARM_TLS_LE32, R_ARM_TLS_LE32},
1367 {BFD_RELOC_VTABLE_INHERIT, R_ARM_GNU_VTINHERIT},
1368 {BFD_RELOC_VTABLE_ENTRY, R_ARM_GNU_VTENTRY},
1371 static reloc_howto_type *
1372 elf32_arm_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1373 bfd_reloc_code_real_type code)
1376 for (i = 0; i < NUM_ELEM (elf32_arm_reloc_map); i ++)
1377 if (elf32_arm_reloc_map[i].bfd_reloc_val == code)
1378 return elf32_arm_howto_from_type (elf32_arm_reloc_map[i].elf_reloc_val);
1383 /* Support for core dump NOTE sections */
1385 elf32_arm_nabi_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
1390 switch (note->descsz)
1395 case 148: /* Linux/ARM 32-bit*/
1397 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
1400 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
1409 /* Make a ".reg/999" section. */
1410 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
1411 size, note->descpos + offset);
1415 elf32_arm_nabi_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
1417 switch (note->descsz)
1422 case 124: /* Linux/ARM elf_prpsinfo */
1423 elf_tdata (abfd)->core_program
1424 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
1425 elf_tdata (abfd)->core_command
1426 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
1429 /* Note that for some reason, a spurious space is tacked
1430 onto the end of the args in some (at least one anyway)
1431 implementations, so strip it off if it exists. */
1434 char *command = elf_tdata (abfd)->core_command;
1435 int n = strlen (command);
1437 if (0 < n && command[n - 1] == ' ')
1438 command[n - 1] = '\0';
1444 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_vec
1445 #define TARGET_LITTLE_NAME "elf32-littlearm"
1446 #define TARGET_BIG_SYM bfd_elf32_bigarm_vec
1447 #define TARGET_BIG_NAME "elf32-bigarm"
1449 #define elf_backend_grok_prstatus elf32_arm_nabi_grok_prstatus
1450 #define elf_backend_grok_psinfo elf32_arm_nabi_grok_psinfo
1452 typedef unsigned long int insn32;
1453 typedef unsigned short int insn16;
1455 /* In lieu of proper flags, assume all EABIv4 objects are interworkable. */
1456 #define INTERWORK_FLAG(abfd) \
1457 (EF_ARM_EABI_VERSION (elf_elfheader (abfd)->e_flags) == EF_ARM_EABI_VER4 \
1458 || (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK))
1460 /* The linker script knows the section names for placement.
1461 The entry_names are used to do simple name mangling on the stubs.
1462 Given a function name, and its type, the stub can be found. The
1463 name can be changed. The only requirement is the %s be present. */
1464 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
1465 #define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
1467 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
1468 #define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
1470 /* The name of the dynamic interpreter. This is put in the .interp
1472 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
1474 #ifdef FOUR_WORD_PLT
1476 /* The first entry in a procedure linkage table looks like
1477 this. It is set up so that any shared library function that is
1478 called before the relocation has been set up calls the dynamic
1480 static const bfd_vma elf32_arm_plt0_entry [] =
1482 0xe52de004, /* str lr, [sp, #-4]! */
1483 0xe59fe010, /* ldr lr, [pc, #16] */
1484 0xe08fe00e, /* add lr, pc, lr */
1485 0xe5bef008, /* ldr pc, [lr, #8]! */
1488 /* Subsequent entries in a procedure linkage table look like
1490 static const bfd_vma elf32_arm_plt_entry [] =
1492 0xe28fc600, /* add ip, pc, #NN */
1493 0xe28cca00, /* add ip, ip, #NN */
1494 0xe5bcf000, /* ldr pc, [ip, #NN]! */
1495 0x00000000, /* unused */
1500 /* The first entry in a procedure linkage table looks like
1501 this. It is set up so that any shared library function that is
1502 called before the relocation has been set up calls the dynamic
1504 static const bfd_vma elf32_arm_plt0_entry [] =
1506 0xe52de004, /* str lr, [sp, #-4]! */
1507 0xe59fe004, /* ldr lr, [pc, #4] */
1508 0xe08fe00e, /* add lr, pc, lr */
1509 0xe5bef008, /* ldr pc, [lr, #8]! */
1510 0x00000000, /* &GOT[0] - . */
1513 /* Subsequent entries in a procedure linkage table look like
1515 static const bfd_vma elf32_arm_plt_entry [] =
1517 0xe28fc600, /* add ip, pc, #0xNN00000 */
1518 0xe28cca00, /* add ip, ip, #0xNN000 */
1519 0xe5bcf000, /* ldr pc, [ip, #0xNNN]! */
1524 /* The format of the first entry in the procedure linkage table
1525 for a VxWorks executable. */
1526 static const bfd_vma elf32_arm_vxworks_exec_plt0_entry[] =
1528 0xe52dc008, /* str ip,[sp,#-8]! */
1529 0xe59fc000, /* ldr ip,[pc] */
1530 0xe59cf008, /* ldr pc,[ip,#8] */
1531 0x00000000, /* .long _GLOBAL_OFFSET_TABLE_ */
1534 /* The format of subsequent entries in a VxWorks executable. */
1535 static const bfd_vma elf32_arm_vxworks_exec_plt_entry[] =
1537 0xe59fc000, /* ldr ip,[pc] */
1538 0xe59cf000, /* ldr pc,[ip] */
1539 0x00000000, /* .long @got */
1540 0xe59fc000, /* ldr ip,[pc] */
1541 0xea000000, /* b _PLT */
1542 0x00000000, /* .long @pltindex*sizeof(Elf32_Rela) */
1545 /* The format of entries in a VxWorks shared library. */
1546 static const bfd_vma elf32_arm_vxworks_shared_plt_entry[] =
1548 0xe59fc000, /* ldr ip,[pc] */
1549 0xe79cf009, /* ldr pc,[ip,r9] */
1550 0x00000000, /* .long @got */
1551 0xe59fc000, /* ldr ip,[pc] */
1552 0xe599f008, /* ldr pc,[r9,#8] */
1553 0x00000000, /* .long @pltindex*sizeof(Elf32_Rela) */
1556 /* An initial stub used if the PLT entry is referenced from Thumb code. */
1557 #define PLT_THUMB_STUB_SIZE 4
1558 static const bfd_vma elf32_arm_plt_thumb_stub [] =
1564 /* The entries in a PLT when using a DLL-based target with multiple
1566 static const bfd_vma elf32_arm_symbian_plt_entry [] =
1568 0xe51ff004, /* ldr pc, [pc, #-4] */
1569 0x00000000, /* dcd R_ARM_GLOB_DAT(X) */
1572 /* Used to build a map of a section. This is required for mixed-endian
1575 typedef struct elf32_elf_section_map
1580 elf32_arm_section_map;
1582 typedef struct _arm_elf_section_data
1584 struct bfd_elf_section_data elf;
1585 unsigned int mapcount;
1586 elf32_arm_section_map *map;
1588 _arm_elf_section_data;
1590 #define elf32_arm_section_data(sec) \
1591 ((_arm_elf_section_data *) elf_section_data (sec))
1593 /* The size of the thread control block. */
1596 #define NUM_KNOWN_ATTRIBUTES 32
1598 typedef struct aeabi_attribute
1605 typedef struct aeabi_attribute_list
1607 struct aeabi_attribute_list *next;
1609 aeabi_attribute attr;
1610 } aeabi_attribute_list;
1612 struct elf32_arm_obj_tdata
1614 struct elf_obj_tdata root;
1616 /* tls_type for each local got entry. */
1617 char *local_got_tls_type;
1619 aeabi_attribute known_eabi_attributes[NUM_KNOWN_ATTRIBUTES];
1620 aeabi_attribute_list *other_eabi_attributes;
1623 #define elf32_arm_tdata(abfd) \
1624 ((struct elf32_arm_obj_tdata *) (abfd)->tdata.any)
1626 #define elf32_arm_local_got_tls_type(abfd) \
1627 (elf32_arm_tdata (abfd)->local_got_tls_type)
1630 elf32_arm_mkobject (bfd *abfd)
1632 bfd_size_type amt = sizeof (struct elf32_arm_obj_tdata);
1633 abfd->tdata.any = bfd_zalloc (abfd, amt);
1634 if (abfd->tdata.any == NULL)
1639 /* The ARM linker needs to keep track of the number of relocs that it
1640 decides to copy in check_relocs for each symbol. This is so that
1641 it can discard PC relative relocs if it doesn't need them when
1642 linking with -Bsymbolic. We store the information in a field
1643 extending the regular ELF linker hash table. */
1645 /* This structure keeps track of the number of relocs we have copied
1646 for a given symbol. */
1647 struct elf32_arm_relocs_copied
1650 struct elf32_arm_relocs_copied * next;
1651 /* A section in dynobj. */
1653 /* Number of relocs copied in this section. */
1654 bfd_size_type count;
1655 /* Number of PC-relative relocs copied in this section. */
1656 bfd_size_type pc_count;
1659 #define elf32_arm_hash_entry(ent) ((struct elf32_arm_link_hash_entry *)(ent))
1661 /* Arm ELF linker hash entry. */
1662 struct elf32_arm_link_hash_entry
1664 struct elf_link_hash_entry root;
1666 /* Number of PC relative relocs copied for this symbol. */
1667 struct elf32_arm_relocs_copied * relocs_copied;
1669 /* We reference count Thumb references to a PLT entry separately,
1670 so that we can emit the Thumb trampoline only if needed. */
1671 bfd_signed_vma plt_thumb_refcount;
1673 /* Since PLT entries have variable size if the Thumb prologue is
1674 used, we need to record the index into .got.plt instead of
1675 recomputing it from the PLT offset. */
1676 bfd_signed_vma plt_got_offset;
1678 #define GOT_UNKNOWN 0
1679 #define GOT_NORMAL 1
1680 #define GOT_TLS_GD 2
1681 #define GOT_TLS_IE 4
1682 unsigned char tls_type;
1685 /* Traverse an arm ELF linker hash table. */
1686 #define elf32_arm_link_hash_traverse(table, func, info) \
1687 (elf_link_hash_traverse \
1689 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
1692 /* Get the ARM elf linker hash table from a link_info structure. */
1693 #define elf32_arm_hash_table(info) \
1694 ((struct elf32_arm_link_hash_table *) ((info)->hash))
1696 /* ARM ELF linker hash table. */
1697 struct elf32_arm_link_hash_table
1699 /* The main hash table. */
1700 struct elf_link_hash_table root;
1702 /* The size in bytes of the section containing the Thumb-to-ARM glue. */
1703 bfd_size_type thumb_glue_size;
1705 /* The size in bytes of the section containing the ARM-to-Thumb glue. */
1706 bfd_size_type arm_glue_size;
1708 /* An arbitrary input BFD chosen to hold the glue sections. */
1709 bfd * bfd_of_glue_owner;
1711 /* Nonzero to output a BE8 image. */
1714 /* Zero if R_ARM_TARGET1 means R_ARM_ABS32.
1715 Nonzero if R_ARM_TARGET1 means R_ARM_ABS32. */
1718 /* The relocation to use for R_ARM_TARGET2 relocations. */
1721 /* Nonzero to fix BX instructions for ARMv4 targets. */
1724 /* Nonzero if the ARM/Thumb BLX instructions are available for use. */
1727 /* The number of bytes in the initial entry in the PLT. */
1728 bfd_size_type plt_header_size;
1730 /* The number of bytes in the subsequent PLT etries. */
1731 bfd_size_type plt_entry_size;
1733 /* True if the target system is VxWorks. */
1736 /* True if the target system is Symbian OS. */
1739 /* True if the target uses REL relocations. */
1742 /* Short-cuts to get to dynamic linker sections. */
1751 /* The (unloaded but important) VxWorks .rela.plt.unloaded section. */
1754 /* Data for R_ARM_TLS_LDM32 relocations. */
1756 bfd_signed_vma refcount;
1760 /* Small local sym to section mapping cache. */
1761 struct sym_sec_cache sym_sec;
1763 /* For convenience in allocate_dynrelocs. */
1767 /* Create an entry in an ARM ELF linker hash table. */
1769 static struct bfd_hash_entry *
1770 elf32_arm_link_hash_newfunc (struct bfd_hash_entry * entry,
1771 struct bfd_hash_table * table,
1772 const char * string)
1774 struct elf32_arm_link_hash_entry * ret =
1775 (struct elf32_arm_link_hash_entry *) entry;
1777 /* Allocate the structure if it has not already been allocated by a
1779 if (ret == (struct elf32_arm_link_hash_entry *) NULL)
1780 ret = bfd_hash_allocate (table, sizeof (struct elf32_arm_link_hash_entry));
1782 return (struct bfd_hash_entry *) ret;
1784 /* Call the allocation method of the superclass. */
1785 ret = ((struct elf32_arm_link_hash_entry *)
1786 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1790 ret->relocs_copied = NULL;
1791 ret->tls_type = GOT_UNKNOWN;
1792 ret->plt_thumb_refcount = 0;
1793 ret->plt_got_offset = -1;
1796 return (struct bfd_hash_entry *) ret;
1799 /* Return true if NAME is the name of the relocation section associated
1803 reloc_section_p (struct elf32_arm_link_hash_table *htab,
1804 const char *name, asection *s)
1807 return strncmp (name, ".rel", 4) == 0 && strcmp (s->name, name + 4) == 0;
1809 return strncmp (name, ".rela", 5) == 0 && strcmp (s->name, name + 5) == 0;
1812 /* Create .got, .gotplt, and .rel(a).got sections in DYNOBJ, and set up
1813 shortcuts to them in our hash table. */
1816 create_got_section (bfd *dynobj, struct bfd_link_info *info)
1818 struct elf32_arm_link_hash_table *htab;
1820 htab = elf32_arm_hash_table (info);
1821 /* BPABI objects never have a GOT, or associated sections. */
1822 if (htab->symbian_p)
1825 if (! _bfd_elf_create_got_section (dynobj, info))
1828 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
1829 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1830 if (!htab->sgot || !htab->sgotplt)
1833 htab->srelgot = bfd_make_section_with_flags (dynobj,
1834 RELOC_SECTION (htab, ".got"),
1835 (SEC_ALLOC | SEC_LOAD
1838 | SEC_LINKER_CREATED
1840 if (htab->srelgot == NULL
1841 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
1846 /* Create .plt, .rel(a).plt, .got, .got.plt, .rel(a).got, .dynbss, and
1847 .rel(a).bss sections in DYNOBJ, and set up shortcuts to them in our
1851 elf32_arm_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
1853 struct elf32_arm_link_hash_table *htab;
1855 htab = elf32_arm_hash_table (info);
1856 if (!htab->sgot && !create_got_section (dynobj, info))
1859 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1862 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
1863 htab->srelplt = bfd_get_section_by_name (dynobj,
1864 RELOC_SECTION (htab, ".plt"));
1865 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
1867 htab->srelbss = bfd_get_section_by_name (dynobj,
1868 RELOC_SECTION (htab, ".bss"));
1870 if (htab->vxworks_p)
1872 if (!elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2))
1877 htab->plt_header_size = 0;
1878 htab->plt_entry_size
1879 = 4 * ARRAY_SIZE (elf32_arm_vxworks_shared_plt_entry);
1883 htab->plt_header_size
1884 = 4 * ARRAY_SIZE (elf32_arm_vxworks_exec_plt0_entry);
1885 htab->plt_entry_size
1886 = 4 * ARRAY_SIZE (elf32_arm_vxworks_exec_plt_entry);
1893 || (!info->shared && !htab->srelbss))
1899 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1902 elf32_arm_copy_indirect_symbol (struct bfd_link_info *info,
1903 struct elf_link_hash_entry *dir,
1904 struct elf_link_hash_entry *ind)
1906 struct elf32_arm_link_hash_entry *edir, *eind;
1908 edir = (struct elf32_arm_link_hash_entry *) dir;
1909 eind = (struct elf32_arm_link_hash_entry *) ind;
1911 if (eind->relocs_copied != NULL)
1913 if (edir->relocs_copied != NULL)
1915 struct elf32_arm_relocs_copied **pp;
1916 struct elf32_arm_relocs_copied *p;
1918 /* Add reloc counts against the indirect sym to the direct sym
1919 list. Merge any entries against the same section. */
1920 for (pp = &eind->relocs_copied; (p = *pp) != NULL; )
1922 struct elf32_arm_relocs_copied *q;
1924 for (q = edir->relocs_copied; q != NULL; q = q->next)
1925 if (q->section == p->section)
1927 q->pc_count += p->pc_count;
1928 q->count += p->count;
1935 *pp = edir->relocs_copied;
1938 edir->relocs_copied = eind->relocs_copied;
1939 eind->relocs_copied = NULL;
1942 /* Copy over PLT info. */
1943 edir->plt_thumb_refcount += eind->plt_thumb_refcount;
1944 eind->plt_thumb_refcount = 0;
1946 if (ind->root.type == bfd_link_hash_indirect
1947 && dir->got.refcount <= 0)
1949 edir->tls_type = eind->tls_type;
1950 eind->tls_type = GOT_UNKNOWN;
1953 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1956 /* Create an ARM elf linker hash table. */
1958 static struct bfd_link_hash_table *
1959 elf32_arm_link_hash_table_create (bfd *abfd)
1961 struct elf32_arm_link_hash_table *ret;
1962 bfd_size_type amt = sizeof (struct elf32_arm_link_hash_table);
1964 ret = bfd_malloc (amt);
1968 if (!_bfd_elf_link_hash_table_init (& ret->root, abfd,
1969 elf32_arm_link_hash_newfunc))
1976 ret->sgotplt = NULL;
1977 ret->srelgot = NULL;
1979 ret->srelplt = NULL;
1980 ret->sdynbss = NULL;
1981 ret->srelbss = NULL;
1982 ret->srelplt2 = NULL;
1983 ret->thumb_glue_size = 0;
1984 ret->arm_glue_size = 0;
1985 ret->bfd_of_glue_owner = NULL;
1986 ret->byteswap_code = 0;
1987 ret->target1_is_rel = 0;
1988 ret->target2_reloc = R_ARM_NONE;
1989 #ifdef FOUR_WORD_PLT
1990 ret->plt_header_size = 16;
1991 ret->plt_entry_size = 16;
1993 ret->plt_header_size = 20;
1994 ret->plt_entry_size = 12;
2001 ret->sym_sec.abfd = NULL;
2003 ret->tls_ldm_got.refcount = 0;
2005 return &ret->root.root;
2008 /* Locate the Thumb encoded calling stub for NAME. */
2010 static struct elf_link_hash_entry *
2011 find_thumb_glue (struct bfd_link_info *link_info,
2016 struct elf_link_hash_entry *hash;
2017 struct elf32_arm_link_hash_table *hash_table;
2019 /* We need a pointer to the armelf specific hash table. */
2020 hash_table = elf32_arm_hash_table (link_info);
2022 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
2023 + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
2025 BFD_ASSERT (tmp_name);
2027 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
2029 hash = elf_link_hash_lookup
2030 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
2033 /* xgettext:c-format */
2034 (*_bfd_error_handler) (_("%B: unable to find THUMB glue '%s' for `%s'"),
2035 input_bfd, tmp_name, name);
2042 /* Locate the ARM encoded calling stub for NAME. */
2044 static struct elf_link_hash_entry *
2045 find_arm_glue (struct bfd_link_info *link_info,
2050 struct elf_link_hash_entry *myh;
2051 struct elf32_arm_link_hash_table *hash_table;
2053 /* We need a pointer to the elfarm specific hash table. */
2054 hash_table = elf32_arm_hash_table (link_info);
2056 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
2057 + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
2059 BFD_ASSERT (tmp_name);
2061 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
2063 myh = elf_link_hash_lookup
2064 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
2067 /* xgettext:c-format */
2068 (*_bfd_error_handler) (_("%B: unable to find ARM glue '%s' for `%s'"),
2069 input_bfd, tmp_name, name);
2076 /* ARM->Thumb glue (static images):
2080 ldr r12, __func_addr
2083 .word func @ behave as if you saw a ARM_32 reloc.
2085 (relocatable images)
2088 ldr r12, __func_offset
2095 #define ARM2THUMB_STATIC_GLUE_SIZE 12
2096 static const insn32 a2t1_ldr_insn = 0xe59fc000;
2097 static const insn32 a2t2_bx_r12_insn = 0xe12fff1c;
2098 static const insn32 a2t3_func_addr_insn = 0x00000001;
2100 #define ARM2THUMB_PIC_GLUE_SIZE 16
2101 static const insn32 a2t1p_ldr_insn = 0xe59fc004;
2102 static const insn32 a2t2p_add_pc_insn = 0xe08cc00f;
2103 static const insn32 a2t3p_bx_r12_insn = 0xe12fff1c;
2105 /* Thumb->ARM: Thumb->(non-interworking aware) ARM
2109 __func_from_thumb: __func_from_thumb:
2111 nop ldr r6, __func_addr
2113 __func_change_to_arm: bx r6
2115 __func_back_to_thumb:
2121 #define THUMB2ARM_GLUE_SIZE 8
2122 static const insn16 t2a1_bx_pc_insn = 0x4778;
2123 static const insn16 t2a2_noop_insn = 0x46c0;
2124 static const insn32 t2a3_b_insn = 0xea000000;
2126 #ifndef ELFARM_NABI_C_INCLUDED
2128 bfd_elf32_arm_allocate_interworking_sections (struct bfd_link_info * info)
2132 struct elf32_arm_link_hash_table * globals;
2134 globals = elf32_arm_hash_table (info);
2136 BFD_ASSERT (globals != NULL);
2138 if (globals->arm_glue_size != 0)
2140 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2142 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
2143 ARM2THUMB_GLUE_SECTION_NAME);
2145 BFD_ASSERT (s != NULL);
2147 foo = bfd_alloc (globals->bfd_of_glue_owner, globals->arm_glue_size);
2149 s->size = globals->arm_glue_size;
2153 if (globals->thumb_glue_size != 0)
2155 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2157 s = bfd_get_section_by_name
2158 (globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
2160 BFD_ASSERT (s != NULL);
2162 foo = bfd_alloc (globals->bfd_of_glue_owner, globals->thumb_glue_size);
2164 s->size = globals->thumb_glue_size;
2172 record_arm_to_thumb_glue (struct bfd_link_info * link_info,
2173 struct elf_link_hash_entry * h)
2175 const char * name = h->root.root.string;
2178 struct elf_link_hash_entry * myh;
2179 struct bfd_link_hash_entry * bh;
2180 struct elf32_arm_link_hash_table * globals;
2183 globals = elf32_arm_hash_table (link_info);
2185 BFD_ASSERT (globals != NULL);
2186 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2188 s = bfd_get_section_by_name
2189 (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
2191 BFD_ASSERT (s != NULL);
2193 tmp_name = bfd_malloc ((bfd_size_type) strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
2195 BFD_ASSERT (tmp_name);
2197 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
2199 myh = elf_link_hash_lookup
2200 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
2204 /* We've already seen this guy. */
2209 /* The only trick here is using hash_table->arm_glue_size as the value.
2210 Even though the section isn't allocated yet, this is where we will be
2213 val = globals->arm_glue_size + 1;
2214 _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner,
2215 tmp_name, BSF_GLOBAL, s, val,
2216 NULL, TRUE, FALSE, &bh);
2218 myh = (struct elf_link_hash_entry *) bh;
2219 myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
2220 myh->forced_local = 1;
2224 if ((link_info->shared || globals->root.is_relocatable_executable))
2225 globals->arm_glue_size += ARM2THUMB_PIC_GLUE_SIZE;
2227 globals->arm_glue_size += ARM2THUMB_STATIC_GLUE_SIZE;
2233 record_thumb_to_arm_glue (struct bfd_link_info *link_info,
2234 struct elf_link_hash_entry *h)
2236 const char *name = h->root.root.string;
2239 struct elf_link_hash_entry *myh;
2240 struct bfd_link_hash_entry *bh;
2241 struct elf32_arm_link_hash_table *hash_table;
2244 hash_table = elf32_arm_hash_table (link_info);
2246 BFD_ASSERT (hash_table != NULL);
2247 BFD_ASSERT (hash_table->bfd_of_glue_owner != NULL);
2249 s = bfd_get_section_by_name
2250 (hash_table->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
2252 BFD_ASSERT (s != NULL);
2254 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
2255 + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
2257 BFD_ASSERT (tmp_name);
2259 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
2261 myh = elf_link_hash_lookup
2262 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
2266 /* We've already seen this guy. */
2272 val = hash_table->thumb_glue_size + 1;
2273 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
2274 tmp_name, BSF_GLOBAL, s, val,
2275 NULL, TRUE, FALSE, &bh);
2277 /* If we mark it 'Thumb', the disassembler will do a better job. */
2278 myh = (struct elf_link_hash_entry *) bh;
2279 myh->type = ELF_ST_INFO (STB_LOCAL, STT_ARM_TFUNC);
2280 myh->forced_local = 1;
2284 #define CHANGE_TO_ARM "__%s_change_to_arm"
2285 #define BACK_FROM_ARM "__%s_back_from_arm"
2287 /* Allocate another symbol to mark where we switch to Arm mode. */
2288 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
2289 + strlen (CHANGE_TO_ARM) + 1);
2291 BFD_ASSERT (tmp_name);
2293 sprintf (tmp_name, CHANGE_TO_ARM, name);
2296 val = hash_table->thumb_glue_size + 4,
2297 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
2298 tmp_name, BSF_LOCAL, s, val,
2299 NULL, TRUE, FALSE, &bh);
2303 hash_table->thumb_glue_size += THUMB2ARM_GLUE_SIZE;
2308 /* Add the glue sections to ABFD. This function is called from the
2309 linker scripts in ld/emultempl/{armelf}.em. */
2312 bfd_elf32_arm_add_glue_sections_to_bfd (bfd *abfd,
2313 struct bfd_link_info *info)
2318 /* If we are only performing a partial
2319 link do not bother adding the glue. */
2320 if (info->relocatable)
2323 sec = bfd_get_section_by_name (abfd, ARM2THUMB_GLUE_SECTION_NAME);
2327 /* Note: we do not include the flag SEC_LINKER_CREATED, as this
2328 will prevent elf_link_input_bfd() from processing the contents
2330 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE | SEC_READONLY;
2332 sec = bfd_make_section_with_flags (abfd,
2333 ARM2THUMB_GLUE_SECTION_NAME,
2337 || !bfd_set_section_alignment (abfd, sec, 2))
2340 /* Set the gc mark to prevent the section from being removed by garbage
2341 collection, despite the fact that no relocs refer to this section. */
2345 sec = bfd_get_section_by_name (abfd, THUMB2ARM_GLUE_SECTION_NAME);
2349 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2350 | SEC_CODE | SEC_READONLY;
2352 sec = bfd_make_section_with_flags (abfd,
2353 THUMB2ARM_GLUE_SECTION_NAME,
2357 || !bfd_set_section_alignment (abfd, sec, 2))
2366 /* Select a BFD to be used to hold the sections used by the glue code.
2367 This function is called from the linker scripts in ld/emultempl/
2371 bfd_elf32_arm_get_bfd_for_interworking (bfd *abfd, struct bfd_link_info *info)
2373 struct elf32_arm_link_hash_table *globals;
2375 /* If we are only performing a partial link
2376 do not bother getting a bfd to hold the glue. */
2377 if (info->relocatable)
2380 /* Make sure we don't attach the glue sections to a dynamic object. */
2381 BFD_ASSERT (!(abfd->flags & DYNAMIC));
2383 globals = elf32_arm_hash_table (info);
2385 BFD_ASSERT (globals != NULL);
2387 if (globals->bfd_of_glue_owner != NULL)
2390 /* Save the bfd for later use. */
2391 globals->bfd_of_glue_owner = abfd;
2396 static void check_use_blx(struct elf32_arm_link_hash_table *globals)
2398 if (elf32_arm_get_eabi_attr_int (globals->obfd, Tag_CPU_arch) > 2)
2399 globals->use_blx = 1;
2403 bfd_elf32_arm_process_before_allocation (bfd *abfd,
2404 struct bfd_link_info *link_info,
2407 Elf_Internal_Shdr *symtab_hdr;
2408 Elf_Internal_Rela *internal_relocs = NULL;
2409 Elf_Internal_Rela *irel, *irelend;
2410 bfd_byte *contents = NULL;
2413 struct elf32_arm_link_hash_table *globals;
2415 /* If we are only performing a partial link do not bother
2416 to construct any glue. */
2417 if (link_info->relocatable)
2420 /* Here we have a bfd that is to be included on the link. We have a hook
2421 to do reloc rummaging, before section sizes are nailed down. */
2422 globals = elf32_arm_hash_table (link_info);
2423 check_use_blx (globals);
2425 BFD_ASSERT (globals != NULL);
2426 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2428 if (byteswap_code && !bfd_big_endian (abfd))
2430 _bfd_error_handler (_("%B: BE8 images only valid in big-endian mode."),
2434 globals->byteswap_code = byteswap_code;
2436 /* Rummage around all the relocs and map the glue vectors. */
2437 sec = abfd->sections;
2442 for (; sec != NULL; sec = sec->next)
2444 if (sec->reloc_count == 0)
2447 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2449 /* Load the relocs. */
2451 = _bfd_elf_link_read_relocs (abfd, sec, (void *) NULL,
2452 (Elf_Internal_Rela *) NULL, FALSE);
2454 if (internal_relocs == NULL)
2457 irelend = internal_relocs + sec->reloc_count;
2458 for (irel = internal_relocs; irel < irelend; irel++)
2461 unsigned long r_index;
2463 struct elf_link_hash_entry *h;
2465 r_type = ELF32_R_TYPE (irel->r_info);
2466 r_index = ELF32_R_SYM (irel->r_info);
2468 /* These are the only relocation types we care about. */
2469 if ( r_type != R_ARM_PC24
2470 && r_type != R_ARM_PLT32
2471 && r_type != R_ARM_CALL
2472 && r_type != R_ARM_JUMP24
2473 && r_type != R_ARM_THM_CALL)
2476 /* Get the section contents if we haven't done so already. */
2477 if (contents == NULL)
2479 /* Get cached copy if it exists. */
2480 if (elf_section_data (sec)->this_hdr.contents != NULL)
2481 contents = elf_section_data (sec)->this_hdr.contents;
2484 /* Go get them off disk. */
2485 if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2490 /* If the relocation is not against a symbol it cannot concern us. */
2493 /* We don't care about local symbols. */
2494 if (r_index < symtab_hdr->sh_info)
2497 /* This is an external symbol. */
2498 r_index -= symtab_hdr->sh_info;
2499 h = (struct elf_link_hash_entry *)
2500 elf_sym_hashes (abfd)[r_index];
2502 /* If the relocation is against a static symbol it must be within
2503 the current section and so cannot be a cross ARM/Thumb relocation. */
2507 /* If the call will go through a PLT entry then we do not need
2509 if (globals->splt != NULL && h->plt.offset != (bfd_vma) -1)
2518 /* This one is a call from arm code. We need to look up
2519 the target of the call. If it is a thumb target, we
2521 if (ELF_ST_TYPE(h->type) == STT_ARM_TFUNC
2522 && !(r_type == R_ARM_CALL && globals->use_blx))
2523 record_arm_to_thumb_glue (link_info, h);
2526 case R_ARM_THM_CALL:
2527 /* This one is a call from thumb code. We look
2528 up the target of the call. If it is not a thumb
2529 target, we insert glue. */
2530 if (ELF_ST_TYPE (h->type) != STT_ARM_TFUNC && !globals->use_blx)
2531 record_thumb_to_arm_glue (link_info, h);
2539 if (contents != NULL
2540 && elf_section_data (sec)->this_hdr.contents != contents)
2544 if (internal_relocs != NULL
2545 && elf_section_data (sec)->relocs != internal_relocs)
2546 free (internal_relocs);
2547 internal_relocs = NULL;
2553 if (contents != NULL
2554 && elf_section_data (sec)->this_hdr.contents != contents)
2556 if (internal_relocs != NULL
2557 && elf_section_data (sec)->relocs != internal_relocs)
2558 free (internal_relocs);
2565 /* Set target relocation values needed during linking. */
2568 bfd_elf32_arm_set_target_relocs (struct bfd_link_info *link_info,
2570 char * target2_type,
2574 struct elf32_arm_link_hash_table *globals;
2576 globals = elf32_arm_hash_table (link_info);
2578 globals->target1_is_rel = target1_is_rel;
2579 if (strcmp (target2_type, "rel") == 0)
2580 globals->target2_reloc = R_ARM_REL32;
2581 else if (strcmp (target2_type, "abs") == 0)
2582 globals->target2_reloc = R_ARM_ABS32;
2583 else if (strcmp (target2_type, "got-rel") == 0)
2584 globals->target2_reloc = R_ARM_GOT_PREL;
2587 _bfd_error_handler (_("Invalid TARGET2 relocation type '%s'."),
2590 globals->fix_v4bx = fix_v4bx;
2591 globals->use_blx |= use_blx;
2594 /* The thumb form of a long branch is a bit finicky, because the offset
2595 encoding is split over two fields, each in it's own instruction. They
2596 can occur in any order. So given a thumb form of long branch, and an
2597 offset, insert the offset into the thumb branch and return finished
2600 It takes two thumb instructions to encode the target address. Each has
2601 11 bits to invest. The upper 11 bits are stored in one (identified by
2602 H-0.. see below), the lower 11 bits are stored in the other (identified
2605 Combine together and shifted left by 1 (it's a half word address) and
2609 H-0, upper address-0 = 000
2611 H-1, lower address-0 = 800
2613 They can be ordered either way, but the arm tools I've seen always put
2614 the lower one first. It probably doesn't matter. krk@cygnus.com
2616 XXX: Actually the order does matter. The second instruction (H-1)
2617 moves the computed address into the PC, so it must be the second one
2618 in the sequence. The problem, however is that whilst little endian code
2619 stores the instructions in HI then LOW order, big endian code does the
2620 reverse. nickc@cygnus.com. */
2622 #define LOW_HI_ORDER 0xF800F000
2623 #define HI_LOW_ORDER 0xF000F800
2626 insert_thumb_branch (insn32 br_insn, int rel_off)
2628 unsigned int low_bits;
2629 unsigned int high_bits;
2631 BFD_ASSERT ((rel_off & 1) != 1);
2633 rel_off >>= 1; /* Half word aligned address. */
2634 low_bits = rel_off & 0x000007FF; /* The bottom 11 bits. */
2635 high_bits = (rel_off >> 11) & 0x000007FF; /* The top 11 bits. */
2637 if ((br_insn & LOW_HI_ORDER) == LOW_HI_ORDER)
2638 br_insn = LOW_HI_ORDER | (low_bits << 16) | high_bits;
2639 else if ((br_insn & HI_LOW_ORDER) == HI_LOW_ORDER)
2640 br_insn = HI_LOW_ORDER | (high_bits << 16) | low_bits;
2642 /* FIXME: abort is probably not the right call. krk@cygnus.com */
2643 abort (); /* Error - not a valid branch instruction form. */
2648 /* Thumb code calling an ARM function. */
2651 elf32_thumb_to_arm_stub (struct bfd_link_info * info,
2655 asection * input_section,
2656 bfd_byte * hit_data,
2659 bfd_signed_vma addend,
2664 unsigned long int tmp;
2665 long int ret_offset;
2666 struct elf_link_hash_entry * myh;
2667 struct elf32_arm_link_hash_table * globals;
2669 myh = find_thumb_glue (info, name, input_bfd);
2673 globals = elf32_arm_hash_table (info);
2675 BFD_ASSERT (globals != NULL);
2676 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2678 my_offset = myh->root.u.def.value;
2680 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
2681 THUMB2ARM_GLUE_SECTION_NAME);
2683 BFD_ASSERT (s != NULL);
2684 BFD_ASSERT (s->contents != NULL);
2685 BFD_ASSERT (s->output_section != NULL);
2687 if ((my_offset & 0x01) == 0x01)
2690 && sym_sec->owner != NULL
2691 && !INTERWORK_FLAG (sym_sec->owner))
2693 (*_bfd_error_handler)
2694 (_("%B(%s): warning: interworking not enabled.\n"
2695 " first occurrence: %B: thumb call to arm"),
2696 sym_sec->owner, input_bfd, name);
2702 myh->root.u.def.value = my_offset;
2704 bfd_put_16 (output_bfd, (bfd_vma) t2a1_bx_pc_insn,
2705 s->contents + my_offset);
2707 bfd_put_16 (output_bfd, (bfd_vma) t2a2_noop_insn,
2708 s->contents + my_offset + 2);
2711 /* Address of destination of the stub. */
2712 ((bfd_signed_vma) val)
2714 /* Offset from the start of the current section
2715 to the start of the stubs. */
2717 /* Offset of the start of this stub from the start of the stubs. */
2719 /* Address of the start of the current section. */
2720 + s->output_section->vma)
2721 /* The branch instruction is 4 bytes into the stub. */
2723 /* ARM branches work from the pc of the instruction + 8. */
2726 bfd_put_32 (output_bfd,
2727 (bfd_vma) t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
2728 s->contents + my_offset + 4);
2731 BFD_ASSERT (my_offset <= globals->thumb_glue_size);
2733 /* Now go back and fix up the original BL insn to point to here. */
2735 /* Address of where the stub is located. */
2736 (s->output_section->vma + s->output_offset + my_offset)
2737 /* Address of where the BL is located. */
2738 - (input_section->output_section->vma + input_section->output_offset
2740 /* Addend in the relocation. */
2742 /* Biassing for PC-relative addressing. */
2745 tmp = bfd_get_32 (input_bfd, hit_data
2746 - input_section->vma);
2748 bfd_put_32 (output_bfd,
2749 (bfd_vma) insert_thumb_branch (tmp, ret_offset),
2750 hit_data - input_section->vma);
2755 /* Arm code calling a Thumb function. */
2758 elf32_arm_to_thumb_stub (struct bfd_link_info * info,
2762 asection * input_section,
2763 bfd_byte * hit_data,
2766 bfd_signed_vma addend,
2769 unsigned long int tmp;
2772 long int ret_offset;
2773 struct elf_link_hash_entry * myh;
2774 struct elf32_arm_link_hash_table * globals;
2776 myh = find_arm_glue (info, name, input_bfd);
2780 globals = elf32_arm_hash_table (info);
2782 BFD_ASSERT (globals != NULL);
2783 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2785 my_offset = myh->root.u.def.value;
2786 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
2787 ARM2THUMB_GLUE_SECTION_NAME);
2788 BFD_ASSERT (s != NULL);
2789 BFD_ASSERT (s->contents != NULL);
2790 BFD_ASSERT (s->output_section != NULL);
2792 if ((my_offset & 0x01) == 0x01)
2795 && sym_sec->owner != NULL
2796 && !INTERWORK_FLAG (sym_sec->owner))
2798 (*_bfd_error_handler)
2799 (_("%B(%s): warning: interworking not enabled.\n"
2800 " first occurrence: %B: arm call to thumb"),
2801 sym_sec->owner, input_bfd, name);
2805 myh->root.u.def.value = my_offset;
2807 if ((info->shared || globals->root.is_relocatable_executable))
2809 /* For relocatable objects we can't use absolute addresses,
2810 so construct the address from a relative offset. */
2811 /* TODO: If the offset is small it's probably worth
2812 constructing the address with adds. */
2813 bfd_put_32 (output_bfd, (bfd_vma) a2t1p_ldr_insn,
2814 s->contents + my_offset);
2815 bfd_put_32 (output_bfd, (bfd_vma) a2t2p_add_pc_insn,
2816 s->contents + my_offset + 4);
2817 bfd_put_32 (output_bfd, (bfd_vma) a2t3p_bx_r12_insn,
2818 s->contents + my_offset + 8);
2819 /* Adjust the offset by 4 for the position of the add,
2820 and 8 for the pipeline offset. */
2821 ret_offset = (val - (s->output_offset
2822 + s->output_section->vma
2825 bfd_put_32 (output_bfd, ret_offset,
2826 s->contents + my_offset + 12);
2830 bfd_put_32 (output_bfd, (bfd_vma) a2t1_ldr_insn,
2831 s->contents + my_offset);
2833 bfd_put_32 (output_bfd, (bfd_vma) a2t2_bx_r12_insn,
2834 s->contents + my_offset + 4);
2836 /* It's a thumb address. Add the low order bit. */
2837 bfd_put_32 (output_bfd, val | a2t3_func_addr_insn,
2838 s->contents + my_offset + 8);
2842 BFD_ASSERT (my_offset <= globals->arm_glue_size);
2844 tmp = bfd_get_32 (input_bfd, hit_data);
2845 tmp = tmp & 0xFF000000;
2847 /* Somehow these are both 4 too far, so subtract 8. */
2848 ret_offset = (s->output_offset
2850 + s->output_section->vma
2851 - (input_section->output_offset
2852 + input_section->output_section->vma
2856 tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
2858 bfd_put_32 (output_bfd, (bfd_vma) tmp, hit_data - input_section->vma);
2863 /* Some relocations map to different relocations depending on the
2864 target. Return the real relocation. */
2866 arm_real_reloc_type (struct elf32_arm_link_hash_table * globals,
2872 if (globals->target1_is_rel)
2878 return globals->target2_reloc;
2885 /* Return the base VMA address which should be subtracted from real addresses
2886 when resolving @dtpoff relocation.
2887 This is PT_TLS segment p_vaddr. */
2890 dtpoff_base (struct bfd_link_info *info)
2892 /* If tls_sec is NULL, we should have signalled an error already. */
2893 if (elf_hash_table (info)->tls_sec == NULL)
2895 return elf_hash_table (info)->tls_sec->vma;
2898 /* Return the relocation value for @tpoff relocation
2899 if STT_TLS virtual address is ADDRESS. */
2902 tpoff (struct bfd_link_info *info, bfd_vma address)
2904 struct elf_link_hash_table *htab = elf_hash_table (info);
2907 /* If tls_sec is NULL, we should have signalled an error already. */
2908 if (htab->tls_sec == NULL)
2910 base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power);
2911 return address - htab->tls_sec->vma + base;
2914 /* Perform an R_ARM_ABS12 relocation on the field pointed to by DATA.
2915 VALUE is the relocation value. */
2917 static bfd_reloc_status_type
2918 elf32_arm_abs12_reloc (bfd *abfd, void *data, bfd_vma value)
2921 return bfd_reloc_overflow;
2923 value |= bfd_get_32 (abfd, data) & 0xfffff000;
2924 bfd_put_32 (abfd, value, data);
2925 return bfd_reloc_ok;
2928 /* Perform a relocation as part of a final link. */
2930 static bfd_reloc_status_type
2931 elf32_arm_final_link_relocate (reloc_howto_type * howto,
2934 asection * input_section,
2935 bfd_byte * contents,
2936 Elf_Internal_Rela * rel,
2938 struct bfd_link_info * info,
2940 const char * sym_name,
2942 struct elf_link_hash_entry * h,
2943 bfd_boolean * unresolved_reloc_p)
2945 unsigned long r_type = howto->type;
2946 unsigned long r_symndx;
2947 bfd_byte * hit_data = contents + rel->r_offset;
2948 bfd * dynobj = NULL;
2949 Elf_Internal_Shdr * symtab_hdr;
2950 struct elf_link_hash_entry ** sym_hashes;
2951 bfd_vma * local_got_offsets;
2952 asection * sgot = NULL;
2953 asection * splt = NULL;
2954 asection * sreloc = NULL;
2956 bfd_signed_vma signed_addend;
2957 struct elf32_arm_link_hash_table * globals;
2959 globals = elf32_arm_hash_table (info);
2961 /* Some relocation type map to different relocations depending on the
2962 target. We pick the right one here. */
2963 r_type = arm_real_reloc_type (globals, r_type);
2964 if (r_type != howto->type)
2965 howto = elf32_arm_howto_from_type (r_type);
2967 /* If the start address has been set, then set the EF_ARM_HASENTRY
2968 flag. Setting this more than once is redundant, but the cost is
2969 not too high, and it keeps the code simple.
2971 The test is done here, rather than somewhere else, because the
2972 start address is only set just before the final link commences.
2974 Note - if the user deliberately sets a start address of 0, the
2975 flag will not be set. */
2976 if (bfd_get_start_address (output_bfd) != 0)
2977 elf_elfheader (output_bfd)->e_flags |= EF_ARM_HASENTRY;
2979 dynobj = elf_hash_table (info)->dynobj;
2982 sgot = bfd_get_section_by_name (dynobj, ".got");
2983 splt = bfd_get_section_by_name (dynobj, ".plt");
2985 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
2986 sym_hashes = elf_sym_hashes (input_bfd);
2987 local_got_offsets = elf_local_got_offsets (input_bfd);
2988 r_symndx = ELF32_R_SYM (rel->r_info);
2990 if (globals->use_rel)
2992 addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask;
2994 if (addend & ((howto->src_mask + 1) >> 1))
2997 signed_addend &= ~ howto->src_mask;
2998 signed_addend |= addend;
3001 signed_addend = addend;
3004 addend = signed_addend = rel->r_addend;
3009 /* We don't need to find a value for this symbol. It's just a
3011 *unresolved_reloc_p = FALSE;
3012 return bfd_reloc_ok;
3015 if (!globals->vxworks_p)
3016 return elf32_arm_abs12_reloc (input_bfd, hit_data, value + addend);
3026 /* r_symndx will be zero only for relocs against symbols
3027 from removed linkonce sections, or sections discarded by
3030 return bfd_reloc_ok;
3032 /* Handle relocations which should use the PLT entry. ABS32/REL32
3033 will use the symbol's value, which may point to a PLT entry, but we
3034 don't need to handle that here. If we created a PLT entry, all
3035 branches in this object should go to it. */
3036 if ((r_type != R_ARM_ABS32 && r_type != R_ARM_REL32)
3039 && h->plt.offset != (bfd_vma) -1)
3041 /* If we've created a .plt section, and assigned a PLT entry to
3042 this function, it should not be known to bind locally. If
3043 it were, we would have cleared the PLT entry. */
3044 BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info, h));
3046 value = (splt->output_section->vma
3047 + splt->output_offset
3049 *unresolved_reloc_p = FALSE;
3050 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3051 contents, rel->r_offset, value,
3055 /* When generating a shared object or relocatable executable, these
3056 relocations are copied into the output file to be resolved at
3058 if ((info->shared || globals->root.is_relocatable_executable)
3059 && (input_section->flags & SEC_ALLOC)
3060 && (r_type != R_ARM_REL32
3061 || !SYMBOL_CALLS_LOCAL (info, h))
3063 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3064 || h->root.type != bfd_link_hash_undefweak)
3065 && r_type != R_ARM_PC24
3066 && r_type != R_ARM_CALL
3067 && r_type != R_ARM_JUMP24
3068 && r_type != R_ARM_PREL31
3069 && r_type != R_ARM_PLT32)
3071 Elf_Internal_Rela outrel;
3073 bfd_boolean skip, relocate;
3075 *unresolved_reloc_p = FALSE;
3081 name = (bfd_elf_string_from_elf_section
3083 elf_elfheader (input_bfd)->e_shstrndx,
3084 elf_section_data (input_section)->rel_hdr.sh_name));
3086 return bfd_reloc_notsupported;
3088 BFD_ASSERT (reloc_section_p (globals, name, input_section));
3090 sreloc = bfd_get_section_by_name (dynobj, name);
3091 BFD_ASSERT (sreloc != NULL);
3097 outrel.r_addend = addend;
3099 _bfd_elf_section_offset (output_bfd, info, input_section,
3101 if (outrel.r_offset == (bfd_vma) -1)
3103 else if (outrel.r_offset == (bfd_vma) -2)
3104 skip = TRUE, relocate = TRUE;
3105 outrel.r_offset += (input_section->output_section->vma
3106 + input_section->output_offset);
3109 memset (&outrel, 0, sizeof outrel);
3114 || !h->def_regular))
3115 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3120 /* This symbol is local, or marked to become local. */
3121 if (sym_flags == STT_ARM_TFUNC)
3123 if (globals->symbian_p)
3125 /* On Symbian OS, the data segment and text segement
3126 can be relocated independently. Therefore, we
3127 must indicate the segment to which this
3128 relocation is relative. The BPABI allows us to
3129 use any symbol in the right segment; we just use
3130 the section symbol as it is convenient. (We
3131 cannot use the symbol given by "h" directly as it
3132 will not appear in the dynamic symbol table.) */
3134 symbol = elf_section_data (sym_sec->output_section)->dynindx;
3136 symbol = elf_section_data (input_section->output_section)->dynindx;
3137 BFD_ASSERT (symbol != 0);
3140 /* On SVR4-ish systems, the dynamic loader cannot
3141 relocate the text and data segments independently,
3142 so the symbol does not matter. */
3144 outrel.r_info = ELF32_R_INFO (symbol, R_ARM_RELATIVE);
3145 if (globals->use_rel)
3148 outrel.r_addend += value;
3151 loc = sreloc->contents;
3152 loc += sreloc->reloc_count++ * RELOC_SIZE (globals);
3153 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
3155 /* If this reloc is against an external symbol, we do not want to
3156 fiddle with the addend. Otherwise, we need to include the symbol
3157 value so that it becomes an addend for the dynamic reloc. */
3159 return bfd_reloc_ok;
3161 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3162 contents, rel->r_offset, value,
3165 else switch (r_type)
3168 return elf32_arm_abs12_reloc (input_bfd, hit_data, value + addend);
3170 case R_ARM_XPC25: /* Arm BLX instruction. */
3173 case R_ARM_PC24: /* Arm B/BL instruction */
3175 if (r_type == R_ARM_XPC25)
3177 /* Check for Arm calling Arm function. */
3178 /* FIXME: Should we translate the instruction into a BL
3179 instruction instead ? */
3180 if (sym_flags != STT_ARM_TFUNC)
3181 (*_bfd_error_handler)
3182 (_("\%B: Warning: Arm BLX instruction targets Arm function '%s'."),
3184 h ? h->root.root.string : "(local)");
3186 else if (r_type != R_ARM_CALL || !globals->use_blx)
3188 /* Check for Arm calling Thumb function. */
3189 if (sym_flags == STT_ARM_TFUNC)
3191 elf32_arm_to_thumb_stub (info, sym_name, input_bfd,
3192 output_bfd, input_section,
3193 hit_data, sym_sec, rel->r_offset,
3194 signed_addend, value);
3195 return bfd_reloc_ok;
3199 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
3201 S is the address of the symbol in the relocation.
3202 P is address of the instruction being relocated.
3203 A is the addend (extracted from the instruction) in bytes.
3205 S is held in 'value'.
3206 P is the base address of the section containing the
3207 instruction plus the offset of the reloc into that
3209 (input_section->output_section->vma +
3210 input_section->output_offset +
3212 A is the addend, converted into bytes, ie:
3215 Note: None of these operations have knowledge of the pipeline
3216 size of the processor, thus it is up to the assembler to
3217 encode this information into the addend. */
3218 value -= (input_section->output_section->vma
3219 + input_section->output_offset);
3220 value -= rel->r_offset;
3221 if (globals->use_rel)
3222 value += (signed_addend << howto->size);
3224 /* RELA addends do not have to be adjusted by howto->size. */
3225 value += signed_addend;
3227 signed_addend = value;
3228 signed_addend >>= howto->rightshift;
3230 /* It is not an error for an undefined weak reference to be
3231 out of range. Any program that branches to such a symbol
3232 is going to crash anyway, so there is no point worrying
3233 about getting the destination exactly right. */
3234 if (! h || h->root.type != bfd_link_hash_undefweak)
3236 /* Perform a signed range check. */
3237 if ( signed_addend > ((bfd_signed_vma) (howto->dst_mask >> 1))
3238 || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1)))
3239 return bfd_reloc_overflow;
3242 addend = (value & 2);
3244 value = (signed_addend & howto->dst_mask)
3245 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
3247 /* Set the H bit in the BLX instruction. */
3248 if (sym_flags == STT_ARM_TFUNC)
3253 value &= ~(bfd_vma)(1 << 24);
3255 if (r_type == R_ARM_CALL)
3257 /* Select the correct instruction (BL or BLX). */
3258 if (sym_flags == STT_ARM_TFUNC)
3262 value &= ~(bfd_vma)(1 << 28);
3270 if (sym_flags == STT_ARM_TFUNC)
3275 value -= (input_section->output_section->vma
3276 + input_section->output_offset + rel->r_offset);
3281 value -= (input_section->output_section->vma
3282 + input_section->output_offset + rel->r_offset);
3283 value += signed_addend;
3284 if (! h || h->root.type != bfd_link_hash_undefweak)
3286 /* Check for overflow */
3287 if ((value ^ (value >> 1)) & (1 << 30))
3288 return bfd_reloc_overflow;
3290 value &= 0x7fffffff;
3291 value |= (bfd_get_32 (input_bfd, hit_data) & 0x80000000);
3292 if (sym_flags == STT_ARM_TFUNC)
3297 bfd_put_32 (input_bfd, value, hit_data);
3298 return bfd_reloc_ok;
3302 if ((long) value > 0x7f || (long) value < -0x80)
3303 return bfd_reloc_overflow;
3305 bfd_put_8 (input_bfd, value, hit_data);
3306 return bfd_reloc_ok;
3311 if ((long) value > 0x7fff || (long) value < -0x8000)
3312 return bfd_reloc_overflow;
3314 bfd_put_16 (input_bfd, value, hit_data);
3315 return bfd_reloc_ok;
3317 case R_ARM_THM_ABS5:
3318 /* Support ldr and str instructions for the thumb. */
3319 if (globals->use_rel)
3321 /* Need to refetch addend. */
3322 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
3323 /* ??? Need to determine shift amount from operand size. */
3324 addend >>= howto->rightshift;
3328 /* ??? Isn't value unsigned? */
3329 if ((long) value > 0x1f || (long) value < -0x10)
3330 return bfd_reloc_overflow;
3332 /* ??? Value needs to be properly shifted into place first. */
3333 value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
3334 bfd_put_16 (input_bfd, value, hit_data);
3335 return bfd_reloc_ok;
3337 case R_ARM_THM_XPC22:
3338 case R_ARM_THM_CALL:
3339 /* Thumb BL (branch long instruction). */
3342 bfd_boolean overflow = FALSE;
3343 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
3344 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
3345 bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
3346 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
3348 bfd_signed_vma signed_check;
3350 /* Need to refetch the addend and squish the two 11 bit pieces
3352 if (globals->use_rel)
3354 bfd_vma upper = upper_insn & 0x7ff;
3355 bfd_vma lower = lower_insn & 0x7ff;
3356 upper = (upper ^ 0x400) - 0x400; /* Sign extend. */
3357 addend = (upper << 12) | (lower << 1);
3358 signed_addend = addend;
3361 if (r_type == R_ARM_THM_XPC22)
3363 /* Check for Thumb to Thumb call. */
3364 /* FIXME: Should we translate the instruction into a BL
3365 instruction instead ? */
3366 if (sym_flags == STT_ARM_TFUNC)
3367 (*_bfd_error_handler)
3368 (_("%B: Warning: Thumb BLX instruction targets thumb function '%s'."),
3370 h ? h->root.root.string : "(local)");
3374 /* If it is not a call to Thumb, assume call to Arm.
3375 If it is a call relative to a section name, then it is not a
3376 function call at all, but rather a long jump. Calls through
3377 the PLT do not require stubs. */
3378 if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION
3379 && (h == NULL || splt == NULL
3380 || h->plt.offset == (bfd_vma) -1))
3382 if (globals->use_blx)
3384 /* Convert BL to BLX. */
3385 lower_insn = (lower_insn & ~0x1000) | 0x0800;
3387 else if (elf32_thumb_to_arm_stub
3388 (info, sym_name, input_bfd, output_bfd, input_section,
3389 hit_data, sym_sec, rel->r_offset, signed_addend, value))
3390 return bfd_reloc_ok;
3392 return bfd_reloc_dangerous;
3394 else if (sym_flags == STT_ARM_TFUNC && globals->use_blx)
3396 /* Make sure this is a BL. */
3397 lower_insn |= 0x1800;
3401 /* Handle calls via the PLT. */
3402 if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
3404 value = (splt->output_section->vma
3405 + splt->output_offset
3407 if (globals->use_blx)
3409 /* If the Thumb BLX instruction is available, convert the
3410 BL to a BLX instruction to call the ARM-mode PLT entry. */
3411 lower_insn = (lower_insn & ~0x1000) | 0x0800;
3414 /* Target the Thumb stub before the ARM PLT entry. */
3415 value -= PLT_THUMB_STUB_SIZE;
3416 *unresolved_reloc_p = FALSE;
3419 relocation = value + signed_addend;
3421 relocation -= (input_section->output_section->vma
3422 + input_section->output_offset
3425 check = relocation >> howto->rightshift;
3427 /* If this is a signed value, the rightshift just dropped
3428 leading 1 bits (assuming twos complement). */
3429 if ((bfd_signed_vma) relocation >= 0)
3430 signed_check = check;
3432 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
3434 /* Assumes two's complement. */
3435 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
3438 if ((lower_insn & 0x1800) == 0x0800)
3439 /* For a BLX instruction, make sure that the relocation is rounded up
3440 to a word boundary. This follows the semantics of the instruction
3441 which specifies that bit 1 of the target address will come from bit
3442 1 of the base address. */
3443 relocation = (relocation + 2) & ~ 3;
3445 /* Put RELOCATION back into the insn. */
3446 upper_insn = (upper_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 12) & 0x7ff);
3447 lower_insn = (lower_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 1) & 0x7ff);
3449 /* Put the relocated value back in the object file: */
3450 bfd_put_16 (input_bfd, upper_insn, hit_data);
3451 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
3453 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
3457 case R_ARM_THM_JUMP24:
3458 /* Thumb32 unconditional branch instruction. */
3461 bfd_boolean overflow = FALSE;
3462 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
3463 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
3464 bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
3465 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
3467 bfd_signed_vma signed_check;
3469 /* Need to refetch the addend, reconstruct the top three bits, and glue the
3470 two pieces together. */
3471 if (globals->use_rel)
3473 bfd_vma S = (upper_insn & 0x0400) >> 10;
3474 bfd_vma hi = (upper_insn & 0x03ff);
3475 bfd_vma I1 = (lower_insn & 0x2000) >> 13;
3476 bfd_vma I2 = (lower_insn & 0x0800) >> 11;
3477 bfd_vma lo = (lower_insn & 0x07ff);
3483 signed_addend = (S << 24) | (I1 << 23) | (I2 << 22) | (hi << 12) | (lo << 1);
3484 signed_addend -= (1 << 24); /* Sign extend. */
3487 /* ??? Should handle interworking? GCC might someday try to
3488 use this for tail calls. */
3490 relocation = value + signed_addend;
3491 relocation -= (input_section->output_section->vma
3492 + input_section->output_offset
3495 check = relocation >> howto->rightshift;
3497 /* If this is a signed value, the rightshift just dropped
3498 leading 1 bits (assuming twos complement). */
3499 if ((bfd_signed_vma) relocation >= 0)
3500 signed_check = check;
3502 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
3504 /* Assumes two's complement. */
3505 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
3508 /* Put RELOCATION back into the insn. */
3510 bfd_vma S = (relocation & 0x01000000) >> 24;
3511 bfd_vma I1 = (relocation & 0x00800000) >> 23;
3512 bfd_vma I2 = (relocation & 0x00400000) >> 22;
3513 bfd_vma hi = (relocation & 0x003ff000) >> 12;
3514 bfd_vma lo = (relocation & 0x00000ffe) >> 1;
3519 upper_insn = (upper_insn & (bfd_vma) 0xf800) | (S << 10) | hi;
3520 lower_insn = (lower_insn & (bfd_vma) 0xd000) | (I1 << 13) | (I2 << 11) | lo;
3523 /* Put the relocated value back in the object file: */
3524 bfd_put_16 (input_bfd, upper_insn, hit_data);
3525 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
3527 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
3530 case R_ARM_THM_JUMP19:
3531 /* Thumb32 conditional branch instruction. */
3534 bfd_boolean overflow = FALSE;
3535 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
3536 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
3537 bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
3538 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
3540 bfd_signed_vma signed_check;
3542 /* Need to refetch the addend, reconstruct the top three bits,
3543 and squish the two 11 bit pieces together. */
3544 if (globals->use_rel)
3546 bfd_vma S = (upper_insn & 0x0400) >> 10;
3547 bfd_vma upper = (upper_insn & 0x001f);
3548 bfd_vma J1 = (lower_insn & 0x2000) >> 13;
3549 bfd_vma J2 = (lower_insn & 0x0800) >> 11;
3550 bfd_vma lower = (lower_insn & 0x07ff);
3555 upper -= 0x0100; /* Sign extend. */
3557 addend = (upper << 12) | (lower << 1);
3558 signed_addend = addend;
3561 /* ??? Should handle interworking? GCC might someday try to
3562 use this for tail calls. */
3564 relocation = value + signed_addend;
3565 relocation -= (input_section->output_section->vma
3566 + input_section->output_offset
3569 check = relocation >> howto->rightshift;
3571 /* If this is a signed value, the rightshift just dropped
3572 leading 1 bits (assuming twos complement). */
3573 if ((bfd_signed_vma) relocation >= 0)
3574 signed_check = check;
3576 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
3578 /* Assumes two's complement. */
3579 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
3582 /* Put RELOCATION back into the insn. */
3584 bfd_vma S = (relocation & 0x00100000) >> 20;
3585 bfd_vma J2 = (relocation & 0x00080000) >> 19;
3586 bfd_vma J1 = (relocation & 0x00040000) >> 18;
3587 bfd_vma hi = (relocation & 0x0003f000) >> 12;
3588 bfd_vma lo = (relocation & 0x00000ffe) >> 1;
3590 upper_insn = (upper_insn & 0xfb30) | (S << 10) | hi;
3591 lower_insn = (lower_insn & 0xd000) | (J1 << 13) | (J2 << 11) | lo;
3594 /* Put the relocated value back in the object file: */
3595 bfd_put_16 (input_bfd, upper_insn, hit_data);
3596 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
3598 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
3601 case R_ARM_THM_JUMP11:
3602 case R_ARM_THM_JUMP8:
3603 case R_ARM_THM_JUMP6:
3604 /* Thumb B (branch) instruction). */
3606 bfd_signed_vma relocation;
3607 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
3608 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
3609 bfd_signed_vma signed_check;
3611 /* CZB cannot jump backward. */
3612 if (r_type == R_ARM_THM_JUMP6)
3613 reloc_signed_min = 0;
3615 if (globals->use_rel)
3617 /* Need to refetch addend. */
3618 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
3619 if (addend & ((howto->src_mask + 1) >> 1))
3622 signed_addend &= ~ howto->src_mask;
3623 signed_addend |= addend;
3626 signed_addend = addend;
3627 /* The value in the insn has been right shifted. We need to
3628 undo this, so that we can perform the address calculation
3629 in terms of bytes. */
3630 signed_addend <<= howto->rightshift;
3632 relocation = value + signed_addend;
3634 relocation -= (input_section->output_section->vma
3635 + input_section->output_offset
3638 relocation >>= howto->rightshift;
3639 signed_check = relocation;
3641 if (r_type == R_ARM_THM_JUMP6)
3642 relocation = ((relocation & 0x0020) << 4) | ((relocation & 0x001f) << 3);
3644 relocation &= howto->dst_mask;
3645 relocation |= (bfd_get_16 (input_bfd, hit_data) & (~ howto->dst_mask));
3647 bfd_put_16 (input_bfd, relocation, hit_data);
3649 /* Assumes two's complement. */
3650 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
3651 return bfd_reloc_overflow;
3653 return bfd_reloc_ok;
3656 case R_ARM_ALU_PCREL7_0:
3657 case R_ARM_ALU_PCREL15_8:
3658 case R_ARM_ALU_PCREL23_15:
3663 insn = bfd_get_32 (input_bfd, hit_data);
3664 if (globals->use_rel)
3666 /* Extract the addend. */
3667 addend = (insn & 0xff) << ((insn & 0xf00) >> 7);
3668 signed_addend = addend;
3670 relocation = value + signed_addend;
3672 relocation -= (input_section->output_section->vma
3673 + input_section->output_offset
3675 insn = (insn & ~0xfff)
3676 | ((howto->bitpos << 7) & 0xf00)
3677 | ((relocation >> howto->bitpos) & 0xff);
3678 bfd_put_32 (input_bfd, value, hit_data);
3680 return bfd_reloc_ok;
3682 case R_ARM_GNU_VTINHERIT:
3683 case R_ARM_GNU_VTENTRY:
3684 return bfd_reloc_ok;
3686 case R_ARM_GOTOFF32:
3687 /* Relocation is relative to the start of the
3688 global offset table. */
3690 BFD_ASSERT (sgot != NULL);
3692 return bfd_reloc_notsupported;
3694 /* If we are addressing a Thumb function, we need to adjust the
3695 address by one, so that attempts to call the function pointer will
3696 correctly interpret it as Thumb code. */
3697 if (sym_flags == STT_ARM_TFUNC)
3700 /* Note that sgot->output_offset is not involved in this
3701 calculation. We always want the start of .got. If we
3702 define _GLOBAL_OFFSET_TABLE in a different way, as is
3703 permitted by the ABI, we might have to change this
3705 value -= sgot->output_section->vma;
3706 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3707 contents, rel->r_offset, value,
3711 /* Use global offset table as symbol value. */
3712 BFD_ASSERT (sgot != NULL);
3715 return bfd_reloc_notsupported;
3717 *unresolved_reloc_p = FALSE;
3718 value = sgot->output_section->vma;
3719 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3720 contents, rel->r_offset, value,
3724 case R_ARM_GOT_PREL:
3725 /* Relocation is to the entry for this symbol in the
3726 global offset table. */
3728 return bfd_reloc_notsupported;
3735 off = h->got.offset;
3736 BFD_ASSERT (off != (bfd_vma) -1);
3737 dyn = globals->root.dynamic_sections_created;
3739 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3741 && SYMBOL_REFERENCES_LOCAL (info, h))
3742 || (ELF_ST_VISIBILITY (h->other)
3743 && h->root.type == bfd_link_hash_undefweak))
3745 /* This is actually a static link, or it is a -Bsymbolic link
3746 and the symbol is defined locally. We must initialize this
3747 entry in the global offset table. Since the offset must
3748 always be a multiple of 4, we use the least significant bit
3749 to record whether we have initialized it already.
3751 When doing a dynamic link, we create a .rel(a).got relocation
3752 entry to initialize the value. This is done in the
3753 finish_dynamic_symbol routine. */
3758 /* If we are addressing a Thumb function, we need to
3759 adjust the address by one, so that attempts to
3760 call the function pointer will correctly
3761 interpret it as Thumb code. */
3762 if (sym_flags == STT_ARM_TFUNC)
3765 bfd_put_32 (output_bfd, value, sgot->contents + off);
3770 *unresolved_reloc_p = FALSE;
3772 value = sgot->output_offset + off;
3778 BFD_ASSERT (local_got_offsets != NULL &&
3779 local_got_offsets[r_symndx] != (bfd_vma) -1);
3781 off = local_got_offsets[r_symndx];
3783 /* The offset must always be a multiple of 4. We use the
3784 least significant bit to record whether we have already
3785 generated the necessary reloc. */
3790 /* If we are addressing a Thumb function, we need to
3791 adjust the address by one, so that attempts to
3792 call the function pointer will correctly
3793 interpret it as Thumb code. */
3794 if (sym_flags == STT_ARM_TFUNC)
3797 if (globals->use_rel)
3798 bfd_put_32 (output_bfd, value, sgot->contents + off);
3803 Elf_Internal_Rela outrel;
3806 srelgot = (bfd_get_section_by_name
3807 (dynobj, RELOC_SECTION (globals, ".got")));
3808 BFD_ASSERT (srelgot != NULL);
3810 outrel.r_addend = addend + value;
3811 outrel.r_offset = (sgot->output_section->vma
3812 + sgot->output_offset
3814 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
3815 loc = srelgot->contents;
3816 loc += srelgot->reloc_count++ * RELOC_SIZE (globals);
3817 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
3820 local_got_offsets[r_symndx] |= 1;
3823 value = sgot->output_offset + off;
3825 if (r_type != R_ARM_GOT32)
3826 value += sgot->output_section->vma;
3828 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3829 contents, rel->r_offset, value,
3832 case R_ARM_TLS_LDO32:
3833 value = value - dtpoff_base (info);
3835 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3836 contents, rel->r_offset, value,
3839 case R_ARM_TLS_LDM32:
3843 if (globals->sgot == NULL)
3846 off = globals->tls_ldm_got.offset;
3852 /* If we don't know the module number, create a relocation
3856 Elf_Internal_Rela outrel;
3859 if (globals->srelgot == NULL)
3862 outrel.r_addend = 0;
3863 outrel.r_offset = (globals->sgot->output_section->vma
3864 + globals->sgot->output_offset + off);
3865 outrel.r_info = ELF32_R_INFO (0, R_ARM_TLS_DTPMOD32);
3867 if (globals->use_rel)
3868 bfd_put_32 (output_bfd, outrel.r_addend,
3869 globals->sgot->contents + off);
3871 loc = globals->srelgot->contents;
3872 loc += globals->srelgot->reloc_count++ * RELOC_SIZE (globals);
3873 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
3876 bfd_put_32 (output_bfd, 1, globals->sgot->contents + off);
3878 globals->tls_ldm_got.offset |= 1;
3881 value = globals->sgot->output_section->vma + globals->sgot->output_offset + off
3882 - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
3884 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3885 contents, rel->r_offset, value,
3889 case R_ARM_TLS_GD32:
3890 case R_ARM_TLS_IE32:
3896 if (globals->sgot == NULL)
3903 dyn = globals->root.dynamic_sections_created;
3904 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3906 || !SYMBOL_REFERENCES_LOCAL (info, h)))
3908 *unresolved_reloc_p = FALSE;
3911 off = h->got.offset;
3912 tls_type = ((struct elf32_arm_link_hash_entry *) h)->tls_type;
3916 if (local_got_offsets == NULL)
3918 off = local_got_offsets[r_symndx];
3919 tls_type = elf32_arm_local_got_tls_type (input_bfd)[r_symndx];
3922 if (tls_type == GOT_UNKNOWN)
3929 bfd_boolean need_relocs = FALSE;
3930 Elf_Internal_Rela outrel;
3931 bfd_byte *loc = NULL;
3934 /* The GOT entries have not been initialized yet. Do it
3935 now, and emit any relocations. If both an IE GOT and a
3936 GD GOT are necessary, we emit the GD first. */
3938 if ((info->shared || indx != 0)
3940 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3941 || h->root.type != bfd_link_hash_undefweak))
3944 if (globals->srelgot == NULL)
3946 loc = globals->srelgot->contents;
3947 loc += globals->srelgot->reloc_count * RELOC_SIZE (globals);
3950 if (tls_type & GOT_TLS_GD)
3954 outrel.r_addend = 0;
3955 outrel.r_offset = (globals->sgot->output_section->vma
3956 + globals->sgot->output_offset
3958 outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_DTPMOD32);
3960 if (globals->use_rel)
3961 bfd_put_32 (output_bfd, outrel.r_addend,
3962 globals->sgot->contents + cur_off);
3964 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
3965 globals->srelgot->reloc_count++;
3966 loc += RELOC_SIZE (globals);
3969 bfd_put_32 (output_bfd, value - dtpoff_base (info),
3970 globals->sgot->contents + cur_off + 4);
3973 outrel.r_addend = 0;
3974 outrel.r_info = ELF32_R_INFO (indx,
3975 R_ARM_TLS_DTPOFF32);
3976 outrel.r_offset += 4;
3978 if (globals->use_rel)
3979 bfd_put_32 (output_bfd, outrel.r_addend,
3980 globals->sgot->contents + cur_off + 4);
3983 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
3984 globals->srelgot->reloc_count++;
3985 loc += RELOC_SIZE (globals);
3990 /* If we are not emitting relocations for a
3991 general dynamic reference, then we must be in a
3992 static link or an executable link with the
3993 symbol binding locally. Mark it as belonging
3994 to module 1, the executable. */
3995 bfd_put_32 (output_bfd, 1,
3996 globals->sgot->contents + cur_off);
3997 bfd_put_32 (output_bfd, value - dtpoff_base (info),
3998 globals->sgot->contents + cur_off + 4);
4004 if (tls_type & GOT_TLS_IE)
4009 outrel.r_addend = value - dtpoff_base (info);
4011 outrel.r_addend = 0;
4012 outrel.r_offset = (globals->sgot->output_section->vma
4013 + globals->sgot->output_offset
4015 outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_TPOFF32);
4017 if (globals->use_rel)
4018 bfd_put_32 (output_bfd, outrel.r_addend,
4019 globals->sgot->contents + cur_off);
4021 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
4022 globals->srelgot->reloc_count++;
4023 loc += RELOC_SIZE (globals);
4026 bfd_put_32 (output_bfd, tpoff (info, value),
4027 globals->sgot->contents + cur_off);
4034 local_got_offsets[r_symndx] |= 1;
4037 if ((tls_type & GOT_TLS_GD) && r_type != R_ARM_TLS_GD32)
4039 value = globals->sgot->output_section->vma + globals->sgot->output_offset + off
4040 - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
4042 return _bfd_final_link_relocate (howto, input_bfd, input_section,
4043 contents, rel->r_offset, value,
4047 case R_ARM_TLS_LE32:
4050 (*_bfd_error_handler)
4051 (_("%B(%A+0x%lx): R_ARM_TLS_LE32 relocation not permitted in shared object"),
4052 input_bfd, input_section,
4053 (long) rel->r_offset, howto->name);
4057 value = tpoff (info, value);
4059 return _bfd_final_link_relocate (howto, input_bfd, input_section,
4060 contents, rel->r_offset, value,
4064 if (globals->fix_v4bx)
4066 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
4068 /* Ensure that we have a BX instruction. */
4069 BFD_ASSERT ((insn & 0x0ffffff0) == 0x012fff10);
4071 /* Preserve Rm (lowest four bits) and the condition code
4072 (highest four bits). Other bits encode MOV PC,Rm. */
4073 insn = (insn & 0xf000000f) | 0x01a0f000;
4075 bfd_put_32 (input_bfd, insn, hit_data);
4077 return bfd_reloc_ok;
4080 return bfd_reloc_notsupported;
4086 uleb128_size (unsigned int i)
4098 /* Return TRUE if the attribute has the default value (0/""). */
4100 is_default_attr (aeabi_attribute *attr)
4102 if ((attr->type & 1) && attr->i != 0)
4104 if ((attr->type & 2) && attr->s && *attr->s)
4110 /* Return the size of a single attribute. */
4112 eabi_attr_size(int tag, aeabi_attribute *attr)
4116 if (is_default_attr (attr))
4119 size = uleb128_size (tag);
4121 size += uleb128_size (attr->i);
4123 size += strlen ((char *)attr->s) + 1;
4127 /* Returns the size of the eabi object attributess section. */
4129 elf32_arm_eabi_attr_size (bfd *abfd)
4132 aeabi_attribute *attr;
4133 aeabi_attribute_list *list;
4136 attr = elf32_arm_tdata (abfd)->known_eabi_attributes;
4137 size = 16; /* 'A' <size> "aeabi" 0x1 <size>. */
4138 for (i = 4; i < NUM_KNOWN_ATTRIBUTES; i++)
4139 size += eabi_attr_size (i, &attr[i]);
4141 for (list = elf32_arm_tdata (abfd)->other_eabi_attributes;
4144 size += eabi_attr_size (list->tag, &list->attr);
4150 write_uleb128 (bfd_byte *p, unsigned int val)
4165 /* Write attribute ATTR to butter P, and return a pointer to the following
4168 write_eabi_attribute (bfd_byte *p, int tag, aeabi_attribute *attr)
4170 /* Suppress default entries. */
4171 if (is_default_attr(attr))
4174 p = write_uleb128 (p, tag);
4176 p = write_uleb128 (p, attr->i);
4181 len = strlen (attr->s) + 1;
4182 memcpy (p, attr->s, len);
4189 /* Write the contents of the eabi attributes section to p. */
4191 elf32_arm_set_eabi_attr_contents (bfd *abfd, bfd_byte *contents, bfd_vma size)
4194 aeabi_attribute *attr;
4195 aeabi_attribute_list *list;
4200 bfd_put_32 (abfd, size - 1, p);
4202 memcpy (p, "aeabi", 6);
4205 bfd_put_32 (abfd, size - 11, p);
4208 attr = elf32_arm_tdata (abfd)->known_eabi_attributes;
4209 for (i = 4; i < NUM_KNOWN_ATTRIBUTES; i++)
4210 p = write_eabi_attribute (p, i, &attr[i]);
4212 for (list = elf32_arm_tdata (abfd)->other_eabi_attributes;
4215 p = write_eabi_attribute (p, list->tag, &list->attr);
4218 /* Override final_link to handle EABI object attribute sections. */
4221 elf32_arm_bfd_final_link (bfd *abfd, struct bfd_link_info *info)
4224 struct bfd_link_order *p;
4225 asection *attr_section = NULL;
4229 /* elf32_arm_merge_private_bfd_data will already have merged the
4230 object attributes. Remove the input sections from the link, and set
4231 the contents of the output secton. */
4232 for (o = abfd->sections; o != NULL; o = o->next)
4234 if (strcmp (o->name, ".ARM.attributes") == 0)
4236 for (p = o->map_head.link_order; p != NULL; p = p->next)
4238 asection *input_section;
4240 if (p->type != bfd_indirect_link_order)
4242 input_section = p->u.indirect.section;
4243 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4244 elf_link_input_bfd ignores this section. */
4245 input_section->flags &= ~SEC_HAS_CONTENTS;
4248 size = elf32_arm_eabi_attr_size (abfd);
4249 bfd_set_section_size (abfd, o, size);
4251 /* Skip this section later on. */
4252 o->map_head.link_order = NULL;
4255 /* Invoke the ELF linker to do all the work. */
4256 if (!bfd_elf_final_link (abfd, info))
4261 contents = bfd_malloc(size);
4262 if (contents == NULL)
4264 elf32_arm_set_eabi_attr_contents (abfd, contents, size);
4265 bfd_set_section_contents (abfd, attr_section, contents, 0, size);
4272 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
4274 arm_add_to_rel (bfd * abfd,
4276 reloc_howto_type * howto,
4277 bfd_signed_vma increment)
4279 bfd_signed_vma addend;
4281 if (howto->type == R_ARM_THM_CALL)
4283 int upper_insn, lower_insn;
4286 upper_insn = bfd_get_16 (abfd, address);
4287 lower_insn = bfd_get_16 (abfd, address + 2);
4288 upper = upper_insn & 0x7ff;
4289 lower = lower_insn & 0x7ff;
4291 addend = (upper << 12) | (lower << 1);
4292 addend += increment;
4295 upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
4296 lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
4298 bfd_put_16 (abfd, (bfd_vma) upper_insn, address);
4299 bfd_put_16 (abfd, (bfd_vma) lower_insn, address + 2);
4305 contents = bfd_get_32 (abfd, address);
4307 /* Get the (signed) value from the instruction. */
4308 addend = contents & howto->src_mask;
4309 if (addend & ((howto->src_mask + 1) >> 1))
4311 bfd_signed_vma mask;
4314 mask &= ~ howto->src_mask;
4318 /* Add in the increment, (which is a byte value). */
4319 switch (howto->type)
4322 addend += increment;
4329 addend <<= howto->size;
4330 addend += increment;
4332 /* Should we check for overflow here ? */
4334 /* Drop any undesired bits. */
4335 addend >>= howto->rightshift;
4339 contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
4341 bfd_put_32 (abfd, contents, address);
4345 #define IS_ARM_TLS_RELOC(R_TYPE) \
4346 ((R_TYPE) == R_ARM_TLS_GD32 \
4347 || (R_TYPE) == R_ARM_TLS_LDO32 \
4348 || (R_TYPE) == R_ARM_TLS_LDM32 \
4349 || (R_TYPE) == R_ARM_TLS_DTPOFF32 \
4350 || (R_TYPE) == R_ARM_TLS_DTPMOD32 \
4351 || (R_TYPE) == R_ARM_TLS_TPOFF32 \
4352 || (R_TYPE) == R_ARM_TLS_LE32 \
4353 || (R_TYPE) == R_ARM_TLS_IE32)
4355 /* Relocate an ARM ELF section. */
4357 elf32_arm_relocate_section (bfd * output_bfd,
4358 struct bfd_link_info * info,
4360 asection * input_section,
4361 bfd_byte * contents,
4362 Elf_Internal_Rela * relocs,
4363 Elf_Internal_Sym * local_syms,
4364 asection ** local_sections)
4366 Elf_Internal_Shdr *symtab_hdr;
4367 struct elf_link_hash_entry **sym_hashes;
4368 Elf_Internal_Rela *rel;
4369 Elf_Internal_Rela *relend;
4371 struct elf32_arm_link_hash_table * globals;
4373 globals = elf32_arm_hash_table (info);
4374 if (info->relocatable && !globals->use_rel)
4377 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
4378 sym_hashes = elf_sym_hashes (input_bfd);
4381 relend = relocs + input_section->reloc_count;
4382 for (; rel < relend; rel++)
4385 reloc_howto_type * howto;
4386 unsigned long r_symndx;
4387 Elf_Internal_Sym * sym;
4389 struct elf_link_hash_entry * h;
4391 bfd_reloc_status_type r;
4394 bfd_boolean unresolved_reloc = FALSE;
4396 r_symndx = ELF32_R_SYM (rel->r_info);
4397 r_type = ELF32_R_TYPE (rel->r_info);
4398 r_type = arm_real_reloc_type (globals, r_type);
4400 if ( r_type == R_ARM_GNU_VTENTRY
4401 || r_type == R_ARM_GNU_VTINHERIT)
4404 bfd_reloc.howto = elf32_arm_howto_from_type (r_type);
4405 howto = bfd_reloc.howto;
4407 if (info->relocatable && globals->use_rel)
4409 /* This is a relocatable link. We don't have to change
4410 anything, unless the reloc is against a section symbol,
4411 in which case we have to adjust according to where the
4412 section symbol winds up in the output section. */
4413 if (r_symndx < symtab_hdr->sh_info)
4415 sym = local_syms + r_symndx;
4416 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4418 sec = local_sections[r_symndx];
4419 arm_add_to_rel (input_bfd, contents + rel->r_offset,
4421 (bfd_signed_vma) (sec->output_offset
4429 /* This is a final link. */
4434 if (r_symndx < symtab_hdr->sh_info)
4436 sym = local_syms + r_symndx;
4437 sym_type = ELF32_ST_TYPE (sym->st_info);
4438 sec = local_sections[r_symndx];
4439 if (globals->use_rel)
4441 relocation = (sec->output_section->vma
4442 + sec->output_offset
4444 if ((sec->flags & SEC_MERGE)
4445 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4448 bfd_vma addend, value;
4450 if (howto->rightshift)
4452 (*_bfd_error_handler)
4453 (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
4454 input_bfd, input_section,
4455 (long) rel->r_offset, howto->name);
4459 value = bfd_get_32 (input_bfd, contents + rel->r_offset);
4461 /* Get the (signed) value from the instruction. */
4462 addend = value & howto->src_mask;
4463 if (addend & ((howto->src_mask + 1) >> 1))
4465 bfd_signed_vma mask;
4468 mask &= ~ howto->src_mask;
4473 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
4475 addend += msec->output_section->vma + msec->output_offset;
4476 value = (value & ~ howto->dst_mask) | (addend & howto->dst_mask);
4477 bfd_put_32 (input_bfd, value, contents + rel->r_offset);
4481 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
4487 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4488 r_symndx, symtab_hdr, sym_hashes,
4490 unresolved_reloc, warned);
4496 name = h->root.root.string;
4499 name = (bfd_elf_string_from_elf_section
4500 (input_bfd, symtab_hdr->sh_link, sym->st_name));
4501 if (name == NULL || *name == '\0')
4502 name = bfd_section_name (input_bfd, sec);
4506 && r_type != R_ARM_NONE
4508 || h->root.type == bfd_link_hash_defined
4509 || h->root.type == bfd_link_hash_defweak)
4510 && IS_ARM_TLS_RELOC (r_type) != (sym_type == STT_TLS))
4512 (*_bfd_error_handler)
4513 ((sym_type == STT_TLS
4514 ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
4515 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
4518 (long) rel->r_offset,
4523 r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
4524 input_section, contents, rel,
4525 relocation, info, sec, name,
4526 (h ? ELF_ST_TYPE (h->type) :
4527 ELF_ST_TYPE (sym->st_info)), h,
4530 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4531 because such sections are not SEC_ALLOC and thus ld.so will
4532 not process them. */
4533 if (unresolved_reloc
4534 && !((input_section->flags & SEC_DEBUGGING) != 0
4537 (*_bfd_error_handler)
4538 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4541 (long) rel->r_offset,
4543 h->root.root.string);
4547 if (r != bfd_reloc_ok)
4549 const char * msg = (const char *) 0;
4553 case bfd_reloc_overflow:
4554 /* If the overflowing reloc was to an undefined symbol,
4555 we have already printed one error message and there
4556 is no point complaining again. */
4558 h->root.type != bfd_link_hash_undefined)
4559 && (!((*info->callbacks->reloc_overflow)
4560 (info, (h ? &h->root : NULL), name, howto->name,
4561 (bfd_vma) 0, input_bfd, input_section,
4566 case bfd_reloc_undefined:
4567 if (!((*info->callbacks->undefined_symbol)
4568 (info, name, input_bfd, input_section,
4569 rel->r_offset, TRUE)))
4573 case bfd_reloc_outofrange:
4574 msg = _("internal error: out of range error");
4577 case bfd_reloc_notsupported:
4578 msg = _("internal error: unsupported relocation error");
4581 case bfd_reloc_dangerous:
4582 msg = _("internal error: dangerous error");
4586 msg = _("internal error: unknown error");
4590 if (!((*info->callbacks->warning)
4591 (info, msg, name, input_bfd, input_section,
4602 /* Allocate/find an object attribute. */
4603 static aeabi_attribute *
4604 elf32_arm_new_eabi_attr (bfd *abfd, int tag)
4606 aeabi_attribute *attr;
4607 aeabi_attribute_list *list;
4608 aeabi_attribute_list *p;
4609 aeabi_attribute_list **lastp;
4612 if (tag < NUM_KNOWN_ATTRIBUTES)
4614 /* Knwon tags are preallocated. */
4615 attr = &elf32_arm_tdata (abfd)->known_eabi_attributes[tag];
4619 /* Create a new tag. */
4620 list = (aeabi_attribute_list *)
4621 bfd_alloc (abfd, sizeof (aeabi_attribute_list));
4622 memset (list, 0, sizeof (aeabi_attribute_list));
4624 /* Keep the tag list in order. */
4625 lastp = &elf32_arm_tdata (abfd)->other_eabi_attributes;
4626 for (p = *lastp; p; p = p->next)
4632 list->next = *lastp;
4641 elf32_arm_get_eabi_attr_int (bfd *abfd, int tag)
4643 aeabi_attribute_list *p;
4645 if (tag < NUM_KNOWN_ATTRIBUTES)
4647 /* Knwon tags are preallocated. */
4648 return elf32_arm_tdata (abfd)->known_eabi_attributes[tag].i;
4652 for (p = elf32_arm_tdata (abfd)->other_eabi_attributes;
4666 elf32_arm_add_eabi_attr_int (bfd *abfd, int tag, unsigned int i)
4668 aeabi_attribute *attr;
4670 attr = elf32_arm_new_eabi_attr (abfd, tag);
4676 attr_strdup (bfd *abfd, const char * s)
4681 len = strlen (s) + 1;
4682 p = (char *)bfd_alloc(abfd, len);
4683 return memcpy (p, s, len);
4687 elf32_arm_add_eabi_attr_string (bfd *abfd, int tag, const char *s)
4689 aeabi_attribute *attr;
4691 attr = elf32_arm_new_eabi_attr (abfd, tag);
4693 attr->s = attr_strdup (abfd, s);
4697 elf32_arm_add_eabi_attr_compat (bfd *abfd, unsigned int i, const char *s)
4699 aeabi_attribute_list *list;
4700 aeabi_attribute_list *p;
4701 aeabi_attribute_list **lastp;
4703 list = (aeabi_attribute_list *)
4704 bfd_alloc (abfd, sizeof (aeabi_attribute_list));
4705 memset (list, 0, sizeof (aeabi_attribute_list));
4706 list->tag = Tag_compatibility;
4707 list->attr.type = 3;
4709 list->attr.s = attr_strdup (abfd, s);
4711 lastp = &elf32_arm_tdata (abfd)->other_eabi_attributes;
4712 for (p = *lastp; p; p = p->next)
4715 if (p->tag != Tag_compatibility)
4717 cmp = strcmp(s, p->attr.s);
4718 if (cmp < 0 || (cmp == 0 && i < p->attr.i))
4722 list->next = *lastp;
4726 /* Set the right machine number. */
4729 elf32_arm_object_p (bfd *abfd)
4733 mach = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
4735 if (mach != bfd_mach_arm_unknown)
4736 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
4738 else if (elf_elfheader (abfd)->e_flags & EF_ARM_MAVERICK_FLOAT)
4739 bfd_default_set_arch_mach (abfd, bfd_arch_arm, bfd_mach_arm_ep9312);
4742 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
4747 /* Function to keep ARM specific flags in the ELF header. */
4750 elf32_arm_set_private_flags (bfd *abfd, flagword flags)
4752 if (elf_flags_init (abfd)
4753 && elf_elfheader (abfd)->e_flags != flags)
4755 if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
4757 if (flags & EF_ARM_INTERWORK)
4758 (*_bfd_error_handler)
4759 (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
4763 (_("Warning: Clearing the interworking flag of %B due to outside request"),
4769 elf_elfheader (abfd)->e_flags = flags;
4770 elf_flags_init (abfd) = TRUE;
4776 /* Copy the eabi object attribute from IBFD to OBFD. */
4778 copy_eabi_attributes (bfd *ibfd, bfd *obfd)
4780 aeabi_attribute *in_attr;
4781 aeabi_attribute *out_attr;
4782 aeabi_attribute_list *list;
4785 in_attr = elf32_arm_tdata (ibfd)->known_eabi_attributes;
4786 out_attr = elf32_arm_tdata (obfd)->known_eabi_attributes;
4787 for (i = 4; i < NUM_KNOWN_ATTRIBUTES; i++)
4789 out_attr->i = in_attr->i;
4790 if (in_attr->s && *in_attr->s)
4791 out_attr->s = attr_strdup (obfd, in_attr->s);
4796 for (list = elf32_arm_tdata (ibfd)->other_eabi_attributes;
4800 in_attr = &list->attr;
4801 switch (in_attr->type)
4804 elf32_arm_add_eabi_attr_int (obfd, list->tag, in_attr->i);
4807 elf32_arm_add_eabi_attr_string (obfd, list->tag, in_attr->s);
4810 elf32_arm_add_eabi_attr_compat (obfd, in_attr->i, in_attr->s);
4819 /* Copy backend specific data from one object module to another. */
4822 elf32_arm_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
4827 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4828 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4831 in_flags = elf_elfheader (ibfd)->e_flags;
4832 out_flags = elf_elfheader (obfd)->e_flags;
4834 if (elf_flags_init (obfd)
4835 && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
4836 && in_flags != out_flags)
4838 /* Cannot mix APCS26 and APCS32 code. */
4839 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
4842 /* Cannot mix float APCS and non-float APCS code. */
4843 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
4846 /* If the src and dest have different interworking flags
4847 then turn off the interworking bit. */
4848 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
4850 if (out_flags & EF_ARM_INTERWORK)
4852 (_("Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
4855 in_flags &= ~EF_ARM_INTERWORK;
4858 /* Likewise for PIC, though don't warn for this case. */
4859 if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC))
4860 in_flags &= ~EF_ARM_PIC;
4863 elf_elfheader (obfd)->e_flags = in_flags;
4864 elf_flags_init (obfd) = TRUE;
4866 /* Also copy the EI_OSABI field. */
4867 elf_elfheader (obfd)->e_ident[EI_OSABI] =
4868 elf_elfheader (ibfd)->e_ident[EI_OSABI];
4870 /* Copy EABI object attributes. */
4871 copy_eabi_attributes (ibfd, obfd);
4876 /* Values for Tag_ABI_PCS_R9_use. */
4885 /* Values for Tag_ABI_PCS_RW_data. */
4888 AEABI_PCS_RW_data_absolute,
4889 AEABI_PCS_RW_data_PCrel,
4890 AEABI_PCS_RW_data_SBrel,
4891 AEABI_PCS_RW_data_unused
4894 /* Values for Tag_ABI_enum_size. */
4900 AEABI_enum_forced_wide
4903 /* Merge EABI object attributes from IBFD into OBFD. Raise an error if there
4904 are conflicting attributes. */
4906 elf32_arm_merge_eabi_attributes (bfd *ibfd, bfd *obfd)
4908 aeabi_attribute *in_attr;
4909 aeabi_attribute *out_attr;
4910 aeabi_attribute_list *in_list;
4911 aeabi_attribute_list *out_list;
4912 /* Some tags have 0 = don't care, 1 = strong requirement,
4913 2 = weak requirement. */
4914 static const int order_312[3] = {3, 1, 2};
4917 if (!elf32_arm_tdata (ibfd)->known_eabi_attributes[0].i)
4919 /* This is the first object. Copy the attributes. */
4920 copy_eabi_attributes (ibfd, obfd);
4924 /* Use the Tag_null value to indicate the attributes have been
4926 elf32_arm_tdata (ibfd)->known_eabi_attributes[0].i = 1;
4928 in_attr = elf32_arm_tdata (ibfd)->known_eabi_attributes;
4929 out_attr = elf32_arm_tdata (obfd)->known_eabi_attributes;
4930 /* This needs to happen before Tag_ABI_FP_number_model is merged. */
4931 if (in_attr[Tag_ABI_VFP_args].i != out_attr[Tag_ABI_VFP_args].i)
4933 /* Ignore mismatches if teh object doesn't use floating point. */
4934 if (out_attr[Tag_ABI_FP_number_model].i == 0)
4935 out_attr[Tag_ABI_VFP_args].i = in_attr[Tag_ABI_VFP_args].i;
4936 else if (in_attr[Tag_ABI_FP_number_model].i != 0)
4939 (_("ERROR: %B uses VFP register arguments, %B does not"),
4945 for (i = 4; i < NUM_KNOWN_ATTRIBUTES; i++)
4947 /* Merge this attribute with existing attributes. */
4950 case Tag_CPU_raw_name:
4952 /* Use whichever has the greatest architecture requirements. */
4953 if (in_attr[Tag_CPU_arch].i > out_attr[Tag_CPU_arch].i)
4954 out_attr[i].s = attr_strdup(obfd, in_attr[i].s);
4957 case Tag_ABI_optimization_goals:
4958 case Tag_ABI_FP_optimization_goals:
4959 /* Use the first value seen. */
4963 case Tag_ARM_ISA_use:
4964 case Tag_THUMB_ISA_use:
4968 /* ??? Do NEON and WMMX conflict? */
4969 case Tag_ABI_FP_rounding:
4970 case Tag_ABI_FP_denormal:
4971 case Tag_ABI_FP_exceptions:
4972 case Tag_ABI_FP_user_exceptions:
4973 case Tag_ABI_FP_number_model:
4974 case Tag_ABI_align8_preserved:
4975 case Tag_ABI_HardFP_use:
4976 /* Use the largest value specified. */
4977 if (in_attr[i].i > out_attr[i].i)
4978 out_attr[i].i = in_attr[i].i;
4981 case Tag_CPU_arch_profile:
4982 /* Warn if conflicting architecture profiles used. */
4983 if (out_attr[i].i && in_attr[i].i && in_attr[i].i != out_attr[i].i)
4986 (_("ERROR: %B: Conflicting architecture profiles %c/%c"),
4987 ibfd, in_attr[i].i, out_attr[i].i);
4991 out_attr[i].i = in_attr[i].i;
4993 case Tag_PCS_config:
4994 if (out_attr[i].i == 0)
4995 out_attr[i].i = in_attr[i].i;
4996 else if (in_attr[i].i != 0 && out_attr[i].i != 0)
4998 /* It's sometimes ok to mix different configs, so this is only
5001 (_("Warning: %B: Conflicting platform configuration"), ibfd);
5004 case Tag_ABI_PCS_R9_use:
5005 if (out_attr[i].i != AEABI_R9_unused
5006 && in_attr[i].i != AEABI_R9_unused)
5009 (_("ERROR: %B: Conflicting use of R9"), ibfd);
5012 if (out_attr[i].i == AEABI_R9_unused)
5013 out_attr[i].i = in_attr[i].i;
5015 case Tag_ABI_PCS_RW_data:
5016 if (in_attr[i].i == AEABI_PCS_RW_data_SBrel
5017 && out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_SB
5018 && out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_unused)
5021 (_("ERROR: %B: SB relative addressing conflicts with use of R9"),
5025 /* Use the smallest value specified. */
5026 if (in_attr[i].i < out_attr[i].i)
5027 out_attr[i].i = in_attr[i].i;
5029 case Tag_ABI_PCS_RO_data:
5030 /* Use the smallest value specified. */
5031 if (in_attr[i].i < out_attr[i].i)
5032 out_attr[i].i = in_attr[i].i;
5034 case Tag_ABI_PCS_GOT_use:
5035 if (in_attr[i].i > 2 || out_attr[i].i > 2
5036 || order_312[in_attr[i].i] < order_312[out_attr[i].i])
5037 out_attr[i].i = in_attr[i].i;
5039 case Tag_ABI_PCS_wchar_t:
5040 if (out_attr[i].i && in_attr[i].i && out_attr[i].i != in_attr[i].i)
5043 (_("ERROR: %B: Conflicting definitions of wchar_t"), ibfd);
5047 out_attr[i].i = in_attr[i].i;
5049 case Tag_ABI_align8_needed:
5050 /* ??? Check against Tag_ABI_align8_preserved. */
5051 if (in_attr[i].i > 2 || out_attr[i].i > 2
5052 || order_312[in_attr[i].i] < order_312[out_attr[i].i])
5053 out_attr[i].i = in_attr[i].i;
5055 case Tag_ABI_enum_size:
5056 if (in_attr[i].i != AEABI_enum_unused)
5058 if (out_attr[i].i == AEABI_enum_unused
5059 || out_attr[i].i == AEABI_enum_forced_wide)
5061 /* The existing object is compatible with anything.
5062 Use whatever requirements the new object has. */
5063 out_attr[i].i = in_attr[i].i;
5065 else if (in_attr[i].i != AEABI_enum_forced_wide
5066 && out_attr[i].i != in_attr[i].i)
5069 (_("ERROR: %B: Conflicting enum sizes"), ibfd);
5073 case Tag_ABI_VFP_args:
5076 case Tag_ABI_WMMX_args:
5077 if (in_attr[i].i != out_attr[i].i)
5080 (_("ERROR: %B uses iWMMXt register arguments, %B does not"),
5085 default: /* All known attributes should be explicitly covered. */
5090 in_list = elf32_arm_tdata (ibfd)->other_eabi_attributes;
5091 out_list = elf32_arm_tdata (ibfd)->other_eabi_attributes;
5092 while (in_list && in_list->tag == Tag_compatibility)
5094 in_attr = &in_list->attr;
5095 if (in_attr->i == 0)
5097 if (in_attr->i == 1)
5100 (_("ERROR: %B: Must be processed by '%s' toolchain"),
5104 if (!out_list || out_list->tag != Tag_compatibility
5105 || strcmp (in_attr->s, out_list->attr.s) != 0)
5107 /* Add this compatibility tag to the output. */
5108 elf32_arm_add_eabi_attr_compat (obfd, in_attr->i, in_attr->s);
5111 out_attr = &out_list->attr;
5112 /* Check all the input tags with the same identifier. */
5115 if (out_list->tag != Tag_compatibility
5116 || in_attr->i != out_attr->i
5117 || strcmp (in_attr->s, out_attr->s) != 0)
5120 (_("ERROR: %B: Incompatible object tag '%s':%d"),
5121 ibfd, in_attr->s, in_attr->i);
5124 in_list = in_list->next;
5125 if (in_list->tag != Tag_compatibility
5126 || strcmp (in_attr->s, in_list->attr.s) != 0)
5128 in_attr = &in_list->attr;
5129 out_list = out_list->next;
5131 out_attr = &out_list->attr;
5134 /* Check the output doesn't have extra tags with this identifier. */
5135 if (out_list && out_list->tag == Tag_compatibility
5136 && strcmp (in_attr->s, out_list->attr.s) == 0)
5139 (_("ERROR: %B: Incompatible object tag '%s':%d"),
5140 ibfd, in_attr->s, out_list->attr.i);
5145 for (; in_list; in_list = in_list->next)
5147 if ((in_list->tag & 128) < 64)
5149 (_("Warning: %B: Unknown EABI object attribute %d"),
5150 ibfd, in_list->tag);
5156 /* Merge backend specific data from an object file to the output
5157 object file when linking. */
5160 elf32_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
5164 bfd_boolean flags_compatible = TRUE;
5167 /* Check if we have the same endianess. */
5168 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
5171 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5172 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5175 if (!elf32_arm_merge_eabi_attributes (ibfd, obfd))
5178 /* The input BFD must have had its flags initialised. */
5179 /* The following seems bogus to me -- The flags are initialized in
5180 the assembler but I don't think an elf_flags_init field is
5181 written into the object. */
5182 /* BFD_ASSERT (elf_flags_init (ibfd)); */
5184 in_flags = elf_elfheader (ibfd)->e_flags;
5185 out_flags = elf_elfheader (obfd)->e_flags;
5187 if (!elf_flags_init (obfd))
5189 /* If the input is the default architecture and had the default
5190 flags then do not bother setting the flags for the output
5191 architecture, instead allow future merges to do this. If no
5192 future merges ever set these flags then they will retain their
5193 uninitialised values, which surprise surprise, correspond
5194 to the default values. */
5195 if (bfd_get_arch_info (ibfd)->the_default
5196 && elf_elfheader (ibfd)->e_flags == 0)
5199 elf_flags_init (obfd) = TRUE;
5200 elf_elfheader (obfd)->e_flags = in_flags;
5202 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
5203 && bfd_get_arch_info (obfd)->the_default)
5204 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
5209 /* Determine what should happen if the input ARM architecture
5210 does not match the output ARM architecture. */
5211 if (! bfd_arm_merge_machines (ibfd, obfd))
5214 /* Identical flags must be compatible. */
5215 if (in_flags == out_flags)
5218 /* Check to see if the input BFD actually contains any sections. If
5219 not, its flags may not have been initialised either, but it
5220 cannot actually cause any incompatiblity. Do not short-circuit
5221 dynamic objects; their section list may be emptied by
5222 elf_link_add_object_symbols.
5224 Also check to see if there are no code sections in the input.
5225 In this case there is no need to check for code specific flags.
5226 XXX - do we need to worry about floating-point format compatability
5227 in data sections ? */
5228 if (!(ibfd->flags & DYNAMIC))
5230 bfd_boolean null_input_bfd = TRUE;
5231 bfd_boolean only_data_sections = TRUE;
5233 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
5235 /* Ignore synthetic glue sections. */
5236 if (strcmp (sec->name, ".glue_7")
5237 && strcmp (sec->name, ".glue_7t"))
5239 if ((bfd_get_section_flags (ibfd, sec)
5240 & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
5241 == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
5242 only_data_sections = FALSE;
5244 null_input_bfd = FALSE;
5249 if (null_input_bfd || only_data_sections)
5253 /* Complain about various flag mismatches. */
5254 if (EF_ARM_EABI_VERSION (in_flags) != EF_ARM_EABI_VERSION (out_flags))
5257 (_("ERROR: Source object %B has EABI version %d, but target %B has EABI version %d"),
5259 (in_flags & EF_ARM_EABIMASK) >> 24,
5260 (out_flags & EF_ARM_EABIMASK) >> 24);
5264 /* Not sure what needs to be checked for EABI versions >= 1. */
5265 /* VxWorks libraries do not use these flags. */
5266 if (get_elf_backend_data (obfd) != &elf32_arm_vxworks_bed
5267 && get_elf_backend_data (ibfd) != &elf32_arm_vxworks_bed
5268 && EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
5270 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
5273 (_("ERROR: %B is compiled for APCS-%d, whereas target %B uses APCS-%d"),
5275 in_flags & EF_ARM_APCS_26 ? 26 : 32,
5276 out_flags & EF_ARM_APCS_26 ? 26 : 32);
5277 flags_compatible = FALSE;
5280 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
5282 if (in_flags & EF_ARM_APCS_FLOAT)
5284 (_("ERROR: %B passes floats in float registers, whereas %B passes them in integer registers"),
5288 (_("ERROR: %B passes floats in integer registers, whereas %B passes them in float registers"),
5291 flags_compatible = FALSE;
5294 if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT))
5296 if (in_flags & EF_ARM_VFP_FLOAT)
5298 (_("ERROR: %B uses VFP instructions, whereas %B does not"),
5302 (_("ERROR: %B uses FPA instructions, whereas %B does not"),
5305 flags_compatible = FALSE;
5308 if ((in_flags & EF_ARM_MAVERICK_FLOAT) != (out_flags & EF_ARM_MAVERICK_FLOAT))
5310 if (in_flags & EF_ARM_MAVERICK_FLOAT)
5312 (_("ERROR: %B uses Maverick instructions, whereas %B does not"),
5316 (_("ERROR: %B does not use Maverick instructions, whereas %B does"),
5319 flags_compatible = FALSE;
5322 #ifdef EF_ARM_SOFT_FLOAT
5323 if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
5325 /* We can allow interworking between code that is VFP format
5326 layout, and uses either soft float or integer regs for
5327 passing floating point arguments and results. We already
5328 know that the APCS_FLOAT flags match; similarly for VFP
5330 if ((in_flags & EF_ARM_APCS_FLOAT) != 0
5331 || (in_flags & EF_ARM_VFP_FLOAT) == 0)
5333 if (in_flags & EF_ARM_SOFT_FLOAT)
5335 (_("ERROR: %B uses software FP, whereas %B uses hardware FP"),
5339 (_("ERROR: %B uses hardware FP, whereas %B uses software FP"),
5342 flags_compatible = FALSE;
5347 /* Interworking mismatch is only a warning. */
5348 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
5350 if (in_flags & EF_ARM_INTERWORK)
5353 (_("Warning: %B supports interworking, whereas %B does not"),
5359 (_("Warning: %B does not support interworking, whereas %B does"),
5365 return flags_compatible;
5368 /* Display the flags field. */
5371 elf32_arm_print_private_bfd_data (bfd *abfd, void * ptr)
5373 FILE * file = (FILE *) ptr;
5374 unsigned long flags;
5376 BFD_ASSERT (abfd != NULL && ptr != NULL);
5378 /* Print normal ELF private data. */
5379 _bfd_elf_print_private_bfd_data (abfd, ptr);
5381 flags = elf_elfheader (abfd)->e_flags;
5382 /* Ignore init flag - it may not be set, despite the flags field
5383 containing valid data. */
5385 /* xgettext:c-format */
5386 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
5388 switch (EF_ARM_EABI_VERSION (flags))
5390 case EF_ARM_EABI_UNKNOWN:
5391 /* The following flag bits are GNU extensions and not part of the
5392 official ARM ELF extended ABI. Hence they are only decoded if
5393 the EABI version is not set. */
5394 if (flags & EF_ARM_INTERWORK)
5395 fprintf (file, _(" [interworking enabled]"));
5397 if (flags & EF_ARM_APCS_26)
5398 fprintf (file, " [APCS-26]");
5400 fprintf (file, " [APCS-32]");
5402 if (flags & EF_ARM_VFP_FLOAT)
5403 fprintf (file, _(" [VFP float format]"));
5404 else if (flags & EF_ARM_MAVERICK_FLOAT)
5405 fprintf (file, _(" [Maverick float format]"));
5407 fprintf (file, _(" [FPA float format]"));
5409 if (flags & EF_ARM_APCS_FLOAT)
5410 fprintf (file, _(" [floats passed in float registers]"));
5412 if (flags & EF_ARM_PIC)
5413 fprintf (file, _(" [position independent]"));
5415 if (flags & EF_ARM_NEW_ABI)
5416 fprintf (file, _(" [new ABI]"));
5418 if (flags & EF_ARM_OLD_ABI)
5419 fprintf (file, _(" [old ABI]"));
5421 if (flags & EF_ARM_SOFT_FLOAT)
5422 fprintf (file, _(" [software FP]"));
5424 flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT
5425 | EF_ARM_PIC | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI
5426 | EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT
5427 | EF_ARM_MAVERICK_FLOAT);
5430 case EF_ARM_EABI_VER1:
5431 fprintf (file, _(" [Version1 EABI]"));
5433 if (flags & EF_ARM_SYMSARESORTED)
5434 fprintf (file, _(" [sorted symbol table]"));
5436 fprintf (file, _(" [unsorted symbol table]"));
5438 flags &= ~ EF_ARM_SYMSARESORTED;
5441 case EF_ARM_EABI_VER2:
5442 fprintf (file, _(" [Version2 EABI]"));
5444 if (flags & EF_ARM_SYMSARESORTED)
5445 fprintf (file, _(" [sorted symbol table]"));
5447 fprintf (file, _(" [unsorted symbol table]"));
5449 if (flags & EF_ARM_DYNSYMSUSESEGIDX)
5450 fprintf (file, _(" [dynamic symbols use segment index]"));
5452 if (flags & EF_ARM_MAPSYMSFIRST)
5453 fprintf (file, _(" [mapping symbols precede others]"));
5455 flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX
5456 | EF_ARM_MAPSYMSFIRST);
5459 case EF_ARM_EABI_VER3:
5460 fprintf (file, _(" [Version3 EABI]"));
5463 case EF_ARM_EABI_VER4:
5464 fprintf (file, _(" [Version4 EABI]"));
5466 if (flags & EF_ARM_BE8)
5467 fprintf (file, _(" [BE8]"));
5469 if (flags & EF_ARM_LE8)
5470 fprintf (file, _(" [LE8]"));
5472 flags &= ~(EF_ARM_LE8 | EF_ARM_BE8);
5476 fprintf (file, _(" <EABI version unrecognised>"));
5480 flags &= ~ EF_ARM_EABIMASK;
5482 if (flags & EF_ARM_RELEXEC)
5483 fprintf (file, _(" [relocatable executable]"));
5485 if (flags & EF_ARM_HASENTRY)
5486 fprintf (file, _(" [has entry point]"));
5488 flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
5491 fprintf (file, _("<Unrecognised flag bits set>"));
5499 elf32_arm_get_symbol_type (Elf_Internal_Sym * elf_sym, int type)
5501 switch (ELF_ST_TYPE (elf_sym->st_info))
5504 return ELF_ST_TYPE (elf_sym->st_info);
5507 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
5508 This allows us to distinguish between data used by Thumb instructions
5509 and non-data (which is probably code) inside Thumb regions of an
5511 if (type != STT_OBJECT && type != STT_TLS)
5512 return ELF_ST_TYPE (elf_sym->st_info);
5523 elf32_arm_gc_mark_hook (asection * sec,
5524 struct bfd_link_info * info ATTRIBUTE_UNUSED,
5525 Elf_Internal_Rela * rel,
5526 struct elf_link_hash_entry * h,
5527 Elf_Internal_Sym * sym)
5531 switch (ELF32_R_TYPE (rel->r_info))
5533 case R_ARM_GNU_VTINHERIT:
5534 case R_ARM_GNU_VTENTRY:
5538 switch (h->root.type)
5540 case bfd_link_hash_defined:
5541 case bfd_link_hash_defweak:
5542 return h->root.u.def.section;
5544 case bfd_link_hash_common:
5545 return h->root.u.c.p->section;
5553 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5558 /* Update the got entry reference counts for the section being removed. */
5561 elf32_arm_gc_sweep_hook (bfd * abfd,
5562 struct bfd_link_info * info,
5564 const Elf_Internal_Rela * relocs)
5566 Elf_Internal_Shdr *symtab_hdr;
5567 struct elf_link_hash_entry **sym_hashes;
5568 bfd_signed_vma *local_got_refcounts;
5569 const Elf_Internal_Rela *rel, *relend;
5570 struct elf32_arm_link_hash_table * globals;
5572 globals = elf32_arm_hash_table (info);
5574 elf_section_data (sec)->local_dynrel = NULL;
5576 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5577 sym_hashes = elf_sym_hashes (abfd);
5578 local_got_refcounts = elf_local_got_refcounts (abfd);
5580 relend = relocs + sec->reloc_count;
5581 for (rel = relocs; rel < relend; rel++)
5583 unsigned long r_symndx;
5584 struct elf_link_hash_entry *h = NULL;
5587 r_symndx = ELF32_R_SYM (rel->r_info);
5588 if (r_symndx >= symtab_hdr->sh_info)
5590 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5591 while (h->root.type == bfd_link_hash_indirect
5592 || h->root.type == bfd_link_hash_warning)
5593 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5596 r_type = ELF32_R_TYPE (rel->r_info);
5597 r_type = arm_real_reloc_type (globals, r_type);
5601 case R_ARM_GOT_PREL:
5602 case R_ARM_TLS_GD32:
5603 case R_ARM_TLS_IE32:
5606 if (h->got.refcount > 0)
5607 h->got.refcount -= 1;
5609 else if (local_got_refcounts != NULL)
5611 if (local_got_refcounts[r_symndx] > 0)
5612 local_got_refcounts[r_symndx] -= 1;
5616 case R_ARM_TLS_LDM32:
5617 elf32_arm_hash_table (info)->tls_ldm_got.refcount -= 1;
5627 case R_ARM_THM_CALL:
5628 /* Should the interworking branches be here also? */
5632 struct elf32_arm_link_hash_entry *eh;
5633 struct elf32_arm_relocs_copied **pp;
5634 struct elf32_arm_relocs_copied *p;
5636 eh = (struct elf32_arm_link_hash_entry *) h;
5638 if (h->plt.refcount > 0)
5640 h->plt.refcount -= 1;
5641 if (ELF32_R_TYPE (rel->r_info) == R_ARM_THM_CALL)
5642 eh->plt_thumb_refcount--;
5645 if (r_type == R_ARM_ABS32
5646 || r_type == R_ARM_REL32)
5648 for (pp = &eh->relocs_copied; (p = *pp) != NULL;
5650 if (p->section == sec)
5653 if (ELF32_R_TYPE (rel->r_info) == R_ARM_REL32)
5671 /* Look through the relocs for a section during the first phase. */
5674 elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info,
5675 asection *sec, const Elf_Internal_Rela *relocs)
5677 Elf_Internal_Shdr *symtab_hdr;
5678 struct elf_link_hash_entry **sym_hashes;
5679 struct elf_link_hash_entry **sym_hashes_end;
5680 const Elf_Internal_Rela *rel;
5681 const Elf_Internal_Rela *rel_end;
5684 bfd_vma *local_got_offsets;
5685 struct elf32_arm_link_hash_table *htab;
5687 if (info->relocatable)
5690 htab = elf32_arm_hash_table (info);
5693 /* Create dynamic sections for relocatable executables so that we can
5694 copy relocations. */
5695 if (htab->root.is_relocatable_executable
5696 && ! htab->root.dynamic_sections_created)
5698 if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
5702 dynobj = elf_hash_table (info)->dynobj;
5703 local_got_offsets = elf_local_got_offsets (abfd);
5705 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5706 sym_hashes = elf_sym_hashes (abfd);
5707 sym_hashes_end = sym_hashes
5708 + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
5710 if (!elf_bad_symtab (abfd))
5711 sym_hashes_end -= symtab_hdr->sh_info;
5713 rel_end = relocs + sec->reloc_count;
5714 for (rel = relocs; rel < rel_end; rel++)
5716 struct elf_link_hash_entry *h;
5717 struct elf32_arm_link_hash_entry *eh;
5718 unsigned long r_symndx;
5721 r_symndx = ELF32_R_SYM (rel->r_info);
5722 r_type = ELF32_R_TYPE (rel->r_info);
5723 r_type = arm_real_reloc_type (htab, r_type);
5725 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
5727 (*_bfd_error_handler) (_("%B: bad symbol index: %d"), abfd,
5732 if (r_symndx < symtab_hdr->sh_info)
5736 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5737 while (h->root.type == bfd_link_hash_indirect
5738 || h->root.type == bfd_link_hash_warning)
5739 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5742 eh = (struct elf32_arm_link_hash_entry *) h;
5747 case R_ARM_GOT_PREL:
5748 case R_ARM_TLS_GD32:
5749 case R_ARM_TLS_IE32:
5750 /* This symbol requires a global offset table entry. */
5752 int tls_type, old_tls_type;
5756 case R_ARM_TLS_GD32: tls_type = GOT_TLS_GD; break;
5757 case R_ARM_TLS_IE32: tls_type = GOT_TLS_IE; break;
5758 default: tls_type = GOT_NORMAL; break;
5764 old_tls_type = elf32_arm_hash_entry (h)->tls_type;
5768 bfd_signed_vma *local_got_refcounts;
5770 /* This is a global offset table entry for a local symbol. */
5771 local_got_refcounts = elf_local_got_refcounts (abfd);
5772 if (local_got_refcounts == NULL)
5776 size = symtab_hdr->sh_info;
5777 size *= (sizeof (bfd_signed_vma) + sizeof(char));
5778 local_got_refcounts = bfd_zalloc (abfd, size);
5779 if (local_got_refcounts == NULL)
5781 elf_local_got_refcounts (abfd) = local_got_refcounts;
5782 elf32_arm_local_got_tls_type (abfd)
5783 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
5785 local_got_refcounts[r_symndx] += 1;
5786 old_tls_type = elf32_arm_local_got_tls_type (abfd) [r_symndx];
5789 /* We will already have issued an error message if there is a
5790 TLS / non-TLS mismatch, based on the symbol type. We don't
5791 support any linker relaxations. So just combine any TLS
5793 if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
5794 && tls_type != GOT_NORMAL)
5795 tls_type |= old_tls_type;
5797 if (old_tls_type != tls_type)
5800 elf32_arm_hash_entry (h)->tls_type = tls_type;
5802 elf32_arm_local_got_tls_type (abfd) [r_symndx] = tls_type;
5807 case R_ARM_TLS_LDM32:
5808 if (r_type == R_ARM_TLS_LDM32)
5809 htab->tls_ldm_got.refcount++;
5812 case R_ARM_GOTOFF32:
5814 if (htab->sgot == NULL)
5816 if (htab->root.dynobj == NULL)
5817 htab->root.dynobj = abfd;
5818 if (!create_got_section (htab->root.dynobj, info))
5824 /* VxWorks uses dynamic R_ARM_ABS12 relocations for
5825 ldr __GOTT_INDEX__ offsets. */
5826 if (!htab->vxworks_p)
5837 case R_ARM_THM_CALL:
5838 /* Should the interworking branches be listed here? */
5841 /* If this reloc is in a read-only section, we might
5842 need a copy reloc. We can't check reliably at this
5843 stage whether the section is read-only, as input
5844 sections have not yet been mapped to output sections.
5845 Tentatively set the flag for now, and correct in
5846 adjust_dynamic_symbol. */
5850 /* We may need a .plt entry if the function this reloc
5851 refers to is in a different object. We can't tell for
5852 sure yet, because something later might force the
5854 if (r_type == R_ARM_PC24
5855 || r_type == R_ARM_CALL
5856 || r_type == R_ARM_JUMP24
5857 || r_type == R_ARM_PREL31
5858 || r_type == R_ARM_PLT32
5859 || r_type == R_ARM_THM_CALL)
5862 /* If we create a PLT entry, this relocation will reference
5863 it, even if it's an ABS32 relocation. */
5864 h->plt.refcount += 1;
5866 if (r_type == R_ARM_THM_CALL)
5867 eh->plt_thumb_refcount += 1;
5870 /* If we are creating a shared library or relocatable executable,
5871 and this is a reloc against a global symbol, or a non PC
5872 relative reloc against a local symbol, then we need to copy
5873 the reloc into the shared library. However, if we are linking
5874 with -Bsymbolic, we do not need to copy a reloc against a
5875 global symbol which is defined in an object we are
5876 including in the link (i.e., DEF_REGULAR is set). At
5877 this point we have not seen all the input files, so it is
5878 possible that DEF_REGULAR is not set now but will be set
5879 later (it is never cleared). We account for that
5880 possibility below by storing information in the
5881 relocs_copied field of the hash table entry. */
5882 if ((info->shared || htab->root.is_relocatable_executable)
5883 && (sec->flags & SEC_ALLOC) != 0
5884 && (r_type == R_ARM_ABS32
5885 || (h != NULL && ! h->needs_plt
5886 && (! info->symbolic || ! h->def_regular))))
5888 struct elf32_arm_relocs_copied *p, **head;
5890 /* When creating a shared object, we must copy these
5891 reloc types into the output file. We create a reloc
5892 section in dynobj and make room for this reloc. */
5897 name = (bfd_elf_string_from_elf_section
5899 elf_elfheader (abfd)->e_shstrndx,
5900 elf_section_data (sec)->rel_hdr.sh_name));
5904 BFD_ASSERT (reloc_section_p (htab, name, sec));
5906 sreloc = bfd_get_section_by_name (dynobj, name);
5911 flags = (SEC_HAS_CONTENTS | SEC_READONLY
5912 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
5913 if ((sec->flags & SEC_ALLOC) != 0
5914 /* BPABI objects never have dynamic
5915 relocations mapped. */
5916 && !htab->symbian_p)
5917 flags |= SEC_ALLOC | SEC_LOAD;
5918 sreloc = bfd_make_section_with_flags (dynobj,
5922 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
5926 elf_section_data (sec)->sreloc = sreloc;
5929 /* If this is a global symbol, we count the number of
5930 relocations we need for this symbol. */
5933 head = &((struct elf32_arm_link_hash_entry *) h)->relocs_copied;
5937 /* Track dynamic relocs needed for local syms too.
5938 We really need local syms available to do this
5944 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
5949 vpp = &elf_section_data (s)->local_dynrel;
5950 head = (struct elf32_arm_relocs_copied **) vpp;
5954 if (p == NULL || p->section != sec)
5956 bfd_size_type amt = sizeof *p;
5958 p = bfd_alloc (htab->root.dynobj, amt);
5968 if (r_type == R_ARM_REL32)
5974 /* This relocation describes the C++ object vtable hierarchy.
5975 Reconstruct it for later use during GC. */
5976 case R_ARM_GNU_VTINHERIT:
5977 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5981 /* This relocation describes which C++ vtable entries are actually
5982 used. Record for later use during GC. */
5983 case R_ARM_GNU_VTENTRY:
5984 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
5993 /* Treat mapping symbols as special target symbols. */
5996 elf32_arm_is_target_special_symbol (bfd * abfd ATTRIBUTE_UNUSED, asymbol * sym)
5998 return bfd_is_arm_mapping_symbol_name (sym->name);
6001 /* This is a copy of elf_find_function() from elf.c except that
6002 ARM mapping symbols are ignored when looking for function names
6003 and STT_ARM_TFUNC is considered to a function type. */
6006 arm_elf_find_function (bfd * abfd ATTRIBUTE_UNUSED,
6010 const char ** filename_ptr,
6011 const char ** functionname_ptr)
6013 const char * filename = NULL;
6014 asymbol * func = NULL;
6015 bfd_vma low_func = 0;
6018 for (p = symbols; *p != NULL; p++)
6022 q = (elf_symbol_type *) *p;
6024 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
6029 filename = bfd_asymbol_name (&q->symbol);
6034 /* Skip $a and $t symbols. */
6035 if ((q->symbol.flags & BSF_LOCAL)
6036 && bfd_is_arm_mapping_symbol_name (q->symbol.name))
6039 if (bfd_get_section (&q->symbol) == section
6040 && q->symbol.value >= low_func
6041 && q->symbol.value <= offset)
6043 func = (asymbol *) q;
6044 low_func = q->symbol.value;
6054 *filename_ptr = filename;
6055 if (functionname_ptr)
6056 *functionname_ptr = bfd_asymbol_name (func);
6062 /* Find the nearest line to a particular section and offset, for error
6063 reporting. This code is a duplicate of the code in elf.c, except
6064 that it uses arm_elf_find_function. */
6067 elf32_arm_find_nearest_line (bfd * abfd,
6071 const char ** filename_ptr,
6072 const char ** functionname_ptr,
6073 unsigned int * line_ptr)
6075 bfd_boolean found = FALSE;
6077 /* We skip _bfd_dwarf1_find_nearest_line since no known ARM toolchain uses it. */
6079 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
6080 filename_ptr, functionname_ptr,
6082 & elf_tdata (abfd)->dwarf2_find_line_info))
6084 if (!*functionname_ptr)
6085 arm_elf_find_function (abfd, section, symbols, offset,
6086 *filename_ptr ? NULL : filename_ptr,
6092 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
6093 & found, filename_ptr,
6094 functionname_ptr, line_ptr,
6095 & elf_tdata (abfd)->line_info))
6098 if (found && (*functionname_ptr || *line_ptr))
6101 if (symbols == NULL)
6104 if (! arm_elf_find_function (abfd, section, symbols, offset,
6105 filename_ptr, functionname_ptr))
6113 elf32_arm_find_inliner_info (bfd * abfd,
6114 const char ** filename_ptr,
6115 const char ** functionname_ptr,
6116 unsigned int * line_ptr)
6119 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
6120 functionname_ptr, line_ptr,
6121 & elf_tdata (abfd)->dwarf2_find_line_info);
6125 /* Adjust a symbol defined by a dynamic object and referenced by a
6126 regular object. The current definition is in some section of the
6127 dynamic object, but we're not including those sections. We have to
6128 change the definition to something the rest of the link can
6132 elf32_arm_adjust_dynamic_symbol (struct bfd_link_info * info,
6133 struct elf_link_hash_entry * h)
6137 unsigned int power_of_two;
6138 struct elf32_arm_link_hash_entry * eh;
6139 struct elf32_arm_link_hash_table *globals;
6141 globals = elf32_arm_hash_table (info);
6142 dynobj = elf_hash_table (info)->dynobj;
6144 /* Make sure we know what is going on here. */
6145 BFD_ASSERT (dynobj != NULL
6147 || h->u.weakdef != NULL
6150 && !h->def_regular)));
6152 eh = (struct elf32_arm_link_hash_entry *) h;
6154 /* If this is a function, put it in the procedure linkage table. We
6155 will fill in the contents of the procedure linkage table later,
6156 when we know the address of the .got section. */
6157 if (h->type == STT_FUNC || h->type == STT_ARM_TFUNC
6160 if (h->plt.refcount <= 0
6161 || SYMBOL_CALLS_LOCAL (info, h)
6162 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6163 && h->root.type == bfd_link_hash_undefweak))
6165 /* This case can occur if we saw a PLT32 reloc in an input
6166 file, but the symbol was never referred to by a dynamic
6167 object, or if all references were garbage collected. In
6168 such a case, we don't actually need to build a procedure
6169 linkage table, and we can just do a PC24 reloc instead. */
6170 h->plt.offset = (bfd_vma) -1;
6171 eh->plt_thumb_refcount = 0;
6179 /* It's possible that we incorrectly decided a .plt reloc was
6180 needed for an R_ARM_PC24 or similar reloc to a non-function sym
6181 in check_relocs. We can't decide accurately between function
6182 and non-function syms in check-relocs; Objects loaded later in
6183 the link may change h->type. So fix it now. */
6184 h->plt.offset = (bfd_vma) -1;
6185 eh->plt_thumb_refcount = 0;
6188 /* If this is a weak symbol, and there is a real definition, the
6189 processor independent code will have arranged for us to see the
6190 real definition first, and we can just use the same value. */
6191 if (h->u.weakdef != NULL)
6193 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6194 || h->u.weakdef->root.type == bfd_link_hash_defweak);
6195 h->root.u.def.section = h->u.weakdef->root.u.def.section;
6196 h->root.u.def.value = h->u.weakdef->root.u.def.value;
6200 /* If there are no non-GOT references, we do not need a copy
6202 if (!h->non_got_ref)
6205 /* This is a reference to a symbol defined by a dynamic object which
6206 is not a function. */
6208 /* If we are creating a shared library, we must presume that the
6209 only references to the symbol are via the global offset table.
6210 For such cases we need not do anything here; the relocations will
6211 be handled correctly by relocate_section. Relocatable executables
6212 can reference data in shared objects directly, so we don't need to
6213 do anything here. */
6214 if (info->shared || globals->root.is_relocatable_executable)
6219 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
6220 h->root.root.string);
6224 /* We must allocate the symbol in our .dynbss section, which will
6225 become part of the .bss section of the executable. There will be
6226 an entry for this symbol in the .dynsym section. The dynamic
6227 object will contain position independent code, so all references
6228 from the dynamic object to this symbol will go through the global
6229 offset table. The dynamic linker will use the .dynsym entry to
6230 determine the address it must put in the global offset table, so
6231 both the dynamic object and the regular object will refer to the
6232 same memory location for the variable. */
6233 s = bfd_get_section_by_name (dynobj, ".dynbss");
6234 BFD_ASSERT (s != NULL);
6236 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
6237 copy the initial value out of the dynamic object and into the
6238 runtime process image. We need to remember the offset into the
6239 .rel(a).bss section we are going to use. */
6240 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
6244 srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (globals, ".bss"));
6245 BFD_ASSERT (srel != NULL);
6246 srel->size += RELOC_SIZE (globals);
6250 /* We need to figure out the alignment required for this symbol. I
6251 have no idea how ELF linkers handle this. */
6252 power_of_two = bfd_log2 (h->size);
6253 if (power_of_two > 3)
6256 /* Apply the required alignment. */
6257 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
6258 if (power_of_two > bfd_get_section_alignment (dynobj, s))
6260 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
6264 /* Define the symbol as being at this point in the section. */
6265 h->root.u.def.section = s;
6266 h->root.u.def.value = s->size;
6268 /* Increment the section size to make room for the symbol. */
6274 /* Allocate space in .plt, .got and associated reloc sections for
6278 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
6280 struct bfd_link_info *info;
6281 struct elf32_arm_link_hash_table *htab;
6282 struct elf32_arm_link_hash_entry *eh;
6283 struct elf32_arm_relocs_copied *p;
6285 eh = (struct elf32_arm_link_hash_entry *) h;
6287 if (h->root.type == bfd_link_hash_indirect)
6290 if (h->root.type == bfd_link_hash_warning)
6291 /* When warning symbols are created, they **replace** the "real"
6292 entry in the hash table, thus we never get to see the real
6293 symbol in a hash traversal. So look at it now. */
6294 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6296 info = (struct bfd_link_info *) inf;
6297 htab = elf32_arm_hash_table (info);
6299 if (htab->root.dynamic_sections_created
6300 && h->plt.refcount > 0)
6302 /* Make sure this symbol is output as a dynamic symbol.
6303 Undefined weak syms won't yet be marked as dynamic. */
6304 if (h->dynindx == -1
6305 && !h->forced_local)
6307 if (! bfd_elf_link_record_dynamic_symbol (info, h))
6312 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
6314 asection *s = htab->splt;
6316 /* If this is the first .plt entry, make room for the special
6319 s->size += htab->plt_header_size;
6321 h->plt.offset = s->size;
6323 /* If we will insert a Thumb trampoline before this PLT, leave room
6325 if (!htab->use_blx && eh->plt_thumb_refcount > 0)
6327 h->plt.offset += PLT_THUMB_STUB_SIZE;
6328 s->size += PLT_THUMB_STUB_SIZE;
6331 /* If this symbol is not defined in a regular file, and we are
6332 not generating a shared library, then set the symbol to this
6333 location in the .plt. This is required to make function
6334 pointers compare as equal between the normal executable and
6335 the shared library. */
6339 h->root.u.def.section = s;
6340 h->root.u.def.value = h->plt.offset;
6342 /* Make sure the function is not marked as Thumb, in case
6343 it is the target of an ABS32 relocation, which will
6344 point to the PLT entry. */
6345 if (ELF_ST_TYPE (h->type) == STT_ARM_TFUNC)
6346 h->type = ELF_ST_INFO (ELF_ST_BIND (h->type), STT_FUNC);
6349 /* Make room for this entry. */
6350 s->size += htab->plt_entry_size;
6352 if (!htab->symbian_p)
6354 /* We also need to make an entry in the .got.plt section, which
6355 will be placed in the .got section by the linker script. */
6356 eh->plt_got_offset = htab->sgotplt->size;
6357 htab->sgotplt->size += 4;
6360 /* We also need to make an entry in the .rel(a).plt section. */
6361 htab->srelplt->size += RELOC_SIZE (htab);
6363 /* VxWorks executables have a second set of relocations for
6364 each PLT entry. They go in a separate relocation section,
6365 which is processed by the kernel loader. */
6366 if (htab->vxworks_p && !info->shared)
6368 /* There is a relocation for the initial PLT entry:
6369 an R_ARM_32 relocation for _GLOBAL_OFFSET_TABLE_. */
6370 if (h->plt.offset == htab->plt_header_size)
6371 htab->srelplt2->size += RELOC_SIZE (htab);
6373 /* There are two extra relocations for each subsequent
6374 PLT entry: an R_ARM_32 relocation for the GOT entry,
6375 and an R_ARM_32 relocation for the PLT entry. */
6376 htab->srelplt2->size += RELOC_SIZE (htab) * 2;
6381 h->plt.offset = (bfd_vma) -1;
6387 h->plt.offset = (bfd_vma) -1;
6391 if (h->got.refcount > 0)
6395 int tls_type = elf32_arm_hash_entry (h)->tls_type;
6398 /* Make sure this symbol is output as a dynamic symbol.
6399 Undefined weak syms won't yet be marked as dynamic. */
6400 if (h->dynindx == -1
6401 && !h->forced_local)
6403 if (! bfd_elf_link_record_dynamic_symbol (info, h))
6407 if (!htab->symbian_p)
6410 h->got.offset = s->size;
6412 if (tls_type == GOT_UNKNOWN)
6415 if (tls_type == GOT_NORMAL)
6416 /* Non-TLS symbols need one GOT slot. */
6420 if (tls_type & GOT_TLS_GD)
6421 /* R_ARM_TLS_GD32 needs 2 consecutive GOT slots. */
6423 if (tls_type & GOT_TLS_IE)
6424 /* R_ARM_TLS_IE32 needs one GOT slot. */
6428 dyn = htab->root.dynamic_sections_created;
6431 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
6433 || !SYMBOL_REFERENCES_LOCAL (info, h)))
6436 if (tls_type != GOT_NORMAL
6437 && (info->shared || indx != 0)
6438 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
6439 || h->root.type != bfd_link_hash_undefweak))
6441 if (tls_type & GOT_TLS_IE)
6442 htab->srelgot->size += RELOC_SIZE (htab);
6444 if (tls_type & GOT_TLS_GD)
6445 htab->srelgot->size += RELOC_SIZE (htab);
6447 if ((tls_type & GOT_TLS_GD) && indx != 0)
6448 htab->srelgot->size += RELOC_SIZE (htab);
6450 else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
6451 || h->root.type != bfd_link_hash_undefweak)
6453 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
6454 htab->srelgot->size += RELOC_SIZE (htab);
6458 h->got.offset = (bfd_vma) -1;
6460 if (eh->relocs_copied == NULL)
6463 /* In the shared -Bsymbolic case, discard space allocated for
6464 dynamic pc-relative relocs against symbols which turn out to be
6465 defined in regular objects. For the normal shared case, discard
6466 space for pc-relative relocs that have become local due to symbol
6467 visibility changes. */
6469 if (info->shared || htab->root.is_relocatable_executable)
6471 /* The only reloc that uses pc_count is R_ARM_REL32, which will
6472 appear on something like ".long foo - .". We want calls to
6473 protected symbols to resolve directly to the function rather
6474 than going via the plt. If people want function pointer
6475 comparisons to work as expected then they should avoid
6476 writing assembly like ".long foo - .". */
6477 if (SYMBOL_CALLS_LOCAL (info, h))
6479 struct elf32_arm_relocs_copied **pp;
6481 for (pp = &eh->relocs_copied; (p = *pp) != NULL; )
6483 p->count -= p->pc_count;
6492 /* Also discard relocs on undefined weak syms with non-default
6494 if (eh->relocs_copied != NULL
6495 && h->root.type == bfd_link_hash_undefweak)
6497 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
6498 eh->relocs_copied = NULL;
6500 /* Make sure undefined weak symbols are output as a dynamic
6502 else if (h->dynindx == -1
6503 && !h->forced_local)
6505 if (! bfd_elf_link_record_dynamic_symbol (info, h))
6510 else if (htab->root.is_relocatable_executable && h->dynindx == -1
6511 && h->root.type == bfd_link_hash_new)
6513 /* Output absolute symbols so that we can create relocations
6514 against them. For normal symbols we output a relocation
6515 against the section that contains them. */
6516 if (! bfd_elf_link_record_dynamic_symbol (info, h))
6523 /* For the non-shared case, discard space for relocs against
6524 symbols which turn out to need copy relocs or are not
6530 || (htab->root.dynamic_sections_created
6531 && (h->root.type == bfd_link_hash_undefweak
6532 || h->root.type == bfd_link_hash_undefined))))
6534 /* Make sure this symbol is output as a dynamic symbol.
6535 Undefined weak syms won't yet be marked as dynamic. */
6536 if (h->dynindx == -1
6537 && !h->forced_local)
6539 if (! bfd_elf_link_record_dynamic_symbol (info, h))
6543 /* If that succeeded, we know we'll be keeping all the
6545 if (h->dynindx != -1)
6549 eh->relocs_copied = NULL;
6554 /* Finally, allocate space. */
6555 for (p = eh->relocs_copied; p != NULL; p = p->next)
6557 asection *sreloc = elf_section_data (p->section)->sreloc;
6558 sreloc->size += p->count * RELOC_SIZE (htab);
6564 /* Find any dynamic relocs that apply to read-only sections. */
6567 elf32_arm_readonly_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
6569 struct elf32_arm_link_hash_entry *eh;
6570 struct elf32_arm_relocs_copied *p;
6572 if (h->root.type == bfd_link_hash_warning)
6573 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6575 eh = (struct elf32_arm_link_hash_entry *) h;
6576 for (p = eh->relocs_copied; p != NULL; p = p->next)
6578 asection *s = p->section;
6580 if (s != NULL && (s->flags & SEC_READONLY) != 0)
6582 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6584 info->flags |= DF_TEXTREL;
6586 /* Not an error, just cut short the traversal. */
6593 /* Set the sizes of the dynamic sections. */
6596 elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
6597 struct bfd_link_info * info)
6604 struct elf32_arm_link_hash_table *htab;
6606 htab = elf32_arm_hash_table (info);
6607 dynobj = elf_hash_table (info)->dynobj;
6608 BFD_ASSERT (dynobj != NULL);
6609 check_use_blx (htab);
6611 if (elf_hash_table (info)->dynamic_sections_created)
6613 /* Set the contents of the .interp section to the interpreter. */
6614 if (info->executable)
6616 s = bfd_get_section_by_name (dynobj, ".interp");
6617 BFD_ASSERT (s != NULL);
6618 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
6619 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
6623 /* Set up .got offsets for local syms, and space for local dynamic
6625 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6627 bfd_signed_vma *local_got;
6628 bfd_signed_vma *end_local_got;
6629 char *local_tls_type;
6630 bfd_size_type locsymcount;
6631 Elf_Internal_Shdr *symtab_hdr;
6634 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
6637 for (s = ibfd->sections; s != NULL; s = s->next)
6639 struct elf32_arm_relocs_copied *p;
6641 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
6643 if (!bfd_is_abs_section (p->section)
6644 && bfd_is_abs_section (p->section->output_section))
6646 /* Input section has been discarded, either because
6647 it is a copy of a linkonce section or due to
6648 linker script /DISCARD/, so we'll be discarding
6651 else if (p->count != 0)
6653 srel = elf_section_data (p->section)->sreloc;
6654 srel->size += p->count * RELOC_SIZE (htab);
6655 if ((p->section->output_section->flags & SEC_READONLY) != 0)
6656 info->flags |= DF_TEXTREL;
6661 local_got = elf_local_got_refcounts (ibfd);
6665 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
6666 locsymcount = symtab_hdr->sh_info;
6667 end_local_got = local_got + locsymcount;
6668 local_tls_type = elf32_arm_local_got_tls_type (ibfd);
6670 srel = htab->srelgot;
6671 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
6675 *local_got = s->size;
6676 if (*local_tls_type & GOT_TLS_GD)
6677 /* TLS_GD relocs need an 8-byte structure in the GOT. */
6679 if (*local_tls_type & GOT_TLS_IE)
6681 if (*local_tls_type == GOT_NORMAL)
6684 if (info->shared || *local_tls_type == GOT_TLS_GD)
6685 srel->size += RELOC_SIZE (htab);
6688 *local_got = (bfd_vma) -1;
6692 if (htab->tls_ldm_got.refcount > 0)
6694 /* Allocate two GOT entries and one dynamic relocation (if necessary)
6695 for R_ARM_TLS_LDM32 relocations. */
6696 htab->tls_ldm_got.offset = htab->sgot->size;
6697 htab->sgot->size += 8;
6699 htab->srelgot->size += RELOC_SIZE (htab);
6702 htab->tls_ldm_got.offset = -1;
6704 /* Allocate global sym .plt and .got entries, and space for global
6705 sym dynamic relocs. */
6706 elf_link_hash_traverse (& htab->root, allocate_dynrelocs, info);
6708 /* The check_relocs and adjust_dynamic_symbol entry points have
6709 determined the sizes of the various dynamic sections. Allocate
6713 for (s = dynobj->sections; s != NULL; s = s->next)
6717 if ((s->flags & SEC_LINKER_CREATED) == 0)
6720 /* It's OK to base decisions on the section name, because none
6721 of the dynobj section names depend upon the input files. */
6722 name = bfd_get_section_name (dynobj, s);
6724 if (strcmp (name, ".plt") == 0)
6726 /* Remember whether there is a PLT. */
6729 else if (strncmp (name, ".rel", 4) == 0)
6733 /* Remember whether there are any reloc sections other
6734 than .rel(a).plt and .rela.plt.unloaded. */
6735 if (s != htab->srelplt && s != htab->srelplt2)
6738 /* We use the reloc_count field as a counter if we need
6739 to copy relocs into the output file. */
6743 else if (strncmp (name, ".got", 4) != 0
6744 && strcmp (name, ".dynbss") != 0)
6746 /* It's not one of our sections, so don't allocate space. */
6752 /* If we don't need this section, strip it from the
6753 output file. This is mostly to handle .rel(a).bss and
6754 .rel(a).plt. We must create both sections in
6755 create_dynamic_sections, because they must be created
6756 before the linker maps input sections to output
6757 sections. The linker does that before
6758 adjust_dynamic_symbol is called, and it is that
6759 function which decides whether anything needs to go
6760 into these sections. */
6761 s->flags |= SEC_EXCLUDE;
6765 if ((s->flags & SEC_HAS_CONTENTS) == 0)
6768 /* Allocate memory for the section contents. */
6769 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
6770 if (s->contents == NULL)
6774 if (elf_hash_table (info)->dynamic_sections_created)
6776 /* Add some entries to the .dynamic section. We fill in the
6777 values later, in elf32_arm_finish_dynamic_sections, but we
6778 must add the entries now so that we get the correct size for
6779 the .dynamic section. The DT_DEBUG entry is filled in by the
6780 dynamic linker and used by the debugger. */
6781 #define add_dynamic_entry(TAG, VAL) \
6782 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
6784 if (info->executable)
6786 if (!add_dynamic_entry (DT_DEBUG, 0))
6792 if ( !add_dynamic_entry (DT_PLTGOT, 0)
6793 || !add_dynamic_entry (DT_PLTRELSZ, 0)
6794 || !add_dynamic_entry (DT_PLTREL,
6795 htab->use_rel ? DT_REL : DT_RELA)
6796 || !add_dynamic_entry (DT_JMPREL, 0))
6804 if (!add_dynamic_entry (DT_REL, 0)
6805 || !add_dynamic_entry (DT_RELSZ, 0)
6806 || !add_dynamic_entry (DT_RELENT, RELOC_SIZE (htab)))
6811 if (!add_dynamic_entry (DT_RELA, 0)
6812 || !add_dynamic_entry (DT_RELASZ, 0)
6813 || !add_dynamic_entry (DT_RELAENT, RELOC_SIZE (htab)))
6818 /* If any dynamic relocs apply to a read-only section,
6819 then we need a DT_TEXTREL entry. */
6820 if ((info->flags & DF_TEXTREL) == 0)
6821 elf_link_hash_traverse (&htab->root, elf32_arm_readonly_dynrelocs,
6824 if ((info->flags & DF_TEXTREL) != 0)
6826 if (!add_dynamic_entry (DT_TEXTREL, 0))
6830 #undef add_dynamic_entry
6835 /* Finish up dynamic symbol handling. We set the contents of various
6836 dynamic sections here. */
6839 elf32_arm_finish_dynamic_symbol (bfd * output_bfd, struct bfd_link_info * info,
6840 struct elf_link_hash_entry * h, Elf_Internal_Sym * sym)
6843 struct elf32_arm_link_hash_table *htab;
6844 struct elf32_arm_link_hash_entry *eh;
6846 dynobj = elf_hash_table (info)->dynobj;
6847 htab = elf32_arm_hash_table (info);
6848 eh = (struct elf32_arm_link_hash_entry *) h;
6850 if (h->plt.offset != (bfd_vma) -1)
6856 Elf_Internal_Rela rel;
6858 /* This symbol has an entry in the procedure linkage table. Set
6861 BFD_ASSERT (h->dynindx != -1);
6863 splt = bfd_get_section_by_name (dynobj, ".plt");
6864 srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (htab, ".plt"));
6865 BFD_ASSERT (splt != NULL && srel != NULL);
6867 /* Fill in the entry in the procedure linkage table. */
6868 if (htab->symbian_p)
6871 for (i = 0; i < htab->plt_entry_size / 4; ++i)
6872 bfd_put_32 (output_bfd,
6873 elf32_arm_symbian_plt_entry[i],
6874 splt->contents + h->plt.offset + 4 * i);
6876 /* Fill in the entry in the .rel.plt section. */
6877 rel.r_offset = (splt->output_section->vma
6878 + splt->output_offset
6879 + h->plt.offset + 4 * (i - 1));
6880 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
6882 /* Get the index in the procedure linkage table which
6883 corresponds to this symbol. This is the index of this symbol
6884 in all the symbols for which we are making plt entries. The
6885 first entry in the procedure linkage table is reserved. */
6886 plt_index = ((h->plt.offset - htab->plt_header_size)
6887 / htab->plt_entry_size);
6891 bfd_vma got_offset, got_address, plt_address;
6892 bfd_vma got_displacement;
6895 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
6896 BFD_ASSERT (sgot != NULL);
6898 /* Get the offset into the .got.plt table of the entry that
6899 corresponds to this function. */
6900 got_offset = eh->plt_got_offset;
6902 /* Get the index in the procedure linkage table which
6903 corresponds to this symbol. This is the index of this symbol
6904 in all the symbols for which we are making plt entries. The
6905 first three entries in .got.plt are reserved; after that
6906 symbols appear in the same order as in .plt. */
6907 plt_index = (got_offset - 12) / 4;
6909 /* Calculate the address of the GOT entry. */
6910 got_address = (sgot->output_section->vma
6911 + sgot->output_offset
6914 /* ...and the address of the PLT entry. */
6915 plt_address = (splt->output_section->vma
6916 + splt->output_offset
6919 if (htab->vxworks_p && info->shared)
6924 for (i = 0; i != htab->plt_entry_size / 4; i++)
6926 val = elf32_arm_vxworks_shared_plt_entry[i];
6928 val |= got_address - sgot->output_section->vma;
6930 val |= plt_index * RELOC_SIZE (htab);
6931 bfd_put_32 (output_bfd, val,
6932 htab->splt->contents + h->plt.offset + i * 4);
6935 else if (htab->vxworks_p)
6940 for (i = 0; i != htab->plt_entry_size / 4; i++)
6942 val = elf32_arm_vxworks_exec_plt_entry[i];
6946 val |= 0xffffff & -((h->plt.offset + i * 4 + 8) >> 2);
6948 val |= plt_index * RELOC_SIZE (htab);
6949 bfd_put_32 (output_bfd, val,
6950 htab->splt->contents + h->plt.offset + i * 4);
6953 loc = (htab->srelplt2->contents
6954 + (plt_index * 2 + 1) * RELOC_SIZE (htab));
6956 /* Create the .rela.plt.unloaded R_ARM_ABS32 relocation
6957 referencing the GOT for this PLT entry. */
6958 rel.r_offset = plt_address + 8;
6959 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
6960 rel.r_addend = got_offset;
6961 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
6962 loc += RELOC_SIZE (htab);
6964 /* Create the R_ARM_ABS32 relocation referencing the
6965 beginning of the PLT for this GOT entry. */
6966 rel.r_offset = got_address;
6967 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_ARM_ABS32);
6969 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
6973 /* Calculate the displacement between the PLT slot and the
6974 entry in the GOT. The eight-byte offset accounts for the
6975 value produced by adding to pc in the first instruction
6977 got_displacement = got_address - (plt_address + 8);
6979 BFD_ASSERT ((got_displacement & 0xf0000000) == 0);
6981 if (!htab->use_blx && eh->plt_thumb_refcount > 0)
6983 bfd_put_16 (output_bfd, elf32_arm_plt_thumb_stub[0],
6984 splt->contents + h->plt.offset - 4);
6985 bfd_put_16 (output_bfd, elf32_arm_plt_thumb_stub[1],
6986 splt->contents + h->plt.offset - 2);
6989 bfd_put_32 (output_bfd,
6990 elf32_arm_plt_entry[0]
6991 | ((got_displacement & 0x0ff00000) >> 20),
6992 splt->contents + h->plt.offset + 0);
6993 bfd_put_32 (output_bfd,
6994 elf32_arm_plt_entry[1]
6995 | ((got_displacement & 0x000ff000) >> 12),
6996 splt->contents + h->plt.offset + 4);
6997 bfd_put_32 (output_bfd,
6998 elf32_arm_plt_entry[2]
6999 | (got_displacement & 0x00000fff),
7000 splt->contents + h->plt.offset + 8);
7001 #ifdef FOUR_WORD_PLT
7002 bfd_put_32 (output_bfd, elf32_arm_plt_entry[3],
7003 splt->contents + h->plt.offset + 12);
7007 /* Fill in the entry in the global offset table. */
7008 bfd_put_32 (output_bfd,
7009 (splt->output_section->vma
7010 + splt->output_offset),
7011 sgot->contents + got_offset);
7013 /* Fill in the entry in the .rel(a).plt section. */
7015 rel.r_offset = got_address;
7016 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
7019 loc = srel->contents + plt_index * RELOC_SIZE (htab);
7020 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
7022 if (!h->def_regular)
7024 /* Mark the symbol as undefined, rather than as defined in
7025 the .plt section. Leave the value alone. */
7026 sym->st_shndx = SHN_UNDEF;
7027 /* If the symbol is weak, we do need to clear the value.
7028 Otherwise, the PLT entry would provide a definition for
7029 the symbol even if the symbol wasn't defined anywhere,
7030 and so the symbol would never be NULL. */
7031 if (!h->ref_regular_nonweak)
7036 if (h->got.offset != (bfd_vma) -1
7037 && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_GD) == 0
7038 && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_IE) == 0)
7042 Elf_Internal_Rela rel;
7046 /* This symbol has an entry in the global offset table. Set it
7048 sgot = bfd_get_section_by_name (dynobj, ".got");
7049 srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (htab, ".got"));
7050 BFD_ASSERT (sgot != NULL && srel != NULL);
7052 offset = (h->got.offset & ~(bfd_vma) 1);
7054 rel.r_offset = (sgot->output_section->vma
7055 + sgot->output_offset
7058 /* If this is a static link, or it is a -Bsymbolic link and the
7059 symbol is defined locally or was forced to be local because
7060 of a version file, we just want to emit a RELATIVE reloc.
7061 The entry in the global offset table will already have been
7062 initialized in the relocate_section function. */
7064 && SYMBOL_REFERENCES_LOCAL (info, h))
7066 BFD_ASSERT((h->got.offset & 1) != 0);
7067 rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
7070 rel.r_addend = bfd_get_32 (output_bfd, sgot->contents + offset);
7071 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset);
7076 BFD_ASSERT((h->got.offset & 1) == 0);
7077 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset);
7078 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
7081 loc = srel->contents + srel->reloc_count++ * RELOC_SIZE (htab);
7082 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
7088 Elf_Internal_Rela rel;
7091 /* This symbol needs a copy reloc. Set it up. */
7092 BFD_ASSERT (h->dynindx != -1
7093 && (h->root.type == bfd_link_hash_defined
7094 || h->root.type == bfd_link_hash_defweak));
7096 s = bfd_get_section_by_name (h->root.u.def.section->owner,
7097 RELOC_SECTION (htab, ".bss"));
7098 BFD_ASSERT (s != NULL);
7101 rel.r_offset = (h->root.u.def.value
7102 + h->root.u.def.section->output_section->vma
7103 + h->root.u.def.section->output_offset);
7104 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
7105 loc = s->contents + s->reloc_count++ * RELOC_SIZE (htab);
7106 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
7109 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. On VxWorks,
7110 the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: it is relative
7111 to the ".got" section. */
7112 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
7113 || (!htab->vxworks_p && h == htab->root.hgot))
7114 sym->st_shndx = SHN_ABS;
7119 /* Finish up the dynamic sections. */
7122 elf32_arm_finish_dynamic_sections (bfd * output_bfd, struct bfd_link_info * info)
7128 dynobj = elf_hash_table (info)->dynobj;
7130 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
7131 BFD_ASSERT (elf32_arm_hash_table (info)->symbian_p || sgot != NULL);
7132 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
7134 if (elf_hash_table (info)->dynamic_sections_created)
7137 Elf32_External_Dyn *dyncon, *dynconend;
7138 struct elf32_arm_link_hash_table *htab;
7140 htab = elf32_arm_hash_table (info);
7141 splt = bfd_get_section_by_name (dynobj, ".plt");
7142 BFD_ASSERT (splt != NULL && sdyn != NULL);
7144 dyncon = (Elf32_External_Dyn *) sdyn->contents;
7145 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
7147 for (; dyncon < dynconend; dyncon++)
7149 Elf_Internal_Dyn dyn;
7153 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
7164 goto get_vma_if_bpabi;
7167 goto get_vma_if_bpabi;
7170 goto get_vma_if_bpabi;
7172 name = ".gnu.version";
7173 goto get_vma_if_bpabi;
7175 name = ".gnu.version_d";
7176 goto get_vma_if_bpabi;
7178 name = ".gnu.version_r";
7179 goto get_vma_if_bpabi;
7185 name = RELOC_SECTION (htab, ".plt");
7187 s = bfd_get_section_by_name (output_bfd, name);
7188 BFD_ASSERT (s != NULL);
7189 if (!htab->symbian_p)
7190 dyn.d_un.d_ptr = s->vma;
7192 /* In the BPABI, tags in the PT_DYNAMIC section point
7193 at the file offset, not the memory address, for the
7194 convenience of the post linker. */
7195 dyn.d_un.d_ptr = s->filepos;
7196 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7200 if (htab->symbian_p)
7205 s = bfd_get_section_by_name (output_bfd,
7206 RELOC_SECTION (htab, ".plt"));
7207 BFD_ASSERT (s != NULL);
7208 dyn.d_un.d_val = s->size;
7209 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7214 if (!htab->symbian_p)
7216 /* My reading of the SVR4 ABI indicates that the
7217 procedure linkage table relocs (DT_JMPREL) should be
7218 included in the overall relocs (DT_REL). This is
7219 what Solaris does. However, UnixWare can not handle
7220 that case. Therefore, we override the DT_RELSZ entry
7221 here to make it not include the JMPREL relocs. Since
7222 the linker script arranges for .rel(a).plt to follow all
7223 other relocation sections, we don't have to worry
7224 about changing the DT_REL entry. */
7225 s = bfd_get_section_by_name (output_bfd,
7226 RELOC_SECTION (htab, ".plt"));
7228 dyn.d_un.d_val -= s->size;
7229 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7236 /* In the BPABI, the DT_REL tag must point at the file
7237 offset, not the VMA, of the first relocation
7238 section. So, we use code similar to that in
7239 elflink.c, but do not check for SHF_ALLOC on the
7240 relcoation section, since relocations sections are
7241 never allocated under the BPABI. The comments above
7242 about Unixware notwithstanding, we include all of the
7243 relocations here. */
7244 if (htab->symbian_p)
7247 type = ((dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
7248 ? SHT_REL : SHT_RELA);
7250 for (i = 1; i < elf_numsections (output_bfd); i++)
7252 Elf_Internal_Shdr *hdr
7253 = elf_elfsections (output_bfd)[i];
7254 if (hdr->sh_type == type)
7256 if (dyn.d_tag == DT_RELSZ
7257 || dyn.d_tag == DT_RELASZ)
7258 dyn.d_un.d_val += hdr->sh_size;
7259 else if ((ufile_ptr) hdr->sh_offset
7260 <= dyn.d_un.d_val - 1)
7261 dyn.d_un.d_val = hdr->sh_offset;
7264 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7268 /* Set the bottom bit of DT_INIT/FINI if the
7269 corresponding function is Thumb. */
7271 name = info->init_function;
7274 name = info->fini_function;
7276 /* If it wasn't set by elf_bfd_final_link
7277 then there is nothing to adjust. */
7278 if (dyn.d_un.d_val != 0)
7280 struct elf_link_hash_entry * eh;
7282 eh = elf_link_hash_lookup (elf_hash_table (info), name,
7283 FALSE, FALSE, TRUE);
7284 if (eh != (struct elf_link_hash_entry *) NULL
7285 && ELF_ST_TYPE (eh->type) == STT_ARM_TFUNC)
7287 dyn.d_un.d_val |= 1;
7288 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7295 /* Fill in the first entry in the procedure linkage table. */
7296 if (splt->size > 0 && elf32_arm_hash_table (info)->plt_header_size)
7298 const bfd_vma *plt0_entry;
7299 bfd_vma got_address, plt_address, got_displacement;
7301 /* Calculate the addresses of the GOT and PLT. */
7302 got_address = sgot->output_section->vma + sgot->output_offset;
7303 plt_address = splt->output_section->vma + splt->output_offset;
7305 if (htab->vxworks_p)
7307 /* The VxWorks GOT is relocated by the dynamic linker.
7308 Therefore, we must emit relocations rather than simply
7309 computing the values now. */
7310 Elf_Internal_Rela rel;
7312 plt0_entry = elf32_arm_vxworks_exec_plt0_entry;
7313 bfd_put_32 (output_bfd, plt0_entry[0], splt->contents + 0);
7314 bfd_put_32 (output_bfd, plt0_entry[1], splt->contents + 4);
7315 bfd_put_32 (output_bfd, plt0_entry[2], splt->contents + 8);
7316 bfd_put_32 (output_bfd, got_address, splt->contents + 12);
7318 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_. */
7319 rel.r_offset = plt_address + 12;
7320 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
7322 SWAP_RELOC_OUT (htab) (output_bfd, &rel,
7323 htab->srelplt2->contents);
7327 got_displacement = got_address - (plt_address + 16);
7329 plt0_entry = elf32_arm_plt0_entry;
7330 bfd_put_32 (output_bfd, plt0_entry[0], splt->contents + 0);
7331 bfd_put_32 (output_bfd, plt0_entry[1], splt->contents + 4);
7332 bfd_put_32 (output_bfd, plt0_entry[2], splt->contents + 8);
7333 bfd_put_32 (output_bfd, plt0_entry[3], splt->contents + 12);
7335 #ifdef FOUR_WORD_PLT
7336 /* The displacement value goes in the otherwise-unused
7337 last word of the second entry. */
7338 bfd_put_32 (output_bfd, got_displacement, splt->contents + 28);
7340 bfd_put_32 (output_bfd, got_displacement, splt->contents + 16);
7345 /* UnixWare sets the entsize of .plt to 4, although that doesn't
7346 really seem like the right value. */
7347 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
7349 if (htab->vxworks_p && !info->shared && htab->splt->size > 0)
7351 /* Correct the .rel(a).plt.unloaded relocations. They will have
7352 incorrect symbol indexes. */
7356 num_plts = ((htab->splt->size - htab->plt_header_size)
7357 / htab->plt_entry_size);
7358 p = htab->srelplt2->contents + RELOC_SIZE (htab);
7360 for (; num_plts; num_plts--)
7362 Elf_Internal_Rela rel;
7364 SWAP_RELOC_IN (htab) (output_bfd, p, &rel);
7365 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
7366 SWAP_RELOC_OUT (htab) (output_bfd, &rel, p);
7367 p += RELOC_SIZE (htab);
7369 SWAP_RELOC_IN (htab) (output_bfd, p, &rel);
7370 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_ARM_ABS32);
7371 SWAP_RELOC_OUT (htab) (output_bfd, &rel, p);
7372 p += RELOC_SIZE (htab);
7377 /* Fill in the first three entries in the global offset table. */
7383 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
7385 bfd_put_32 (output_bfd,
7386 sdyn->output_section->vma + sdyn->output_offset,
7388 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
7389 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
7392 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
7399 elf32_arm_post_process_headers (bfd * abfd, struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
7401 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
7402 struct elf32_arm_link_hash_table *globals;
7404 i_ehdrp = elf_elfheader (abfd);
7406 if (EF_ARM_EABI_VERSION (i_ehdrp->e_flags) == EF_ARM_EABI_UNKNOWN)
7407 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_ARM;
7409 i_ehdrp->e_ident[EI_OSABI] = 0;
7410 i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
7414 globals = elf32_arm_hash_table (link_info);
7415 if (globals->byteswap_code)
7416 i_ehdrp->e_flags |= EF_ARM_BE8;
7420 static enum elf_reloc_type_class
7421 elf32_arm_reloc_type_class (const Elf_Internal_Rela *rela)
7423 switch ((int) ELF32_R_TYPE (rela->r_info))
7425 case R_ARM_RELATIVE:
7426 return reloc_class_relative;
7427 case R_ARM_JUMP_SLOT:
7428 return reloc_class_plt;
7430 return reloc_class_copy;
7432 return reloc_class_normal;
7436 /* Set the right machine number for an Arm ELF file. */
7439 elf32_arm_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
7441 if (hdr->sh_type == SHT_NOTE)
7442 *flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_CONTENTS;
7448 elf32_arm_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
7450 bfd_arm_update_notes (abfd, ARM_NOTE_SECTION);
7453 /* Return TRUE if this is an unwinding table entry. */
7456 is_arm_elf_unwind_section_name (bfd * abfd ATTRIBUTE_UNUSED, const char * name)
7460 len1 = sizeof (ELF_STRING_ARM_unwind) - 1;
7461 len2 = sizeof (ELF_STRING_ARM_unwind_once) - 1;
7462 return (strncmp (name, ELF_STRING_ARM_unwind, len1) == 0
7463 || strncmp (name, ELF_STRING_ARM_unwind_once, len2) == 0);
7467 /* Set the type and flags for an ARM section. We do this by
7468 the section name, which is a hack, but ought to work. */
7471 elf32_arm_fake_sections (bfd * abfd, Elf_Internal_Shdr * hdr, asection * sec)
7475 name = bfd_get_section_name (abfd, sec);
7477 if (is_arm_elf_unwind_section_name (abfd, name))
7479 hdr->sh_type = SHT_ARM_EXIDX;
7480 hdr->sh_flags |= SHF_LINK_ORDER;
7482 else if (strcmp(name, ".ARM.attributes") == 0)
7484 hdr->sh_type = SHT_ARM_ATTRIBUTES;
7489 /* Parse an Arm EABI attributes section. */
7491 elf32_arm_parse_attributes (bfd *abfd, Elf_Internal_Shdr * hdr)
7497 contents = bfd_malloc (hdr->sh_size);
7500 if (!bfd_get_section_contents (abfd, hdr->bfd_section, contents, 0,
7509 len = hdr->sh_size - 1;
7513 bfd_vma section_len;
7515 section_len = bfd_get_32 (abfd, p);
7517 if (section_len > len)
7520 namelen = strlen ((char *)p) + 1;
7521 section_len -= namelen + 4;
7522 if (strcmp((char *)p, "aeabi") != 0)
7524 /* Vendor section. Ignore it. */
7525 p += namelen + section_len;
7530 while (section_len > 0)
7535 bfd_vma subsection_len;
7538 tag = read_unsigned_leb128 (abfd, p, &n);
7540 subsection_len = bfd_get_32 (abfd, p);
7542 if (subsection_len > section_len)
7543 subsection_len = section_len;
7544 section_len -= subsection_len;
7545 subsection_len -= n + 4;
7546 end = p + subsection_len;
7552 bfd_boolean is_string;
7554 tag = read_unsigned_leb128 (abfd, p, &n);
7556 if (tag == 4 || tag == 5)
7561 is_string = (tag & 1) != 0;
7562 if (tag == Tag_compatibility)
7564 val = read_unsigned_leb128 (abfd, p, &n);
7566 elf32_arm_add_eabi_attr_compat (abfd, val,
7568 p += strlen ((char *)p) + 1;
7572 elf32_arm_add_eabi_attr_string (abfd, tag,
7574 p += strlen ((char *)p) + 1;
7578 val = read_unsigned_leb128 (abfd, p, &n);
7580 elf32_arm_add_eabi_attr_int (abfd, tag, val);
7586 /* Don't have anywhere convenient to attach these.
7587 Fall through for now. */
7589 /* Ignore things we don't kow about. */
7590 p += subsection_len;
7601 /* Handle an ARM specific section when reading an object file. This is
7602 called when bfd_section_from_shdr finds a section with an unknown
7606 elf32_arm_section_from_shdr (bfd *abfd,
7607 Elf_Internal_Shdr * hdr,
7611 /* There ought to be a place to keep ELF backend specific flags, but
7612 at the moment there isn't one. We just keep track of the
7613 sections by their name, instead. Fortunately, the ABI gives
7614 names for all the ARM specific sections, so we will probably get
7616 switch (hdr->sh_type)
7619 case SHT_ARM_PREEMPTMAP:
7620 case SHT_ARM_ATTRIBUTES:
7627 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
7630 if (hdr->sh_type == SHT_ARM_ATTRIBUTES)
7631 elf32_arm_parse_attributes(abfd, hdr);
7635 /* A structure used to record a list of sections, independently
7636 of the next and prev fields in the asection structure. */
7637 typedef struct section_list
7640 struct section_list * next;
7641 struct section_list * prev;
7645 /* Unfortunately we need to keep a list of sections for which
7646 an _arm_elf_section_data structure has been allocated. This
7647 is because it is possible for functions like elf32_arm_write_section
7648 to be called on a section which has had an elf_data_structure
7649 allocated for it (and so the used_by_bfd field is valid) but
7650 for which the ARM extended version of this structure - the
7651 _arm_elf_section_data structure - has not been allocated. */
7652 static section_list * sections_with_arm_elf_section_data = NULL;
7655 record_section_with_arm_elf_section_data (asection * sec)
7657 struct section_list * entry;
7659 entry = bfd_malloc (sizeof (* entry));
7663 entry->next = sections_with_arm_elf_section_data;
7665 if (entry->next != NULL)
7666 entry->next->prev = entry;
7667 sections_with_arm_elf_section_data = entry;
7670 static struct section_list *
7671 find_arm_elf_section_entry (asection * sec)
7673 struct section_list * entry;
7674 static struct section_list * last_entry = NULL;
7676 /* This is a short cut for the typical case where the sections are added
7677 to the sections_with_arm_elf_section_data list in forward order and
7678 then looked up here in backwards order. This makes a real difference
7679 to the ld-srec/sec64k.exp linker test. */
7680 entry = sections_with_arm_elf_section_data;
7681 if (last_entry != NULL)
7683 if (last_entry->sec == sec)
7685 else if (last_entry->next != NULL
7686 && last_entry->next->sec == sec)
7687 entry = last_entry->next;
7690 for (; entry; entry = entry->next)
7691 if (entry->sec == sec)
7695 /* Record the entry prior to this one - it is the entry we are most
7696 likely to want to locate next time. Also this way if we have been
7697 called from unrecord_section_with_arm_elf_section_data() we will not
7698 be caching a pointer that is about to be freed. */
7699 last_entry = entry->prev;
7704 static _arm_elf_section_data *
7705 get_arm_elf_section_data (asection * sec)
7707 struct section_list * entry;
7709 entry = find_arm_elf_section_entry (sec);
7712 return elf32_arm_section_data (entry->sec);
7718 unrecord_section_with_arm_elf_section_data (asection * sec)
7720 struct section_list * entry;
7722 entry = find_arm_elf_section_entry (sec);
7726 if (entry->prev != NULL)
7727 entry->prev->next = entry->next;
7728 if (entry->next != NULL)
7729 entry->next->prev = entry->prev;
7730 if (entry == sections_with_arm_elf_section_data)
7731 sections_with_arm_elf_section_data = entry->next;
7736 /* Called for each symbol. Builds a section map based on mapping symbols.
7737 Does not alter any of the symbols. */
7740 elf32_arm_output_symbol_hook (struct bfd_link_info *info,
7742 Elf_Internal_Sym *elfsym,
7743 asection *input_sec,
7744 struct elf_link_hash_entry *h)
7747 elf32_arm_section_map *map;
7748 elf32_arm_section_map *newmap;
7749 _arm_elf_section_data *arm_data;
7750 struct elf32_arm_link_hash_table *globals;
7752 globals = elf32_arm_hash_table (info);
7753 if (globals->vxworks_p
7754 && !elf_vxworks_link_output_symbol_hook (info, name, elfsym,
7758 /* Only do this on final link. */
7759 if (info->relocatable)
7762 /* Only build a map if we need to byteswap code. */
7763 if (!globals->byteswap_code)
7766 /* We only want mapping symbols. */
7767 if (! bfd_is_arm_mapping_symbol_name (name))
7770 /* If this section has not been allocated an _arm_elf_section_data
7771 structure then we cannot record anything. */
7772 arm_data = get_arm_elf_section_data (input_sec);
7773 if (arm_data == NULL)
7776 mapcount = arm_data->mapcount + 1;
7777 map = arm_data->map;
7779 /* TODO: This may be inefficient, but we probably don't usually have many
7780 mapping symbols per section. */
7781 newmap = bfd_realloc (map, mapcount * sizeof (* map));
7784 arm_data->map = newmap;
7785 arm_data->mapcount = mapcount;
7787 newmap[mapcount - 1].vma = elfsym->st_value;
7788 newmap[mapcount - 1].type = name[1];
7794 /* Allocate target specific section data. */
7797 elf32_arm_new_section_hook (bfd *abfd, asection *sec)
7799 _arm_elf_section_data *sdata;
7800 bfd_size_type amt = sizeof (*sdata);
7802 sdata = bfd_zalloc (abfd, amt);
7805 sec->used_by_bfd = sdata;
7807 record_section_with_arm_elf_section_data (sec);
7809 return _bfd_elf_new_section_hook (abfd, sec);
7813 /* Used to order a list of mapping symbols by address. */
7816 elf32_arm_compare_mapping (const void * a, const void * b)
7818 return ((const elf32_arm_section_map *) a)->vma
7819 > ((const elf32_arm_section_map *) b)->vma;
7823 /* Do code byteswapping. Return FALSE afterwards so that the section is
7824 written out as normal. */
7827 elf32_arm_write_section (bfd *output_bfd ATTRIBUTE_UNUSED, asection *sec,
7831 _arm_elf_section_data *arm_data;
7832 elf32_arm_section_map *map;
7839 /* If this section has not been allocated an _arm_elf_section_data
7840 structure then we cannot record anything. */
7841 arm_data = get_arm_elf_section_data (sec);
7842 if (arm_data == NULL)
7845 mapcount = arm_data->mapcount;
7846 map = arm_data->map;
7851 qsort (map, mapcount, sizeof (* map), elf32_arm_compare_mapping);
7853 offset = sec->output_section->vma + sec->output_offset;
7854 ptr = map[0].vma - offset;
7855 for (i = 0; i < mapcount; i++)
7857 if (i == mapcount - 1)
7860 end = map[i + 1].vma - offset;
7862 switch (map[i].type)
7865 /* Byte swap code words. */
7866 while (ptr + 3 < end)
7868 tmp = contents[ptr];
7869 contents[ptr] = contents[ptr + 3];
7870 contents[ptr + 3] = tmp;
7871 tmp = contents[ptr + 1];
7872 contents[ptr + 1] = contents[ptr + 2];
7873 contents[ptr + 2] = tmp;
7879 /* Byte swap code halfwords. */
7880 while (ptr + 1 < end)
7882 tmp = contents[ptr];
7883 contents[ptr] = contents[ptr + 1];
7884 contents[ptr + 1] = tmp;
7890 /* Leave data alone. */
7897 arm_data->mapcount = 0;
7898 arm_data->map = NULL;
7899 unrecord_section_with_arm_elf_section_data (sec);
7905 unrecord_section_via_map_over_sections (bfd * abfd ATTRIBUTE_UNUSED,
7907 void * ignore ATTRIBUTE_UNUSED)
7909 unrecord_section_with_arm_elf_section_data (sec);
7913 elf32_arm_close_and_cleanup (bfd * abfd)
7915 bfd_map_over_sections (abfd, unrecord_section_via_map_over_sections, NULL);
7917 return _bfd_elf_close_and_cleanup (abfd);
7920 /* Display STT_ARM_TFUNC symbols as functions. */
7923 elf32_arm_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
7926 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
7928 if (ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_ARM_TFUNC)
7929 elfsym->symbol.flags |= BSF_FUNCTION;
7933 /* Mangle thumb function symbols as we read them in. */
7936 elf32_arm_swap_symbol_in (bfd * abfd,
7939 Elf_Internal_Sym *dst)
7941 bfd_elf32_swap_symbol_in (abfd, psrc, pshn, dst);
7943 /* New EABI objects mark thumb function symbols by setting the low bit of
7944 the address. Turn these into STT_ARM_TFUNC. */
7945 if (ELF_ST_TYPE (dst->st_info) == STT_FUNC
7946 && (dst->st_value & 1))
7948 dst->st_info = ELF_ST_INFO (ELF_ST_BIND (dst->st_info), STT_ARM_TFUNC);
7949 dst->st_value &= ~(bfd_vma) 1;
7954 /* Mangle thumb function symbols as we write them out. */
7957 elf32_arm_swap_symbol_out (bfd *abfd,
7958 const Elf_Internal_Sym *src,
7962 Elf_Internal_Sym newsym;
7964 /* We convert STT_ARM_TFUNC symbols into STT_FUNC with the low bit
7965 of the address set, as per the new EABI. We do this unconditionally
7966 because objcopy does not set the elf header flags until after
7967 it writes out the symbol table. */
7968 if (ELF_ST_TYPE (src->st_info) == STT_ARM_TFUNC)
7971 newsym.st_info = ELF_ST_INFO (ELF_ST_BIND (src->st_info), STT_FUNC);
7972 newsym.st_value |= 1;
7976 bfd_elf32_swap_symbol_out (abfd, src, cdst, shndx);
7979 /* Add the PT_ARM_EXIDX program header. */
7982 elf32_arm_modify_segment_map (bfd *abfd,
7983 struct bfd_link_info *info ATTRIBUTE_UNUSED)
7985 struct elf_segment_map *m;
7988 sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
7989 if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
7991 /* If there is already a PT_ARM_EXIDX header, then we do not
7992 want to add another one. This situation arises when running
7993 "strip"; the input binary already has the header. */
7994 m = elf_tdata (abfd)->segment_map;
7995 while (m && m->p_type != PT_ARM_EXIDX)
7999 m = bfd_zalloc (abfd, sizeof (struct elf_segment_map));
8002 m->p_type = PT_ARM_EXIDX;
8004 m->sections[0] = sec;
8006 m->next = elf_tdata (abfd)->segment_map;
8007 elf_tdata (abfd)->segment_map = m;
8014 /* We may add a PT_ARM_EXIDX program header. */
8017 elf32_arm_additional_program_headers (bfd *abfd)
8021 sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
8022 if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
8028 /* We use this to override swap_symbol_in and swap_symbol_out. */
8029 const struct elf_size_info elf32_arm_size_info = {
8030 sizeof (Elf32_External_Ehdr),
8031 sizeof (Elf32_External_Phdr),
8032 sizeof (Elf32_External_Shdr),
8033 sizeof (Elf32_External_Rel),
8034 sizeof (Elf32_External_Rela),
8035 sizeof (Elf32_External_Sym),
8036 sizeof (Elf32_External_Dyn),
8037 sizeof (Elf_External_Note),
8041 ELFCLASS32, EV_CURRENT,
8042 bfd_elf32_write_out_phdrs,
8043 bfd_elf32_write_shdrs_and_ehdr,
8044 bfd_elf32_write_relocs,
8045 elf32_arm_swap_symbol_in,
8046 elf32_arm_swap_symbol_out,
8047 bfd_elf32_slurp_reloc_table,
8048 bfd_elf32_slurp_symbol_table,
8049 bfd_elf32_swap_dyn_in,
8050 bfd_elf32_swap_dyn_out,
8051 bfd_elf32_swap_reloc_in,
8052 bfd_elf32_swap_reloc_out,
8053 bfd_elf32_swap_reloca_in,
8054 bfd_elf32_swap_reloca_out
8057 #define ELF_ARCH bfd_arch_arm
8058 #define ELF_MACHINE_CODE EM_ARM
8059 #ifdef __QNXTARGET__
8060 #define ELF_MAXPAGESIZE 0x1000
8062 #define ELF_MAXPAGESIZE 0x8000
8064 #define ELF_MINPAGESIZE 0x1000
8066 #define bfd_elf32_mkobject elf32_arm_mkobject
8068 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
8069 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
8070 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
8071 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
8072 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
8073 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
8074 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
8075 #define bfd_elf32_find_inliner_info elf32_arm_find_inliner_info
8076 #define bfd_elf32_new_section_hook elf32_arm_new_section_hook
8077 #define bfd_elf32_bfd_is_target_special_symbol elf32_arm_is_target_special_symbol
8078 #define bfd_elf32_close_and_cleanup elf32_arm_close_and_cleanup
8079 #define bfd_elf32_bfd_final_link elf32_arm_bfd_final_link
8081 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
8082 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
8083 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
8084 #define elf_backend_check_relocs elf32_arm_check_relocs
8085 #define elf_backend_relocate_section elf32_arm_relocate_section
8086 #define elf_backend_write_section elf32_arm_write_section
8087 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
8088 #define elf_backend_create_dynamic_sections elf32_arm_create_dynamic_sections
8089 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
8090 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
8091 #define elf_backend_link_output_symbol_hook elf32_arm_output_symbol_hook
8092 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
8093 #define elf_backend_post_process_headers elf32_arm_post_process_headers
8094 #define elf_backend_reloc_type_class elf32_arm_reloc_type_class
8095 #define elf_backend_object_p elf32_arm_object_p
8096 #define elf_backend_section_flags elf32_arm_section_flags
8097 #define elf_backend_fake_sections elf32_arm_fake_sections
8098 #define elf_backend_section_from_shdr elf32_arm_section_from_shdr
8099 #define elf_backend_final_write_processing elf32_arm_final_write_processing
8100 #define elf_backend_copy_indirect_symbol elf32_arm_copy_indirect_symbol
8101 #define elf_backend_symbol_processing elf32_arm_symbol_processing
8102 #define elf_backend_size_info elf32_arm_size_info
8103 #define elf_backend_modify_segment_map elf32_arm_modify_segment_map
8104 #define elf_backend_additional_program_headers \
8105 elf32_arm_additional_program_headers
8107 #define elf_backend_can_refcount 1
8108 #define elf_backend_can_gc_sections 1
8109 #define elf_backend_plt_readonly 1
8110 #define elf_backend_want_got_plt 1
8111 #define elf_backend_want_plt_sym 0
8112 #define elf_backend_may_use_rel_p 1
8113 #define elf_backend_may_use_rela_p 0
8114 #define elf_backend_default_use_rela_p 0
8115 #define elf_backend_rela_normal 0
8117 #define elf_backend_got_header_size 12
8119 #include "elf32-target.h"
8121 /* VxWorks Targets */
8123 #undef TARGET_LITTLE_SYM
8124 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_vxworks_vec
8125 #undef TARGET_LITTLE_NAME
8126 #define TARGET_LITTLE_NAME "elf32-littlearm-vxworks"
8127 #undef TARGET_BIG_SYM
8128 #define TARGET_BIG_SYM bfd_elf32_bigarm_vxworks_vec
8129 #undef TARGET_BIG_NAME
8130 #define TARGET_BIG_NAME "elf32-bigarm-vxworks"
8132 /* Like elf32_arm_link_hash_table_create -- but overrides
8133 appropriately for VxWorks. */
8134 static struct bfd_link_hash_table *
8135 elf32_arm_vxworks_link_hash_table_create (bfd *abfd)
8137 struct bfd_link_hash_table *ret;
8139 ret = elf32_arm_link_hash_table_create (abfd);
8142 struct elf32_arm_link_hash_table *htab
8143 = (struct elf32_arm_link_hash_table *) ret;
8145 htab->vxworks_p = 1;
8151 elf32_arm_vxworks_final_write_processing (bfd *abfd, bfd_boolean linker)
8153 elf32_arm_final_write_processing (abfd, linker);
8154 elf_vxworks_final_write_processing (abfd, linker);
8158 #define elf32_bed elf32_arm_vxworks_bed
8160 #undef bfd_elf32_bfd_link_hash_table_create
8161 #define bfd_elf32_bfd_link_hash_table_create \
8162 elf32_arm_vxworks_link_hash_table_create
8163 #undef elf_backend_add_symbol_hook
8164 #define elf_backend_add_symbol_hook \
8165 elf_vxworks_add_symbol_hook
8166 #undef elf_backend_final_write_processing
8167 #define elf_backend_final_write_processing \
8168 elf32_arm_vxworks_final_write_processing
8169 #undef elf_backend_emit_relocs
8170 #define elf_backend_emit_relocs \
8171 elf_vxworks_emit_relocs
8173 #undef elf_backend_may_use_rel_p
8174 #define elf_backend_may_use_rel_p 0
8175 #undef elf_backend_may_use_rela_p
8176 #define elf_backend_may_use_rela_p 1
8177 #undef elf_backend_default_use_rela_p
8178 #define elf_backend_default_use_rela_p 1
8179 #undef elf_backend_rela_normal
8180 #define elf_backend_rela_normal 1
8181 #undef elf_backend_want_plt_sym
8182 #define elf_backend_want_plt_sym 1
8183 #undef ELF_MAXPAGESIZE
8184 #define ELF_MAXPAGESIZE 0x1000
8186 #include "elf32-target.h"
8189 /* Symbian OS Targets */
8191 #undef TARGET_LITTLE_SYM
8192 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_symbian_vec
8193 #undef TARGET_LITTLE_NAME
8194 #define TARGET_LITTLE_NAME "elf32-littlearm-symbian"
8195 #undef TARGET_BIG_SYM
8196 #define TARGET_BIG_SYM bfd_elf32_bigarm_symbian_vec
8197 #undef TARGET_BIG_NAME
8198 #define TARGET_BIG_NAME "elf32-bigarm-symbian"
8200 /* Like elf32_arm_link_hash_table_create -- but overrides
8201 appropriately for Symbian OS. */
8202 static struct bfd_link_hash_table *
8203 elf32_arm_symbian_link_hash_table_create (bfd *abfd)
8205 struct bfd_link_hash_table *ret;
8207 ret = elf32_arm_link_hash_table_create (abfd);
8210 struct elf32_arm_link_hash_table *htab
8211 = (struct elf32_arm_link_hash_table *)ret;
8212 /* There is no PLT header for Symbian OS. */
8213 htab->plt_header_size = 0;
8214 /* The PLT entries are each three instructions. */
8215 htab->plt_entry_size = 4 * NUM_ELEM (elf32_arm_symbian_plt_entry);
8216 htab->symbian_p = 1;
8217 /* Symbian uses armv5t or above, so use_blx is always true. */
8219 htab->root.is_relocatable_executable = 1;
8224 static const struct bfd_elf_special_section
8225 elf32_arm_symbian_special_sections[] =
8227 /* In a BPABI executable, the dynamic linking sections do not go in
8228 the loadable read-only segment. The post-linker may wish to
8229 refer to these sections, but they are not part of the final
8231 { ".dynamic", 8, 0, SHT_DYNAMIC, 0 },
8232 { ".dynstr", 7, 0, SHT_STRTAB, 0 },
8233 { ".dynsym", 7, 0, SHT_DYNSYM, 0 },
8234 { ".got", 4, 0, SHT_PROGBITS, 0 },
8235 { ".hash", 5, 0, SHT_HASH, 0 },
8236 /* These sections do not need to be writable as the SymbianOS
8237 postlinker will arrange things so that no dynamic relocation is
8239 { ".init_array", 11, 0, SHT_INIT_ARRAY, SHF_ALLOC },
8240 { ".fini_array", 11, 0, SHT_FINI_ARRAY, SHF_ALLOC },
8241 { ".preinit_array", 14, 0, SHT_PREINIT_ARRAY, SHF_ALLOC },
8242 { NULL, 0, 0, 0, 0 }
8246 elf32_arm_symbian_begin_write_processing (bfd *abfd,
8247 struct bfd_link_info *link_info
8250 /* BPABI objects are never loaded directly by an OS kernel; they are
8251 processed by a postlinker first, into an OS-specific format. If
8252 the D_PAGED bit is set on the file, BFD will align segments on
8253 page boundaries, so that an OS can directly map the file. With
8254 BPABI objects, that just results in wasted space. In addition,
8255 because we clear the D_PAGED bit, map_sections_to_segments will
8256 recognize that the program headers should not be mapped into any
8257 loadable segment. */
8258 abfd->flags &= ~D_PAGED;
8262 elf32_arm_symbian_modify_segment_map (bfd *abfd,
8263 struct bfd_link_info *info)
8265 struct elf_segment_map *m;
8268 /* BPABI shared libraries and executables should have a PT_DYNAMIC
8269 segment. However, because the .dynamic section is not marked
8270 with SEC_LOAD, the generic ELF code will not create such a
8272 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
8275 m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
8276 m->next = elf_tdata (abfd)->segment_map;
8277 elf_tdata (abfd)->segment_map = m;
8280 /* Also call the generic arm routine. */
8281 return elf32_arm_modify_segment_map (abfd, info);
8285 #define elf32_bed elf32_arm_symbian_bed
8287 /* The dynamic sections are not allocated on SymbianOS; the postlinker
8288 will process them and then discard them. */
8289 #undef ELF_DYNAMIC_SEC_FLAGS
8290 #define ELF_DYNAMIC_SEC_FLAGS \
8291 (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED)
8293 #undef bfd_elf32_bfd_link_hash_table_create
8294 #define bfd_elf32_bfd_link_hash_table_create \
8295 elf32_arm_symbian_link_hash_table_create
8296 #undef elf_backend_add_symbol_hook
8298 #undef elf_backend_special_sections
8299 #define elf_backend_special_sections elf32_arm_symbian_special_sections
8301 #undef elf_backend_begin_write_processing
8302 #define elf_backend_begin_write_processing \
8303 elf32_arm_symbian_begin_write_processing
8304 #undef elf_backend_final_write_processing
8305 #define elf_backend_final_write_processing \
8306 elf32_arm_final_write_processing
8307 #undef elf_backend_emit_relocs
8309 #undef elf_backend_modify_segment_map
8310 #define elf_backend_modify_segment_map elf32_arm_symbian_modify_segment_map
8312 /* There is no .got section for BPABI objects, and hence no header. */
8313 #undef elf_backend_got_header_size
8314 #define elf_backend_got_header_size 0
8316 /* Similarly, there is no .got.plt section. */
8317 #undef elf_backend_want_got_plt
8318 #define elf_backend_want_got_plt 0
8320 #undef elf_backend_may_use_rel_p
8321 #define elf_backend_may_use_rel_p 1
8322 #undef elf_backend_may_use_rela_p
8323 #define elf_backend_may_use_rela_p 0
8324 #undef elf_backend_default_use_rela_p
8325 #define elf_backend_default_use_rela_p 0
8326 #undef elf_backend_rela_normal
8327 #define elf_backend_rela_normal 0
8328 #undef elf_backend_want_plt_sym
8329 #define elf_backend_want_plt_sym 0
8330 #undef ELF_MAXPAGESIZE
8331 #define ELF_MAXPAGESIZE 0x8000
8333 #include "elf32-target.h"
projects / external / binutils.git / blob