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},
1369 {BFD_RELOC_ARM_MOVW, R_ARM_MOVW_ABS_NC},
1370 {BFD_RELOC_ARM_MOVT, R_ARM_MOVT_ABS},
1371 {BFD_RELOC_ARM_MOVW_PCREL, R_ARM_MOVW_PREL_NC},
1372 {BFD_RELOC_ARM_MOVT_PCREL, R_ARM_MOVT_PREL},
1373 {BFD_RELOC_ARM_THUMB_MOVW, R_ARM_THM_MOVW_ABS_NC},
1374 {BFD_RELOC_ARM_THUMB_MOVT, R_ARM_THM_MOVT_ABS},
1375 {BFD_RELOC_ARM_THUMB_MOVW_PCREL, R_ARM_THM_MOVW_PREL_NC},
1376 {BFD_RELOC_ARM_THUMB_MOVT_PCREL, R_ARM_THM_MOVT_PREL},
1379 static reloc_howto_type *
1380 elf32_arm_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1381 bfd_reloc_code_real_type code)
1384 for (i = 0; i < NUM_ELEM (elf32_arm_reloc_map); i ++)
1385 if (elf32_arm_reloc_map[i].bfd_reloc_val == code)
1386 return elf32_arm_howto_from_type (elf32_arm_reloc_map[i].elf_reloc_val);
1391 /* Support for core dump NOTE sections */
1393 elf32_arm_nabi_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
1398 switch (note->descsz)
1403 case 148: /* Linux/ARM 32-bit*/
1405 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
1408 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
1417 /* Make a ".reg/999" section. */
1418 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
1419 size, note->descpos + offset);
1423 elf32_arm_nabi_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
1425 switch (note->descsz)
1430 case 124: /* Linux/ARM elf_prpsinfo */
1431 elf_tdata (abfd)->core_program
1432 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
1433 elf_tdata (abfd)->core_command
1434 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
1437 /* Note that for some reason, a spurious space is tacked
1438 onto the end of the args in some (at least one anyway)
1439 implementations, so strip it off if it exists. */
1442 char *command = elf_tdata (abfd)->core_command;
1443 int n = strlen (command);
1445 if (0 < n && command[n - 1] == ' ')
1446 command[n - 1] = '\0';
1452 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_vec
1453 #define TARGET_LITTLE_NAME "elf32-littlearm"
1454 #define TARGET_BIG_SYM bfd_elf32_bigarm_vec
1455 #define TARGET_BIG_NAME "elf32-bigarm"
1457 #define elf_backend_grok_prstatus elf32_arm_nabi_grok_prstatus
1458 #define elf_backend_grok_psinfo elf32_arm_nabi_grok_psinfo
1460 typedef unsigned long int insn32;
1461 typedef unsigned short int insn16;
1463 /* In lieu of proper flags, assume all EABIv4 or later objects are
1465 #define INTERWORK_FLAG(abfd) \
1466 (EF_ARM_EABI_VERSION (elf_elfheader (abfd)->e_flags) >= EF_ARM_EABI_VER4 \
1467 || (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK))
1469 /* The linker script knows the section names for placement.
1470 The entry_names are used to do simple name mangling on the stubs.
1471 Given a function name, and its type, the stub can be found. The
1472 name can be changed. The only requirement is the %s be present. */
1473 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
1474 #define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
1476 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
1477 #define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
1479 /* The name of the dynamic interpreter. This is put in the .interp
1481 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
1483 #ifdef FOUR_WORD_PLT
1485 /* The first entry in a procedure linkage table looks like
1486 this. It is set up so that any shared library function that is
1487 called before the relocation has been set up calls the dynamic
1489 static const bfd_vma elf32_arm_plt0_entry [] =
1491 0xe52de004, /* str lr, [sp, #-4]! */
1492 0xe59fe010, /* ldr lr, [pc, #16] */
1493 0xe08fe00e, /* add lr, pc, lr */
1494 0xe5bef008, /* ldr pc, [lr, #8]! */
1497 /* Subsequent entries in a procedure linkage table look like
1499 static const bfd_vma elf32_arm_plt_entry [] =
1501 0xe28fc600, /* add ip, pc, #NN */
1502 0xe28cca00, /* add ip, ip, #NN */
1503 0xe5bcf000, /* ldr pc, [ip, #NN]! */
1504 0x00000000, /* unused */
1509 /* The first entry in a procedure linkage table looks like
1510 this. It is set up so that any shared library function that is
1511 called before the relocation has been set up calls the dynamic
1513 static const bfd_vma elf32_arm_plt0_entry [] =
1515 0xe52de004, /* str lr, [sp, #-4]! */
1516 0xe59fe004, /* ldr lr, [pc, #4] */
1517 0xe08fe00e, /* add lr, pc, lr */
1518 0xe5bef008, /* ldr pc, [lr, #8]! */
1519 0x00000000, /* &GOT[0] - . */
1522 /* Subsequent entries in a procedure linkage table look like
1524 static const bfd_vma elf32_arm_plt_entry [] =
1526 0xe28fc600, /* add ip, pc, #0xNN00000 */
1527 0xe28cca00, /* add ip, ip, #0xNN000 */
1528 0xe5bcf000, /* ldr pc, [ip, #0xNNN]! */
1533 /* The format of the first entry in the procedure linkage table
1534 for a VxWorks executable. */
1535 static const bfd_vma elf32_arm_vxworks_exec_plt0_entry[] =
1537 0xe52dc008, /* str ip,[sp,#-8]! */
1538 0xe59fc000, /* ldr ip,[pc] */
1539 0xe59cf008, /* ldr pc,[ip,#8] */
1540 0x00000000, /* .long _GLOBAL_OFFSET_TABLE_ */
1543 /* The format of subsequent entries in a VxWorks executable. */
1544 static const bfd_vma elf32_arm_vxworks_exec_plt_entry[] =
1546 0xe59fc000, /* ldr ip,[pc] */
1547 0xe59cf000, /* ldr pc,[ip] */
1548 0x00000000, /* .long @got */
1549 0xe59fc000, /* ldr ip,[pc] */
1550 0xea000000, /* b _PLT */
1551 0x00000000, /* .long @pltindex*sizeof(Elf32_Rela) */
1554 /* The format of entries in a VxWorks shared library. */
1555 static const bfd_vma elf32_arm_vxworks_shared_plt_entry[] =
1557 0xe59fc000, /* ldr ip,[pc] */
1558 0xe79cf009, /* ldr pc,[ip,r9] */
1559 0x00000000, /* .long @got */
1560 0xe59fc000, /* ldr ip,[pc] */
1561 0xe599f008, /* ldr pc,[r9,#8] */
1562 0x00000000, /* .long @pltindex*sizeof(Elf32_Rela) */
1565 /* An initial stub used if the PLT entry is referenced from Thumb code. */
1566 #define PLT_THUMB_STUB_SIZE 4
1567 static const bfd_vma elf32_arm_plt_thumb_stub [] =
1573 /* The entries in a PLT when using a DLL-based target with multiple
1575 static const bfd_vma elf32_arm_symbian_plt_entry [] =
1577 0xe51ff004, /* ldr pc, [pc, #-4] */
1578 0x00000000, /* dcd R_ARM_GLOB_DAT(X) */
1581 /* Used to build a map of a section. This is required for mixed-endian
1584 typedef struct elf32_elf_section_map
1589 elf32_arm_section_map;
1591 typedef struct _arm_elf_section_data
1593 struct bfd_elf_section_data elf;
1594 unsigned int mapcount;
1595 elf32_arm_section_map *map;
1597 _arm_elf_section_data;
1599 #define elf32_arm_section_data(sec) \
1600 ((_arm_elf_section_data *) elf_section_data (sec))
1602 /* The size of the thread control block. */
1605 #define NUM_KNOWN_ATTRIBUTES 32
1607 typedef struct aeabi_attribute
1614 typedef struct aeabi_attribute_list
1616 struct aeabi_attribute_list *next;
1618 aeabi_attribute attr;
1619 } aeabi_attribute_list;
1621 struct elf32_arm_obj_tdata
1623 struct elf_obj_tdata root;
1625 /* tls_type for each local got entry. */
1626 char *local_got_tls_type;
1628 aeabi_attribute known_eabi_attributes[NUM_KNOWN_ATTRIBUTES];
1629 aeabi_attribute_list *other_eabi_attributes;
1632 #define elf32_arm_tdata(abfd) \
1633 ((struct elf32_arm_obj_tdata *) (abfd)->tdata.any)
1635 #define elf32_arm_local_got_tls_type(abfd) \
1636 (elf32_arm_tdata (abfd)->local_got_tls_type)
1639 elf32_arm_mkobject (bfd *abfd)
1641 bfd_size_type amt = sizeof (struct elf32_arm_obj_tdata);
1642 abfd->tdata.any = bfd_zalloc (abfd, amt);
1643 if (abfd->tdata.any == NULL)
1648 /* The ARM linker needs to keep track of the number of relocs that it
1649 decides to copy in check_relocs for each symbol. This is so that
1650 it can discard PC relative relocs if it doesn't need them when
1651 linking with -Bsymbolic. We store the information in a field
1652 extending the regular ELF linker hash table. */
1654 /* This structure keeps track of the number of relocs we have copied
1655 for a given symbol. */
1656 struct elf32_arm_relocs_copied
1659 struct elf32_arm_relocs_copied * next;
1660 /* A section in dynobj. */
1662 /* Number of relocs copied in this section. */
1663 bfd_size_type count;
1664 /* Number of PC-relative relocs copied in this section. */
1665 bfd_size_type pc_count;
1668 #define elf32_arm_hash_entry(ent) ((struct elf32_arm_link_hash_entry *)(ent))
1670 /* Arm ELF linker hash entry. */
1671 struct elf32_arm_link_hash_entry
1673 struct elf_link_hash_entry root;
1675 /* Number of PC relative relocs copied for this symbol. */
1676 struct elf32_arm_relocs_copied * relocs_copied;
1678 /* We reference count Thumb references to a PLT entry separately,
1679 so that we can emit the Thumb trampoline only if needed. */
1680 bfd_signed_vma plt_thumb_refcount;
1682 /* Since PLT entries have variable size if the Thumb prologue is
1683 used, we need to record the index into .got.plt instead of
1684 recomputing it from the PLT offset. */
1685 bfd_signed_vma plt_got_offset;
1687 #define GOT_UNKNOWN 0
1688 #define GOT_NORMAL 1
1689 #define GOT_TLS_GD 2
1690 #define GOT_TLS_IE 4
1691 unsigned char tls_type;
1694 /* Traverse an arm ELF linker hash table. */
1695 #define elf32_arm_link_hash_traverse(table, func, info) \
1696 (elf_link_hash_traverse \
1698 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
1701 /* Get the ARM elf linker hash table from a link_info structure. */
1702 #define elf32_arm_hash_table(info) \
1703 ((struct elf32_arm_link_hash_table *) ((info)->hash))
1705 /* ARM ELF linker hash table. */
1706 struct elf32_arm_link_hash_table
1708 /* The main hash table. */
1709 struct elf_link_hash_table root;
1711 /* The size in bytes of the section containing the Thumb-to-ARM glue. */
1712 bfd_size_type thumb_glue_size;
1714 /* The size in bytes of the section containing the ARM-to-Thumb glue. */
1715 bfd_size_type arm_glue_size;
1717 /* An arbitrary input BFD chosen to hold the glue sections. */
1718 bfd * bfd_of_glue_owner;
1720 /* Nonzero to output a BE8 image. */
1723 /* Zero if R_ARM_TARGET1 means R_ARM_ABS32.
1724 Nonzero if R_ARM_TARGET1 means R_ARM_ABS32. */
1727 /* The relocation to use for R_ARM_TARGET2 relocations. */
1730 /* Nonzero to fix BX instructions for ARMv4 targets. */
1733 /* Nonzero if the ARM/Thumb BLX instructions are available for use. */
1736 /* The number of bytes in the initial entry in the PLT. */
1737 bfd_size_type plt_header_size;
1739 /* The number of bytes in the subsequent PLT etries. */
1740 bfd_size_type plt_entry_size;
1742 /* True if the target system is VxWorks. */
1745 /* True if the target system is Symbian OS. */
1748 /* True if the target uses REL relocations. */
1751 /* Short-cuts to get to dynamic linker sections. */
1760 /* The (unloaded but important) VxWorks .rela.plt.unloaded section. */
1763 /* Data for R_ARM_TLS_LDM32 relocations. */
1765 bfd_signed_vma refcount;
1769 /* Small local sym to section mapping cache. */
1770 struct sym_sec_cache sym_sec;
1772 /* For convenience in allocate_dynrelocs. */
1776 /* Create an entry in an ARM ELF linker hash table. */
1778 static struct bfd_hash_entry *
1779 elf32_arm_link_hash_newfunc (struct bfd_hash_entry * entry,
1780 struct bfd_hash_table * table,
1781 const char * string)
1783 struct elf32_arm_link_hash_entry * ret =
1784 (struct elf32_arm_link_hash_entry *) entry;
1786 /* Allocate the structure if it has not already been allocated by a
1788 if (ret == (struct elf32_arm_link_hash_entry *) NULL)
1789 ret = bfd_hash_allocate (table, sizeof (struct elf32_arm_link_hash_entry));
1791 return (struct bfd_hash_entry *) ret;
1793 /* Call the allocation method of the superclass. */
1794 ret = ((struct elf32_arm_link_hash_entry *)
1795 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1799 ret->relocs_copied = NULL;
1800 ret->tls_type = GOT_UNKNOWN;
1801 ret->plt_thumb_refcount = 0;
1802 ret->plt_got_offset = -1;
1805 return (struct bfd_hash_entry *) ret;
1808 /* Return true if NAME is the name of the relocation section associated
1812 reloc_section_p (struct elf32_arm_link_hash_table *htab,
1813 const char *name, asection *s)
1816 return strncmp (name, ".rel", 4) == 0 && strcmp (s->name, name + 4) == 0;
1818 return strncmp (name, ".rela", 5) == 0 && strcmp (s->name, name + 5) == 0;
1821 /* Create .got, .gotplt, and .rel(a).got sections in DYNOBJ, and set up
1822 shortcuts to them in our hash table. */
1825 create_got_section (bfd *dynobj, struct bfd_link_info *info)
1827 struct elf32_arm_link_hash_table *htab;
1829 htab = elf32_arm_hash_table (info);
1830 /* BPABI objects never have a GOT, or associated sections. */
1831 if (htab->symbian_p)
1834 if (! _bfd_elf_create_got_section (dynobj, info))
1837 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
1838 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1839 if (!htab->sgot || !htab->sgotplt)
1842 htab->srelgot = bfd_make_section_with_flags (dynobj,
1843 RELOC_SECTION (htab, ".got"),
1844 (SEC_ALLOC | SEC_LOAD
1847 | SEC_LINKER_CREATED
1849 if (htab->srelgot == NULL
1850 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
1855 /* Create .plt, .rel(a).plt, .got, .got.plt, .rel(a).got, .dynbss, and
1856 .rel(a).bss sections in DYNOBJ, and set up shortcuts to them in our
1860 elf32_arm_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
1862 struct elf32_arm_link_hash_table *htab;
1864 htab = elf32_arm_hash_table (info);
1865 if (!htab->sgot && !create_got_section (dynobj, info))
1868 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1871 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
1872 htab->srelplt = bfd_get_section_by_name (dynobj,
1873 RELOC_SECTION (htab, ".plt"));
1874 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
1876 htab->srelbss = bfd_get_section_by_name (dynobj,
1877 RELOC_SECTION (htab, ".bss"));
1879 if (htab->vxworks_p)
1881 if (!elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2))
1886 htab->plt_header_size = 0;
1887 htab->plt_entry_size
1888 = 4 * ARRAY_SIZE (elf32_arm_vxworks_shared_plt_entry);
1892 htab->plt_header_size
1893 = 4 * ARRAY_SIZE (elf32_arm_vxworks_exec_plt0_entry);
1894 htab->plt_entry_size
1895 = 4 * ARRAY_SIZE (elf32_arm_vxworks_exec_plt_entry);
1902 || (!info->shared && !htab->srelbss))
1908 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1911 elf32_arm_copy_indirect_symbol (struct bfd_link_info *info,
1912 struct elf_link_hash_entry *dir,
1913 struct elf_link_hash_entry *ind)
1915 struct elf32_arm_link_hash_entry *edir, *eind;
1917 edir = (struct elf32_arm_link_hash_entry *) dir;
1918 eind = (struct elf32_arm_link_hash_entry *) ind;
1920 if (eind->relocs_copied != NULL)
1922 if (edir->relocs_copied != NULL)
1924 struct elf32_arm_relocs_copied **pp;
1925 struct elf32_arm_relocs_copied *p;
1927 /* Add reloc counts against the indirect sym to the direct sym
1928 list. Merge any entries against the same section. */
1929 for (pp = &eind->relocs_copied; (p = *pp) != NULL; )
1931 struct elf32_arm_relocs_copied *q;
1933 for (q = edir->relocs_copied; q != NULL; q = q->next)
1934 if (q->section == p->section)
1936 q->pc_count += p->pc_count;
1937 q->count += p->count;
1944 *pp = edir->relocs_copied;
1947 edir->relocs_copied = eind->relocs_copied;
1948 eind->relocs_copied = NULL;
1951 /* Copy over PLT info. */
1952 edir->plt_thumb_refcount += eind->plt_thumb_refcount;
1953 eind->plt_thumb_refcount = 0;
1955 if (ind->root.type == bfd_link_hash_indirect
1956 && dir->got.refcount <= 0)
1958 edir->tls_type = eind->tls_type;
1959 eind->tls_type = GOT_UNKNOWN;
1962 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1965 /* Create an ARM elf linker hash table. */
1967 static struct bfd_link_hash_table *
1968 elf32_arm_link_hash_table_create (bfd *abfd)
1970 struct elf32_arm_link_hash_table *ret;
1971 bfd_size_type amt = sizeof (struct elf32_arm_link_hash_table);
1973 ret = bfd_malloc (amt);
1977 if (!_bfd_elf_link_hash_table_init (& ret->root, abfd,
1978 elf32_arm_link_hash_newfunc,
1979 sizeof (struct elf32_arm_link_hash_entry)))
1986 ret->sgotplt = NULL;
1987 ret->srelgot = NULL;
1989 ret->srelplt = NULL;
1990 ret->sdynbss = NULL;
1991 ret->srelbss = NULL;
1992 ret->srelplt2 = NULL;
1993 ret->thumb_glue_size = 0;
1994 ret->arm_glue_size = 0;
1995 ret->bfd_of_glue_owner = NULL;
1996 ret->byteswap_code = 0;
1997 ret->target1_is_rel = 0;
1998 ret->target2_reloc = R_ARM_NONE;
1999 #ifdef FOUR_WORD_PLT
2000 ret->plt_header_size = 16;
2001 ret->plt_entry_size = 16;
2003 ret->plt_header_size = 20;
2004 ret->plt_entry_size = 12;
2011 ret->sym_sec.abfd = NULL;
2013 ret->tls_ldm_got.refcount = 0;
2015 return &ret->root.root;
2018 /* Locate the Thumb encoded calling stub for NAME. */
2020 static struct elf_link_hash_entry *
2021 find_thumb_glue (struct bfd_link_info *link_info,
2026 struct elf_link_hash_entry *hash;
2027 struct elf32_arm_link_hash_table *hash_table;
2029 /* We need a pointer to the armelf specific hash table. */
2030 hash_table = elf32_arm_hash_table (link_info);
2032 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
2033 + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
2035 BFD_ASSERT (tmp_name);
2037 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
2039 hash = elf_link_hash_lookup
2040 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
2043 /* xgettext:c-format */
2044 (*_bfd_error_handler) (_("%B: unable to find THUMB glue '%s' for `%s'"),
2045 input_bfd, tmp_name, name);
2052 /* Locate the ARM encoded calling stub for NAME. */
2054 static struct elf_link_hash_entry *
2055 find_arm_glue (struct bfd_link_info *link_info,
2060 struct elf_link_hash_entry *myh;
2061 struct elf32_arm_link_hash_table *hash_table;
2063 /* We need a pointer to the elfarm specific hash table. */
2064 hash_table = elf32_arm_hash_table (link_info);
2066 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
2067 + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
2069 BFD_ASSERT (tmp_name);
2071 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
2073 myh = elf_link_hash_lookup
2074 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
2077 /* xgettext:c-format */
2078 (*_bfd_error_handler) (_("%B: unable to find ARM glue '%s' for `%s'"),
2079 input_bfd, tmp_name, name);
2086 /* ARM->Thumb glue (static images):
2090 ldr r12, __func_addr
2093 .word func @ behave as if you saw a ARM_32 reloc.
2095 (relocatable images)
2098 ldr r12, __func_offset
2105 #define ARM2THUMB_STATIC_GLUE_SIZE 12
2106 static const insn32 a2t1_ldr_insn = 0xe59fc000;
2107 static const insn32 a2t2_bx_r12_insn = 0xe12fff1c;
2108 static const insn32 a2t3_func_addr_insn = 0x00000001;
2110 #define ARM2THUMB_PIC_GLUE_SIZE 16
2111 static const insn32 a2t1p_ldr_insn = 0xe59fc004;
2112 static const insn32 a2t2p_add_pc_insn = 0xe08cc00f;
2113 static const insn32 a2t3p_bx_r12_insn = 0xe12fff1c;
2115 /* Thumb->ARM: Thumb->(non-interworking aware) ARM
2119 __func_from_thumb: __func_from_thumb:
2121 nop ldr r6, __func_addr
2123 __func_change_to_arm: bx r6
2125 __func_back_to_thumb:
2131 #define THUMB2ARM_GLUE_SIZE 8
2132 static const insn16 t2a1_bx_pc_insn = 0x4778;
2133 static const insn16 t2a2_noop_insn = 0x46c0;
2134 static const insn32 t2a3_b_insn = 0xea000000;
2136 #ifndef ELFARM_NABI_C_INCLUDED
2138 bfd_elf32_arm_allocate_interworking_sections (struct bfd_link_info * info)
2142 struct elf32_arm_link_hash_table * globals;
2144 globals = elf32_arm_hash_table (info);
2146 BFD_ASSERT (globals != NULL);
2148 if (globals->arm_glue_size != 0)
2150 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2152 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
2153 ARM2THUMB_GLUE_SECTION_NAME);
2155 BFD_ASSERT (s != NULL);
2157 foo = bfd_alloc (globals->bfd_of_glue_owner, globals->arm_glue_size);
2159 s->size = globals->arm_glue_size;
2163 if (globals->thumb_glue_size != 0)
2165 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2167 s = bfd_get_section_by_name
2168 (globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
2170 BFD_ASSERT (s != NULL);
2172 foo = bfd_alloc (globals->bfd_of_glue_owner, globals->thumb_glue_size);
2174 s->size = globals->thumb_glue_size;
2182 record_arm_to_thumb_glue (struct bfd_link_info * link_info,
2183 struct elf_link_hash_entry * h)
2185 const char * name = h->root.root.string;
2188 struct elf_link_hash_entry * myh;
2189 struct bfd_link_hash_entry * bh;
2190 struct elf32_arm_link_hash_table * globals;
2193 globals = elf32_arm_hash_table (link_info);
2195 BFD_ASSERT (globals != NULL);
2196 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2198 s = bfd_get_section_by_name
2199 (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
2201 BFD_ASSERT (s != NULL);
2203 tmp_name = bfd_malloc ((bfd_size_type) strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
2205 BFD_ASSERT (tmp_name);
2207 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
2209 myh = elf_link_hash_lookup
2210 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
2214 /* We've already seen this guy. */
2219 /* The only trick here is using hash_table->arm_glue_size as the value.
2220 Even though the section isn't allocated yet, this is where we will be
2223 val = globals->arm_glue_size + 1;
2224 _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner,
2225 tmp_name, BSF_GLOBAL, s, val,
2226 NULL, TRUE, FALSE, &bh);
2228 myh = (struct elf_link_hash_entry *) bh;
2229 myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
2230 myh->forced_local = 1;
2234 if ((link_info->shared || globals->root.is_relocatable_executable))
2235 globals->arm_glue_size += ARM2THUMB_PIC_GLUE_SIZE;
2237 globals->arm_glue_size += ARM2THUMB_STATIC_GLUE_SIZE;
2243 record_thumb_to_arm_glue (struct bfd_link_info *link_info,
2244 struct elf_link_hash_entry *h)
2246 const char *name = h->root.root.string;
2249 struct elf_link_hash_entry *myh;
2250 struct bfd_link_hash_entry *bh;
2251 struct elf32_arm_link_hash_table *hash_table;
2254 hash_table = elf32_arm_hash_table (link_info);
2256 BFD_ASSERT (hash_table != NULL);
2257 BFD_ASSERT (hash_table->bfd_of_glue_owner != NULL);
2259 s = bfd_get_section_by_name
2260 (hash_table->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
2262 BFD_ASSERT (s != NULL);
2264 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
2265 + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
2267 BFD_ASSERT (tmp_name);
2269 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
2271 myh = elf_link_hash_lookup
2272 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
2276 /* We've already seen this guy. */
2282 val = hash_table->thumb_glue_size + 1;
2283 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
2284 tmp_name, BSF_GLOBAL, s, val,
2285 NULL, TRUE, FALSE, &bh);
2287 /* If we mark it 'Thumb', the disassembler will do a better job. */
2288 myh = (struct elf_link_hash_entry *) bh;
2289 myh->type = ELF_ST_INFO (STB_LOCAL, STT_ARM_TFUNC);
2290 myh->forced_local = 1;
2294 #define CHANGE_TO_ARM "__%s_change_to_arm"
2295 #define BACK_FROM_ARM "__%s_back_from_arm"
2297 /* Allocate another symbol to mark where we switch to Arm mode. */
2298 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
2299 + strlen (CHANGE_TO_ARM) + 1);
2301 BFD_ASSERT (tmp_name);
2303 sprintf (tmp_name, CHANGE_TO_ARM, name);
2306 val = hash_table->thumb_glue_size + 4,
2307 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
2308 tmp_name, BSF_LOCAL, s, val,
2309 NULL, TRUE, FALSE, &bh);
2313 hash_table->thumb_glue_size += THUMB2ARM_GLUE_SIZE;
2318 /* Add the glue sections to ABFD. This function is called from the
2319 linker scripts in ld/emultempl/{armelf}.em. */
2322 bfd_elf32_arm_add_glue_sections_to_bfd (bfd *abfd,
2323 struct bfd_link_info *info)
2328 /* If we are only performing a partial
2329 link do not bother adding the glue. */
2330 if (info->relocatable)
2333 sec = bfd_get_section_by_name (abfd, ARM2THUMB_GLUE_SECTION_NAME);
2337 /* Note: we do not include the flag SEC_LINKER_CREATED, as this
2338 will prevent elf_link_input_bfd() from processing the contents
2340 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE | SEC_READONLY;
2342 sec = bfd_make_section_with_flags (abfd,
2343 ARM2THUMB_GLUE_SECTION_NAME,
2347 || !bfd_set_section_alignment (abfd, sec, 2))
2350 /* Set the gc mark to prevent the section from being removed by garbage
2351 collection, despite the fact that no relocs refer to this section. */
2355 sec = bfd_get_section_by_name (abfd, THUMB2ARM_GLUE_SECTION_NAME);
2359 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2360 | SEC_CODE | SEC_READONLY;
2362 sec = bfd_make_section_with_flags (abfd,
2363 THUMB2ARM_GLUE_SECTION_NAME,
2367 || !bfd_set_section_alignment (abfd, sec, 2))
2376 /* Select a BFD to be used to hold the sections used by the glue code.
2377 This function is called from the linker scripts in ld/emultempl/
2381 bfd_elf32_arm_get_bfd_for_interworking (bfd *abfd, struct bfd_link_info *info)
2383 struct elf32_arm_link_hash_table *globals;
2385 /* If we are only performing a partial link
2386 do not bother getting a bfd to hold the glue. */
2387 if (info->relocatable)
2390 /* Make sure we don't attach the glue sections to a dynamic object. */
2391 BFD_ASSERT (!(abfd->flags & DYNAMIC));
2393 globals = elf32_arm_hash_table (info);
2395 BFD_ASSERT (globals != NULL);
2397 if (globals->bfd_of_glue_owner != NULL)
2400 /* Save the bfd for later use. */
2401 globals->bfd_of_glue_owner = abfd;
2406 static void check_use_blx(struct elf32_arm_link_hash_table *globals)
2408 if (elf32_arm_get_eabi_attr_int (globals->obfd, Tag_CPU_arch) > 2)
2409 globals->use_blx = 1;
2413 bfd_elf32_arm_process_before_allocation (bfd *abfd,
2414 struct bfd_link_info *link_info,
2417 Elf_Internal_Shdr *symtab_hdr;
2418 Elf_Internal_Rela *internal_relocs = NULL;
2419 Elf_Internal_Rela *irel, *irelend;
2420 bfd_byte *contents = NULL;
2423 struct elf32_arm_link_hash_table *globals;
2425 /* If we are only performing a partial link do not bother
2426 to construct any glue. */
2427 if (link_info->relocatable)
2430 /* Here we have a bfd that is to be included on the link. We have a hook
2431 to do reloc rummaging, before section sizes are nailed down. */
2432 globals = elf32_arm_hash_table (link_info);
2433 check_use_blx (globals);
2435 BFD_ASSERT (globals != NULL);
2436 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2438 if (byteswap_code && !bfd_big_endian (abfd))
2440 _bfd_error_handler (_("%B: BE8 images only valid in big-endian mode."),
2444 globals->byteswap_code = byteswap_code;
2446 /* Rummage around all the relocs and map the glue vectors. */
2447 sec = abfd->sections;
2452 for (; sec != NULL; sec = sec->next)
2454 if (sec->reloc_count == 0)
2457 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2459 /* Load the relocs. */
2461 = _bfd_elf_link_read_relocs (abfd, sec, (void *) NULL,
2462 (Elf_Internal_Rela *) NULL, FALSE);
2464 if (internal_relocs == NULL)
2467 irelend = internal_relocs + sec->reloc_count;
2468 for (irel = internal_relocs; irel < irelend; irel++)
2471 unsigned long r_index;
2473 struct elf_link_hash_entry *h;
2475 r_type = ELF32_R_TYPE (irel->r_info);
2476 r_index = ELF32_R_SYM (irel->r_info);
2478 /* These are the only relocation types we care about. */
2479 if ( r_type != R_ARM_PC24
2480 && r_type != R_ARM_PLT32
2481 && r_type != R_ARM_CALL
2482 && r_type != R_ARM_JUMP24
2483 && r_type != R_ARM_THM_CALL)
2486 /* Get the section contents if we haven't done so already. */
2487 if (contents == NULL)
2489 /* Get cached copy if it exists. */
2490 if (elf_section_data (sec)->this_hdr.contents != NULL)
2491 contents = elf_section_data (sec)->this_hdr.contents;
2494 /* Go get them off disk. */
2495 if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2500 /* If the relocation is not against a symbol it cannot concern us. */
2503 /* We don't care about local symbols. */
2504 if (r_index < symtab_hdr->sh_info)
2507 /* This is an external symbol. */
2508 r_index -= symtab_hdr->sh_info;
2509 h = (struct elf_link_hash_entry *)
2510 elf_sym_hashes (abfd)[r_index];
2512 /* If the relocation is against a static symbol it must be within
2513 the current section and so cannot be a cross ARM/Thumb relocation. */
2517 /* If the call will go through a PLT entry then we do not need
2519 if (globals->splt != NULL && h->plt.offset != (bfd_vma) -1)
2528 /* This one is a call from arm code. We need to look up
2529 the target of the call. If it is a thumb target, we
2531 if (ELF_ST_TYPE(h->type) == STT_ARM_TFUNC
2532 && !(r_type == R_ARM_CALL && globals->use_blx))
2533 record_arm_to_thumb_glue (link_info, h);
2536 case R_ARM_THM_CALL:
2537 /* This one is a call from thumb code. We look
2538 up the target of the call. If it is not a thumb
2539 target, we insert glue. */
2540 if (ELF_ST_TYPE (h->type) != STT_ARM_TFUNC && !globals->use_blx)
2541 record_thumb_to_arm_glue (link_info, h);
2549 if (contents != NULL
2550 && elf_section_data (sec)->this_hdr.contents != contents)
2554 if (internal_relocs != NULL
2555 && elf_section_data (sec)->relocs != internal_relocs)
2556 free (internal_relocs);
2557 internal_relocs = NULL;
2563 if (contents != NULL
2564 && elf_section_data (sec)->this_hdr.contents != contents)
2566 if (internal_relocs != NULL
2567 && elf_section_data (sec)->relocs != internal_relocs)
2568 free (internal_relocs);
2575 /* Set target relocation values needed during linking. */
2578 bfd_elf32_arm_set_target_relocs (struct bfd_link_info *link_info,
2580 char * target2_type,
2584 struct elf32_arm_link_hash_table *globals;
2586 globals = elf32_arm_hash_table (link_info);
2588 globals->target1_is_rel = target1_is_rel;
2589 if (strcmp (target2_type, "rel") == 0)
2590 globals->target2_reloc = R_ARM_REL32;
2591 else if (strcmp (target2_type, "abs") == 0)
2592 globals->target2_reloc = R_ARM_ABS32;
2593 else if (strcmp (target2_type, "got-rel") == 0)
2594 globals->target2_reloc = R_ARM_GOT_PREL;
2597 _bfd_error_handler (_("Invalid TARGET2 relocation type '%s'."),
2600 globals->fix_v4bx = fix_v4bx;
2601 globals->use_blx |= use_blx;
2604 /* The thumb form of a long branch is a bit finicky, because the offset
2605 encoding is split over two fields, each in it's own instruction. They
2606 can occur in any order. So given a thumb form of long branch, and an
2607 offset, insert the offset into the thumb branch and return finished
2610 It takes two thumb instructions to encode the target address. Each has
2611 11 bits to invest. The upper 11 bits are stored in one (identified by
2612 H-0.. see below), the lower 11 bits are stored in the other (identified
2615 Combine together and shifted left by 1 (it's a half word address) and
2619 H-0, upper address-0 = 000
2621 H-1, lower address-0 = 800
2623 They can be ordered either way, but the arm tools I've seen always put
2624 the lower one first. It probably doesn't matter. krk@cygnus.com
2626 XXX: Actually the order does matter. The second instruction (H-1)
2627 moves the computed address into the PC, so it must be the second one
2628 in the sequence. The problem, however is that whilst little endian code
2629 stores the instructions in HI then LOW order, big endian code does the
2630 reverse. nickc@cygnus.com. */
2632 #define LOW_HI_ORDER 0xF800F000
2633 #define HI_LOW_ORDER 0xF000F800
2636 insert_thumb_branch (insn32 br_insn, int rel_off)
2638 unsigned int low_bits;
2639 unsigned int high_bits;
2641 BFD_ASSERT ((rel_off & 1) != 1);
2643 rel_off >>= 1; /* Half word aligned address. */
2644 low_bits = rel_off & 0x000007FF; /* The bottom 11 bits. */
2645 high_bits = (rel_off >> 11) & 0x000007FF; /* The top 11 bits. */
2647 if ((br_insn & LOW_HI_ORDER) == LOW_HI_ORDER)
2648 br_insn = LOW_HI_ORDER | (low_bits << 16) | high_bits;
2649 else if ((br_insn & HI_LOW_ORDER) == HI_LOW_ORDER)
2650 br_insn = HI_LOW_ORDER | (high_bits << 16) | low_bits;
2652 /* FIXME: abort is probably not the right call. krk@cygnus.com */
2653 abort (); /* Error - not a valid branch instruction form. */
2658 /* Thumb code calling an ARM function. */
2661 elf32_thumb_to_arm_stub (struct bfd_link_info * info,
2665 asection * input_section,
2666 bfd_byte * hit_data,
2669 bfd_signed_vma addend,
2674 unsigned long int tmp;
2675 long int ret_offset;
2676 struct elf_link_hash_entry * myh;
2677 struct elf32_arm_link_hash_table * globals;
2679 myh = find_thumb_glue (info, name, input_bfd);
2683 globals = elf32_arm_hash_table (info);
2685 BFD_ASSERT (globals != NULL);
2686 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2688 my_offset = myh->root.u.def.value;
2690 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
2691 THUMB2ARM_GLUE_SECTION_NAME);
2693 BFD_ASSERT (s != NULL);
2694 BFD_ASSERT (s->contents != NULL);
2695 BFD_ASSERT (s->output_section != NULL);
2697 if ((my_offset & 0x01) == 0x01)
2700 && sym_sec->owner != NULL
2701 && !INTERWORK_FLAG (sym_sec->owner))
2703 (*_bfd_error_handler)
2704 (_("%B(%s): warning: interworking not enabled.\n"
2705 " first occurrence: %B: thumb call to arm"),
2706 sym_sec->owner, input_bfd, name);
2712 myh->root.u.def.value = my_offset;
2714 bfd_put_16 (output_bfd, (bfd_vma) t2a1_bx_pc_insn,
2715 s->contents + my_offset);
2717 bfd_put_16 (output_bfd, (bfd_vma) t2a2_noop_insn,
2718 s->contents + my_offset + 2);
2721 /* Address of destination of the stub. */
2722 ((bfd_signed_vma) val)
2724 /* Offset from the start of the current section
2725 to the start of the stubs. */
2727 /* Offset of the start of this stub from the start of the stubs. */
2729 /* Address of the start of the current section. */
2730 + s->output_section->vma)
2731 /* The branch instruction is 4 bytes into the stub. */
2733 /* ARM branches work from the pc of the instruction + 8. */
2736 bfd_put_32 (output_bfd,
2737 (bfd_vma) t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
2738 s->contents + my_offset + 4);
2741 BFD_ASSERT (my_offset <= globals->thumb_glue_size);
2743 /* Now go back and fix up the original BL insn to point to here. */
2745 /* Address of where the stub is located. */
2746 (s->output_section->vma + s->output_offset + my_offset)
2747 /* Address of where the BL is located. */
2748 - (input_section->output_section->vma + input_section->output_offset
2750 /* Addend in the relocation. */
2752 /* Biassing for PC-relative addressing. */
2755 tmp = bfd_get_32 (input_bfd, hit_data
2756 - input_section->vma);
2758 bfd_put_32 (output_bfd,
2759 (bfd_vma) insert_thumb_branch (tmp, ret_offset),
2760 hit_data - input_section->vma);
2765 /* Arm code calling a Thumb function. */
2768 elf32_arm_to_thumb_stub (struct bfd_link_info * info,
2772 asection * input_section,
2773 bfd_byte * hit_data,
2776 bfd_signed_vma addend,
2779 unsigned long int tmp;
2782 long int ret_offset;
2783 struct elf_link_hash_entry * myh;
2784 struct elf32_arm_link_hash_table * globals;
2786 myh = find_arm_glue (info, name, input_bfd);
2790 globals = elf32_arm_hash_table (info);
2792 BFD_ASSERT (globals != NULL);
2793 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2795 my_offset = myh->root.u.def.value;
2796 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
2797 ARM2THUMB_GLUE_SECTION_NAME);
2798 BFD_ASSERT (s != NULL);
2799 BFD_ASSERT (s->contents != NULL);
2800 BFD_ASSERT (s->output_section != NULL);
2802 if ((my_offset & 0x01) == 0x01)
2805 && sym_sec->owner != NULL
2806 && !INTERWORK_FLAG (sym_sec->owner))
2808 (*_bfd_error_handler)
2809 (_("%B(%s): warning: interworking not enabled.\n"
2810 " first occurrence: %B: arm call to thumb"),
2811 sym_sec->owner, input_bfd, name);
2815 myh->root.u.def.value = my_offset;
2817 if ((info->shared || globals->root.is_relocatable_executable))
2819 /* For relocatable objects we can't use absolute addresses,
2820 so construct the address from a relative offset. */
2821 /* TODO: If the offset is small it's probably worth
2822 constructing the address with adds. */
2823 bfd_put_32 (output_bfd, (bfd_vma) a2t1p_ldr_insn,
2824 s->contents + my_offset);
2825 bfd_put_32 (output_bfd, (bfd_vma) a2t2p_add_pc_insn,
2826 s->contents + my_offset + 4);
2827 bfd_put_32 (output_bfd, (bfd_vma) a2t3p_bx_r12_insn,
2828 s->contents + my_offset + 8);
2829 /* Adjust the offset by 4 for the position of the add,
2830 and 8 for the pipeline offset. */
2831 ret_offset = (val - (s->output_offset
2832 + s->output_section->vma
2835 bfd_put_32 (output_bfd, ret_offset,
2836 s->contents + my_offset + 12);
2840 bfd_put_32 (output_bfd, (bfd_vma) a2t1_ldr_insn,
2841 s->contents + my_offset);
2843 bfd_put_32 (output_bfd, (bfd_vma) a2t2_bx_r12_insn,
2844 s->contents + my_offset + 4);
2846 /* It's a thumb address. Add the low order bit. */
2847 bfd_put_32 (output_bfd, val | a2t3_func_addr_insn,
2848 s->contents + my_offset + 8);
2852 BFD_ASSERT (my_offset <= globals->arm_glue_size);
2854 tmp = bfd_get_32 (input_bfd, hit_data);
2855 tmp = tmp & 0xFF000000;
2857 /* Somehow these are both 4 too far, so subtract 8. */
2858 ret_offset = (s->output_offset
2860 + s->output_section->vma
2861 - (input_section->output_offset
2862 + input_section->output_section->vma
2866 tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
2868 bfd_put_32 (output_bfd, (bfd_vma) tmp, hit_data - input_section->vma);
2873 /* Some relocations map to different relocations depending on the
2874 target. Return the real relocation. */
2876 arm_real_reloc_type (struct elf32_arm_link_hash_table * globals,
2882 if (globals->target1_is_rel)
2888 return globals->target2_reloc;
2895 /* Return the base VMA address which should be subtracted from real addresses
2896 when resolving @dtpoff relocation.
2897 This is PT_TLS segment p_vaddr. */
2900 dtpoff_base (struct bfd_link_info *info)
2902 /* If tls_sec is NULL, we should have signalled an error already. */
2903 if (elf_hash_table (info)->tls_sec == NULL)
2905 return elf_hash_table (info)->tls_sec->vma;
2908 /* Return the relocation value for @tpoff relocation
2909 if STT_TLS virtual address is ADDRESS. */
2912 tpoff (struct bfd_link_info *info, bfd_vma address)
2914 struct elf_link_hash_table *htab = elf_hash_table (info);
2917 /* If tls_sec is NULL, we should have signalled an error already. */
2918 if (htab->tls_sec == NULL)
2920 base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power);
2921 return address - htab->tls_sec->vma + base;
2924 /* Perform an R_ARM_ABS12 relocation on the field pointed to by DATA.
2925 VALUE is the relocation value. */
2927 static bfd_reloc_status_type
2928 elf32_arm_abs12_reloc (bfd *abfd, void *data, bfd_vma value)
2931 return bfd_reloc_overflow;
2933 value |= bfd_get_32 (abfd, data) & 0xfffff000;
2934 bfd_put_32 (abfd, value, data);
2935 return bfd_reloc_ok;
2938 /* Perform a relocation as part of a final link. */
2940 static bfd_reloc_status_type
2941 elf32_arm_final_link_relocate (reloc_howto_type * howto,
2944 asection * input_section,
2945 bfd_byte * contents,
2946 Elf_Internal_Rela * rel,
2948 struct bfd_link_info * info,
2950 const char * sym_name,
2952 struct elf_link_hash_entry * h,
2953 bfd_boolean * unresolved_reloc_p)
2955 unsigned long r_type = howto->type;
2956 unsigned long r_symndx;
2957 bfd_byte * hit_data = contents + rel->r_offset;
2958 bfd * dynobj = NULL;
2959 Elf_Internal_Shdr * symtab_hdr;
2960 struct elf_link_hash_entry ** sym_hashes;
2961 bfd_vma * local_got_offsets;
2962 asection * sgot = NULL;
2963 asection * splt = NULL;
2964 asection * sreloc = NULL;
2966 bfd_signed_vma signed_addend;
2967 struct elf32_arm_link_hash_table * globals;
2969 globals = elf32_arm_hash_table (info);
2971 /* Some relocation type map to different relocations depending on the
2972 target. We pick the right one here. */
2973 r_type = arm_real_reloc_type (globals, r_type);
2974 if (r_type != howto->type)
2975 howto = elf32_arm_howto_from_type (r_type);
2977 /* If the start address has been set, then set the EF_ARM_HASENTRY
2978 flag. Setting this more than once is redundant, but the cost is
2979 not too high, and it keeps the code simple.
2981 The test is done here, rather than somewhere else, because the
2982 start address is only set just before the final link commences.
2984 Note - if the user deliberately sets a start address of 0, the
2985 flag will not be set. */
2986 if (bfd_get_start_address (output_bfd) != 0)
2987 elf_elfheader (output_bfd)->e_flags |= EF_ARM_HASENTRY;
2989 dynobj = elf_hash_table (info)->dynobj;
2992 sgot = bfd_get_section_by_name (dynobj, ".got");
2993 splt = bfd_get_section_by_name (dynobj, ".plt");
2995 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
2996 sym_hashes = elf_sym_hashes (input_bfd);
2997 local_got_offsets = elf_local_got_offsets (input_bfd);
2998 r_symndx = ELF32_R_SYM (rel->r_info);
3000 if (globals->use_rel)
3002 addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask;
3004 if (addend & ((howto->src_mask + 1) >> 1))
3007 signed_addend &= ~ howto->src_mask;
3008 signed_addend |= addend;
3011 signed_addend = addend;
3014 addend = signed_addend = rel->r_addend;
3019 /* We don't need to find a value for this symbol. It's just a
3021 *unresolved_reloc_p = FALSE;
3022 return bfd_reloc_ok;
3025 if (!globals->vxworks_p)
3026 return elf32_arm_abs12_reloc (input_bfd, hit_data, value + addend);
3036 /* r_symndx will be zero only for relocs against symbols
3037 from removed linkonce sections, or sections discarded by
3040 return bfd_reloc_ok;
3042 /* Handle relocations which should use the PLT entry. ABS32/REL32
3043 will use the symbol's value, which may point to a PLT entry, but we
3044 don't need to handle that here. If we created a PLT entry, all
3045 branches in this object should go to it. */
3046 if ((r_type != R_ARM_ABS32 && r_type != R_ARM_REL32)
3049 && h->plt.offset != (bfd_vma) -1)
3051 /* If we've created a .plt section, and assigned a PLT entry to
3052 this function, it should not be known to bind locally. If
3053 it were, we would have cleared the PLT entry. */
3054 BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info, h));
3056 value = (splt->output_section->vma
3057 + splt->output_offset
3059 *unresolved_reloc_p = FALSE;
3060 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3061 contents, rel->r_offset, value,
3065 /* When generating a shared object or relocatable executable, these
3066 relocations are copied into the output file to be resolved at
3068 if ((info->shared || globals->root.is_relocatable_executable)
3069 && (input_section->flags & SEC_ALLOC)
3070 && (r_type != R_ARM_REL32
3071 || !SYMBOL_CALLS_LOCAL (info, h))
3073 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3074 || h->root.type != bfd_link_hash_undefweak)
3075 && r_type != R_ARM_PC24
3076 && r_type != R_ARM_CALL
3077 && r_type != R_ARM_JUMP24
3078 && r_type != R_ARM_PREL31
3079 && r_type != R_ARM_PLT32)
3081 Elf_Internal_Rela outrel;
3083 bfd_boolean skip, relocate;
3085 *unresolved_reloc_p = FALSE;
3091 name = (bfd_elf_string_from_elf_section
3093 elf_elfheader (input_bfd)->e_shstrndx,
3094 elf_section_data (input_section)->rel_hdr.sh_name));
3096 return bfd_reloc_notsupported;
3098 BFD_ASSERT (reloc_section_p (globals, name, input_section));
3100 sreloc = bfd_get_section_by_name (dynobj, name);
3101 BFD_ASSERT (sreloc != NULL);
3107 outrel.r_addend = addend;
3109 _bfd_elf_section_offset (output_bfd, info, input_section,
3111 if (outrel.r_offset == (bfd_vma) -1)
3113 else if (outrel.r_offset == (bfd_vma) -2)
3114 skip = TRUE, relocate = TRUE;
3115 outrel.r_offset += (input_section->output_section->vma
3116 + input_section->output_offset);
3119 memset (&outrel, 0, sizeof outrel);
3124 || !h->def_regular))
3125 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3130 /* This symbol is local, or marked to become local. */
3131 if (sym_flags == STT_ARM_TFUNC)
3133 if (globals->symbian_p)
3135 /* On Symbian OS, the data segment and text segement
3136 can be relocated independently. Therefore, we
3137 must indicate the segment to which this
3138 relocation is relative. The BPABI allows us to
3139 use any symbol in the right segment; we just use
3140 the section symbol as it is convenient. (We
3141 cannot use the symbol given by "h" directly as it
3142 will not appear in the dynamic symbol table.) */
3144 symbol = elf_section_data (sym_sec->output_section)->dynindx;
3146 symbol = elf_section_data (input_section->output_section)->dynindx;
3147 BFD_ASSERT (symbol != 0);
3150 /* On SVR4-ish systems, the dynamic loader cannot
3151 relocate the text and data segments independently,
3152 so the symbol does not matter. */
3154 outrel.r_info = ELF32_R_INFO (symbol, R_ARM_RELATIVE);
3155 if (globals->use_rel)
3158 outrel.r_addend += value;
3161 loc = sreloc->contents;
3162 loc += sreloc->reloc_count++ * RELOC_SIZE (globals);
3163 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
3165 /* If this reloc is against an external symbol, we do not want to
3166 fiddle with the addend. Otherwise, we need to include the symbol
3167 value so that it becomes an addend for the dynamic reloc. */
3169 return bfd_reloc_ok;
3171 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3172 contents, rel->r_offset, value,
3175 else switch (r_type)
3178 return elf32_arm_abs12_reloc (input_bfd, hit_data, value + addend);
3180 case R_ARM_XPC25: /* Arm BLX instruction. */
3183 case R_ARM_PC24: /* Arm B/BL instruction */
3185 if (r_type == R_ARM_XPC25)
3187 /* Check for Arm calling Arm function. */
3188 /* FIXME: Should we translate the instruction into a BL
3189 instruction instead ? */
3190 if (sym_flags != STT_ARM_TFUNC)
3191 (*_bfd_error_handler)
3192 (_("\%B: Warning: Arm BLX instruction targets Arm function '%s'."),
3194 h ? h->root.root.string : "(local)");
3196 else if (r_type != R_ARM_CALL || !globals->use_blx)
3198 /* Check for Arm calling Thumb function. */
3199 if (sym_flags == STT_ARM_TFUNC)
3201 elf32_arm_to_thumb_stub (info, sym_name, input_bfd,
3202 output_bfd, input_section,
3203 hit_data, sym_sec, rel->r_offset,
3204 signed_addend, value);
3205 return bfd_reloc_ok;
3209 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
3211 S is the address of the symbol in the relocation.
3212 P is address of the instruction being relocated.
3213 A is the addend (extracted from the instruction) in bytes.
3215 S is held in 'value'.
3216 P is the base address of the section containing the
3217 instruction plus the offset of the reloc into that
3219 (input_section->output_section->vma +
3220 input_section->output_offset +
3222 A is the addend, converted into bytes, ie:
3225 Note: None of these operations have knowledge of the pipeline
3226 size of the processor, thus it is up to the assembler to
3227 encode this information into the addend. */
3228 value -= (input_section->output_section->vma
3229 + input_section->output_offset);
3230 value -= rel->r_offset;
3231 if (globals->use_rel)
3232 value += (signed_addend << howto->size);
3234 /* RELA addends do not have to be adjusted by howto->size. */
3235 value += signed_addend;
3237 signed_addend = value;
3238 signed_addend >>= howto->rightshift;
3240 /* It is not an error for an undefined weak reference to be
3241 out of range. Any program that branches to such a symbol
3242 is going to crash anyway, so there is no point worrying
3243 about getting the destination exactly right. */
3244 if (! h || h->root.type != bfd_link_hash_undefweak)
3246 /* Perform a signed range check. */
3247 if ( signed_addend > ((bfd_signed_vma) (howto->dst_mask >> 1))
3248 || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1)))
3249 return bfd_reloc_overflow;
3252 addend = (value & 2);
3254 value = (signed_addend & howto->dst_mask)
3255 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
3257 /* Set the H bit in the BLX instruction. */
3258 if (sym_flags == STT_ARM_TFUNC)
3263 value &= ~(bfd_vma)(1 << 24);
3265 if (r_type == R_ARM_CALL)
3267 /* Select the correct instruction (BL or BLX). */
3268 if (sym_flags == STT_ARM_TFUNC)
3272 value &= ~(bfd_vma)(1 << 28);
3280 if (sym_flags == STT_ARM_TFUNC)
3286 if (sym_flags == STT_ARM_TFUNC)
3288 value -= (input_section->output_section->vma
3289 + input_section->output_offset + rel->r_offset);
3293 value -= (input_section->output_section->vma
3294 + input_section->output_offset + rel->r_offset);
3295 value += signed_addend;
3296 if (! h || h->root.type != bfd_link_hash_undefweak)
3298 /* Check for overflow */
3299 if ((value ^ (value >> 1)) & (1 << 30))
3300 return bfd_reloc_overflow;
3302 value &= 0x7fffffff;
3303 value |= (bfd_get_32 (input_bfd, hit_data) & 0x80000000);
3304 if (sym_flags == STT_ARM_TFUNC)
3309 bfd_put_32 (input_bfd, value, hit_data);
3310 return bfd_reloc_ok;
3314 if ((long) value > 0x7f || (long) value < -0x80)
3315 return bfd_reloc_overflow;
3317 bfd_put_8 (input_bfd, value, hit_data);
3318 return bfd_reloc_ok;
3323 if ((long) value > 0x7fff || (long) value < -0x8000)
3324 return bfd_reloc_overflow;
3326 bfd_put_16 (input_bfd, value, hit_data);
3327 return bfd_reloc_ok;
3329 case R_ARM_THM_ABS5:
3330 /* Support ldr and str instructions for the thumb. */
3331 if (globals->use_rel)
3333 /* Need to refetch addend. */
3334 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
3335 /* ??? Need to determine shift amount from operand size. */
3336 addend >>= howto->rightshift;
3340 /* ??? Isn't value unsigned? */
3341 if ((long) value > 0x1f || (long) value < -0x10)
3342 return bfd_reloc_overflow;
3344 /* ??? Value needs to be properly shifted into place first. */
3345 value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
3346 bfd_put_16 (input_bfd, value, hit_data);
3347 return bfd_reloc_ok;
3349 case R_ARM_THM_XPC22:
3350 case R_ARM_THM_CALL:
3351 /* Thumb BL (branch long instruction). */
3354 bfd_boolean overflow = FALSE;
3355 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
3356 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
3357 bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
3358 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
3360 bfd_signed_vma signed_check;
3362 /* Need to refetch the addend and squish the two 11 bit pieces
3364 if (globals->use_rel)
3366 bfd_vma upper = upper_insn & 0x7ff;
3367 bfd_vma lower = lower_insn & 0x7ff;
3368 upper = (upper ^ 0x400) - 0x400; /* Sign extend. */
3369 addend = (upper << 12) | (lower << 1);
3370 signed_addend = addend;
3373 if (r_type == R_ARM_THM_XPC22)
3375 /* Check for Thumb to Thumb call. */
3376 /* FIXME: Should we translate the instruction into a BL
3377 instruction instead ? */
3378 if (sym_flags == STT_ARM_TFUNC)
3379 (*_bfd_error_handler)
3380 (_("%B: Warning: Thumb BLX instruction targets thumb function '%s'."),
3382 h ? h->root.root.string : "(local)");
3386 /* If it is not a call to Thumb, assume call to Arm.
3387 If it is a call relative to a section name, then it is not a
3388 function call at all, but rather a long jump. Calls through
3389 the PLT do not require stubs. */
3390 if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION
3391 && (h == NULL || splt == NULL
3392 || h->plt.offset == (bfd_vma) -1))
3394 if (globals->use_blx)
3396 /* Convert BL to BLX. */
3397 lower_insn = (lower_insn & ~0x1000) | 0x0800;
3399 else if (elf32_thumb_to_arm_stub
3400 (info, sym_name, input_bfd, output_bfd, input_section,
3401 hit_data, sym_sec, rel->r_offset, signed_addend, value))
3402 return bfd_reloc_ok;
3404 return bfd_reloc_dangerous;
3406 else if (sym_flags == STT_ARM_TFUNC && globals->use_blx)
3408 /* Make sure this is a BL. */
3409 lower_insn |= 0x1800;
3413 /* Handle calls via the PLT. */
3414 if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
3416 value = (splt->output_section->vma
3417 + splt->output_offset
3419 if (globals->use_blx)
3421 /* If the Thumb BLX instruction is available, convert the
3422 BL to a BLX instruction to call the ARM-mode PLT entry. */
3423 lower_insn = (lower_insn & ~0x1000) | 0x0800;
3426 /* Target the Thumb stub before the ARM PLT entry. */
3427 value -= PLT_THUMB_STUB_SIZE;
3428 *unresolved_reloc_p = FALSE;
3431 relocation = value + signed_addend;
3433 relocation -= (input_section->output_section->vma
3434 + input_section->output_offset
3437 check = relocation >> howto->rightshift;
3439 /* If this is a signed value, the rightshift just dropped
3440 leading 1 bits (assuming twos complement). */
3441 if ((bfd_signed_vma) relocation >= 0)
3442 signed_check = check;
3444 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
3446 /* Assumes two's complement. */
3447 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
3450 if ((lower_insn & 0x1800) == 0x0800)
3451 /* For a BLX instruction, make sure that the relocation is rounded up
3452 to a word boundary. This follows the semantics of the instruction
3453 which specifies that bit 1 of the target address will come from bit
3454 1 of the base address. */
3455 relocation = (relocation + 2) & ~ 3;
3457 /* Put RELOCATION back into the insn. */
3458 upper_insn = (upper_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 12) & 0x7ff);
3459 lower_insn = (lower_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 1) & 0x7ff);
3461 /* Put the relocated value back in the object file: */
3462 bfd_put_16 (input_bfd, upper_insn, hit_data);
3463 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
3465 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
3469 case R_ARM_THM_JUMP24:
3470 /* Thumb32 unconditional branch instruction. */
3473 bfd_boolean overflow = FALSE;
3474 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
3475 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
3476 bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
3477 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
3479 bfd_signed_vma signed_check;
3481 /* Need to refetch the addend, reconstruct the top three bits, and glue the
3482 two pieces together. */
3483 if (globals->use_rel)
3485 bfd_vma S = (upper_insn & 0x0400) >> 10;
3486 bfd_vma hi = (upper_insn & 0x03ff);
3487 bfd_vma I1 = (lower_insn & 0x2000) >> 13;
3488 bfd_vma I2 = (lower_insn & 0x0800) >> 11;
3489 bfd_vma lo = (lower_insn & 0x07ff);
3495 signed_addend = (S << 24) | (I1 << 23) | (I2 << 22) | (hi << 12) | (lo << 1);
3496 signed_addend -= (1 << 24); /* Sign extend. */
3499 /* ??? Should handle interworking? GCC might someday try to
3500 use this for tail calls. */
3502 relocation = value + signed_addend;
3503 relocation -= (input_section->output_section->vma
3504 + input_section->output_offset
3507 check = relocation >> howto->rightshift;
3509 /* If this is a signed value, the rightshift just dropped
3510 leading 1 bits (assuming twos complement). */
3511 if ((bfd_signed_vma) relocation >= 0)
3512 signed_check = check;
3514 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
3516 /* Assumes two's complement. */
3517 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
3520 /* Put RELOCATION back into the insn. */
3522 bfd_vma S = (relocation & 0x01000000) >> 24;
3523 bfd_vma I1 = (relocation & 0x00800000) >> 23;
3524 bfd_vma I2 = (relocation & 0x00400000) >> 22;
3525 bfd_vma hi = (relocation & 0x003ff000) >> 12;
3526 bfd_vma lo = (relocation & 0x00000ffe) >> 1;
3531 upper_insn = (upper_insn & (bfd_vma) 0xf800) | (S << 10) | hi;
3532 lower_insn = (lower_insn & (bfd_vma) 0xd000) | (I1 << 13) | (I2 << 11) | lo;
3535 /* Put the relocated value back in the object file: */
3536 bfd_put_16 (input_bfd, upper_insn, hit_data);
3537 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
3539 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
3542 case R_ARM_THM_JUMP19:
3543 /* Thumb32 conditional branch instruction. */
3546 bfd_boolean overflow = FALSE;
3547 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
3548 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
3549 bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
3550 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
3552 bfd_signed_vma signed_check;
3554 /* Need to refetch the addend, reconstruct the top three bits,
3555 and squish the two 11 bit pieces together. */
3556 if (globals->use_rel)
3558 bfd_vma S = (upper_insn & 0x0400) >> 10;
3559 bfd_vma upper = (upper_insn & 0x001f);
3560 bfd_vma J1 = (lower_insn & 0x2000) >> 13;
3561 bfd_vma J2 = (lower_insn & 0x0800) >> 11;
3562 bfd_vma lower = (lower_insn & 0x07ff);
3567 upper -= 0x0100; /* Sign extend. */
3569 addend = (upper << 12) | (lower << 1);
3570 signed_addend = addend;
3573 /* ??? Should handle interworking? GCC might someday try to
3574 use this for tail calls. */
3576 relocation = value + signed_addend;
3577 relocation -= (input_section->output_section->vma
3578 + input_section->output_offset
3581 check = relocation >> howto->rightshift;
3583 /* If this is a signed value, the rightshift just dropped
3584 leading 1 bits (assuming twos complement). */
3585 if ((bfd_signed_vma) relocation >= 0)
3586 signed_check = check;
3588 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
3590 /* Assumes two's complement. */
3591 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
3594 /* Put RELOCATION back into the insn. */
3596 bfd_vma S = (relocation & 0x00100000) >> 20;
3597 bfd_vma J2 = (relocation & 0x00080000) >> 19;
3598 bfd_vma J1 = (relocation & 0x00040000) >> 18;
3599 bfd_vma hi = (relocation & 0x0003f000) >> 12;
3600 bfd_vma lo = (relocation & 0x00000ffe) >> 1;
3602 upper_insn = (upper_insn & 0xfb30) | (S << 10) | hi;
3603 lower_insn = (lower_insn & 0xd000) | (J1 << 13) | (J2 << 11) | lo;
3606 /* Put the relocated value back in the object file: */
3607 bfd_put_16 (input_bfd, upper_insn, hit_data);
3608 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
3610 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
3613 case R_ARM_THM_JUMP11:
3614 case R_ARM_THM_JUMP8:
3615 case R_ARM_THM_JUMP6:
3616 /* Thumb B (branch) instruction). */
3618 bfd_signed_vma relocation;
3619 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
3620 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
3621 bfd_signed_vma signed_check;
3623 /* CZB cannot jump backward. */
3624 if (r_type == R_ARM_THM_JUMP6)
3625 reloc_signed_min = 0;
3627 if (globals->use_rel)
3629 /* Need to refetch addend. */
3630 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
3631 if (addend & ((howto->src_mask + 1) >> 1))
3634 signed_addend &= ~ howto->src_mask;
3635 signed_addend |= addend;
3638 signed_addend = addend;
3639 /* The value in the insn has been right shifted. We need to
3640 undo this, so that we can perform the address calculation
3641 in terms of bytes. */
3642 signed_addend <<= howto->rightshift;
3644 relocation = value + signed_addend;
3646 relocation -= (input_section->output_section->vma
3647 + input_section->output_offset
3650 relocation >>= howto->rightshift;
3651 signed_check = relocation;
3653 if (r_type == R_ARM_THM_JUMP6)
3654 relocation = ((relocation & 0x0020) << 4) | ((relocation & 0x001f) << 3);
3656 relocation &= howto->dst_mask;
3657 relocation |= (bfd_get_16 (input_bfd, hit_data) & (~ howto->dst_mask));
3659 bfd_put_16 (input_bfd, relocation, hit_data);
3661 /* Assumes two's complement. */
3662 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
3663 return bfd_reloc_overflow;
3665 return bfd_reloc_ok;
3668 case R_ARM_ALU_PCREL7_0:
3669 case R_ARM_ALU_PCREL15_8:
3670 case R_ARM_ALU_PCREL23_15:
3675 insn = bfd_get_32 (input_bfd, hit_data);
3676 if (globals->use_rel)
3678 /* Extract the addend. */
3679 addend = (insn & 0xff) << ((insn & 0xf00) >> 7);
3680 signed_addend = addend;
3682 relocation = value + signed_addend;
3684 relocation -= (input_section->output_section->vma
3685 + input_section->output_offset
3687 insn = (insn & ~0xfff)
3688 | ((howto->bitpos << 7) & 0xf00)
3689 | ((relocation >> howto->bitpos) & 0xff);
3690 bfd_put_32 (input_bfd, value, hit_data);
3692 return bfd_reloc_ok;
3694 case R_ARM_GNU_VTINHERIT:
3695 case R_ARM_GNU_VTENTRY:
3696 return bfd_reloc_ok;
3698 case R_ARM_GOTOFF32:
3699 /* Relocation is relative to the start of the
3700 global offset table. */
3702 BFD_ASSERT (sgot != NULL);
3704 return bfd_reloc_notsupported;
3706 /* If we are addressing a Thumb function, we need to adjust the
3707 address by one, so that attempts to call the function pointer will
3708 correctly interpret it as Thumb code. */
3709 if (sym_flags == STT_ARM_TFUNC)
3712 /* Note that sgot->output_offset is not involved in this
3713 calculation. We always want the start of .got. If we
3714 define _GLOBAL_OFFSET_TABLE in a different way, as is
3715 permitted by the ABI, we might have to change this
3717 value -= sgot->output_section->vma;
3718 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3719 contents, rel->r_offset, value,
3723 /* Use global offset table as symbol value. */
3724 BFD_ASSERT (sgot != NULL);
3727 return bfd_reloc_notsupported;
3729 *unresolved_reloc_p = FALSE;
3730 value = sgot->output_section->vma;
3731 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3732 contents, rel->r_offset, value,
3736 case R_ARM_GOT_PREL:
3737 /* Relocation is to the entry for this symbol in the
3738 global offset table. */
3740 return bfd_reloc_notsupported;
3747 off = h->got.offset;
3748 BFD_ASSERT (off != (bfd_vma) -1);
3749 dyn = globals->root.dynamic_sections_created;
3751 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3753 && SYMBOL_REFERENCES_LOCAL (info, h))
3754 || (ELF_ST_VISIBILITY (h->other)
3755 && h->root.type == bfd_link_hash_undefweak))
3757 /* This is actually a static link, or it is a -Bsymbolic link
3758 and the symbol is defined locally. We must initialize this
3759 entry in the global offset table. Since the offset must
3760 always be a multiple of 4, we use the least significant bit
3761 to record whether we have initialized it already.
3763 When doing a dynamic link, we create a .rel(a).got relocation
3764 entry to initialize the value. This is done in the
3765 finish_dynamic_symbol routine. */
3770 /* If we are addressing a Thumb function, we need to
3771 adjust the address by one, so that attempts to
3772 call the function pointer will correctly
3773 interpret it as Thumb code. */
3774 if (sym_flags == STT_ARM_TFUNC)
3777 bfd_put_32 (output_bfd, value, sgot->contents + off);
3782 *unresolved_reloc_p = FALSE;
3784 value = sgot->output_offset + off;
3790 BFD_ASSERT (local_got_offsets != NULL &&
3791 local_got_offsets[r_symndx] != (bfd_vma) -1);
3793 off = local_got_offsets[r_symndx];
3795 /* The offset must always be a multiple of 4. We use the
3796 least significant bit to record whether we have already
3797 generated the necessary reloc. */
3802 /* If we are addressing a Thumb function, we need to
3803 adjust the address by one, so that attempts to
3804 call the function pointer will correctly
3805 interpret it as Thumb code. */
3806 if (sym_flags == STT_ARM_TFUNC)
3809 if (globals->use_rel)
3810 bfd_put_32 (output_bfd, value, sgot->contents + off);
3815 Elf_Internal_Rela outrel;
3818 srelgot = (bfd_get_section_by_name
3819 (dynobj, RELOC_SECTION (globals, ".got")));
3820 BFD_ASSERT (srelgot != NULL);
3822 outrel.r_addend = addend + value;
3823 outrel.r_offset = (sgot->output_section->vma
3824 + sgot->output_offset
3826 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
3827 loc = srelgot->contents;
3828 loc += srelgot->reloc_count++ * RELOC_SIZE (globals);
3829 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
3832 local_got_offsets[r_symndx] |= 1;
3835 value = sgot->output_offset + off;
3837 if (r_type != R_ARM_GOT32)
3838 value += sgot->output_section->vma;
3840 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3841 contents, rel->r_offset, value,
3844 case R_ARM_TLS_LDO32:
3845 value = value - dtpoff_base (info);
3847 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3848 contents, rel->r_offset, value,
3851 case R_ARM_TLS_LDM32:
3855 if (globals->sgot == NULL)
3858 off = globals->tls_ldm_got.offset;
3864 /* If we don't know the module number, create a relocation
3868 Elf_Internal_Rela outrel;
3871 if (globals->srelgot == NULL)
3874 outrel.r_addend = 0;
3875 outrel.r_offset = (globals->sgot->output_section->vma
3876 + globals->sgot->output_offset + off);
3877 outrel.r_info = ELF32_R_INFO (0, R_ARM_TLS_DTPMOD32);
3879 if (globals->use_rel)
3880 bfd_put_32 (output_bfd, outrel.r_addend,
3881 globals->sgot->contents + off);
3883 loc = globals->srelgot->contents;
3884 loc += globals->srelgot->reloc_count++ * RELOC_SIZE (globals);
3885 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
3888 bfd_put_32 (output_bfd, 1, globals->sgot->contents + off);
3890 globals->tls_ldm_got.offset |= 1;
3893 value = globals->sgot->output_section->vma + globals->sgot->output_offset + off
3894 - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
3896 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3897 contents, rel->r_offset, value,
3901 case R_ARM_TLS_GD32:
3902 case R_ARM_TLS_IE32:
3908 if (globals->sgot == NULL)
3915 dyn = globals->root.dynamic_sections_created;
3916 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3918 || !SYMBOL_REFERENCES_LOCAL (info, h)))
3920 *unresolved_reloc_p = FALSE;
3923 off = h->got.offset;
3924 tls_type = ((struct elf32_arm_link_hash_entry *) h)->tls_type;
3928 if (local_got_offsets == NULL)
3930 off = local_got_offsets[r_symndx];
3931 tls_type = elf32_arm_local_got_tls_type (input_bfd)[r_symndx];
3934 if (tls_type == GOT_UNKNOWN)
3941 bfd_boolean need_relocs = FALSE;
3942 Elf_Internal_Rela outrel;
3943 bfd_byte *loc = NULL;
3946 /* The GOT entries have not been initialized yet. Do it
3947 now, and emit any relocations. If both an IE GOT and a
3948 GD GOT are necessary, we emit the GD first. */
3950 if ((info->shared || indx != 0)
3952 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3953 || h->root.type != bfd_link_hash_undefweak))
3956 if (globals->srelgot == NULL)
3958 loc = globals->srelgot->contents;
3959 loc += globals->srelgot->reloc_count * RELOC_SIZE (globals);
3962 if (tls_type & GOT_TLS_GD)
3966 outrel.r_addend = 0;
3967 outrel.r_offset = (globals->sgot->output_section->vma
3968 + globals->sgot->output_offset
3970 outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_DTPMOD32);
3972 if (globals->use_rel)
3973 bfd_put_32 (output_bfd, outrel.r_addend,
3974 globals->sgot->contents + cur_off);
3976 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
3977 globals->srelgot->reloc_count++;
3978 loc += RELOC_SIZE (globals);
3981 bfd_put_32 (output_bfd, value - dtpoff_base (info),
3982 globals->sgot->contents + cur_off + 4);
3985 outrel.r_addend = 0;
3986 outrel.r_info = ELF32_R_INFO (indx,
3987 R_ARM_TLS_DTPOFF32);
3988 outrel.r_offset += 4;
3990 if (globals->use_rel)
3991 bfd_put_32 (output_bfd, outrel.r_addend,
3992 globals->sgot->contents + cur_off + 4);
3995 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
3996 globals->srelgot->reloc_count++;
3997 loc += RELOC_SIZE (globals);
4002 /* If we are not emitting relocations for a
4003 general dynamic reference, then we must be in a
4004 static link or an executable link with the
4005 symbol binding locally. Mark it as belonging
4006 to module 1, the executable. */
4007 bfd_put_32 (output_bfd, 1,
4008 globals->sgot->contents + cur_off);
4009 bfd_put_32 (output_bfd, value - dtpoff_base (info),
4010 globals->sgot->contents + cur_off + 4);
4016 if (tls_type & GOT_TLS_IE)
4021 outrel.r_addend = value - dtpoff_base (info);
4023 outrel.r_addend = 0;
4024 outrel.r_offset = (globals->sgot->output_section->vma
4025 + globals->sgot->output_offset
4027 outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_TPOFF32);
4029 if (globals->use_rel)
4030 bfd_put_32 (output_bfd, outrel.r_addend,
4031 globals->sgot->contents + cur_off);
4033 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
4034 globals->srelgot->reloc_count++;
4035 loc += RELOC_SIZE (globals);
4038 bfd_put_32 (output_bfd, tpoff (info, value),
4039 globals->sgot->contents + cur_off);
4046 local_got_offsets[r_symndx] |= 1;
4049 if ((tls_type & GOT_TLS_GD) && r_type != R_ARM_TLS_GD32)
4051 value = globals->sgot->output_section->vma + globals->sgot->output_offset + off
4052 - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
4054 return _bfd_final_link_relocate (howto, input_bfd, input_section,
4055 contents, rel->r_offset, value,
4059 case R_ARM_TLS_LE32:
4062 (*_bfd_error_handler)
4063 (_("%B(%A+0x%lx): R_ARM_TLS_LE32 relocation not permitted in shared object"),
4064 input_bfd, input_section,
4065 (long) rel->r_offset, howto->name);
4069 value = tpoff (info, value);
4071 return _bfd_final_link_relocate (howto, input_bfd, input_section,
4072 contents, rel->r_offset, value,
4076 if (globals->fix_v4bx)
4078 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
4080 /* Ensure that we have a BX instruction. */
4081 BFD_ASSERT ((insn & 0x0ffffff0) == 0x012fff10);
4083 /* Preserve Rm (lowest four bits) and the condition code
4084 (highest four bits). Other bits encode MOV PC,Rm. */
4085 insn = (insn & 0xf000000f) | 0x01a0f000;
4087 bfd_put_32 (input_bfd, insn, hit_data);
4089 return bfd_reloc_ok;
4091 case R_ARM_MOVW_ABS_NC:
4092 case R_ARM_MOVT_ABS:
4093 case R_ARM_MOVW_PREL_NC:
4094 case R_ARM_MOVT_PREL:
4096 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
4098 if (globals->use_rel)
4100 addend = ((insn >> 4) & 0xf000) | (insn & 0xfff);
4101 signed_addend = (addend ^ 0x10000) - 0x10000;
4103 value += signed_addend;
4104 if (sym_flags == STT_ARM_TFUNC)
4107 if (r_type == R_ARM_MOVW_PREL_NC || r_type == R_ARM_MOVT_PREL)
4108 value -= (input_section->output_section->vma
4109 + input_section->output_offset + rel->r_offset);
4111 if (r_type == R_ARM_MOVT_ABS || r_type == R_ARM_MOVT_PREL)
4115 insn |= value & 0xfff;
4116 insn |= (value & 0xf000) << 4;
4117 bfd_put_32 (input_bfd, insn, hit_data);
4119 return bfd_reloc_ok;
4121 case R_ARM_THM_MOVW_ABS_NC:
4122 case R_ARM_THM_MOVT_ABS:
4123 case R_ARM_THM_MOVW_PREL_NC:
4124 case R_ARM_THM_MOVT_PREL:
4128 insn = bfd_get_16 (input_bfd, hit_data) << 16;
4129 insn |= bfd_get_16 (input_bfd, hit_data + 2);
4131 if (globals->use_rel)
4133 addend = ((insn >> 4) & 0xf000)
4134 | ((insn >> 15) & 0x0800)
4135 | ((insn >> 4) & 0x0700)
4137 signed_addend = (addend ^ 0x10000) - 0x10000;
4139 value += signed_addend;
4140 if (sym_flags == STT_ARM_TFUNC)
4143 if (r_type == R_ARM_THM_MOVW_PREL_NC || r_type == R_ARM_THM_MOVT_PREL)
4144 value -= (input_section->output_section->vma
4145 + input_section->output_offset + rel->r_offset);
4147 if (r_type == R_ARM_THM_MOVT_ABS || r_type == R_ARM_THM_MOVT_PREL)
4151 insn |= (value & 0xf000) << 4;
4152 insn |= (value & 0x0800) << 15;
4153 insn |= (value & 0x0700) << 4;
4154 insn |= (value & 0x00ff);
4156 bfd_put_16 (input_bfd, insn >> 16, hit_data);
4157 bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2);
4159 return bfd_reloc_ok;
4162 return bfd_reloc_notsupported;
4168 uleb128_size (unsigned int i)
4180 /* Return TRUE if the attribute has the default value (0/""). */
4182 is_default_attr (aeabi_attribute *attr)
4184 if ((attr->type & 1) && attr->i != 0)
4186 if ((attr->type & 2) && attr->s && *attr->s)
4192 /* Return the size of a single attribute. */
4194 eabi_attr_size(int tag, aeabi_attribute *attr)
4198 if (is_default_attr (attr))
4201 size = uleb128_size (tag);
4203 size += uleb128_size (attr->i);
4205 size += strlen ((char *)attr->s) + 1;
4209 /* Returns the size of the eabi object attributess section. */
4211 elf32_arm_eabi_attr_size (bfd *abfd)
4214 aeabi_attribute *attr;
4215 aeabi_attribute_list *list;
4218 attr = elf32_arm_tdata (abfd)->known_eabi_attributes;
4219 size = 16; /* 'A' <size> "aeabi" 0x1 <size>. */
4220 for (i = 4; i < NUM_KNOWN_ATTRIBUTES; i++)
4221 size += eabi_attr_size (i, &attr[i]);
4223 for (list = elf32_arm_tdata (abfd)->other_eabi_attributes;
4226 size += eabi_attr_size (list->tag, &list->attr);
4232 write_uleb128 (bfd_byte *p, unsigned int val)
4247 /* Write attribute ATTR to butter P, and return a pointer to the following
4250 write_eabi_attribute (bfd_byte *p, int tag, aeabi_attribute *attr)
4252 /* Suppress default entries. */
4253 if (is_default_attr(attr))
4256 p = write_uleb128 (p, tag);
4258 p = write_uleb128 (p, attr->i);
4263 len = strlen (attr->s) + 1;
4264 memcpy (p, attr->s, len);
4271 /* Write the contents of the eabi attributes section to p. */
4273 elf32_arm_set_eabi_attr_contents (bfd *abfd, bfd_byte *contents, bfd_vma size)
4276 aeabi_attribute *attr;
4277 aeabi_attribute_list *list;
4282 bfd_put_32 (abfd, size - 1, p);
4284 memcpy (p, "aeabi", 6);
4287 bfd_put_32 (abfd, size - 11, p);
4290 attr = elf32_arm_tdata (abfd)->known_eabi_attributes;
4291 for (i = 4; i < NUM_KNOWN_ATTRIBUTES; i++)
4292 p = write_eabi_attribute (p, i, &attr[i]);
4294 for (list = elf32_arm_tdata (abfd)->other_eabi_attributes;
4297 p = write_eabi_attribute (p, list->tag, &list->attr);
4300 /* Override final_link to handle EABI object attribute sections. */
4303 elf32_arm_bfd_final_link (bfd *abfd, struct bfd_link_info *info)
4306 struct bfd_link_order *p;
4307 asection *attr_section = NULL;
4311 /* elf32_arm_merge_private_bfd_data will already have merged the
4312 object attributes. Remove the input sections from the link, and set
4313 the contents of the output secton. */
4314 for (o = abfd->sections; o != NULL; o = o->next)
4316 if (strcmp (o->name, ".ARM.attributes") == 0)
4318 for (p = o->map_head.link_order; p != NULL; p = p->next)
4320 asection *input_section;
4322 if (p->type != bfd_indirect_link_order)
4324 input_section = p->u.indirect.section;
4325 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4326 elf_link_input_bfd ignores this section. */
4327 input_section->flags &= ~SEC_HAS_CONTENTS;
4330 size = elf32_arm_eabi_attr_size (abfd);
4331 bfd_set_section_size (abfd, o, size);
4333 /* Skip this section later on. */
4334 o->map_head.link_order = NULL;
4337 /* Invoke the ELF linker to do all the work. */
4338 if (!bfd_elf_final_link (abfd, info))
4343 contents = bfd_malloc(size);
4344 if (contents == NULL)
4346 elf32_arm_set_eabi_attr_contents (abfd, contents, size);
4347 bfd_set_section_contents (abfd, attr_section, contents, 0, size);
4354 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
4356 arm_add_to_rel (bfd * abfd,
4358 reloc_howto_type * howto,
4359 bfd_signed_vma increment)
4361 bfd_signed_vma addend;
4363 if (howto->type == R_ARM_THM_CALL)
4365 int upper_insn, lower_insn;
4368 upper_insn = bfd_get_16 (abfd, address);
4369 lower_insn = bfd_get_16 (abfd, address + 2);
4370 upper = upper_insn & 0x7ff;
4371 lower = lower_insn & 0x7ff;
4373 addend = (upper << 12) | (lower << 1);
4374 addend += increment;
4377 upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
4378 lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
4380 bfd_put_16 (abfd, (bfd_vma) upper_insn, address);
4381 bfd_put_16 (abfd, (bfd_vma) lower_insn, address + 2);
4387 contents = bfd_get_32 (abfd, address);
4389 /* Get the (signed) value from the instruction. */
4390 addend = contents & howto->src_mask;
4391 if (addend & ((howto->src_mask + 1) >> 1))
4393 bfd_signed_vma mask;
4396 mask &= ~ howto->src_mask;
4400 /* Add in the increment, (which is a byte value). */
4401 switch (howto->type)
4404 addend += increment;
4411 addend <<= howto->size;
4412 addend += increment;
4414 /* Should we check for overflow here ? */
4416 /* Drop any undesired bits. */
4417 addend >>= howto->rightshift;
4421 contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
4423 bfd_put_32 (abfd, contents, address);
4427 #define IS_ARM_TLS_RELOC(R_TYPE) \
4428 ((R_TYPE) == R_ARM_TLS_GD32 \
4429 || (R_TYPE) == R_ARM_TLS_LDO32 \
4430 || (R_TYPE) == R_ARM_TLS_LDM32 \
4431 || (R_TYPE) == R_ARM_TLS_DTPOFF32 \
4432 || (R_TYPE) == R_ARM_TLS_DTPMOD32 \
4433 || (R_TYPE) == R_ARM_TLS_TPOFF32 \
4434 || (R_TYPE) == R_ARM_TLS_LE32 \
4435 || (R_TYPE) == R_ARM_TLS_IE32)
4437 /* Relocate an ARM ELF section. */
4439 elf32_arm_relocate_section (bfd * output_bfd,
4440 struct bfd_link_info * info,
4442 asection * input_section,
4443 bfd_byte * contents,
4444 Elf_Internal_Rela * relocs,
4445 Elf_Internal_Sym * local_syms,
4446 asection ** local_sections)
4448 Elf_Internal_Shdr *symtab_hdr;
4449 struct elf_link_hash_entry **sym_hashes;
4450 Elf_Internal_Rela *rel;
4451 Elf_Internal_Rela *relend;
4453 struct elf32_arm_link_hash_table * globals;
4455 globals = elf32_arm_hash_table (info);
4456 if (info->relocatable && !globals->use_rel)
4459 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
4460 sym_hashes = elf_sym_hashes (input_bfd);
4463 relend = relocs + input_section->reloc_count;
4464 for (; rel < relend; rel++)
4467 reloc_howto_type * howto;
4468 unsigned long r_symndx;
4469 Elf_Internal_Sym * sym;
4471 struct elf_link_hash_entry * h;
4473 bfd_reloc_status_type r;
4476 bfd_boolean unresolved_reloc = FALSE;
4478 r_symndx = ELF32_R_SYM (rel->r_info);
4479 r_type = ELF32_R_TYPE (rel->r_info);
4480 r_type = arm_real_reloc_type (globals, r_type);
4482 if ( r_type == R_ARM_GNU_VTENTRY
4483 || r_type == R_ARM_GNU_VTINHERIT)
4486 bfd_reloc.howto = elf32_arm_howto_from_type (r_type);
4487 howto = bfd_reloc.howto;
4489 if (info->relocatable && globals->use_rel)
4491 /* This is a relocatable link. We don't have to change
4492 anything, unless the reloc is against a section symbol,
4493 in which case we have to adjust according to where the
4494 section symbol winds up in the output section. */
4495 if (r_symndx < symtab_hdr->sh_info)
4497 sym = local_syms + r_symndx;
4498 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4500 sec = local_sections[r_symndx];
4501 arm_add_to_rel (input_bfd, contents + rel->r_offset,
4503 (bfd_signed_vma) (sec->output_offset
4511 /* This is a final link. */
4516 if (r_symndx < symtab_hdr->sh_info)
4518 sym = local_syms + r_symndx;
4519 sym_type = ELF32_ST_TYPE (sym->st_info);
4520 sec = local_sections[r_symndx];
4521 if (globals->use_rel)
4523 relocation = (sec->output_section->vma
4524 + sec->output_offset
4526 if ((sec->flags & SEC_MERGE)
4527 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4530 bfd_vma addend, value;
4532 if (howto->rightshift)
4534 (*_bfd_error_handler)
4535 (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
4536 input_bfd, input_section,
4537 (long) rel->r_offset, howto->name);
4541 value = bfd_get_32 (input_bfd, contents + rel->r_offset);
4543 /* Get the (signed) value from the instruction. */
4544 addend = value & howto->src_mask;
4545 if (addend & ((howto->src_mask + 1) >> 1))
4547 bfd_signed_vma mask;
4550 mask &= ~ howto->src_mask;
4555 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
4557 addend += msec->output_section->vma + msec->output_offset;
4558 value = (value & ~ howto->dst_mask) | (addend & howto->dst_mask);
4559 bfd_put_32 (input_bfd, value, contents + rel->r_offset);
4563 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
4569 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4570 r_symndx, symtab_hdr, sym_hashes,
4572 unresolved_reloc, warned);
4578 name = h->root.root.string;
4581 name = (bfd_elf_string_from_elf_section
4582 (input_bfd, symtab_hdr->sh_link, sym->st_name));
4583 if (name == NULL || *name == '\0')
4584 name = bfd_section_name (input_bfd, sec);
4588 && r_type != R_ARM_NONE
4590 || h->root.type == bfd_link_hash_defined
4591 || h->root.type == bfd_link_hash_defweak)
4592 && IS_ARM_TLS_RELOC (r_type) != (sym_type == STT_TLS))
4594 (*_bfd_error_handler)
4595 ((sym_type == STT_TLS
4596 ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
4597 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
4600 (long) rel->r_offset,
4605 r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
4606 input_section, contents, rel,
4607 relocation, info, sec, name,
4608 (h ? ELF_ST_TYPE (h->type) :
4609 ELF_ST_TYPE (sym->st_info)), h,
4612 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4613 because such sections are not SEC_ALLOC and thus ld.so will
4614 not process them. */
4615 if (unresolved_reloc
4616 && !((input_section->flags & SEC_DEBUGGING) != 0
4619 (*_bfd_error_handler)
4620 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4623 (long) rel->r_offset,
4625 h->root.root.string);
4629 if (r != bfd_reloc_ok)
4631 const char * msg = (const char *) 0;
4635 case bfd_reloc_overflow:
4636 /* If the overflowing reloc was to an undefined symbol,
4637 we have already printed one error message and there
4638 is no point complaining again. */
4640 h->root.type != bfd_link_hash_undefined)
4641 && (!((*info->callbacks->reloc_overflow)
4642 (info, (h ? &h->root : NULL), name, howto->name,
4643 (bfd_vma) 0, input_bfd, input_section,
4648 case bfd_reloc_undefined:
4649 if (!((*info->callbacks->undefined_symbol)
4650 (info, name, input_bfd, input_section,
4651 rel->r_offset, TRUE)))
4655 case bfd_reloc_outofrange:
4656 msg = _("internal error: out of range error");
4659 case bfd_reloc_notsupported:
4660 msg = _("internal error: unsupported relocation error");
4663 case bfd_reloc_dangerous:
4664 msg = _("internal error: dangerous error");
4668 msg = _("internal error: unknown error");
4672 if (!((*info->callbacks->warning)
4673 (info, msg, name, input_bfd, input_section,
4684 /* Allocate/find an object attribute. */
4685 static aeabi_attribute *
4686 elf32_arm_new_eabi_attr (bfd *abfd, int tag)
4688 aeabi_attribute *attr;
4689 aeabi_attribute_list *list;
4690 aeabi_attribute_list *p;
4691 aeabi_attribute_list **lastp;
4694 if (tag < NUM_KNOWN_ATTRIBUTES)
4696 /* Knwon tags are preallocated. */
4697 attr = &elf32_arm_tdata (abfd)->known_eabi_attributes[tag];
4701 /* Create a new tag. */
4702 list = (aeabi_attribute_list *)
4703 bfd_alloc (abfd, sizeof (aeabi_attribute_list));
4704 memset (list, 0, sizeof (aeabi_attribute_list));
4706 /* Keep the tag list in order. */
4707 lastp = &elf32_arm_tdata (abfd)->other_eabi_attributes;
4708 for (p = *lastp; p; p = p->next)
4714 list->next = *lastp;
4723 elf32_arm_get_eabi_attr_int (bfd *abfd, int tag)
4725 aeabi_attribute_list *p;
4727 if (tag < NUM_KNOWN_ATTRIBUTES)
4729 /* Knwon tags are preallocated. */
4730 return elf32_arm_tdata (abfd)->known_eabi_attributes[tag].i;
4734 for (p = elf32_arm_tdata (abfd)->other_eabi_attributes;
4748 elf32_arm_add_eabi_attr_int (bfd *abfd, int tag, unsigned int i)
4750 aeabi_attribute *attr;
4752 attr = elf32_arm_new_eabi_attr (abfd, tag);
4758 attr_strdup (bfd *abfd, const char * s)
4763 len = strlen (s) + 1;
4764 p = (char *)bfd_alloc(abfd, len);
4765 return memcpy (p, s, len);
4769 elf32_arm_add_eabi_attr_string (bfd *abfd, int tag, const char *s)
4771 aeabi_attribute *attr;
4773 attr = elf32_arm_new_eabi_attr (abfd, tag);
4775 attr->s = attr_strdup (abfd, s);
4779 elf32_arm_add_eabi_attr_compat (bfd *abfd, unsigned int i, const char *s)
4781 aeabi_attribute_list *list;
4782 aeabi_attribute_list *p;
4783 aeabi_attribute_list **lastp;
4785 list = (aeabi_attribute_list *)
4786 bfd_alloc (abfd, sizeof (aeabi_attribute_list));
4787 memset (list, 0, sizeof (aeabi_attribute_list));
4788 list->tag = Tag_compatibility;
4789 list->attr.type = 3;
4791 list->attr.s = attr_strdup (abfd, s);
4793 lastp = &elf32_arm_tdata (abfd)->other_eabi_attributes;
4794 for (p = *lastp; p; p = p->next)
4797 if (p->tag != Tag_compatibility)
4799 cmp = strcmp(s, p->attr.s);
4800 if (cmp < 0 || (cmp == 0 && i < p->attr.i))
4804 list->next = *lastp;
4808 /* Set the right machine number. */
4811 elf32_arm_object_p (bfd *abfd)
4815 mach = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
4817 if (mach != bfd_mach_arm_unknown)
4818 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
4820 else if (elf_elfheader (abfd)->e_flags & EF_ARM_MAVERICK_FLOAT)
4821 bfd_default_set_arch_mach (abfd, bfd_arch_arm, bfd_mach_arm_ep9312);
4824 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
4829 /* Function to keep ARM specific flags in the ELF header. */
4832 elf32_arm_set_private_flags (bfd *abfd, flagword flags)
4834 if (elf_flags_init (abfd)
4835 && elf_elfheader (abfd)->e_flags != flags)
4837 if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
4839 if (flags & EF_ARM_INTERWORK)
4840 (*_bfd_error_handler)
4841 (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
4845 (_("Warning: Clearing the interworking flag of %B due to outside request"),
4851 elf_elfheader (abfd)->e_flags = flags;
4852 elf_flags_init (abfd) = TRUE;
4858 /* Copy the eabi object attribute from IBFD to OBFD. */
4860 copy_eabi_attributes (bfd *ibfd, bfd *obfd)
4862 aeabi_attribute *in_attr;
4863 aeabi_attribute *out_attr;
4864 aeabi_attribute_list *list;
4867 in_attr = elf32_arm_tdata (ibfd)->known_eabi_attributes;
4868 out_attr = elf32_arm_tdata (obfd)->known_eabi_attributes;
4869 for (i = 4; i < NUM_KNOWN_ATTRIBUTES; i++)
4871 out_attr->i = in_attr->i;
4872 if (in_attr->s && *in_attr->s)
4873 out_attr->s = attr_strdup (obfd, in_attr->s);
4878 for (list = elf32_arm_tdata (ibfd)->other_eabi_attributes;
4882 in_attr = &list->attr;
4883 switch (in_attr->type)
4886 elf32_arm_add_eabi_attr_int (obfd, list->tag, in_attr->i);
4889 elf32_arm_add_eabi_attr_string (obfd, list->tag, in_attr->s);
4892 elf32_arm_add_eabi_attr_compat (obfd, in_attr->i, in_attr->s);
4901 /* Copy backend specific data from one object module to another. */
4904 elf32_arm_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
4909 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4910 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4913 in_flags = elf_elfheader (ibfd)->e_flags;
4914 out_flags = elf_elfheader (obfd)->e_flags;
4916 if (elf_flags_init (obfd)
4917 && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
4918 && in_flags != out_flags)
4920 /* Cannot mix APCS26 and APCS32 code. */
4921 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
4924 /* Cannot mix float APCS and non-float APCS code. */
4925 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
4928 /* If the src and dest have different interworking flags
4929 then turn off the interworking bit. */
4930 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
4932 if (out_flags & EF_ARM_INTERWORK)
4934 (_("Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
4937 in_flags &= ~EF_ARM_INTERWORK;
4940 /* Likewise for PIC, though don't warn for this case. */
4941 if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC))
4942 in_flags &= ~EF_ARM_PIC;
4945 elf_elfheader (obfd)->e_flags = in_flags;
4946 elf_flags_init (obfd) = TRUE;
4948 /* Also copy the EI_OSABI field. */
4949 elf_elfheader (obfd)->e_ident[EI_OSABI] =
4950 elf_elfheader (ibfd)->e_ident[EI_OSABI];
4952 /* Copy EABI object attributes. */
4953 copy_eabi_attributes (ibfd, obfd);
4958 /* Values for Tag_ABI_PCS_R9_use. */
4967 /* Values for Tag_ABI_PCS_RW_data. */
4970 AEABI_PCS_RW_data_absolute,
4971 AEABI_PCS_RW_data_PCrel,
4972 AEABI_PCS_RW_data_SBrel,
4973 AEABI_PCS_RW_data_unused
4976 /* Values for Tag_ABI_enum_size. */
4982 AEABI_enum_forced_wide
4985 /* Merge EABI object attributes from IBFD into OBFD. Raise an error if there
4986 are conflicting attributes. */
4988 elf32_arm_merge_eabi_attributes (bfd *ibfd, bfd *obfd)
4990 aeabi_attribute *in_attr;
4991 aeabi_attribute *out_attr;
4992 aeabi_attribute_list *in_list;
4993 aeabi_attribute_list *out_list;
4994 /* Some tags have 0 = don't care, 1 = strong requirement,
4995 2 = weak requirement. */
4996 static const int order_312[3] = {3, 1, 2};
4999 if (!elf32_arm_tdata (ibfd)->known_eabi_attributes[0].i)
5001 /* This is the first object. Copy the attributes. */
5002 copy_eabi_attributes (ibfd, obfd);
5006 /* Use the Tag_null value to indicate the attributes have been
5008 elf32_arm_tdata (ibfd)->known_eabi_attributes[0].i = 1;
5010 in_attr = elf32_arm_tdata (ibfd)->known_eabi_attributes;
5011 out_attr = elf32_arm_tdata (obfd)->known_eabi_attributes;
5012 /* This needs to happen before Tag_ABI_FP_number_model is merged. */
5013 if (in_attr[Tag_ABI_VFP_args].i != out_attr[Tag_ABI_VFP_args].i)
5015 /* Ignore mismatches if teh object doesn't use floating point. */
5016 if (out_attr[Tag_ABI_FP_number_model].i == 0)
5017 out_attr[Tag_ABI_VFP_args].i = in_attr[Tag_ABI_VFP_args].i;
5018 else if (in_attr[Tag_ABI_FP_number_model].i != 0)
5021 (_("ERROR: %B uses VFP register arguments, %B does not"),
5027 for (i = 4; i < NUM_KNOWN_ATTRIBUTES; i++)
5029 /* Merge this attribute with existing attributes. */
5032 case Tag_CPU_raw_name:
5034 /* Use whichever has the greatest architecture requirements. */
5035 if (in_attr[Tag_CPU_arch].i > out_attr[Tag_CPU_arch].i)
5036 out_attr[i].s = attr_strdup(obfd, in_attr[i].s);
5039 case Tag_ABI_optimization_goals:
5040 case Tag_ABI_FP_optimization_goals:
5041 /* Use the first value seen. */
5045 case Tag_ARM_ISA_use:
5046 case Tag_THUMB_ISA_use:
5050 /* ??? Do NEON and WMMX conflict? */
5051 case Tag_ABI_FP_rounding:
5052 case Tag_ABI_FP_denormal:
5053 case Tag_ABI_FP_exceptions:
5054 case Tag_ABI_FP_user_exceptions:
5055 case Tag_ABI_FP_number_model:
5056 case Tag_ABI_align8_preserved:
5057 case Tag_ABI_HardFP_use:
5058 /* Use the largest value specified. */
5059 if (in_attr[i].i > out_attr[i].i)
5060 out_attr[i].i = in_attr[i].i;
5063 case Tag_CPU_arch_profile:
5064 /* Warn if conflicting architecture profiles used. */
5065 if (out_attr[i].i && in_attr[i].i && in_attr[i].i != out_attr[i].i)
5068 (_("ERROR: %B: Conflicting architecture profiles %c/%c"),
5069 ibfd, in_attr[i].i, out_attr[i].i);
5073 out_attr[i].i = in_attr[i].i;
5075 case Tag_PCS_config:
5076 if (out_attr[i].i == 0)
5077 out_attr[i].i = in_attr[i].i;
5078 else if (in_attr[i].i != 0 && out_attr[i].i != 0)
5080 /* It's sometimes ok to mix different configs, so this is only
5083 (_("Warning: %B: Conflicting platform configuration"), ibfd);
5086 case Tag_ABI_PCS_R9_use:
5087 if (out_attr[i].i != AEABI_R9_unused
5088 && in_attr[i].i != AEABI_R9_unused)
5091 (_("ERROR: %B: Conflicting use of R9"), ibfd);
5094 if (out_attr[i].i == AEABI_R9_unused)
5095 out_attr[i].i = in_attr[i].i;
5097 case Tag_ABI_PCS_RW_data:
5098 if (in_attr[i].i == AEABI_PCS_RW_data_SBrel
5099 && out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_SB
5100 && out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_unused)
5103 (_("ERROR: %B: SB relative addressing conflicts with use of R9"),
5107 /* Use the smallest value specified. */
5108 if (in_attr[i].i < out_attr[i].i)
5109 out_attr[i].i = in_attr[i].i;
5111 case Tag_ABI_PCS_RO_data:
5112 /* Use the smallest value specified. */
5113 if (in_attr[i].i < out_attr[i].i)
5114 out_attr[i].i = in_attr[i].i;
5116 case Tag_ABI_PCS_GOT_use:
5117 if (in_attr[i].i > 2 || out_attr[i].i > 2
5118 || order_312[in_attr[i].i] < order_312[out_attr[i].i])
5119 out_attr[i].i = in_attr[i].i;
5121 case Tag_ABI_PCS_wchar_t:
5122 if (out_attr[i].i && in_attr[i].i && out_attr[i].i != in_attr[i].i)
5125 (_("ERROR: %B: Conflicting definitions of wchar_t"), ibfd);
5129 out_attr[i].i = in_attr[i].i;
5131 case Tag_ABI_align8_needed:
5132 /* ??? Check against Tag_ABI_align8_preserved. */
5133 if (in_attr[i].i > 2 || out_attr[i].i > 2
5134 || order_312[in_attr[i].i] < order_312[out_attr[i].i])
5135 out_attr[i].i = in_attr[i].i;
5137 case Tag_ABI_enum_size:
5138 if (in_attr[i].i != AEABI_enum_unused)
5140 if (out_attr[i].i == AEABI_enum_unused
5141 || out_attr[i].i == AEABI_enum_forced_wide)
5143 /* The existing object is compatible with anything.
5144 Use whatever requirements the new object has. */
5145 out_attr[i].i = in_attr[i].i;
5147 else if (in_attr[i].i != AEABI_enum_forced_wide
5148 && out_attr[i].i != in_attr[i].i)
5151 (_("ERROR: %B: Conflicting enum sizes"), ibfd);
5155 case Tag_ABI_VFP_args:
5158 case Tag_ABI_WMMX_args:
5159 if (in_attr[i].i != out_attr[i].i)
5162 (_("ERROR: %B uses iWMMXt register arguments, %B does not"),
5167 default: /* All known attributes should be explicitly covered. */
5172 in_list = elf32_arm_tdata (ibfd)->other_eabi_attributes;
5173 out_list = elf32_arm_tdata (ibfd)->other_eabi_attributes;
5174 while (in_list && in_list->tag == Tag_compatibility)
5176 in_attr = &in_list->attr;
5177 if (in_attr->i == 0)
5179 if (in_attr->i == 1)
5182 (_("ERROR: %B: Must be processed by '%s' toolchain"),
5186 if (!out_list || out_list->tag != Tag_compatibility
5187 || strcmp (in_attr->s, out_list->attr.s) != 0)
5189 /* Add this compatibility tag to the output. */
5190 elf32_arm_add_eabi_attr_compat (obfd, in_attr->i, in_attr->s);
5193 out_attr = &out_list->attr;
5194 /* Check all the input tags with the same identifier. */
5197 if (out_list->tag != Tag_compatibility
5198 || in_attr->i != out_attr->i
5199 || strcmp (in_attr->s, out_attr->s) != 0)
5202 (_("ERROR: %B: Incompatible object tag '%s':%d"),
5203 ibfd, in_attr->s, in_attr->i);
5206 in_list = in_list->next;
5207 if (in_list->tag != Tag_compatibility
5208 || strcmp (in_attr->s, in_list->attr.s) != 0)
5210 in_attr = &in_list->attr;
5211 out_list = out_list->next;
5213 out_attr = &out_list->attr;
5216 /* Check the output doesn't have extra tags with this identifier. */
5217 if (out_list && out_list->tag == Tag_compatibility
5218 && strcmp (in_attr->s, out_list->attr.s) == 0)
5221 (_("ERROR: %B: Incompatible object tag '%s':%d"),
5222 ibfd, in_attr->s, out_list->attr.i);
5227 for (; in_list; in_list = in_list->next)
5229 if ((in_list->tag & 128) < 64)
5232 (_("Warning: %B: Unknown EABI object attribute %d"),
5233 ibfd, in_list->tag);
5241 /* Return TRUE if the two EABI versions are incompatible. */
5244 elf32_arm_versions_compatible (unsigned iver, unsigned over)
5246 /* v4 and v5 are the same spec before and after it was released,
5247 so allow mixing them. */
5248 if ((iver == EF_ARM_EABI_VER4 && over == EF_ARM_EABI_VER5)
5249 || (iver == EF_ARM_EABI_VER5 && over == EF_ARM_EABI_VER4))
5252 return (iver == over);
5255 /* Merge backend specific data from an object file to the output
5256 object file when linking. */
5259 elf32_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
5263 bfd_boolean flags_compatible = TRUE;
5266 /* Check if we have the same endianess. */
5267 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
5270 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5271 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5274 if (!elf32_arm_merge_eabi_attributes (ibfd, obfd))
5277 /* The input BFD must have had its flags initialised. */
5278 /* The following seems bogus to me -- The flags are initialized in
5279 the assembler but I don't think an elf_flags_init field is
5280 written into the object. */
5281 /* BFD_ASSERT (elf_flags_init (ibfd)); */
5283 in_flags = elf_elfheader (ibfd)->e_flags;
5284 out_flags = elf_elfheader (obfd)->e_flags;
5286 if (!elf_flags_init (obfd))
5288 /* If the input is the default architecture and had the default
5289 flags then do not bother setting the flags for the output
5290 architecture, instead allow future merges to do this. If no
5291 future merges ever set these flags then they will retain their
5292 uninitialised values, which surprise surprise, correspond
5293 to the default values. */
5294 if (bfd_get_arch_info (ibfd)->the_default
5295 && elf_elfheader (ibfd)->e_flags == 0)
5298 elf_flags_init (obfd) = TRUE;
5299 elf_elfheader (obfd)->e_flags = in_flags;
5301 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
5302 && bfd_get_arch_info (obfd)->the_default)
5303 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
5308 /* Determine what should happen if the input ARM architecture
5309 does not match the output ARM architecture. */
5310 if (! bfd_arm_merge_machines (ibfd, obfd))
5313 /* Identical flags must be compatible. */
5314 if (in_flags == out_flags)
5317 /* Check to see if the input BFD actually contains any sections. If
5318 not, its flags may not have been initialised either, but it
5319 cannot actually cause any incompatiblity. Do not short-circuit
5320 dynamic objects; their section list may be emptied by
5321 elf_link_add_object_symbols.
5323 Also check to see if there are no code sections in the input.
5324 In this case there is no need to check for code specific flags.
5325 XXX - do we need to worry about floating-point format compatability
5326 in data sections ? */
5327 if (!(ibfd->flags & DYNAMIC))
5329 bfd_boolean null_input_bfd = TRUE;
5330 bfd_boolean only_data_sections = TRUE;
5332 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
5334 /* Ignore synthetic glue sections. */
5335 if (strcmp (sec->name, ".glue_7")
5336 && strcmp (sec->name, ".glue_7t"))
5338 if ((bfd_get_section_flags (ibfd, sec)
5339 & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
5340 == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
5341 only_data_sections = FALSE;
5343 null_input_bfd = FALSE;
5348 if (null_input_bfd || only_data_sections)
5352 /* Complain about various flag mismatches. */
5353 if (!elf32_arm_versions_compatible (EF_ARM_EABI_VERSION (in_flags),
5354 EF_ARM_EABI_VERSION (out_flags)))
5357 (_("ERROR: Source object %B has EABI version %d, but target %B has EABI version %d"),
5359 (in_flags & EF_ARM_EABIMASK) >> 24,
5360 (out_flags & EF_ARM_EABIMASK) >> 24);
5364 /* Not sure what needs to be checked for EABI versions >= 1. */
5365 /* VxWorks libraries do not use these flags. */
5366 if (get_elf_backend_data (obfd) != &elf32_arm_vxworks_bed
5367 && get_elf_backend_data (ibfd) != &elf32_arm_vxworks_bed
5368 && EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
5370 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
5373 (_("ERROR: %B is compiled for APCS-%d, whereas target %B uses APCS-%d"),
5375 in_flags & EF_ARM_APCS_26 ? 26 : 32,
5376 out_flags & EF_ARM_APCS_26 ? 26 : 32);
5377 flags_compatible = FALSE;
5380 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
5382 if (in_flags & EF_ARM_APCS_FLOAT)
5384 (_("ERROR: %B passes floats in float registers, whereas %B passes them in integer registers"),
5388 (_("ERROR: %B passes floats in integer registers, whereas %B passes them in float registers"),
5391 flags_compatible = FALSE;
5394 if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT))
5396 if (in_flags & EF_ARM_VFP_FLOAT)
5398 (_("ERROR: %B uses VFP instructions, whereas %B does not"),
5402 (_("ERROR: %B uses FPA instructions, whereas %B does not"),
5405 flags_compatible = FALSE;
5408 if ((in_flags & EF_ARM_MAVERICK_FLOAT) != (out_flags & EF_ARM_MAVERICK_FLOAT))
5410 if (in_flags & EF_ARM_MAVERICK_FLOAT)
5412 (_("ERROR: %B uses Maverick instructions, whereas %B does not"),
5416 (_("ERROR: %B does not use Maverick instructions, whereas %B does"),
5419 flags_compatible = FALSE;
5422 #ifdef EF_ARM_SOFT_FLOAT
5423 if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
5425 /* We can allow interworking between code that is VFP format
5426 layout, and uses either soft float or integer regs for
5427 passing floating point arguments and results. We already
5428 know that the APCS_FLOAT flags match; similarly for VFP
5430 if ((in_flags & EF_ARM_APCS_FLOAT) != 0
5431 || (in_flags & EF_ARM_VFP_FLOAT) == 0)
5433 if (in_flags & EF_ARM_SOFT_FLOAT)
5435 (_("ERROR: %B uses software FP, whereas %B uses hardware FP"),
5439 (_("ERROR: %B uses hardware FP, whereas %B uses software FP"),
5442 flags_compatible = FALSE;
5447 /* Interworking mismatch is only a warning. */
5448 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
5450 if (in_flags & EF_ARM_INTERWORK)
5453 (_("Warning: %B supports interworking, whereas %B does not"),
5459 (_("Warning: %B does not support interworking, whereas %B does"),
5465 return flags_compatible;
5468 /* Display the flags field. */
5471 elf32_arm_print_private_bfd_data (bfd *abfd, void * ptr)
5473 FILE * file = (FILE *) ptr;
5474 unsigned long flags;
5476 BFD_ASSERT (abfd != NULL && ptr != NULL);
5478 /* Print normal ELF private data. */
5479 _bfd_elf_print_private_bfd_data (abfd, ptr);
5481 flags = elf_elfheader (abfd)->e_flags;
5482 /* Ignore init flag - it may not be set, despite the flags field
5483 containing valid data. */
5485 /* xgettext:c-format */
5486 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
5488 switch (EF_ARM_EABI_VERSION (flags))
5490 case EF_ARM_EABI_UNKNOWN:
5491 /* The following flag bits are GNU extensions and not part of the
5492 official ARM ELF extended ABI. Hence they are only decoded if
5493 the EABI version is not set. */
5494 if (flags & EF_ARM_INTERWORK)
5495 fprintf (file, _(" [interworking enabled]"));
5497 if (flags & EF_ARM_APCS_26)
5498 fprintf (file, " [APCS-26]");
5500 fprintf (file, " [APCS-32]");
5502 if (flags & EF_ARM_VFP_FLOAT)
5503 fprintf (file, _(" [VFP float format]"));
5504 else if (flags & EF_ARM_MAVERICK_FLOAT)
5505 fprintf (file, _(" [Maverick float format]"));
5507 fprintf (file, _(" [FPA float format]"));
5509 if (flags & EF_ARM_APCS_FLOAT)
5510 fprintf (file, _(" [floats passed in float registers]"));
5512 if (flags & EF_ARM_PIC)
5513 fprintf (file, _(" [position independent]"));
5515 if (flags & EF_ARM_NEW_ABI)
5516 fprintf (file, _(" [new ABI]"));
5518 if (flags & EF_ARM_OLD_ABI)
5519 fprintf (file, _(" [old ABI]"));
5521 if (flags & EF_ARM_SOFT_FLOAT)
5522 fprintf (file, _(" [software FP]"));
5524 flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT
5525 | EF_ARM_PIC | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI
5526 | EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT
5527 | EF_ARM_MAVERICK_FLOAT);
5530 case EF_ARM_EABI_VER1:
5531 fprintf (file, _(" [Version1 EABI]"));
5533 if (flags & EF_ARM_SYMSARESORTED)
5534 fprintf (file, _(" [sorted symbol table]"));
5536 fprintf (file, _(" [unsorted symbol table]"));
5538 flags &= ~ EF_ARM_SYMSARESORTED;
5541 case EF_ARM_EABI_VER2:
5542 fprintf (file, _(" [Version2 EABI]"));
5544 if (flags & EF_ARM_SYMSARESORTED)
5545 fprintf (file, _(" [sorted symbol table]"));
5547 fprintf (file, _(" [unsorted symbol table]"));
5549 if (flags & EF_ARM_DYNSYMSUSESEGIDX)
5550 fprintf (file, _(" [dynamic symbols use segment index]"));
5552 if (flags & EF_ARM_MAPSYMSFIRST)
5553 fprintf (file, _(" [mapping symbols precede others]"));
5555 flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX
5556 | EF_ARM_MAPSYMSFIRST);
5559 case EF_ARM_EABI_VER3:
5560 fprintf (file, _(" [Version3 EABI]"));
5563 case EF_ARM_EABI_VER4:
5564 fprintf (file, _(" [Version4 EABI]"));
5567 case EF_ARM_EABI_VER5:
5568 fprintf (file, _(" [Version5 EABI]"));
5570 if (flags & EF_ARM_BE8)
5571 fprintf (file, _(" [BE8]"));
5573 if (flags & EF_ARM_LE8)
5574 fprintf (file, _(" [LE8]"));
5576 flags &= ~(EF_ARM_LE8 | EF_ARM_BE8);
5580 fprintf (file, _(" <EABI version unrecognised>"));
5584 flags &= ~ EF_ARM_EABIMASK;
5586 if (flags & EF_ARM_RELEXEC)
5587 fprintf (file, _(" [relocatable executable]"));
5589 if (flags & EF_ARM_HASENTRY)
5590 fprintf (file, _(" [has entry point]"));
5592 flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
5595 fprintf (file, _("<Unrecognised flag bits set>"));
5603 elf32_arm_get_symbol_type (Elf_Internal_Sym * elf_sym, int type)
5605 switch (ELF_ST_TYPE (elf_sym->st_info))
5608 return ELF_ST_TYPE (elf_sym->st_info);
5611 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
5612 This allows us to distinguish between data used by Thumb instructions
5613 and non-data (which is probably code) inside Thumb regions of an
5615 if (type != STT_OBJECT && type != STT_TLS)
5616 return ELF_ST_TYPE (elf_sym->st_info);
5627 elf32_arm_gc_mark_hook (asection * sec,
5628 struct bfd_link_info * info ATTRIBUTE_UNUSED,
5629 Elf_Internal_Rela * rel,
5630 struct elf_link_hash_entry * h,
5631 Elf_Internal_Sym * sym)
5635 switch (ELF32_R_TYPE (rel->r_info))
5637 case R_ARM_GNU_VTINHERIT:
5638 case R_ARM_GNU_VTENTRY:
5642 switch (h->root.type)
5644 case bfd_link_hash_defined:
5645 case bfd_link_hash_defweak:
5646 return h->root.u.def.section;
5648 case bfd_link_hash_common:
5649 return h->root.u.c.p->section;
5657 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5662 /* Update the got entry reference counts for the section being removed. */
5665 elf32_arm_gc_sweep_hook (bfd * abfd,
5666 struct bfd_link_info * info,
5668 const Elf_Internal_Rela * relocs)
5670 Elf_Internal_Shdr *symtab_hdr;
5671 struct elf_link_hash_entry **sym_hashes;
5672 bfd_signed_vma *local_got_refcounts;
5673 const Elf_Internal_Rela *rel, *relend;
5674 struct elf32_arm_link_hash_table * globals;
5676 globals = elf32_arm_hash_table (info);
5678 elf_section_data (sec)->local_dynrel = NULL;
5680 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5681 sym_hashes = elf_sym_hashes (abfd);
5682 local_got_refcounts = elf_local_got_refcounts (abfd);
5684 relend = relocs + sec->reloc_count;
5685 for (rel = relocs; rel < relend; rel++)
5687 unsigned long r_symndx;
5688 struct elf_link_hash_entry *h = NULL;
5691 r_symndx = ELF32_R_SYM (rel->r_info);
5692 if (r_symndx >= symtab_hdr->sh_info)
5694 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5695 while (h->root.type == bfd_link_hash_indirect
5696 || h->root.type == bfd_link_hash_warning)
5697 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5700 r_type = ELF32_R_TYPE (rel->r_info);
5701 r_type = arm_real_reloc_type (globals, r_type);
5705 case R_ARM_GOT_PREL:
5706 case R_ARM_TLS_GD32:
5707 case R_ARM_TLS_IE32:
5710 if (h->got.refcount > 0)
5711 h->got.refcount -= 1;
5713 else if (local_got_refcounts != NULL)
5715 if (local_got_refcounts[r_symndx] > 0)
5716 local_got_refcounts[r_symndx] -= 1;
5720 case R_ARM_TLS_LDM32:
5721 elf32_arm_hash_table (info)->tls_ldm_got.refcount -= 1;
5731 case R_ARM_THM_CALL:
5732 case R_ARM_MOVW_ABS_NC:
5733 case R_ARM_MOVT_ABS:
5734 case R_ARM_MOVW_PREL_NC:
5735 case R_ARM_MOVT_PREL:
5736 case R_ARM_THM_MOVW_ABS_NC:
5737 case R_ARM_THM_MOVT_ABS:
5738 case R_ARM_THM_MOVW_PREL_NC:
5739 case R_ARM_THM_MOVT_PREL:
5740 /* Should the interworking branches be here also? */
5744 struct elf32_arm_link_hash_entry *eh;
5745 struct elf32_arm_relocs_copied **pp;
5746 struct elf32_arm_relocs_copied *p;
5748 eh = (struct elf32_arm_link_hash_entry *) h;
5750 if (h->plt.refcount > 0)
5752 h->plt.refcount -= 1;
5753 if (ELF32_R_TYPE (rel->r_info) == R_ARM_THM_CALL)
5754 eh->plt_thumb_refcount--;
5757 if (r_type == R_ARM_ABS32
5758 || r_type == R_ARM_REL32)
5760 for (pp = &eh->relocs_copied; (p = *pp) != NULL;
5762 if (p->section == sec)
5765 if (ELF32_R_TYPE (rel->r_info) == R_ARM_REL32)
5783 /* Look through the relocs for a section during the first phase. */
5786 elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info,
5787 asection *sec, const Elf_Internal_Rela *relocs)
5789 Elf_Internal_Shdr *symtab_hdr;
5790 struct elf_link_hash_entry **sym_hashes;
5791 struct elf_link_hash_entry **sym_hashes_end;
5792 const Elf_Internal_Rela *rel;
5793 const Elf_Internal_Rela *rel_end;
5796 bfd_vma *local_got_offsets;
5797 struct elf32_arm_link_hash_table *htab;
5799 if (info->relocatable)
5802 htab = elf32_arm_hash_table (info);
5805 /* Create dynamic sections for relocatable executables so that we can
5806 copy relocations. */
5807 if (htab->root.is_relocatable_executable
5808 && ! htab->root.dynamic_sections_created)
5810 if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
5814 dynobj = elf_hash_table (info)->dynobj;
5815 local_got_offsets = elf_local_got_offsets (abfd);
5817 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5818 sym_hashes = elf_sym_hashes (abfd);
5819 sym_hashes_end = sym_hashes
5820 + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
5822 if (!elf_bad_symtab (abfd))
5823 sym_hashes_end -= symtab_hdr->sh_info;
5825 rel_end = relocs + sec->reloc_count;
5826 for (rel = relocs; rel < rel_end; rel++)
5828 struct elf_link_hash_entry *h;
5829 struct elf32_arm_link_hash_entry *eh;
5830 unsigned long r_symndx;
5833 r_symndx = ELF32_R_SYM (rel->r_info);
5834 r_type = ELF32_R_TYPE (rel->r_info);
5835 r_type = arm_real_reloc_type (htab, r_type);
5837 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
5839 (*_bfd_error_handler) (_("%B: bad symbol index: %d"), abfd,
5844 if (r_symndx < symtab_hdr->sh_info)
5848 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5849 while (h->root.type == bfd_link_hash_indirect
5850 || h->root.type == bfd_link_hash_warning)
5851 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5854 eh = (struct elf32_arm_link_hash_entry *) h;
5859 case R_ARM_GOT_PREL:
5860 case R_ARM_TLS_GD32:
5861 case R_ARM_TLS_IE32:
5862 /* This symbol requires a global offset table entry. */
5864 int tls_type, old_tls_type;
5868 case R_ARM_TLS_GD32: tls_type = GOT_TLS_GD; break;
5869 case R_ARM_TLS_IE32: tls_type = GOT_TLS_IE; break;
5870 default: tls_type = GOT_NORMAL; break;
5876 old_tls_type = elf32_arm_hash_entry (h)->tls_type;
5880 bfd_signed_vma *local_got_refcounts;
5882 /* This is a global offset table entry for a local symbol. */
5883 local_got_refcounts = elf_local_got_refcounts (abfd);
5884 if (local_got_refcounts == NULL)
5888 size = symtab_hdr->sh_info;
5889 size *= (sizeof (bfd_signed_vma) + sizeof(char));
5890 local_got_refcounts = bfd_zalloc (abfd, size);
5891 if (local_got_refcounts == NULL)
5893 elf_local_got_refcounts (abfd) = local_got_refcounts;
5894 elf32_arm_local_got_tls_type (abfd)
5895 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
5897 local_got_refcounts[r_symndx] += 1;
5898 old_tls_type = elf32_arm_local_got_tls_type (abfd) [r_symndx];
5901 /* We will already have issued an error message if there is a
5902 TLS / non-TLS mismatch, based on the symbol type. We don't
5903 support any linker relaxations. So just combine any TLS
5905 if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
5906 && tls_type != GOT_NORMAL)
5907 tls_type |= old_tls_type;
5909 if (old_tls_type != tls_type)
5912 elf32_arm_hash_entry (h)->tls_type = tls_type;
5914 elf32_arm_local_got_tls_type (abfd) [r_symndx] = tls_type;
5919 case R_ARM_TLS_LDM32:
5920 if (r_type == R_ARM_TLS_LDM32)
5921 htab->tls_ldm_got.refcount++;
5924 case R_ARM_GOTOFF32:
5926 if (htab->sgot == NULL)
5928 if (htab->root.dynobj == NULL)
5929 htab->root.dynobj = abfd;
5930 if (!create_got_section (htab->root.dynobj, info))
5936 /* VxWorks uses dynamic R_ARM_ABS12 relocations for
5937 ldr __GOTT_INDEX__ offsets. */
5938 if (!htab->vxworks_p)
5949 case R_ARM_THM_CALL:
5950 case R_ARM_MOVW_ABS_NC:
5951 case R_ARM_MOVT_ABS:
5952 case R_ARM_MOVW_PREL_NC:
5953 case R_ARM_MOVT_PREL:
5954 case R_ARM_THM_MOVW_ABS_NC:
5955 case R_ARM_THM_MOVT_ABS:
5956 case R_ARM_THM_MOVW_PREL_NC:
5957 case R_ARM_THM_MOVT_PREL:
5958 /* Should the interworking branches be listed here? */
5961 /* If this reloc is in a read-only section, we might
5962 need a copy reloc. We can't check reliably at this
5963 stage whether the section is read-only, as input
5964 sections have not yet been mapped to output sections.
5965 Tentatively set the flag for now, and correct in
5966 adjust_dynamic_symbol. */
5970 /* We may need a .plt entry if the function this reloc
5971 refers to is in a different object. We can't tell for
5972 sure yet, because something later might force the
5974 if (r_type != R_ARM_ABS32 && r_type != R_ARM_REL32)
5977 /* If we create a PLT entry, this relocation will reference
5978 it, even if it's an ABS32 relocation. */
5979 h->plt.refcount += 1;
5981 if (r_type == R_ARM_THM_CALL)
5982 eh->plt_thumb_refcount += 1;
5985 /* If we are creating a shared library or relocatable executable,
5986 and this is a reloc against a global symbol, or a non PC
5987 relative reloc against a local symbol, then we need to copy
5988 the reloc into the shared library. However, if we are linking
5989 with -Bsymbolic, we do not need to copy a reloc against a
5990 global symbol which is defined in an object we are
5991 including in the link (i.e., DEF_REGULAR is set). At
5992 this point we have not seen all the input files, so it is
5993 possible that DEF_REGULAR is not set now but will be set
5994 later (it is never cleared). We account for that
5995 possibility below by storing information in the
5996 relocs_copied field of the hash table entry. */
5997 if ((info->shared || htab->root.is_relocatable_executable)
5998 && (sec->flags & SEC_ALLOC) != 0
5999 && (r_type == R_ARM_ABS32
6000 || (h != NULL && ! h->needs_plt
6001 && (! info->symbolic || ! h->def_regular))))
6003 struct elf32_arm_relocs_copied *p, **head;
6005 /* When creating a shared object, we must copy these
6006 reloc types into the output file. We create a reloc
6007 section in dynobj and make room for this reloc. */
6012 name = (bfd_elf_string_from_elf_section
6014 elf_elfheader (abfd)->e_shstrndx,
6015 elf_section_data (sec)->rel_hdr.sh_name));
6019 BFD_ASSERT (reloc_section_p (htab, name, sec));
6021 sreloc = bfd_get_section_by_name (dynobj, name);
6026 flags = (SEC_HAS_CONTENTS | SEC_READONLY
6027 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
6028 if ((sec->flags & SEC_ALLOC) != 0
6029 /* BPABI objects never have dynamic
6030 relocations mapped. */
6031 && !htab->symbian_p)
6032 flags |= SEC_ALLOC | SEC_LOAD;
6033 sreloc = bfd_make_section_with_flags (dynobj,
6037 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
6041 elf_section_data (sec)->sreloc = sreloc;
6044 /* If this is a global symbol, we count the number of
6045 relocations we need for this symbol. */
6048 head = &((struct elf32_arm_link_hash_entry *) h)->relocs_copied;
6052 /* Track dynamic relocs needed for local syms too.
6053 We really need local syms available to do this
6059 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
6064 vpp = &elf_section_data (s)->local_dynrel;
6065 head = (struct elf32_arm_relocs_copied **) vpp;
6069 if (p == NULL || p->section != sec)
6071 bfd_size_type amt = sizeof *p;
6073 p = bfd_alloc (htab->root.dynobj, amt);
6083 if (r_type == R_ARM_REL32)
6089 /* This relocation describes the C++ object vtable hierarchy.
6090 Reconstruct it for later use during GC. */
6091 case R_ARM_GNU_VTINHERIT:
6092 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
6096 /* This relocation describes which C++ vtable entries are actually
6097 used. Record for later use during GC. */
6098 case R_ARM_GNU_VTENTRY:
6099 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
6108 /* Treat mapping symbols as special target symbols. */
6111 elf32_arm_is_target_special_symbol (bfd * abfd ATTRIBUTE_UNUSED, asymbol * sym)
6113 return bfd_is_arm_mapping_symbol_name (sym->name);
6116 /* This is a copy of elf_find_function() from elf.c except that
6117 ARM mapping symbols are ignored when looking for function names
6118 and STT_ARM_TFUNC is considered to a function type. */
6121 arm_elf_find_function (bfd * abfd ATTRIBUTE_UNUSED,
6125 const char ** filename_ptr,
6126 const char ** functionname_ptr)
6128 const char * filename = NULL;
6129 asymbol * func = NULL;
6130 bfd_vma low_func = 0;
6133 for (p = symbols; *p != NULL; p++)
6137 q = (elf_symbol_type *) *p;
6139 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
6144 filename = bfd_asymbol_name (&q->symbol);
6149 /* Skip $a and $t symbols. */
6150 if ((q->symbol.flags & BSF_LOCAL)
6151 && bfd_is_arm_mapping_symbol_name (q->symbol.name))
6154 if (bfd_get_section (&q->symbol) == section
6155 && q->symbol.value >= low_func
6156 && q->symbol.value <= offset)
6158 func = (asymbol *) q;
6159 low_func = q->symbol.value;
6169 *filename_ptr = filename;
6170 if (functionname_ptr)
6171 *functionname_ptr = bfd_asymbol_name (func);
6177 /* Find the nearest line to a particular section and offset, for error
6178 reporting. This code is a duplicate of the code in elf.c, except
6179 that it uses arm_elf_find_function. */
6182 elf32_arm_find_nearest_line (bfd * abfd,
6186 const char ** filename_ptr,
6187 const char ** functionname_ptr,
6188 unsigned int * line_ptr)
6190 bfd_boolean found = FALSE;
6192 /* We skip _bfd_dwarf1_find_nearest_line since no known ARM toolchain uses it. */
6194 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
6195 filename_ptr, functionname_ptr,
6197 & elf_tdata (abfd)->dwarf2_find_line_info))
6199 if (!*functionname_ptr)
6200 arm_elf_find_function (abfd, section, symbols, offset,
6201 *filename_ptr ? NULL : filename_ptr,
6207 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
6208 & found, filename_ptr,
6209 functionname_ptr, line_ptr,
6210 & elf_tdata (abfd)->line_info))
6213 if (found && (*functionname_ptr || *line_ptr))
6216 if (symbols == NULL)
6219 if (! arm_elf_find_function (abfd, section, symbols, offset,
6220 filename_ptr, functionname_ptr))
6228 elf32_arm_find_inliner_info (bfd * abfd,
6229 const char ** filename_ptr,
6230 const char ** functionname_ptr,
6231 unsigned int * line_ptr)
6234 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
6235 functionname_ptr, line_ptr,
6236 & elf_tdata (abfd)->dwarf2_find_line_info);
6240 /* Adjust a symbol defined by a dynamic object and referenced by a
6241 regular object. The current definition is in some section of the
6242 dynamic object, but we're not including those sections. We have to
6243 change the definition to something the rest of the link can
6247 elf32_arm_adjust_dynamic_symbol (struct bfd_link_info * info,
6248 struct elf_link_hash_entry * h)
6252 unsigned int power_of_two;
6253 struct elf32_arm_link_hash_entry * eh;
6254 struct elf32_arm_link_hash_table *globals;
6256 globals = elf32_arm_hash_table (info);
6257 dynobj = elf_hash_table (info)->dynobj;
6259 /* Make sure we know what is going on here. */
6260 BFD_ASSERT (dynobj != NULL
6262 || h->u.weakdef != NULL
6265 && !h->def_regular)));
6267 eh = (struct elf32_arm_link_hash_entry *) h;
6269 /* If this is a function, put it in the procedure linkage table. We
6270 will fill in the contents of the procedure linkage table later,
6271 when we know the address of the .got section. */
6272 if (h->type == STT_FUNC || h->type == STT_ARM_TFUNC
6275 if (h->plt.refcount <= 0
6276 || SYMBOL_CALLS_LOCAL (info, h)
6277 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6278 && h->root.type == bfd_link_hash_undefweak))
6280 /* This case can occur if we saw a PLT32 reloc in an input
6281 file, but the symbol was never referred to by a dynamic
6282 object, or if all references were garbage collected. In
6283 such a case, we don't actually need to build a procedure
6284 linkage table, and we can just do a PC24 reloc instead. */
6285 h->plt.offset = (bfd_vma) -1;
6286 eh->plt_thumb_refcount = 0;
6294 /* It's possible that we incorrectly decided a .plt reloc was
6295 needed for an R_ARM_PC24 or similar reloc to a non-function sym
6296 in check_relocs. We can't decide accurately between function
6297 and non-function syms in check-relocs; Objects loaded later in
6298 the link may change h->type. So fix it now. */
6299 h->plt.offset = (bfd_vma) -1;
6300 eh->plt_thumb_refcount = 0;
6303 /* If this is a weak symbol, and there is a real definition, the
6304 processor independent code will have arranged for us to see the
6305 real definition first, and we can just use the same value. */
6306 if (h->u.weakdef != NULL)
6308 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6309 || h->u.weakdef->root.type == bfd_link_hash_defweak);
6310 h->root.u.def.section = h->u.weakdef->root.u.def.section;
6311 h->root.u.def.value = h->u.weakdef->root.u.def.value;
6315 /* If there are no non-GOT references, we do not need a copy
6317 if (!h->non_got_ref)
6320 /* This is a reference to a symbol defined by a dynamic object which
6321 is not a function. */
6323 /* If we are creating a shared library, we must presume that the
6324 only references to the symbol are via the global offset table.
6325 For such cases we need not do anything here; the relocations will
6326 be handled correctly by relocate_section. Relocatable executables
6327 can reference data in shared objects directly, so we don't need to
6328 do anything here. */
6329 if (info->shared || globals->root.is_relocatable_executable)
6334 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
6335 h->root.root.string);
6339 /* We must allocate the symbol in our .dynbss section, which will
6340 become part of the .bss section of the executable. There will be
6341 an entry for this symbol in the .dynsym section. The dynamic
6342 object will contain position independent code, so all references
6343 from the dynamic object to this symbol will go through the global
6344 offset table. The dynamic linker will use the .dynsym entry to
6345 determine the address it must put in the global offset table, so
6346 both the dynamic object and the regular object will refer to the
6347 same memory location for the variable. */
6348 s = bfd_get_section_by_name (dynobj, ".dynbss");
6349 BFD_ASSERT (s != NULL);
6351 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
6352 copy the initial value out of the dynamic object and into the
6353 runtime process image. We need to remember the offset into the
6354 .rel(a).bss section we are going to use. */
6355 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
6359 srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (globals, ".bss"));
6360 BFD_ASSERT (srel != NULL);
6361 srel->size += RELOC_SIZE (globals);
6365 /* We need to figure out the alignment required for this symbol. I
6366 have no idea how ELF linkers handle this. */
6367 power_of_two = bfd_log2 (h->size);
6368 if (power_of_two > 3)
6371 /* Apply the required alignment. */
6372 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
6373 if (power_of_two > bfd_get_section_alignment (dynobj, s))
6375 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
6379 /* Define the symbol as being at this point in the section. */
6380 h->root.u.def.section = s;
6381 h->root.u.def.value = s->size;
6383 /* Increment the section size to make room for the symbol. */
6389 /* Allocate space in .plt, .got and associated reloc sections for
6393 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
6395 struct bfd_link_info *info;
6396 struct elf32_arm_link_hash_table *htab;
6397 struct elf32_arm_link_hash_entry *eh;
6398 struct elf32_arm_relocs_copied *p;
6400 eh = (struct elf32_arm_link_hash_entry *) h;
6402 if (h->root.type == bfd_link_hash_indirect)
6405 if (h->root.type == bfd_link_hash_warning)
6406 /* When warning symbols are created, they **replace** the "real"
6407 entry in the hash table, thus we never get to see the real
6408 symbol in a hash traversal. So look at it now. */
6409 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6411 info = (struct bfd_link_info *) inf;
6412 htab = elf32_arm_hash_table (info);
6414 if (htab->root.dynamic_sections_created
6415 && h->plt.refcount > 0)
6417 /* Make sure this symbol is output as a dynamic symbol.
6418 Undefined weak syms won't yet be marked as dynamic. */
6419 if (h->dynindx == -1
6420 && !h->forced_local)
6422 if (! bfd_elf_link_record_dynamic_symbol (info, h))
6427 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
6429 asection *s = htab->splt;
6431 /* If this is the first .plt entry, make room for the special
6434 s->size += htab->plt_header_size;
6436 h->plt.offset = s->size;
6438 /* If we will insert a Thumb trampoline before this PLT, leave room
6440 if (!htab->use_blx && eh->plt_thumb_refcount > 0)
6442 h->plt.offset += PLT_THUMB_STUB_SIZE;
6443 s->size += PLT_THUMB_STUB_SIZE;
6446 /* If this symbol is not defined in a regular file, and we are
6447 not generating a shared library, then set the symbol to this
6448 location in the .plt. This is required to make function
6449 pointers compare as equal between the normal executable and
6450 the shared library. */
6454 h->root.u.def.section = s;
6455 h->root.u.def.value = h->plt.offset;
6457 /* Make sure the function is not marked as Thumb, in case
6458 it is the target of an ABS32 relocation, which will
6459 point to the PLT entry. */
6460 if (ELF_ST_TYPE (h->type) == STT_ARM_TFUNC)
6461 h->type = ELF_ST_INFO (ELF_ST_BIND (h->type), STT_FUNC);
6464 /* Make room for this entry. */
6465 s->size += htab->plt_entry_size;
6467 if (!htab->symbian_p)
6469 /* We also need to make an entry in the .got.plt section, which
6470 will be placed in the .got section by the linker script. */
6471 eh->plt_got_offset = htab->sgotplt->size;
6472 htab->sgotplt->size += 4;
6475 /* We also need to make an entry in the .rel(a).plt section. */
6476 htab->srelplt->size += RELOC_SIZE (htab);
6478 /* VxWorks executables have a second set of relocations for
6479 each PLT entry. They go in a separate relocation section,
6480 which is processed by the kernel loader. */
6481 if (htab->vxworks_p && !info->shared)
6483 /* There is a relocation for the initial PLT entry:
6484 an R_ARM_32 relocation for _GLOBAL_OFFSET_TABLE_. */
6485 if (h->plt.offset == htab->plt_header_size)
6486 htab->srelplt2->size += RELOC_SIZE (htab);
6488 /* There are two extra relocations for each subsequent
6489 PLT entry: an R_ARM_32 relocation for the GOT entry,
6490 and an R_ARM_32 relocation for the PLT entry. */
6491 htab->srelplt2->size += RELOC_SIZE (htab) * 2;
6496 h->plt.offset = (bfd_vma) -1;
6502 h->plt.offset = (bfd_vma) -1;
6506 if (h->got.refcount > 0)
6510 int tls_type = elf32_arm_hash_entry (h)->tls_type;
6513 /* Make sure this symbol is output as a dynamic symbol.
6514 Undefined weak syms won't yet be marked as dynamic. */
6515 if (h->dynindx == -1
6516 && !h->forced_local)
6518 if (! bfd_elf_link_record_dynamic_symbol (info, h))
6522 if (!htab->symbian_p)
6525 h->got.offset = s->size;
6527 if (tls_type == GOT_UNKNOWN)
6530 if (tls_type == GOT_NORMAL)
6531 /* Non-TLS symbols need one GOT slot. */
6535 if (tls_type & GOT_TLS_GD)
6536 /* R_ARM_TLS_GD32 needs 2 consecutive GOT slots. */
6538 if (tls_type & GOT_TLS_IE)
6539 /* R_ARM_TLS_IE32 needs one GOT slot. */
6543 dyn = htab->root.dynamic_sections_created;
6546 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
6548 || !SYMBOL_REFERENCES_LOCAL (info, h)))
6551 if (tls_type != GOT_NORMAL
6552 && (info->shared || indx != 0)
6553 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
6554 || h->root.type != bfd_link_hash_undefweak))
6556 if (tls_type & GOT_TLS_IE)
6557 htab->srelgot->size += RELOC_SIZE (htab);
6559 if (tls_type & GOT_TLS_GD)
6560 htab->srelgot->size += RELOC_SIZE (htab);
6562 if ((tls_type & GOT_TLS_GD) && indx != 0)
6563 htab->srelgot->size += RELOC_SIZE (htab);
6565 else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
6566 || h->root.type != bfd_link_hash_undefweak)
6568 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
6569 htab->srelgot->size += RELOC_SIZE (htab);
6573 h->got.offset = (bfd_vma) -1;
6575 if (eh->relocs_copied == NULL)
6578 /* In the shared -Bsymbolic case, discard space allocated for
6579 dynamic pc-relative relocs against symbols which turn out to be
6580 defined in regular objects. For the normal shared case, discard
6581 space for pc-relative relocs that have become local due to symbol
6582 visibility changes. */
6584 if (info->shared || htab->root.is_relocatable_executable)
6586 /* The only reloc that uses pc_count is R_ARM_REL32, which will
6587 appear on something like ".long foo - .". We want calls to
6588 protected symbols to resolve directly to the function rather
6589 than going via the plt. If people want function pointer
6590 comparisons to work as expected then they should avoid
6591 writing assembly like ".long foo - .". */
6592 if (SYMBOL_CALLS_LOCAL (info, h))
6594 struct elf32_arm_relocs_copied **pp;
6596 for (pp = &eh->relocs_copied; (p = *pp) != NULL; )
6598 p->count -= p->pc_count;
6607 /* Also discard relocs on undefined weak syms with non-default
6609 if (eh->relocs_copied != NULL
6610 && h->root.type == bfd_link_hash_undefweak)
6612 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
6613 eh->relocs_copied = NULL;
6615 /* Make sure undefined weak symbols are output as a dynamic
6617 else if (h->dynindx == -1
6618 && !h->forced_local)
6620 if (! bfd_elf_link_record_dynamic_symbol (info, h))
6625 else if (htab->root.is_relocatable_executable && h->dynindx == -1
6626 && h->root.type == bfd_link_hash_new)
6628 /* Output absolute symbols so that we can create relocations
6629 against them. For normal symbols we output a relocation
6630 against the section that contains them. */
6631 if (! bfd_elf_link_record_dynamic_symbol (info, h))
6638 /* For the non-shared case, discard space for relocs against
6639 symbols which turn out to need copy relocs or are not
6645 || (htab->root.dynamic_sections_created
6646 && (h->root.type == bfd_link_hash_undefweak
6647 || h->root.type == bfd_link_hash_undefined))))
6649 /* Make sure this symbol is output as a dynamic symbol.
6650 Undefined weak syms won't yet be marked as dynamic. */
6651 if (h->dynindx == -1
6652 && !h->forced_local)
6654 if (! bfd_elf_link_record_dynamic_symbol (info, h))
6658 /* If that succeeded, we know we'll be keeping all the
6660 if (h->dynindx != -1)
6664 eh->relocs_copied = NULL;
6669 /* Finally, allocate space. */
6670 for (p = eh->relocs_copied; p != NULL; p = p->next)
6672 asection *sreloc = elf_section_data (p->section)->sreloc;
6673 sreloc->size += p->count * RELOC_SIZE (htab);
6679 /* Find any dynamic relocs that apply to read-only sections. */
6682 elf32_arm_readonly_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
6684 struct elf32_arm_link_hash_entry *eh;
6685 struct elf32_arm_relocs_copied *p;
6687 if (h->root.type == bfd_link_hash_warning)
6688 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6690 eh = (struct elf32_arm_link_hash_entry *) h;
6691 for (p = eh->relocs_copied; p != NULL; p = p->next)
6693 asection *s = p->section;
6695 if (s != NULL && (s->flags & SEC_READONLY) != 0)
6697 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6699 info->flags |= DF_TEXTREL;
6701 /* Not an error, just cut short the traversal. */
6708 /* Set the sizes of the dynamic sections. */
6711 elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
6712 struct bfd_link_info * info)
6719 struct elf32_arm_link_hash_table *htab;
6721 htab = elf32_arm_hash_table (info);
6722 dynobj = elf_hash_table (info)->dynobj;
6723 BFD_ASSERT (dynobj != NULL);
6724 check_use_blx (htab);
6726 if (elf_hash_table (info)->dynamic_sections_created)
6728 /* Set the contents of the .interp section to the interpreter. */
6729 if (info->executable)
6731 s = bfd_get_section_by_name (dynobj, ".interp");
6732 BFD_ASSERT (s != NULL);
6733 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
6734 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
6738 /* Set up .got offsets for local syms, and space for local dynamic
6740 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6742 bfd_signed_vma *local_got;
6743 bfd_signed_vma *end_local_got;
6744 char *local_tls_type;
6745 bfd_size_type locsymcount;
6746 Elf_Internal_Shdr *symtab_hdr;
6749 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
6752 for (s = ibfd->sections; s != NULL; s = s->next)
6754 struct elf32_arm_relocs_copied *p;
6756 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
6758 if (!bfd_is_abs_section (p->section)
6759 && bfd_is_abs_section (p->section->output_section))
6761 /* Input section has been discarded, either because
6762 it is a copy of a linkonce section or due to
6763 linker script /DISCARD/, so we'll be discarding
6766 else if (p->count != 0)
6768 srel = elf_section_data (p->section)->sreloc;
6769 srel->size += p->count * RELOC_SIZE (htab);
6770 if ((p->section->output_section->flags & SEC_READONLY) != 0)
6771 info->flags |= DF_TEXTREL;
6776 local_got = elf_local_got_refcounts (ibfd);
6780 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
6781 locsymcount = symtab_hdr->sh_info;
6782 end_local_got = local_got + locsymcount;
6783 local_tls_type = elf32_arm_local_got_tls_type (ibfd);
6785 srel = htab->srelgot;
6786 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
6790 *local_got = s->size;
6791 if (*local_tls_type & GOT_TLS_GD)
6792 /* TLS_GD relocs need an 8-byte structure in the GOT. */
6794 if (*local_tls_type & GOT_TLS_IE)
6796 if (*local_tls_type == GOT_NORMAL)
6799 if (info->shared || *local_tls_type == GOT_TLS_GD)
6800 srel->size += RELOC_SIZE (htab);
6803 *local_got = (bfd_vma) -1;
6807 if (htab->tls_ldm_got.refcount > 0)
6809 /* Allocate two GOT entries and one dynamic relocation (if necessary)
6810 for R_ARM_TLS_LDM32 relocations. */
6811 htab->tls_ldm_got.offset = htab->sgot->size;
6812 htab->sgot->size += 8;
6814 htab->srelgot->size += RELOC_SIZE (htab);
6817 htab->tls_ldm_got.offset = -1;
6819 /* Allocate global sym .plt and .got entries, and space for global
6820 sym dynamic relocs. */
6821 elf_link_hash_traverse (& htab->root, allocate_dynrelocs, info);
6823 /* The check_relocs and adjust_dynamic_symbol entry points have
6824 determined the sizes of the various dynamic sections. Allocate
6828 for (s = dynobj->sections; s != NULL; s = s->next)
6832 if ((s->flags & SEC_LINKER_CREATED) == 0)
6835 /* It's OK to base decisions on the section name, because none
6836 of the dynobj section names depend upon the input files. */
6837 name = bfd_get_section_name (dynobj, s);
6839 if (strcmp (name, ".plt") == 0)
6841 /* Remember whether there is a PLT. */
6844 else if (strncmp (name, ".rel", 4) == 0)
6848 /* Remember whether there are any reloc sections other
6849 than .rel(a).plt and .rela.plt.unloaded. */
6850 if (s != htab->srelplt && s != htab->srelplt2)
6853 /* We use the reloc_count field as a counter if we need
6854 to copy relocs into the output file. */
6858 else if (strncmp (name, ".got", 4) != 0
6859 && strcmp (name, ".dynbss") != 0)
6861 /* It's not one of our sections, so don't allocate space. */
6867 /* If we don't need this section, strip it from the
6868 output file. This is mostly to handle .rel(a).bss and
6869 .rel(a).plt. We must create both sections in
6870 create_dynamic_sections, because they must be created
6871 before the linker maps input sections to output
6872 sections. The linker does that before
6873 adjust_dynamic_symbol is called, and it is that
6874 function which decides whether anything needs to go
6875 into these sections. */
6876 s->flags |= SEC_EXCLUDE;
6880 if ((s->flags & SEC_HAS_CONTENTS) == 0)
6883 /* Allocate memory for the section contents. */
6884 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
6885 if (s->contents == NULL)
6889 if (elf_hash_table (info)->dynamic_sections_created)
6891 /* Add some entries to the .dynamic section. We fill in the
6892 values later, in elf32_arm_finish_dynamic_sections, but we
6893 must add the entries now so that we get the correct size for
6894 the .dynamic section. The DT_DEBUG entry is filled in by the
6895 dynamic linker and used by the debugger. */
6896 #define add_dynamic_entry(TAG, VAL) \
6897 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
6899 if (info->executable)
6901 if (!add_dynamic_entry (DT_DEBUG, 0))
6907 if ( !add_dynamic_entry (DT_PLTGOT, 0)
6908 || !add_dynamic_entry (DT_PLTRELSZ, 0)
6909 || !add_dynamic_entry (DT_PLTREL,
6910 htab->use_rel ? DT_REL : DT_RELA)
6911 || !add_dynamic_entry (DT_JMPREL, 0))
6919 if (!add_dynamic_entry (DT_REL, 0)
6920 || !add_dynamic_entry (DT_RELSZ, 0)
6921 || !add_dynamic_entry (DT_RELENT, RELOC_SIZE (htab)))
6926 if (!add_dynamic_entry (DT_RELA, 0)
6927 || !add_dynamic_entry (DT_RELASZ, 0)
6928 || !add_dynamic_entry (DT_RELAENT, RELOC_SIZE (htab)))
6933 /* If any dynamic relocs apply to a read-only section,
6934 then we need a DT_TEXTREL entry. */
6935 if ((info->flags & DF_TEXTREL) == 0)
6936 elf_link_hash_traverse (&htab->root, elf32_arm_readonly_dynrelocs,
6939 if ((info->flags & DF_TEXTREL) != 0)
6941 if (!add_dynamic_entry (DT_TEXTREL, 0))
6945 #undef add_dynamic_entry
6950 /* Finish up dynamic symbol handling. We set the contents of various
6951 dynamic sections here. */
6954 elf32_arm_finish_dynamic_symbol (bfd * output_bfd, struct bfd_link_info * info,
6955 struct elf_link_hash_entry * h, Elf_Internal_Sym * sym)
6958 struct elf32_arm_link_hash_table *htab;
6959 struct elf32_arm_link_hash_entry *eh;
6961 dynobj = elf_hash_table (info)->dynobj;
6962 htab = elf32_arm_hash_table (info);
6963 eh = (struct elf32_arm_link_hash_entry *) h;
6965 if (h->plt.offset != (bfd_vma) -1)
6971 Elf_Internal_Rela rel;
6973 /* This symbol has an entry in the procedure linkage table. Set
6976 BFD_ASSERT (h->dynindx != -1);
6978 splt = bfd_get_section_by_name (dynobj, ".plt");
6979 srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (htab, ".plt"));
6980 BFD_ASSERT (splt != NULL && srel != NULL);
6982 /* Fill in the entry in the procedure linkage table. */
6983 if (htab->symbian_p)
6986 for (i = 0; i < htab->plt_entry_size / 4; ++i)
6987 bfd_put_32 (output_bfd,
6988 elf32_arm_symbian_plt_entry[i],
6989 splt->contents + h->plt.offset + 4 * i);
6991 /* Fill in the entry in the .rel.plt section. */
6992 rel.r_offset = (splt->output_section->vma
6993 + splt->output_offset
6994 + h->plt.offset + 4 * (i - 1));
6995 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
6997 /* Get the index in the procedure linkage table which
6998 corresponds to this symbol. This is the index of this symbol
6999 in all the symbols for which we are making plt entries. The
7000 first entry in the procedure linkage table is reserved. */
7001 plt_index = ((h->plt.offset - htab->plt_header_size)
7002 / htab->plt_entry_size);
7006 bfd_vma got_offset, got_address, plt_address;
7007 bfd_vma got_displacement;
7010 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
7011 BFD_ASSERT (sgot != NULL);
7013 /* Get the offset into the .got.plt table of the entry that
7014 corresponds to this function. */
7015 got_offset = eh->plt_got_offset;
7017 /* Get the index in the procedure linkage table which
7018 corresponds to this symbol. This is the index of this symbol
7019 in all the symbols for which we are making plt entries. The
7020 first three entries in .got.plt are reserved; after that
7021 symbols appear in the same order as in .plt. */
7022 plt_index = (got_offset - 12) / 4;
7024 /* Calculate the address of the GOT entry. */
7025 got_address = (sgot->output_section->vma
7026 + sgot->output_offset
7029 /* ...and the address of the PLT entry. */
7030 plt_address = (splt->output_section->vma
7031 + splt->output_offset
7034 if (htab->vxworks_p && info->shared)
7039 for (i = 0; i != htab->plt_entry_size / 4; i++)
7041 val = elf32_arm_vxworks_shared_plt_entry[i];
7043 val |= got_address - sgot->output_section->vma;
7045 val |= plt_index * RELOC_SIZE (htab);
7046 bfd_put_32 (output_bfd, val,
7047 htab->splt->contents + h->plt.offset + i * 4);
7050 else if (htab->vxworks_p)
7055 for (i = 0; i != htab->plt_entry_size / 4; i++)
7057 val = elf32_arm_vxworks_exec_plt_entry[i];
7061 val |= 0xffffff & -((h->plt.offset + i * 4 + 8) >> 2);
7063 val |= plt_index * RELOC_SIZE (htab);
7064 bfd_put_32 (output_bfd, val,
7065 htab->splt->contents + h->plt.offset + i * 4);
7068 loc = (htab->srelplt2->contents
7069 + (plt_index * 2 + 1) * RELOC_SIZE (htab));
7071 /* Create the .rela.plt.unloaded R_ARM_ABS32 relocation
7072 referencing the GOT for this PLT entry. */
7073 rel.r_offset = plt_address + 8;
7074 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
7075 rel.r_addend = got_offset;
7076 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
7077 loc += RELOC_SIZE (htab);
7079 /* Create the R_ARM_ABS32 relocation referencing the
7080 beginning of the PLT for this GOT entry. */
7081 rel.r_offset = got_address;
7082 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_ARM_ABS32);
7084 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
7088 /* Calculate the displacement between the PLT slot and the
7089 entry in the GOT. The eight-byte offset accounts for the
7090 value produced by adding to pc in the first instruction
7092 got_displacement = got_address - (plt_address + 8);
7094 BFD_ASSERT ((got_displacement & 0xf0000000) == 0);
7096 if (!htab->use_blx && eh->plt_thumb_refcount > 0)
7098 bfd_put_16 (output_bfd, elf32_arm_plt_thumb_stub[0],
7099 splt->contents + h->plt.offset - 4);
7100 bfd_put_16 (output_bfd, elf32_arm_plt_thumb_stub[1],
7101 splt->contents + h->plt.offset - 2);
7104 bfd_put_32 (output_bfd,
7105 elf32_arm_plt_entry[0]
7106 | ((got_displacement & 0x0ff00000) >> 20),
7107 splt->contents + h->plt.offset + 0);
7108 bfd_put_32 (output_bfd,
7109 elf32_arm_plt_entry[1]
7110 | ((got_displacement & 0x000ff000) >> 12),
7111 splt->contents + h->plt.offset + 4);
7112 bfd_put_32 (output_bfd,
7113 elf32_arm_plt_entry[2]
7114 | (got_displacement & 0x00000fff),
7115 splt->contents + h->plt.offset + 8);
7116 #ifdef FOUR_WORD_PLT
7117 bfd_put_32 (output_bfd, elf32_arm_plt_entry[3],
7118 splt->contents + h->plt.offset + 12);
7122 /* Fill in the entry in the global offset table. */
7123 bfd_put_32 (output_bfd,
7124 (splt->output_section->vma
7125 + splt->output_offset),
7126 sgot->contents + got_offset);
7128 /* Fill in the entry in the .rel(a).plt section. */
7130 rel.r_offset = got_address;
7131 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
7134 loc = srel->contents + plt_index * RELOC_SIZE (htab);
7135 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
7137 if (!h->def_regular)
7139 /* Mark the symbol as undefined, rather than as defined in
7140 the .plt section. Leave the value alone. */
7141 sym->st_shndx = SHN_UNDEF;
7142 /* If the symbol is weak, we do need to clear the value.
7143 Otherwise, the PLT entry would provide a definition for
7144 the symbol even if the symbol wasn't defined anywhere,
7145 and so the symbol would never be NULL. */
7146 if (!h->ref_regular_nonweak)
7151 if (h->got.offset != (bfd_vma) -1
7152 && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_GD) == 0
7153 && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_IE) == 0)
7157 Elf_Internal_Rela rel;
7161 /* This symbol has an entry in the global offset table. Set it
7163 sgot = bfd_get_section_by_name (dynobj, ".got");
7164 srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (htab, ".got"));
7165 BFD_ASSERT (sgot != NULL && srel != NULL);
7167 offset = (h->got.offset & ~(bfd_vma) 1);
7169 rel.r_offset = (sgot->output_section->vma
7170 + sgot->output_offset
7173 /* If this is a static link, or it is a -Bsymbolic link and the
7174 symbol is defined locally or was forced to be local because
7175 of a version file, we just want to emit a RELATIVE reloc.
7176 The entry in the global offset table will already have been
7177 initialized in the relocate_section function. */
7179 && SYMBOL_REFERENCES_LOCAL (info, h))
7181 BFD_ASSERT((h->got.offset & 1) != 0);
7182 rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
7185 rel.r_addend = bfd_get_32 (output_bfd, sgot->contents + offset);
7186 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset);
7191 BFD_ASSERT((h->got.offset & 1) == 0);
7192 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset);
7193 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
7196 loc = srel->contents + srel->reloc_count++ * RELOC_SIZE (htab);
7197 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
7203 Elf_Internal_Rela rel;
7206 /* This symbol needs a copy reloc. Set it up. */
7207 BFD_ASSERT (h->dynindx != -1
7208 && (h->root.type == bfd_link_hash_defined
7209 || h->root.type == bfd_link_hash_defweak));
7211 s = bfd_get_section_by_name (h->root.u.def.section->owner,
7212 RELOC_SECTION (htab, ".bss"));
7213 BFD_ASSERT (s != NULL);
7216 rel.r_offset = (h->root.u.def.value
7217 + h->root.u.def.section->output_section->vma
7218 + h->root.u.def.section->output_offset);
7219 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
7220 loc = s->contents + s->reloc_count++ * RELOC_SIZE (htab);
7221 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
7224 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. On VxWorks,
7225 the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: it is relative
7226 to the ".got" section. */
7227 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
7228 || (!htab->vxworks_p && h == htab->root.hgot))
7229 sym->st_shndx = SHN_ABS;
7234 /* Finish up the dynamic sections. */
7237 elf32_arm_finish_dynamic_sections (bfd * output_bfd, struct bfd_link_info * info)
7243 dynobj = elf_hash_table (info)->dynobj;
7245 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
7246 BFD_ASSERT (elf32_arm_hash_table (info)->symbian_p || sgot != NULL);
7247 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
7249 if (elf_hash_table (info)->dynamic_sections_created)
7252 Elf32_External_Dyn *dyncon, *dynconend;
7253 struct elf32_arm_link_hash_table *htab;
7255 htab = elf32_arm_hash_table (info);
7256 splt = bfd_get_section_by_name (dynobj, ".plt");
7257 BFD_ASSERT (splt != NULL && sdyn != NULL);
7259 dyncon = (Elf32_External_Dyn *) sdyn->contents;
7260 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
7262 for (; dyncon < dynconend; dyncon++)
7264 Elf_Internal_Dyn dyn;
7268 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
7279 goto get_vma_if_bpabi;
7282 goto get_vma_if_bpabi;
7285 goto get_vma_if_bpabi;
7287 name = ".gnu.version";
7288 goto get_vma_if_bpabi;
7290 name = ".gnu.version_d";
7291 goto get_vma_if_bpabi;
7293 name = ".gnu.version_r";
7294 goto get_vma_if_bpabi;
7300 name = RELOC_SECTION (htab, ".plt");
7302 s = bfd_get_section_by_name (output_bfd, name);
7303 BFD_ASSERT (s != NULL);
7304 if (!htab->symbian_p)
7305 dyn.d_un.d_ptr = s->vma;
7307 /* In the BPABI, tags in the PT_DYNAMIC section point
7308 at the file offset, not the memory address, for the
7309 convenience of the post linker. */
7310 dyn.d_un.d_ptr = s->filepos;
7311 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7315 if (htab->symbian_p)
7320 s = bfd_get_section_by_name (output_bfd,
7321 RELOC_SECTION (htab, ".plt"));
7322 BFD_ASSERT (s != NULL);
7323 dyn.d_un.d_val = s->size;
7324 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7329 if (!htab->symbian_p)
7331 /* My reading of the SVR4 ABI indicates that the
7332 procedure linkage table relocs (DT_JMPREL) should be
7333 included in the overall relocs (DT_REL). This is
7334 what Solaris does. However, UnixWare can not handle
7335 that case. Therefore, we override the DT_RELSZ entry
7336 here to make it not include the JMPREL relocs. Since
7337 the linker script arranges for .rel(a).plt to follow all
7338 other relocation sections, we don't have to worry
7339 about changing the DT_REL entry. */
7340 s = bfd_get_section_by_name (output_bfd,
7341 RELOC_SECTION (htab, ".plt"));
7343 dyn.d_un.d_val -= s->size;
7344 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7351 /* In the BPABI, the DT_REL tag must point at the file
7352 offset, not the VMA, of the first relocation
7353 section. So, we use code similar to that in
7354 elflink.c, but do not check for SHF_ALLOC on the
7355 relcoation section, since relocations sections are
7356 never allocated under the BPABI. The comments above
7357 about Unixware notwithstanding, we include all of the
7358 relocations here. */
7359 if (htab->symbian_p)
7362 type = ((dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
7363 ? SHT_REL : SHT_RELA);
7365 for (i = 1; i < elf_numsections (output_bfd); i++)
7367 Elf_Internal_Shdr *hdr
7368 = elf_elfsections (output_bfd)[i];
7369 if (hdr->sh_type == type)
7371 if (dyn.d_tag == DT_RELSZ
7372 || dyn.d_tag == DT_RELASZ)
7373 dyn.d_un.d_val += hdr->sh_size;
7374 else if ((ufile_ptr) hdr->sh_offset
7375 <= dyn.d_un.d_val - 1)
7376 dyn.d_un.d_val = hdr->sh_offset;
7379 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7383 /* Set the bottom bit of DT_INIT/FINI if the
7384 corresponding function is Thumb. */
7386 name = info->init_function;
7389 name = info->fini_function;
7391 /* If it wasn't set by elf_bfd_final_link
7392 then there is nothing to adjust. */
7393 if (dyn.d_un.d_val != 0)
7395 struct elf_link_hash_entry * eh;
7397 eh = elf_link_hash_lookup (elf_hash_table (info), name,
7398 FALSE, FALSE, TRUE);
7399 if (eh != (struct elf_link_hash_entry *) NULL
7400 && ELF_ST_TYPE (eh->type) == STT_ARM_TFUNC)
7402 dyn.d_un.d_val |= 1;
7403 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7410 /* Fill in the first entry in the procedure linkage table. */
7411 if (splt->size > 0 && elf32_arm_hash_table (info)->plt_header_size)
7413 const bfd_vma *plt0_entry;
7414 bfd_vma got_address, plt_address, got_displacement;
7416 /* Calculate the addresses of the GOT and PLT. */
7417 got_address = sgot->output_section->vma + sgot->output_offset;
7418 plt_address = splt->output_section->vma + splt->output_offset;
7420 if (htab->vxworks_p)
7422 /* The VxWorks GOT is relocated by the dynamic linker.
7423 Therefore, we must emit relocations rather than simply
7424 computing the values now. */
7425 Elf_Internal_Rela rel;
7427 plt0_entry = elf32_arm_vxworks_exec_plt0_entry;
7428 bfd_put_32 (output_bfd, plt0_entry[0], splt->contents + 0);
7429 bfd_put_32 (output_bfd, plt0_entry[1], splt->contents + 4);
7430 bfd_put_32 (output_bfd, plt0_entry[2], splt->contents + 8);
7431 bfd_put_32 (output_bfd, got_address, splt->contents + 12);
7433 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_. */
7434 rel.r_offset = plt_address + 12;
7435 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
7437 SWAP_RELOC_OUT (htab) (output_bfd, &rel,
7438 htab->srelplt2->contents);
7442 got_displacement = got_address - (plt_address + 16);
7444 plt0_entry = elf32_arm_plt0_entry;
7445 bfd_put_32 (output_bfd, plt0_entry[0], splt->contents + 0);
7446 bfd_put_32 (output_bfd, plt0_entry[1], splt->contents + 4);
7447 bfd_put_32 (output_bfd, plt0_entry[2], splt->contents + 8);
7448 bfd_put_32 (output_bfd, plt0_entry[3], splt->contents + 12);
7450 #ifdef FOUR_WORD_PLT
7451 /* The displacement value goes in the otherwise-unused
7452 last word of the second entry. */
7453 bfd_put_32 (output_bfd, got_displacement, splt->contents + 28);
7455 bfd_put_32 (output_bfd, got_displacement, splt->contents + 16);
7460 /* UnixWare sets the entsize of .plt to 4, although that doesn't
7461 really seem like the right value. */
7462 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
7464 if (htab->vxworks_p && !info->shared && htab->splt->size > 0)
7466 /* Correct the .rel(a).plt.unloaded relocations. They will have
7467 incorrect symbol indexes. */
7471 num_plts = ((htab->splt->size - htab->plt_header_size)
7472 / htab->plt_entry_size);
7473 p = htab->srelplt2->contents + RELOC_SIZE (htab);
7475 for (; num_plts; num_plts--)
7477 Elf_Internal_Rela rel;
7479 SWAP_RELOC_IN (htab) (output_bfd, p, &rel);
7480 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
7481 SWAP_RELOC_OUT (htab) (output_bfd, &rel, p);
7482 p += RELOC_SIZE (htab);
7484 SWAP_RELOC_IN (htab) (output_bfd, p, &rel);
7485 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_ARM_ABS32);
7486 SWAP_RELOC_OUT (htab) (output_bfd, &rel, p);
7487 p += RELOC_SIZE (htab);
7492 /* Fill in the first three entries in the global offset table. */
7498 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
7500 bfd_put_32 (output_bfd,
7501 sdyn->output_section->vma + sdyn->output_offset,
7503 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
7504 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
7507 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
7514 elf32_arm_post_process_headers (bfd * abfd, struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
7516 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
7517 struct elf32_arm_link_hash_table *globals;
7519 i_ehdrp = elf_elfheader (abfd);
7521 if (EF_ARM_EABI_VERSION (i_ehdrp->e_flags) == EF_ARM_EABI_UNKNOWN)
7522 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_ARM;
7524 i_ehdrp->e_ident[EI_OSABI] = 0;
7525 i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
7529 globals = elf32_arm_hash_table (link_info);
7530 if (globals->byteswap_code)
7531 i_ehdrp->e_flags |= EF_ARM_BE8;
7535 static enum elf_reloc_type_class
7536 elf32_arm_reloc_type_class (const Elf_Internal_Rela *rela)
7538 switch ((int) ELF32_R_TYPE (rela->r_info))
7540 case R_ARM_RELATIVE:
7541 return reloc_class_relative;
7542 case R_ARM_JUMP_SLOT:
7543 return reloc_class_plt;
7545 return reloc_class_copy;
7547 return reloc_class_normal;
7551 /* Set the right machine number for an Arm ELF file. */
7554 elf32_arm_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
7556 if (hdr->sh_type == SHT_NOTE)
7557 *flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_CONTENTS;
7563 elf32_arm_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
7565 bfd_arm_update_notes (abfd, ARM_NOTE_SECTION);
7568 /* Return TRUE if this is an unwinding table entry. */
7571 is_arm_elf_unwind_section_name (bfd * abfd ATTRIBUTE_UNUSED, const char * name)
7575 len1 = sizeof (ELF_STRING_ARM_unwind) - 1;
7576 len2 = sizeof (ELF_STRING_ARM_unwind_once) - 1;
7577 return (strncmp (name, ELF_STRING_ARM_unwind, len1) == 0
7578 || strncmp (name, ELF_STRING_ARM_unwind_once, len2) == 0);
7582 /* Set the type and flags for an ARM section. We do this by
7583 the section name, which is a hack, but ought to work. */
7586 elf32_arm_fake_sections (bfd * abfd, Elf_Internal_Shdr * hdr, asection * sec)
7590 name = bfd_get_section_name (abfd, sec);
7592 if (is_arm_elf_unwind_section_name (abfd, name))
7594 hdr->sh_type = SHT_ARM_EXIDX;
7595 hdr->sh_flags |= SHF_LINK_ORDER;
7597 else if (strcmp(name, ".ARM.attributes") == 0)
7599 hdr->sh_type = SHT_ARM_ATTRIBUTES;
7604 /* Parse an Arm EABI attributes section. */
7606 elf32_arm_parse_attributes (bfd *abfd, Elf_Internal_Shdr * hdr)
7612 contents = bfd_malloc (hdr->sh_size);
7615 if (!bfd_get_section_contents (abfd, hdr->bfd_section, contents, 0,
7624 len = hdr->sh_size - 1;
7628 bfd_vma section_len;
7630 section_len = bfd_get_32 (abfd, p);
7632 if (section_len > len)
7635 namelen = strlen ((char *)p) + 1;
7636 section_len -= namelen + 4;
7637 if (strcmp((char *)p, "aeabi") != 0)
7639 /* Vendor section. Ignore it. */
7640 p += namelen + section_len;
7645 while (section_len > 0)
7650 bfd_vma subsection_len;
7653 tag = read_unsigned_leb128 (abfd, p, &n);
7655 subsection_len = bfd_get_32 (abfd, p);
7657 if (subsection_len > section_len)
7658 subsection_len = section_len;
7659 section_len -= subsection_len;
7660 subsection_len -= n + 4;
7661 end = p + subsection_len;
7667 bfd_boolean is_string;
7669 tag = read_unsigned_leb128 (abfd, p, &n);
7671 if (tag == 4 || tag == 5)
7676 is_string = (tag & 1) != 0;
7677 if (tag == Tag_compatibility)
7679 val = read_unsigned_leb128 (abfd, p, &n);
7681 elf32_arm_add_eabi_attr_compat (abfd, val,
7683 p += strlen ((char *)p) + 1;
7687 elf32_arm_add_eabi_attr_string (abfd, tag,
7689 p += strlen ((char *)p) + 1;
7693 val = read_unsigned_leb128 (abfd, p, &n);
7695 elf32_arm_add_eabi_attr_int (abfd, tag, val);
7701 /* Don't have anywhere convenient to attach these.
7702 Fall through for now. */
7704 /* Ignore things we don't kow about. */
7705 p += subsection_len;
7716 /* Handle an ARM specific section when reading an object file. This is
7717 called when bfd_section_from_shdr finds a section with an unknown
7721 elf32_arm_section_from_shdr (bfd *abfd,
7722 Elf_Internal_Shdr * hdr,
7726 /* There ought to be a place to keep ELF backend specific flags, but
7727 at the moment there isn't one. We just keep track of the
7728 sections by their name, instead. Fortunately, the ABI gives
7729 names for all the ARM specific sections, so we will probably get
7731 switch (hdr->sh_type)
7734 case SHT_ARM_PREEMPTMAP:
7735 case SHT_ARM_ATTRIBUTES:
7742 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
7745 if (hdr->sh_type == SHT_ARM_ATTRIBUTES)
7746 elf32_arm_parse_attributes(abfd, hdr);
7750 /* A structure used to record a list of sections, independently
7751 of the next and prev fields in the asection structure. */
7752 typedef struct section_list
7755 struct section_list * next;
7756 struct section_list * prev;
7760 /* Unfortunately we need to keep a list of sections for which
7761 an _arm_elf_section_data structure has been allocated. This
7762 is because it is possible for functions like elf32_arm_write_section
7763 to be called on a section which has had an elf_data_structure
7764 allocated for it (and so the used_by_bfd field is valid) but
7765 for which the ARM extended version of this structure - the
7766 _arm_elf_section_data structure - has not been allocated. */
7767 static section_list * sections_with_arm_elf_section_data = NULL;
7770 record_section_with_arm_elf_section_data (asection * sec)
7772 struct section_list * entry;
7774 entry = bfd_malloc (sizeof (* entry));
7778 entry->next = sections_with_arm_elf_section_data;
7780 if (entry->next != NULL)
7781 entry->next->prev = entry;
7782 sections_with_arm_elf_section_data = entry;
7785 static struct section_list *
7786 find_arm_elf_section_entry (asection * sec)
7788 struct section_list * entry;
7789 static struct section_list * last_entry = NULL;
7791 /* This is a short cut for the typical case where the sections are added
7792 to the sections_with_arm_elf_section_data list in forward order and
7793 then looked up here in backwards order. This makes a real difference
7794 to the ld-srec/sec64k.exp linker test. */
7795 entry = sections_with_arm_elf_section_data;
7796 if (last_entry != NULL)
7798 if (last_entry->sec == sec)
7800 else if (last_entry->next != NULL
7801 && last_entry->next->sec == sec)
7802 entry = last_entry->next;
7805 for (; entry; entry = entry->next)
7806 if (entry->sec == sec)
7810 /* Record the entry prior to this one - it is the entry we are most
7811 likely to want to locate next time. Also this way if we have been
7812 called from unrecord_section_with_arm_elf_section_data() we will not
7813 be caching a pointer that is about to be freed. */
7814 last_entry = entry->prev;
7819 static _arm_elf_section_data *
7820 get_arm_elf_section_data (asection * sec)
7822 struct section_list * entry;
7824 entry = find_arm_elf_section_entry (sec);
7827 return elf32_arm_section_data (entry->sec);
7833 unrecord_section_with_arm_elf_section_data (asection * sec)
7835 struct section_list * entry;
7837 entry = find_arm_elf_section_entry (sec);
7841 if (entry->prev != NULL)
7842 entry->prev->next = entry->next;
7843 if (entry->next != NULL)
7844 entry->next->prev = entry->prev;
7845 if (entry == sections_with_arm_elf_section_data)
7846 sections_with_arm_elf_section_data = entry->next;
7851 /* Called for each symbol. Builds a section map based on mapping symbols.
7852 Does not alter any of the symbols. */
7855 elf32_arm_output_symbol_hook (struct bfd_link_info *info,
7857 Elf_Internal_Sym *elfsym,
7858 asection *input_sec,
7859 struct elf_link_hash_entry *h)
7862 elf32_arm_section_map *map;
7863 elf32_arm_section_map *newmap;
7864 _arm_elf_section_data *arm_data;
7865 struct elf32_arm_link_hash_table *globals;
7867 globals = elf32_arm_hash_table (info);
7868 if (globals->vxworks_p
7869 && !elf_vxworks_link_output_symbol_hook (info, name, elfsym,
7873 /* Only do this on final link. */
7874 if (info->relocatable)
7877 /* Only build a map if we need to byteswap code. */
7878 if (!globals->byteswap_code)
7881 /* We only want mapping symbols. */
7882 if (! bfd_is_arm_mapping_symbol_name (name))
7885 /* If this section has not been allocated an _arm_elf_section_data
7886 structure then we cannot record anything. */
7887 arm_data = get_arm_elf_section_data (input_sec);
7888 if (arm_data == NULL)
7891 mapcount = arm_data->mapcount + 1;
7892 map = arm_data->map;
7894 /* TODO: This may be inefficient, but we probably don't usually have many
7895 mapping symbols per section. */
7896 newmap = bfd_realloc (map, mapcount * sizeof (* map));
7899 arm_data->map = newmap;
7900 arm_data->mapcount = mapcount;
7902 newmap[mapcount - 1].vma = elfsym->st_value;
7903 newmap[mapcount - 1].type = name[1];
7909 /* Allocate target specific section data. */
7912 elf32_arm_new_section_hook (bfd *abfd, asection *sec)
7914 if (!sec->used_by_bfd)
7916 _arm_elf_section_data *sdata;
7917 bfd_size_type amt = sizeof (*sdata);
7919 sdata = bfd_zalloc (abfd, amt);
7922 sec->used_by_bfd = sdata;
7925 record_section_with_arm_elf_section_data (sec);
7927 return _bfd_elf_new_section_hook (abfd, sec);
7931 /* Used to order a list of mapping symbols by address. */
7934 elf32_arm_compare_mapping (const void * a, const void * b)
7936 return ((const elf32_arm_section_map *) a)->vma
7937 > ((const elf32_arm_section_map *) b)->vma;
7941 /* Do code byteswapping. Return FALSE afterwards so that the section is
7942 written out as normal. */
7945 elf32_arm_write_section (bfd *output_bfd ATTRIBUTE_UNUSED, asection *sec,
7949 _arm_elf_section_data *arm_data;
7950 elf32_arm_section_map *map;
7957 /* If this section has not been allocated an _arm_elf_section_data
7958 structure then we cannot record anything. */
7959 arm_data = get_arm_elf_section_data (sec);
7960 if (arm_data == NULL)
7963 mapcount = arm_data->mapcount;
7964 map = arm_data->map;
7969 qsort (map, mapcount, sizeof (* map), elf32_arm_compare_mapping);
7971 offset = sec->output_section->vma + sec->output_offset;
7972 ptr = map[0].vma - offset;
7973 for (i = 0; i < mapcount; i++)
7975 if (i == mapcount - 1)
7978 end = map[i + 1].vma - offset;
7980 switch (map[i].type)
7983 /* Byte swap code words. */
7984 while (ptr + 3 < end)
7986 tmp = contents[ptr];
7987 contents[ptr] = contents[ptr + 3];
7988 contents[ptr + 3] = tmp;
7989 tmp = contents[ptr + 1];
7990 contents[ptr + 1] = contents[ptr + 2];
7991 contents[ptr + 2] = tmp;
7997 /* Byte swap code halfwords. */
7998 while (ptr + 1 < end)
8000 tmp = contents[ptr];
8001 contents[ptr] = contents[ptr + 1];
8002 contents[ptr + 1] = tmp;
8008 /* Leave data alone. */
8015 arm_data->mapcount = 0;
8016 arm_data->map = NULL;
8017 unrecord_section_with_arm_elf_section_data (sec);
8023 unrecord_section_via_map_over_sections (bfd * abfd ATTRIBUTE_UNUSED,
8025 void * ignore ATTRIBUTE_UNUSED)
8027 unrecord_section_with_arm_elf_section_data (sec);
8031 elf32_arm_close_and_cleanup (bfd * abfd)
8034 bfd_map_over_sections (abfd,
8035 unrecord_section_via_map_over_sections,
8038 return _bfd_elf_close_and_cleanup (abfd);
8042 elf32_arm_bfd_free_cached_info (bfd * abfd)
8045 bfd_map_over_sections (abfd,
8046 unrecord_section_via_map_over_sections,
8049 return _bfd_free_cached_info (abfd);
8052 /* Display STT_ARM_TFUNC symbols as functions. */
8055 elf32_arm_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
8058 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
8060 if (ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_ARM_TFUNC)
8061 elfsym->symbol.flags |= BSF_FUNCTION;
8065 /* Mangle thumb function symbols as we read them in. */
8068 elf32_arm_swap_symbol_in (bfd * abfd,
8071 Elf_Internal_Sym *dst)
8073 bfd_elf32_swap_symbol_in (abfd, psrc, pshn, dst);
8075 /* New EABI objects mark thumb function symbols by setting the low bit of
8076 the address. Turn these into STT_ARM_TFUNC. */
8077 if (ELF_ST_TYPE (dst->st_info) == STT_FUNC
8078 && (dst->st_value & 1))
8080 dst->st_info = ELF_ST_INFO (ELF_ST_BIND (dst->st_info), STT_ARM_TFUNC);
8081 dst->st_value &= ~(bfd_vma) 1;
8086 /* Mangle thumb function symbols as we write them out. */
8089 elf32_arm_swap_symbol_out (bfd *abfd,
8090 const Elf_Internal_Sym *src,
8094 Elf_Internal_Sym newsym;
8096 /* We convert STT_ARM_TFUNC symbols into STT_FUNC with the low bit
8097 of the address set, as per the new EABI. We do this unconditionally
8098 because objcopy does not set the elf header flags until after
8099 it writes out the symbol table. */
8100 if (ELF_ST_TYPE (src->st_info) == STT_ARM_TFUNC)
8103 newsym.st_info = ELF_ST_INFO (ELF_ST_BIND (src->st_info), STT_FUNC);
8104 newsym.st_value |= 1;
8108 bfd_elf32_swap_symbol_out (abfd, src, cdst, shndx);
8111 /* Add the PT_ARM_EXIDX program header. */
8114 elf32_arm_modify_segment_map (bfd *abfd,
8115 struct bfd_link_info *info ATTRIBUTE_UNUSED)
8117 struct elf_segment_map *m;
8120 sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
8121 if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
8123 /* If there is already a PT_ARM_EXIDX header, then we do not
8124 want to add another one. This situation arises when running
8125 "strip"; the input binary already has the header. */
8126 m = elf_tdata (abfd)->segment_map;
8127 while (m && m->p_type != PT_ARM_EXIDX)
8131 m = bfd_zalloc (abfd, sizeof (struct elf_segment_map));
8134 m->p_type = PT_ARM_EXIDX;
8136 m->sections[0] = sec;
8138 m->next = elf_tdata (abfd)->segment_map;
8139 elf_tdata (abfd)->segment_map = m;
8146 /* We may add a PT_ARM_EXIDX program header. */
8149 elf32_arm_additional_program_headers (bfd *abfd)
8153 sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
8154 if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
8160 /* We use this to override swap_symbol_in and swap_symbol_out. */
8161 const struct elf_size_info elf32_arm_size_info = {
8162 sizeof (Elf32_External_Ehdr),
8163 sizeof (Elf32_External_Phdr),
8164 sizeof (Elf32_External_Shdr),
8165 sizeof (Elf32_External_Rel),
8166 sizeof (Elf32_External_Rela),
8167 sizeof (Elf32_External_Sym),
8168 sizeof (Elf32_External_Dyn),
8169 sizeof (Elf_External_Note),
8173 ELFCLASS32, EV_CURRENT,
8174 bfd_elf32_write_out_phdrs,
8175 bfd_elf32_write_shdrs_and_ehdr,
8176 bfd_elf32_write_relocs,
8177 elf32_arm_swap_symbol_in,
8178 elf32_arm_swap_symbol_out,
8179 bfd_elf32_slurp_reloc_table,
8180 bfd_elf32_slurp_symbol_table,
8181 bfd_elf32_swap_dyn_in,
8182 bfd_elf32_swap_dyn_out,
8183 bfd_elf32_swap_reloc_in,
8184 bfd_elf32_swap_reloc_out,
8185 bfd_elf32_swap_reloca_in,
8186 bfd_elf32_swap_reloca_out
8189 #define ELF_ARCH bfd_arch_arm
8190 #define ELF_MACHINE_CODE EM_ARM
8191 #ifdef __QNXTARGET__
8192 #define ELF_MAXPAGESIZE 0x1000
8194 #define ELF_MAXPAGESIZE 0x8000
8196 #define ELF_MINPAGESIZE 0x1000
8198 #define bfd_elf32_mkobject elf32_arm_mkobject
8200 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
8201 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
8202 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
8203 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
8204 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
8205 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
8206 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
8207 #define bfd_elf32_find_inliner_info elf32_arm_find_inliner_info
8208 #define bfd_elf32_new_section_hook elf32_arm_new_section_hook
8209 #define bfd_elf32_bfd_is_target_special_symbol elf32_arm_is_target_special_symbol
8210 #define bfd_elf32_close_and_cleanup elf32_arm_close_and_cleanup
8211 #define bfd_elf32_bfd_free_cached_info elf32_arm_bfd_free_cached_info
8212 #define bfd_elf32_bfd_final_link elf32_arm_bfd_final_link
8214 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
8215 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
8216 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
8217 #define elf_backend_check_relocs elf32_arm_check_relocs
8218 #define elf_backend_relocate_section elf32_arm_relocate_section
8219 #define elf_backend_write_section elf32_arm_write_section
8220 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
8221 #define elf_backend_create_dynamic_sections elf32_arm_create_dynamic_sections
8222 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
8223 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
8224 #define elf_backend_link_output_symbol_hook elf32_arm_output_symbol_hook
8225 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
8226 #define elf_backend_post_process_headers elf32_arm_post_process_headers
8227 #define elf_backend_reloc_type_class elf32_arm_reloc_type_class
8228 #define elf_backend_object_p elf32_arm_object_p
8229 #define elf_backend_section_flags elf32_arm_section_flags
8230 #define elf_backend_fake_sections elf32_arm_fake_sections
8231 #define elf_backend_section_from_shdr elf32_arm_section_from_shdr
8232 #define elf_backend_final_write_processing elf32_arm_final_write_processing
8233 #define elf_backend_copy_indirect_symbol elf32_arm_copy_indirect_symbol
8234 #define elf_backend_symbol_processing elf32_arm_symbol_processing
8235 #define elf_backend_size_info elf32_arm_size_info
8236 #define elf_backend_modify_segment_map elf32_arm_modify_segment_map
8237 #define elf_backend_additional_program_headers \
8238 elf32_arm_additional_program_headers
8240 #define elf_backend_can_refcount 1
8241 #define elf_backend_can_gc_sections 1
8242 #define elf_backend_plt_readonly 1
8243 #define elf_backend_want_got_plt 1
8244 #define elf_backend_want_plt_sym 0
8245 #define elf_backend_may_use_rel_p 1
8246 #define elf_backend_may_use_rela_p 0
8247 #define elf_backend_default_use_rela_p 0
8248 #define elf_backend_rela_normal 0
8250 #define elf_backend_got_header_size 12
8252 #include "elf32-target.h"
8254 /* VxWorks Targets */
8256 #undef TARGET_LITTLE_SYM
8257 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_vxworks_vec
8258 #undef TARGET_LITTLE_NAME
8259 #define TARGET_LITTLE_NAME "elf32-littlearm-vxworks"
8260 #undef TARGET_BIG_SYM
8261 #define TARGET_BIG_SYM bfd_elf32_bigarm_vxworks_vec
8262 #undef TARGET_BIG_NAME
8263 #define TARGET_BIG_NAME "elf32-bigarm-vxworks"
8265 /* Like elf32_arm_link_hash_table_create -- but overrides
8266 appropriately for VxWorks. */
8267 static struct bfd_link_hash_table *
8268 elf32_arm_vxworks_link_hash_table_create (bfd *abfd)
8270 struct bfd_link_hash_table *ret;
8272 ret = elf32_arm_link_hash_table_create (abfd);
8275 struct elf32_arm_link_hash_table *htab
8276 = (struct elf32_arm_link_hash_table *) ret;
8278 htab->vxworks_p = 1;
8284 elf32_arm_vxworks_final_write_processing (bfd *abfd, bfd_boolean linker)
8286 elf32_arm_final_write_processing (abfd, linker);
8287 elf_vxworks_final_write_processing (abfd, linker);
8291 #define elf32_bed elf32_arm_vxworks_bed
8293 #undef bfd_elf32_bfd_link_hash_table_create
8294 #define bfd_elf32_bfd_link_hash_table_create \
8295 elf32_arm_vxworks_link_hash_table_create
8296 #undef elf_backend_add_symbol_hook
8297 #define elf_backend_add_symbol_hook \
8298 elf_vxworks_add_symbol_hook
8299 #undef elf_backend_final_write_processing
8300 #define elf_backend_final_write_processing \
8301 elf32_arm_vxworks_final_write_processing
8302 #undef elf_backend_emit_relocs
8303 #define elf_backend_emit_relocs \
8304 elf_vxworks_emit_relocs
8306 #undef elf_backend_may_use_rel_p
8307 #define elf_backend_may_use_rel_p 0
8308 #undef elf_backend_may_use_rela_p
8309 #define elf_backend_may_use_rela_p 1
8310 #undef elf_backend_default_use_rela_p
8311 #define elf_backend_default_use_rela_p 1
8312 #undef elf_backend_rela_normal
8313 #define elf_backend_rela_normal 1
8314 #undef elf_backend_want_plt_sym
8315 #define elf_backend_want_plt_sym 1
8316 #undef ELF_MAXPAGESIZE
8317 #define ELF_MAXPAGESIZE 0x1000
8319 #include "elf32-target.h"
8322 /* Symbian OS Targets */
8324 #undef TARGET_LITTLE_SYM
8325 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_symbian_vec
8326 #undef TARGET_LITTLE_NAME
8327 #define TARGET_LITTLE_NAME "elf32-littlearm-symbian"
8328 #undef TARGET_BIG_SYM
8329 #define TARGET_BIG_SYM bfd_elf32_bigarm_symbian_vec
8330 #undef TARGET_BIG_NAME
8331 #define TARGET_BIG_NAME "elf32-bigarm-symbian"
8333 /* Like elf32_arm_link_hash_table_create -- but overrides
8334 appropriately for Symbian OS. */
8335 static struct bfd_link_hash_table *
8336 elf32_arm_symbian_link_hash_table_create (bfd *abfd)
8338 struct bfd_link_hash_table *ret;
8340 ret = elf32_arm_link_hash_table_create (abfd);
8343 struct elf32_arm_link_hash_table *htab
8344 = (struct elf32_arm_link_hash_table *)ret;
8345 /* There is no PLT header for Symbian OS. */
8346 htab->plt_header_size = 0;
8347 /* The PLT entries are each three instructions. */
8348 htab->plt_entry_size = 4 * NUM_ELEM (elf32_arm_symbian_plt_entry);
8349 htab->symbian_p = 1;
8350 /* Symbian uses armv5t or above, so use_blx is always true. */
8352 htab->root.is_relocatable_executable = 1;
8357 static const struct bfd_elf_special_section
8358 elf32_arm_symbian_special_sections[] =
8360 /* In a BPABI executable, the dynamic linking sections do not go in
8361 the loadable read-only segment. The post-linker may wish to
8362 refer to these sections, but they are not part of the final
8364 { ".dynamic", 8, 0, SHT_DYNAMIC, 0 },
8365 { ".dynstr", 7, 0, SHT_STRTAB, 0 },
8366 { ".dynsym", 7, 0, SHT_DYNSYM, 0 },
8367 { ".got", 4, 0, SHT_PROGBITS, 0 },
8368 { ".hash", 5, 0, SHT_HASH, 0 },
8369 /* These sections do not need to be writable as the SymbianOS
8370 postlinker will arrange things so that no dynamic relocation is
8372 { ".init_array", 11, 0, SHT_INIT_ARRAY, SHF_ALLOC },
8373 { ".fini_array", 11, 0, SHT_FINI_ARRAY, SHF_ALLOC },
8374 { ".preinit_array", 14, 0, SHT_PREINIT_ARRAY, SHF_ALLOC },
8375 { NULL, 0, 0, 0, 0 }
8379 elf32_arm_symbian_begin_write_processing (bfd *abfd,
8380 struct bfd_link_info *link_info
8383 /* BPABI objects are never loaded directly by an OS kernel; they are
8384 processed by a postlinker first, into an OS-specific format. If
8385 the D_PAGED bit is set on the file, BFD will align segments on
8386 page boundaries, so that an OS can directly map the file. With
8387 BPABI objects, that just results in wasted space. In addition,
8388 because we clear the D_PAGED bit, map_sections_to_segments will
8389 recognize that the program headers should not be mapped into any
8390 loadable segment. */
8391 abfd->flags &= ~D_PAGED;
8395 elf32_arm_symbian_modify_segment_map (bfd *abfd,
8396 struct bfd_link_info *info)
8398 struct elf_segment_map *m;
8401 /* BPABI shared libraries and executables should have a PT_DYNAMIC
8402 segment. However, because the .dynamic section is not marked
8403 with SEC_LOAD, the generic ELF code will not create such a
8405 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
8408 m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
8409 m->next = elf_tdata (abfd)->segment_map;
8410 elf_tdata (abfd)->segment_map = m;
8413 /* Also call the generic arm routine. */
8414 return elf32_arm_modify_segment_map (abfd, info);
8418 #define elf32_bed elf32_arm_symbian_bed
8420 /* The dynamic sections are not allocated on SymbianOS; the postlinker
8421 will process them and then discard them. */
8422 #undef ELF_DYNAMIC_SEC_FLAGS
8423 #define ELF_DYNAMIC_SEC_FLAGS \
8424 (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED)
8426 #undef bfd_elf32_bfd_link_hash_table_create
8427 #define bfd_elf32_bfd_link_hash_table_create \
8428 elf32_arm_symbian_link_hash_table_create
8429 #undef elf_backend_add_symbol_hook
8431 #undef elf_backend_special_sections
8432 #define elf_backend_special_sections elf32_arm_symbian_special_sections
8434 #undef elf_backend_begin_write_processing
8435 #define elf_backend_begin_write_processing \
8436 elf32_arm_symbian_begin_write_processing
8437 #undef elf_backend_final_write_processing
8438 #define elf_backend_final_write_processing \
8439 elf32_arm_final_write_processing
8440 #undef elf_backend_emit_relocs
8442 #undef elf_backend_modify_segment_map
8443 #define elf_backend_modify_segment_map elf32_arm_symbian_modify_segment_map
8445 /* There is no .got section for BPABI objects, and hence no header. */
8446 #undef elf_backend_got_header_size
8447 #define elf_backend_got_header_size 0
8449 /* Similarly, there is no .got.plt section. */
8450 #undef elf_backend_want_got_plt
8451 #define elf_backend_want_got_plt 0
8453 #undef elf_backend_may_use_rel_p
8454 #define elf_backend_may_use_rel_p 1
8455 #undef elf_backend_may_use_rela_p
8456 #define elf_backend_may_use_rela_p 0
8457 #undef elf_backend_default_use_rela_p
8458 #define elf_backend_default_use_rela_p 0
8459 #undef elf_backend_rela_normal
8460 #define elf_backend_rela_normal 0
8461 #undef elf_backend_want_plt_sym
8462 #define elf_backend_want_plt_sym 0
8463 #undef ELF_MAXPAGESIZE
8464 #define ELF_MAXPAGESIZE 0x8000
8466 #include "elf32-target.h"
projects / external / binutils.git / blob