1 /* 32-bit ELF support for ARM
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 #define NUM_ELEM(a) (sizeof (a) / (sizeof (a)[0]))
31 #define elf_info_to_howto 0
32 #define elf_info_to_howto_rel elf32_arm_info_to_howto
34 #define ARM_ELF_ABI_VERSION 0
35 #define ARM_ELF_OS_ABI_VERSION ELFOSABI_ARM
37 static reloc_howto_type * elf32_arm_reloc_type_lookup
38 PARAMS ((bfd * abfd, bfd_reloc_code_real_type code));
39 static bfd_boolean elf32_arm_nabi_grok_prstatus
40 PARAMS ((bfd *abfd, Elf_Internal_Note *note));
41 static bfd_boolean elf32_arm_nabi_grok_psinfo
42 PARAMS ((bfd *abfd, Elf_Internal_Note *note));
44 /* Note: code such as elf32_arm_reloc_type_lookup expect to use e.g.
45 R_ARM_PC24 as an index into this, and find the R_ARM_PC24 HOWTO
48 static reloc_howto_type elf32_arm_howto_table[] =
51 HOWTO (R_ARM_NONE, /* type */
53 0, /* size (0 = byte, 1 = short, 2 = long) */
55 FALSE, /* pc_relative */
57 complain_overflow_dont,/* complain_on_overflow */
58 bfd_elf_generic_reloc, /* special_function */
59 "R_ARM_NONE", /* name */
60 FALSE, /* partial_inplace */
63 FALSE), /* pcrel_offset */
65 HOWTO (R_ARM_PC24, /* type */
67 2, /* size (0 = byte, 1 = short, 2 = long) */
69 TRUE, /* pc_relative */
71 complain_overflow_signed,/* complain_on_overflow */
72 bfd_elf_generic_reloc, /* special_function */
73 "R_ARM_PC24", /* name */
74 FALSE, /* partial_inplace */
75 0x00ffffff, /* src_mask */
76 0x00ffffff, /* dst_mask */
77 TRUE), /* pcrel_offset */
80 HOWTO (R_ARM_ABS32, /* type */
82 2, /* size (0 = byte, 1 = short, 2 = long) */
84 FALSE, /* pc_relative */
86 complain_overflow_bitfield,/* complain_on_overflow */
87 bfd_elf_generic_reloc, /* special_function */
88 "R_ARM_ABS32", /* name */
89 FALSE, /* partial_inplace */
90 0xffffffff, /* src_mask */
91 0xffffffff, /* dst_mask */
92 FALSE), /* pcrel_offset */
94 /* standard 32bit pc-relative reloc */
95 HOWTO (R_ARM_REL32, /* type */
97 2, /* size (0 = byte, 1 = short, 2 = long) */
99 TRUE, /* pc_relative */
101 complain_overflow_bitfield,/* complain_on_overflow */
102 bfd_elf_generic_reloc, /* special_function */
103 "R_ARM_REL32", /* name */
104 FALSE, /* partial_inplace */
105 0xffffffff, /* src_mask */
106 0xffffffff, /* dst_mask */
107 TRUE), /* pcrel_offset */
110 HOWTO (R_ARM_PC13, /* type */
112 0, /* size (0 = byte, 1 = short, 2 = long) */
114 FALSE, /* pc_relative */
116 complain_overflow_bitfield,/* complain_on_overflow */
117 bfd_elf_generic_reloc, /* special_function */
118 "R_ARM_PC13", /* name */
119 FALSE, /* partial_inplace */
120 0x000000ff, /* src_mask */
121 0x000000ff, /* dst_mask */
122 FALSE), /* pcrel_offset */
124 /* 16 bit absolute */
125 HOWTO (R_ARM_ABS16, /* type */
127 1, /* size (0 = byte, 1 = short, 2 = long) */
129 FALSE, /* pc_relative */
131 complain_overflow_bitfield,/* complain_on_overflow */
132 bfd_elf_generic_reloc, /* special_function */
133 "R_ARM_ABS16", /* name */
134 FALSE, /* partial_inplace */
135 0x0000ffff, /* src_mask */
136 0x0000ffff, /* dst_mask */
137 FALSE), /* pcrel_offset */
139 /* 12 bit absolute */
140 HOWTO (R_ARM_ABS12, /* type */
142 2, /* size (0 = byte, 1 = short, 2 = long) */
144 FALSE, /* pc_relative */
146 complain_overflow_bitfield,/* complain_on_overflow */
147 bfd_elf_generic_reloc, /* special_function */
148 "R_ARM_ABS12", /* name */
149 FALSE, /* partial_inplace */
150 0x000008ff, /* src_mask */
151 0x000008ff, /* dst_mask */
152 FALSE), /* pcrel_offset */
154 HOWTO (R_ARM_THM_ABS5, /* type */
156 1, /* size (0 = byte, 1 = short, 2 = long) */
158 FALSE, /* pc_relative */
160 complain_overflow_bitfield,/* complain_on_overflow */
161 bfd_elf_generic_reloc, /* special_function */
162 "R_ARM_THM_ABS5", /* name */
163 FALSE, /* partial_inplace */
164 0x000007e0, /* src_mask */
165 0x000007e0, /* dst_mask */
166 FALSE), /* pcrel_offset */
169 HOWTO (R_ARM_ABS8, /* type */
171 0, /* size (0 = byte, 1 = short, 2 = long) */
173 FALSE, /* pc_relative */
175 complain_overflow_bitfield,/* complain_on_overflow */
176 bfd_elf_generic_reloc, /* special_function */
177 "R_ARM_ABS8", /* name */
178 FALSE, /* partial_inplace */
179 0x000000ff, /* src_mask */
180 0x000000ff, /* dst_mask */
181 FALSE), /* pcrel_offset */
183 HOWTO (R_ARM_SBREL32, /* type */
185 2, /* size (0 = byte, 1 = short, 2 = long) */
187 FALSE, /* pc_relative */
189 complain_overflow_dont,/* complain_on_overflow */
190 bfd_elf_generic_reloc, /* special_function */
191 "R_ARM_SBREL32", /* name */
192 FALSE, /* partial_inplace */
193 0xffffffff, /* src_mask */
194 0xffffffff, /* dst_mask */
195 FALSE), /* pcrel_offset */
197 HOWTO (R_ARM_THM_PC22, /* type */
199 2, /* size (0 = byte, 1 = short, 2 = long) */
201 TRUE, /* pc_relative */
203 complain_overflow_signed,/* complain_on_overflow */
204 bfd_elf_generic_reloc, /* special_function */
205 "R_ARM_THM_PC22", /* name */
206 FALSE, /* partial_inplace */
207 0x07ff07ff, /* src_mask */
208 0x07ff07ff, /* dst_mask */
209 TRUE), /* pcrel_offset */
211 HOWTO (R_ARM_THM_PC8, /* type */
213 1, /* size (0 = byte, 1 = short, 2 = long) */
215 TRUE, /* pc_relative */
217 complain_overflow_signed,/* complain_on_overflow */
218 bfd_elf_generic_reloc, /* special_function */
219 "R_ARM_THM_PC8", /* name */
220 FALSE, /* partial_inplace */
221 0x000000ff, /* src_mask */
222 0x000000ff, /* dst_mask */
223 TRUE), /* pcrel_offset */
225 HOWTO (R_ARM_AMP_VCALL9, /* type */
227 1, /* size (0 = byte, 1 = short, 2 = long) */
229 TRUE, /* pc_relative */
231 complain_overflow_signed,/* complain_on_overflow */
232 bfd_elf_generic_reloc, /* special_function */
233 "R_ARM_AMP_VCALL9", /* name */
234 FALSE, /* partial_inplace */
235 0x000000ff, /* src_mask */
236 0x000000ff, /* dst_mask */
237 TRUE), /* pcrel_offset */
239 HOWTO (R_ARM_SWI24, /* type */
241 0, /* size (0 = byte, 1 = short, 2 = long) */
243 FALSE, /* pc_relative */
245 complain_overflow_signed,/* complain_on_overflow */
246 bfd_elf_generic_reloc, /* special_function */
247 "R_ARM_SWI24", /* name */
248 FALSE, /* partial_inplace */
249 0x00000000, /* src_mask */
250 0x00000000, /* dst_mask */
251 FALSE), /* pcrel_offset */
253 HOWTO (R_ARM_THM_SWI8, /* type */
255 0, /* size (0 = byte, 1 = short, 2 = long) */
257 FALSE, /* pc_relative */
259 complain_overflow_signed,/* complain_on_overflow */
260 bfd_elf_generic_reloc, /* special_function */
261 "R_ARM_SWI8", /* name */
262 FALSE, /* partial_inplace */
263 0x00000000, /* src_mask */
264 0x00000000, /* dst_mask */
265 FALSE), /* pcrel_offset */
267 /* BLX instruction for the ARM. */
268 HOWTO (R_ARM_XPC25, /* type */
270 2, /* size (0 = byte, 1 = short, 2 = long) */
272 TRUE, /* pc_relative */
274 complain_overflow_signed,/* complain_on_overflow */
275 bfd_elf_generic_reloc, /* special_function */
276 "R_ARM_XPC25", /* name */
277 FALSE, /* partial_inplace */
278 0x00ffffff, /* src_mask */
279 0x00ffffff, /* dst_mask */
280 TRUE), /* pcrel_offset */
282 /* BLX instruction for the Thumb. */
283 HOWTO (R_ARM_THM_XPC22, /* type */
285 2, /* size (0 = byte, 1 = short, 2 = long) */
287 TRUE, /* pc_relative */
289 complain_overflow_signed,/* complain_on_overflow */
290 bfd_elf_generic_reloc, /* special_function */
291 "R_ARM_THM_XPC22", /* name */
292 FALSE, /* partial_inplace */
293 0x07ff07ff, /* src_mask */
294 0x07ff07ff, /* dst_mask */
295 TRUE), /* pcrel_offset */
297 /* Dynamic TLS relocations. */
299 HOWTO (R_ARM_TLS_DTPMOD32, /* type */
301 2, /* size (0 = byte, 1 = short, 2 = long) */
303 FALSE, /* pc_relative */
305 complain_overflow_bitfield,/* complain_on_overflow */
306 bfd_elf_generic_reloc, /* special_function */
307 "R_ARM_TLS_DTPMOD32", /* name */
308 TRUE, /* partial_inplace */
309 0xffffffff, /* src_mask */
310 0xffffffff, /* dst_mask */
311 FALSE), /* pcrel_offset */
313 HOWTO (R_ARM_TLS_DTPOFF32, /* type */
315 2, /* size (0 = byte, 1 = short, 2 = long) */
317 FALSE, /* pc_relative */
319 complain_overflow_bitfield,/* complain_on_overflow */
320 bfd_elf_generic_reloc, /* special_function */
321 "R_ARM_TLS_DTPOFF32", /* name */
322 TRUE, /* partial_inplace */
323 0xffffffff, /* src_mask */
324 0xffffffff, /* dst_mask */
325 FALSE), /* pcrel_offset */
327 HOWTO (R_ARM_TLS_TPOFF32, /* type */
329 2, /* size (0 = byte, 1 = short, 2 = long) */
331 FALSE, /* pc_relative */
333 complain_overflow_bitfield,/* complain_on_overflow */
334 bfd_elf_generic_reloc, /* special_function */
335 "R_ARM_TLS_TPOFF32", /* name */
336 TRUE, /* partial_inplace */
337 0xffffffff, /* src_mask */
338 0xffffffff, /* dst_mask */
339 FALSE), /* pcrel_offset */
341 /* Relocs used in ARM Linux */
343 HOWTO (R_ARM_COPY, /* type */
345 2, /* size (0 = byte, 1 = short, 2 = long) */
347 FALSE, /* pc_relative */
349 complain_overflow_bitfield,/* complain_on_overflow */
350 bfd_elf_generic_reloc, /* special_function */
351 "R_ARM_COPY", /* name */
352 TRUE, /* partial_inplace */
353 0xffffffff, /* src_mask */
354 0xffffffff, /* dst_mask */
355 FALSE), /* pcrel_offset */
357 HOWTO (R_ARM_GLOB_DAT, /* type */
359 2, /* size (0 = byte, 1 = short, 2 = long) */
361 FALSE, /* pc_relative */
363 complain_overflow_bitfield,/* complain_on_overflow */
364 bfd_elf_generic_reloc, /* special_function */
365 "R_ARM_GLOB_DAT", /* name */
366 TRUE, /* partial_inplace */
367 0xffffffff, /* src_mask */
368 0xffffffff, /* dst_mask */
369 FALSE), /* pcrel_offset */
371 HOWTO (R_ARM_JUMP_SLOT, /* type */
373 2, /* size (0 = byte, 1 = short, 2 = long) */
375 FALSE, /* pc_relative */
377 complain_overflow_bitfield,/* complain_on_overflow */
378 bfd_elf_generic_reloc, /* special_function */
379 "R_ARM_JUMP_SLOT", /* name */
380 TRUE, /* partial_inplace */
381 0xffffffff, /* src_mask */
382 0xffffffff, /* dst_mask */
383 FALSE), /* pcrel_offset */
385 HOWTO (R_ARM_RELATIVE, /* type */
387 2, /* size (0 = byte, 1 = short, 2 = long) */
389 FALSE, /* pc_relative */
391 complain_overflow_bitfield,/* complain_on_overflow */
392 bfd_elf_generic_reloc, /* special_function */
393 "R_ARM_RELATIVE", /* name */
394 TRUE, /* partial_inplace */
395 0xffffffff, /* src_mask */
396 0xffffffff, /* dst_mask */
397 FALSE), /* pcrel_offset */
399 HOWTO (R_ARM_GOTOFF, /* type */
401 2, /* size (0 = byte, 1 = short, 2 = long) */
403 FALSE, /* pc_relative */
405 complain_overflow_bitfield,/* complain_on_overflow */
406 bfd_elf_generic_reloc, /* special_function */
407 "R_ARM_GOTOFF", /* name */
408 TRUE, /* partial_inplace */
409 0xffffffff, /* src_mask */
410 0xffffffff, /* dst_mask */
411 FALSE), /* pcrel_offset */
413 HOWTO (R_ARM_GOTPC, /* type */
415 2, /* size (0 = byte, 1 = short, 2 = long) */
417 TRUE, /* pc_relative */
419 complain_overflow_bitfield,/* complain_on_overflow */
420 bfd_elf_generic_reloc, /* special_function */
421 "R_ARM_GOTPC", /* name */
422 TRUE, /* partial_inplace */
423 0xffffffff, /* src_mask */
424 0xffffffff, /* dst_mask */
425 TRUE), /* pcrel_offset */
427 HOWTO (R_ARM_GOT32, /* type */
429 2, /* size (0 = byte, 1 = short, 2 = long) */
431 FALSE, /* pc_relative */
433 complain_overflow_bitfield,/* complain_on_overflow */
434 bfd_elf_generic_reloc, /* special_function */
435 "R_ARM_GOT32", /* name */
436 TRUE, /* partial_inplace */
437 0xffffffff, /* src_mask */
438 0xffffffff, /* dst_mask */
439 FALSE), /* pcrel_offset */
441 HOWTO (R_ARM_PLT32, /* type */
443 2, /* size (0 = byte, 1 = short, 2 = long) */
445 TRUE, /* pc_relative */
447 complain_overflow_bitfield,/* complain_on_overflow */
448 bfd_elf_generic_reloc, /* special_function */
449 "R_ARM_PLT32", /* name */
450 TRUE, /* partial_inplace */
451 0x00ffffff, /* src_mask */
452 0x00ffffff, /* dst_mask */
453 TRUE), /* pcrel_offset */
455 HOWTO (R_ARM_CALL, /* type */
457 2, /* size (0 = byte, 1 = short, 2 = long) */
459 TRUE, /* pc_relative */
461 complain_overflow_signed,/* complain_on_overflow */
462 bfd_elf_generic_reloc, /* special_function */
463 "R_ARM_CALL", /* name */
464 FALSE, /* partial_inplace */
465 0x00ffffff, /* src_mask */
466 0x00ffffff, /* dst_mask */
467 TRUE), /* pcrel_offset */
469 HOWTO (R_ARM_JUMP24, /* type */
471 2, /* size (0 = byte, 1 = short, 2 = long) */
473 TRUE, /* pc_relative */
475 complain_overflow_signed,/* complain_on_overflow */
476 bfd_elf_generic_reloc, /* special_function */
477 "R_ARM_JUMP24", /* name */
478 FALSE, /* partial_inplace */
479 0x00ffffff, /* src_mask */
480 0x00ffffff, /* dst_mask */
481 TRUE), /* pcrel_offset */
483 HOWTO (R_ARM_NONE, /* type */
485 0, /* size (0 = byte, 1 = short, 2 = long) */
487 FALSE, /* pc_relative */
489 complain_overflow_dont,/* complain_on_overflow */
490 bfd_elf_generic_reloc, /* special_function */
491 "R_ARM_unknown_30", /* name */
492 FALSE, /* partial_inplace */
495 FALSE), /* pcrel_offset */
497 HOWTO (R_ARM_NONE, /* type */
499 0, /* size (0 = byte, 1 = short, 2 = long) */
501 FALSE, /* pc_relative */
503 complain_overflow_dont,/* complain_on_overflow */
504 bfd_elf_generic_reloc, /* special_function */
505 "R_ARM_unknown_31", /* name */
506 FALSE, /* partial_inplace */
509 FALSE), /* pcrel_offset */
511 HOWTO (R_ARM_ALU_PCREL7_0, /* type */
513 2, /* size (0 = byte, 1 = short, 2 = long) */
515 TRUE, /* pc_relative */
517 complain_overflow_dont,/* complain_on_overflow */
518 bfd_elf_generic_reloc, /* special_function */
519 "R_ARM_ALU_PCREL_7_0", /* name */
520 FALSE, /* partial_inplace */
521 0x00000fff, /* src_mask */
522 0x00000fff, /* dst_mask */
523 TRUE), /* pcrel_offset */
525 HOWTO (R_ARM_ALU_PCREL15_8, /* type */
527 2, /* size (0 = byte, 1 = short, 2 = long) */
529 TRUE, /* pc_relative */
531 complain_overflow_dont,/* complain_on_overflow */
532 bfd_elf_generic_reloc, /* special_function */
533 "R_ARM_ALU_PCREL_15_8",/* name */
534 FALSE, /* partial_inplace */
535 0x00000fff, /* src_mask */
536 0x00000fff, /* dst_mask */
537 TRUE), /* pcrel_offset */
539 HOWTO (R_ARM_ALU_PCREL23_15, /* type */
541 2, /* size (0 = byte, 1 = short, 2 = long) */
543 TRUE, /* pc_relative */
545 complain_overflow_dont,/* complain_on_overflow */
546 bfd_elf_generic_reloc, /* special_function */
547 "R_ARM_ALU_PCREL_23_15",/* name */
548 FALSE, /* partial_inplace */
549 0x00000fff, /* src_mask */
550 0x00000fff, /* dst_mask */
551 TRUE), /* pcrel_offset */
553 HOWTO (R_ARM_LDR_SBREL_11_0, /* type */
555 2, /* size (0 = byte, 1 = short, 2 = long) */
557 FALSE, /* pc_relative */
559 complain_overflow_dont,/* complain_on_overflow */
560 bfd_elf_generic_reloc, /* special_function */
561 "R_ARM_LDR_SBREL_11_0",/* name */
562 FALSE, /* partial_inplace */
563 0x00000fff, /* src_mask */
564 0x00000fff, /* dst_mask */
565 FALSE), /* pcrel_offset */
567 HOWTO (R_ARM_ALU_SBREL_19_12, /* type */
569 2, /* size (0 = byte, 1 = short, 2 = long) */
571 FALSE, /* pc_relative */
573 complain_overflow_dont,/* complain_on_overflow */
574 bfd_elf_generic_reloc, /* special_function */
575 "R_ARM_ALU_SBREL_19_12",/* name */
576 FALSE, /* partial_inplace */
577 0x000ff000, /* src_mask */
578 0x000ff000, /* dst_mask */
579 FALSE), /* pcrel_offset */
581 HOWTO (R_ARM_ALU_SBREL_27_20, /* type */
583 2, /* size (0 = byte, 1 = short, 2 = long) */
585 FALSE, /* pc_relative */
587 complain_overflow_dont,/* complain_on_overflow */
588 bfd_elf_generic_reloc, /* special_function */
589 "R_ARM_ALU_SBREL_27_20",/* name */
590 FALSE, /* partial_inplace */
591 0x0ff00000, /* src_mask */
592 0x0ff00000, /* dst_mask */
593 FALSE), /* pcrel_offset */
595 HOWTO (R_ARM_TARGET1, /* type */
597 2, /* size (0 = byte, 1 = short, 2 = long) */
599 FALSE, /* pc_relative */
601 complain_overflow_dont,/* complain_on_overflow */
602 bfd_elf_generic_reloc, /* special_function */
603 "R_ARM_TARGET1", /* name */
604 FALSE, /* partial_inplace */
605 0xffffffff, /* src_mask */
606 0xffffffff, /* dst_mask */
607 FALSE), /* pcrel_offset */
609 HOWTO (R_ARM_ROSEGREL32, /* type */
611 2, /* size (0 = byte, 1 = short, 2 = long) */
613 FALSE, /* pc_relative */
615 complain_overflow_dont,/* complain_on_overflow */
616 bfd_elf_generic_reloc, /* special_function */
617 "R_ARM_ROSEGREL32", /* name */
618 FALSE, /* partial_inplace */
619 0xffffffff, /* src_mask */
620 0xffffffff, /* dst_mask */
621 FALSE), /* pcrel_offset */
623 HOWTO (R_ARM_V4BX, /* type */
625 2, /* size (0 = byte, 1 = short, 2 = long) */
627 FALSE, /* pc_relative */
629 complain_overflow_dont,/* complain_on_overflow */
630 bfd_elf_generic_reloc, /* special_function */
631 "R_ARM_V4BX", /* name */
632 FALSE, /* partial_inplace */
633 0xffffffff, /* src_mask */
634 0xffffffff, /* dst_mask */
635 FALSE), /* pcrel_offset */
637 HOWTO (R_ARM_TARGET2, /* type */
639 2, /* size (0 = byte, 1 = short, 2 = long) */
641 FALSE, /* pc_relative */
643 complain_overflow_signed,/* complain_on_overflow */
644 bfd_elf_generic_reloc, /* special_function */
645 "R_ARM_TARGET2", /* name */
646 FALSE, /* partial_inplace */
647 0xffffffff, /* src_mask */
648 0xffffffff, /* dst_mask */
649 TRUE), /* pcrel_offset */
651 HOWTO (R_ARM_PREL31, /* type */
653 2, /* size (0 = byte, 1 = short, 2 = long) */
655 TRUE, /* pc_relative */
657 complain_overflow_signed,/* complain_on_overflow */
658 bfd_elf_generic_reloc, /* special_function */
659 "R_ARM_PREL31", /* name */
660 FALSE, /* partial_inplace */
661 0x7fffffff, /* src_mask */
662 0x7fffffff, /* dst_mask */
663 TRUE), /* pcrel_offset */
666 static reloc_howto_type elf32_arm_tls_gd32_howto =
667 HOWTO (R_ARM_TLS_GD32, /* type */
669 2, /* size (0 = byte, 1 = short, 2 = long) */
671 FALSE, /* pc_relative */
673 complain_overflow_bitfield,/* complain_on_overflow */
674 NULL, /* special_function */
675 "R_ARM_TLS_GD32", /* name */
676 TRUE, /* partial_inplace */
677 0xffffffff, /* src_mask */
678 0xffffffff, /* dst_mask */
679 FALSE); /* pcrel_offset */
681 static reloc_howto_type elf32_arm_tls_ldo32_howto =
682 HOWTO (R_ARM_TLS_LDO32, /* type */
684 2, /* size (0 = byte, 1 = short, 2 = long) */
686 FALSE, /* pc_relative */
688 complain_overflow_bitfield,/* complain_on_overflow */
689 bfd_elf_generic_reloc, /* special_function */
690 "R_ARM_TLS_LDO32", /* name */
691 TRUE, /* partial_inplace */
692 0xffffffff, /* src_mask */
693 0xffffffff, /* dst_mask */
694 FALSE); /* pcrel_offset */
696 static reloc_howto_type elf32_arm_tls_ldm32_howto =
697 HOWTO (R_ARM_TLS_LDM32, /* type */
699 2, /* size (0 = byte, 1 = short, 2 = long) */
701 FALSE, /* pc_relative */
703 complain_overflow_bitfield,/* complain_on_overflow */
704 bfd_elf_generic_reloc, /* special_function */
705 "R_ARM_TLS_LDM32", /* name */
706 TRUE, /* partial_inplace */
707 0xffffffff, /* src_mask */
708 0xffffffff, /* dst_mask */
709 FALSE); /* pcrel_offset */
711 static reloc_howto_type elf32_arm_tls_le32_howto =
712 HOWTO (R_ARM_TLS_LE32, /* type */
714 2, /* size (0 = byte, 1 = short, 2 = long) */
716 FALSE, /* pc_relative */
718 complain_overflow_bitfield,/* complain_on_overflow */
719 bfd_elf_generic_reloc, /* special_function */
720 "R_ARM_TLS_LE32", /* name */
721 TRUE, /* partial_inplace */
722 0xffffffff, /* src_mask */
723 0xffffffff, /* dst_mask */
724 FALSE); /* pcrel_offset */
726 static reloc_howto_type elf32_arm_tls_ie32_howto =
727 HOWTO (R_ARM_TLS_IE32, /* type */
729 2, /* size (0 = byte, 1 = short, 2 = long) */
731 FALSE, /* pc_relative */
733 complain_overflow_bitfield,/* complain_on_overflow */
734 NULL, /* special_function */
735 "R_ARM_TLS_IE32", /* name */
736 TRUE, /* partial_inplace */
737 0xffffffff, /* src_mask */
738 0xffffffff, /* dst_mask */
739 FALSE); /* pcrel_offset */
741 /* GNU extension to record C++ vtable hierarchy */
742 static reloc_howto_type elf32_arm_vtinherit_howto =
743 HOWTO (R_ARM_GNU_VTINHERIT, /* type */
745 2, /* size (0 = byte, 1 = short, 2 = long) */
747 FALSE, /* pc_relative */
749 complain_overflow_dont, /* complain_on_overflow */
750 NULL, /* special_function */
751 "R_ARM_GNU_VTINHERIT", /* name */
752 FALSE, /* partial_inplace */
755 FALSE); /* pcrel_offset */
757 /* GNU extension to record C++ vtable member usage */
758 static reloc_howto_type elf32_arm_vtentry_howto =
759 HOWTO (R_ARM_GNU_VTENTRY, /* type */
761 2, /* size (0 = byte, 1 = short, 2 = long) */
763 FALSE, /* pc_relative */
765 complain_overflow_dont, /* complain_on_overflow */
766 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
767 "R_ARM_GNU_VTENTRY", /* name */
768 FALSE, /* partial_inplace */
771 FALSE); /* pcrel_offset */
773 /* 12 bit pc relative */
774 static reloc_howto_type elf32_arm_thm_pc11_howto =
775 HOWTO (R_ARM_THM_PC11, /* type */
777 1, /* size (0 = byte, 1 = short, 2 = long) */
779 TRUE, /* pc_relative */
781 complain_overflow_signed, /* complain_on_overflow */
782 bfd_elf_generic_reloc, /* special_function */
783 "R_ARM_THM_PC11", /* name */
784 FALSE, /* partial_inplace */
785 0x000007ff, /* src_mask */
786 0x000007ff, /* dst_mask */
787 TRUE); /* pcrel_offset */
789 /* 12 bit pc relative */
790 static reloc_howto_type elf32_arm_thm_pc9_howto =
791 HOWTO (R_ARM_THM_PC9, /* type */
793 1, /* size (0 = byte, 1 = short, 2 = long) */
795 TRUE, /* pc_relative */
797 complain_overflow_signed, /* complain_on_overflow */
798 bfd_elf_generic_reloc, /* special_function */
799 "R_ARM_THM_PC9", /* name */
800 FALSE, /* partial_inplace */
801 0x000000ff, /* src_mask */
802 0x000000ff, /* dst_mask */
803 TRUE); /* pcrel_offset */
805 /* Place relative GOT-indirect. */
806 static reloc_howto_type elf32_arm_got_prel =
807 HOWTO (R_ARM_GOT_PREL, /* type */
809 2, /* size (0 = byte, 1 = short, 2 = long) */
811 TRUE, /* pc_relative */
813 complain_overflow_dont, /* complain_on_overflow */
814 bfd_elf_generic_reloc, /* special_function */
815 "R_ARM_GOT_PREL", /* name */
816 FALSE, /* partial_inplace */
817 0xffffffff, /* src_mask */
818 0xffffffff, /* dst_mask */
819 TRUE); /* pcrel_offset */
821 /* Currently unused relocations. */
822 static reloc_howto_type elf32_arm_r_howto[4] =
824 HOWTO (R_ARM_RREL32, /* type */
826 0, /* size (0 = byte, 1 = short, 2 = long) */
828 FALSE, /* pc_relative */
830 complain_overflow_dont,/* complain_on_overflow */
831 bfd_elf_generic_reloc, /* special_function */
832 "R_ARM_RREL32", /* name */
833 FALSE, /* partial_inplace */
836 FALSE), /* pcrel_offset */
838 HOWTO (R_ARM_RABS32, /* type */
840 0, /* size (0 = byte, 1 = short, 2 = long) */
842 FALSE, /* pc_relative */
844 complain_overflow_dont,/* complain_on_overflow */
845 bfd_elf_generic_reloc, /* special_function */
846 "R_ARM_RABS32", /* name */
847 FALSE, /* partial_inplace */
850 FALSE), /* pcrel_offset */
852 HOWTO (R_ARM_RPC24, /* type */
854 0, /* size (0 = byte, 1 = short, 2 = long) */
856 FALSE, /* pc_relative */
858 complain_overflow_dont,/* complain_on_overflow */
859 bfd_elf_generic_reloc, /* special_function */
860 "R_ARM_RPC24", /* name */
861 FALSE, /* partial_inplace */
864 FALSE), /* pcrel_offset */
866 HOWTO (R_ARM_RBASE, /* type */
868 0, /* size (0 = byte, 1 = short, 2 = long) */
870 FALSE, /* pc_relative */
872 complain_overflow_dont,/* complain_on_overflow */
873 bfd_elf_generic_reloc, /* special_function */
874 "R_ARM_RBASE", /* name */
875 FALSE, /* partial_inplace */
878 FALSE) /* pcrel_offset */
881 static reloc_howto_type *
882 elf32_arm_howto_from_type (unsigned int r_type)
884 if (r_type < NUM_ELEM (elf32_arm_howto_table))
885 return &elf32_arm_howto_table[r_type];
890 return &elf32_arm_got_prel;
892 case R_ARM_GNU_VTINHERIT:
893 return &elf32_arm_vtinherit_howto;
895 case R_ARM_GNU_VTENTRY:
896 return &elf32_arm_vtentry_howto;
899 return &elf32_arm_thm_pc11_howto;
902 return &elf32_arm_thm_pc9_howto;
905 return &elf32_arm_tls_gd32_howto;
908 case R_ARM_TLS_LDO32:
909 return &elf32_arm_tls_ldo32_howto;
912 case R_ARM_TLS_LDM32:
913 return &elf32_arm_tls_ldm32_howto;
917 return &elf32_arm_tls_ie32_howto;
921 return &elf32_arm_tls_le32_howto;
928 return &elf32_arm_r_howto[r_type - R_ARM_RREL32];
936 elf32_arm_info_to_howto (bfd * abfd ATTRIBUTE_UNUSED, arelent * bfd_reloc,
937 Elf_Internal_Rela * elf_reloc)
941 r_type = ELF32_R_TYPE (elf_reloc->r_info);
942 bfd_reloc->howto = elf32_arm_howto_from_type (r_type);
945 struct elf32_arm_reloc_map
947 bfd_reloc_code_real_type bfd_reloc_val;
948 unsigned char elf_reloc_val;
951 /* All entries in this list must also be present in elf32_arm_howto_table. */
952 static const struct elf32_arm_reloc_map elf32_arm_reloc_map[] =
954 {BFD_RELOC_NONE, R_ARM_NONE},
955 {BFD_RELOC_ARM_PCREL_BRANCH, R_ARM_PC24},
956 {BFD_RELOC_ARM_PCREL_BLX, R_ARM_XPC25},
957 {BFD_RELOC_THUMB_PCREL_BLX, R_ARM_THM_XPC22},
958 {BFD_RELOC_32, R_ARM_ABS32},
959 {BFD_RELOC_32_PCREL, R_ARM_REL32},
960 {BFD_RELOC_8, R_ARM_ABS8},
961 {BFD_RELOC_16, R_ARM_ABS16},
962 {BFD_RELOC_ARM_OFFSET_IMM, R_ARM_ABS12},
963 {BFD_RELOC_ARM_THUMB_OFFSET, R_ARM_THM_ABS5},
964 {BFD_RELOC_THUMB_PCREL_BRANCH23, R_ARM_THM_PC22},
965 {BFD_RELOC_ARM_COPY, R_ARM_COPY},
966 {BFD_RELOC_ARM_GLOB_DAT, R_ARM_GLOB_DAT},
967 {BFD_RELOC_ARM_JUMP_SLOT, R_ARM_JUMP_SLOT},
968 {BFD_RELOC_ARM_RELATIVE, R_ARM_RELATIVE},
969 {BFD_RELOC_ARM_GOTOFF, R_ARM_GOTOFF},
970 {BFD_RELOC_ARM_GOTPC, R_ARM_GOTPC},
971 {BFD_RELOC_ARM_GOT32, R_ARM_GOT32},
972 {BFD_RELOC_ARM_PLT32, R_ARM_PLT32},
973 {BFD_RELOC_ARM_TARGET1, R_ARM_TARGET1},
974 {BFD_RELOC_ARM_ROSEGREL32, R_ARM_ROSEGREL32},
975 {BFD_RELOC_ARM_SBREL32, R_ARM_SBREL32},
976 {BFD_RELOC_ARM_PREL31, R_ARM_PREL31},
977 {BFD_RELOC_ARM_TARGET2, R_ARM_TARGET2},
978 {BFD_RELOC_ARM_PLT32, R_ARM_PLT32},
979 {BFD_RELOC_ARM_TLS_GD32, R_ARM_TLS_GD32},
980 {BFD_RELOC_ARM_TLS_LDO32, R_ARM_TLS_LDO32},
981 {BFD_RELOC_ARM_TLS_LDM32, R_ARM_TLS_LDM32},
982 {BFD_RELOC_ARM_TLS_DTPMOD32, R_ARM_TLS_DTPMOD32},
983 {BFD_RELOC_ARM_TLS_DTPOFF32, R_ARM_TLS_DTPOFF32},
984 {BFD_RELOC_ARM_TLS_TPOFF32, R_ARM_TLS_TPOFF32},
985 {BFD_RELOC_ARM_TLS_IE32, R_ARM_TLS_IE32},
986 {BFD_RELOC_ARM_TLS_LE32, R_ARM_TLS_LE32},
989 static reloc_howto_type *
990 elf32_arm_reloc_type_lookup (abfd, code)
991 bfd *abfd ATTRIBUTE_UNUSED;
992 bfd_reloc_code_real_type code;
998 case BFD_RELOC_VTABLE_INHERIT:
999 return & elf32_arm_vtinherit_howto;
1001 case BFD_RELOC_VTABLE_ENTRY:
1002 return & elf32_arm_vtentry_howto;
1004 case BFD_RELOC_THUMB_PCREL_BRANCH12:
1005 return & elf32_arm_thm_pc11_howto;
1007 case BFD_RELOC_THUMB_PCREL_BRANCH9:
1008 return & elf32_arm_thm_pc9_howto;
1010 case BFD_RELOC_ARM_TLS_GD32:
1011 return & elf32_arm_tls_gd32_howto;
1013 case BFD_RELOC_ARM_TLS_LDO32:
1014 return & elf32_arm_tls_ldo32_howto;
1016 case BFD_RELOC_ARM_TLS_LDM32:
1017 return & elf32_arm_tls_ldm32_howto;
1019 case BFD_RELOC_ARM_TLS_IE32:
1020 return & elf32_arm_tls_ie32_howto;
1022 case BFD_RELOC_ARM_TLS_LE32:
1023 return & elf32_arm_tls_le32_howto;
1026 for (i = 0; i < NUM_ELEM (elf32_arm_reloc_map); i ++)
1027 if (elf32_arm_reloc_map[i].bfd_reloc_val == code)
1028 return & elf32_arm_howto_table[elf32_arm_reloc_map[i].elf_reloc_val];
1034 /* Support for core dump NOTE sections */
1036 elf32_arm_nabi_grok_prstatus (abfd, note)
1038 Elf_Internal_Note *note;
1043 switch (note->descsz)
1048 case 148: /* Linux/ARM 32-bit*/
1050 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
1053 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
1062 /* Make a ".reg/999" section. */
1063 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
1064 size, note->descpos + offset);
1068 elf32_arm_nabi_grok_psinfo (abfd, note)
1070 Elf_Internal_Note *note;
1072 switch (note->descsz)
1077 case 124: /* Linux/ARM elf_prpsinfo */
1078 elf_tdata (abfd)->core_program
1079 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
1080 elf_tdata (abfd)->core_command
1081 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
1084 /* Note that for some reason, a spurious space is tacked
1085 onto the end of the args in some (at least one anyway)
1086 implementations, so strip it off if it exists. */
1089 char *command = elf_tdata (abfd)->core_command;
1090 int n = strlen (command);
1092 if (0 < n && command[n - 1] == ' ')
1093 command[n - 1] = '\0';
1099 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_vec
1100 #define TARGET_LITTLE_NAME "elf32-littlearm"
1101 #define TARGET_BIG_SYM bfd_elf32_bigarm_vec
1102 #define TARGET_BIG_NAME "elf32-bigarm"
1104 #define elf_backend_grok_prstatus elf32_arm_nabi_grok_prstatus
1105 #define elf_backend_grok_psinfo elf32_arm_nabi_grok_psinfo
1107 typedef unsigned long int insn32;
1108 typedef unsigned short int insn16;
1110 /* In lieu of proper flags, assume all EABIv4 objects are interworkable. */
1111 #define INTERWORK_FLAG(abfd) \
1112 (EF_ARM_EABI_VERSION (elf_elfheader (abfd)->e_flags) == EF_ARM_EABI_VER4 \
1113 || (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK))
1115 /* The linker script knows the section names for placement.
1116 The entry_names are used to do simple name mangling on the stubs.
1117 Given a function name, and its type, the stub can be found. The
1118 name can be changed. The only requirement is the %s be present. */
1119 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
1120 #define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
1122 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
1123 #define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
1125 /* The name of the dynamic interpreter. This is put in the .interp
1127 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
1129 #ifdef FOUR_WORD_PLT
1131 /* The first entry in a procedure linkage table looks like
1132 this. It is set up so that any shared library function that is
1133 called before the relocation has been set up calls the dynamic
1135 static const bfd_vma elf32_arm_plt0_entry [] =
1137 0xe52de004, /* str lr, [sp, #-4]! */
1138 0xe59fe010, /* ldr lr, [pc, #16] */
1139 0xe08fe00e, /* add lr, pc, lr */
1140 0xe5bef008, /* ldr pc, [lr, #8]! */
1143 /* Subsequent entries in a procedure linkage table look like
1145 static const bfd_vma elf32_arm_plt_entry [] =
1147 0xe28fc600, /* add ip, pc, #NN */
1148 0xe28cca00, /* add ip, ip, #NN */
1149 0xe5bcf000, /* ldr pc, [ip, #NN]! */
1150 0x00000000, /* unused */
1155 /* The first entry in a procedure linkage table looks like
1156 this. It is set up so that any shared library function that is
1157 called before the relocation has been set up calls the dynamic
1159 static const bfd_vma elf32_arm_plt0_entry [] =
1161 0xe52de004, /* str lr, [sp, #-4]! */
1162 0xe59fe004, /* ldr lr, [pc, #4] */
1163 0xe08fe00e, /* add lr, pc, lr */
1164 0xe5bef008, /* ldr pc, [lr, #8]! */
1165 0x00000000, /* &GOT[0] - . */
1168 /* Subsequent entries in a procedure linkage table look like
1170 static const bfd_vma elf32_arm_plt_entry [] =
1172 0xe28fc600, /* add ip, pc, #0xNN00000 */
1173 0xe28cca00, /* add ip, ip, #0xNN000 */
1174 0xe5bcf000, /* ldr pc, [ip, #0xNNN]! */
1179 /* An initial stub used if the PLT entry is referenced from Thumb code. */
1180 #define PLT_THUMB_STUB_SIZE 4
1181 static const bfd_vma elf32_arm_plt_thumb_stub [] =
1187 /* The entries in a PLT when using a DLL-based target with multiple
1189 static const bfd_vma elf32_arm_symbian_plt_entry [] =
1191 0xe51ff004, /* ldr pc, [pc, #-4] */
1192 0x00000000, /* dcd R_ARM_GLOB_DAT(X) */
1195 /* Used to build a map of a section. This is required for mixed-endian
1198 typedef struct elf32_elf_section_map
1203 elf32_arm_section_map;
1205 struct _arm_elf_section_data
1207 struct bfd_elf_section_data elf;
1209 elf32_arm_section_map *map;
1212 #define elf32_arm_section_data(sec) \
1213 ((struct _arm_elf_section_data *) elf_section_data (sec))
1215 /* The size of the thread control block. */
1218 struct elf32_arm_obj_tdata
1220 struct elf_obj_tdata root;
1222 /* tls_type for each local got entry. */
1223 char *local_got_tls_type;
1226 #define elf32_arm_tdata(abfd) \
1227 ((struct elf32_arm_obj_tdata *) (abfd)->tdata.any)
1229 #define elf32_arm_local_got_tls_type(abfd) \
1230 (elf32_arm_tdata (abfd)->local_got_tls_type)
1233 elf32_arm_mkobject (bfd *abfd)
1235 bfd_size_type amt = sizeof (struct elf32_arm_obj_tdata);
1236 abfd->tdata.any = bfd_zalloc (abfd, amt);
1237 if (abfd->tdata.any == NULL)
1242 /* The ARM linker needs to keep track of the number of relocs that it
1243 decides to copy in check_relocs for each symbol. This is so that
1244 it can discard PC relative relocs if it doesn't need them when
1245 linking with -Bsymbolic. We store the information in a field
1246 extending the regular ELF linker hash table. */
1248 /* This structure keeps track of the number of relocs we have copied
1249 for a given symbol. */
1250 struct elf32_arm_relocs_copied
1253 struct elf32_arm_relocs_copied * next;
1254 /* A section in dynobj. */
1256 /* Number of relocs copied in this section. */
1257 bfd_size_type count;
1258 /* Number of PC-relative relocs copied in this section. */
1259 bfd_size_type pc_count;
1262 #define elf32_arm_hash_entry(ent) ((struct elf32_arm_link_hash_entry *)(ent))
1264 /* Arm ELF linker hash entry. */
1265 struct elf32_arm_link_hash_entry
1267 struct elf_link_hash_entry root;
1269 /* Number of PC relative relocs copied for this symbol. */
1270 struct elf32_arm_relocs_copied * relocs_copied;
1272 /* We reference count Thumb references to a PLT entry separately,
1273 so that we can emit the Thumb trampoline only if needed. */
1274 bfd_signed_vma plt_thumb_refcount;
1276 /* Since PLT entries have variable size if the Thumb prologue is
1277 used, we need to record the index into .got.plt instead of
1278 recomputing it from the PLT offset. */
1279 bfd_signed_vma plt_got_offset;
1281 #define GOT_UNKNOWN 0
1282 #define GOT_NORMAL 1
1283 #define GOT_TLS_GD 2
1284 #define GOT_TLS_IE 4
1285 unsigned char tls_type;
1288 /* Traverse an arm ELF linker hash table. */
1289 #define elf32_arm_link_hash_traverse(table, func, info) \
1290 (elf_link_hash_traverse \
1292 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
1295 /* Get the ARM elf linker hash table from a link_info structure. */
1296 #define elf32_arm_hash_table(info) \
1297 ((struct elf32_arm_link_hash_table *) ((info)->hash))
1299 /* ARM ELF linker hash table. */
1300 struct elf32_arm_link_hash_table
1302 /* The main hash table. */
1303 struct elf_link_hash_table root;
1305 /* The size in bytes of the section containing the Thumb-to-ARM glue. */
1306 bfd_size_type thumb_glue_size;
1308 /* The size in bytes of the section containing the ARM-to-Thumb glue. */
1309 bfd_size_type arm_glue_size;
1311 /* An arbitrary input BFD chosen to hold the glue sections. */
1312 bfd * bfd_of_glue_owner;
1314 /* Nonzero to output a BE8 image. */
1317 /* Zero if R_ARM_TARGET1 means R_ARM_ABS32.
1318 Nonzero if R_ARM_TARGET1 means R_ARM_ABS32. */
1321 /* The relocation to use for R_ARM_TARGET2 relocations. */
1324 /* Nonzero to fix BX instructions for ARMv4 targets. */
1327 /* The number of bytes in the initial entry in the PLT. */
1328 bfd_size_type plt_header_size;
1330 /* The number of bytes in the subsequent PLT etries. */
1331 bfd_size_type plt_entry_size;
1333 /* True if the target system is Symbian OS. */
1336 /* True if the target uses REL relocations. */
1339 /* Short-cuts to get to dynamic linker sections. */
1348 /* Data for R_ARM_TLS_LDM32 relocations. */
1350 bfd_signed_vma refcount;
1354 /* Small local sym to section mapping cache. */
1355 struct sym_sec_cache sym_sec;
1357 /* For convenience in allocate_dynrelocs. */
1361 /* Create an entry in an ARM ELF linker hash table. */
1363 static struct bfd_hash_entry *
1364 elf32_arm_link_hash_newfunc (struct bfd_hash_entry * entry,
1365 struct bfd_hash_table * table,
1366 const char * string)
1368 struct elf32_arm_link_hash_entry * ret =
1369 (struct elf32_arm_link_hash_entry *) entry;
1371 /* Allocate the structure if it has not already been allocated by a
1373 if (ret == (struct elf32_arm_link_hash_entry *) NULL)
1374 ret = bfd_hash_allocate (table, sizeof (struct elf32_arm_link_hash_entry));
1376 return (struct bfd_hash_entry *) ret;
1378 /* Call the allocation method of the superclass. */
1379 ret = ((struct elf32_arm_link_hash_entry *)
1380 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1384 ret->relocs_copied = NULL;
1385 ret->tls_type = GOT_UNKNOWN;
1386 ret->plt_thumb_refcount = 0;
1387 ret->plt_got_offset = -1;
1390 return (struct bfd_hash_entry *) ret;
1393 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
1394 shortcuts to them in our hash table. */
1397 create_got_section (bfd *dynobj, struct bfd_link_info *info)
1399 struct elf32_arm_link_hash_table *htab;
1401 htab = elf32_arm_hash_table (info);
1402 /* BPABI objects never have a GOT, or associated sections. */
1403 if (htab->symbian_p)
1406 if (! _bfd_elf_create_got_section (dynobj, info))
1409 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
1410 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1411 if (!htab->sgot || !htab->sgotplt)
1414 htab->srelgot = bfd_make_section (dynobj, ".rel.got");
1415 if (htab->srelgot == NULL
1416 || ! bfd_set_section_flags (dynobj, htab->srelgot,
1417 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
1418 | SEC_IN_MEMORY | SEC_LINKER_CREATED
1420 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
1425 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
1426 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
1430 elf32_arm_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
1432 struct elf32_arm_link_hash_table *htab;
1434 htab = elf32_arm_hash_table (info);
1435 if (!htab->sgot && !create_got_section (dynobj, info))
1438 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1441 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
1442 htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt");
1443 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
1445 htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss");
1450 || (!info->shared && !htab->srelbss))
1456 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1459 elf32_arm_copy_indirect_symbol (const struct elf_backend_data *bed,
1460 struct elf_link_hash_entry *dir,
1461 struct elf_link_hash_entry *ind)
1463 struct elf32_arm_link_hash_entry *edir, *eind;
1465 edir = (struct elf32_arm_link_hash_entry *) dir;
1466 eind = (struct elf32_arm_link_hash_entry *) ind;
1468 if (eind->relocs_copied != NULL)
1470 if (edir->relocs_copied != NULL)
1472 struct elf32_arm_relocs_copied **pp;
1473 struct elf32_arm_relocs_copied *p;
1475 if (ind->root.type == bfd_link_hash_indirect)
1478 /* Add reloc counts against the weak sym to the strong sym
1479 list. Merge any entries against the same section. */
1480 for (pp = &eind->relocs_copied; (p = *pp) != NULL; )
1482 struct elf32_arm_relocs_copied *q;
1484 for (q = edir->relocs_copied; q != NULL; q = q->next)
1485 if (q->section == p->section)
1487 q->pc_count += p->pc_count;
1488 q->count += p->count;
1495 *pp = edir->relocs_copied;
1498 edir->relocs_copied = eind->relocs_copied;
1499 eind->relocs_copied = NULL;
1502 /* If the direct symbol already has an associated PLT entry, the
1503 indirect symbol should not. If it doesn't, swap refcount information
1504 from the indirect symbol. */
1505 if (edir->plt_thumb_refcount == 0)
1507 edir->plt_thumb_refcount = eind->plt_thumb_refcount;
1508 eind->plt_thumb_refcount = 0;
1511 BFD_ASSERT (eind->plt_thumb_refcount == 0);
1513 if (ind->root.type == bfd_link_hash_indirect
1514 && dir->got.refcount <= 0)
1516 edir->tls_type = eind->tls_type;
1517 eind->tls_type = GOT_UNKNOWN;
1520 _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
1523 /* Create an ARM elf linker hash table. */
1525 static struct bfd_link_hash_table *
1526 elf32_arm_link_hash_table_create (bfd *abfd)
1528 struct elf32_arm_link_hash_table *ret;
1529 bfd_size_type amt = sizeof (struct elf32_arm_link_hash_table);
1531 ret = bfd_malloc (amt);
1535 if (!_bfd_elf_link_hash_table_init (& ret->root, abfd,
1536 elf32_arm_link_hash_newfunc))
1543 ret->sgotplt = NULL;
1544 ret->srelgot = NULL;
1546 ret->srelplt = NULL;
1547 ret->sdynbss = NULL;
1548 ret->srelbss = NULL;
1549 ret->thumb_glue_size = 0;
1550 ret->arm_glue_size = 0;
1551 ret->bfd_of_glue_owner = NULL;
1552 ret->byteswap_code = 0;
1553 ret->target1_is_rel = 0;
1554 ret->target2_reloc = R_ARM_NONE;
1555 #ifdef FOUR_WORD_PLT
1556 ret->plt_header_size = 16;
1557 ret->plt_entry_size = 16;
1559 ret->plt_header_size = 20;
1560 ret->plt_entry_size = 12;
1564 ret->sym_sec.abfd = NULL;
1566 ret->tls_ldm_got.refcount = 0;
1568 return &ret->root.root;
1571 /* Locate the Thumb encoded calling stub for NAME. */
1573 static struct elf_link_hash_entry *
1574 find_thumb_glue (struct bfd_link_info *link_info,
1579 struct elf_link_hash_entry *hash;
1580 struct elf32_arm_link_hash_table *hash_table;
1582 /* We need a pointer to the armelf specific hash table. */
1583 hash_table = elf32_arm_hash_table (link_info);
1585 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
1586 + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
1588 BFD_ASSERT (tmp_name);
1590 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
1592 hash = elf_link_hash_lookup
1593 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
1596 /* xgettext:c-format */
1597 (*_bfd_error_handler) (_("%B: unable to find THUMB glue '%s' for `%s'"),
1598 input_bfd, tmp_name, name);
1605 /* Locate the ARM encoded calling stub for NAME. */
1607 static struct elf_link_hash_entry *
1608 find_arm_glue (struct bfd_link_info *link_info,
1613 struct elf_link_hash_entry *myh;
1614 struct elf32_arm_link_hash_table *hash_table;
1616 /* We need a pointer to the elfarm specific hash table. */
1617 hash_table = elf32_arm_hash_table (link_info);
1619 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
1620 + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
1622 BFD_ASSERT (tmp_name);
1624 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
1626 myh = elf_link_hash_lookup
1627 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
1630 /* xgettext:c-format */
1631 (*_bfd_error_handler) (_("%B: unable to find ARM glue '%s' for `%s'"),
1632 input_bfd, tmp_name, name);
1643 ldr r12, __func_addr
1646 .word func @ behave as if you saw a ARM_32 reloc. */
1648 #define ARM2THUMB_GLUE_SIZE 12
1649 static const insn32 a2t1_ldr_insn = 0xe59fc000;
1650 static const insn32 a2t2_bx_r12_insn = 0xe12fff1c;
1651 static const insn32 a2t3_func_addr_insn = 0x00000001;
1653 /* Thumb->ARM: Thumb->(non-interworking aware) ARM
1657 __func_from_thumb: __func_from_thumb:
1659 nop ldr r6, __func_addr
1661 __func_change_to_arm: bx r6
1663 __func_back_to_thumb:
1669 #define THUMB2ARM_GLUE_SIZE 8
1670 static const insn16 t2a1_bx_pc_insn = 0x4778;
1671 static const insn16 t2a2_noop_insn = 0x46c0;
1672 static const insn32 t2a3_b_insn = 0xea000000;
1674 #ifndef ELFARM_NABI_C_INCLUDED
1676 bfd_elf32_arm_allocate_interworking_sections (struct bfd_link_info * info)
1680 struct elf32_arm_link_hash_table * globals;
1682 globals = elf32_arm_hash_table (info);
1684 BFD_ASSERT (globals != NULL);
1686 if (globals->arm_glue_size != 0)
1688 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1690 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
1691 ARM2THUMB_GLUE_SECTION_NAME);
1693 BFD_ASSERT (s != NULL);
1695 foo = bfd_alloc (globals->bfd_of_glue_owner, globals->arm_glue_size);
1697 s->size = globals->arm_glue_size;
1701 if (globals->thumb_glue_size != 0)
1703 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1705 s = bfd_get_section_by_name
1706 (globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
1708 BFD_ASSERT (s != NULL);
1710 foo = bfd_alloc (globals->bfd_of_glue_owner, globals->thumb_glue_size);
1712 s->size = globals->thumb_glue_size;
1720 record_arm_to_thumb_glue (struct bfd_link_info * link_info,
1721 struct elf_link_hash_entry * h)
1723 const char * name = h->root.root.string;
1726 struct elf_link_hash_entry * myh;
1727 struct bfd_link_hash_entry * bh;
1728 struct elf32_arm_link_hash_table * globals;
1731 globals = elf32_arm_hash_table (link_info);
1733 BFD_ASSERT (globals != NULL);
1734 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1736 s = bfd_get_section_by_name
1737 (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
1739 BFD_ASSERT (s != NULL);
1741 tmp_name = bfd_malloc ((bfd_size_type) strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
1743 BFD_ASSERT (tmp_name);
1745 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
1747 myh = elf_link_hash_lookup
1748 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
1752 /* We've already seen this guy. */
1757 /* The only trick here is using hash_table->arm_glue_size as the value.
1758 Even though the section isn't allocated yet, this is where we will be
1761 val = globals->arm_glue_size + 1;
1762 _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner,
1763 tmp_name, BSF_GLOBAL, s, val,
1764 NULL, TRUE, FALSE, &bh);
1766 myh = (struct elf_link_hash_entry *) bh;
1767 myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
1768 myh->forced_local = 1;
1772 globals->arm_glue_size += ARM2THUMB_GLUE_SIZE;
1778 record_thumb_to_arm_glue (struct bfd_link_info *link_info,
1779 struct elf_link_hash_entry *h)
1781 const char *name = h->root.root.string;
1784 struct elf_link_hash_entry *myh;
1785 struct bfd_link_hash_entry *bh;
1786 struct elf32_arm_link_hash_table *hash_table;
1789 hash_table = elf32_arm_hash_table (link_info);
1791 BFD_ASSERT (hash_table != NULL);
1792 BFD_ASSERT (hash_table->bfd_of_glue_owner != NULL);
1794 s = bfd_get_section_by_name
1795 (hash_table->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
1797 BFD_ASSERT (s != NULL);
1799 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
1800 + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
1802 BFD_ASSERT (tmp_name);
1804 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
1806 myh = elf_link_hash_lookup
1807 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
1811 /* We've already seen this guy. */
1817 val = hash_table->thumb_glue_size + 1;
1818 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
1819 tmp_name, BSF_GLOBAL, s, val,
1820 NULL, TRUE, FALSE, &bh);
1822 /* If we mark it 'Thumb', the disassembler will do a better job. */
1823 myh = (struct elf_link_hash_entry *) bh;
1824 myh->type = ELF_ST_INFO (STB_LOCAL, STT_ARM_TFUNC);
1825 myh->forced_local = 1;
1829 #define CHANGE_TO_ARM "__%s_change_to_arm"
1830 #define BACK_FROM_ARM "__%s_back_from_arm"
1832 /* Allocate another symbol to mark where we switch to Arm mode. */
1833 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
1834 + strlen (CHANGE_TO_ARM) + 1);
1836 BFD_ASSERT (tmp_name);
1838 sprintf (tmp_name, CHANGE_TO_ARM, name);
1841 val = hash_table->thumb_glue_size + 4,
1842 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
1843 tmp_name, BSF_LOCAL, s, val,
1844 NULL, TRUE, FALSE, &bh);
1848 hash_table->thumb_glue_size += THUMB2ARM_GLUE_SIZE;
1853 /* Add the glue sections to ABFD. This function is called from the
1854 linker scripts in ld/emultempl/{armelf}.em. */
1857 bfd_elf32_arm_add_glue_sections_to_bfd (bfd *abfd,
1858 struct bfd_link_info *info)
1863 /* If we are only performing a partial
1864 link do not bother adding the glue. */
1865 if (info->relocatable)
1868 sec = bfd_get_section_by_name (abfd, ARM2THUMB_GLUE_SECTION_NAME);
1872 /* Note: we do not include the flag SEC_LINKER_CREATED, as this
1873 will prevent elf_link_input_bfd() from processing the contents
1875 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE | SEC_READONLY;
1877 sec = bfd_make_section (abfd, ARM2THUMB_GLUE_SECTION_NAME);
1880 || !bfd_set_section_flags (abfd, sec, flags)
1881 || !bfd_set_section_alignment (abfd, sec, 2))
1884 /* Set the gc mark to prevent the section from being removed by garbage
1885 collection, despite the fact that no relocs refer to this section. */
1889 sec = bfd_get_section_by_name (abfd, THUMB2ARM_GLUE_SECTION_NAME);
1893 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1894 | SEC_CODE | SEC_READONLY;
1896 sec = bfd_make_section (abfd, THUMB2ARM_GLUE_SECTION_NAME);
1899 || !bfd_set_section_flags (abfd, sec, flags)
1900 || !bfd_set_section_alignment (abfd, sec, 2))
1909 /* Select a BFD to be used to hold the sections used by the glue code.
1910 This function is called from the linker scripts in ld/emultempl/
1914 bfd_elf32_arm_get_bfd_for_interworking (bfd *abfd, struct bfd_link_info *info)
1916 struct elf32_arm_link_hash_table *globals;
1918 /* If we are only performing a partial link
1919 do not bother getting a bfd to hold the glue. */
1920 if (info->relocatable)
1923 /* Make sure we don't attach the glue sections to a dynamic object. */
1924 BFD_ASSERT (!(abfd->flags & DYNAMIC));
1926 globals = elf32_arm_hash_table (info);
1928 BFD_ASSERT (globals != NULL);
1930 if (globals->bfd_of_glue_owner != NULL)
1933 /* Save the bfd for later use. */
1934 globals->bfd_of_glue_owner = abfd;
1940 bfd_elf32_arm_process_before_allocation (bfd *abfd,
1941 struct bfd_link_info *link_info,
1944 Elf_Internal_Shdr *symtab_hdr;
1945 Elf_Internal_Rela *internal_relocs = NULL;
1946 Elf_Internal_Rela *irel, *irelend;
1947 bfd_byte *contents = NULL;
1950 struct elf32_arm_link_hash_table *globals;
1952 /* If we are only performing a partial link do not bother
1953 to construct any glue. */
1954 if (link_info->relocatable)
1957 /* Here we have a bfd that is to be included on the link. We have a hook
1958 to do reloc rummaging, before section sizes are nailed down. */
1959 globals = elf32_arm_hash_table (link_info);
1961 BFD_ASSERT (globals != NULL);
1962 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1964 if (byteswap_code && !bfd_big_endian (abfd))
1966 _bfd_error_handler (_("%B: BE8 images only valid in big-endian mode."),
1970 globals->byteswap_code = byteswap_code;
1972 /* Rummage around all the relocs and map the glue vectors. */
1973 sec = abfd->sections;
1978 for (; sec != NULL; sec = sec->next)
1980 if (sec->reloc_count == 0)
1983 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1985 /* Load the relocs. */
1987 = _bfd_elf_link_read_relocs (abfd, sec, (void *) NULL,
1988 (Elf_Internal_Rela *) NULL, FALSE);
1990 if (internal_relocs == NULL)
1993 irelend = internal_relocs + sec->reloc_count;
1994 for (irel = internal_relocs; irel < irelend; irel++)
1997 unsigned long r_index;
1999 struct elf_link_hash_entry *h;
2001 r_type = ELF32_R_TYPE (irel->r_info);
2002 r_index = ELF32_R_SYM (irel->r_info);
2004 /* These are the only relocation types we care about. */
2005 if ( r_type != R_ARM_PC24
2006 && r_type != R_ARM_PLT32
2008 && r_type != R_ARM_CALL
2009 && r_type != R_ARM_JUMP24
2011 && r_type != R_ARM_THM_PC22)
2014 /* Get the section contents if we haven't done so already. */
2015 if (contents == NULL)
2017 /* Get cached copy if it exists. */
2018 if (elf_section_data (sec)->this_hdr.contents != NULL)
2019 contents = elf_section_data (sec)->this_hdr.contents;
2022 /* Go get them off disk. */
2023 if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2028 /* If the relocation is not against a symbol it cannot concern us. */
2031 /* We don't care about local symbols. */
2032 if (r_index < symtab_hdr->sh_info)
2035 /* This is an external symbol. */
2036 r_index -= symtab_hdr->sh_info;
2037 h = (struct elf_link_hash_entry *)
2038 elf_sym_hashes (abfd)[r_index];
2040 /* If the relocation is against a static symbol it must be within
2041 the current section and so cannot be a cross ARM/Thumb relocation. */
2045 /* If the call will go through a PLT entry then we do not need
2047 if (globals->splt != NULL && h->plt.offset != (bfd_vma) -1)
2057 /* This one is a call from arm code. We need to look up
2058 the target of the call. If it is a thumb target, we
2060 if (ELF_ST_TYPE(h->type) == STT_ARM_TFUNC)
2061 record_arm_to_thumb_glue (link_info, h);
2064 case R_ARM_THM_PC22:
2065 /* This one is a call from thumb code. We look
2066 up the target of the call. If it is not a thumb
2067 target, we insert glue. */
2068 if (ELF_ST_TYPE (h->type) != STT_ARM_TFUNC)
2069 record_thumb_to_arm_glue (link_info, h);
2077 if (contents != NULL
2078 && elf_section_data (sec)->this_hdr.contents != contents)
2082 if (internal_relocs != NULL
2083 && elf_section_data (sec)->relocs != internal_relocs)
2084 free (internal_relocs);
2085 internal_relocs = NULL;
2091 if (contents != NULL
2092 && elf_section_data (sec)->this_hdr.contents != contents)
2094 if (internal_relocs != NULL
2095 && elf_section_data (sec)->relocs != internal_relocs)
2096 free (internal_relocs);
2104 /* Set target relocation values needed during linking. */
2107 bfd_elf32_arm_set_target_relocs (struct bfd_link_info *link_info,
2109 char * target2_type,
2112 struct elf32_arm_link_hash_table *globals;
2114 globals = elf32_arm_hash_table (link_info);
2116 globals->target1_is_rel = target1_is_rel;
2117 if (strcmp (target2_type, "rel") == 0)
2118 globals->target2_reloc = R_ARM_REL32;
2119 else if (strcmp (target2_type, "abs") == 0)
2120 globals->target2_reloc = R_ARM_ABS32;
2121 else if (strcmp (target2_type, "got-rel") == 0)
2122 globals->target2_reloc = R_ARM_GOT_PREL;
2125 _bfd_error_handler (_("Invalid TARGET2 relocation type '%s'."),
2128 globals->fix_v4bx = fix_v4bx;
2132 /* The thumb form of a long branch is a bit finicky, because the offset
2133 encoding is split over two fields, each in it's own instruction. They
2134 can occur in any order. So given a thumb form of long branch, and an
2135 offset, insert the offset into the thumb branch and return finished
2138 It takes two thumb instructions to encode the target address. Each has
2139 11 bits to invest. The upper 11 bits are stored in one (identified by
2140 H-0.. see below), the lower 11 bits are stored in the other (identified
2143 Combine together and shifted left by 1 (it's a half word address) and
2147 H-0, upper address-0 = 000
2149 H-1, lower address-0 = 800
2151 They can be ordered either way, but the arm tools I've seen always put
2152 the lower one first. It probably doesn't matter. krk@cygnus.com
2154 XXX: Actually the order does matter. The second instruction (H-1)
2155 moves the computed address into the PC, so it must be the second one
2156 in the sequence. The problem, however is that whilst little endian code
2157 stores the instructions in HI then LOW order, big endian code does the
2158 reverse. nickc@cygnus.com. */
2160 #define LOW_HI_ORDER 0xF800F000
2161 #define HI_LOW_ORDER 0xF000F800
2164 insert_thumb_branch (insn32 br_insn, int rel_off)
2166 unsigned int low_bits;
2167 unsigned int high_bits;
2169 BFD_ASSERT ((rel_off & 1) != 1);
2171 rel_off >>= 1; /* Half word aligned address. */
2172 low_bits = rel_off & 0x000007FF; /* The bottom 11 bits. */
2173 high_bits = (rel_off >> 11) & 0x000007FF; /* The top 11 bits. */
2175 if ((br_insn & LOW_HI_ORDER) == LOW_HI_ORDER)
2176 br_insn = LOW_HI_ORDER | (low_bits << 16) | high_bits;
2177 else if ((br_insn & HI_LOW_ORDER) == HI_LOW_ORDER)
2178 br_insn = HI_LOW_ORDER | (high_bits << 16) | low_bits;
2180 /* FIXME: abort is probably not the right call. krk@cygnus.com */
2181 abort (); /* Error - not a valid branch instruction form. */
2186 /* Thumb code calling an ARM function. */
2189 elf32_thumb_to_arm_stub (struct bfd_link_info * info,
2193 asection * input_section,
2194 bfd_byte * hit_data,
2197 bfd_signed_vma addend,
2202 unsigned long int tmp;
2203 long int ret_offset;
2204 struct elf_link_hash_entry * myh;
2205 struct elf32_arm_link_hash_table * globals;
2207 myh = find_thumb_glue (info, name, input_bfd);
2211 globals = elf32_arm_hash_table (info);
2213 BFD_ASSERT (globals != NULL);
2214 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2216 my_offset = myh->root.u.def.value;
2218 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
2219 THUMB2ARM_GLUE_SECTION_NAME);
2221 BFD_ASSERT (s != NULL);
2222 BFD_ASSERT (s->contents != NULL);
2223 BFD_ASSERT (s->output_section != NULL);
2225 if ((my_offset & 0x01) == 0x01)
2228 && sym_sec->owner != NULL
2229 && !INTERWORK_FLAG (sym_sec->owner))
2231 (*_bfd_error_handler)
2232 (_("%B(%s): warning: interworking not enabled.\n"
2233 " first occurrence: %B: thumb call to arm"),
2234 sym_sec->owner, input_bfd, name);
2240 myh->root.u.def.value = my_offset;
2242 bfd_put_16 (output_bfd, (bfd_vma) t2a1_bx_pc_insn,
2243 s->contents + my_offset);
2245 bfd_put_16 (output_bfd, (bfd_vma) t2a2_noop_insn,
2246 s->contents + my_offset + 2);
2249 /* Address of destination of the stub. */
2250 ((bfd_signed_vma) val)
2252 /* Offset from the start of the current section
2253 to the start of the stubs. */
2255 /* Offset of the start of this stub from the start of the stubs. */
2257 /* Address of the start of the current section. */
2258 + s->output_section->vma)
2259 /* The branch instruction is 4 bytes into the stub. */
2261 /* ARM branches work from the pc of the instruction + 8. */
2264 bfd_put_32 (output_bfd,
2265 (bfd_vma) t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
2266 s->contents + my_offset + 4);
2269 BFD_ASSERT (my_offset <= globals->thumb_glue_size);
2271 /* Now go back and fix up the original BL insn to point to here. */
2273 /* Address of where the stub is located. */
2274 (s->output_section->vma + s->output_offset + my_offset)
2275 /* Address of where the BL is located. */
2276 - (input_section->output_section->vma + input_section->output_offset
2278 /* Addend in the relocation. */
2280 /* Biassing for PC-relative addressing. */
2283 tmp = bfd_get_32 (input_bfd, hit_data
2284 - input_section->vma);
2286 bfd_put_32 (output_bfd,
2287 (bfd_vma) insert_thumb_branch (tmp, ret_offset),
2288 hit_data - input_section->vma);
2293 /* Arm code calling a Thumb function. */
2296 elf32_arm_to_thumb_stub (struct bfd_link_info * info,
2300 asection * input_section,
2301 bfd_byte * hit_data,
2304 bfd_signed_vma addend,
2307 unsigned long int tmp;
2310 long int ret_offset;
2311 struct elf_link_hash_entry * myh;
2312 struct elf32_arm_link_hash_table * globals;
2314 myh = find_arm_glue (info, name, input_bfd);
2318 globals = elf32_arm_hash_table (info);
2320 BFD_ASSERT (globals != NULL);
2321 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2323 my_offset = myh->root.u.def.value;
2324 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
2325 ARM2THUMB_GLUE_SECTION_NAME);
2326 BFD_ASSERT (s != NULL);
2327 BFD_ASSERT (s->contents != NULL);
2328 BFD_ASSERT (s->output_section != NULL);
2330 if ((my_offset & 0x01) == 0x01)
2333 && sym_sec->owner != NULL
2334 && !INTERWORK_FLAG (sym_sec->owner))
2336 (*_bfd_error_handler)
2337 (_("%B(%s): warning: interworking not enabled.\n"
2338 " first occurrence: %B: arm call to thumb"),
2339 sym_sec->owner, input_bfd, name);
2343 myh->root.u.def.value = my_offset;
2345 bfd_put_32 (output_bfd, (bfd_vma) a2t1_ldr_insn,
2346 s->contents + my_offset);
2348 bfd_put_32 (output_bfd, (bfd_vma) a2t2_bx_r12_insn,
2349 s->contents + my_offset + 4);
2351 /* It's a thumb address. Add the low order bit. */
2352 bfd_put_32 (output_bfd, val | a2t3_func_addr_insn,
2353 s->contents + my_offset + 8);
2356 BFD_ASSERT (my_offset <= globals->arm_glue_size);
2358 tmp = bfd_get_32 (input_bfd, hit_data);
2359 tmp = tmp & 0xFF000000;
2361 /* Somehow these are both 4 too far, so subtract 8. */
2362 ret_offset = (s->output_offset
2364 + s->output_section->vma
2365 - (input_section->output_offset
2366 + input_section->output_section->vma
2370 tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
2372 bfd_put_32 (output_bfd, (bfd_vma) tmp, hit_data - input_section->vma);
2379 /* Some relocations map to different relocations depending on the
2380 target. Return the real relocation. */
2382 arm_real_reloc_type (struct elf32_arm_link_hash_table * globals,
2388 if (globals->target1_is_rel)
2394 return globals->target2_reloc;
2400 #endif /* OLD_ARM_ABI */
2403 /* Return the base VMA address which should be subtracted from real addresses
2404 when resolving @dtpoff relocation.
2405 This is PT_TLS segment p_vaddr. */
2408 dtpoff_base (struct bfd_link_info *info)
2410 /* If tls_sec is NULL, we should have signalled an error already. */
2411 if (elf_hash_table (info)->tls_sec == NULL)
2413 return elf_hash_table (info)->tls_sec->vma;
2416 /* Return the relocation value for @tpoff relocation
2417 if STT_TLS virtual address is ADDRESS. */
2420 tpoff (struct bfd_link_info *info, bfd_vma address)
2422 struct elf_link_hash_table *htab = elf_hash_table (info);
2425 /* If tls_sec is NULL, we should have signalled an error already. */
2426 if (htab->tls_sec == NULL)
2428 base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power);
2429 return address - htab->tls_sec->vma + base;
2432 /* Perform a relocation as part of a final link. */
2434 static bfd_reloc_status_type
2435 elf32_arm_final_link_relocate (reloc_howto_type * howto,
2438 asection * input_section,
2439 bfd_byte * contents,
2440 Elf_Internal_Rela * rel,
2442 struct bfd_link_info * info,
2444 const char * sym_name,
2446 struct elf_link_hash_entry * h,
2447 bfd_boolean * unresolved_reloc_p)
2449 unsigned long r_type = howto->type;
2450 unsigned long r_symndx;
2451 bfd_byte * hit_data = contents + rel->r_offset;
2452 bfd * dynobj = NULL;
2453 Elf_Internal_Shdr * symtab_hdr;
2454 struct elf_link_hash_entry ** sym_hashes;
2455 bfd_vma * local_got_offsets;
2456 asection * sgot = NULL;
2457 asection * splt = NULL;
2458 asection * sreloc = NULL;
2460 bfd_signed_vma signed_addend;
2461 struct elf32_arm_link_hash_table * globals;
2463 globals = elf32_arm_hash_table (info);
2466 /* Some relocation type map to different relocations depending on the
2467 target. We pick the right one here. */
2468 r_type = arm_real_reloc_type (globals, r_type);
2469 if (r_type != howto->type)
2470 howto = elf32_arm_howto_from_type (r_type);
2471 #endif /* OLD_ARM_ABI */
2473 /* If the start address has been set, then set the EF_ARM_HASENTRY
2474 flag. Setting this more than once is redundant, but the cost is
2475 not too high, and it keeps the code simple.
2477 The test is done here, rather than somewhere else, because the
2478 start address is only set just before the final link commences.
2480 Note - if the user deliberately sets a start address of 0, the
2481 flag will not be set. */
2482 if (bfd_get_start_address (output_bfd) != 0)
2483 elf_elfheader (output_bfd)->e_flags |= EF_ARM_HASENTRY;
2485 dynobj = elf_hash_table (info)->dynobj;
2488 sgot = bfd_get_section_by_name (dynobj, ".got");
2489 splt = bfd_get_section_by_name (dynobj, ".plt");
2491 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
2492 sym_hashes = elf_sym_hashes (input_bfd);
2493 local_got_offsets = elf_local_got_offsets (input_bfd);
2494 r_symndx = ELF32_R_SYM (rel->r_info);
2496 if (globals->use_rel)
2498 addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask;
2500 if (addend & ((howto->src_mask + 1) >> 1))
2503 signed_addend &= ~ howto->src_mask;
2504 signed_addend |= addend;
2507 signed_addend = addend;
2510 addend = signed_addend = rel->r_addend;
2515 /* We don't need to find a value for this symbol. It's just a
2517 *unresolved_reloc_p = FALSE;
2518 return bfd_reloc_ok;
2530 /* r_symndx will be zero only for relocs against symbols
2531 from removed linkonce sections, or sections discarded by
2534 return bfd_reloc_ok;
2536 /* Handle relocations which should use the PLT entry. ABS32/REL32
2537 will use the symbol's value, which may point to a PLT entry, but we
2538 don't need to handle that here. If we created a PLT entry, all
2539 branches in this object should go to it. */
2540 if ((r_type != R_ARM_ABS32 && r_type != R_ARM_REL32)
2543 && h->plt.offset != (bfd_vma) -1)
2545 /* If we've created a .plt section, and assigned a PLT entry to
2546 this function, it should not be known to bind locally. If
2547 it were, we would have cleared the PLT entry. */
2548 BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info, h));
2550 value = (splt->output_section->vma
2551 + splt->output_offset
2553 *unresolved_reloc_p = FALSE;
2554 return _bfd_final_link_relocate (howto, input_bfd, input_section,
2555 contents, rel->r_offset, value,
2559 /* When generating a shared object or relocatable executable, these
2560 relocations are copied into the output file to be resolved at
2562 if ((info->shared || globals->root.is_relocatable_executable)
2563 && (input_section->flags & SEC_ALLOC)
2564 && (r_type != R_ARM_REL32
2565 || !SYMBOL_CALLS_LOCAL (info, h))
2567 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2568 || h->root.type != bfd_link_hash_undefweak)
2569 && r_type != R_ARM_PC24
2571 && r_type != R_ARM_CALL
2572 && r_type != R_ARM_JUMP24
2573 && r_type != R_ARM_PREL31
2575 && r_type != R_ARM_PLT32)
2577 Elf_Internal_Rela outrel;
2579 bfd_boolean skip, relocate;
2581 *unresolved_reloc_p = FALSE;
2587 name = (bfd_elf_string_from_elf_section
2589 elf_elfheader (input_bfd)->e_shstrndx,
2590 elf_section_data (input_section)->rel_hdr.sh_name));
2592 return bfd_reloc_notsupported;
2594 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
2595 && strcmp (bfd_get_section_name (input_bfd,
2599 sreloc = bfd_get_section_by_name (dynobj, name);
2600 BFD_ASSERT (sreloc != NULL);
2607 _bfd_elf_section_offset (output_bfd, info, input_section,
2609 if (outrel.r_offset == (bfd_vma) -1)
2611 else if (outrel.r_offset == (bfd_vma) -2)
2612 skip = TRUE, relocate = TRUE;
2613 outrel.r_offset += (input_section->output_section->vma
2614 + input_section->output_offset);
2617 memset (&outrel, 0, sizeof outrel);
2622 || !h->def_regular))
2623 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2628 /* This symbol is local, or marked to become local. */
2630 if (sym_flags == STT_ARM_TFUNC)
2632 if (globals->symbian_p)
2634 /* On Symbian OS, the data segment and text segement
2635 can be relocated independently. Therefore, we
2636 must indicate the segment to which this
2637 relocation is relative. The BPABI allows us to
2638 use any symbol in the right segment; we just use
2639 the section symbol as it is convenient. (We
2640 cannot use the symbol given by "h" directly as it
2641 will not appear in the dynamic symbol table.) */
2642 symbol = elf_section_data (sym_sec->output_section)->dynindx;
2643 BFD_ASSERT (symbol != 0);
2646 /* On SVR4-ish systems, the dynamic loader cannot
2647 relocate the text and data segments independently,
2648 so the symbol does not matter. */
2650 outrel.r_info = ELF32_R_INFO (symbol, R_ARM_RELATIVE);
2653 loc = sreloc->contents;
2654 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2655 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2657 /* If this reloc is against an external symbol, we do not want to
2658 fiddle with the addend. Otherwise, we need to include the symbol
2659 value so that it becomes an addend for the dynamic reloc. */
2661 return bfd_reloc_ok;
2663 return _bfd_final_link_relocate (howto, input_bfd, input_section,
2664 contents, rel->r_offset, value,
2667 else switch (r_type)
2670 case R_ARM_XPC25: /* Arm BLX instruction. */
2674 case R_ARM_PC24: /* Arm B/BL instruction */
2677 if (r_type == R_ARM_XPC25)
2679 /* Check for Arm calling Arm function. */
2680 /* FIXME: Should we translate the instruction into a BL
2681 instruction instead ? */
2682 if (sym_flags != STT_ARM_TFUNC)
2683 (*_bfd_error_handler)
2684 (_("\%B: Warning: Arm BLX instruction targets Arm function '%s'."),
2686 h ? h->root.root.string : "(local)");
2691 /* Check for Arm calling Thumb function. */
2692 if (sym_flags == STT_ARM_TFUNC)
2694 elf32_arm_to_thumb_stub (info, sym_name, input_bfd,
2695 output_bfd, input_section,
2696 hit_data, sym_sec, rel->r_offset,
2697 signed_addend, value);
2698 return bfd_reloc_ok;
2702 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
2704 S is the address of the symbol in the relocation.
2705 P is address of the instruction being relocated.
2706 A is the addend (extracted from the instruction) in bytes.
2708 S is held in 'value'.
2709 P is the base address of the section containing the
2710 instruction plus the offset of the reloc into that
2712 (input_section->output_section->vma +
2713 input_section->output_offset +
2715 A is the addend, converted into bytes, ie:
2718 Note: None of these operations have knowledge of the pipeline
2719 size of the processor, thus it is up to the assembler to
2720 encode this information into the addend. */
2721 value -= (input_section->output_section->vma
2722 + input_section->output_offset);
2723 value -= rel->r_offset;
2724 if (globals->use_rel)
2725 value += (signed_addend << howto->size);
2727 /* RELA addends do not have to be adjusted by howto->size. */
2728 value += signed_addend;
2730 signed_addend = value;
2731 signed_addend >>= howto->rightshift;
2733 /* It is not an error for an undefined weak reference to be
2734 out of range. Any program that branches to such a symbol
2735 is going to crash anyway, so there is no point worrying
2736 about getting the destination exactly right. */
2737 if (! h || h->root.type != bfd_link_hash_undefweak)
2739 /* Perform a signed range check. */
2740 if ( signed_addend > ((bfd_signed_vma) (howto->dst_mask >> 1))
2741 || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1)))
2742 return bfd_reloc_overflow;
2746 /* If necessary set the H bit in the BLX instruction. */
2747 if (r_type == R_ARM_XPC25 && ((value & 2) == 2))
2748 value = (signed_addend & howto->dst_mask)
2749 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask))
2753 value = (signed_addend & howto->dst_mask)
2754 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
2759 if (sym_flags == STT_ARM_TFUNC)
2764 value -= (input_section->output_section->vma
2765 + input_section->output_offset + rel->r_offset);
2771 value -= (input_section->output_section->vma
2772 + input_section->output_offset + rel->r_offset);
2773 value += signed_addend;
2774 if (! h || h->root.type != bfd_link_hash_undefweak)
2776 /* Check for overflow */
2777 if ((value ^ (value >> 1)) & (1 << 30))
2778 return bfd_reloc_overflow;
2780 value &= 0x7fffffff;
2781 value |= (bfd_get_32 (input_bfd, hit_data) & 0x80000000);
2782 if (sym_flags == STT_ARM_TFUNC)
2788 bfd_put_32 (input_bfd, value, hit_data);
2789 return bfd_reloc_ok;
2793 if ((long) value > 0x7f || (long) value < -0x80)
2794 return bfd_reloc_overflow;
2796 bfd_put_8 (input_bfd, value, hit_data);
2797 return bfd_reloc_ok;
2802 if ((long) value > 0x7fff || (long) value < -0x8000)
2803 return bfd_reloc_overflow;
2805 bfd_put_16 (input_bfd, value, hit_data);
2806 return bfd_reloc_ok;
2809 /* Support ldr and str instruction for the arm */
2810 /* Also thumb b (unconditional branch). ??? Really? */
2813 if ((long) value > 0x7ff || (long) value < -0x800)
2814 return bfd_reloc_overflow;
2816 value |= (bfd_get_32 (input_bfd, hit_data) & 0xfffff000);
2817 bfd_put_32 (input_bfd, value, hit_data);
2818 return bfd_reloc_ok;
2820 case R_ARM_THM_ABS5:
2821 /* Support ldr and str instructions for the thumb. */
2822 if (globals->use_rel)
2824 /* Need to refetch addend. */
2825 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
2826 /* ??? Need to determine shift amount from operand size. */
2827 addend >>= howto->rightshift;
2831 /* ??? Isn't value unsigned? */
2832 if ((long) value > 0x1f || (long) value < -0x10)
2833 return bfd_reloc_overflow;
2835 /* ??? Value needs to be properly shifted into place first. */
2836 value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
2837 bfd_put_16 (input_bfd, value, hit_data);
2838 return bfd_reloc_ok;
2841 case R_ARM_THM_XPC22:
2843 case R_ARM_THM_PC22:
2844 /* Thumb BL (branch long instruction). */
2847 bfd_boolean overflow = FALSE;
2848 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
2849 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
2850 bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
2851 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
2853 bfd_signed_vma signed_check;
2855 /* Need to refetch the addend and squish the two 11 bit pieces
2857 if (globals->use_rel)
2859 bfd_vma upper = upper_insn & 0x7ff;
2860 bfd_vma lower = lower_insn & 0x7ff;
2861 upper = (upper ^ 0x400) - 0x400; /* Sign extend. */
2862 addend = (upper << 12) | (lower << 1);
2863 signed_addend = addend;
2866 if (r_type == R_ARM_THM_XPC22)
2868 /* Check for Thumb to Thumb call. */
2869 /* FIXME: Should we translate the instruction into a BL
2870 instruction instead ? */
2871 if (sym_flags == STT_ARM_TFUNC)
2872 (*_bfd_error_handler)
2873 (_("%B: Warning: Thumb BLX instruction targets thumb function '%s'."),
2875 h ? h->root.root.string : "(local)");
2880 /* If it is not a call to Thumb, assume call to Arm.
2881 If it is a call relative to a section name, then it is not a
2882 function call at all, but rather a long jump. Calls through
2883 the PLT do not require stubs. */
2884 if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION
2885 && (h == NULL || splt == NULL
2886 || h->plt.offset == (bfd_vma) -1))
2888 if (elf32_thumb_to_arm_stub
2889 (info, sym_name, input_bfd, output_bfd, input_section,
2890 hit_data, sym_sec, rel->r_offset, signed_addend, value))
2891 return bfd_reloc_ok;
2893 return bfd_reloc_dangerous;
2897 /* Handle calls via the PLT. */
2898 if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
2900 value = (splt->output_section->vma
2901 + splt->output_offset
2903 /* Target the Thumb stub before the ARM PLT entry. */
2905 *unresolved_reloc_p = FALSE;
2908 relocation = value + signed_addend;
2910 relocation -= (input_section->output_section->vma
2911 + input_section->output_offset
2914 check = relocation >> howto->rightshift;
2916 /* If this is a signed value, the rightshift just dropped
2917 leading 1 bits (assuming twos complement). */
2918 if ((bfd_signed_vma) relocation >= 0)
2919 signed_check = check;
2921 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
2923 /* Assumes two's complement. */
2924 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
2928 if (r_type == R_ARM_THM_XPC22
2929 && ((lower_insn & 0x1800) == 0x0800))
2930 /* For a BLX instruction, make sure that the relocation is rounded up
2931 to a word boundary. This follows the semantics of the instruction
2932 which specifies that bit 1 of the target address will come from bit
2933 1 of the base address. */
2934 relocation = (relocation + 2) & ~ 3;
2936 /* Put RELOCATION back into the insn. */
2937 upper_insn = (upper_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 12) & 0x7ff);
2938 lower_insn = (lower_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 1) & 0x7ff);
2940 /* Put the relocated value back in the object file: */
2941 bfd_put_16 (input_bfd, upper_insn, hit_data);
2942 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
2944 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
2948 case R_ARM_THM_PC11:
2950 /* Thumb B (branch) instruction). */
2952 bfd_signed_vma relocation;
2953 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
2954 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
2955 bfd_signed_vma signed_check;
2957 if (globals->use_rel)
2959 /* Need to refetch addend. */
2960 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
2961 if (addend & ((howto->src_mask + 1) >> 1))
2964 signed_addend &= ~ howto->src_mask;
2965 signed_addend |= addend;
2968 signed_addend = addend;
2969 /* The value in the insn has been right shifted. We need to
2970 undo this, so that we can perform the address calculation
2971 in terms of bytes. */
2972 signed_addend <<= howto->rightshift;
2974 relocation = value + signed_addend;
2976 relocation -= (input_section->output_section->vma
2977 + input_section->output_offset
2980 relocation >>= howto->rightshift;
2981 signed_check = relocation;
2982 relocation &= howto->dst_mask;
2983 relocation |= (bfd_get_16 (input_bfd, hit_data) & (~ howto->dst_mask));
2985 bfd_put_16 (input_bfd, relocation, hit_data);
2987 /* Assumes two's complement. */
2988 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
2989 return bfd_reloc_overflow;
2991 return bfd_reloc_ok;
2995 case R_ARM_ALU_PCREL7_0:
2996 case R_ARM_ALU_PCREL15_8:
2997 case R_ARM_ALU_PCREL23_15:
3002 insn = bfd_get_32 (input_bfd, hit_data);
3003 if (globals->use_rel)
3005 /* Extract the addend. */
3006 addend = (insn & 0xff) << ((insn & 0xf00) >> 7);
3007 signed_addend = addend;
3009 relocation = value + signed_addend;
3011 relocation -= (input_section->output_section->vma
3012 + input_section->output_offset
3014 insn = (insn & ~0xfff)
3015 | ((howto->bitpos << 7) & 0xf00)
3016 | ((relocation >> howto->bitpos) & 0xff);
3017 bfd_put_32 (input_bfd, value, hit_data);
3019 return bfd_reloc_ok;
3022 case R_ARM_GNU_VTINHERIT:
3023 case R_ARM_GNU_VTENTRY:
3024 return bfd_reloc_ok;
3027 return bfd_reloc_notsupported;
3029 case R_ARM_GLOB_DAT:
3030 return bfd_reloc_notsupported;
3032 case R_ARM_JUMP_SLOT:
3033 return bfd_reloc_notsupported;
3035 case R_ARM_RELATIVE:
3036 return bfd_reloc_notsupported;
3039 /* Relocation is relative to the start of the
3040 global offset table. */
3042 BFD_ASSERT (sgot != NULL);
3044 return bfd_reloc_notsupported;
3046 /* If we are addressing a Thumb function, we need to adjust the
3047 address by one, so that attempts to call the function pointer will
3048 correctly interpret it as Thumb code. */
3049 if (sym_flags == STT_ARM_TFUNC)
3052 /* Note that sgot->output_offset is not involved in this
3053 calculation. We always want the start of .got. If we
3054 define _GLOBAL_OFFSET_TABLE in a different way, as is
3055 permitted by the ABI, we might have to change this
3057 value -= sgot->output_section->vma;
3058 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3059 contents, rel->r_offset, value,
3063 /* Use global offset table as symbol value. */
3064 BFD_ASSERT (sgot != NULL);
3067 return bfd_reloc_notsupported;
3069 *unresolved_reloc_p = FALSE;
3070 value = sgot->output_section->vma;
3071 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3072 contents, rel->r_offset, value,
3077 case R_ARM_GOT_PREL:
3079 /* Relocation is to the entry for this symbol in the
3080 global offset table. */
3082 return bfd_reloc_notsupported;
3089 off = h->got.offset;
3090 BFD_ASSERT (off != (bfd_vma) -1);
3091 dyn = globals->root.dynamic_sections_created;
3093 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3095 && SYMBOL_REFERENCES_LOCAL (info, h))
3096 || (ELF_ST_VISIBILITY (h->other)
3097 && h->root.type == bfd_link_hash_undefweak))
3099 /* This is actually a static link, or it is a -Bsymbolic link
3100 and the symbol is defined locally. We must initialize this
3101 entry in the global offset table. Since the offset must
3102 always be a multiple of 4, we use the least significant bit
3103 to record whether we have initialized it already.
3105 When doing a dynamic link, we create a .rel.got relocation
3106 entry to initialize the value. This is done in the
3107 finish_dynamic_symbol routine. */
3112 /* If we are addressing a Thumb function, we need to
3113 adjust the address by one, so that attempts to
3114 call the function pointer will correctly
3115 interpret it as Thumb code. */
3116 if (sym_flags == STT_ARM_TFUNC)
3119 bfd_put_32 (output_bfd, value, sgot->contents + off);
3124 *unresolved_reloc_p = FALSE;
3126 value = sgot->output_offset + off;
3132 BFD_ASSERT (local_got_offsets != NULL &&
3133 local_got_offsets[r_symndx] != (bfd_vma) -1);
3135 off = local_got_offsets[r_symndx];
3137 /* The offset must always be a multiple of 4. We use the
3138 least significant bit to record whether we have already
3139 generated the necessary reloc. */
3144 /* If we are addressing a Thumb function, we need to
3145 adjust the address by one, so that attempts to
3146 call the function pointer will correctly
3147 interpret it as Thumb code. */
3148 if (sym_flags == STT_ARM_TFUNC)
3151 bfd_put_32 (output_bfd, value, sgot->contents + off);
3156 Elf_Internal_Rela outrel;
3159 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
3160 BFD_ASSERT (srelgot != NULL);
3162 outrel.r_offset = (sgot->output_section->vma
3163 + sgot->output_offset
3165 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
3166 loc = srelgot->contents;
3167 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
3168 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3171 local_got_offsets[r_symndx] |= 1;
3174 value = sgot->output_offset + off;
3176 if (r_type != R_ARM_GOT32)
3177 value += sgot->output_section->vma;
3179 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3180 contents, rel->r_offset, value,
3183 case R_ARM_TLS_LDO32:
3184 value = value - dtpoff_base (info);
3186 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3187 contents, rel->r_offset, value, (bfd_vma) 0);
3189 case R_ARM_TLS_LDM32:
3193 if (globals->sgot == NULL)
3196 off = globals->tls_ldm_got.offset;
3202 /* If we don't know the module number, create a relocation
3206 Elf_Internal_Rela outrel;
3209 if (globals->srelgot == NULL)
3212 outrel.r_offset = (globals->sgot->output_section->vma
3213 + globals->sgot->output_offset + off);
3214 outrel.r_info = ELF32_R_INFO (0, R_ARM_TLS_DTPMOD32);
3216 bfd_put_32 (output_bfd, 0, globals->sgot->contents + off);
3218 loc = globals->srelgot->contents;
3219 loc += globals->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
3220 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3223 bfd_put_32 (output_bfd, 1, globals->sgot->contents + off);
3225 globals->tls_ldm_got.offset |= 1;
3228 value = globals->sgot->output_section->vma + globals->sgot->output_offset + off
3229 - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
3231 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3232 contents, rel->r_offset, value,
3236 case R_ARM_TLS_GD32:
3237 case R_ARM_TLS_IE32:
3243 if (globals->sgot == NULL)
3250 dyn = globals->root.dynamic_sections_created;
3251 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3253 || !SYMBOL_REFERENCES_LOCAL (info, h)))
3255 *unresolved_reloc_p = FALSE;
3258 off = h->got.offset;
3259 tls_type = ((struct elf32_arm_link_hash_entry *) h)->tls_type;
3263 if (local_got_offsets == NULL)
3265 off = local_got_offsets[r_symndx];
3266 tls_type = elf32_arm_local_got_tls_type (input_bfd)[r_symndx];
3269 if (tls_type == GOT_UNKNOWN)
3276 bfd_boolean need_relocs = FALSE;
3277 Elf_Internal_Rela outrel;
3278 bfd_byte *loc = NULL;
3281 /* The GOT entries have not been initialized yet. Do it
3282 now, and emit any relocations. If both an IE GOT and a
3283 GD GOT are necessary, we emit the GD first. */
3285 if ((info->shared || indx != 0)
3287 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3288 || h->root.type != bfd_link_hash_undefweak))
3291 if (globals->srelgot == NULL)
3293 loc = globals->srelgot->contents;
3294 loc += globals->srelgot->reloc_count * sizeof (Elf32_External_Rel);
3297 if (tls_type & GOT_TLS_GD)
3301 outrel.r_offset = (globals->sgot->output_section->vma
3302 + globals->sgot->output_offset + cur_off);
3303 outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_DTPMOD32);
3304 bfd_put_32 (output_bfd, 0, globals->sgot->contents + cur_off);
3306 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3307 globals->srelgot->reloc_count++;
3308 loc += sizeof (Elf32_External_Rel);
3311 bfd_put_32 (output_bfd, value - dtpoff_base (info),
3312 globals->sgot->contents + cur_off + 4);
3315 bfd_put_32 (output_bfd, 0,
3316 globals->sgot->contents + cur_off + 4);
3318 outrel.r_info = ELF32_R_INFO (indx,
3319 R_ARM_TLS_DTPOFF32);
3320 outrel.r_offset += 4;
3321 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3322 globals->srelgot->reloc_count++;
3323 loc += sizeof (Elf32_External_Rel);
3328 /* If we are not emitting relocations for a
3329 general dynamic reference, then we must be in a
3330 static link or an executable link with the
3331 symbol binding locally. Mark it as belonging
3332 to module 1, the executable. */
3333 bfd_put_32 (output_bfd, 1,
3334 globals->sgot->contents + cur_off);
3335 bfd_put_32 (output_bfd, value - dtpoff_base (info),
3336 globals->sgot->contents + cur_off + 4);
3342 if (tls_type & GOT_TLS_IE)
3346 outrel.r_offset = (globals->sgot->output_section->vma
3347 + globals->sgot->output_offset
3349 outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_TPOFF32);
3352 bfd_put_32 (output_bfd, value - dtpoff_base (info),
3353 globals->sgot->contents + cur_off);
3355 bfd_put_32 (output_bfd, 0,
3356 globals->sgot->contents + cur_off);
3358 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3359 globals->srelgot->reloc_count++;
3360 loc += sizeof (Elf32_External_Rel);
3363 bfd_put_32 (output_bfd, tpoff (info, value),
3364 globals->sgot->contents + cur_off);
3371 local_got_offsets[r_symndx] |= 1;
3374 if ((tls_type & GOT_TLS_GD) && r_type != R_ARM_TLS_GD32)
3376 value = globals->sgot->output_section->vma + globals->sgot->output_offset + off
3377 - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
3379 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3380 contents, rel->r_offset, value,
3384 case R_ARM_TLS_LE32:
3387 (*_bfd_error_handler)
3388 (_("%B(%A+0x%lx): R_ARM_TLS_LE32 relocation not permitted in shared object"),
3389 input_bfd, input_section,
3390 (long) rel->r_offset, howto->name);
3394 value = tpoff (info, value);
3396 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3397 contents, rel->r_offset, value, (bfd_vma) 0);
3400 return bfd_reloc_notsupported;
3402 case R_ARM_AMP_VCALL9:
3403 return bfd_reloc_notsupported;
3405 case R_ARM_RSBREL32:
3406 return bfd_reloc_notsupported;
3408 case R_ARM_THM_RPC22:
3409 return bfd_reloc_notsupported;
3412 return bfd_reloc_notsupported;
3415 return bfd_reloc_notsupported;
3418 return bfd_reloc_notsupported;
3421 return bfd_reloc_notsupported;
3424 if (globals->fix_v4bx)
3426 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
3428 /* Ensure that we have a BX instruction. */
3429 BFD_ASSERT ((insn & 0x0ffffff0) == 0x012fff10);
3431 /* Preserve Rm (lowest four bits) and the condition code
3432 (highest four bits). Other bits encode MOV PC,Rm. */
3433 insn = (insn & 0xf000000f) | 0x01a0f000;
3435 bfd_put_32 (input_bfd, insn, hit_data);
3437 return bfd_reloc_ok;
3440 return bfd_reloc_notsupported;
3444 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
3446 arm_add_to_rel (bfd * abfd,
3448 reloc_howto_type * howto,
3449 bfd_signed_vma increment)
3451 bfd_signed_vma addend;
3453 if (howto->type == R_ARM_THM_PC22)
3455 int upper_insn, lower_insn;
3458 upper_insn = bfd_get_16 (abfd, address);
3459 lower_insn = bfd_get_16 (abfd, address + 2);
3460 upper = upper_insn & 0x7ff;
3461 lower = lower_insn & 0x7ff;
3463 addend = (upper << 12) | (lower << 1);
3464 addend += increment;
3467 upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
3468 lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
3470 bfd_put_16 (abfd, (bfd_vma) upper_insn, address);
3471 bfd_put_16 (abfd, (bfd_vma) lower_insn, address + 2);
3477 contents = bfd_get_32 (abfd, address);
3479 /* Get the (signed) value from the instruction. */
3480 addend = contents & howto->src_mask;
3481 if (addend & ((howto->src_mask + 1) >> 1))
3483 bfd_signed_vma mask;
3486 mask &= ~ howto->src_mask;
3490 /* Add in the increment, (which is a byte value). */
3491 switch (howto->type)
3494 addend += increment;
3502 addend <<= howto->size;
3503 addend += increment;
3505 /* Should we check for overflow here ? */
3507 /* Drop any undesired bits. */
3508 addend >>= howto->rightshift;
3512 contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
3514 bfd_put_32 (abfd, contents, address);
3518 #define IS_ARM_TLS_RELOC(R_TYPE) \
3519 ((R_TYPE) == R_ARM_TLS_GD32 \
3520 || (R_TYPE) == R_ARM_TLS_LDO32 \
3521 || (R_TYPE) == R_ARM_TLS_LDM32 \
3522 || (R_TYPE) == R_ARM_TLS_DTPOFF32 \
3523 || (R_TYPE) == R_ARM_TLS_DTPMOD32 \
3524 || (R_TYPE) == R_ARM_TLS_TPOFF32 \
3525 || (R_TYPE) == R_ARM_TLS_LE32 \
3526 || (R_TYPE) == R_ARM_TLS_IE32)
3528 /* Relocate an ARM ELF section. */
3530 elf32_arm_relocate_section (bfd * output_bfd,
3531 struct bfd_link_info * info,
3533 asection * input_section,
3534 bfd_byte * contents,
3535 Elf_Internal_Rela * relocs,
3536 Elf_Internal_Sym * local_syms,
3537 asection ** local_sections)
3539 Elf_Internal_Shdr *symtab_hdr;
3540 struct elf_link_hash_entry **sym_hashes;
3541 Elf_Internal_Rela *rel;
3542 Elf_Internal_Rela *relend;
3544 struct elf32_arm_link_hash_table * globals;
3546 globals = elf32_arm_hash_table (info);
3547 if (info->relocatable && !globals->use_rel)
3550 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
3551 sym_hashes = elf_sym_hashes (input_bfd);
3554 relend = relocs + input_section->reloc_count;
3555 for (; rel < relend; rel++)
3558 reloc_howto_type * howto;
3559 unsigned long r_symndx;
3560 Elf_Internal_Sym * sym;
3562 struct elf_link_hash_entry * h;
3564 bfd_reloc_status_type r;
3567 bfd_boolean unresolved_reloc = FALSE;
3569 r_symndx = ELF32_R_SYM (rel->r_info);
3570 r_type = ELF32_R_TYPE (rel->r_info);
3571 r_type = arm_real_reloc_type (globals, r_type);
3573 if ( r_type == R_ARM_GNU_VTENTRY
3574 || r_type == R_ARM_GNU_VTINHERIT)
3577 bfd_reloc.howto = elf32_arm_howto_from_type (r_type);
3578 howto = bfd_reloc.howto;
3580 if (info->relocatable && globals->use_rel)
3582 /* This is a relocatable link. We don't have to change
3583 anything, unless the reloc is against a section symbol,
3584 in which case we have to adjust according to where the
3585 section symbol winds up in the output section. */
3586 if (r_symndx < symtab_hdr->sh_info)
3588 sym = local_syms + r_symndx;
3589 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
3591 sec = local_sections[r_symndx];
3592 arm_add_to_rel (input_bfd, contents + rel->r_offset,
3594 (bfd_signed_vma) (sec->output_offset
3602 /* This is a final link. */
3607 if (r_symndx < symtab_hdr->sh_info)
3609 sym = local_syms + r_symndx;
3610 sym_type = ELF32_ST_TYPE (sym->st_info);
3611 sec = local_sections[r_symndx];
3612 if (globals->use_rel)
3614 relocation = (sec->output_section->vma
3615 + sec->output_offset
3617 if ((sec->flags & SEC_MERGE)
3618 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
3621 bfd_vma addend, value;
3623 if (howto->rightshift)
3625 (*_bfd_error_handler)
3626 (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
3627 input_bfd, input_section,
3628 (long) rel->r_offset, howto->name);
3632 value = bfd_get_32 (input_bfd, contents + rel->r_offset);
3634 /* Get the (signed) value from the instruction. */
3635 addend = value & howto->src_mask;
3636 if (addend & ((howto->src_mask + 1) >> 1))
3638 bfd_signed_vma mask;
3641 mask &= ~ howto->src_mask;
3646 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
3648 addend += msec->output_section->vma + msec->output_offset;
3649 value = (value & ~ howto->dst_mask) | (addend & howto->dst_mask);
3650 bfd_put_32 (input_bfd, value, contents + rel->r_offset);
3654 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
3660 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3661 r_symndx, symtab_hdr, sym_hashes,
3663 unresolved_reloc, warned);
3669 name = h->root.root.string;
3672 name = (bfd_elf_string_from_elf_section
3673 (input_bfd, symtab_hdr->sh_link, sym->st_name));
3674 if (name == NULL || *name == '\0')
3675 name = bfd_section_name (input_bfd, sec);
3679 && r_type != R_ARM_NONE
3681 || h->root.type == bfd_link_hash_defined
3682 || h->root.type == bfd_link_hash_defweak)
3683 && IS_ARM_TLS_RELOC (r_type) != (sym_type == STT_TLS))
3685 (*_bfd_error_handler)
3686 ((sym_type == STT_TLS
3687 ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
3688 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
3691 (long) rel->r_offset,
3696 r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
3697 input_section, contents, rel,
3698 relocation, info, sec, name,
3699 (h ? ELF_ST_TYPE (h->type) :
3700 ELF_ST_TYPE (sym->st_info)), h,
3703 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3704 because such sections are not SEC_ALLOC and thus ld.so will
3705 not process them. */
3706 if (unresolved_reloc
3707 && !((input_section->flags & SEC_DEBUGGING) != 0
3710 (*_bfd_error_handler)
3711 (_("%B(%A+0x%lx): warning: unresolvable relocation %d against symbol `%s'"),
3712 input_bfd, input_section, (long) rel->r_offset,
3713 r_type, h->root.root.string);
3717 if (r != bfd_reloc_ok)
3719 const char * msg = (const char *) 0;
3723 case bfd_reloc_overflow:
3724 /* If the overflowing reloc was to an undefined symbol,
3725 we have already printed one error message and there
3726 is no point complaining again. */
3728 h->root.type != bfd_link_hash_undefined)
3729 && (!((*info->callbacks->reloc_overflow)
3730 (info, (h ? &h->root : NULL), name, howto->name,
3731 (bfd_vma) 0, input_bfd, input_section,
3736 case bfd_reloc_undefined:
3737 if (!((*info->callbacks->undefined_symbol)
3738 (info, name, input_bfd, input_section,
3739 rel->r_offset, TRUE)))
3743 case bfd_reloc_outofrange:
3744 msg = _("internal error: out of range error");
3747 case bfd_reloc_notsupported:
3748 msg = _("internal error: unsupported relocation error");
3751 case bfd_reloc_dangerous:
3752 msg = _("internal error: dangerous error");
3756 msg = _("internal error: unknown error");
3760 if (!((*info->callbacks->warning)
3761 (info, msg, name, input_bfd, input_section,
3772 /* Set the right machine number. */
3775 elf32_arm_object_p (bfd *abfd)
3779 mach = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
3781 if (mach != bfd_mach_arm_unknown)
3782 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
3784 else if (elf_elfheader (abfd)->e_flags & EF_ARM_MAVERICK_FLOAT)
3785 bfd_default_set_arch_mach (abfd, bfd_arch_arm, bfd_mach_arm_ep9312);
3788 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
3793 /* Function to keep ARM specific flags in the ELF header. */
3796 elf32_arm_set_private_flags (bfd *abfd, flagword flags)
3798 if (elf_flags_init (abfd)
3799 && elf_elfheader (abfd)->e_flags != flags)
3801 if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
3803 if (flags & EF_ARM_INTERWORK)
3804 (*_bfd_error_handler)
3805 (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
3809 (_("Warning: Clearing the interworking flag of %B due to outside request"),
3815 elf_elfheader (abfd)->e_flags = flags;
3816 elf_flags_init (abfd) = TRUE;
3822 /* Copy backend specific data from one object module to another. */
3825 elf32_arm_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
3830 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3831 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3834 in_flags = elf_elfheader (ibfd)->e_flags;
3835 out_flags = elf_elfheader (obfd)->e_flags;
3837 if (elf_flags_init (obfd)
3838 && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
3839 && in_flags != out_flags)
3841 /* Cannot mix APCS26 and APCS32 code. */
3842 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
3845 /* Cannot mix float APCS and non-float APCS code. */
3846 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
3849 /* If the src and dest have different interworking flags
3850 then turn off the interworking bit. */
3851 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
3853 if (out_flags & EF_ARM_INTERWORK)
3855 (_("Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
3858 in_flags &= ~EF_ARM_INTERWORK;
3861 /* Likewise for PIC, though don't warn for this case. */
3862 if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC))
3863 in_flags &= ~EF_ARM_PIC;
3866 elf_elfheader (obfd)->e_flags = in_flags;
3867 elf_flags_init (obfd) = TRUE;
3869 /* Also copy the EI_OSABI field. */
3870 elf_elfheader (obfd)->e_ident[EI_OSABI] =
3871 elf_elfheader (ibfd)->e_ident[EI_OSABI];
3876 /* Merge backend specific data from an object file to the output
3877 object file when linking. */
3880 elf32_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
3884 bfd_boolean flags_compatible = TRUE;
3887 /* Check if we have the same endianess. */
3888 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
3891 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3892 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3895 /* The input BFD must have had its flags initialised. */
3896 /* The following seems bogus to me -- The flags are initialized in
3897 the assembler but I don't think an elf_flags_init field is
3898 written into the object. */
3899 /* BFD_ASSERT (elf_flags_init (ibfd)); */
3901 in_flags = elf_elfheader (ibfd)->e_flags;
3902 out_flags = elf_elfheader (obfd)->e_flags;
3904 if (!elf_flags_init (obfd))
3906 /* If the input is the default architecture and had the default
3907 flags then do not bother setting the flags for the output
3908 architecture, instead allow future merges to do this. If no
3909 future merges ever set these flags then they will retain their
3910 uninitialised values, which surprise surprise, correspond
3911 to the default values. */
3912 if (bfd_get_arch_info (ibfd)->the_default
3913 && elf_elfheader (ibfd)->e_flags == 0)
3916 elf_flags_init (obfd) = TRUE;
3917 elf_elfheader (obfd)->e_flags = in_flags;
3919 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3920 && bfd_get_arch_info (obfd)->the_default)
3921 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
3926 /* Determine what should happen if the input ARM architecture
3927 does not match the output ARM architecture. */
3928 if (! bfd_arm_merge_machines (ibfd, obfd))
3931 /* Identical flags must be compatible. */
3932 if (in_flags == out_flags)
3935 /* Check to see if the input BFD actually contains any sections. If
3936 not, its flags may not have been initialised either, but it
3937 cannot actually cause any incompatibility. Do not short-circuit
3938 dynamic objects; their section list may be emptied by
3939 elf_link_add_object_symbols.
3941 Also check to see if there are no code sections in the input.
3942 In this case there is no need to check for code specific flags.
3943 XXX - do we need to worry about floating-point format compatability
3944 in data sections ? */
3945 if (!(ibfd->flags & DYNAMIC))
3947 bfd_boolean null_input_bfd = TRUE;
3948 bfd_boolean only_data_sections = TRUE;
3950 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
3952 /* Ignore synthetic glue sections. */
3953 if (strcmp (sec->name, ".glue_7")
3954 && strcmp (sec->name, ".glue_7t"))
3956 if ((bfd_get_section_flags (ibfd, sec)
3957 & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
3958 == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
3959 only_data_sections = FALSE;
3961 null_input_bfd = FALSE;
3966 if (null_input_bfd || only_data_sections)
3970 /* Complain about various flag mismatches. */
3971 if (EF_ARM_EABI_VERSION (in_flags) != EF_ARM_EABI_VERSION (out_flags))
3974 (_("ERROR: Source object %B has EABI version %d, but target %B has EABI version %d"),
3976 (in_flags & EF_ARM_EABIMASK) >> 24,
3977 (out_flags & EF_ARM_EABIMASK) >> 24);
3981 /* Not sure what needs to be checked for EABI versions >= 1. */
3982 if (EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
3984 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
3987 (_("ERROR: %B is compiled for APCS-%d, whereas target %B uses APCS-%d"),
3989 in_flags & EF_ARM_APCS_26 ? 26 : 32,
3990 out_flags & EF_ARM_APCS_26 ? 26 : 32);
3991 flags_compatible = FALSE;
3994 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
3996 if (in_flags & EF_ARM_APCS_FLOAT)
3998 (_("ERROR: %B passes floats in float registers, whereas %B passes them in integer registers"),
4002 (_("ERROR: %B passes floats in integer registers, whereas %B passes them in float registers"),
4005 flags_compatible = FALSE;
4008 if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT))
4010 if (in_flags & EF_ARM_VFP_FLOAT)
4012 (_("ERROR: %B uses VFP instructions, whereas %B does not"),
4016 (_("ERROR: %B uses FPA instructions, whereas %B does not"),
4019 flags_compatible = FALSE;
4022 if ((in_flags & EF_ARM_MAVERICK_FLOAT) != (out_flags & EF_ARM_MAVERICK_FLOAT))
4024 if (in_flags & EF_ARM_MAVERICK_FLOAT)
4026 (_("ERROR: %B uses Maverick instructions, whereas %B does not"),
4030 (_("ERROR: %B does not use Maverick instructions, whereas %B does"),
4033 flags_compatible = FALSE;
4036 #ifdef EF_ARM_SOFT_FLOAT
4037 if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
4039 /* We can allow interworking between code that is VFP format
4040 layout, and uses either soft float or integer regs for
4041 passing floating point arguments and results. We already
4042 know that the APCS_FLOAT flags match; similarly for VFP
4044 if ((in_flags & EF_ARM_APCS_FLOAT) != 0
4045 || (in_flags & EF_ARM_VFP_FLOAT) == 0)
4047 if (in_flags & EF_ARM_SOFT_FLOAT)
4049 (_("ERROR: %B uses software FP, whereas %B uses hardware FP"),
4053 (_("ERROR: %B uses hardware FP, whereas %B uses software FP"),
4056 flags_compatible = FALSE;
4061 /* Interworking mismatch is only a warning. */
4062 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
4064 if (in_flags & EF_ARM_INTERWORK)
4067 (_("Warning: %B supports interworking, whereas %B does not"),
4073 (_("Warning: %B does not support interworking, whereas %B does"),
4079 return flags_compatible;
4082 /* Display the flags field. */
4085 elf32_arm_print_private_bfd_data (bfd *abfd, void * ptr)
4087 FILE * file = (FILE *) ptr;
4088 unsigned long flags;
4090 BFD_ASSERT (abfd != NULL && ptr != NULL);
4092 /* Print normal ELF private data. */
4093 _bfd_elf_print_private_bfd_data (abfd, ptr);
4095 flags = elf_elfheader (abfd)->e_flags;
4096 /* Ignore init flag - it may not be set, despite the flags field
4097 containing valid data. */
4099 /* xgettext:c-format */
4100 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
4102 switch (EF_ARM_EABI_VERSION (flags))
4104 case EF_ARM_EABI_UNKNOWN:
4105 /* The following flag bits are GNU extensions and not part of the
4106 official ARM ELF extended ABI. Hence they are only decoded if
4107 the EABI version is not set. */
4108 if (flags & EF_ARM_INTERWORK)
4109 fprintf (file, _(" [interworking enabled]"));
4111 if (flags & EF_ARM_APCS_26)
4112 fprintf (file, " [APCS-26]");
4114 fprintf (file, " [APCS-32]");
4116 if (flags & EF_ARM_VFP_FLOAT)
4117 fprintf (file, _(" [VFP float format]"));
4118 else if (flags & EF_ARM_MAVERICK_FLOAT)
4119 fprintf (file, _(" [Maverick float format]"));
4121 fprintf (file, _(" [FPA float format]"));
4123 if (flags & EF_ARM_APCS_FLOAT)
4124 fprintf (file, _(" [floats passed in float registers]"));
4126 if (flags & EF_ARM_PIC)
4127 fprintf (file, _(" [position independent]"));
4129 if (flags & EF_ARM_NEW_ABI)
4130 fprintf (file, _(" [new ABI]"));
4132 if (flags & EF_ARM_OLD_ABI)
4133 fprintf (file, _(" [old ABI]"));
4135 if (flags & EF_ARM_SOFT_FLOAT)
4136 fprintf (file, _(" [software FP]"));
4138 flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT
4139 | EF_ARM_PIC | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI
4140 | EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT
4141 | EF_ARM_MAVERICK_FLOAT);
4144 case EF_ARM_EABI_VER1:
4145 fprintf (file, _(" [Version1 EABI]"));
4147 if (flags & EF_ARM_SYMSARESORTED)
4148 fprintf (file, _(" [sorted symbol table]"));
4150 fprintf (file, _(" [unsorted symbol table]"));
4152 flags &= ~ EF_ARM_SYMSARESORTED;
4155 case EF_ARM_EABI_VER2:
4156 fprintf (file, _(" [Version2 EABI]"));
4158 if (flags & EF_ARM_SYMSARESORTED)
4159 fprintf (file, _(" [sorted symbol table]"));
4161 fprintf (file, _(" [unsorted symbol table]"));
4163 if (flags & EF_ARM_DYNSYMSUSESEGIDX)
4164 fprintf (file, _(" [dynamic symbols use segment index]"));
4166 if (flags & EF_ARM_MAPSYMSFIRST)
4167 fprintf (file, _(" [mapping symbols precede others]"));
4169 flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX
4170 | EF_ARM_MAPSYMSFIRST);
4173 case EF_ARM_EABI_VER3:
4174 fprintf (file, _(" [Version3 EABI]"));
4177 case EF_ARM_EABI_VER4:
4178 fprintf (file, _(" [Version4 EABI]"));
4180 if (flags & EF_ARM_BE8)
4181 fprintf (file, _(" [BE8]"));
4183 if (flags & EF_ARM_LE8)
4184 fprintf (file, _(" [LE8]"));
4186 flags &= ~(EF_ARM_LE8 | EF_ARM_BE8);
4190 fprintf (file, _(" <EABI version unrecognised>"));
4194 flags &= ~ EF_ARM_EABIMASK;
4196 if (flags & EF_ARM_RELEXEC)
4197 fprintf (file, _(" [relocatable executable]"));
4199 if (flags & EF_ARM_HASENTRY)
4200 fprintf (file, _(" [has entry point]"));
4202 flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
4205 fprintf (file, _("<Unrecognised flag bits set>"));
4213 elf32_arm_get_symbol_type (Elf_Internal_Sym * elf_sym, int type)
4215 switch (ELF_ST_TYPE (elf_sym->st_info))
4218 return ELF_ST_TYPE (elf_sym->st_info);
4221 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
4222 This allows us to distinguish between data used by Thumb instructions
4223 and non-data (which is probably code) inside Thumb regions of an
4225 if (type != STT_OBJECT)
4226 return ELF_ST_TYPE (elf_sym->st_info);
4237 elf32_arm_gc_mark_hook (asection * sec,
4238 struct bfd_link_info * info ATTRIBUTE_UNUSED,
4239 Elf_Internal_Rela * rel,
4240 struct elf_link_hash_entry * h,
4241 Elf_Internal_Sym * sym)
4245 switch (ELF32_R_TYPE (rel->r_info))
4247 case R_ARM_GNU_VTINHERIT:
4248 case R_ARM_GNU_VTENTRY:
4252 switch (h->root.type)
4254 case bfd_link_hash_defined:
4255 case bfd_link_hash_defweak:
4256 return h->root.u.def.section;
4258 case bfd_link_hash_common:
4259 return h->root.u.c.p->section;
4267 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
4272 /* Update the got entry reference counts for the section being removed. */
4275 elf32_arm_gc_sweep_hook (bfd * abfd,
4276 struct bfd_link_info * info,
4278 const Elf_Internal_Rela * relocs)
4280 Elf_Internal_Shdr *symtab_hdr;
4281 struct elf_link_hash_entry **sym_hashes;
4282 bfd_signed_vma *local_got_refcounts;
4283 const Elf_Internal_Rela *rel, *relend;
4284 struct elf32_arm_link_hash_table * globals;
4286 globals = elf32_arm_hash_table (info);
4288 elf_section_data (sec)->local_dynrel = NULL;
4290 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4291 sym_hashes = elf_sym_hashes (abfd);
4292 local_got_refcounts = elf_local_got_refcounts (abfd);
4294 relend = relocs + sec->reloc_count;
4295 for (rel = relocs; rel < relend; rel++)
4297 unsigned long r_symndx;
4298 struct elf_link_hash_entry *h = NULL;
4301 r_symndx = ELF32_R_SYM (rel->r_info);
4302 if (r_symndx >= symtab_hdr->sh_info)
4304 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4305 while (h->root.type == bfd_link_hash_indirect
4306 || h->root.type == bfd_link_hash_warning)
4307 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4310 r_type = ELF32_R_TYPE (rel->r_info);
4312 r_type = arm_real_reloc_type (globals, r_type);
4318 case R_ARM_GOT_PREL:
4320 case R_ARM_TLS_GD32:
4321 case R_ARM_TLS_IE32:
4324 if (h->got.refcount > 0)
4325 h->got.refcount -= 1;
4327 else if (local_got_refcounts != NULL)
4329 if (local_got_refcounts[r_symndx] > 0)
4330 local_got_refcounts[r_symndx] -= 1;
4334 case R_ARM_TLS_LDM32:
4335 elf32_arm_hash_table (info)->tls_ldm_got.refcount -= 1;
4347 case R_ARM_THM_PC22:
4348 /* Should the interworking branches be here also? */
4352 struct elf32_arm_link_hash_entry *eh;
4353 struct elf32_arm_relocs_copied **pp;
4354 struct elf32_arm_relocs_copied *p;
4356 eh = (struct elf32_arm_link_hash_entry *) h;
4358 if (h->plt.refcount > 0)
4360 h->plt.refcount -= 1;
4361 if (ELF32_R_TYPE (rel->r_info) == R_ARM_THM_PC22)
4362 eh->plt_thumb_refcount--;
4365 if (r_type == R_ARM_ABS32
4366 || r_type == R_ARM_REL32)
4368 for (pp = &eh->relocs_copied; (p = *pp) != NULL;
4370 if (p->section == sec)
4373 if (ELF32_R_TYPE (rel->r_info) == R_ARM_REL32)
4391 /* Look through the relocs for a section during the first phase. */
4394 elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info,
4395 asection *sec, const Elf_Internal_Rela *relocs)
4397 Elf_Internal_Shdr *symtab_hdr;
4398 struct elf_link_hash_entry **sym_hashes;
4399 struct elf_link_hash_entry **sym_hashes_end;
4400 const Elf_Internal_Rela *rel;
4401 const Elf_Internal_Rela *rel_end;
4404 bfd_vma *local_got_offsets;
4405 struct elf32_arm_link_hash_table *htab;
4407 if (info->relocatable)
4410 htab = elf32_arm_hash_table (info);
4413 /* Create dynamic sections for relocatable executables so that we can
4414 copy relocations. */
4415 if (htab->root.is_relocatable_executable
4416 && ! htab->root.dynamic_sections_created)
4418 if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
4422 dynobj = elf_hash_table (info)->dynobj;
4423 local_got_offsets = elf_local_got_offsets (abfd);
4425 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4426 sym_hashes = elf_sym_hashes (abfd);
4427 sym_hashes_end = sym_hashes
4428 + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
4430 if (!elf_bad_symtab (abfd))
4431 sym_hashes_end -= symtab_hdr->sh_info;
4433 rel_end = relocs + sec->reloc_count;
4434 for (rel = relocs; rel < rel_end; rel++)
4436 struct elf_link_hash_entry *h;
4437 struct elf32_arm_link_hash_entry *eh;
4438 unsigned long r_symndx;
4441 r_symndx = ELF32_R_SYM (rel->r_info);
4442 r_type = ELF32_R_TYPE (rel->r_info);
4444 r_type = arm_real_reloc_type (htab, r_type);
4447 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
4449 (*_bfd_error_handler) (_("%B: bad symbol index: %d"), abfd,
4454 if (r_symndx < symtab_hdr->sh_info)
4457 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4459 eh = (struct elf32_arm_link_hash_entry *) h;
4465 case R_ARM_GOT_PREL:
4467 case R_ARM_TLS_GD32:
4468 case R_ARM_TLS_IE32:
4469 /* This symbol requires a global offset table entry. */
4471 int tls_type, old_tls_type;
4475 case R_ARM_TLS_GD32: tls_type = GOT_TLS_GD; break;
4476 case R_ARM_TLS_IE32: tls_type = GOT_TLS_IE; break;
4477 default: tls_type = GOT_NORMAL; break;
4483 old_tls_type = elf32_arm_hash_entry (h)->tls_type;
4487 bfd_signed_vma *local_got_refcounts;
4489 /* This is a global offset table entry for a local symbol. */
4490 local_got_refcounts = elf_local_got_refcounts (abfd);
4491 if (local_got_refcounts == NULL)
4495 size = symtab_hdr->sh_info;
4496 size *= (sizeof (bfd_signed_vma) + sizeof(char));
4497 local_got_refcounts = bfd_zalloc (abfd, size);
4498 if (local_got_refcounts == NULL)
4500 elf_local_got_refcounts (abfd) = local_got_refcounts;
4501 elf32_arm_local_got_tls_type (abfd)
4502 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
4504 local_got_refcounts[r_symndx] += 1;
4505 old_tls_type = elf32_arm_local_got_tls_type (abfd) [r_symndx];
4508 /* We will already have issued an error message if there is a
4509 TLS / non-TLS mismatch, based on the symbol type. We don't
4510 support any linker relaxations. So just combine any TLS
4512 if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
4513 && tls_type != GOT_NORMAL)
4514 tls_type |= old_tls_type;
4516 if (old_tls_type != tls_type)
4519 elf32_arm_hash_entry (h)->tls_type = tls_type;
4521 elf32_arm_local_got_tls_type (abfd) [r_symndx] = tls_type;
4526 case R_ARM_TLS_LDM32:
4527 if (r_type == R_ARM_TLS_LDM32)
4528 htab->tls_ldm_got.refcount++;
4533 if (htab->sgot == NULL)
4535 if (htab->root.dynobj == NULL)
4536 htab->root.dynobj = abfd;
4537 if (!create_got_section (htab->root.dynobj, info))
4551 case R_ARM_THM_PC22:
4552 /* Should the interworking branches be listed here? */
4555 /* If this reloc is in a read-only section, we might
4556 need a copy reloc. We can't check reliably at this
4557 stage whether the section is read-only, as input
4558 sections have not yet been mapped to output sections.
4559 Tentatively set the flag for now, and correct in
4560 adjust_dynamic_symbol. */
4564 /* We may need a .plt entry if the function this reloc
4565 refers to is in a different object. We can't tell for
4566 sure yet, because something later might force the
4568 if (r_type == R_ARM_PC24
4570 || r_type == R_ARM_CALL
4571 || r_type == R_ARM_JUMP24
4572 || r_type == R_ARM_PREL31
4574 || r_type == R_ARM_PLT32
4575 || r_type == R_ARM_THM_PC22)
4578 /* If we create a PLT entry, this relocation will reference
4579 it, even if it's an ABS32 relocation. */
4580 h->plt.refcount += 1;
4582 if (r_type == R_ARM_THM_PC22)
4583 eh->plt_thumb_refcount += 1;
4586 /* If we are creating a shared library or relocatable executable,
4587 and this is a reloc against a global symbol, or a non PC
4588 relative reloc against a local symbol, then we need to copy
4589 the reloc into the shared library. However, if we are linking
4590 with -Bsymbolic, we do not need to copy a reloc against a
4591 global symbol which is defined in an object we are
4592 including in the link (i.e., DEF_REGULAR is set). At
4593 this point we have not seen all the input files, so it is
4594 possible that DEF_REGULAR is not set now but will be set
4595 later (it is never cleared). We account for that
4596 possibility below by storing information in the
4597 relocs_copied field of the hash table entry. */
4598 if ((info->shared || htab->root.is_relocatable_executable)
4599 && (sec->flags & SEC_ALLOC) != 0
4600 && (r_type == R_ARM_ABS32
4601 || (h != NULL && ! h->needs_plt
4602 && (! info->symbolic || ! h->def_regular))))
4604 struct elf32_arm_relocs_copied *p, **head;
4606 /* When creating a shared object, we must copy these
4607 reloc types into the output file. We create a reloc
4608 section in dynobj and make room for this reloc. */
4613 name = (bfd_elf_string_from_elf_section
4615 elf_elfheader (abfd)->e_shstrndx,
4616 elf_section_data (sec)->rel_hdr.sh_name));
4620 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
4621 && strcmp (bfd_get_section_name (abfd, sec),
4624 sreloc = bfd_get_section_by_name (dynobj, name);
4629 sreloc = bfd_make_section (dynobj, name);
4630 flags = (SEC_HAS_CONTENTS | SEC_READONLY
4631 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4632 if ((sec->flags & SEC_ALLOC) != 0
4633 /* BPABI objects never have dynamic
4634 relocations mapped. */
4635 && !htab->symbian_p)
4636 flags |= SEC_ALLOC | SEC_LOAD;
4638 || ! bfd_set_section_flags (dynobj, sreloc, flags)
4639 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
4643 elf_section_data (sec)->sreloc = sreloc;
4646 /* If this is a global symbol, we count the number of
4647 relocations we need for this symbol. */
4650 head = &((struct elf32_arm_link_hash_entry *) h)->relocs_copied;
4654 /* Track dynamic relocs needed for local syms too.
4655 We really need local syms available to do this
4659 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
4664 head = ((struct elf32_arm_relocs_copied **)
4665 &elf_section_data (s)->local_dynrel);
4669 if (p == NULL || p->section != sec)
4671 bfd_size_type amt = sizeof *p;
4673 p = bfd_alloc (htab->root.dynobj, amt);
4683 if (r_type == R_ARM_REL32)
4689 /* This relocation describes the C++ object vtable hierarchy.
4690 Reconstruct it for later use during GC. */
4691 case R_ARM_GNU_VTINHERIT:
4692 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4696 /* This relocation describes which C++ vtable entries are actually
4697 used. Record for later use during GC. */
4698 case R_ARM_GNU_VTENTRY:
4699 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
4708 /* Treat mapping symbols as special target symbols. */
4711 elf32_arm_is_target_special_symbol (bfd * abfd ATTRIBUTE_UNUSED, asymbol * sym)
4713 return bfd_is_arm_mapping_symbol_name (sym->name);
4716 /* This is a copy of elf_find_function() from elf.c except that
4717 ARM mapping symbols are ignored when looking for function names
4718 and STT_ARM_TFUNC is considered to a function type. */
4721 arm_elf_find_function (bfd * abfd ATTRIBUTE_UNUSED,
4725 const char ** filename_ptr,
4726 const char ** functionname_ptr)
4728 const char * filename = NULL;
4729 asymbol * func = NULL;
4730 bfd_vma low_func = 0;
4733 for (p = symbols; *p != NULL; p++)
4737 q = (elf_symbol_type *) *p;
4739 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
4744 filename = bfd_asymbol_name (&q->symbol);
4749 /* Skip $a and $t symbols. */
4750 if ((q->symbol.flags & BSF_LOCAL)
4751 && bfd_is_arm_mapping_symbol_name (q->symbol.name))
4754 if (bfd_get_section (&q->symbol) == section
4755 && q->symbol.value >= low_func
4756 && q->symbol.value <= offset)
4758 func = (asymbol *) q;
4759 low_func = q->symbol.value;
4769 *filename_ptr = filename;
4770 if (functionname_ptr)
4771 *functionname_ptr = bfd_asymbol_name (func);
4777 /* Find the nearest line to a particular section and offset, for error
4778 reporting. This code is a duplicate of the code in elf.c, except
4779 that it uses arm_elf_find_function. */
4782 elf32_arm_find_nearest_line (bfd * abfd,
4786 const char ** filename_ptr,
4787 const char ** functionname_ptr,
4788 unsigned int * line_ptr)
4790 bfd_boolean found = FALSE;
4792 /* We skip _bfd_dwarf1_find_nearest_line since no known ARM toolchain uses it. */
4794 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
4795 filename_ptr, functionname_ptr,
4797 & elf_tdata (abfd)->dwarf2_find_line_info))
4799 if (!*functionname_ptr)
4800 arm_elf_find_function (abfd, section, symbols, offset,
4801 *filename_ptr ? NULL : filename_ptr,
4807 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
4808 & found, filename_ptr,
4809 functionname_ptr, line_ptr,
4810 & elf_tdata (abfd)->line_info))
4813 if (found && (*functionname_ptr || *line_ptr))
4816 if (symbols == NULL)
4819 if (! arm_elf_find_function (abfd, section, symbols, offset,
4820 filename_ptr, functionname_ptr))
4827 /* Adjust a symbol defined by a dynamic object and referenced by a
4828 regular object. The current definition is in some section of the
4829 dynamic object, but we're not including those sections. We have to
4830 change the definition to something the rest of the link can
4834 elf32_arm_adjust_dynamic_symbol (struct bfd_link_info * info,
4835 struct elf_link_hash_entry * h)
4839 unsigned int power_of_two;
4840 struct elf32_arm_link_hash_entry * eh;
4841 struct elf32_arm_link_hash_table *globals;
4843 globals = elf32_arm_hash_table (info);
4844 dynobj = elf_hash_table (info)->dynobj;
4846 /* Make sure we know what is going on here. */
4847 BFD_ASSERT (dynobj != NULL
4849 || h->u.weakdef != NULL
4852 && !h->def_regular)));
4854 eh = (struct elf32_arm_link_hash_entry *) h;
4856 /* If this is a function, put it in the procedure linkage table. We
4857 will fill in the contents of the procedure linkage table later,
4858 when we know the address of the .got section. */
4859 if (h->type == STT_FUNC || h->type == STT_ARM_TFUNC
4862 if (h->plt.refcount <= 0
4863 || SYMBOL_CALLS_LOCAL (info, h)
4864 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
4865 && h->root.type == bfd_link_hash_undefweak))
4867 /* This case can occur if we saw a PLT32 reloc in an input
4868 file, but the symbol was never referred to by a dynamic
4869 object, or if all references were garbage collected. In
4870 such a case, we don't actually need to build a procedure
4871 linkage table, and we can just do a PC24 reloc instead. */
4872 h->plt.offset = (bfd_vma) -1;
4873 eh->plt_thumb_refcount = 0;
4881 /* It's possible that we incorrectly decided a .plt reloc was
4882 needed for an R_ARM_PC24 or similar reloc to a non-function sym
4883 in check_relocs. We can't decide accurately between function
4884 and non-function syms in check-relocs; Objects loaded later in
4885 the link may change h->type. So fix it now. */
4886 h->plt.offset = (bfd_vma) -1;
4887 eh->plt_thumb_refcount = 0;
4890 /* If this is a weak symbol, and there is a real definition, the
4891 processor independent code will have arranged for us to see the
4892 real definition first, and we can just use the same value. */
4893 if (h->u.weakdef != NULL)
4895 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
4896 || h->u.weakdef->root.type == bfd_link_hash_defweak);
4897 h->root.u.def.section = h->u.weakdef->root.u.def.section;
4898 h->root.u.def.value = h->u.weakdef->root.u.def.value;
4902 /* If there are no non-GOT references, we do not need a copy
4904 if (!h->non_got_ref)
4907 /* This is a reference to a symbol defined by a dynamic object which
4908 is not a function. */
4910 /* If we are creating a shared library, we must presume that the
4911 only references to the symbol are via the global offset table.
4912 For such cases we need not do anything here; the relocations will
4913 be handled correctly by relocate_section. Relocatable executables
4914 can reference data in shared objects directly, so we don't need to
4915 do anything here. */
4916 if (info->shared || globals->root.is_relocatable_executable)
4919 /* We must allocate the symbol in our .dynbss section, which will
4920 become part of the .bss section of the executable. There will be
4921 an entry for this symbol in the .dynsym section. The dynamic
4922 object will contain position independent code, so all references
4923 from the dynamic object to this symbol will go through the global
4924 offset table. The dynamic linker will use the .dynsym entry to
4925 determine the address it must put in the global offset table, so
4926 both the dynamic object and the regular object will refer to the
4927 same memory location for the variable. */
4928 s = bfd_get_section_by_name (dynobj, ".dynbss");
4929 BFD_ASSERT (s != NULL);
4931 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
4932 copy the initial value out of the dynamic object and into the
4933 runtime process image. We need to remember the offset into the
4934 .rel.bss section we are going to use. */
4935 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
4939 srel = bfd_get_section_by_name (dynobj, ".rel.bss");
4940 BFD_ASSERT (srel != NULL);
4941 srel->size += sizeof (Elf32_External_Rel);
4945 /* We need to figure out the alignment required for this symbol. I
4946 have no idea how ELF linkers handle this. */
4947 power_of_two = bfd_log2 (h->size);
4948 if (power_of_two > 3)
4951 /* Apply the required alignment. */
4952 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
4953 if (power_of_two > bfd_get_section_alignment (dynobj, s))
4955 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
4959 /* Define the symbol as being at this point in the section. */
4960 h->root.u.def.section = s;
4961 h->root.u.def.value = s->size;
4963 /* Increment the section size to make room for the symbol. */
4969 /* Allocate space in .plt, .got and associated reloc sections for
4973 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
4975 struct bfd_link_info *info;
4976 struct elf32_arm_link_hash_table *htab;
4977 struct elf32_arm_link_hash_entry *eh;
4978 struct elf32_arm_relocs_copied *p;
4980 eh = (struct elf32_arm_link_hash_entry *) h;
4982 if (h->root.type == bfd_link_hash_indirect)
4985 if (h->root.type == bfd_link_hash_warning)
4986 /* When warning symbols are created, they **replace** the "real"
4987 entry in the hash table, thus we never get to see the real
4988 symbol in a hash traversal. So look at it now. */
4989 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4991 info = (struct bfd_link_info *) inf;
4992 htab = elf32_arm_hash_table (info);
4994 if (htab->root.dynamic_sections_created
4995 && h->plt.refcount > 0)
4997 /* Make sure this symbol is output as a dynamic symbol.
4998 Undefined weak syms won't yet be marked as dynamic. */
4999 if (h->dynindx == -1
5000 && !h->forced_local)
5002 if (! bfd_elf_link_record_dynamic_symbol (info, h))
5007 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
5009 asection *s = htab->splt;
5011 /* If this is the first .plt entry, make room for the special
5014 s->size += htab->plt_header_size;
5016 h->plt.offset = s->size;
5018 /* If we will insert a Thumb trampoline before this PLT, leave room
5020 if (!htab->symbian_p && eh->plt_thumb_refcount > 0)
5022 h->plt.offset += PLT_THUMB_STUB_SIZE;
5023 s->size += PLT_THUMB_STUB_SIZE;
5026 /* If this symbol is not defined in a regular file, and we are
5027 not generating a shared library, then set the symbol to this
5028 location in the .plt. This is required to make function
5029 pointers compare as equal between the normal executable and
5030 the shared library. */
5034 h->root.u.def.section = s;
5035 h->root.u.def.value = h->plt.offset;
5037 /* Make sure the function is not marked as Thumb, in case
5038 it is the target of an ABS32 relocation, which will
5039 point to the PLT entry. */
5040 if (ELF_ST_TYPE (h->type) == STT_ARM_TFUNC)
5041 h->type = ELF_ST_INFO (ELF_ST_BIND (h->type), STT_FUNC);
5044 /* Make room for this entry. */
5045 s->size += htab->plt_entry_size;
5047 if (!htab->symbian_p)
5049 /* We also need to make an entry in the .got.plt section, which
5050 will be placed in the .got section by the linker script. */
5051 eh->plt_got_offset = htab->sgotplt->size;
5052 htab->sgotplt->size += 4;
5055 /* We also need to make an entry in the .rel.plt section. */
5056 htab->srelplt->size += sizeof (Elf32_External_Rel);
5060 h->plt.offset = (bfd_vma) -1;
5066 h->plt.offset = (bfd_vma) -1;
5070 if (h->got.refcount > 0)
5074 int tls_type = elf32_arm_hash_entry (h)->tls_type;
5077 /* Make sure this symbol is output as a dynamic symbol.
5078 Undefined weak syms won't yet be marked as dynamic. */
5079 if (h->dynindx == -1
5080 && !h->forced_local)
5082 if (! bfd_elf_link_record_dynamic_symbol (info, h))
5086 if (!htab->symbian_p)
5089 h->got.offset = s->size;
5091 if (tls_type == GOT_UNKNOWN)
5094 if (tls_type == GOT_NORMAL)
5095 /* Non-TLS symbols need one GOT slot. */
5099 if (tls_type & GOT_TLS_GD)
5100 /* R_ARM_TLS_GD32 needs 2 consecutive GOT slots. */
5102 if (tls_type & GOT_TLS_IE)
5103 /* R_ARM_TLS_IE32 needs one GOT slot. */
5107 dyn = htab->root.dynamic_sections_created;
5110 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
5112 || !SYMBOL_REFERENCES_LOCAL (info, h)))
5115 if (tls_type != GOT_NORMAL
5116 && (info->shared || indx != 0)
5117 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5118 || h->root.type != bfd_link_hash_undefweak))
5120 if (tls_type & GOT_TLS_IE)
5121 htab->srelgot->size += sizeof (Elf32_External_Rel);
5123 if (tls_type & GOT_TLS_GD)
5124 htab->srelgot->size += sizeof (Elf32_External_Rel);
5126 if ((tls_type & GOT_TLS_GD) && indx != 0)
5127 htab->srelgot->size += sizeof (Elf32_External_Rel);
5129 else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5130 || h->root.type != bfd_link_hash_undefweak)
5132 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
5133 htab->srelgot->size += sizeof (Elf32_External_Rel);
5137 h->got.offset = (bfd_vma) -1;
5139 if (eh->relocs_copied == NULL)
5142 /* In the shared -Bsymbolic case, discard space allocated for
5143 dynamic pc-relative relocs against symbols which turn out to be
5144 defined in regular objects. For the normal shared case, discard
5145 space for pc-relative relocs that have become local due to symbol
5146 visibility changes. */
5148 if (info->shared || htab->root.is_relocatable_executable)
5150 /* The only reloc that uses pc_count is R_ARM_REL32, which will
5151 appear on something like ".long foo - .". We want calls to
5152 protected symbols to resolve directly to the function rather
5153 than going via the plt. If people want function pointer
5154 comparisons to work as expected then they should avoid
5155 writing assembly like ".long foo - .". */
5156 if (SYMBOL_CALLS_LOCAL (info, h))
5158 struct elf32_arm_relocs_copied **pp;
5160 for (pp = &eh->relocs_copied; (p = *pp) != NULL; )
5162 p->count -= p->pc_count;
5171 /* Also discard relocs on undefined weak syms with non-default
5173 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
5174 && h->root.type == bfd_link_hash_undefweak)
5175 eh->relocs_copied = NULL;
5176 else if (htab->root.is_relocatable_executable && h->dynindx == -1
5177 && h->root.type == bfd_link_hash_new)
5179 /* Output absolute symbols so that we can create relocations
5180 against them. For normal symbols we output a relocation
5181 against the section that contains them. */
5182 if (! bfd_elf_link_record_dynamic_symbol (info, h))
5189 /* For the non-shared case, discard space for relocs against
5190 symbols which turn out to need copy relocs or are not
5196 || (htab->root.dynamic_sections_created
5197 && (h->root.type == bfd_link_hash_undefweak
5198 || h->root.type == bfd_link_hash_undefined))))
5200 /* Make sure this symbol is output as a dynamic symbol.
5201 Undefined weak syms won't yet be marked as dynamic. */
5202 if (h->dynindx == -1
5203 && !h->forced_local)
5205 if (! bfd_elf_link_record_dynamic_symbol (info, h))
5209 /* If that succeeded, we know we'll be keeping all the
5211 if (h->dynindx != -1)
5215 eh->relocs_copied = NULL;
5220 /* Finally, allocate space. */
5221 for (p = eh->relocs_copied; p != NULL; p = p->next)
5223 asection *sreloc = elf_section_data (p->section)->sreloc;
5224 sreloc->size += p->count * sizeof (Elf32_External_Rel);
5230 /* Find any dynamic relocs that apply to read-only sections. */
5233 elf32_arm_readonly_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
5235 struct elf32_arm_link_hash_entry *eh;
5236 struct elf32_arm_relocs_copied *p;
5238 if (h->root.type == bfd_link_hash_warning)
5239 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5241 eh = (struct elf32_arm_link_hash_entry *) h;
5242 for (p = eh->relocs_copied; p != NULL; p = p->next)
5244 asection *s = p->section;
5246 if (s != NULL && (s->flags & SEC_READONLY) != 0)
5248 struct bfd_link_info *info = (struct bfd_link_info *) inf;
5250 info->flags |= DF_TEXTREL;
5252 /* Not an error, just cut short the traversal. */
5259 /* Set the sizes of the dynamic sections. */
5262 elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
5263 struct bfd_link_info * info)
5270 struct elf32_arm_link_hash_table *htab;
5272 htab = elf32_arm_hash_table (info);
5273 dynobj = elf_hash_table (info)->dynobj;
5274 BFD_ASSERT (dynobj != NULL);
5276 if (elf_hash_table (info)->dynamic_sections_created)
5278 /* Set the contents of the .interp section to the interpreter. */
5279 if (info->executable)
5281 s = bfd_get_section_by_name (dynobj, ".interp");
5282 BFD_ASSERT (s != NULL);
5283 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
5284 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
5288 /* Set up .got offsets for local syms, and space for local dynamic
5290 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
5292 bfd_signed_vma *local_got;
5293 bfd_signed_vma *end_local_got;
5294 char *local_tls_type;
5295 bfd_size_type locsymcount;
5296 Elf_Internal_Shdr *symtab_hdr;
5299 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
5302 for (s = ibfd->sections; s != NULL; s = s->next)
5304 struct elf32_arm_relocs_copied *p;
5306 for (p = *((struct elf32_arm_relocs_copied **)
5307 &elf_section_data (s)->local_dynrel);
5311 if (!bfd_is_abs_section (p->section)
5312 && bfd_is_abs_section (p->section->output_section))
5314 /* Input section has been discarded, either because
5315 it is a copy of a linkonce section or due to
5316 linker script /DISCARD/, so we'll be discarding
5319 else if (p->count != 0)
5321 srel = elf_section_data (p->section)->sreloc;
5322 srel->size += p->count * sizeof (Elf32_External_Rel);
5323 if ((p->section->output_section->flags & SEC_READONLY) != 0)
5324 info->flags |= DF_TEXTREL;
5329 local_got = elf_local_got_refcounts (ibfd);
5333 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
5334 locsymcount = symtab_hdr->sh_info;
5335 end_local_got = local_got + locsymcount;
5336 local_tls_type = elf32_arm_local_got_tls_type (ibfd);
5338 srel = htab->srelgot;
5339 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
5343 *local_got = s->size;
5344 if (*local_tls_type & GOT_TLS_GD)
5345 /* TLS_GD relocs need an 8-byte structure in the GOT. */
5347 if (*local_tls_type & GOT_TLS_IE)
5349 if (*local_tls_type == GOT_NORMAL)
5352 if (info->shared || *local_tls_type == GOT_TLS_GD)
5353 srel->size += sizeof (Elf32_External_Rel);
5356 *local_got = (bfd_vma) -1;
5360 if (htab->tls_ldm_got.refcount > 0)
5362 /* Allocate two GOT entries and one dynamic relocation (if necessary)
5363 for R_ARM_TLS_LDM32 relocations. */
5364 htab->tls_ldm_got.offset = htab->sgot->size;
5365 htab->sgot->size += 8;
5367 htab->srelgot->size += sizeof (Elf32_External_Rel);
5370 htab->tls_ldm_got.offset = -1;
5372 /* Allocate global sym .plt and .got entries, and space for global
5373 sym dynamic relocs. */
5374 elf_link_hash_traverse (& htab->root, allocate_dynrelocs, info);
5376 /* The check_relocs and adjust_dynamic_symbol entry points have
5377 determined the sizes of the various dynamic sections. Allocate
5381 for (s = dynobj->sections; s != NULL; s = s->next)
5386 if ((s->flags & SEC_LINKER_CREATED) == 0)
5389 /* It's OK to base decisions on the section name, because none
5390 of the dynobj section names depend upon the input files. */
5391 name = bfd_get_section_name (dynobj, s);
5395 if (strcmp (name, ".plt") == 0)
5399 /* Strip this section if we don't need it; see the
5405 /* Remember whether there is a PLT. */
5409 else if (strncmp (name, ".rel", 4) == 0)
5413 /* If we don't need this section, strip it from the
5414 output file. This is mostly to handle .rel.bss and
5415 .rel.plt. We must create both sections in
5416 create_dynamic_sections, because they must be created
5417 before the linker maps input sections to output
5418 sections. The linker does that before
5419 adjust_dynamic_symbol is called, and it is that
5420 function which decides whether anything needs to go
5421 into these sections. */
5426 /* Remember whether there are any reloc sections other
5428 if (strcmp (name, ".rel.plt") != 0)
5431 /* We use the reloc_count field as a counter if we need
5432 to copy relocs into the output file. */
5436 else if (strncmp (name, ".got", 4) != 0)
5438 /* It's not one of our sections, so don't allocate space. */
5444 _bfd_strip_section_from_output (info, s);
5448 /* Allocate memory for the section contents. */
5449 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
5450 if (s->contents == NULL && s->size != 0)
5454 if (elf_hash_table (info)->dynamic_sections_created)
5456 /* Add some entries to the .dynamic section. We fill in the
5457 values later, in elf32_arm_finish_dynamic_sections, but we
5458 must add the entries now so that we get the correct size for
5459 the .dynamic section. The DT_DEBUG entry is filled in by the
5460 dynamic linker and used by the debugger. */
5461 #define add_dynamic_entry(TAG, VAL) \
5462 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
5466 if (!add_dynamic_entry (DT_DEBUG, 0))
5472 if ( !add_dynamic_entry (DT_PLTGOT, 0)
5473 || !add_dynamic_entry (DT_PLTRELSZ, 0)
5474 || !add_dynamic_entry (DT_PLTREL, DT_REL)
5475 || !add_dynamic_entry (DT_JMPREL, 0))
5481 if ( !add_dynamic_entry (DT_REL, 0)
5482 || !add_dynamic_entry (DT_RELSZ, 0)
5483 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
5487 /* If any dynamic relocs apply to a read-only section,
5488 then we need a DT_TEXTREL entry. */
5489 if ((info->flags & DF_TEXTREL) == 0)
5490 elf_link_hash_traverse (&htab->root, elf32_arm_readonly_dynrelocs,
5493 if ((info->flags & DF_TEXTREL) != 0)
5495 if (!add_dynamic_entry (DT_TEXTREL, 0))
5497 info->flags |= DF_TEXTREL;
5500 #undef add_synamic_entry
5505 /* Finish up dynamic symbol handling. We set the contents of various
5506 dynamic sections here. */
5509 elf32_arm_finish_dynamic_symbol (bfd * output_bfd, struct bfd_link_info * info,
5510 struct elf_link_hash_entry * h, Elf_Internal_Sym * sym)
5513 struct elf32_arm_link_hash_table *htab;
5514 struct elf32_arm_link_hash_entry *eh;
5516 dynobj = elf_hash_table (info)->dynobj;
5517 htab = elf32_arm_hash_table (info);
5518 eh = (struct elf32_arm_link_hash_entry *) h;
5520 if (h->plt.offset != (bfd_vma) -1)
5526 Elf_Internal_Rela rel;
5528 /* This symbol has an entry in the procedure linkage table. Set
5531 BFD_ASSERT (h->dynindx != -1);
5533 splt = bfd_get_section_by_name (dynobj, ".plt");
5534 srel = bfd_get_section_by_name (dynobj, ".rel.plt");
5535 BFD_ASSERT (splt != NULL && srel != NULL);
5537 /* Fill in the entry in the procedure linkage table. */
5538 if (htab->symbian_p)
5541 for (i = 0; i < htab->plt_entry_size / 4; ++i)
5542 bfd_put_32 (output_bfd,
5543 elf32_arm_symbian_plt_entry[i],
5544 splt->contents + h->plt.offset + 4 * i);
5546 /* Fill in the entry in the .rel.plt section. */
5547 rel.r_offset = (splt->output_section->vma
5548 + splt->output_offset
5549 + h->plt.offset + 4 * (i - 1));
5550 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
5552 /* Get the index in the procedure linkage table which
5553 corresponds to this symbol. This is the index of this symbol
5554 in all the symbols for which we are making plt entries. The
5555 first entry in the procedure linkage table is reserved. */
5556 plt_index = ((h->plt.offset - htab->plt_header_size)
5557 / htab->plt_entry_size);
5562 bfd_vma got_displacement;
5565 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
5566 BFD_ASSERT (sgot != NULL);
5568 /* Get the offset into the .got.plt table of the entry that
5569 corresponds to this function. */
5570 got_offset = eh->plt_got_offset;
5572 /* Get the index in the procedure linkage table which
5573 corresponds to this symbol. This is the index of this symbol
5574 in all the symbols for which we are making plt entries. The
5575 first three entries in .got.plt are reserved; after that
5576 symbols appear in the same order as in .plt. */
5577 plt_index = (got_offset - 12) / 4;
5579 /* Calculate the displacement between the PLT slot and the
5580 entry in the GOT. The eight-byte offset accounts for the
5581 value produced by adding to pc in the first instruction
5583 got_displacement = (sgot->output_section->vma
5584 + sgot->output_offset
5586 - splt->output_section->vma
5587 - splt->output_offset
5591 BFD_ASSERT ((got_displacement & 0xf0000000) == 0);
5593 if (eh->plt_thumb_refcount > 0)
5595 bfd_put_16 (output_bfd, elf32_arm_plt_thumb_stub[0],
5596 splt->contents + h->plt.offset - 4);
5597 bfd_put_16 (output_bfd, elf32_arm_plt_thumb_stub[1],
5598 splt->contents + h->plt.offset - 2);
5601 bfd_put_32 (output_bfd, elf32_arm_plt_entry[0] | ((got_displacement & 0x0ff00000) >> 20),
5602 splt->contents + h->plt.offset + 0);
5603 bfd_put_32 (output_bfd, elf32_arm_plt_entry[1] | ((got_displacement & 0x000ff000) >> 12),
5604 splt->contents + h->plt.offset + 4);
5605 bfd_put_32 (output_bfd, elf32_arm_plt_entry[2] | (got_displacement & 0x00000fff),
5606 splt->contents + h->plt.offset + 8);
5607 #ifdef FOUR_WORD_PLT
5608 bfd_put_32 (output_bfd, elf32_arm_plt_entry[3],
5609 splt->contents + h->plt.offset + 12);
5612 /* Fill in the entry in the global offset table. */
5613 bfd_put_32 (output_bfd,
5614 (splt->output_section->vma
5615 + splt->output_offset),
5616 sgot->contents + got_offset);
5618 /* Fill in the entry in the .rel.plt section. */
5619 rel.r_offset = (sgot->output_section->vma
5620 + sgot->output_offset
5622 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
5625 loc = srel->contents + plt_index * sizeof (Elf32_External_Rel);
5626 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
5628 if (!h->def_regular)
5630 /* Mark the symbol as undefined, rather than as defined in
5631 the .plt section. Leave the value alone. */
5632 sym->st_shndx = SHN_UNDEF;
5633 /* If the symbol is weak, we do need to clear the value.
5634 Otherwise, the PLT entry would provide a definition for
5635 the symbol even if the symbol wasn't defined anywhere,
5636 and so the symbol would never be NULL. */
5637 if (!h->ref_regular_nonweak)
5642 if (h->got.offset != (bfd_vma) -1
5643 && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_GD) == 0
5644 && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_IE) == 0)
5648 Elf_Internal_Rela rel;
5651 /* This symbol has an entry in the global offset table. Set it
5653 sgot = bfd_get_section_by_name (dynobj, ".got");
5654 srel = bfd_get_section_by_name (dynobj, ".rel.got");
5655 BFD_ASSERT (sgot != NULL && srel != NULL);
5657 rel.r_offset = (sgot->output_section->vma
5658 + sgot->output_offset
5659 + (h->got.offset &~ (bfd_vma) 1));
5661 /* If this is a static link, or it is a -Bsymbolic link and the
5662 symbol is defined locally or was forced to be local because
5663 of a version file, we just want to emit a RELATIVE reloc.
5664 The entry in the global offset table will already have been
5665 initialized in the relocate_section function. */
5667 && SYMBOL_REFERENCES_LOCAL (info, h))
5669 BFD_ASSERT((h->got.offset & 1) != 0);
5670 rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
5674 BFD_ASSERT((h->got.offset & 1) == 0);
5675 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
5676 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
5679 loc = srel->contents + srel->reloc_count++ * sizeof (Elf32_External_Rel);
5680 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
5686 Elf_Internal_Rela rel;
5689 /* This symbol needs a copy reloc. Set it up. */
5690 BFD_ASSERT (h->dynindx != -1
5691 && (h->root.type == bfd_link_hash_defined
5692 || h->root.type == bfd_link_hash_defweak));
5694 s = bfd_get_section_by_name (h->root.u.def.section->owner,
5696 BFD_ASSERT (s != NULL);
5698 rel.r_offset = (h->root.u.def.value
5699 + h->root.u.def.section->output_section->vma
5700 + h->root.u.def.section->output_offset);
5701 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
5702 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rel);
5703 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
5706 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
5707 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
5708 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
5709 sym->st_shndx = SHN_ABS;
5714 /* Finish up the dynamic sections. */
5717 elf32_arm_finish_dynamic_sections (bfd * output_bfd, struct bfd_link_info * info)
5723 dynobj = elf_hash_table (info)->dynobj;
5725 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
5726 BFD_ASSERT (elf32_arm_hash_table (info)->symbian_p || sgot != NULL);
5727 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
5729 if (elf_hash_table (info)->dynamic_sections_created)
5732 Elf32_External_Dyn *dyncon, *dynconend;
5733 struct elf32_arm_link_hash_table *htab;
5735 htab = elf32_arm_hash_table (info);
5736 splt = bfd_get_section_by_name (dynobj, ".plt");
5737 BFD_ASSERT (splt != NULL && sdyn != NULL);
5739 dyncon = (Elf32_External_Dyn *) sdyn->contents;
5740 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5742 for (; dyncon < dynconend; dyncon++)
5744 Elf_Internal_Dyn dyn;
5748 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5759 goto get_vma_if_bpabi;
5762 goto get_vma_if_bpabi;
5765 goto get_vma_if_bpabi;
5767 name = ".gnu.version";
5768 goto get_vma_if_bpabi;
5770 name = ".gnu.version_d";
5771 goto get_vma_if_bpabi;
5773 name = ".gnu.version_r";
5774 goto get_vma_if_bpabi;
5782 s = bfd_get_section_by_name (output_bfd, name);
5783 BFD_ASSERT (s != NULL);
5784 if (!htab->symbian_p)
5785 dyn.d_un.d_ptr = s->vma;
5787 /* In the BPABI, tags in the PT_DYNAMIC section point
5788 at the file offset, not the memory address, for the
5789 convenience of the post linker. */
5790 dyn.d_un.d_ptr = s->filepos;
5791 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5795 if (htab->symbian_p)
5800 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
5801 BFD_ASSERT (s != NULL);
5802 dyn.d_un.d_val = s->size;
5803 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5807 if (!htab->symbian_p)
5809 /* My reading of the SVR4 ABI indicates that the
5810 procedure linkage table relocs (DT_JMPREL) should be
5811 included in the overall relocs (DT_REL). This is
5812 what Solaris does. However, UnixWare can not handle
5813 that case. Therefore, we override the DT_RELSZ entry
5814 here to make it not include the JMPREL relocs. Since
5815 the linker script arranges for .rel.plt to follow all
5816 other relocation sections, we don't have to worry
5817 about changing the DT_REL entry. */
5818 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
5820 dyn.d_un.d_val -= s->size;
5821 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5829 /* In the BPABI, the DT_REL tag must point at the file
5830 offset, not the VMA, of the first relocation
5831 section. So, we use code similar to that in
5832 elflink.c, but do not check for SHF_ALLOC on the
5833 relcoation section, since relocations sections are
5834 never allocated under the BPABI. The comments above
5835 about Unixware notwithstanding, we include all of the
5836 relocations here. */
5837 if (htab->symbian_p)
5840 type = ((dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
5841 ? SHT_REL : SHT_RELA);
5843 for (i = 1; i < elf_numsections (output_bfd); i++)
5845 Elf_Internal_Shdr *hdr
5846 = elf_elfsections (output_bfd)[i];
5847 if (hdr->sh_type == type)
5849 if (dyn.d_tag == DT_RELSZ
5850 || dyn.d_tag == DT_RELASZ)
5851 dyn.d_un.d_val += hdr->sh_size;
5852 else if ((ufile_ptr) hdr->sh_offset
5853 <= dyn.d_un.d_val - 1)
5854 dyn.d_un.d_val = hdr->sh_offset;
5857 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5861 /* Set the bottom bit of DT_INIT/FINI if the
5862 corresponding function is Thumb. */
5864 name = info->init_function;
5867 name = info->fini_function;
5869 /* If it wasn't set by elf_bfd_final_link
5870 then there is nothing to adjust. */
5871 if (dyn.d_un.d_val != 0)
5873 struct elf_link_hash_entry * eh;
5875 eh = elf_link_hash_lookup (elf_hash_table (info), name,
5876 FALSE, FALSE, TRUE);
5877 if (eh != (struct elf_link_hash_entry *) NULL
5878 && ELF_ST_TYPE (eh->type) == STT_ARM_TFUNC)
5880 dyn.d_un.d_val |= 1;
5881 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5888 /* Fill in the first entry in the procedure linkage table. */
5889 if (splt->size > 0 && elf32_arm_hash_table (info)->plt_header_size)
5891 bfd_vma got_displacement;
5893 /* Calculate the displacement between the PLT slot and &GOT[0]. */
5894 got_displacement = (sgot->output_section->vma
5895 + sgot->output_offset
5896 - splt->output_section->vma
5897 - splt->output_offset
5900 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[0], splt->contents + 0);
5901 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[1], splt->contents + 4);
5902 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[2], splt->contents + 8);
5903 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[3], splt->contents + 12);
5904 #ifdef FOUR_WORD_PLT
5905 /* The displacement value goes in the otherwise-unused last word of
5906 the second entry. */
5907 bfd_put_32 (output_bfd, got_displacement, splt->contents + 28);
5909 bfd_put_32 (output_bfd, got_displacement, splt->contents + 16);
5913 /* UnixWare sets the entsize of .plt to 4, although that doesn't
5914 really seem like the right value. */
5915 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
5918 /* Fill in the first three entries in the global offset table. */
5924 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
5926 bfd_put_32 (output_bfd,
5927 sdyn->output_section->vma + sdyn->output_offset,
5929 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
5930 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
5933 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
5940 elf32_arm_post_process_headers (bfd * abfd, struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
5942 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
5943 struct elf32_arm_link_hash_table *globals;
5945 i_ehdrp = elf_elfheader (abfd);
5947 if (EF_ARM_EABI_VERSION (i_ehdrp->e_flags) == EF_ARM_EABI_UNKNOWN)
5948 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_ARM;
5950 i_ehdrp->e_ident[EI_OSABI] = 0;
5951 i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
5955 globals = elf32_arm_hash_table (link_info);
5956 if (globals->byteswap_code)
5957 i_ehdrp->e_flags |= EF_ARM_BE8;
5961 static enum elf_reloc_type_class
5962 elf32_arm_reloc_type_class (const Elf_Internal_Rela *rela)
5964 switch ((int) ELF32_R_TYPE (rela->r_info))
5966 case R_ARM_RELATIVE:
5967 return reloc_class_relative;
5968 case R_ARM_JUMP_SLOT:
5969 return reloc_class_plt;
5971 return reloc_class_copy;
5973 return reloc_class_normal;
5977 /* Set the right machine number for an Arm ELF file. */
5980 elf32_arm_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
5982 if (hdr->sh_type == SHT_NOTE)
5983 *flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_CONTENTS;
5989 elf32_arm_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
5991 bfd_arm_update_notes (abfd, ARM_NOTE_SECTION);
5994 /* Return TRUE if this is an unwinding table entry. */
5997 is_arm_elf_unwind_section_name (bfd * abfd ATTRIBUTE_UNUSED, const char * name)
6001 len1 = sizeof (ELF_STRING_ARM_unwind) - 1;
6002 len2 = sizeof (ELF_STRING_ARM_unwind_once) - 1;
6003 return (strncmp (name, ELF_STRING_ARM_unwind, len1) == 0
6004 || strncmp (name, ELF_STRING_ARM_unwind_once, len2) == 0);
6008 /* Set the type and flags for an ARM section. We do this by
6009 the section name, which is a hack, but ought to work. */
6012 elf32_arm_fake_sections (bfd * abfd, Elf_Internal_Shdr * hdr, asection * sec)
6016 name = bfd_get_section_name (abfd, sec);
6018 if (is_arm_elf_unwind_section_name (abfd, name))
6020 hdr->sh_type = SHT_ARM_EXIDX;
6021 hdr->sh_flags |= SHF_LINK_ORDER;
6026 /* Handle an ARM specific section when reading an object file. This is
6027 called when bfd_section_from_shdr finds a section with an unknown
6031 elf32_arm_section_from_shdr (bfd *abfd,
6032 Elf_Internal_Shdr * hdr,
6036 /* There ought to be a place to keep ELF backend specific flags, but
6037 at the moment there isn't one. We just keep track of the
6038 sections by their name, instead. Fortunately, the ABI gives
6039 names for all the ARM specific sections, so we will probably get
6041 switch (hdr->sh_type)
6050 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
6056 /* Called for each symbol. Builds a section map based on mapping symbols.
6057 Does not alter any of the symbols. */
6060 elf32_arm_output_symbol_hook (struct bfd_link_info *info,
6062 Elf_Internal_Sym *elfsym,
6063 asection *input_sec,
6064 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
6067 elf32_arm_section_map *map;
6068 struct elf32_arm_link_hash_table *globals;
6070 /* Only do this on final link. */
6071 if (info->relocatable)
6074 /* Only build a map if we need to byteswap code. */
6075 globals = elf32_arm_hash_table (info);
6076 if (!globals->byteswap_code)
6079 /* We only want mapping symbols. */
6080 if (! bfd_is_arm_mapping_symbol_name (name))
6083 mapcount = ++(elf32_arm_section_data (input_sec)->mapcount);
6084 map = elf32_arm_section_data (input_sec)->map;
6085 /* TODO: This may be inefficient, but we probably don't usually have many
6086 mapping symbols per section. */
6087 map = bfd_realloc (map, mapcount * sizeof (elf32_arm_section_map));
6088 elf32_arm_section_data (input_sec)->map = map;
6090 map[mapcount - 1].vma = elfsym->st_value;
6091 map[mapcount - 1].type = name[1];
6096 /* Allocate target specific section data. */
6099 elf32_arm_new_section_hook (bfd *abfd, asection *sec)
6101 struct _arm_elf_section_data *sdata;
6102 bfd_size_type amt = sizeof (*sdata);
6104 sdata = bfd_zalloc (abfd, amt);
6107 sec->used_by_bfd = sdata;
6109 return _bfd_elf_new_section_hook (abfd, sec);
6113 /* Used to order a list of mapping symbols by address. */
6116 elf32_arm_compare_mapping (const void * a, const void * b)
6118 return ((const elf32_arm_section_map *) a)->vma
6119 > ((const elf32_arm_section_map *) b)->vma;
6123 /* Do code byteswapping. Return FALSE afterwards so that the section is
6124 written out as normal. */
6127 elf32_arm_write_section (bfd *output_bfd ATTRIBUTE_UNUSED, asection *sec,
6131 elf32_arm_section_map *map;
6138 mapcount = elf32_arm_section_data (sec)->mapcount;
6139 map = elf32_arm_section_data (sec)->map;
6144 qsort (map, mapcount, sizeof (elf32_arm_section_map),
6145 elf32_arm_compare_mapping);
6147 offset = sec->output_section->vma + sec->output_offset;
6148 ptr = map[0].vma - offset;
6149 for (i = 0; i < mapcount; i++)
6151 if (i == mapcount - 1)
6154 end = map[i + 1].vma - offset;
6156 switch (map[i].type)
6159 /* Byte swap code words. */
6160 while (ptr + 3 < end)
6162 tmp = contents[ptr];
6163 contents[ptr] = contents[ptr + 3];
6164 contents[ptr + 3] = tmp;
6165 tmp = contents[ptr + 1];
6166 contents[ptr + 1] = contents[ptr + 2];
6167 contents[ptr + 2] = tmp;
6173 /* Byte swap code halfwords. */
6174 while (ptr + 1 < end)
6176 tmp = contents[ptr];
6177 contents[ptr] = contents[ptr + 1];
6178 contents[ptr + 1] = tmp;
6184 /* Leave data alone. */
6193 /* Display STT_ARM_TFUNC symbols as functions. */
6196 elf32_arm_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
6199 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
6201 if (ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_ARM_TFUNC)
6202 elfsym->symbol.flags |= BSF_FUNCTION;
6206 /* Mangle thumb function symbols as we read them in. */
6209 elf32_arm_swap_symbol_in (bfd * abfd,
6212 Elf_Internal_Sym *dst)
6214 bfd_elf32_swap_symbol_in (abfd, psrc, pshn, dst);
6216 /* New EABI objects mark thumb function symbols by setting the low bit of
6217 the address. Turn these into STT_ARM_TFUNC. */
6218 if (ELF_ST_TYPE (dst->st_info) == STT_FUNC
6219 && (dst->st_value & 1))
6221 dst->st_info = ELF_ST_INFO (ELF_ST_BIND (dst->st_info), STT_ARM_TFUNC);
6222 dst->st_value &= ~(bfd_vma) 1;
6227 /* Mangle thumb function symbols as we write them out. */
6230 elf32_arm_swap_symbol_out (bfd *abfd,
6231 const Elf_Internal_Sym *src,
6235 Elf_Internal_Sym newsym;
6237 /* We convert STT_ARM_TFUNC symbols into STT_FUNC with the low bit
6238 of the address set, as per the new EABI. We do this unconditionally
6239 because objcopy does not set the elf header flags until after
6240 it writes out the symbol table. */
6241 if (ELF_ST_TYPE (src->st_info) == STT_ARM_TFUNC)
6244 newsym.st_info = ELF_ST_INFO (ELF_ST_BIND (src->st_info), STT_FUNC);
6245 newsym.st_value |= 1;
6249 bfd_elf32_swap_symbol_out (abfd, src, cdst, shndx);
6252 /* Add the PT_ARM_EXIDX program header. */
6255 elf32_arm_modify_segment_map (bfd *abfd,
6256 struct bfd_link_info *info ATTRIBUTE_UNUSED)
6258 struct elf_segment_map *m;
6261 sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
6262 if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
6264 /* If there is already a PT_ARM_EXIDX header, then we do not
6265 want to add another one. This situation arises when running
6266 "strip"; the input binary already has the header. */
6267 m = elf_tdata (abfd)->segment_map;
6268 while (m && m->p_type != PT_ARM_EXIDX)
6272 m = bfd_zalloc (abfd, sizeof (struct elf_segment_map));
6275 m->p_type = PT_ARM_EXIDX;
6277 m->sections[0] = sec;
6279 m->next = elf_tdata (abfd)->segment_map;
6280 elf_tdata (abfd)->segment_map = m;
6287 /* We may add a PT_ARM_EXIDX program header. */
6290 elf32_arm_additional_program_headers (bfd *abfd)
6294 sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
6295 if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
6301 /* We use this to override swap_symbol_in and swap_symbol_out. */
6302 const struct elf_size_info elf32_arm_size_info = {
6303 sizeof (Elf32_External_Ehdr),
6304 sizeof (Elf32_External_Phdr),
6305 sizeof (Elf32_External_Shdr),
6306 sizeof (Elf32_External_Rel),
6307 sizeof (Elf32_External_Rela),
6308 sizeof (Elf32_External_Sym),
6309 sizeof (Elf32_External_Dyn),
6310 sizeof (Elf_External_Note),
6314 ELFCLASS32, EV_CURRENT,
6315 bfd_elf32_write_out_phdrs,
6316 bfd_elf32_write_shdrs_and_ehdr,
6317 bfd_elf32_write_relocs,
6318 elf32_arm_swap_symbol_in,
6319 elf32_arm_swap_symbol_out,
6320 bfd_elf32_slurp_reloc_table,
6321 bfd_elf32_slurp_symbol_table,
6322 bfd_elf32_swap_dyn_in,
6323 bfd_elf32_swap_dyn_out,
6324 bfd_elf32_swap_reloc_in,
6325 bfd_elf32_swap_reloc_out,
6326 bfd_elf32_swap_reloca_in,
6327 bfd_elf32_swap_reloca_out
6330 #define ELF_ARCH bfd_arch_arm
6331 #define ELF_MACHINE_CODE EM_ARM
6332 #ifdef __QNXTARGET__
6333 #define ELF_MAXPAGESIZE 0x1000
6335 #define ELF_MAXPAGESIZE 0x8000
6337 #define ELF_MINPAGESIZE 0x1000
6339 #define bfd_elf32_mkobject elf32_arm_mkobject
6341 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
6342 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
6343 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
6344 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
6345 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
6346 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
6347 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
6348 #define bfd_elf32_new_section_hook elf32_arm_new_section_hook
6349 #define bfd_elf32_bfd_is_target_special_symbol elf32_arm_is_target_special_symbol
6351 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
6352 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
6353 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
6354 #define elf_backend_check_relocs elf32_arm_check_relocs
6355 #define elf_backend_relocate_section elf32_arm_relocate_section
6356 #define elf_backend_write_section elf32_arm_write_section
6357 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
6358 #define elf_backend_create_dynamic_sections elf32_arm_create_dynamic_sections
6359 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
6360 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
6361 #define elf_backend_link_output_symbol_hook elf32_arm_output_symbol_hook
6362 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
6363 #define elf_backend_post_process_headers elf32_arm_post_process_headers
6364 #define elf_backend_reloc_type_class elf32_arm_reloc_type_class
6365 #define elf_backend_object_p elf32_arm_object_p
6366 #define elf_backend_section_flags elf32_arm_section_flags
6367 #define elf_backend_fake_sections elf32_arm_fake_sections
6368 #define elf_backend_section_from_shdr elf32_arm_section_from_shdr
6369 #define elf_backend_final_write_processing elf32_arm_final_write_processing
6370 #define elf_backend_copy_indirect_symbol elf32_arm_copy_indirect_symbol
6371 #define elf_backend_symbol_processing elf32_arm_symbol_processing
6372 #define elf_backend_size_info elf32_arm_size_info
6373 #define elf_backend_modify_segment_map elf32_arm_modify_segment_map
6374 #define elf_backend_additional_program_headers \
6375 elf32_arm_additional_program_headers
6377 #define elf_backend_can_refcount 1
6378 #define elf_backend_can_gc_sections 1
6379 #define elf_backend_plt_readonly 1
6380 #define elf_backend_want_got_plt 1
6381 #define elf_backend_want_plt_sym 0
6382 #define elf_backend_may_use_rel_p 1
6383 #define elf_backend_may_use_rela_p 0
6384 #define elf_backend_default_use_rela_p 0
6385 #define elf_backend_rela_normal 0
6387 #define elf_backend_got_header_size 12
6389 #include "elf32-target.h"
6391 /* VxWorks Targets */
6393 #undef TARGET_LITTLE_SYM
6394 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_vxworks_vec
6395 #undef TARGET_LITTLE_NAME
6396 #define TARGET_LITTLE_NAME "elf32-littlearm-vxworks"
6397 #undef TARGET_BIG_SYM
6398 #define TARGET_BIG_SYM bfd_elf32_bigarm_vxworks_vec
6399 #undef TARGET_BIG_NAME
6400 #define TARGET_BIG_NAME "elf32-bigarm-vxworks"
6402 /* Like elf32_arm_link_hash_table_create -- but overrides
6403 appropriately for VxWorks. */
6404 static struct bfd_link_hash_table *
6405 elf32_arm_vxworks_link_hash_table_create (bfd *abfd)
6407 struct bfd_link_hash_table *ret;
6409 ret = elf32_arm_link_hash_table_create (abfd);
6412 struct elf32_arm_link_hash_table *htab
6413 = (struct elf32_arm_link_hash_table *)ret;
6420 #define elf32_bed elf32_arm_vxworks_bed
6422 #undef bfd_elf32_bfd_link_hash_table_create
6423 #define bfd_elf32_bfd_link_hash_table_create \
6424 elf32_arm_vxworks_link_hash_table_create
6426 #undef elf_backend_may_use_rel_p
6427 #define elf_backend_may_use_rel_p 0
6428 #undef elf_backend_may_use_rela_p
6429 #define elf_backend_may_use_rela_p 1
6430 #undef elf_backend_default_use_rela_p
6431 #define elf_backend_default_use_rela_p 1
6432 #undef elf_backend_rela_normal
6433 #define elf_backend_rela_normal 1
6435 #include "elf32-target.h"
6438 /* Symbian OS Targets */
6440 #undef TARGET_LITTLE_SYM
6441 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_symbian_vec
6442 #undef TARGET_LITTLE_NAME
6443 #define TARGET_LITTLE_NAME "elf32-littlearm-symbian"
6444 #undef TARGET_BIG_SYM
6445 #define TARGET_BIG_SYM bfd_elf32_bigarm_symbian_vec
6446 #undef TARGET_BIG_NAME
6447 #define TARGET_BIG_NAME "elf32-bigarm-symbian"
6449 /* Like elf32_arm_link_hash_table_create -- but overrides
6450 appropriately for Symbian OS. */
6451 static struct bfd_link_hash_table *
6452 elf32_arm_symbian_link_hash_table_create (bfd *abfd)
6454 struct bfd_link_hash_table *ret;
6456 ret = elf32_arm_link_hash_table_create (abfd);
6459 struct elf32_arm_link_hash_table *htab
6460 = (struct elf32_arm_link_hash_table *)ret;
6461 /* There is no PLT header for Symbian OS. */
6462 htab->plt_header_size = 0;
6463 /* The PLT entries are each three instructions. */
6464 htab->plt_entry_size = 4 * NUM_ELEM (elf32_arm_symbian_plt_entry);
6465 htab->symbian_p = 1;
6466 htab->root.is_relocatable_executable = 1;
6471 static struct bfd_elf_special_section const
6472 elf32_arm_symbian_special_sections[]=
6474 /* In a BPABI executable, the dynamic linking sections do not go in
6475 the loadable read-only segment. The post-linker may wish to
6476 refer to these sections, but they are not part of the final
6478 { ".dynamic", 8, 0, SHT_DYNAMIC, 0 },
6479 { ".dynstr", 7, 0, SHT_STRTAB, 0 },
6480 { ".dynsym", 7, 0, SHT_DYNSYM, 0 },
6481 { ".got", 4, 0, SHT_PROGBITS, 0 },
6482 { ".hash", 5, 0, SHT_HASH, 0 },
6483 /* These sections do not need to be writable as the SymbianOS
6484 postlinker will arrange things so that no dynamic relocation is
6486 { ".init_array", 11, 0, SHT_INIT_ARRAY, SHF_ALLOC },
6487 { ".fini_array", 11, 0, SHT_FINI_ARRAY, SHF_ALLOC },
6488 { ".preinit_array", 14, 0, SHT_PREINIT_ARRAY, SHF_ALLOC },
6489 { NULL, 0, 0, 0, 0 }
6493 elf32_arm_symbian_begin_write_processing (bfd *abfd,
6494 struct bfd_link_info *link_info
6497 /* BPABI objects are never loaded directly by an OS kernel; they are
6498 processed by a postlinker first, into an OS-specific format. If
6499 the D_PAGED bit is set on the file, BFD will align segments on
6500 page boundaries, so that an OS can directly map the file. With
6501 BPABI objects, that just results in wasted space. In addition,
6502 because we clear the D_PAGED bit, map_sections_to_segments will
6503 recognize that the program headers should not be mapped into any
6504 loadable segment. */
6505 abfd->flags &= ~D_PAGED;
6509 elf32_arm_symbian_modify_segment_map (bfd *abfd,
6510 struct bfd_link_info *info)
6512 struct elf_segment_map *m;
6515 /* BPABI shared libraries and executables should have a PT_DYNAMIC
6516 segment. However, because the .dynamic section is not marked
6517 with SEC_LOAD, the generic ELF code will not create such a
6519 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
6522 m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
6523 m->next = elf_tdata (abfd)->segment_map;
6524 elf_tdata (abfd)->segment_map = m;
6527 /* Also call the generic arm routine. */
6528 return elf32_arm_modify_segment_map (abfd, info);
6532 #define elf32_bed elf32_arm_symbian_bed
6534 /* The dynamic sections are not allocated on SymbianOS; the postlinker
6535 will process them and then discard them. */
6536 #undef ELF_DYNAMIC_SEC_FLAGS
6537 #define ELF_DYNAMIC_SEC_FLAGS \
6538 (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED)
6540 #undef bfd_elf32_bfd_link_hash_table_create
6541 #define bfd_elf32_bfd_link_hash_table_create \
6542 elf32_arm_symbian_link_hash_table_create
6544 #undef elf_backend_special_sections
6545 #define elf_backend_special_sections elf32_arm_symbian_special_sections
6547 #undef elf_backend_begin_write_processing
6548 #define elf_backend_begin_write_processing \
6549 elf32_arm_symbian_begin_write_processing
6551 #undef elf_backend_modify_segment_map
6552 #define elf_backend_modify_segment_map elf32_arm_symbian_modify_segment_map
6554 /* There is no .got section for BPABI objects, and hence no header. */
6555 #undef elf_backend_got_header_size
6556 #define elf_backend_got_header_size 0
6558 /* Similarly, there is no .got.plt section. */
6559 #undef elf_backend_want_got_plt
6560 #define elf_backend_want_got_plt 0
6562 #undef elf_backend_may_use_rel_p
6563 #define elf_backend_may_use_rel_p 1
6564 #undef elf_backend_may_use_rela_p
6565 #define elf_backend_may_use_rela_p 0
6566 #undef elf_backend_default_use_rela_p
6567 #define elf_backend_default_use_rela_p 0
6568 #undef elf_backend_rela_normal
6569 #define elf_backend_rela_normal 0
6571 #include "elf32-target.h"
projects / external / binutils.git / blob