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 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. */
2659 /* Store an Arm insn into an output section not processed by
2660 elf32_arm_write_section. */
2663 put_arm_insn (struct elf32_arm_link_hash_table *htab,
2664 bfd * output_bfd, bfd_vma val, void * ptr)
2666 if (htab->byteswap_code != bfd_little_endian (output_bfd))
2667 bfd_putl32 (val, ptr);
2669 bfd_putb32 (val, ptr);
2673 /* Store a 16-bit Thumb insn into an output section not processed by
2674 elf32_arm_write_section. */
2677 put_thumb_insn (struct elf32_arm_link_hash_table *htab,
2678 bfd * output_bfd, bfd_vma val, void * ptr)
2680 if (htab->byteswap_code != bfd_little_endian (output_bfd))
2681 bfd_putl16 (val, ptr);
2683 bfd_putb16 (val, ptr);
2687 /* Thumb code calling an ARM function. */
2690 elf32_thumb_to_arm_stub (struct bfd_link_info * info,
2694 asection * input_section,
2695 bfd_byte * hit_data,
2698 bfd_signed_vma addend,
2703 unsigned long int tmp;
2704 long int ret_offset;
2705 struct elf_link_hash_entry * myh;
2706 struct elf32_arm_link_hash_table * globals;
2708 myh = find_thumb_glue (info, name, input_bfd);
2712 globals = elf32_arm_hash_table (info);
2714 BFD_ASSERT (globals != NULL);
2715 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2717 my_offset = myh->root.u.def.value;
2719 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
2720 THUMB2ARM_GLUE_SECTION_NAME);
2722 BFD_ASSERT (s != NULL);
2723 BFD_ASSERT (s->contents != NULL);
2724 BFD_ASSERT (s->output_section != NULL);
2726 if ((my_offset & 0x01) == 0x01)
2729 && sym_sec->owner != NULL
2730 && !INTERWORK_FLAG (sym_sec->owner))
2732 (*_bfd_error_handler)
2733 (_("%B(%s): warning: interworking not enabled.\n"
2734 " first occurrence: %B: thumb call to arm"),
2735 sym_sec->owner, input_bfd, name);
2741 myh->root.u.def.value = my_offset;
2743 put_thumb_insn (globals, output_bfd, (bfd_vma) t2a1_bx_pc_insn,
2744 s->contents + my_offset);
2746 put_thumb_insn (globals, output_bfd, (bfd_vma) t2a2_noop_insn,
2747 s->contents + my_offset + 2);
2750 /* Address of destination of the stub. */
2751 ((bfd_signed_vma) val)
2753 /* Offset from the start of the current section
2754 to the start of the stubs. */
2756 /* Offset of the start of this stub from the start of the stubs. */
2758 /* Address of the start of the current section. */
2759 + s->output_section->vma)
2760 /* The branch instruction is 4 bytes into the stub. */
2762 /* ARM branches work from the pc of the instruction + 8. */
2765 put_arm_insn (globals, output_bfd,
2766 (bfd_vma) t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
2767 s->contents + my_offset + 4);
2770 BFD_ASSERT (my_offset <= globals->thumb_glue_size);
2772 /* Now go back and fix up the original BL insn to point to here. */
2774 /* Address of where the stub is located. */
2775 (s->output_section->vma + s->output_offset + my_offset)
2776 /* Address of where the BL is located. */
2777 - (input_section->output_section->vma + input_section->output_offset
2779 /* Addend in the relocation. */
2781 /* Biassing for PC-relative addressing. */
2784 tmp = bfd_get_32 (input_bfd, hit_data
2785 - input_section->vma);
2787 bfd_put_32 (output_bfd,
2788 (bfd_vma) insert_thumb_branch (tmp, ret_offset),
2789 hit_data - input_section->vma);
2794 /* Arm code calling a Thumb function. */
2797 elf32_arm_to_thumb_stub (struct bfd_link_info * info,
2801 asection * input_section,
2802 bfd_byte * hit_data,
2805 bfd_signed_vma addend,
2808 unsigned long int tmp;
2811 long int ret_offset;
2812 struct elf_link_hash_entry * myh;
2813 struct elf32_arm_link_hash_table * globals;
2815 myh = find_arm_glue (info, name, input_bfd);
2819 globals = elf32_arm_hash_table (info);
2821 BFD_ASSERT (globals != NULL);
2822 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2824 my_offset = myh->root.u.def.value;
2825 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
2826 ARM2THUMB_GLUE_SECTION_NAME);
2827 BFD_ASSERT (s != NULL);
2828 BFD_ASSERT (s->contents != NULL);
2829 BFD_ASSERT (s->output_section != NULL);
2831 if ((my_offset & 0x01) == 0x01)
2834 && sym_sec->owner != NULL
2835 && !INTERWORK_FLAG (sym_sec->owner))
2837 (*_bfd_error_handler)
2838 (_("%B(%s): warning: interworking not enabled.\n"
2839 " first occurrence: %B: arm call to thumb"),
2840 sym_sec->owner, input_bfd, name);
2844 myh->root.u.def.value = my_offset;
2846 if ((info->shared || globals->root.is_relocatable_executable))
2848 /* For relocatable objects we can't use absolute addresses,
2849 so construct the address from a relative offset. */
2850 /* TODO: If the offset is small it's probably worth
2851 constructing the address with adds. */
2852 put_arm_insn (globals, output_bfd, (bfd_vma) a2t1p_ldr_insn,
2853 s->contents + my_offset);
2854 put_arm_insn (globals, output_bfd, (bfd_vma) a2t2p_add_pc_insn,
2855 s->contents + my_offset + 4);
2856 put_arm_insn (globals, output_bfd, (bfd_vma) a2t3p_bx_r12_insn,
2857 s->contents + my_offset + 8);
2858 /* Adjust the offset by 4 for the position of the add,
2859 and 8 for the pipeline offset. */
2860 ret_offset = (val - (s->output_offset
2861 + s->output_section->vma
2864 bfd_put_32 (output_bfd, ret_offset,
2865 s->contents + my_offset + 12);
2869 put_arm_insn (globals, output_bfd, (bfd_vma) a2t1_ldr_insn,
2870 s->contents + my_offset);
2872 put_arm_insn (globals, output_bfd, (bfd_vma) a2t2_bx_r12_insn,
2873 s->contents + my_offset + 4);
2875 /* It's a thumb address. Add the low order bit. */
2876 bfd_put_32 (output_bfd, val | a2t3_func_addr_insn,
2877 s->contents + my_offset + 8);
2881 BFD_ASSERT (my_offset <= globals->arm_glue_size);
2883 tmp = bfd_get_32 (input_bfd, hit_data);
2884 tmp = tmp & 0xFF000000;
2886 /* Somehow these are both 4 too far, so subtract 8. */
2887 ret_offset = (s->output_offset
2889 + s->output_section->vma
2890 - (input_section->output_offset
2891 + input_section->output_section->vma
2895 tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
2897 bfd_put_32 (output_bfd, (bfd_vma) tmp, hit_data - input_section->vma);
2902 /* Some relocations map to different relocations depending on the
2903 target. Return the real relocation. */
2905 arm_real_reloc_type (struct elf32_arm_link_hash_table * globals,
2911 if (globals->target1_is_rel)
2917 return globals->target2_reloc;
2924 /* Return the base VMA address which should be subtracted from real addresses
2925 when resolving @dtpoff relocation.
2926 This is PT_TLS segment p_vaddr. */
2929 dtpoff_base (struct bfd_link_info *info)
2931 /* If tls_sec is NULL, we should have signalled an error already. */
2932 if (elf_hash_table (info)->tls_sec == NULL)
2934 return elf_hash_table (info)->tls_sec->vma;
2937 /* Return the relocation value for @tpoff relocation
2938 if STT_TLS virtual address is ADDRESS. */
2941 tpoff (struct bfd_link_info *info, bfd_vma address)
2943 struct elf_link_hash_table *htab = elf_hash_table (info);
2946 /* If tls_sec is NULL, we should have signalled an error already. */
2947 if (htab->tls_sec == NULL)
2949 base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power);
2950 return address - htab->tls_sec->vma + base;
2953 /* Perform an R_ARM_ABS12 relocation on the field pointed to by DATA.
2954 VALUE is the relocation value. */
2956 static bfd_reloc_status_type
2957 elf32_arm_abs12_reloc (bfd *abfd, void *data, bfd_vma value)
2960 return bfd_reloc_overflow;
2962 value |= bfd_get_32 (abfd, data) & 0xfffff000;
2963 bfd_put_32 (abfd, value, data);
2964 return bfd_reloc_ok;
2967 /* Perform a relocation as part of a final link. */
2969 static bfd_reloc_status_type
2970 elf32_arm_final_link_relocate (reloc_howto_type * howto,
2973 asection * input_section,
2974 bfd_byte * contents,
2975 Elf_Internal_Rela * rel,
2977 struct bfd_link_info * info,
2979 const char * sym_name,
2981 struct elf_link_hash_entry * h,
2982 bfd_boolean * unresolved_reloc_p)
2984 unsigned long r_type = howto->type;
2985 unsigned long r_symndx;
2986 bfd_byte * hit_data = contents + rel->r_offset;
2987 bfd * dynobj = NULL;
2988 Elf_Internal_Shdr * symtab_hdr;
2989 struct elf_link_hash_entry ** sym_hashes;
2990 bfd_vma * local_got_offsets;
2991 asection * sgot = NULL;
2992 asection * splt = NULL;
2993 asection * sreloc = NULL;
2995 bfd_signed_vma signed_addend;
2996 struct elf32_arm_link_hash_table * globals;
2998 globals = elf32_arm_hash_table (info);
3000 /* Some relocation type map to different relocations depending on the
3001 target. We pick the right one here. */
3002 r_type = arm_real_reloc_type (globals, r_type);
3003 if (r_type != howto->type)
3004 howto = elf32_arm_howto_from_type (r_type);
3006 /* If the start address has been set, then set the EF_ARM_HASENTRY
3007 flag. Setting this more than once is redundant, but the cost is
3008 not too high, and it keeps the code simple.
3010 The test is done here, rather than somewhere else, because the
3011 start address is only set just before the final link commences.
3013 Note - if the user deliberately sets a start address of 0, the
3014 flag will not be set. */
3015 if (bfd_get_start_address (output_bfd) != 0)
3016 elf_elfheader (output_bfd)->e_flags |= EF_ARM_HASENTRY;
3018 dynobj = elf_hash_table (info)->dynobj;
3021 sgot = bfd_get_section_by_name (dynobj, ".got");
3022 splt = bfd_get_section_by_name (dynobj, ".plt");
3024 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
3025 sym_hashes = elf_sym_hashes (input_bfd);
3026 local_got_offsets = elf_local_got_offsets (input_bfd);
3027 r_symndx = ELF32_R_SYM (rel->r_info);
3029 if (globals->use_rel)
3031 addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask;
3033 if (addend & ((howto->src_mask + 1) >> 1))
3036 signed_addend &= ~ howto->src_mask;
3037 signed_addend |= addend;
3040 signed_addend = addend;
3043 addend = signed_addend = rel->r_addend;
3048 /* We don't need to find a value for this symbol. It's just a
3050 *unresolved_reloc_p = FALSE;
3051 return bfd_reloc_ok;
3054 if (!globals->vxworks_p)
3055 return elf32_arm_abs12_reloc (input_bfd, hit_data, value + addend);
3065 /* r_symndx will be zero only for relocs against symbols
3066 from removed linkonce sections, or sections discarded by
3069 return bfd_reloc_ok;
3071 /* Handle relocations which should use the PLT entry. ABS32/REL32
3072 will use the symbol's value, which may point to a PLT entry, but we
3073 don't need to handle that here. If we created a PLT entry, all
3074 branches in this object should go to it. */
3075 if ((r_type != R_ARM_ABS32 && r_type != R_ARM_REL32)
3078 && h->plt.offset != (bfd_vma) -1)
3080 /* If we've created a .plt section, and assigned a PLT entry to
3081 this function, it should not be known to bind locally. If
3082 it were, we would have cleared the PLT entry. */
3083 BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info, h));
3085 value = (splt->output_section->vma
3086 + splt->output_offset
3088 *unresolved_reloc_p = FALSE;
3089 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3090 contents, rel->r_offset, value,
3094 /* When generating a shared object or relocatable executable, these
3095 relocations are copied into the output file to be resolved at
3097 if ((info->shared || globals->root.is_relocatable_executable)
3098 && (input_section->flags & SEC_ALLOC)
3099 && (r_type != R_ARM_REL32
3100 || !SYMBOL_CALLS_LOCAL (info, h))
3102 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3103 || h->root.type != bfd_link_hash_undefweak)
3104 && r_type != R_ARM_PC24
3105 && r_type != R_ARM_CALL
3106 && r_type != R_ARM_JUMP24
3107 && r_type != R_ARM_PREL31
3108 && r_type != R_ARM_PLT32)
3110 Elf_Internal_Rela outrel;
3112 bfd_boolean skip, relocate;
3114 *unresolved_reloc_p = FALSE;
3120 name = (bfd_elf_string_from_elf_section
3122 elf_elfheader (input_bfd)->e_shstrndx,
3123 elf_section_data (input_section)->rel_hdr.sh_name));
3125 return bfd_reloc_notsupported;
3127 BFD_ASSERT (reloc_section_p (globals, name, input_section));
3129 sreloc = bfd_get_section_by_name (dynobj, name);
3130 BFD_ASSERT (sreloc != NULL);
3136 outrel.r_addend = addend;
3138 _bfd_elf_section_offset (output_bfd, info, input_section,
3140 if (outrel.r_offset == (bfd_vma) -1)
3142 else if (outrel.r_offset == (bfd_vma) -2)
3143 skip = TRUE, relocate = TRUE;
3144 outrel.r_offset += (input_section->output_section->vma
3145 + input_section->output_offset);
3148 memset (&outrel, 0, sizeof outrel);
3153 || !h->def_regular))
3154 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3159 /* This symbol is local, or marked to become local. */
3160 if (sym_flags == STT_ARM_TFUNC)
3162 if (globals->symbian_p)
3164 /* On Symbian OS, the data segment and text segement
3165 can be relocated independently. Therefore, we
3166 must indicate the segment to which this
3167 relocation is relative. The BPABI allows us to
3168 use any symbol in the right segment; we just use
3169 the section symbol as it is convenient. (We
3170 cannot use the symbol given by "h" directly as it
3171 will not appear in the dynamic symbol table.) */
3173 symbol = elf_section_data (sym_sec->output_section)->dynindx;
3175 symbol = elf_section_data (input_section->output_section)->dynindx;
3176 BFD_ASSERT (symbol != 0);
3179 /* On SVR4-ish systems, the dynamic loader cannot
3180 relocate the text and data segments independently,
3181 so the symbol does not matter. */
3183 outrel.r_info = ELF32_R_INFO (symbol, R_ARM_RELATIVE);
3184 if (globals->use_rel)
3187 outrel.r_addend += value;
3190 loc = sreloc->contents;
3191 loc += sreloc->reloc_count++ * RELOC_SIZE (globals);
3192 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
3194 /* If this reloc is against an external symbol, we do not want to
3195 fiddle with the addend. Otherwise, we need to include the symbol
3196 value so that it becomes an addend for the dynamic reloc. */
3198 return bfd_reloc_ok;
3200 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3201 contents, rel->r_offset, value,
3204 else switch (r_type)
3207 return elf32_arm_abs12_reloc (input_bfd, hit_data, value + addend);
3209 case R_ARM_XPC25: /* Arm BLX instruction. */
3212 case R_ARM_PC24: /* Arm B/BL instruction */
3214 if (r_type == R_ARM_XPC25)
3216 /* Check for Arm calling Arm function. */
3217 /* FIXME: Should we translate the instruction into a BL
3218 instruction instead ? */
3219 if (sym_flags != STT_ARM_TFUNC)
3220 (*_bfd_error_handler)
3221 (_("\%B: Warning: Arm BLX instruction targets Arm function '%s'."),
3223 h ? h->root.root.string : "(local)");
3225 else if (r_type != R_ARM_CALL || !globals->use_blx)
3227 /* Check for Arm calling Thumb function. */
3228 if (sym_flags == STT_ARM_TFUNC)
3230 elf32_arm_to_thumb_stub (info, sym_name, input_bfd,
3231 output_bfd, input_section,
3232 hit_data, sym_sec, rel->r_offset,
3233 signed_addend, value);
3234 return bfd_reloc_ok;
3238 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
3240 S is the address of the symbol in the relocation.
3241 P is address of the instruction being relocated.
3242 A is the addend (extracted from the instruction) in bytes.
3244 S is held in 'value'.
3245 P is the base address of the section containing the
3246 instruction plus the offset of the reloc into that
3248 (input_section->output_section->vma +
3249 input_section->output_offset +
3251 A is the addend, converted into bytes, ie:
3254 Note: None of these operations have knowledge of the pipeline
3255 size of the processor, thus it is up to the assembler to
3256 encode this information into the addend. */
3257 value -= (input_section->output_section->vma
3258 + input_section->output_offset);
3259 value -= rel->r_offset;
3260 if (globals->use_rel)
3261 value += (signed_addend << howto->size);
3263 /* RELA addends do not have to be adjusted by howto->size. */
3264 value += signed_addend;
3266 signed_addend = value;
3267 signed_addend >>= howto->rightshift;
3269 /* It is not an error for an undefined weak reference to be
3270 out of range. Any program that branches to such a symbol
3271 is going to crash anyway, so there is no point worrying
3272 about getting the destination exactly right. */
3273 if (! h || h->root.type != bfd_link_hash_undefweak)
3275 /* Perform a signed range check. */
3276 if ( signed_addend > ((bfd_signed_vma) (howto->dst_mask >> 1))
3277 || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1)))
3278 return bfd_reloc_overflow;
3281 addend = (value & 2);
3283 value = (signed_addend & howto->dst_mask)
3284 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
3286 /* Set the H bit in the BLX instruction. */
3287 if (sym_flags == STT_ARM_TFUNC)
3292 value &= ~(bfd_vma)(1 << 24);
3294 if (r_type == R_ARM_CALL)
3296 /* Select the correct instruction (BL or BLX). */
3297 if (sym_flags == STT_ARM_TFUNC)
3301 value &= ~(bfd_vma)(1 << 28);
3309 if (sym_flags == STT_ARM_TFUNC)
3315 if (sym_flags == STT_ARM_TFUNC)
3317 value -= (input_section->output_section->vma
3318 + input_section->output_offset + rel->r_offset);
3322 value -= (input_section->output_section->vma
3323 + input_section->output_offset + rel->r_offset);
3324 value += signed_addend;
3325 if (! h || h->root.type != bfd_link_hash_undefweak)
3327 /* Check for overflow */
3328 if ((value ^ (value >> 1)) & (1 << 30))
3329 return bfd_reloc_overflow;
3331 value &= 0x7fffffff;
3332 value |= (bfd_get_32 (input_bfd, hit_data) & 0x80000000);
3333 if (sym_flags == STT_ARM_TFUNC)
3338 bfd_put_32 (input_bfd, value, hit_data);
3339 return bfd_reloc_ok;
3343 if ((long) value > 0x7f || (long) value < -0x80)
3344 return bfd_reloc_overflow;
3346 bfd_put_8 (input_bfd, value, hit_data);
3347 return bfd_reloc_ok;
3352 if ((long) value > 0x7fff || (long) value < -0x8000)
3353 return bfd_reloc_overflow;
3355 bfd_put_16 (input_bfd, value, hit_data);
3356 return bfd_reloc_ok;
3358 case R_ARM_THM_ABS5:
3359 /* Support ldr and str instructions for the thumb. */
3360 if (globals->use_rel)
3362 /* Need to refetch addend. */
3363 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
3364 /* ??? Need to determine shift amount from operand size. */
3365 addend >>= howto->rightshift;
3369 /* ??? Isn't value unsigned? */
3370 if ((long) value > 0x1f || (long) value < -0x10)
3371 return bfd_reloc_overflow;
3373 /* ??? Value needs to be properly shifted into place first. */
3374 value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
3375 bfd_put_16 (input_bfd, value, hit_data);
3376 return bfd_reloc_ok;
3378 case R_ARM_THM_XPC22:
3379 case R_ARM_THM_CALL:
3380 /* Thumb BL (branch long instruction). */
3383 bfd_boolean overflow = FALSE;
3384 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
3385 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
3386 bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
3387 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
3389 bfd_signed_vma signed_check;
3391 /* Need to refetch the addend and squish the two 11 bit pieces
3393 if (globals->use_rel)
3395 bfd_vma upper = upper_insn & 0x7ff;
3396 bfd_vma lower = lower_insn & 0x7ff;
3397 upper = (upper ^ 0x400) - 0x400; /* Sign extend. */
3398 addend = (upper << 12) | (lower << 1);
3399 signed_addend = addend;
3402 if (r_type == R_ARM_THM_XPC22)
3404 /* Check for Thumb to Thumb call. */
3405 /* FIXME: Should we translate the instruction into a BL
3406 instruction instead ? */
3407 if (sym_flags == STT_ARM_TFUNC)
3408 (*_bfd_error_handler)
3409 (_("%B: Warning: Thumb BLX instruction targets thumb function '%s'."),
3411 h ? h->root.root.string : "(local)");
3415 /* If it is not a call to Thumb, assume call to Arm.
3416 If it is a call relative to a section name, then it is not a
3417 function call at all, but rather a long jump. Calls through
3418 the PLT do not require stubs. */
3419 if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION
3420 && (h == NULL || splt == NULL
3421 || h->plt.offset == (bfd_vma) -1))
3423 if (globals->use_blx)
3425 /* Convert BL to BLX. */
3426 lower_insn = (lower_insn & ~0x1000) | 0x0800;
3428 else if (elf32_thumb_to_arm_stub
3429 (info, sym_name, input_bfd, output_bfd, input_section,
3430 hit_data, sym_sec, rel->r_offset, signed_addend, value))
3431 return bfd_reloc_ok;
3433 return bfd_reloc_dangerous;
3435 else if (sym_flags == STT_ARM_TFUNC && globals->use_blx)
3437 /* Make sure this is a BL. */
3438 lower_insn |= 0x1800;
3442 /* Handle calls via the PLT. */
3443 if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
3445 value = (splt->output_section->vma
3446 + splt->output_offset
3448 if (globals->use_blx)
3450 /* If the Thumb BLX instruction is available, convert the
3451 BL to a BLX instruction to call the ARM-mode PLT entry. */
3452 lower_insn = (lower_insn & ~0x1000) | 0x0800;
3455 /* Target the Thumb stub before the ARM PLT entry. */
3456 value -= PLT_THUMB_STUB_SIZE;
3457 *unresolved_reloc_p = FALSE;
3460 relocation = value + signed_addend;
3462 relocation -= (input_section->output_section->vma
3463 + input_section->output_offset
3466 check = relocation >> howto->rightshift;
3468 /* If this is a signed value, the rightshift just dropped
3469 leading 1 bits (assuming twos complement). */
3470 if ((bfd_signed_vma) relocation >= 0)
3471 signed_check = check;
3473 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
3475 /* Assumes two's complement. */
3476 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
3479 if ((lower_insn & 0x1800) == 0x0800)
3480 /* For a BLX instruction, make sure that the relocation is rounded up
3481 to a word boundary. This follows the semantics of the instruction
3482 which specifies that bit 1 of the target address will come from bit
3483 1 of the base address. */
3484 relocation = (relocation + 2) & ~ 3;
3486 /* Put RELOCATION back into the insn. */
3487 upper_insn = (upper_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 12) & 0x7ff);
3488 lower_insn = (lower_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 1) & 0x7ff);
3490 /* Put the relocated value back in the object file: */
3491 bfd_put_16 (input_bfd, upper_insn, hit_data);
3492 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
3494 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
3498 case R_ARM_THM_JUMP24:
3499 /* Thumb32 unconditional branch instruction. */
3502 bfd_boolean overflow = FALSE;
3503 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
3504 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
3505 bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
3506 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
3508 bfd_signed_vma signed_check;
3510 /* Need to refetch the addend, reconstruct the top three bits, and glue the
3511 two pieces together. */
3512 if (globals->use_rel)
3514 bfd_vma S = (upper_insn & 0x0400) >> 10;
3515 bfd_vma hi = (upper_insn & 0x03ff);
3516 bfd_vma I1 = (lower_insn & 0x2000) >> 13;
3517 bfd_vma I2 = (lower_insn & 0x0800) >> 11;
3518 bfd_vma lo = (lower_insn & 0x07ff);
3524 signed_addend = (S << 24) | (I1 << 23) | (I2 << 22) | (hi << 12) | (lo << 1);
3525 signed_addend -= (1 << 24); /* Sign extend. */
3528 /* ??? Should handle interworking? GCC might someday try to
3529 use this for tail calls. */
3531 relocation = value + signed_addend;
3532 relocation -= (input_section->output_section->vma
3533 + input_section->output_offset
3536 check = relocation >> howto->rightshift;
3538 /* If this is a signed value, the rightshift just dropped
3539 leading 1 bits (assuming twos complement). */
3540 if ((bfd_signed_vma) relocation >= 0)
3541 signed_check = check;
3543 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
3545 /* Assumes two's complement. */
3546 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
3549 /* Put RELOCATION back into the insn. */
3551 bfd_vma S = (relocation & 0x01000000) >> 24;
3552 bfd_vma I1 = (relocation & 0x00800000) >> 23;
3553 bfd_vma I2 = (relocation & 0x00400000) >> 22;
3554 bfd_vma hi = (relocation & 0x003ff000) >> 12;
3555 bfd_vma lo = (relocation & 0x00000ffe) >> 1;
3560 upper_insn = (upper_insn & (bfd_vma) 0xf800) | (S << 10) | hi;
3561 lower_insn = (lower_insn & (bfd_vma) 0xd000) | (I1 << 13) | (I2 << 11) | lo;
3564 /* Put the relocated value back in the object file: */
3565 bfd_put_16 (input_bfd, upper_insn, hit_data);
3566 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
3568 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
3571 case R_ARM_THM_JUMP19:
3572 /* Thumb32 conditional branch instruction. */
3575 bfd_boolean overflow = FALSE;
3576 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
3577 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
3578 bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
3579 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
3581 bfd_signed_vma signed_check;
3583 /* Need to refetch the addend, reconstruct the top three bits,
3584 and squish the two 11 bit pieces together. */
3585 if (globals->use_rel)
3587 bfd_vma S = (upper_insn & 0x0400) >> 10;
3588 bfd_vma upper = (upper_insn & 0x001f);
3589 bfd_vma J1 = (lower_insn & 0x2000) >> 13;
3590 bfd_vma J2 = (lower_insn & 0x0800) >> 11;
3591 bfd_vma lower = (lower_insn & 0x07ff);
3596 upper -= 0x0100; /* Sign extend. */
3598 addend = (upper << 12) | (lower << 1);
3599 signed_addend = addend;
3602 /* ??? Should handle interworking? GCC might someday try to
3603 use this for tail calls. */
3605 relocation = value + signed_addend;
3606 relocation -= (input_section->output_section->vma
3607 + input_section->output_offset
3610 check = relocation >> howto->rightshift;
3612 /* If this is a signed value, the rightshift just dropped
3613 leading 1 bits (assuming twos complement). */
3614 if ((bfd_signed_vma) relocation >= 0)
3615 signed_check = check;
3617 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
3619 /* Assumes two's complement. */
3620 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
3623 /* Put RELOCATION back into the insn. */
3625 bfd_vma S = (relocation & 0x00100000) >> 20;
3626 bfd_vma J2 = (relocation & 0x00080000) >> 19;
3627 bfd_vma J1 = (relocation & 0x00040000) >> 18;
3628 bfd_vma hi = (relocation & 0x0003f000) >> 12;
3629 bfd_vma lo = (relocation & 0x00000ffe) >> 1;
3631 upper_insn = (upper_insn & 0xfb30) | (S << 10) | hi;
3632 lower_insn = (lower_insn & 0xd000) | (J1 << 13) | (J2 << 11) | lo;
3635 /* Put the relocated value back in the object file: */
3636 bfd_put_16 (input_bfd, upper_insn, hit_data);
3637 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
3639 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
3642 case R_ARM_THM_JUMP11:
3643 case R_ARM_THM_JUMP8:
3644 case R_ARM_THM_JUMP6:
3645 /* Thumb B (branch) instruction). */
3647 bfd_signed_vma relocation;
3648 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
3649 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
3650 bfd_signed_vma signed_check;
3652 /* CZB cannot jump backward. */
3653 if (r_type == R_ARM_THM_JUMP6)
3654 reloc_signed_min = 0;
3656 if (globals->use_rel)
3658 /* Need to refetch addend. */
3659 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
3660 if (addend & ((howto->src_mask + 1) >> 1))
3663 signed_addend &= ~ howto->src_mask;
3664 signed_addend |= addend;
3667 signed_addend = addend;
3668 /* The value in the insn has been right shifted. We need to
3669 undo this, so that we can perform the address calculation
3670 in terms of bytes. */
3671 signed_addend <<= howto->rightshift;
3673 relocation = value + signed_addend;
3675 relocation -= (input_section->output_section->vma
3676 + input_section->output_offset
3679 relocation >>= howto->rightshift;
3680 signed_check = relocation;
3682 if (r_type == R_ARM_THM_JUMP6)
3683 relocation = ((relocation & 0x0020) << 4) | ((relocation & 0x001f) << 3);
3685 relocation &= howto->dst_mask;
3686 relocation |= (bfd_get_16 (input_bfd, hit_data) & (~ howto->dst_mask));
3688 bfd_put_16 (input_bfd, relocation, hit_data);
3690 /* Assumes two's complement. */
3691 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
3692 return bfd_reloc_overflow;
3694 return bfd_reloc_ok;
3697 case R_ARM_ALU_PCREL7_0:
3698 case R_ARM_ALU_PCREL15_8:
3699 case R_ARM_ALU_PCREL23_15:
3704 insn = bfd_get_32 (input_bfd, hit_data);
3705 if (globals->use_rel)
3707 /* Extract the addend. */
3708 addend = (insn & 0xff) << ((insn & 0xf00) >> 7);
3709 signed_addend = addend;
3711 relocation = value + signed_addend;
3713 relocation -= (input_section->output_section->vma
3714 + input_section->output_offset
3716 insn = (insn & ~0xfff)
3717 | ((howto->bitpos << 7) & 0xf00)
3718 | ((relocation >> howto->bitpos) & 0xff);
3719 bfd_put_32 (input_bfd, value, hit_data);
3721 return bfd_reloc_ok;
3723 case R_ARM_GNU_VTINHERIT:
3724 case R_ARM_GNU_VTENTRY:
3725 return bfd_reloc_ok;
3727 case R_ARM_GOTOFF32:
3728 /* Relocation is relative to the start of the
3729 global offset table. */
3731 BFD_ASSERT (sgot != NULL);
3733 return bfd_reloc_notsupported;
3735 /* If we are addressing a Thumb function, we need to adjust the
3736 address by one, so that attempts to call the function pointer will
3737 correctly interpret it as Thumb code. */
3738 if (sym_flags == STT_ARM_TFUNC)
3741 /* Note that sgot->output_offset is not involved in this
3742 calculation. We always want the start of .got. If we
3743 define _GLOBAL_OFFSET_TABLE in a different way, as is
3744 permitted by the ABI, we might have to change this
3746 value -= sgot->output_section->vma;
3747 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3748 contents, rel->r_offset, value,
3752 /* Use global offset table as symbol value. */
3753 BFD_ASSERT (sgot != NULL);
3756 return bfd_reloc_notsupported;
3758 *unresolved_reloc_p = FALSE;
3759 value = sgot->output_section->vma;
3760 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3761 contents, rel->r_offset, value,
3765 case R_ARM_GOT_PREL:
3766 /* Relocation is to the entry for this symbol in the
3767 global offset table. */
3769 return bfd_reloc_notsupported;
3776 off = h->got.offset;
3777 BFD_ASSERT (off != (bfd_vma) -1);
3778 dyn = globals->root.dynamic_sections_created;
3780 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3782 && SYMBOL_REFERENCES_LOCAL (info, h))
3783 || (ELF_ST_VISIBILITY (h->other)
3784 && h->root.type == bfd_link_hash_undefweak))
3786 /* This is actually a static link, or it is a -Bsymbolic link
3787 and the symbol is defined locally. We must initialize this
3788 entry in the global offset table. Since the offset must
3789 always be a multiple of 4, we use the least significant bit
3790 to record whether we have initialized it already.
3792 When doing a dynamic link, we create a .rel(a).got relocation
3793 entry to initialize the value. This is done in the
3794 finish_dynamic_symbol routine. */
3799 /* If we are addressing a Thumb function, we need to
3800 adjust the address by one, so that attempts to
3801 call the function pointer will correctly
3802 interpret it as Thumb code. */
3803 if (sym_flags == STT_ARM_TFUNC)
3806 bfd_put_32 (output_bfd, value, sgot->contents + off);
3811 *unresolved_reloc_p = FALSE;
3813 value = sgot->output_offset + off;
3819 BFD_ASSERT (local_got_offsets != NULL &&
3820 local_got_offsets[r_symndx] != (bfd_vma) -1);
3822 off = local_got_offsets[r_symndx];
3824 /* The offset must always be a multiple of 4. We use the
3825 least significant bit to record whether we have already
3826 generated the necessary reloc. */
3831 /* If we are addressing a Thumb function, we need to
3832 adjust the address by one, so that attempts to
3833 call the function pointer will correctly
3834 interpret it as Thumb code. */
3835 if (sym_flags == STT_ARM_TFUNC)
3838 if (globals->use_rel)
3839 bfd_put_32 (output_bfd, value, sgot->contents + off);
3844 Elf_Internal_Rela outrel;
3847 srelgot = (bfd_get_section_by_name
3848 (dynobj, RELOC_SECTION (globals, ".got")));
3849 BFD_ASSERT (srelgot != NULL);
3851 outrel.r_addend = addend + value;
3852 outrel.r_offset = (sgot->output_section->vma
3853 + sgot->output_offset
3855 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
3856 loc = srelgot->contents;
3857 loc += srelgot->reloc_count++ * RELOC_SIZE (globals);
3858 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
3861 local_got_offsets[r_symndx] |= 1;
3864 value = sgot->output_offset + off;
3866 if (r_type != R_ARM_GOT32)
3867 value += sgot->output_section->vma;
3869 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3870 contents, rel->r_offset, value,
3873 case R_ARM_TLS_LDO32:
3874 value = value - dtpoff_base (info);
3876 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3877 contents, rel->r_offset, value,
3880 case R_ARM_TLS_LDM32:
3884 if (globals->sgot == NULL)
3887 off = globals->tls_ldm_got.offset;
3893 /* If we don't know the module number, create a relocation
3897 Elf_Internal_Rela outrel;
3900 if (globals->srelgot == NULL)
3903 outrel.r_addend = 0;
3904 outrel.r_offset = (globals->sgot->output_section->vma
3905 + globals->sgot->output_offset + off);
3906 outrel.r_info = ELF32_R_INFO (0, R_ARM_TLS_DTPMOD32);
3908 if (globals->use_rel)
3909 bfd_put_32 (output_bfd, outrel.r_addend,
3910 globals->sgot->contents + off);
3912 loc = globals->srelgot->contents;
3913 loc += globals->srelgot->reloc_count++ * RELOC_SIZE (globals);
3914 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
3917 bfd_put_32 (output_bfd, 1, globals->sgot->contents + off);
3919 globals->tls_ldm_got.offset |= 1;
3922 value = globals->sgot->output_section->vma + globals->sgot->output_offset + off
3923 - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
3925 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3926 contents, rel->r_offset, value,
3930 case R_ARM_TLS_GD32:
3931 case R_ARM_TLS_IE32:
3937 if (globals->sgot == NULL)
3944 dyn = globals->root.dynamic_sections_created;
3945 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3947 || !SYMBOL_REFERENCES_LOCAL (info, h)))
3949 *unresolved_reloc_p = FALSE;
3952 off = h->got.offset;
3953 tls_type = ((struct elf32_arm_link_hash_entry *) h)->tls_type;
3957 if (local_got_offsets == NULL)
3959 off = local_got_offsets[r_symndx];
3960 tls_type = elf32_arm_local_got_tls_type (input_bfd)[r_symndx];
3963 if (tls_type == GOT_UNKNOWN)
3970 bfd_boolean need_relocs = FALSE;
3971 Elf_Internal_Rela outrel;
3972 bfd_byte *loc = NULL;
3975 /* The GOT entries have not been initialized yet. Do it
3976 now, and emit any relocations. If both an IE GOT and a
3977 GD GOT are necessary, we emit the GD first. */
3979 if ((info->shared || indx != 0)
3981 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3982 || h->root.type != bfd_link_hash_undefweak))
3985 if (globals->srelgot == NULL)
3987 loc = globals->srelgot->contents;
3988 loc += globals->srelgot->reloc_count * RELOC_SIZE (globals);
3991 if (tls_type & GOT_TLS_GD)
3995 outrel.r_addend = 0;
3996 outrel.r_offset = (globals->sgot->output_section->vma
3997 + globals->sgot->output_offset
3999 outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_DTPMOD32);
4001 if (globals->use_rel)
4002 bfd_put_32 (output_bfd, outrel.r_addend,
4003 globals->sgot->contents + cur_off);
4005 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
4006 globals->srelgot->reloc_count++;
4007 loc += RELOC_SIZE (globals);
4010 bfd_put_32 (output_bfd, value - dtpoff_base (info),
4011 globals->sgot->contents + cur_off + 4);
4014 outrel.r_addend = 0;
4015 outrel.r_info = ELF32_R_INFO (indx,
4016 R_ARM_TLS_DTPOFF32);
4017 outrel.r_offset += 4;
4019 if (globals->use_rel)
4020 bfd_put_32 (output_bfd, outrel.r_addend,
4021 globals->sgot->contents + cur_off + 4);
4024 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
4025 globals->srelgot->reloc_count++;
4026 loc += RELOC_SIZE (globals);
4031 /* If we are not emitting relocations for a
4032 general dynamic reference, then we must be in a
4033 static link or an executable link with the
4034 symbol binding locally. Mark it as belonging
4035 to module 1, the executable. */
4036 bfd_put_32 (output_bfd, 1,
4037 globals->sgot->contents + cur_off);
4038 bfd_put_32 (output_bfd, value - dtpoff_base (info),
4039 globals->sgot->contents + cur_off + 4);
4045 if (tls_type & GOT_TLS_IE)
4050 outrel.r_addend = value - dtpoff_base (info);
4052 outrel.r_addend = 0;
4053 outrel.r_offset = (globals->sgot->output_section->vma
4054 + globals->sgot->output_offset
4056 outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_TPOFF32);
4058 if (globals->use_rel)
4059 bfd_put_32 (output_bfd, outrel.r_addend,
4060 globals->sgot->contents + cur_off);
4062 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
4063 globals->srelgot->reloc_count++;
4064 loc += RELOC_SIZE (globals);
4067 bfd_put_32 (output_bfd, tpoff (info, value),
4068 globals->sgot->contents + cur_off);
4075 local_got_offsets[r_symndx] |= 1;
4078 if ((tls_type & GOT_TLS_GD) && r_type != R_ARM_TLS_GD32)
4080 value = globals->sgot->output_section->vma + globals->sgot->output_offset + off
4081 - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
4083 return _bfd_final_link_relocate (howto, input_bfd, input_section,
4084 contents, rel->r_offset, value,
4088 case R_ARM_TLS_LE32:
4091 (*_bfd_error_handler)
4092 (_("%B(%A+0x%lx): R_ARM_TLS_LE32 relocation not permitted in shared object"),
4093 input_bfd, input_section,
4094 (long) rel->r_offset, howto->name);
4098 value = tpoff (info, value);
4100 return _bfd_final_link_relocate (howto, input_bfd, input_section,
4101 contents, rel->r_offset, value,
4105 if (globals->fix_v4bx)
4107 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
4109 /* Ensure that we have a BX instruction. */
4110 BFD_ASSERT ((insn & 0x0ffffff0) == 0x012fff10);
4112 /* Preserve Rm (lowest four bits) and the condition code
4113 (highest four bits). Other bits encode MOV PC,Rm. */
4114 insn = (insn & 0xf000000f) | 0x01a0f000;
4116 bfd_put_32 (input_bfd, insn, hit_data);
4118 return bfd_reloc_ok;
4120 case R_ARM_MOVW_ABS_NC:
4121 case R_ARM_MOVT_ABS:
4122 case R_ARM_MOVW_PREL_NC:
4123 case R_ARM_MOVT_PREL:
4125 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
4127 if (globals->use_rel)
4129 addend = ((insn >> 4) & 0xf000) | (insn & 0xfff);
4130 signed_addend = (addend ^ 0x10000) - 0x10000;
4132 value += signed_addend;
4133 if (sym_flags == STT_ARM_TFUNC)
4136 if (r_type == R_ARM_MOVW_PREL_NC || r_type == R_ARM_MOVT_PREL)
4137 value -= (input_section->output_section->vma
4138 + input_section->output_offset + rel->r_offset);
4140 if (r_type == R_ARM_MOVT_ABS || r_type == R_ARM_MOVT_PREL)
4144 insn |= value & 0xfff;
4145 insn |= (value & 0xf000) << 4;
4146 bfd_put_32 (input_bfd, insn, hit_data);
4148 return bfd_reloc_ok;
4150 case R_ARM_THM_MOVW_ABS_NC:
4151 case R_ARM_THM_MOVT_ABS:
4152 case R_ARM_THM_MOVW_PREL_NC:
4153 case R_ARM_THM_MOVT_PREL:
4157 insn = bfd_get_16 (input_bfd, hit_data) << 16;
4158 insn |= bfd_get_16 (input_bfd, hit_data + 2);
4160 if (globals->use_rel)
4162 addend = ((insn >> 4) & 0xf000)
4163 | ((insn >> 15) & 0x0800)
4164 | ((insn >> 4) & 0x0700)
4166 signed_addend = (addend ^ 0x10000) - 0x10000;
4168 value += signed_addend;
4169 if (sym_flags == STT_ARM_TFUNC)
4172 if (r_type == R_ARM_THM_MOVW_PREL_NC || r_type == R_ARM_THM_MOVT_PREL)
4173 value -= (input_section->output_section->vma
4174 + input_section->output_offset + rel->r_offset);
4176 if (r_type == R_ARM_THM_MOVT_ABS || r_type == R_ARM_THM_MOVT_PREL)
4180 insn |= (value & 0xf000) << 4;
4181 insn |= (value & 0x0800) << 15;
4182 insn |= (value & 0x0700) << 4;
4183 insn |= (value & 0x00ff);
4185 bfd_put_16 (input_bfd, insn >> 16, hit_data);
4186 bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2);
4188 return bfd_reloc_ok;
4191 return bfd_reloc_notsupported;
4197 uleb128_size (unsigned int i)
4209 /* Return TRUE if the attribute has the default value (0/""). */
4211 is_default_attr (aeabi_attribute *attr)
4213 if ((attr->type & 1) && attr->i != 0)
4215 if ((attr->type & 2) && attr->s && *attr->s)
4221 /* Return the size of a single attribute. */
4223 eabi_attr_size(int tag, aeabi_attribute *attr)
4227 if (is_default_attr (attr))
4230 size = uleb128_size (tag);
4232 size += uleb128_size (attr->i);
4234 size += strlen ((char *)attr->s) + 1;
4238 /* Returns the size of the eabi object attributess section. */
4240 elf32_arm_eabi_attr_size (bfd *abfd)
4243 aeabi_attribute *attr;
4244 aeabi_attribute_list *list;
4247 attr = elf32_arm_tdata (abfd)->known_eabi_attributes;
4248 size = 16; /* 'A' <size> "aeabi" 0x1 <size>. */
4249 for (i = 4; i < NUM_KNOWN_ATTRIBUTES; i++)
4250 size += eabi_attr_size (i, &attr[i]);
4252 for (list = elf32_arm_tdata (abfd)->other_eabi_attributes;
4255 size += eabi_attr_size (list->tag, &list->attr);
4261 write_uleb128 (bfd_byte *p, unsigned int val)
4276 /* Write attribute ATTR to butter P, and return a pointer to the following
4279 write_eabi_attribute (bfd_byte *p, int tag, aeabi_attribute *attr)
4281 /* Suppress default entries. */
4282 if (is_default_attr(attr))
4285 p = write_uleb128 (p, tag);
4287 p = write_uleb128 (p, attr->i);
4292 len = strlen (attr->s) + 1;
4293 memcpy (p, attr->s, len);
4300 /* Write the contents of the eabi attributes section to p. */
4302 elf32_arm_set_eabi_attr_contents (bfd *abfd, bfd_byte *contents, bfd_vma size)
4305 aeabi_attribute *attr;
4306 aeabi_attribute_list *list;
4311 bfd_put_32 (abfd, size - 1, p);
4313 memcpy (p, "aeabi", 6);
4316 bfd_put_32 (abfd, size - 11, p);
4319 attr = elf32_arm_tdata (abfd)->known_eabi_attributes;
4320 for (i = 4; i < NUM_KNOWN_ATTRIBUTES; i++)
4321 p = write_eabi_attribute (p, i, &attr[i]);
4323 for (list = elf32_arm_tdata (abfd)->other_eabi_attributes;
4326 p = write_eabi_attribute (p, list->tag, &list->attr);
4329 /* Override final_link to handle EABI object attribute sections. */
4332 elf32_arm_bfd_final_link (bfd *abfd, struct bfd_link_info *info)
4335 struct bfd_link_order *p;
4336 asection *attr_section = NULL;
4340 /* elf32_arm_merge_private_bfd_data will already have merged the
4341 object attributes. Remove the input sections from the link, and set
4342 the contents of the output secton. */
4343 for (o = abfd->sections; o != NULL; o = o->next)
4345 if (strcmp (o->name, ".ARM.attributes") == 0)
4347 for (p = o->map_head.link_order; p != NULL; p = p->next)
4349 asection *input_section;
4351 if (p->type != bfd_indirect_link_order)
4353 input_section = p->u.indirect.section;
4354 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4355 elf_link_input_bfd ignores this section. */
4356 input_section->flags &= ~SEC_HAS_CONTENTS;
4359 size = elf32_arm_eabi_attr_size (abfd);
4360 bfd_set_section_size (abfd, o, size);
4362 /* Skip this section later on. */
4363 o->map_head.link_order = NULL;
4366 /* Invoke the ELF linker to do all the work. */
4367 if (!bfd_elf_final_link (abfd, info))
4372 contents = bfd_malloc(size);
4373 if (contents == NULL)
4375 elf32_arm_set_eabi_attr_contents (abfd, contents, size);
4376 bfd_set_section_contents (abfd, attr_section, contents, 0, size);
4383 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
4385 arm_add_to_rel (bfd * abfd,
4387 reloc_howto_type * howto,
4388 bfd_signed_vma increment)
4390 bfd_signed_vma addend;
4392 if (howto->type == R_ARM_THM_CALL)
4394 int upper_insn, lower_insn;
4397 upper_insn = bfd_get_16 (abfd, address);
4398 lower_insn = bfd_get_16 (abfd, address + 2);
4399 upper = upper_insn & 0x7ff;
4400 lower = lower_insn & 0x7ff;
4402 addend = (upper << 12) | (lower << 1);
4403 addend += increment;
4406 upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
4407 lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
4409 bfd_put_16 (abfd, (bfd_vma) upper_insn, address);
4410 bfd_put_16 (abfd, (bfd_vma) lower_insn, address + 2);
4416 contents = bfd_get_32 (abfd, address);
4418 /* Get the (signed) value from the instruction. */
4419 addend = contents & howto->src_mask;
4420 if (addend & ((howto->src_mask + 1) >> 1))
4422 bfd_signed_vma mask;
4425 mask &= ~ howto->src_mask;
4429 /* Add in the increment, (which is a byte value). */
4430 switch (howto->type)
4433 addend += increment;
4440 addend <<= howto->size;
4441 addend += increment;
4443 /* Should we check for overflow here ? */
4445 /* Drop any undesired bits. */
4446 addend >>= howto->rightshift;
4450 contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
4452 bfd_put_32 (abfd, contents, address);
4456 #define IS_ARM_TLS_RELOC(R_TYPE) \
4457 ((R_TYPE) == R_ARM_TLS_GD32 \
4458 || (R_TYPE) == R_ARM_TLS_LDO32 \
4459 || (R_TYPE) == R_ARM_TLS_LDM32 \
4460 || (R_TYPE) == R_ARM_TLS_DTPOFF32 \
4461 || (R_TYPE) == R_ARM_TLS_DTPMOD32 \
4462 || (R_TYPE) == R_ARM_TLS_TPOFF32 \
4463 || (R_TYPE) == R_ARM_TLS_LE32 \
4464 || (R_TYPE) == R_ARM_TLS_IE32)
4466 /* Relocate an ARM ELF section. */
4468 elf32_arm_relocate_section (bfd * output_bfd,
4469 struct bfd_link_info * info,
4471 asection * input_section,
4472 bfd_byte * contents,
4473 Elf_Internal_Rela * relocs,
4474 Elf_Internal_Sym * local_syms,
4475 asection ** local_sections)
4477 Elf_Internal_Shdr *symtab_hdr;
4478 struct elf_link_hash_entry **sym_hashes;
4479 Elf_Internal_Rela *rel;
4480 Elf_Internal_Rela *relend;
4482 struct elf32_arm_link_hash_table * globals;
4484 globals = elf32_arm_hash_table (info);
4485 if (info->relocatable && !globals->use_rel)
4488 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
4489 sym_hashes = elf_sym_hashes (input_bfd);
4492 relend = relocs + input_section->reloc_count;
4493 for (; rel < relend; rel++)
4496 reloc_howto_type * howto;
4497 unsigned long r_symndx;
4498 Elf_Internal_Sym * sym;
4500 struct elf_link_hash_entry * h;
4502 bfd_reloc_status_type r;
4505 bfd_boolean unresolved_reloc = FALSE;
4507 r_symndx = ELF32_R_SYM (rel->r_info);
4508 r_type = ELF32_R_TYPE (rel->r_info);
4509 r_type = arm_real_reloc_type (globals, r_type);
4511 if ( r_type == R_ARM_GNU_VTENTRY
4512 || r_type == R_ARM_GNU_VTINHERIT)
4515 bfd_reloc.howto = elf32_arm_howto_from_type (r_type);
4516 howto = bfd_reloc.howto;
4518 if (info->relocatable && globals->use_rel)
4520 /* This is a relocatable link. We don't have to change
4521 anything, unless the reloc is against a section symbol,
4522 in which case we have to adjust according to where the
4523 section symbol winds up in the output section. */
4524 if (r_symndx < symtab_hdr->sh_info)
4526 sym = local_syms + r_symndx;
4527 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4529 sec = local_sections[r_symndx];
4530 arm_add_to_rel (input_bfd, contents + rel->r_offset,
4532 (bfd_signed_vma) (sec->output_offset
4540 /* This is a final link. */
4545 if (r_symndx < symtab_hdr->sh_info)
4547 sym = local_syms + r_symndx;
4548 sym_type = ELF32_ST_TYPE (sym->st_info);
4549 sec = local_sections[r_symndx];
4550 if (globals->use_rel)
4552 relocation = (sec->output_section->vma
4553 + sec->output_offset
4555 if ((sec->flags & SEC_MERGE)
4556 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4559 bfd_vma addend, value;
4561 if (howto->rightshift)
4563 (*_bfd_error_handler)
4564 (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
4565 input_bfd, input_section,
4566 (long) rel->r_offset, howto->name);
4570 value = bfd_get_32 (input_bfd, contents + rel->r_offset);
4572 /* Get the (signed) value from the instruction. */
4573 addend = value & howto->src_mask;
4574 if (addend & ((howto->src_mask + 1) >> 1))
4576 bfd_signed_vma mask;
4579 mask &= ~ howto->src_mask;
4584 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
4586 addend += msec->output_section->vma + msec->output_offset;
4587 value = (value & ~ howto->dst_mask) | (addend & howto->dst_mask);
4588 bfd_put_32 (input_bfd, value, contents + rel->r_offset);
4592 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
4598 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4599 r_symndx, symtab_hdr, sym_hashes,
4601 unresolved_reloc, warned);
4607 name = h->root.root.string;
4610 name = (bfd_elf_string_from_elf_section
4611 (input_bfd, symtab_hdr->sh_link, sym->st_name));
4612 if (name == NULL || *name == '\0')
4613 name = bfd_section_name (input_bfd, sec);
4617 && r_type != R_ARM_NONE
4619 || h->root.type == bfd_link_hash_defined
4620 || h->root.type == bfd_link_hash_defweak)
4621 && IS_ARM_TLS_RELOC (r_type) != (sym_type == STT_TLS))
4623 (*_bfd_error_handler)
4624 ((sym_type == STT_TLS
4625 ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
4626 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
4629 (long) rel->r_offset,
4634 r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
4635 input_section, contents, rel,
4636 relocation, info, sec, name,
4637 (h ? ELF_ST_TYPE (h->type) :
4638 ELF_ST_TYPE (sym->st_info)), h,
4641 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4642 because such sections are not SEC_ALLOC and thus ld.so will
4643 not process them. */
4644 if (unresolved_reloc
4645 && !((input_section->flags & SEC_DEBUGGING) != 0
4648 (*_bfd_error_handler)
4649 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4652 (long) rel->r_offset,
4654 h->root.root.string);
4658 if (r != bfd_reloc_ok)
4660 const char * msg = (const char *) 0;
4664 case bfd_reloc_overflow:
4665 /* If the overflowing reloc was to an undefined symbol,
4666 we have already printed one error message and there
4667 is no point complaining again. */
4669 h->root.type != bfd_link_hash_undefined)
4670 && (!((*info->callbacks->reloc_overflow)
4671 (info, (h ? &h->root : NULL), name, howto->name,
4672 (bfd_vma) 0, input_bfd, input_section,
4677 case bfd_reloc_undefined:
4678 if (!((*info->callbacks->undefined_symbol)
4679 (info, name, input_bfd, input_section,
4680 rel->r_offset, TRUE)))
4684 case bfd_reloc_outofrange:
4685 msg = _("internal error: out of range error");
4688 case bfd_reloc_notsupported:
4689 msg = _("internal error: unsupported relocation error");
4692 case bfd_reloc_dangerous:
4693 msg = _("internal error: dangerous error");
4697 msg = _("internal error: unknown error");
4701 if (!((*info->callbacks->warning)
4702 (info, msg, name, input_bfd, input_section,
4713 /* Allocate/find an object attribute. */
4714 static aeabi_attribute *
4715 elf32_arm_new_eabi_attr (bfd *abfd, int tag)
4717 aeabi_attribute *attr;
4718 aeabi_attribute_list *list;
4719 aeabi_attribute_list *p;
4720 aeabi_attribute_list **lastp;
4723 if (tag < NUM_KNOWN_ATTRIBUTES)
4725 /* Knwon tags are preallocated. */
4726 attr = &elf32_arm_tdata (abfd)->known_eabi_attributes[tag];
4730 /* Create a new tag. */
4731 list = (aeabi_attribute_list *)
4732 bfd_alloc (abfd, sizeof (aeabi_attribute_list));
4733 memset (list, 0, sizeof (aeabi_attribute_list));
4735 /* Keep the tag list in order. */
4736 lastp = &elf32_arm_tdata (abfd)->other_eabi_attributes;
4737 for (p = *lastp; p; p = p->next)
4743 list->next = *lastp;
4752 elf32_arm_get_eabi_attr_int (bfd *abfd, int tag)
4754 aeabi_attribute_list *p;
4756 if (tag < NUM_KNOWN_ATTRIBUTES)
4758 /* Knwon tags are preallocated. */
4759 return elf32_arm_tdata (abfd)->known_eabi_attributes[tag].i;
4763 for (p = elf32_arm_tdata (abfd)->other_eabi_attributes;
4777 elf32_arm_add_eabi_attr_int (bfd *abfd, int tag, unsigned int i)
4779 aeabi_attribute *attr;
4781 attr = elf32_arm_new_eabi_attr (abfd, tag);
4787 attr_strdup (bfd *abfd, const char * s)
4792 len = strlen (s) + 1;
4793 p = (char *)bfd_alloc(abfd, len);
4794 return memcpy (p, s, len);
4798 elf32_arm_add_eabi_attr_string (bfd *abfd, int tag, const char *s)
4800 aeabi_attribute *attr;
4802 attr = elf32_arm_new_eabi_attr (abfd, tag);
4804 attr->s = attr_strdup (abfd, s);
4808 elf32_arm_add_eabi_attr_compat (bfd *abfd, unsigned int i, const char *s)
4810 aeabi_attribute_list *list;
4811 aeabi_attribute_list *p;
4812 aeabi_attribute_list **lastp;
4814 list = (aeabi_attribute_list *)
4815 bfd_alloc (abfd, sizeof (aeabi_attribute_list));
4816 memset (list, 0, sizeof (aeabi_attribute_list));
4817 list->tag = Tag_compatibility;
4818 list->attr.type = 3;
4820 list->attr.s = attr_strdup (abfd, s);
4822 lastp = &elf32_arm_tdata (abfd)->other_eabi_attributes;
4823 for (p = *lastp; p; p = p->next)
4826 if (p->tag != Tag_compatibility)
4828 cmp = strcmp(s, p->attr.s);
4829 if (cmp < 0 || (cmp == 0 && i < p->attr.i))
4833 list->next = *lastp;
4837 /* Set the right machine number. */
4840 elf32_arm_object_p (bfd *abfd)
4844 mach = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
4846 if (mach != bfd_mach_arm_unknown)
4847 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
4849 else if (elf_elfheader (abfd)->e_flags & EF_ARM_MAVERICK_FLOAT)
4850 bfd_default_set_arch_mach (abfd, bfd_arch_arm, bfd_mach_arm_ep9312);
4853 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
4858 /* Function to keep ARM specific flags in the ELF header. */
4861 elf32_arm_set_private_flags (bfd *abfd, flagword flags)
4863 if (elf_flags_init (abfd)
4864 && elf_elfheader (abfd)->e_flags != flags)
4866 if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
4868 if (flags & EF_ARM_INTERWORK)
4869 (*_bfd_error_handler)
4870 (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
4874 (_("Warning: Clearing the interworking flag of %B due to outside request"),
4880 elf_elfheader (abfd)->e_flags = flags;
4881 elf_flags_init (abfd) = TRUE;
4887 /* Copy the eabi object attribute from IBFD to OBFD. */
4889 copy_eabi_attributes (bfd *ibfd, bfd *obfd)
4891 aeabi_attribute *in_attr;
4892 aeabi_attribute *out_attr;
4893 aeabi_attribute_list *list;
4896 in_attr = elf32_arm_tdata (ibfd)->known_eabi_attributes;
4897 out_attr = elf32_arm_tdata (obfd)->known_eabi_attributes;
4898 for (i = 4; i < NUM_KNOWN_ATTRIBUTES; i++)
4900 out_attr->i = in_attr->i;
4901 if (in_attr->s && *in_attr->s)
4902 out_attr->s = attr_strdup (obfd, in_attr->s);
4907 for (list = elf32_arm_tdata (ibfd)->other_eabi_attributes;
4911 in_attr = &list->attr;
4912 switch (in_attr->type)
4915 elf32_arm_add_eabi_attr_int (obfd, list->tag, in_attr->i);
4918 elf32_arm_add_eabi_attr_string (obfd, list->tag, in_attr->s);
4921 elf32_arm_add_eabi_attr_compat (obfd, in_attr->i, in_attr->s);
4930 /* Copy backend specific data from one object module to another. */
4933 elf32_arm_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
4938 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4939 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4942 in_flags = elf_elfheader (ibfd)->e_flags;
4943 out_flags = elf_elfheader (obfd)->e_flags;
4945 if (elf_flags_init (obfd)
4946 && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
4947 && in_flags != out_flags)
4949 /* Cannot mix APCS26 and APCS32 code. */
4950 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
4953 /* Cannot mix float APCS and non-float APCS code. */
4954 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
4957 /* If the src and dest have different interworking flags
4958 then turn off the interworking bit. */
4959 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
4961 if (out_flags & EF_ARM_INTERWORK)
4963 (_("Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
4966 in_flags &= ~EF_ARM_INTERWORK;
4969 /* Likewise for PIC, though don't warn for this case. */
4970 if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC))
4971 in_flags &= ~EF_ARM_PIC;
4974 elf_elfheader (obfd)->e_flags = in_flags;
4975 elf_flags_init (obfd) = TRUE;
4977 /* Also copy the EI_OSABI field. */
4978 elf_elfheader (obfd)->e_ident[EI_OSABI] =
4979 elf_elfheader (ibfd)->e_ident[EI_OSABI];
4981 /* Copy EABI object attributes. */
4982 copy_eabi_attributes (ibfd, obfd);
4987 /* Values for Tag_ABI_PCS_R9_use. */
4996 /* Values for Tag_ABI_PCS_RW_data. */
4999 AEABI_PCS_RW_data_absolute,
5000 AEABI_PCS_RW_data_PCrel,
5001 AEABI_PCS_RW_data_SBrel,
5002 AEABI_PCS_RW_data_unused
5005 /* Values for Tag_ABI_enum_size. */
5011 AEABI_enum_forced_wide
5014 /* Merge EABI object attributes from IBFD into OBFD. Raise an error if there
5015 are conflicting attributes. */
5017 elf32_arm_merge_eabi_attributes (bfd *ibfd, bfd *obfd)
5019 aeabi_attribute *in_attr;
5020 aeabi_attribute *out_attr;
5021 aeabi_attribute_list *in_list;
5022 aeabi_attribute_list *out_list;
5023 /* Some tags have 0 = don't care, 1 = strong requirement,
5024 2 = weak requirement. */
5025 static const int order_312[3] = {3, 1, 2};
5028 if (!elf32_arm_tdata (ibfd)->known_eabi_attributes[0].i)
5030 /* This is the first object. Copy the attributes. */
5031 copy_eabi_attributes (ibfd, obfd);
5035 /* Use the Tag_null value to indicate the attributes have been
5037 elf32_arm_tdata (ibfd)->known_eabi_attributes[0].i = 1;
5039 in_attr = elf32_arm_tdata (ibfd)->known_eabi_attributes;
5040 out_attr = elf32_arm_tdata (obfd)->known_eabi_attributes;
5041 /* This needs to happen before Tag_ABI_FP_number_model is merged. */
5042 if (in_attr[Tag_ABI_VFP_args].i != out_attr[Tag_ABI_VFP_args].i)
5044 /* Ignore mismatches if teh object doesn't use floating point. */
5045 if (out_attr[Tag_ABI_FP_number_model].i == 0)
5046 out_attr[Tag_ABI_VFP_args].i = in_attr[Tag_ABI_VFP_args].i;
5047 else if (in_attr[Tag_ABI_FP_number_model].i != 0)
5050 (_("ERROR: %B uses VFP register arguments, %B does not"),
5056 for (i = 4; i < NUM_KNOWN_ATTRIBUTES; i++)
5058 /* Merge this attribute with existing attributes. */
5061 case Tag_CPU_raw_name:
5063 /* Use whichever has the greatest architecture requirements. */
5064 if (in_attr[Tag_CPU_arch].i > out_attr[Tag_CPU_arch].i)
5065 out_attr[i].s = attr_strdup(obfd, in_attr[i].s);
5068 case Tag_ABI_optimization_goals:
5069 case Tag_ABI_FP_optimization_goals:
5070 /* Use the first value seen. */
5074 case Tag_ARM_ISA_use:
5075 case Tag_THUMB_ISA_use:
5079 /* ??? Do NEON and WMMX conflict? */
5080 case Tag_ABI_FP_rounding:
5081 case Tag_ABI_FP_denormal:
5082 case Tag_ABI_FP_exceptions:
5083 case Tag_ABI_FP_user_exceptions:
5084 case Tag_ABI_FP_number_model:
5085 case Tag_ABI_align8_preserved:
5086 case Tag_ABI_HardFP_use:
5087 /* Use the largest value specified. */
5088 if (in_attr[i].i > out_attr[i].i)
5089 out_attr[i].i = in_attr[i].i;
5092 case Tag_CPU_arch_profile:
5093 /* Warn if conflicting architecture profiles used. */
5094 if (out_attr[i].i && in_attr[i].i && in_attr[i].i != out_attr[i].i)
5097 (_("ERROR: %B: Conflicting architecture profiles %c/%c"),
5098 ibfd, in_attr[i].i, out_attr[i].i);
5102 out_attr[i].i = in_attr[i].i;
5104 case Tag_PCS_config:
5105 if (out_attr[i].i == 0)
5106 out_attr[i].i = in_attr[i].i;
5107 else if (in_attr[i].i != 0 && out_attr[i].i != 0)
5109 /* It's sometimes ok to mix different configs, so this is only
5112 (_("Warning: %B: Conflicting platform configuration"), ibfd);
5115 case Tag_ABI_PCS_R9_use:
5116 if (out_attr[i].i != AEABI_R9_unused
5117 && in_attr[i].i != AEABI_R9_unused)
5120 (_("ERROR: %B: Conflicting use of R9"), ibfd);
5123 if (out_attr[i].i == AEABI_R9_unused)
5124 out_attr[i].i = in_attr[i].i;
5126 case Tag_ABI_PCS_RW_data:
5127 if (in_attr[i].i == AEABI_PCS_RW_data_SBrel
5128 && out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_SB
5129 && out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_unused)
5132 (_("ERROR: %B: SB relative addressing conflicts with use of R9"),
5136 /* Use the smallest value specified. */
5137 if (in_attr[i].i < out_attr[i].i)
5138 out_attr[i].i = in_attr[i].i;
5140 case Tag_ABI_PCS_RO_data:
5141 /* Use the smallest value specified. */
5142 if (in_attr[i].i < out_attr[i].i)
5143 out_attr[i].i = in_attr[i].i;
5145 case Tag_ABI_PCS_GOT_use:
5146 if (in_attr[i].i > 2 || out_attr[i].i > 2
5147 || order_312[in_attr[i].i] < order_312[out_attr[i].i])
5148 out_attr[i].i = in_attr[i].i;
5150 case Tag_ABI_PCS_wchar_t:
5151 if (out_attr[i].i && in_attr[i].i && out_attr[i].i != in_attr[i].i)
5154 (_("ERROR: %B: Conflicting definitions of wchar_t"), ibfd);
5158 out_attr[i].i = in_attr[i].i;
5160 case Tag_ABI_align8_needed:
5161 /* ??? Check against Tag_ABI_align8_preserved. */
5162 if (in_attr[i].i > 2 || out_attr[i].i > 2
5163 || order_312[in_attr[i].i] < order_312[out_attr[i].i])
5164 out_attr[i].i = in_attr[i].i;
5166 case Tag_ABI_enum_size:
5167 if (in_attr[i].i != AEABI_enum_unused)
5169 if (out_attr[i].i == AEABI_enum_unused
5170 || out_attr[i].i == AEABI_enum_forced_wide)
5172 /* The existing object is compatible with anything.
5173 Use whatever requirements the new object has. */
5174 out_attr[i].i = in_attr[i].i;
5176 else if (in_attr[i].i != AEABI_enum_forced_wide
5177 && out_attr[i].i != in_attr[i].i)
5180 (_("ERROR: %B: Conflicting enum sizes"), ibfd);
5184 case Tag_ABI_VFP_args:
5187 case Tag_ABI_WMMX_args:
5188 if (in_attr[i].i != out_attr[i].i)
5191 (_("ERROR: %B uses iWMMXt register arguments, %B does not"),
5196 default: /* All known attributes should be explicitly covered. */
5201 in_list = elf32_arm_tdata (ibfd)->other_eabi_attributes;
5202 out_list = elf32_arm_tdata (ibfd)->other_eabi_attributes;
5203 while (in_list && in_list->tag == Tag_compatibility)
5205 in_attr = &in_list->attr;
5206 if (in_attr->i == 0)
5208 if (in_attr->i == 1)
5211 (_("ERROR: %B: Must be processed by '%s' toolchain"),
5215 if (!out_list || out_list->tag != Tag_compatibility
5216 || strcmp (in_attr->s, out_list->attr.s) != 0)
5218 /* Add this compatibility tag to the output. */
5219 elf32_arm_add_eabi_attr_compat (obfd, in_attr->i, in_attr->s);
5222 out_attr = &out_list->attr;
5223 /* Check all the input tags with the same identifier. */
5226 if (out_list->tag != Tag_compatibility
5227 || in_attr->i != out_attr->i
5228 || strcmp (in_attr->s, out_attr->s) != 0)
5231 (_("ERROR: %B: Incompatible object tag '%s':%d"),
5232 ibfd, in_attr->s, in_attr->i);
5235 in_list = in_list->next;
5236 if (in_list->tag != Tag_compatibility
5237 || strcmp (in_attr->s, in_list->attr.s) != 0)
5239 in_attr = &in_list->attr;
5240 out_list = out_list->next;
5242 out_attr = &out_list->attr;
5245 /* Check the output doesn't have extra tags with this identifier. */
5246 if (out_list && out_list->tag == Tag_compatibility
5247 && strcmp (in_attr->s, out_list->attr.s) == 0)
5250 (_("ERROR: %B: Incompatible object tag '%s':%d"),
5251 ibfd, in_attr->s, out_list->attr.i);
5256 for (; in_list; in_list = in_list->next)
5258 if ((in_list->tag & 128) < 64)
5261 (_("Warning: %B: Unknown EABI object attribute %d"),
5262 ibfd, in_list->tag);
5270 /* Return TRUE if the two EABI versions are incompatible. */
5273 elf32_arm_versions_compatible (unsigned iver, unsigned over)
5275 /* v4 and v5 are the same spec before and after it was released,
5276 so allow mixing them. */
5277 if ((iver == EF_ARM_EABI_VER4 && over == EF_ARM_EABI_VER5)
5278 || (iver == EF_ARM_EABI_VER5 && over == EF_ARM_EABI_VER4))
5281 return (iver == over);
5284 /* Merge backend specific data from an object file to the output
5285 object file when linking. */
5288 elf32_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
5292 bfd_boolean flags_compatible = TRUE;
5295 /* Check if we have the same endianess. */
5296 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
5299 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5300 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5303 if (!elf32_arm_merge_eabi_attributes (ibfd, obfd))
5306 /* The input BFD must have had its flags initialised. */
5307 /* The following seems bogus to me -- The flags are initialized in
5308 the assembler but I don't think an elf_flags_init field is
5309 written into the object. */
5310 /* BFD_ASSERT (elf_flags_init (ibfd)); */
5312 in_flags = elf_elfheader (ibfd)->e_flags;
5313 out_flags = elf_elfheader (obfd)->e_flags;
5315 if (!elf_flags_init (obfd))
5317 /* If the input is the default architecture and had the default
5318 flags then do not bother setting the flags for the output
5319 architecture, instead allow future merges to do this. If no
5320 future merges ever set these flags then they will retain their
5321 uninitialised values, which surprise surprise, correspond
5322 to the default values. */
5323 if (bfd_get_arch_info (ibfd)->the_default
5324 && elf_elfheader (ibfd)->e_flags == 0)
5327 elf_flags_init (obfd) = TRUE;
5328 elf_elfheader (obfd)->e_flags = in_flags;
5330 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
5331 && bfd_get_arch_info (obfd)->the_default)
5332 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
5337 /* Determine what should happen if the input ARM architecture
5338 does not match the output ARM architecture. */
5339 if (! bfd_arm_merge_machines (ibfd, obfd))
5342 /* Identical flags must be compatible. */
5343 if (in_flags == out_flags)
5346 /* Check to see if the input BFD actually contains any sections. If
5347 not, its flags may not have been initialised either, but it
5348 cannot actually cause any incompatiblity. Do not short-circuit
5349 dynamic objects; their section list may be emptied by
5350 elf_link_add_object_symbols.
5352 Also check to see if there are no code sections in the input.
5353 In this case there is no need to check for code specific flags.
5354 XXX - do we need to worry about floating-point format compatability
5355 in data sections ? */
5356 if (!(ibfd->flags & DYNAMIC))
5358 bfd_boolean null_input_bfd = TRUE;
5359 bfd_boolean only_data_sections = TRUE;
5361 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
5363 /* Ignore synthetic glue sections. */
5364 if (strcmp (sec->name, ".glue_7")
5365 && strcmp (sec->name, ".glue_7t"))
5367 if ((bfd_get_section_flags (ibfd, sec)
5368 & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
5369 == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
5370 only_data_sections = FALSE;
5372 null_input_bfd = FALSE;
5377 if (null_input_bfd || only_data_sections)
5381 /* Complain about various flag mismatches. */
5382 if (!elf32_arm_versions_compatible (EF_ARM_EABI_VERSION (in_flags),
5383 EF_ARM_EABI_VERSION (out_flags)))
5386 (_("ERROR: Source object %B has EABI version %d, but target %B has EABI version %d"),
5388 (in_flags & EF_ARM_EABIMASK) >> 24,
5389 (out_flags & EF_ARM_EABIMASK) >> 24);
5393 /* Not sure what needs to be checked for EABI versions >= 1. */
5394 /* VxWorks libraries do not use these flags. */
5395 if (get_elf_backend_data (obfd) != &elf32_arm_vxworks_bed
5396 && get_elf_backend_data (ibfd) != &elf32_arm_vxworks_bed
5397 && EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
5399 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
5402 (_("ERROR: %B is compiled for APCS-%d, whereas target %B uses APCS-%d"),
5404 in_flags & EF_ARM_APCS_26 ? 26 : 32,
5405 out_flags & EF_ARM_APCS_26 ? 26 : 32);
5406 flags_compatible = FALSE;
5409 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
5411 if (in_flags & EF_ARM_APCS_FLOAT)
5413 (_("ERROR: %B passes floats in float registers, whereas %B passes them in integer registers"),
5417 (_("ERROR: %B passes floats in integer registers, whereas %B passes them in float registers"),
5420 flags_compatible = FALSE;
5423 if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT))
5425 if (in_flags & EF_ARM_VFP_FLOAT)
5427 (_("ERROR: %B uses VFP instructions, whereas %B does not"),
5431 (_("ERROR: %B uses FPA instructions, whereas %B does not"),
5434 flags_compatible = FALSE;
5437 if ((in_flags & EF_ARM_MAVERICK_FLOAT) != (out_flags & EF_ARM_MAVERICK_FLOAT))
5439 if (in_flags & EF_ARM_MAVERICK_FLOAT)
5441 (_("ERROR: %B uses Maverick instructions, whereas %B does not"),
5445 (_("ERROR: %B does not use Maverick instructions, whereas %B does"),
5448 flags_compatible = FALSE;
5451 #ifdef EF_ARM_SOFT_FLOAT
5452 if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
5454 /* We can allow interworking between code that is VFP format
5455 layout, and uses either soft float or integer regs for
5456 passing floating point arguments and results. We already
5457 know that the APCS_FLOAT flags match; similarly for VFP
5459 if ((in_flags & EF_ARM_APCS_FLOAT) != 0
5460 || (in_flags & EF_ARM_VFP_FLOAT) == 0)
5462 if (in_flags & EF_ARM_SOFT_FLOAT)
5464 (_("ERROR: %B uses software FP, whereas %B uses hardware FP"),
5468 (_("ERROR: %B uses hardware FP, whereas %B uses software FP"),
5471 flags_compatible = FALSE;
5476 /* Interworking mismatch is only a warning. */
5477 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
5479 if (in_flags & EF_ARM_INTERWORK)
5482 (_("Warning: %B supports interworking, whereas %B does not"),
5488 (_("Warning: %B does not support interworking, whereas %B does"),
5494 return flags_compatible;
5497 /* Display the flags field. */
5500 elf32_arm_print_private_bfd_data (bfd *abfd, void * ptr)
5502 FILE * file = (FILE *) ptr;
5503 unsigned long flags;
5505 BFD_ASSERT (abfd != NULL && ptr != NULL);
5507 /* Print normal ELF private data. */
5508 _bfd_elf_print_private_bfd_data (abfd, ptr);
5510 flags = elf_elfheader (abfd)->e_flags;
5511 /* Ignore init flag - it may not be set, despite the flags field
5512 containing valid data. */
5514 /* xgettext:c-format */
5515 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
5517 switch (EF_ARM_EABI_VERSION (flags))
5519 case EF_ARM_EABI_UNKNOWN:
5520 /* The following flag bits are GNU extensions and not part of the
5521 official ARM ELF extended ABI. Hence they are only decoded if
5522 the EABI version is not set. */
5523 if (flags & EF_ARM_INTERWORK)
5524 fprintf (file, _(" [interworking enabled]"));
5526 if (flags & EF_ARM_APCS_26)
5527 fprintf (file, " [APCS-26]");
5529 fprintf (file, " [APCS-32]");
5531 if (flags & EF_ARM_VFP_FLOAT)
5532 fprintf (file, _(" [VFP float format]"));
5533 else if (flags & EF_ARM_MAVERICK_FLOAT)
5534 fprintf (file, _(" [Maverick float format]"));
5536 fprintf (file, _(" [FPA float format]"));
5538 if (flags & EF_ARM_APCS_FLOAT)
5539 fprintf (file, _(" [floats passed in float registers]"));
5541 if (flags & EF_ARM_PIC)
5542 fprintf (file, _(" [position independent]"));
5544 if (flags & EF_ARM_NEW_ABI)
5545 fprintf (file, _(" [new ABI]"));
5547 if (flags & EF_ARM_OLD_ABI)
5548 fprintf (file, _(" [old ABI]"));
5550 if (flags & EF_ARM_SOFT_FLOAT)
5551 fprintf (file, _(" [software FP]"));
5553 flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT
5554 | EF_ARM_PIC | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI
5555 | EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT
5556 | EF_ARM_MAVERICK_FLOAT);
5559 case EF_ARM_EABI_VER1:
5560 fprintf (file, _(" [Version1 EABI]"));
5562 if (flags & EF_ARM_SYMSARESORTED)
5563 fprintf (file, _(" [sorted symbol table]"));
5565 fprintf (file, _(" [unsorted symbol table]"));
5567 flags &= ~ EF_ARM_SYMSARESORTED;
5570 case EF_ARM_EABI_VER2:
5571 fprintf (file, _(" [Version2 EABI]"));
5573 if (flags & EF_ARM_SYMSARESORTED)
5574 fprintf (file, _(" [sorted symbol table]"));
5576 fprintf (file, _(" [unsorted symbol table]"));
5578 if (flags & EF_ARM_DYNSYMSUSESEGIDX)
5579 fprintf (file, _(" [dynamic symbols use segment index]"));
5581 if (flags & EF_ARM_MAPSYMSFIRST)
5582 fprintf (file, _(" [mapping symbols precede others]"));
5584 flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX
5585 | EF_ARM_MAPSYMSFIRST);
5588 case EF_ARM_EABI_VER3:
5589 fprintf (file, _(" [Version3 EABI]"));
5592 case EF_ARM_EABI_VER4:
5593 fprintf (file, _(" [Version4 EABI]"));
5596 case EF_ARM_EABI_VER5:
5597 fprintf (file, _(" [Version5 EABI]"));
5599 if (flags & EF_ARM_BE8)
5600 fprintf (file, _(" [BE8]"));
5602 if (flags & EF_ARM_LE8)
5603 fprintf (file, _(" [LE8]"));
5605 flags &= ~(EF_ARM_LE8 | EF_ARM_BE8);
5609 fprintf (file, _(" <EABI version unrecognised>"));
5613 flags &= ~ EF_ARM_EABIMASK;
5615 if (flags & EF_ARM_RELEXEC)
5616 fprintf (file, _(" [relocatable executable]"));
5618 if (flags & EF_ARM_HASENTRY)
5619 fprintf (file, _(" [has entry point]"));
5621 flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
5624 fprintf (file, _("<Unrecognised flag bits set>"));
5632 elf32_arm_get_symbol_type (Elf_Internal_Sym * elf_sym, int type)
5634 switch (ELF_ST_TYPE (elf_sym->st_info))
5637 return ELF_ST_TYPE (elf_sym->st_info);
5640 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
5641 This allows us to distinguish between data used by Thumb instructions
5642 and non-data (which is probably code) inside Thumb regions of an
5644 if (type != STT_OBJECT && type != STT_TLS)
5645 return ELF_ST_TYPE (elf_sym->st_info);
5656 elf32_arm_gc_mark_hook (asection * sec,
5657 struct bfd_link_info * info ATTRIBUTE_UNUSED,
5658 Elf_Internal_Rela * rel,
5659 struct elf_link_hash_entry * h,
5660 Elf_Internal_Sym * sym)
5664 switch (ELF32_R_TYPE (rel->r_info))
5666 case R_ARM_GNU_VTINHERIT:
5667 case R_ARM_GNU_VTENTRY:
5671 switch (h->root.type)
5673 case bfd_link_hash_defined:
5674 case bfd_link_hash_defweak:
5675 return h->root.u.def.section;
5677 case bfd_link_hash_common:
5678 return h->root.u.c.p->section;
5686 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5691 /* Update the got entry reference counts for the section being removed. */
5694 elf32_arm_gc_sweep_hook (bfd * abfd,
5695 struct bfd_link_info * info,
5697 const Elf_Internal_Rela * relocs)
5699 Elf_Internal_Shdr *symtab_hdr;
5700 struct elf_link_hash_entry **sym_hashes;
5701 bfd_signed_vma *local_got_refcounts;
5702 const Elf_Internal_Rela *rel, *relend;
5703 struct elf32_arm_link_hash_table * globals;
5705 globals = elf32_arm_hash_table (info);
5707 elf_section_data (sec)->local_dynrel = NULL;
5709 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5710 sym_hashes = elf_sym_hashes (abfd);
5711 local_got_refcounts = elf_local_got_refcounts (abfd);
5713 relend = relocs + sec->reloc_count;
5714 for (rel = relocs; rel < relend; rel++)
5716 unsigned long r_symndx;
5717 struct elf_link_hash_entry *h = NULL;
5720 r_symndx = ELF32_R_SYM (rel->r_info);
5721 if (r_symndx >= symtab_hdr->sh_info)
5723 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5724 while (h->root.type == bfd_link_hash_indirect
5725 || h->root.type == bfd_link_hash_warning)
5726 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5729 r_type = ELF32_R_TYPE (rel->r_info);
5730 r_type = arm_real_reloc_type (globals, r_type);
5734 case R_ARM_GOT_PREL:
5735 case R_ARM_TLS_GD32:
5736 case R_ARM_TLS_IE32:
5739 if (h->got.refcount > 0)
5740 h->got.refcount -= 1;
5742 else if (local_got_refcounts != NULL)
5744 if (local_got_refcounts[r_symndx] > 0)
5745 local_got_refcounts[r_symndx] -= 1;
5749 case R_ARM_TLS_LDM32:
5750 elf32_arm_hash_table (info)->tls_ldm_got.refcount -= 1;
5760 case R_ARM_THM_CALL:
5761 case R_ARM_MOVW_ABS_NC:
5762 case R_ARM_MOVT_ABS:
5763 case R_ARM_MOVW_PREL_NC:
5764 case R_ARM_MOVT_PREL:
5765 case R_ARM_THM_MOVW_ABS_NC:
5766 case R_ARM_THM_MOVT_ABS:
5767 case R_ARM_THM_MOVW_PREL_NC:
5768 case R_ARM_THM_MOVT_PREL:
5769 /* Should the interworking branches be here also? */
5773 struct elf32_arm_link_hash_entry *eh;
5774 struct elf32_arm_relocs_copied **pp;
5775 struct elf32_arm_relocs_copied *p;
5777 eh = (struct elf32_arm_link_hash_entry *) h;
5779 if (h->plt.refcount > 0)
5781 h->plt.refcount -= 1;
5782 if (ELF32_R_TYPE (rel->r_info) == R_ARM_THM_CALL)
5783 eh->plt_thumb_refcount--;
5786 if (r_type == R_ARM_ABS32
5787 || r_type == R_ARM_REL32)
5789 for (pp = &eh->relocs_copied; (p = *pp) != NULL;
5791 if (p->section == sec)
5794 if (ELF32_R_TYPE (rel->r_info) == R_ARM_REL32)
5812 /* Look through the relocs for a section during the first phase. */
5815 elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info,
5816 asection *sec, const Elf_Internal_Rela *relocs)
5818 Elf_Internal_Shdr *symtab_hdr;
5819 struct elf_link_hash_entry **sym_hashes;
5820 struct elf_link_hash_entry **sym_hashes_end;
5821 const Elf_Internal_Rela *rel;
5822 const Elf_Internal_Rela *rel_end;
5825 bfd_vma *local_got_offsets;
5826 struct elf32_arm_link_hash_table *htab;
5828 if (info->relocatable)
5831 htab = elf32_arm_hash_table (info);
5834 /* Create dynamic sections for relocatable executables so that we can
5835 copy relocations. */
5836 if (htab->root.is_relocatable_executable
5837 && ! htab->root.dynamic_sections_created)
5839 if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
5843 dynobj = elf_hash_table (info)->dynobj;
5844 local_got_offsets = elf_local_got_offsets (abfd);
5846 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5847 sym_hashes = elf_sym_hashes (abfd);
5848 sym_hashes_end = sym_hashes
5849 + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
5851 if (!elf_bad_symtab (abfd))
5852 sym_hashes_end -= symtab_hdr->sh_info;
5854 rel_end = relocs + sec->reloc_count;
5855 for (rel = relocs; rel < rel_end; rel++)
5857 struct elf_link_hash_entry *h;
5858 struct elf32_arm_link_hash_entry *eh;
5859 unsigned long r_symndx;
5862 r_symndx = ELF32_R_SYM (rel->r_info);
5863 r_type = ELF32_R_TYPE (rel->r_info);
5864 r_type = arm_real_reloc_type (htab, r_type);
5866 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
5868 (*_bfd_error_handler) (_("%B: bad symbol index: %d"), abfd,
5873 if (r_symndx < symtab_hdr->sh_info)
5877 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5878 while (h->root.type == bfd_link_hash_indirect
5879 || h->root.type == bfd_link_hash_warning)
5880 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5883 eh = (struct elf32_arm_link_hash_entry *) h;
5888 case R_ARM_GOT_PREL:
5889 case R_ARM_TLS_GD32:
5890 case R_ARM_TLS_IE32:
5891 /* This symbol requires a global offset table entry. */
5893 int tls_type, old_tls_type;
5897 case R_ARM_TLS_GD32: tls_type = GOT_TLS_GD; break;
5898 case R_ARM_TLS_IE32: tls_type = GOT_TLS_IE; break;
5899 default: tls_type = GOT_NORMAL; break;
5905 old_tls_type = elf32_arm_hash_entry (h)->tls_type;
5909 bfd_signed_vma *local_got_refcounts;
5911 /* This is a global offset table entry for a local symbol. */
5912 local_got_refcounts = elf_local_got_refcounts (abfd);
5913 if (local_got_refcounts == NULL)
5917 size = symtab_hdr->sh_info;
5918 size *= (sizeof (bfd_signed_vma) + sizeof(char));
5919 local_got_refcounts = bfd_zalloc (abfd, size);
5920 if (local_got_refcounts == NULL)
5922 elf_local_got_refcounts (abfd) = local_got_refcounts;
5923 elf32_arm_local_got_tls_type (abfd)
5924 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
5926 local_got_refcounts[r_symndx] += 1;
5927 old_tls_type = elf32_arm_local_got_tls_type (abfd) [r_symndx];
5930 /* We will already have issued an error message if there is a
5931 TLS / non-TLS mismatch, based on the symbol type. We don't
5932 support any linker relaxations. So just combine any TLS
5934 if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
5935 && tls_type != GOT_NORMAL)
5936 tls_type |= old_tls_type;
5938 if (old_tls_type != tls_type)
5941 elf32_arm_hash_entry (h)->tls_type = tls_type;
5943 elf32_arm_local_got_tls_type (abfd) [r_symndx] = tls_type;
5948 case R_ARM_TLS_LDM32:
5949 if (r_type == R_ARM_TLS_LDM32)
5950 htab->tls_ldm_got.refcount++;
5953 case R_ARM_GOTOFF32:
5955 if (htab->sgot == NULL)
5957 if (htab->root.dynobj == NULL)
5958 htab->root.dynobj = abfd;
5959 if (!create_got_section (htab->root.dynobj, info))
5965 /* VxWorks uses dynamic R_ARM_ABS12 relocations for
5966 ldr __GOTT_INDEX__ offsets. */
5967 if (!htab->vxworks_p)
5978 case R_ARM_THM_CALL:
5979 case R_ARM_MOVW_ABS_NC:
5980 case R_ARM_MOVT_ABS:
5981 case R_ARM_MOVW_PREL_NC:
5982 case R_ARM_MOVT_PREL:
5983 case R_ARM_THM_MOVW_ABS_NC:
5984 case R_ARM_THM_MOVT_ABS:
5985 case R_ARM_THM_MOVW_PREL_NC:
5986 case R_ARM_THM_MOVT_PREL:
5987 /* Should the interworking branches be listed here? */
5990 /* If this reloc is in a read-only section, we might
5991 need a copy reloc. We can't check reliably at this
5992 stage whether the section is read-only, as input
5993 sections have not yet been mapped to output sections.
5994 Tentatively set the flag for now, and correct in
5995 adjust_dynamic_symbol. */
5999 /* We may need a .plt entry if the function this reloc
6000 refers to is in a different object. We can't tell for
6001 sure yet, because something later might force the
6003 if (r_type != R_ARM_ABS32 && r_type != R_ARM_REL32)
6006 /* If we create a PLT entry, this relocation will reference
6007 it, even if it's an ABS32 relocation. */
6008 h->plt.refcount += 1;
6010 if (r_type == R_ARM_THM_CALL)
6011 eh->plt_thumb_refcount += 1;
6014 /* If we are creating a shared library or relocatable executable,
6015 and this is a reloc against a global symbol, or a non PC
6016 relative reloc against a local symbol, then we need to copy
6017 the reloc into the shared library. However, if we are linking
6018 with -Bsymbolic, we do not need to copy a reloc against a
6019 global symbol which is defined in an object we are
6020 including in the link (i.e., DEF_REGULAR is set). At
6021 this point we have not seen all the input files, so it is
6022 possible that DEF_REGULAR is not set now but will be set
6023 later (it is never cleared). We account for that
6024 possibility below by storing information in the
6025 relocs_copied field of the hash table entry. */
6026 if ((info->shared || htab->root.is_relocatable_executable)
6027 && (sec->flags & SEC_ALLOC) != 0
6028 && (r_type == R_ARM_ABS32
6029 || (h != NULL && ! h->needs_plt
6030 && (! info->symbolic || ! h->def_regular))))
6032 struct elf32_arm_relocs_copied *p, **head;
6034 /* When creating a shared object, we must copy these
6035 reloc types into the output file. We create a reloc
6036 section in dynobj and make room for this reloc. */
6041 name = (bfd_elf_string_from_elf_section
6043 elf_elfheader (abfd)->e_shstrndx,
6044 elf_section_data (sec)->rel_hdr.sh_name));
6048 BFD_ASSERT (reloc_section_p (htab, name, sec));
6050 sreloc = bfd_get_section_by_name (dynobj, name);
6055 flags = (SEC_HAS_CONTENTS | SEC_READONLY
6056 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
6057 if ((sec->flags & SEC_ALLOC) != 0
6058 /* BPABI objects never have dynamic
6059 relocations mapped. */
6060 && !htab->symbian_p)
6061 flags |= SEC_ALLOC | SEC_LOAD;
6062 sreloc = bfd_make_section_with_flags (dynobj,
6066 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
6070 elf_section_data (sec)->sreloc = sreloc;
6073 /* If this is a global symbol, we count the number of
6074 relocations we need for this symbol. */
6077 head = &((struct elf32_arm_link_hash_entry *) h)->relocs_copied;
6081 /* Track dynamic relocs needed for local syms too.
6082 We really need local syms available to do this
6088 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
6093 vpp = &elf_section_data (s)->local_dynrel;
6094 head = (struct elf32_arm_relocs_copied **) vpp;
6098 if (p == NULL || p->section != sec)
6100 bfd_size_type amt = sizeof *p;
6102 p = bfd_alloc (htab->root.dynobj, amt);
6112 if (r_type == R_ARM_REL32)
6118 /* This relocation describes the C++ object vtable hierarchy.
6119 Reconstruct it for later use during GC. */
6120 case R_ARM_GNU_VTINHERIT:
6121 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
6125 /* This relocation describes which C++ vtable entries are actually
6126 used. Record for later use during GC. */
6127 case R_ARM_GNU_VTENTRY:
6128 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
6137 /* Treat mapping symbols as special target symbols. */
6140 elf32_arm_is_target_special_symbol (bfd * abfd ATTRIBUTE_UNUSED, asymbol * sym)
6142 return bfd_is_arm_special_symbol_name (sym->name,
6143 BFD_ARM_SPECIAL_SYM_TYPE_ANY);
6146 /* This is a copy of elf_find_function() from elf.c except that
6147 ARM mapping symbols are ignored when looking for function names
6148 and STT_ARM_TFUNC is considered to a function type. */
6151 arm_elf_find_function (bfd * abfd ATTRIBUTE_UNUSED,
6155 const char ** filename_ptr,
6156 const char ** functionname_ptr)
6158 const char * filename = NULL;
6159 asymbol * func = NULL;
6160 bfd_vma low_func = 0;
6163 for (p = symbols; *p != NULL; p++)
6167 q = (elf_symbol_type *) *p;
6169 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
6174 filename = bfd_asymbol_name (&q->symbol);
6179 /* Skip mapping symbols. */
6180 if ((q->symbol.flags & BSF_LOCAL)
6181 && bfd_is_arm_special_symbol_name (q->symbol.name,
6182 BFD_ARM_SPECIAL_SYM_TYPE_ANY))
6185 if (bfd_get_section (&q->symbol) == section
6186 && q->symbol.value >= low_func
6187 && q->symbol.value <= offset)
6189 func = (asymbol *) q;
6190 low_func = q->symbol.value;
6200 *filename_ptr = filename;
6201 if (functionname_ptr)
6202 *functionname_ptr = bfd_asymbol_name (func);
6208 /* Find the nearest line to a particular section and offset, for error
6209 reporting. This code is a duplicate of the code in elf.c, except
6210 that it uses arm_elf_find_function. */
6213 elf32_arm_find_nearest_line (bfd * abfd,
6217 const char ** filename_ptr,
6218 const char ** functionname_ptr,
6219 unsigned int * line_ptr)
6221 bfd_boolean found = FALSE;
6223 /* We skip _bfd_dwarf1_find_nearest_line since no known ARM toolchain uses it. */
6225 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
6226 filename_ptr, functionname_ptr,
6228 & elf_tdata (abfd)->dwarf2_find_line_info))
6230 if (!*functionname_ptr)
6231 arm_elf_find_function (abfd, section, symbols, offset,
6232 *filename_ptr ? NULL : filename_ptr,
6238 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
6239 & found, filename_ptr,
6240 functionname_ptr, line_ptr,
6241 & elf_tdata (abfd)->line_info))
6244 if (found && (*functionname_ptr || *line_ptr))
6247 if (symbols == NULL)
6250 if (! arm_elf_find_function (abfd, section, symbols, offset,
6251 filename_ptr, functionname_ptr))
6259 elf32_arm_find_inliner_info (bfd * abfd,
6260 const char ** filename_ptr,
6261 const char ** functionname_ptr,
6262 unsigned int * line_ptr)
6265 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
6266 functionname_ptr, line_ptr,
6267 & elf_tdata (abfd)->dwarf2_find_line_info);
6271 /* Adjust a symbol defined by a dynamic object and referenced by a
6272 regular object. The current definition is in some section of the
6273 dynamic object, but we're not including those sections. We have to
6274 change the definition to something the rest of the link can
6278 elf32_arm_adjust_dynamic_symbol (struct bfd_link_info * info,
6279 struct elf_link_hash_entry * h)
6283 unsigned int power_of_two;
6284 struct elf32_arm_link_hash_entry * eh;
6285 struct elf32_arm_link_hash_table *globals;
6287 globals = elf32_arm_hash_table (info);
6288 dynobj = elf_hash_table (info)->dynobj;
6290 /* Make sure we know what is going on here. */
6291 BFD_ASSERT (dynobj != NULL
6293 || h->u.weakdef != NULL
6296 && !h->def_regular)));
6298 eh = (struct elf32_arm_link_hash_entry *) h;
6300 /* If this is a function, put it in the procedure linkage table. We
6301 will fill in the contents of the procedure linkage table later,
6302 when we know the address of the .got section. */
6303 if (h->type == STT_FUNC || h->type == STT_ARM_TFUNC
6306 if (h->plt.refcount <= 0
6307 || SYMBOL_CALLS_LOCAL (info, h)
6308 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6309 && h->root.type == bfd_link_hash_undefweak))
6311 /* This case can occur if we saw a PLT32 reloc in an input
6312 file, but the symbol was never referred to by a dynamic
6313 object, or if all references were garbage collected. In
6314 such a case, we don't actually need to build a procedure
6315 linkage table, and we can just do a PC24 reloc instead. */
6316 h->plt.offset = (bfd_vma) -1;
6317 eh->plt_thumb_refcount = 0;
6325 /* It's possible that we incorrectly decided a .plt reloc was
6326 needed for an R_ARM_PC24 or similar reloc to a non-function sym
6327 in check_relocs. We can't decide accurately between function
6328 and non-function syms in check-relocs; Objects loaded later in
6329 the link may change h->type. So fix it now. */
6330 h->plt.offset = (bfd_vma) -1;
6331 eh->plt_thumb_refcount = 0;
6334 /* If this is a weak symbol, and there is a real definition, the
6335 processor independent code will have arranged for us to see the
6336 real definition first, and we can just use the same value. */
6337 if (h->u.weakdef != NULL)
6339 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6340 || h->u.weakdef->root.type == bfd_link_hash_defweak);
6341 h->root.u.def.section = h->u.weakdef->root.u.def.section;
6342 h->root.u.def.value = h->u.weakdef->root.u.def.value;
6346 /* If there are no non-GOT references, we do not need a copy
6348 if (!h->non_got_ref)
6351 /* This is a reference to a symbol defined by a dynamic object which
6352 is not a function. */
6354 /* If we are creating a shared library, we must presume that the
6355 only references to the symbol are via the global offset table.
6356 For such cases we need not do anything here; the relocations will
6357 be handled correctly by relocate_section. Relocatable executables
6358 can reference data in shared objects directly, so we don't need to
6359 do anything here. */
6360 if (info->shared || globals->root.is_relocatable_executable)
6365 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
6366 h->root.root.string);
6370 /* We must allocate the symbol in our .dynbss section, which will
6371 become part of the .bss section of the executable. There will be
6372 an entry for this symbol in the .dynsym section. The dynamic
6373 object will contain position independent code, so all references
6374 from the dynamic object to this symbol will go through the global
6375 offset table. The dynamic linker will use the .dynsym entry to
6376 determine the address it must put in the global offset table, so
6377 both the dynamic object and the regular object will refer to the
6378 same memory location for the variable. */
6379 s = bfd_get_section_by_name (dynobj, ".dynbss");
6380 BFD_ASSERT (s != NULL);
6382 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
6383 copy the initial value out of the dynamic object and into the
6384 runtime process image. We need to remember the offset into the
6385 .rel(a).bss section we are going to use. */
6386 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
6390 srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (globals, ".bss"));
6391 BFD_ASSERT (srel != NULL);
6392 srel->size += RELOC_SIZE (globals);
6396 /* We need to figure out the alignment required for this symbol. I
6397 have no idea how ELF linkers handle this. */
6398 power_of_two = bfd_log2 (h->size);
6399 if (power_of_two > 3)
6402 /* Apply the required alignment. */
6403 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
6404 if (power_of_two > bfd_get_section_alignment (dynobj, s))
6406 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
6410 /* Define the symbol as being at this point in the section. */
6411 h->root.u.def.section = s;
6412 h->root.u.def.value = s->size;
6414 /* Increment the section size to make room for the symbol. */
6420 /* Allocate space in .plt, .got and associated reloc sections for
6424 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
6426 struct bfd_link_info *info;
6427 struct elf32_arm_link_hash_table *htab;
6428 struct elf32_arm_link_hash_entry *eh;
6429 struct elf32_arm_relocs_copied *p;
6431 eh = (struct elf32_arm_link_hash_entry *) h;
6433 if (h->root.type == bfd_link_hash_indirect)
6436 if (h->root.type == bfd_link_hash_warning)
6437 /* When warning symbols are created, they **replace** the "real"
6438 entry in the hash table, thus we never get to see the real
6439 symbol in a hash traversal. So look at it now. */
6440 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6442 info = (struct bfd_link_info *) inf;
6443 htab = elf32_arm_hash_table (info);
6445 if (htab->root.dynamic_sections_created
6446 && h->plt.refcount > 0)
6448 /* Make sure this symbol is output as a dynamic symbol.
6449 Undefined weak syms won't yet be marked as dynamic. */
6450 if (h->dynindx == -1
6451 && !h->forced_local)
6453 if (! bfd_elf_link_record_dynamic_symbol (info, h))
6458 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
6460 asection *s = htab->splt;
6462 /* If this is the first .plt entry, make room for the special
6465 s->size += htab->plt_header_size;
6467 h->plt.offset = s->size;
6469 /* If we will insert a Thumb trampoline before this PLT, leave room
6471 if (!htab->use_blx && eh->plt_thumb_refcount > 0)
6473 h->plt.offset += PLT_THUMB_STUB_SIZE;
6474 s->size += PLT_THUMB_STUB_SIZE;
6477 /* If this symbol is not defined in a regular file, and we are
6478 not generating a shared library, then set the symbol to this
6479 location in the .plt. This is required to make function
6480 pointers compare as equal between the normal executable and
6481 the shared library. */
6485 h->root.u.def.section = s;
6486 h->root.u.def.value = h->plt.offset;
6488 /* Make sure the function is not marked as Thumb, in case
6489 it is the target of an ABS32 relocation, which will
6490 point to the PLT entry. */
6491 if (ELF_ST_TYPE (h->type) == STT_ARM_TFUNC)
6492 h->type = ELF_ST_INFO (ELF_ST_BIND (h->type), STT_FUNC);
6495 /* Make room for this entry. */
6496 s->size += htab->plt_entry_size;
6498 if (!htab->symbian_p)
6500 /* We also need to make an entry in the .got.plt section, which
6501 will be placed in the .got section by the linker script. */
6502 eh->plt_got_offset = htab->sgotplt->size;
6503 htab->sgotplt->size += 4;
6506 /* We also need to make an entry in the .rel(a).plt section. */
6507 htab->srelplt->size += RELOC_SIZE (htab);
6509 /* VxWorks executables have a second set of relocations for
6510 each PLT entry. They go in a separate relocation section,
6511 which is processed by the kernel loader. */
6512 if (htab->vxworks_p && !info->shared)
6514 /* There is a relocation for the initial PLT entry:
6515 an R_ARM_32 relocation for _GLOBAL_OFFSET_TABLE_. */
6516 if (h->plt.offset == htab->plt_header_size)
6517 htab->srelplt2->size += RELOC_SIZE (htab);
6519 /* There are two extra relocations for each subsequent
6520 PLT entry: an R_ARM_32 relocation for the GOT entry,
6521 and an R_ARM_32 relocation for the PLT entry. */
6522 htab->srelplt2->size += RELOC_SIZE (htab) * 2;
6527 h->plt.offset = (bfd_vma) -1;
6533 h->plt.offset = (bfd_vma) -1;
6537 if (h->got.refcount > 0)
6541 int tls_type = elf32_arm_hash_entry (h)->tls_type;
6544 /* Make sure this symbol is output as a dynamic symbol.
6545 Undefined weak syms won't yet be marked as dynamic. */
6546 if (h->dynindx == -1
6547 && !h->forced_local)
6549 if (! bfd_elf_link_record_dynamic_symbol (info, h))
6553 if (!htab->symbian_p)
6556 h->got.offset = s->size;
6558 if (tls_type == GOT_UNKNOWN)
6561 if (tls_type == GOT_NORMAL)
6562 /* Non-TLS symbols need one GOT slot. */
6566 if (tls_type & GOT_TLS_GD)
6567 /* R_ARM_TLS_GD32 needs 2 consecutive GOT slots. */
6569 if (tls_type & GOT_TLS_IE)
6570 /* R_ARM_TLS_IE32 needs one GOT slot. */
6574 dyn = htab->root.dynamic_sections_created;
6577 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
6579 || !SYMBOL_REFERENCES_LOCAL (info, h)))
6582 if (tls_type != GOT_NORMAL
6583 && (info->shared || indx != 0)
6584 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
6585 || h->root.type != bfd_link_hash_undefweak))
6587 if (tls_type & GOT_TLS_IE)
6588 htab->srelgot->size += RELOC_SIZE (htab);
6590 if (tls_type & GOT_TLS_GD)
6591 htab->srelgot->size += RELOC_SIZE (htab);
6593 if ((tls_type & GOT_TLS_GD) && indx != 0)
6594 htab->srelgot->size += RELOC_SIZE (htab);
6596 else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
6597 || h->root.type != bfd_link_hash_undefweak)
6599 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
6600 htab->srelgot->size += RELOC_SIZE (htab);
6604 h->got.offset = (bfd_vma) -1;
6606 if (eh->relocs_copied == NULL)
6609 /* In the shared -Bsymbolic case, discard space allocated for
6610 dynamic pc-relative relocs against symbols which turn out to be
6611 defined in regular objects. For the normal shared case, discard
6612 space for pc-relative relocs that have become local due to symbol
6613 visibility changes. */
6615 if (info->shared || htab->root.is_relocatable_executable)
6617 /* The only reloc that uses pc_count is R_ARM_REL32, which will
6618 appear on something like ".long foo - .". We want calls to
6619 protected symbols to resolve directly to the function rather
6620 than going via the plt. If people want function pointer
6621 comparisons to work as expected then they should avoid
6622 writing assembly like ".long foo - .". */
6623 if (SYMBOL_CALLS_LOCAL (info, h))
6625 struct elf32_arm_relocs_copied **pp;
6627 for (pp = &eh->relocs_copied; (p = *pp) != NULL; )
6629 p->count -= p->pc_count;
6638 /* Also discard relocs on undefined weak syms with non-default
6640 if (eh->relocs_copied != NULL
6641 && h->root.type == bfd_link_hash_undefweak)
6643 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
6644 eh->relocs_copied = NULL;
6646 /* Make sure undefined weak symbols are output as a dynamic
6648 else if (h->dynindx == -1
6649 && !h->forced_local)
6651 if (! bfd_elf_link_record_dynamic_symbol (info, h))
6656 else if (htab->root.is_relocatable_executable && h->dynindx == -1
6657 && h->root.type == bfd_link_hash_new)
6659 /* Output absolute symbols so that we can create relocations
6660 against them. For normal symbols we output a relocation
6661 against the section that contains them. */
6662 if (! bfd_elf_link_record_dynamic_symbol (info, h))
6669 /* For the non-shared case, discard space for relocs against
6670 symbols which turn out to need copy relocs or are not
6676 || (htab->root.dynamic_sections_created
6677 && (h->root.type == bfd_link_hash_undefweak
6678 || h->root.type == bfd_link_hash_undefined))))
6680 /* Make sure this symbol is output as a dynamic symbol.
6681 Undefined weak syms won't yet be marked as dynamic. */
6682 if (h->dynindx == -1
6683 && !h->forced_local)
6685 if (! bfd_elf_link_record_dynamic_symbol (info, h))
6689 /* If that succeeded, we know we'll be keeping all the
6691 if (h->dynindx != -1)
6695 eh->relocs_copied = NULL;
6700 /* Finally, allocate space. */
6701 for (p = eh->relocs_copied; p != NULL; p = p->next)
6703 asection *sreloc = elf_section_data (p->section)->sreloc;
6704 sreloc->size += p->count * RELOC_SIZE (htab);
6710 /* Find any dynamic relocs that apply to read-only sections. */
6713 elf32_arm_readonly_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
6715 struct elf32_arm_link_hash_entry *eh;
6716 struct elf32_arm_relocs_copied *p;
6718 if (h->root.type == bfd_link_hash_warning)
6719 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6721 eh = (struct elf32_arm_link_hash_entry *) h;
6722 for (p = eh->relocs_copied; p != NULL; p = p->next)
6724 asection *s = p->section;
6726 if (s != NULL && (s->flags & SEC_READONLY) != 0)
6728 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6730 info->flags |= DF_TEXTREL;
6732 /* Not an error, just cut short the traversal. */
6739 /* Set the sizes of the dynamic sections. */
6742 elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
6743 struct bfd_link_info * info)
6750 struct elf32_arm_link_hash_table *htab;
6752 htab = elf32_arm_hash_table (info);
6753 dynobj = elf_hash_table (info)->dynobj;
6754 BFD_ASSERT (dynobj != NULL);
6755 check_use_blx (htab);
6757 if (elf_hash_table (info)->dynamic_sections_created)
6759 /* Set the contents of the .interp section to the interpreter. */
6760 if (info->executable)
6762 s = bfd_get_section_by_name (dynobj, ".interp");
6763 BFD_ASSERT (s != NULL);
6764 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
6765 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
6769 /* Set up .got offsets for local syms, and space for local dynamic
6771 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6773 bfd_signed_vma *local_got;
6774 bfd_signed_vma *end_local_got;
6775 char *local_tls_type;
6776 bfd_size_type locsymcount;
6777 Elf_Internal_Shdr *symtab_hdr;
6780 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
6783 for (s = ibfd->sections; s != NULL; s = s->next)
6785 struct elf32_arm_relocs_copied *p;
6787 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
6789 if (!bfd_is_abs_section (p->section)
6790 && bfd_is_abs_section (p->section->output_section))
6792 /* Input section has been discarded, either because
6793 it is a copy of a linkonce section or due to
6794 linker script /DISCARD/, so we'll be discarding
6797 else if (p->count != 0)
6799 srel = elf_section_data (p->section)->sreloc;
6800 srel->size += p->count * RELOC_SIZE (htab);
6801 if ((p->section->output_section->flags & SEC_READONLY) != 0)
6802 info->flags |= DF_TEXTREL;
6807 local_got = elf_local_got_refcounts (ibfd);
6811 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
6812 locsymcount = symtab_hdr->sh_info;
6813 end_local_got = local_got + locsymcount;
6814 local_tls_type = elf32_arm_local_got_tls_type (ibfd);
6816 srel = htab->srelgot;
6817 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
6821 *local_got = s->size;
6822 if (*local_tls_type & GOT_TLS_GD)
6823 /* TLS_GD relocs need an 8-byte structure in the GOT. */
6825 if (*local_tls_type & GOT_TLS_IE)
6827 if (*local_tls_type == GOT_NORMAL)
6830 if (info->shared || *local_tls_type == GOT_TLS_GD)
6831 srel->size += RELOC_SIZE (htab);
6834 *local_got = (bfd_vma) -1;
6838 if (htab->tls_ldm_got.refcount > 0)
6840 /* Allocate two GOT entries and one dynamic relocation (if necessary)
6841 for R_ARM_TLS_LDM32 relocations. */
6842 htab->tls_ldm_got.offset = htab->sgot->size;
6843 htab->sgot->size += 8;
6845 htab->srelgot->size += RELOC_SIZE (htab);
6848 htab->tls_ldm_got.offset = -1;
6850 /* Allocate global sym .plt and .got entries, and space for global
6851 sym dynamic relocs. */
6852 elf_link_hash_traverse (& htab->root, allocate_dynrelocs, info);
6854 /* The check_relocs and adjust_dynamic_symbol entry points have
6855 determined the sizes of the various dynamic sections. Allocate
6859 for (s = dynobj->sections; s != NULL; s = s->next)
6863 if ((s->flags & SEC_LINKER_CREATED) == 0)
6866 /* It's OK to base decisions on the section name, because none
6867 of the dynobj section names depend upon the input files. */
6868 name = bfd_get_section_name (dynobj, s);
6870 if (strcmp (name, ".plt") == 0)
6872 /* Remember whether there is a PLT. */
6875 else if (strncmp (name, ".rel", 4) == 0)
6879 /* Remember whether there are any reloc sections other
6880 than .rel(a).plt and .rela.plt.unloaded. */
6881 if (s != htab->srelplt && s != htab->srelplt2)
6884 /* We use the reloc_count field as a counter if we need
6885 to copy relocs into the output file. */
6889 else if (strncmp (name, ".got", 4) != 0
6890 && strcmp (name, ".dynbss") != 0)
6892 /* It's not one of our sections, so don't allocate space. */
6898 /* If we don't need this section, strip it from the
6899 output file. This is mostly to handle .rel(a).bss and
6900 .rel(a).plt. We must create both sections in
6901 create_dynamic_sections, because they must be created
6902 before the linker maps input sections to output
6903 sections. The linker does that before
6904 adjust_dynamic_symbol is called, and it is that
6905 function which decides whether anything needs to go
6906 into these sections. */
6907 s->flags |= SEC_EXCLUDE;
6911 if ((s->flags & SEC_HAS_CONTENTS) == 0)
6914 /* Allocate memory for the section contents. */
6915 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
6916 if (s->contents == NULL)
6920 if (elf_hash_table (info)->dynamic_sections_created)
6922 /* Add some entries to the .dynamic section. We fill in the
6923 values later, in elf32_arm_finish_dynamic_sections, but we
6924 must add the entries now so that we get the correct size for
6925 the .dynamic section. The DT_DEBUG entry is filled in by the
6926 dynamic linker and used by the debugger. */
6927 #define add_dynamic_entry(TAG, VAL) \
6928 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
6930 if (info->executable)
6932 if (!add_dynamic_entry (DT_DEBUG, 0))
6938 if ( !add_dynamic_entry (DT_PLTGOT, 0)
6939 || !add_dynamic_entry (DT_PLTRELSZ, 0)
6940 || !add_dynamic_entry (DT_PLTREL,
6941 htab->use_rel ? DT_REL : DT_RELA)
6942 || !add_dynamic_entry (DT_JMPREL, 0))
6950 if (!add_dynamic_entry (DT_REL, 0)
6951 || !add_dynamic_entry (DT_RELSZ, 0)
6952 || !add_dynamic_entry (DT_RELENT, RELOC_SIZE (htab)))
6957 if (!add_dynamic_entry (DT_RELA, 0)
6958 || !add_dynamic_entry (DT_RELASZ, 0)
6959 || !add_dynamic_entry (DT_RELAENT, RELOC_SIZE (htab)))
6964 /* If any dynamic relocs apply to a read-only section,
6965 then we need a DT_TEXTREL entry. */
6966 if ((info->flags & DF_TEXTREL) == 0)
6967 elf_link_hash_traverse (&htab->root, elf32_arm_readonly_dynrelocs,
6970 if ((info->flags & DF_TEXTREL) != 0)
6972 if (!add_dynamic_entry (DT_TEXTREL, 0))
6976 #undef add_dynamic_entry
6981 /* Finish up dynamic symbol handling. We set the contents of various
6982 dynamic sections here. */
6985 elf32_arm_finish_dynamic_symbol (bfd * output_bfd, struct bfd_link_info * info,
6986 struct elf_link_hash_entry * h, Elf_Internal_Sym * sym)
6989 struct elf32_arm_link_hash_table *htab;
6990 struct elf32_arm_link_hash_entry *eh;
6992 dynobj = elf_hash_table (info)->dynobj;
6993 htab = elf32_arm_hash_table (info);
6994 eh = (struct elf32_arm_link_hash_entry *) h;
6996 if (h->plt.offset != (bfd_vma) -1)
7002 Elf_Internal_Rela rel;
7004 /* This symbol has an entry in the procedure linkage table. Set
7007 BFD_ASSERT (h->dynindx != -1);
7009 splt = bfd_get_section_by_name (dynobj, ".plt");
7010 srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (htab, ".plt"));
7011 BFD_ASSERT (splt != NULL && srel != NULL);
7013 /* Fill in the entry in the procedure linkage table. */
7014 if (htab->symbian_p)
7016 put_arm_insn (htab, output_bfd,
7017 elf32_arm_symbian_plt_entry[0],
7018 splt->contents + h->plt.offset);
7019 bfd_put_32 (output_bfd,
7020 elf32_arm_symbian_plt_entry[1],
7021 splt->contents + h->plt.offset + 4);
7023 /* Fill in the entry in the .rel.plt section. */
7024 rel.r_offset = (splt->output_section->vma
7025 + splt->output_offset
7026 + h->plt.offset + 4);
7027 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
7029 /* Get the index in the procedure linkage table which
7030 corresponds to this symbol. This is the index of this symbol
7031 in all the symbols for which we are making plt entries. The
7032 first entry in the procedure linkage table is reserved. */
7033 plt_index = ((h->plt.offset - htab->plt_header_size)
7034 / htab->plt_entry_size);
7038 bfd_vma got_offset, got_address, plt_address;
7039 bfd_vma got_displacement;
7043 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
7044 BFD_ASSERT (sgot != NULL);
7046 /* Get the offset into the .got.plt table of the entry that
7047 corresponds to this function. */
7048 got_offset = eh->plt_got_offset;
7050 /* Get the index in the procedure linkage table which
7051 corresponds to this symbol. This is the index of this symbol
7052 in all the symbols for which we are making plt entries. The
7053 first three entries in .got.plt are reserved; after that
7054 symbols appear in the same order as in .plt. */
7055 plt_index = (got_offset - 12) / 4;
7057 /* Calculate the address of the GOT entry. */
7058 got_address = (sgot->output_section->vma
7059 + sgot->output_offset
7062 /* ...and the address of the PLT entry. */
7063 plt_address = (splt->output_section->vma
7064 + splt->output_offset
7067 ptr = htab->splt->contents + h->plt.offset;
7068 if (htab->vxworks_p && info->shared)
7073 for (i = 0; i != htab->plt_entry_size / 4; i++, ptr += 4)
7075 val = elf32_arm_vxworks_shared_plt_entry[i];
7077 val |= got_address - sgot->output_section->vma;
7079 val |= plt_index * RELOC_SIZE (htab);
7080 if (i == 2 || i == 5)
7081 bfd_put_32 (output_bfd, val, ptr);
7083 put_arm_insn (htab, output_bfd, val, ptr);
7086 else if (htab->vxworks_p)
7091 for (i = 0; i != htab->plt_entry_size / 4; i++)
7093 val = elf32_arm_vxworks_exec_plt_entry[i];
7097 val |= 0xffffff & -((h->plt.offset + i * 4 + 8) >> 2);
7099 val |= plt_index * RELOC_SIZE (htab);
7100 if (i == 2 || i == 5)
7101 bfd_put_32 (output_bfd, val, ptr);
7103 put_arm_insn (htab, output_bfd, val, ptr);
7106 loc = (htab->srelplt2->contents
7107 + (plt_index * 2 + 1) * RELOC_SIZE (htab));
7109 /* Create the .rela.plt.unloaded R_ARM_ABS32 relocation
7110 referencing the GOT for this PLT entry. */
7111 rel.r_offset = plt_address + 8;
7112 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
7113 rel.r_addend = got_offset;
7114 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
7115 loc += RELOC_SIZE (htab);
7117 /* Create the R_ARM_ABS32 relocation referencing the
7118 beginning of the PLT for this GOT entry. */
7119 rel.r_offset = got_address;
7120 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_ARM_ABS32);
7122 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
7126 /* Calculate the displacement between the PLT slot and the
7127 entry in the GOT. The eight-byte offset accounts for the
7128 value produced by adding to pc in the first instruction
7130 got_displacement = got_address - (plt_address + 8);
7132 BFD_ASSERT ((got_displacement & 0xf0000000) == 0);
7134 if (!htab->use_blx && eh->plt_thumb_refcount > 0)
7136 put_thumb_insn (htab, output_bfd,
7137 elf32_arm_plt_thumb_stub[0], ptr - 4);
7138 put_thumb_insn (htab, output_bfd,
7139 elf32_arm_plt_thumb_stub[1], ptr - 2);
7142 put_arm_insn (htab, output_bfd,
7143 elf32_arm_plt_entry[0]
7144 | ((got_displacement & 0x0ff00000) >> 20),
7146 put_arm_insn (htab, output_bfd,
7147 elf32_arm_plt_entry[1]
7148 | ((got_displacement & 0x000ff000) >> 12),
7150 put_arm_insn (htab, output_bfd,
7151 elf32_arm_plt_entry[2]
7152 | (got_displacement & 0x00000fff),
7154 #ifdef FOUR_WORD_PLT
7155 bfd_put_32 (output_bfd, elf32_arm_plt_entry[3], ptr + 12);
7159 /* Fill in the entry in the global offset table. */
7160 bfd_put_32 (output_bfd,
7161 (splt->output_section->vma
7162 + splt->output_offset),
7163 sgot->contents + got_offset);
7165 /* Fill in the entry in the .rel(a).plt section. */
7167 rel.r_offset = got_address;
7168 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
7171 loc = srel->contents + plt_index * RELOC_SIZE (htab);
7172 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
7174 if (!h->def_regular)
7176 /* Mark the symbol as undefined, rather than as defined in
7177 the .plt section. Leave the value alone. */
7178 sym->st_shndx = SHN_UNDEF;
7179 /* If the symbol is weak, we do need to clear the value.
7180 Otherwise, the PLT entry would provide a definition for
7181 the symbol even if the symbol wasn't defined anywhere,
7182 and so the symbol would never be NULL. */
7183 if (!h->ref_regular_nonweak)
7188 if (h->got.offset != (bfd_vma) -1
7189 && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_GD) == 0
7190 && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_IE) == 0)
7194 Elf_Internal_Rela rel;
7198 /* This symbol has an entry in the global offset table. Set it
7200 sgot = bfd_get_section_by_name (dynobj, ".got");
7201 srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (htab, ".got"));
7202 BFD_ASSERT (sgot != NULL && srel != NULL);
7204 offset = (h->got.offset & ~(bfd_vma) 1);
7206 rel.r_offset = (sgot->output_section->vma
7207 + sgot->output_offset
7210 /* If this is a static link, or it is a -Bsymbolic link and the
7211 symbol is defined locally or was forced to be local because
7212 of a version file, we just want to emit a RELATIVE reloc.
7213 The entry in the global offset table will already have been
7214 initialized in the relocate_section function. */
7216 && SYMBOL_REFERENCES_LOCAL (info, h))
7218 BFD_ASSERT((h->got.offset & 1) != 0);
7219 rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
7222 rel.r_addend = bfd_get_32 (output_bfd, sgot->contents + offset);
7223 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset);
7228 BFD_ASSERT((h->got.offset & 1) == 0);
7229 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset);
7230 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
7233 loc = srel->contents + srel->reloc_count++ * RELOC_SIZE (htab);
7234 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
7240 Elf_Internal_Rela rel;
7243 /* This symbol needs a copy reloc. Set it up. */
7244 BFD_ASSERT (h->dynindx != -1
7245 && (h->root.type == bfd_link_hash_defined
7246 || h->root.type == bfd_link_hash_defweak));
7248 s = bfd_get_section_by_name (h->root.u.def.section->owner,
7249 RELOC_SECTION (htab, ".bss"));
7250 BFD_ASSERT (s != NULL);
7253 rel.r_offset = (h->root.u.def.value
7254 + h->root.u.def.section->output_section->vma
7255 + h->root.u.def.section->output_offset);
7256 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
7257 loc = s->contents + s->reloc_count++ * RELOC_SIZE (htab);
7258 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
7261 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. On VxWorks,
7262 the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: it is relative
7263 to the ".got" section. */
7264 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
7265 || (!htab->vxworks_p && h == htab->root.hgot))
7266 sym->st_shndx = SHN_ABS;
7271 /* Finish up the dynamic sections. */
7274 elf32_arm_finish_dynamic_sections (bfd * output_bfd, struct bfd_link_info * info)
7280 dynobj = elf_hash_table (info)->dynobj;
7282 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
7283 BFD_ASSERT (elf32_arm_hash_table (info)->symbian_p || sgot != NULL);
7284 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
7286 if (elf_hash_table (info)->dynamic_sections_created)
7289 Elf32_External_Dyn *dyncon, *dynconend;
7290 struct elf32_arm_link_hash_table *htab;
7292 htab = elf32_arm_hash_table (info);
7293 splt = bfd_get_section_by_name (dynobj, ".plt");
7294 BFD_ASSERT (splt != NULL && sdyn != NULL);
7296 dyncon = (Elf32_External_Dyn *) sdyn->contents;
7297 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
7299 for (; dyncon < dynconend; dyncon++)
7301 Elf_Internal_Dyn dyn;
7305 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
7316 goto get_vma_if_bpabi;
7319 goto get_vma_if_bpabi;
7322 goto get_vma_if_bpabi;
7324 name = ".gnu.version";
7325 goto get_vma_if_bpabi;
7327 name = ".gnu.version_d";
7328 goto get_vma_if_bpabi;
7330 name = ".gnu.version_r";
7331 goto get_vma_if_bpabi;
7337 name = RELOC_SECTION (htab, ".plt");
7339 s = bfd_get_section_by_name (output_bfd, name);
7340 BFD_ASSERT (s != NULL);
7341 if (!htab->symbian_p)
7342 dyn.d_un.d_ptr = s->vma;
7344 /* In the BPABI, tags in the PT_DYNAMIC section point
7345 at the file offset, not the memory address, for the
7346 convenience of the post linker. */
7347 dyn.d_un.d_ptr = s->filepos;
7348 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7352 if (htab->symbian_p)
7357 s = bfd_get_section_by_name (output_bfd,
7358 RELOC_SECTION (htab, ".plt"));
7359 BFD_ASSERT (s != NULL);
7360 dyn.d_un.d_val = s->size;
7361 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7366 if (!htab->symbian_p)
7368 /* My reading of the SVR4 ABI indicates that the
7369 procedure linkage table relocs (DT_JMPREL) should be
7370 included in the overall relocs (DT_REL). This is
7371 what Solaris does. However, UnixWare can not handle
7372 that case. Therefore, we override the DT_RELSZ entry
7373 here to make it not include the JMPREL relocs. Since
7374 the linker script arranges for .rel(a).plt to follow all
7375 other relocation sections, we don't have to worry
7376 about changing the DT_REL entry. */
7377 s = bfd_get_section_by_name (output_bfd,
7378 RELOC_SECTION (htab, ".plt"));
7380 dyn.d_un.d_val -= s->size;
7381 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7388 /* In the BPABI, the DT_REL tag must point at the file
7389 offset, not the VMA, of the first relocation
7390 section. So, we use code similar to that in
7391 elflink.c, but do not check for SHF_ALLOC on the
7392 relcoation section, since relocations sections are
7393 never allocated under the BPABI. The comments above
7394 about Unixware notwithstanding, we include all of the
7395 relocations here. */
7396 if (htab->symbian_p)
7399 type = ((dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
7400 ? SHT_REL : SHT_RELA);
7402 for (i = 1; i < elf_numsections (output_bfd); i++)
7404 Elf_Internal_Shdr *hdr
7405 = elf_elfsections (output_bfd)[i];
7406 if (hdr->sh_type == type)
7408 if (dyn.d_tag == DT_RELSZ
7409 || dyn.d_tag == DT_RELASZ)
7410 dyn.d_un.d_val += hdr->sh_size;
7411 else if ((ufile_ptr) hdr->sh_offset
7412 <= dyn.d_un.d_val - 1)
7413 dyn.d_un.d_val = hdr->sh_offset;
7416 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7420 /* Set the bottom bit of DT_INIT/FINI if the
7421 corresponding function is Thumb. */
7423 name = info->init_function;
7426 name = info->fini_function;
7428 /* If it wasn't set by elf_bfd_final_link
7429 then there is nothing to adjust. */
7430 if (dyn.d_un.d_val != 0)
7432 struct elf_link_hash_entry * eh;
7434 eh = elf_link_hash_lookup (elf_hash_table (info), name,
7435 FALSE, FALSE, TRUE);
7436 if (eh != (struct elf_link_hash_entry *) NULL
7437 && ELF_ST_TYPE (eh->type) == STT_ARM_TFUNC)
7439 dyn.d_un.d_val |= 1;
7440 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7447 /* Fill in the first entry in the procedure linkage table. */
7448 if (splt->size > 0 && elf32_arm_hash_table (info)->plt_header_size)
7450 const bfd_vma *plt0_entry;
7451 bfd_vma got_address, plt_address, got_displacement;
7453 /* Calculate the addresses of the GOT and PLT. */
7454 got_address = sgot->output_section->vma + sgot->output_offset;
7455 plt_address = splt->output_section->vma + splt->output_offset;
7457 if (htab->vxworks_p)
7459 /* The VxWorks GOT is relocated by the dynamic linker.
7460 Therefore, we must emit relocations rather than simply
7461 computing the values now. */
7462 Elf_Internal_Rela rel;
7464 plt0_entry = elf32_arm_vxworks_exec_plt0_entry;
7465 put_arm_insn (htab, output_bfd, plt0_entry[0],
7466 splt->contents + 0);
7467 put_arm_insn (htab, output_bfd, plt0_entry[1],
7468 splt->contents + 4);
7469 put_arm_insn (htab, output_bfd, plt0_entry[2],
7470 splt->contents + 8);
7471 bfd_put_32 (output_bfd, got_address, splt->contents + 12);
7473 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_. */
7474 rel.r_offset = plt_address + 12;
7475 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
7477 SWAP_RELOC_OUT (htab) (output_bfd, &rel,
7478 htab->srelplt2->contents);
7482 got_displacement = got_address - (plt_address + 16);
7484 plt0_entry = elf32_arm_plt0_entry;
7485 put_arm_insn (htab, output_bfd, plt0_entry[0],
7486 splt->contents + 0);
7487 put_arm_insn (htab, output_bfd, plt0_entry[1],
7488 splt->contents + 4);
7489 put_arm_insn (htab, output_bfd, plt0_entry[2],
7490 splt->contents + 8);
7491 put_arm_insn (htab, output_bfd, plt0_entry[3],
7492 splt->contents + 12);
7494 #ifdef FOUR_WORD_PLT
7495 /* The displacement value goes in the otherwise-unused
7496 last word of the second entry. */
7497 bfd_put_32 (output_bfd, got_displacement, splt->contents + 28);
7499 bfd_put_32 (output_bfd, got_displacement, splt->contents + 16);
7504 /* UnixWare sets the entsize of .plt to 4, although that doesn't
7505 really seem like the right value. */
7506 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
7508 if (htab->vxworks_p && !info->shared && htab->splt->size > 0)
7510 /* Correct the .rel(a).plt.unloaded relocations. They will have
7511 incorrect symbol indexes. */
7515 num_plts = ((htab->splt->size - htab->plt_header_size)
7516 / htab->plt_entry_size);
7517 p = htab->srelplt2->contents + RELOC_SIZE (htab);
7519 for (; num_plts; num_plts--)
7521 Elf_Internal_Rela rel;
7523 SWAP_RELOC_IN (htab) (output_bfd, p, &rel);
7524 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
7525 SWAP_RELOC_OUT (htab) (output_bfd, &rel, p);
7526 p += RELOC_SIZE (htab);
7528 SWAP_RELOC_IN (htab) (output_bfd, p, &rel);
7529 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_ARM_ABS32);
7530 SWAP_RELOC_OUT (htab) (output_bfd, &rel, p);
7531 p += RELOC_SIZE (htab);
7536 /* Fill in the first three entries in the global offset table. */
7542 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
7544 bfd_put_32 (output_bfd,
7545 sdyn->output_section->vma + sdyn->output_offset,
7547 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
7548 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
7551 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
7558 elf32_arm_post_process_headers (bfd * abfd, struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
7560 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
7561 struct elf32_arm_link_hash_table *globals;
7563 i_ehdrp = elf_elfheader (abfd);
7565 if (EF_ARM_EABI_VERSION (i_ehdrp->e_flags) == EF_ARM_EABI_UNKNOWN)
7566 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_ARM;
7568 i_ehdrp->e_ident[EI_OSABI] = 0;
7569 i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
7573 globals = elf32_arm_hash_table (link_info);
7574 if (globals->byteswap_code)
7575 i_ehdrp->e_flags |= EF_ARM_BE8;
7579 static enum elf_reloc_type_class
7580 elf32_arm_reloc_type_class (const Elf_Internal_Rela *rela)
7582 switch ((int) ELF32_R_TYPE (rela->r_info))
7584 case R_ARM_RELATIVE:
7585 return reloc_class_relative;
7586 case R_ARM_JUMP_SLOT:
7587 return reloc_class_plt;
7589 return reloc_class_copy;
7591 return reloc_class_normal;
7595 /* Set the right machine number for an Arm ELF file. */
7598 elf32_arm_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
7600 if (hdr->sh_type == SHT_NOTE)
7601 *flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_CONTENTS;
7607 elf32_arm_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
7609 bfd_arm_update_notes (abfd, ARM_NOTE_SECTION);
7612 /* Return TRUE if this is an unwinding table entry. */
7615 is_arm_elf_unwind_section_name (bfd * abfd ATTRIBUTE_UNUSED, const char * name)
7619 len1 = sizeof (ELF_STRING_ARM_unwind) - 1;
7620 len2 = sizeof (ELF_STRING_ARM_unwind_once) - 1;
7621 return (strncmp (name, ELF_STRING_ARM_unwind, len1) == 0
7622 || strncmp (name, ELF_STRING_ARM_unwind_once, len2) == 0);
7626 /* Set the type and flags for an ARM section. We do this by
7627 the section name, which is a hack, but ought to work. */
7630 elf32_arm_fake_sections (bfd * abfd, Elf_Internal_Shdr * hdr, asection * sec)
7634 name = bfd_get_section_name (abfd, sec);
7636 if (is_arm_elf_unwind_section_name (abfd, name))
7638 hdr->sh_type = SHT_ARM_EXIDX;
7639 hdr->sh_flags |= SHF_LINK_ORDER;
7641 else if (strcmp(name, ".ARM.attributes") == 0)
7643 hdr->sh_type = SHT_ARM_ATTRIBUTES;
7648 /* Parse an Arm EABI attributes section. */
7650 elf32_arm_parse_attributes (bfd *abfd, Elf_Internal_Shdr * hdr)
7656 contents = bfd_malloc (hdr->sh_size);
7659 if (!bfd_get_section_contents (abfd, hdr->bfd_section, contents, 0,
7668 len = hdr->sh_size - 1;
7672 bfd_vma section_len;
7674 section_len = bfd_get_32 (abfd, p);
7676 if (section_len > len)
7679 namelen = strlen ((char *)p) + 1;
7680 section_len -= namelen + 4;
7681 if (strcmp((char *)p, "aeabi") != 0)
7683 /* Vendor section. Ignore it. */
7684 p += namelen + section_len;
7689 while (section_len > 0)
7694 bfd_vma subsection_len;
7697 tag = read_unsigned_leb128 (abfd, p, &n);
7699 subsection_len = bfd_get_32 (abfd, p);
7701 if (subsection_len > section_len)
7702 subsection_len = section_len;
7703 section_len -= subsection_len;
7704 subsection_len -= n + 4;
7705 end = p + subsection_len;
7711 bfd_boolean is_string;
7713 tag = read_unsigned_leb128 (abfd, p, &n);
7715 if (tag == 4 || tag == 5)
7720 is_string = (tag & 1) != 0;
7721 if (tag == Tag_compatibility)
7723 val = read_unsigned_leb128 (abfd, p, &n);
7725 elf32_arm_add_eabi_attr_compat (abfd, val,
7727 p += strlen ((char *)p) + 1;
7731 elf32_arm_add_eabi_attr_string (abfd, tag,
7733 p += strlen ((char *)p) + 1;
7737 val = read_unsigned_leb128 (abfd, p, &n);
7739 elf32_arm_add_eabi_attr_int (abfd, tag, val);
7745 /* Don't have anywhere convenient to attach these.
7746 Fall through for now. */
7748 /* Ignore things we don't kow about. */
7749 p += subsection_len;
7760 /* Handle an ARM specific section when reading an object file. This is
7761 called when bfd_section_from_shdr finds a section with an unknown
7765 elf32_arm_section_from_shdr (bfd *abfd,
7766 Elf_Internal_Shdr * hdr,
7770 /* There ought to be a place to keep ELF backend specific flags, but
7771 at the moment there isn't one. We just keep track of the
7772 sections by their name, instead. Fortunately, the ABI gives
7773 names for all the ARM specific sections, so we will probably get
7775 switch (hdr->sh_type)
7778 case SHT_ARM_PREEMPTMAP:
7779 case SHT_ARM_ATTRIBUTES:
7786 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
7789 if (hdr->sh_type == SHT_ARM_ATTRIBUTES)
7790 elf32_arm_parse_attributes(abfd, hdr);
7794 /* A structure used to record a list of sections, independently
7795 of the next and prev fields in the asection structure. */
7796 typedef struct section_list
7799 struct section_list * next;
7800 struct section_list * prev;
7804 /* Unfortunately we need to keep a list of sections for which
7805 an _arm_elf_section_data structure has been allocated. This
7806 is because it is possible for functions like elf32_arm_write_section
7807 to be called on a section which has had an elf_data_structure
7808 allocated for it (and so the used_by_bfd field is valid) but
7809 for which the ARM extended version of this structure - the
7810 _arm_elf_section_data structure - has not been allocated. */
7811 static section_list * sections_with_arm_elf_section_data = NULL;
7814 record_section_with_arm_elf_section_data (asection * sec)
7816 struct section_list * entry;
7818 entry = bfd_malloc (sizeof (* entry));
7822 entry->next = sections_with_arm_elf_section_data;
7824 if (entry->next != NULL)
7825 entry->next->prev = entry;
7826 sections_with_arm_elf_section_data = entry;
7829 static struct section_list *
7830 find_arm_elf_section_entry (asection * sec)
7832 struct section_list * entry;
7833 static struct section_list * last_entry = NULL;
7835 /* This is a short cut for the typical case where the sections are added
7836 to the sections_with_arm_elf_section_data list in forward order and
7837 then looked up here in backwards order. This makes a real difference
7838 to the ld-srec/sec64k.exp linker test. */
7839 entry = sections_with_arm_elf_section_data;
7840 if (last_entry != NULL)
7842 if (last_entry->sec == sec)
7844 else if (last_entry->next != NULL
7845 && last_entry->next->sec == sec)
7846 entry = last_entry->next;
7849 for (; entry; entry = entry->next)
7850 if (entry->sec == sec)
7854 /* Record the entry prior to this one - it is the entry we are most
7855 likely to want to locate next time. Also this way if we have been
7856 called from unrecord_section_with_arm_elf_section_data() we will not
7857 be caching a pointer that is about to be freed. */
7858 last_entry = entry->prev;
7863 static _arm_elf_section_data *
7864 get_arm_elf_section_data (asection * sec)
7866 struct section_list * entry;
7868 entry = find_arm_elf_section_entry (sec);
7871 return elf32_arm_section_data (entry->sec);
7877 unrecord_section_with_arm_elf_section_data (asection * sec)
7879 struct section_list * entry;
7881 entry = find_arm_elf_section_entry (sec);
7885 if (entry->prev != NULL)
7886 entry->prev->next = entry->next;
7887 if (entry->next != NULL)
7888 entry->next->prev = entry->prev;
7889 if (entry == sections_with_arm_elf_section_data)
7890 sections_with_arm_elf_section_data = entry->next;
7895 /* Called for each symbol. Builds a section map based on mapping symbols.
7896 Does not alter any of the symbols. */
7899 elf32_arm_output_symbol_hook (struct bfd_link_info *info,
7901 Elf_Internal_Sym *elfsym,
7902 asection *input_sec,
7903 struct elf_link_hash_entry *h)
7906 elf32_arm_section_map *map;
7907 elf32_arm_section_map *newmap;
7908 _arm_elf_section_data *arm_data;
7909 struct elf32_arm_link_hash_table *globals;
7911 globals = elf32_arm_hash_table (info);
7912 if (globals->vxworks_p
7913 && !elf_vxworks_link_output_symbol_hook (info, name, elfsym,
7917 /* Only do this on final link. */
7918 if (info->relocatable)
7921 /* Only build a map if we need to byteswap code. */
7922 if (!globals->byteswap_code)
7925 /* We only want mapping symbols. */
7926 if (!bfd_is_arm_special_symbol_name (name, BFD_ARM_SPECIAL_SYM_TYPE_MAP))
7929 /* If this section has not been allocated an _arm_elf_section_data
7930 structure then we cannot record anything. */
7931 arm_data = get_arm_elf_section_data (input_sec);
7932 if (arm_data == NULL)
7935 mapcount = arm_data->mapcount + 1;
7936 map = arm_data->map;
7938 /* TODO: This may be inefficient, but we probably don't usually have many
7939 mapping symbols per section. */
7940 newmap = bfd_realloc (map, mapcount * sizeof (* map));
7943 arm_data->map = newmap;
7944 arm_data->mapcount = mapcount;
7946 newmap[mapcount - 1].vma = elfsym->st_value;
7947 newmap[mapcount - 1].type = name[1];
7956 struct bfd_link_info *info;
7959 bfd_boolean (*func) (void *, const char *, Elf_Internal_Sym *,
7960 asection *, struct elf_link_hash_entry *);
7961 } output_arch_syminfo;
7963 enum map_symbol_type
7971 /* Output a single PLT mapping symbol. */
7974 elf32_arm_ouput_plt_map_sym (output_arch_syminfo *osi,
7975 enum map_symbol_type type,
7978 static const char *names[3] = {"$a", "$t", "$d"};
7979 struct elf32_arm_link_hash_table *htab;
7980 Elf_Internal_Sym sym;
7982 htab = elf32_arm_hash_table (osi->info);
7983 sym.st_value = osi->plt_offset + offset;
7986 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_NOTYPE);
7987 sym.st_shndx = osi->plt_shndx;
7988 if (!osi->func (osi->finfo, names[type], &sym, htab->splt, NULL))
7994 /* Output mapping symbols for PLT entries associated with H. */
7997 elf32_arm_output_plt_map (struct elf_link_hash_entry *h, void *inf)
7999 output_arch_syminfo *osi = (output_arch_syminfo *) inf;
8000 struct elf32_arm_link_hash_table *htab;
8001 struct elf32_arm_link_hash_entry *eh;
8004 htab = elf32_arm_hash_table (osi->info);
8006 if (h->root.type == bfd_link_hash_indirect)
8009 if (h->root.type == bfd_link_hash_warning)
8010 /* When warning symbols are created, they **replace** the "real"
8011 entry in the hash table, thus we never get to see the real
8012 symbol in a hash traversal. So look at it now. */
8013 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8015 if (h->plt.offset == (bfd_vma) -1)
8018 eh = (struct elf32_arm_link_hash_entry *) h;
8019 addr = h->plt.offset;
8020 if (htab->symbian_p)
8022 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_ARM, addr))
8024 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_DATA, addr + 4))
8027 else if (htab->vxworks_p)
8029 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_ARM, addr))
8031 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_DATA, addr + 8))
8033 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_ARM, addr + 12))
8035 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_DATA, addr + 20))
8040 bfd_boolean thumb_stub;
8042 thumb_stub = eh->plt_thumb_refcount > 0 && !htab->use_blx;
8045 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_THUMB, addr - 4))
8048 #ifdef FOUR_WORD_PLT
8049 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_ARM, addr))
8051 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_DATA, addr + 12))
8054 /* A three-word PLT with no Thumb thunk contains only Arm code,
8055 so only need to output a mapping symbol for the first PLT entry and
8056 entries with thumb thunks. */
8057 if (thumb_stub || addr == 20)
8059 if (!elf32_arm_ouput_plt_map_sym (osi, ARM_MAP_ARM, addr))
8069 /* Output mapping symbols for the PLT. */
8072 elf32_arm_output_arch_local_syms (bfd *output_bfd,
8073 struct bfd_link_info *info,
8074 void *finfo, bfd_boolean (*func) (void *, const char *,
8077 struct elf_link_hash_entry *))
8079 output_arch_syminfo osi;
8080 struct elf32_arm_link_hash_table *htab;
8082 htab = elf32_arm_hash_table (info);
8083 if (!htab->splt || htab->splt->size == 0)
8086 check_use_blx(htab);
8090 osi.plt_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
8091 htab->splt->output_section);
8092 osi.plt_offset = htab->splt->output_section->vma;
8094 /* Output mapping symbols for the plt header. SymbianOS does not have a
8096 if (htab->vxworks_p)
8098 /* VxWorks shared libraries have no PLT header. */
8101 if (!elf32_arm_ouput_plt_map_sym (&osi, ARM_MAP_ARM, 0))
8103 if (!elf32_arm_ouput_plt_map_sym (&osi, ARM_MAP_DATA, 12))
8107 else if (!htab->symbian_p)
8109 if (!elf32_arm_ouput_plt_map_sym (&osi, ARM_MAP_ARM, 0))
8111 #ifndef FOUR_WORD_PLT
8112 if (!elf32_arm_ouput_plt_map_sym (&osi, ARM_MAP_DATA, 16))
8117 elf_link_hash_traverse (&htab->root, elf32_arm_output_plt_map, (void *) &osi);
8121 /* Allocate target specific section data. */
8124 elf32_arm_new_section_hook (bfd *abfd, asection *sec)
8126 if (!sec->used_by_bfd)
8128 _arm_elf_section_data *sdata;
8129 bfd_size_type amt = sizeof (*sdata);
8131 sdata = bfd_zalloc (abfd, amt);
8134 sec->used_by_bfd = sdata;
8137 record_section_with_arm_elf_section_data (sec);
8139 return _bfd_elf_new_section_hook (abfd, sec);
8143 /* Used to order a list of mapping symbols by address. */
8146 elf32_arm_compare_mapping (const void * a, const void * b)
8148 return ((const elf32_arm_section_map *) a)->vma
8149 > ((const elf32_arm_section_map *) b)->vma;
8153 /* Do code byteswapping. Return FALSE afterwards so that the section is
8154 written out as normal. */
8157 elf32_arm_write_section (bfd *output_bfd ATTRIBUTE_UNUSED, asection *sec,
8161 _arm_elf_section_data *arm_data;
8162 elf32_arm_section_map *map;
8169 /* If this section has not been allocated an _arm_elf_section_data
8170 structure then we cannot record anything. */
8171 arm_data = get_arm_elf_section_data (sec);
8172 if (arm_data == NULL)
8175 mapcount = arm_data->mapcount;
8176 map = arm_data->map;
8181 qsort (map, mapcount, sizeof (* map), elf32_arm_compare_mapping);
8183 offset = sec->output_section->vma + sec->output_offset;
8184 ptr = map[0].vma - offset;
8185 for (i = 0; i < mapcount; i++)
8187 if (i == mapcount - 1)
8190 end = map[i + 1].vma - offset;
8192 switch (map[i].type)
8195 /* Byte swap code words. */
8196 while (ptr + 3 < end)
8198 tmp = contents[ptr];
8199 contents[ptr] = contents[ptr + 3];
8200 contents[ptr + 3] = tmp;
8201 tmp = contents[ptr + 1];
8202 contents[ptr + 1] = contents[ptr + 2];
8203 contents[ptr + 2] = tmp;
8209 /* Byte swap code halfwords. */
8210 while (ptr + 1 < end)
8212 tmp = contents[ptr];
8213 contents[ptr] = contents[ptr + 1];
8214 contents[ptr + 1] = tmp;
8220 /* Leave data alone. */
8227 arm_data->mapcount = 0;
8228 arm_data->map = NULL;
8229 unrecord_section_with_arm_elf_section_data (sec);
8235 unrecord_section_via_map_over_sections (bfd * abfd ATTRIBUTE_UNUSED,
8237 void * ignore ATTRIBUTE_UNUSED)
8239 unrecord_section_with_arm_elf_section_data (sec);
8243 elf32_arm_close_and_cleanup (bfd * abfd)
8246 bfd_map_over_sections (abfd,
8247 unrecord_section_via_map_over_sections,
8250 return _bfd_elf_close_and_cleanup (abfd);
8254 elf32_arm_bfd_free_cached_info (bfd * abfd)
8257 bfd_map_over_sections (abfd,
8258 unrecord_section_via_map_over_sections,
8261 return _bfd_free_cached_info (abfd);
8264 /* Display STT_ARM_TFUNC symbols as functions. */
8267 elf32_arm_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
8270 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
8272 if (ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_ARM_TFUNC)
8273 elfsym->symbol.flags |= BSF_FUNCTION;
8277 /* Mangle thumb function symbols as we read them in. */
8280 elf32_arm_swap_symbol_in (bfd * abfd,
8283 Elf_Internal_Sym *dst)
8285 bfd_elf32_swap_symbol_in (abfd, psrc, pshn, dst);
8287 /* New EABI objects mark thumb function symbols by setting the low bit of
8288 the address. Turn these into STT_ARM_TFUNC. */
8289 if (ELF_ST_TYPE (dst->st_info) == STT_FUNC
8290 && (dst->st_value & 1))
8292 dst->st_info = ELF_ST_INFO (ELF_ST_BIND (dst->st_info), STT_ARM_TFUNC);
8293 dst->st_value &= ~(bfd_vma) 1;
8298 /* Mangle thumb function symbols as we write them out. */
8301 elf32_arm_swap_symbol_out (bfd *abfd,
8302 const Elf_Internal_Sym *src,
8306 Elf_Internal_Sym newsym;
8308 /* We convert STT_ARM_TFUNC symbols into STT_FUNC with the low bit
8309 of the address set, as per the new EABI. We do this unconditionally
8310 because objcopy does not set the elf header flags until after
8311 it writes out the symbol table. */
8312 if (ELF_ST_TYPE (src->st_info) == STT_ARM_TFUNC)
8315 newsym.st_info = ELF_ST_INFO (ELF_ST_BIND (src->st_info), STT_FUNC);
8316 newsym.st_value |= 1;
8320 bfd_elf32_swap_symbol_out (abfd, src, cdst, shndx);
8323 /* Add the PT_ARM_EXIDX program header. */
8326 elf32_arm_modify_segment_map (bfd *abfd,
8327 struct bfd_link_info *info ATTRIBUTE_UNUSED)
8329 struct elf_segment_map *m;
8332 sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
8333 if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
8335 /* If there is already a PT_ARM_EXIDX header, then we do not
8336 want to add another one. This situation arises when running
8337 "strip"; the input binary already has the header. */
8338 m = elf_tdata (abfd)->segment_map;
8339 while (m && m->p_type != PT_ARM_EXIDX)
8343 m = bfd_zalloc (abfd, sizeof (struct elf_segment_map));
8346 m->p_type = PT_ARM_EXIDX;
8348 m->sections[0] = sec;
8350 m->next = elf_tdata (abfd)->segment_map;
8351 elf_tdata (abfd)->segment_map = m;
8358 /* We may add a PT_ARM_EXIDX program header. */
8361 elf32_arm_additional_program_headers (bfd *abfd)
8365 sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
8366 if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
8372 /* We use this to override swap_symbol_in and swap_symbol_out. */
8373 const struct elf_size_info elf32_arm_size_info = {
8374 sizeof (Elf32_External_Ehdr),
8375 sizeof (Elf32_External_Phdr),
8376 sizeof (Elf32_External_Shdr),
8377 sizeof (Elf32_External_Rel),
8378 sizeof (Elf32_External_Rela),
8379 sizeof (Elf32_External_Sym),
8380 sizeof (Elf32_External_Dyn),
8381 sizeof (Elf_External_Note),
8385 ELFCLASS32, EV_CURRENT,
8386 bfd_elf32_write_out_phdrs,
8387 bfd_elf32_write_shdrs_and_ehdr,
8388 bfd_elf32_write_relocs,
8389 elf32_arm_swap_symbol_in,
8390 elf32_arm_swap_symbol_out,
8391 bfd_elf32_slurp_reloc_table,
8392 bfd_elf32_slurp_symbol_table,
8393 bfd_elf32_swap_dyn_in,
8394 bfd_elf32_swap_dyn_out,
8395 bfd_elf32_swap_reloc_in,
8396 bfd_elf32_swap_reloc_out,
8397 bfd_elf32_swap_reloca_in,
8398 bfd_elf32_swap_reloca_out
8401 #define ELF_ARCH bfd_arch_arm
8402 #define ELF_MACHINE_CODE EM_ARM
8403 #ifdef __QNXTARGET__
8404 #define ELF_MAXPAGESIZE 0x1000
8406 #define ELF_MAXPAGESIZE 0x8000
8408 #define ELF_MINPAGESIZE 0x1000
8409 #define ELF_COMMONPAGESIZE 0x1000
8411 #define bfd_elf32_mkobject elf32_arm_mkobject
8413 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
8414 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
8415 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
8416 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
8417 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
8418 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
8419 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
8420 #define bfd_elf32_find_inliner_info elf32_arm_find_inliner_info
8421 #define bfd_elf32_new_section_hook elf32_arm_new_section_hook
8422 #define bfd_elf32_bfd_is_target_special_symbol elf32_arm_is_target_special_symbol
8423 #define bfd_elf32_close_and_cleanup elf32_arm_close_and_cleanup
8424 #define bfd_elf32_bfd_free_cached_info elf32_arm_bfd_free_cached_info
8425 #define bfd_elf32_bfd_final_link elf32_arm_bfd_final_link
8427 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
8428 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
8429 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
8430 #define elf_backend_check_relocs elf32_arm_check_relocs
8431 #define elf_backend_relocate_section elf32_arm_relocate_section
8432 #define elf_backend_write_section elf32_arm_write_section
8433 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
8434 #define elf_backend_create_dynamic_sections elf32_arm_create_dynamic_sections
8435 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
8436 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
8437 #define elf_backend_link_output_symbol_hook elf32_arm_output_symbol_hook
8438 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
8439 #define elf_backend_post_process_headers elf32_arm_post_process_headers
8440 #define elf_backend_reloc_type_class elf32_arm_reloc_type_class
8441 #define elf_backend_object_p elf32_arm_object_p
8442 #define elf_backend_section_flags elf32_arm_section_flags
8443 #define elf_backend_fake_sections elf32_arm_fake_sections
8444 #define elf_backend_section_from_shdr elf32_arm_section_from_shdr
8445 #define elf_backend_final_write_processing elf32_arm_final_write_processing
8446 #define elf_backend_copy_indirect_symbol elf32_arm_copy_indirect_symbol
8447 #define elf_backend_symbol_processing elf32_arm_symbol_processing
8448 #define elf_backend_size_info elf32_arm_size_info
8449 #define elf_backend_modify_segment_map elf32_arm_modify_segment_map
8450 #define elf_backend_additional_program_headers \
8451 elf32_arm_additional_program_headers
8452 #define elf_backend_output_arch_local_syms \
8453 elf32_arm_output_arch_local_syms
8455 #define elf_backend_can_refcount 1
8456 #define elf_backend_can_gc_sections 1
8457 #define elf_backend_plt_readonly 1
8458 #define elf_backend_want_got_plt 1
8459 #define elf_backend_want_plt_sym 0
8460 #define elf_backend_may_use_rel_p 1
8461 #define elf_backend_may_use_rela_p 0
8462 #define elf_backend_default_use_rela_p 0
8463 #define elf_backend_rela_normal 0
8465 #define elf_backend_got_header_size 12
8467 #include "elf32-target.h"
8469 /* VxWorks Targets */
8471 #undef TARGET_LITTLE_SYM
8472 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_vxworks_vec
8473 #undef TARGET_LITTLE_NAME
8474 #define TARGET_LITTLE_NAME "elf32-littlearm-vxworks"
8475 #undef TARGET_BIG_SYM
8476 #define TARGET_BIG_SYM bfd_elf32_bigarm_vxworks_vec
8477 #undef TARGET_BIG_NAME
8478 #define TARGET_BIG_NAME "elf32-bigarm-vxworks"
8480 /* Like elf32_arm_link_hash_table_create -- but overrides
8481 appropriately for VxWorks. */
8482 static struct bfd_link_hash_table *
8483 elf32_arm_vxworks_link_hash_table_create (bfd *abfd)
8485 struct bfd_link_hash_table *ret;
8487 ret = elf32_arm_link_hash_table_create (abfd);
8490 struct elf32_arm_link_hash_table *htab
8491 = (struct elf32_arm_link_hash_table *) ret;
8493 htab->vxworks_p = 1;
8499 elf32_arm_vxworks_final_write_processing (bfd *abfd, bfd_boolean linker)
8501 elf32_arm_final_write_processing (abfd, linker);
8502 elf_vxworks_final_write_processing (abfd, linker);
8506 #define elf32_bed elf32_arm_vxworks_bed
8508 #undef bfd_elf32_bfd_link_hash_table_create
8509 #define bfd_elf32_bfd_link_hash_table_create \
8510 elf32_arm_vxworks_link_hash_table_create
8511 #undef elf_backend_add_symbol_hook
8512 #define elf_backend_add_symbol_hook \
8513 elf_vxworks_add_symbol_hook
8514 #undef elf_backend_final_write_processing
8515 #define elf_backend_final_write_processing \
8516 elf32_arm_vxworks_final_write_processing
8517 #undef elf_backend_emit_relocs
8518 #define elf_backend_emit_relocs \
8519 elf_vxworks_emit_relocs
8521 #undef elf_backend_may_use_rel_p
8522 #define elf_backend_may_use_rel_p 0
8523 #undef elf_backend_may_use_rela_p
8524 #define elf_backend_may_use_rela_p 1
8525 #undef elf_backend_default_use_rela_p
8526 #define elf_backend_default_use_rela_p 1
8527 #undef elf_backend_rela_normal
8528 #define elf_backend_rela_normal 1
8529 #undef elf_backend_want_plt_sym
8530 #define elf_backend_want_plt_sym 1
8531 #undef ELF_MAXPAGESIZE
8532 #define ELF_MAXPAGESIZE 0x1000
8534 #include "elf32-target.h"
8537 /* Symbian OS Targets */
8539 #undef TARGET_LITTLE_SYM
8540 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_symbian_vec
8541 #undef TARGET_LITTLE_NAME
8542 #define TARGET_LITTLE_NAME "elf32-littlearm-symbian"
8543 #undef TARGET_BIG_SYM
8544 #define TARGET_BIG_SYM bfd_elf32_bigarm_symbian_vec
8545 #undef TARGET_BIG_NAME
8546 #define TARGET_BIG_NAME "elf32-bigarm-symbian"
8548 /* Like elf32_arm_link_hash_table_create -- but overrides
8549 appropriately for Symbian OS. */
8550 static struct bfd_link_hash_table *
8551 elf32_arm_symbian_link_hash_table_create (bfd *abfd)
8553 struct bfd_link_hash_table *ret;
8555 ret = elf32_arm_link_hash_table_create (abfd);
8558 struct elf32_arm_link_hash_table *htab
8559 = (struct elf32_arm_link_hash_table *)ret;
8560 /* There is no PLT header for Symbian OS. */
8561 htab->plt_header_size = 0;
8562 /* The PLT entries are each three instructions. */
8563 htab->plt_entry_size = 4 * NUM_ELEM (elf32_arm_symbian_plt_entry);
8564 htab->symbian_p = 1;
8565 /* Symbian uses armv5t or above, so use_blx is always true. */
8567 htab->root.is_relocatable_executable = 1;
8572 static const struct bfd_elf_special_section
8573 elf32_arm_symbian_special_sections[] =
8575 /* In a BPABI executable, the dynamic linking sections do not go in
8576 the loadable read-only segment. The post-linker may wish to
8577 refer to these sections, but they are not part of the final
8579 { ".dynamic", 8, 0, SHT_DYNAMIC, 0 },
8580 { ".dynstr", 7, 0, SHT_STRTAB, 0 },
8581 { ".dynsym", 7, 0, SHT_DYNSYM, 0 },
8582 { ".got", 4, 0, SHT_PROGBITS, 0 },
8583 { ".hash", 5, 0, SHT_HASH, 0 },
8584 /* These sections do not need to be writable as the SymbianOS
8585 postlinker will arrange things so that no dynamic relocation is
8587 { ".init_array", 11, 0, SHT_INIT_ARRAY, SHF_ALLOC },
8588 { ".fini_array", 11, 0, SHT_FINI_ARRAY, SHF_ALLOC },
8589 { ".preinit_array", 14, 0, SHT_PREINIT_ARRAY, SHF_ALLOC },
8590 { NULL, 0, 0, 0, 0 }
8594 elf32_arm_symbian_begin_write_processing (bfd *abfd,
8595 struct bfd_link_info *link_info
8598 /* BPABI objects are never loaded directly by an OS kernel; they are
8599 processed by a postlinker first, into an OS-specific format. If
8600 the D_PAGED bit is set on the file, BFD will align segments on
8601 page boundaries, so that an OS can directly map the file. With
8602 BPABI objects, that just results in wasted space. In addition,
8603 because we clear the D_PAGED bit, map_sections_to_segments will
8604 recognize that the program headers should not be mapped into any
8605 loadable segment. */
8606 abfd->flags &= ~D_PAGED;
8610 elf32_arm_symbian_modify_segment_map (bfd *abfd,
8611 struct bfd_link_info *info)
8613 struct elf_segment_map *m;
8616 /* BPABI shared libraries and executables should have a PT_DYNAMIC
8617 segment. However, because the .dynamic section is not marked
8618 with SEC_LOAD, the generic ELF code will not create such a
8620 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
8623 m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
8624 m->next = elf_tdata (abfd)->segment_map;
8625 elf_tdata (abfd)->segment_map = m;
8628 /* Also call the generic arm routine. */
8629 return elf32_arm_modify_segment_map (abfd, info);
8633 #define elf32_bed elf32_arm_symbian_bed
8635 /* The dynamic sections are not allocated on SymbianOS; the postlinker
8636 will process them and then discard them. */
8637 #undef ELF_DYNAMIC_SEC_FLAGS
8638 #define ELF_DYNAMIC_SEC_FLAGS \
8639 (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED)
8641 #undef bfd_elf32_bfd_link_hash_table_create
8642 #define bfd_elf32_bfd_link_hash_table_create \
8643 elf32_arm_symbian_link_hash_table_create
8644 #undef elf_backend_add_symbol_hook
8646 #undef elf_backend_special_sections
8647 #define elf_backend_special_sections elf32_arm_symbian_special_sections
8649 #undef elf_backend_begin_write_processing
8650 #define elf_backend_begin_write_processing \
8651 elf32_arm_symbian_begin_write_processing
8652 #undef elf_backend_final_write_processing
8653 #define elf_backend_final_write_processing \
8654 elf32_arm_final_write_processing
8655 #undef elf_backend_emit_relocs
8657 #undef elf_backend_modify_segment_map
8658 #define elf_backend_modify_segment_map elf32_arm_symbian_modify_segment_map
8660 /* There is no .got section for BPABI objects, and hence no header. */
8661 #undef elf_backend_got_header_size
8662 #define elf_backend_got_header_size 0
8664 /* Similarly, there is no .got.plt section. */
8665 #undef elf_backend_want_got_plt
8666 #define elf_backend_want_got_plt 0
8668 #undef elf_backend_may_use_rel_p
8669 #define elf_backend_may_use_rel_p 1
8670 #undef elf_backend_may_use_rela_p
8671 #define elf_backend_may_use_rela_p 0
8672 #undef elf_backend_default_use_rela_p
8673 #define elf_backend_default_use_rela_p 0
8674 #undef elf_backend_rela_normal
8675 #define elf_backend_rela_normal 0
8676 #undef elf_backend_want_plt_sym
8677 #define elf_backend_want_plt_sym 0
8678 #undef ELF_MAXPAGESIZE
8679 #define ELF_MAXPAGESIZE 0x8000
8681 #include "elf32-target.h"
projects / external / binutils.git / blob