1 /* 32-bit ELF support for ARM
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004
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. */
25 typedef unsigned long int insn32
;
26 typedef unsigned short int insn16
;
28 /* In leiu of proper flags, assume all EABIv3 objects are interworkable. */
29 #define INTERWORK_FLAG(abfd) \
30 (EF_ARM_EABI_VERSION (elf_elfheader (abfd)->e_flags) == EF_ARM_EABI_VER3 \
31 || (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK))
33 /* The linker script knows the section names for placement.
34 The entry_names are used to do simple name mangling on the stubs.
35 Given a function name, and its type, the stub can be found. The
36 name can be changed. The only requirement is the %s be present. */
37 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
38 #define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
40 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
41 #define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
43 /* The name of the dynamic interpreter. This is put in the .interp
45 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
49 /* The size in bytes of the special first entry in the procedure
51 #define PLT_HEADER_SIZE 16
53 /* The size in bytes of an entry in the procedure linkage table. */
54 #define PLT_ENTRY_SIZE 16
56 /* The first entry in a procedure linkage table looks like
57 this. It is set up so that any shared library function that is
58 called before the relocation has been set up calls the dynamic
60 static const bfd_vma elf32_arm_plt0_entry
[PLT_HEADER_SIZE
/ 4] =
62 0xe52de004, /* str lr, [sp, #-4]! */
63 0xe59fe010, /* ldr lr, [pc, #16] */
64 0xe08fe00e, /* add lr, pc, lr */
65 0xe5bef008, /* ldr pc, [lr, #8]! */
68 /* Subsequent entries in a procedure linkage table look like
70 static const bfd_vma elf32_arm_plt_entry
[PLT_ENTRY_SIZE
/ 4] =
72 0xe28fc600, /* add ip, pc, #NN */
73 0xe28cca00, /* add ip, ip, #NN */
74 0xe5bcf000, /* ldr pc, [ip, #NN]! */
75 0x00000000, /* unused */
80 /* The size in bytes of the special first entry in the procedure
82 #define PLT_HEADER_SIZE 20
84 /* The size in bytes of an entry in the procedure linkage table. */
85 #define PLT_ENTRY_SIZE 12
87 /* The first entry in a procedure linkage table looks like
88 this. It is set up so that any shared library function that is
89 called before the relocation has been set up calls the dynamic
91 static const bfd_vma elf32_arm_plt0_entry
[PLT_HEADER_SIZE
/ 4] =
93 0xe52de004, /* str lr, [sp, #-4]! */
94 0xe59fe004, /* ldr lr, [pc, #4] */
95 0xe08fe00e, /* add lr, pc, lr */
96 0xe5bef008, /* ldr pc, [lr, #8]! */
97 0x00000000, /* &GOT[0] - . */
100 /* Subsequent entries in a procedure linkage table look like
102 static const bfd_vma elf32_arm_plt_entry
[PLT_ENTRY_SIZE
/ 4] =
104 0xe28fc600, /* add ip, pc, #0xNN00000 */
105 0xe28cca00, /* add ip, ip, #0xNN000 */
106 0xe5bcf000, /* ldr pc, [ip, #0xNNN]! */
111 /* Used to build a map of a section. This is required for mixed-endian
114 typedef struct elf32_elf_section_map
119 elf32_arm_section_map
;
121 struct _arm_elf_section_data
123 struct bfd_elf_section_data elf
;
125 elf32_arm_section_map
*map
;
128 #define elf32_arm_section_data(sec) \
129 ((struct _arm_elf_section_data *) elf_section_data (sec))
131 /* The ARM linker needs to keep track of the number of relocs that it
132 decides to copy in check_relocs for each symbol. This is so that
133 it can discard PC relative relocs if it doesn't need them when
134 linking with -Bsymbolic. We store the information in a field
135 extending the regular ELF linker hash table. */
137 /* This structure keeps track of the number of PC relative relocs we
138 have copied for a given symbol. */
139 struct elf32_arm_relocs_copied
142 struct elf32_arm_relocs_copied
* next
;
143 /* A section in dynobj. */
145 /* Number of relocs copied in this section. */
149 /* Arm ELF linker hash entry. */
150 struct elf32_arm_link_hash_entry
152 struct elf_link_hash_entry root
;
154 /* Number of PC relative relocs copied for this symbol. */
155 struct elf32_arm_relocs_copied
* relocs_copied
;
158 /* Traverse an arm ELF linker hash table. */
159 #define elf32_arm_link_hash_traverse(table, func, info) \
160 (elf_link_hash_traverse \
162 (bfd_boolean (*) (struct elf_link_hash_entry *, void *))) (func), \
165 /* Get the ARM elf linker hash table from a link_info structure. */
166 #define elf32_arm_hash_table(info) \
167 ((struct elf32_arm_link_hash_table *) ((info)->hash))
169 /* ARM ELF linker hash table. */
170 struct elf32_arm_link_hash_table
172 /* The main hash table. */
173 struct elf_link_hash_table root
;
175 /* The size in bytes of the section containing the Thumb-to-ARM glue. */
176 bfd_size_type thumb_glue_size
;
178 /* The size in bytes of the section containing the ARM-to-Thumb glue. */
179 bfd_size_type arm_glue_size
;
181 /* An arbitrary input BFD chosen to hold the glue sections. */
182 bfd
* bfd_of_glue_owner
;
184 /* A boolean indicating whether knowledge of the ARM's pipeline
185 length should be applied by the linker. */
186 int no_pipeline_knowledge
;
188 /* Nonzero to output a BE8 image. */
191 /* Short-cuts to get to dynamic linker sections. */
200 /* Small local sym to section mapping cache. */
201 struct sym_sec_cache sym_sec
;
204 /* Create an entry in an ARM ELF linker hash table. */
206 static struct bfd_hash_entry
*
207 elf32_arm_link_hash_newfunc (struct bfd_hash_entry
* entry
,
208 struct bfd_hash_table
* table
,
211 struct elf32_arm_link_hash_entry
* ret
=
212 (struct elf32_arm_link_hash_entry
*) entry
;
214 /* Allocate the structure if it has not already been allocated by a
216 if (ret
== (struct elf32_arm_link_hash_entry
*) NULL
)
217 ret
= bfd_hash_allocate (table
, sizeof (struct elf32_arm_link_hash_entry
));
219 return (struct bfd_hash_entry
*) ret
;
221 /* Call the allocation method of the superclass. */
222 ret
= ((struct elf32_arm_link_hash_entry
*)
223 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
226 ret
->relocs_copied
= NULL
;
228 return (struct bfd_hash_entry
*) ret
;
231 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
232 shortcuts to them in our hash table. */
235 create_got_section (bfd
*dynobj
, struct bfd_link_info
*info
)
237 struct elf32_arm_link_hash_table
*htab
;
239 if (! _bfd_elf_create_got_section (dynobj
, info
))
242 htab
= elf32_arm_hash_table (info
);
243 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
244 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
245 if (!htab
->sgot
|| !htab
->sgotplt
)
248 htab
->srelgot
= bfd_make_section (dynobj
, ".rel.got");
249 if (htab
->srelgot
== NULL
250 || ! bfd_set_section_flags (dynobj
, htab
->srelgot
,
251 (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
252 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
254 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 2))
259 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
260 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
264 elf32_arm_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
266 struct elf32_arm_link_hash_table
*htab
;
268 htab
= elf32_arm_hash_table (info
);
269 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
272 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
275 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
276 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rel.plt");
277 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
279 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rel.bss");
281 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
282 || (!info
->shared
&& !htab
->srelbss
))
288 /* Copy the extra info we tack onto an elf_link_hash_entry. */
291 elf32_arm_copy_indirect_symbol (const struct elf_backend_data
*bed
,
292 struct elf_link_hash_entry
*dir
,
293 struct elf_link_hash_entry
*ind
)
295 struct elf32_arm_link_hash_entry
*edir
, *eind
;
297 edir
= (struct elf32_arm_link_hash_entry
*) dir
;
298 eind
= (struct elf32_arm_link_hash_entry
*) ind
;
300 if (eind
->relocs_copied
!= NULL
)
302 if (edir
->relocs_copied
!= NULL
)
304 struct elf32_arm_relocs_copied
**pp
;
305 struct elf32_arm_relocs_copied
*p
;
307 if (ind
->root
.type
== bfd_link_hash_indirect
)
310 /* Add reloc counts against the weak sym to the strong sym
311 list. Merge any entries against the same section. */
312 for (pp
= &eind
->relocs_copied
; (p
= *pp
) != NULL
; )
314 struct elf32_arm_relocs_copied
*q
;
316 for (q
= edir
->relocs_copied
; q
!= NULL
; q
= q
->next
)
317 if (q
->section
== p
->section
)
319 q
->count
+= p
->count
;
326 *pp
= edir
->relocs_copied
;
329 edir
->relocs_copied
= eind
->relocs_copied
;
330 eind
->relocs_copied
= NULL
;
333 _bfd_elf_link_hash_copy_indirect (bed
, dir
, ind
);
336 /* Create an ARM elf linker hash table. */
338 static struct bfd_link_hash_table
*
339 elf32_arm_link_hash_table_create (bfd
*abfd
)
341 struct elf32_arm_link_hash_table
*ret
;
342 bfd_size_type amt
= sizeof (struct elf32_arm_link_hash_table
);
344 ret
= bfd_malloc (amt
);
348 if (!_bfd_elf_link_hash_table_init (& ret
->root
, abfd
,
349 elf32_arm_link_hash_newfunc
))
362 ret
->thumb_glue_size
= 0;
363 ret
->arm_glue_size
= 0;
364 ret
->bfd_of_glue_owner
= NULL
;
365 ret
->no_pipeline_knowledge
= 0;
366 ret
->byteswap_code
= 0;
367 ret
->sym_sec
.abfd
= NULL
;
369 return &ret
->root
.root
;
372 /* Locate the Thumb encoded calling stub for NAME. */
374 static struct elf_link_hash_entry
*
375 find_thumb_glue (struct bfd_link_info
*link_info
,
380 struct elf_link_hash_entry
*hash
;
381 struct elf32_arm_link_hash_table
*hash_table
;
383 /* We need a pointer to the armelf specific hash table. */
384 hash_table
= elf32_arm_hash_table (link_info
);
386 tmp_name
= bfd_malloc ((bfd_size_type
) strlen (name
)
387 + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1);
389 BFD_ASSERT (tmp_name
);
391 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
393 hash
= elf_link_hash_lookup
394 (&(hash_table
)->root
, tmp_name
, FALSE
, FALSE
, TRUE
);
397 /* xgettext:c-format */
398 (*_bfd_error_handler
) (_("%B: unable to find THUMB glue '%s' for `%s'"),
399 input_bfd
, tmp_name
, name
);
406 /* Locate the ARM encoded calling stub for NAME. */
408 static struct elf_link_hash_entry
*
409 find_arm_glue (struct bfd_link_info
*link_info
,
414 struct elf_link_hash_entry
*myh
;
415 struct elf32_arm_link_hash_table
*hash_table
;
417 /* We need a pointer to the elfarm specific hash table. */
418 hash_table
= elf32_arm_hash_table (link_info
);
420 tmp_name
= bfd_malloc ((bfd_size_type
) strlen (name
)
421 + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1);
423 BFD_ASSERT (tmp_name
);
425 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
427 myh
= elf_link_hash_lookup
428 (&(hash_table
)->root
, tmp_name
, FALSE
, FALSE
, TRUE
);
431 /* xgettext:c-format */
432 (*_bfd_error_handler
) (_("%B: unable to find ARM glue '%s' for `%s'"),
433 input_bfd
, tmp_name
, name
);
447 .word func @ behave as if you saw a ARM_32 reloc. */
449 #define ARM2THUMB_GLUE_SIZE 12
450 static const insn32 a2t1_ldr_insn
= 0xe59fc000;
451 static const insn32 a2t2_bx_r12_insn
= 0xe12fff1c;
452 static const insn32 a2t3_func_addr_insn
= 0x00000001;
454 /* Thumb->ARM: Thumb->(non-interworking aware) ARM
458 __func_from_thumb: __func_from_thumb:
460 nop ldr r6, __func_addr
462 __func_change_to_arm: bx r6
464 __func_back_to_thumb:
470 #define THUMB2ARM_GLUE_SIZE 8
471 static const insn16 t2a1_bx_pc_insn
= 0x4778;
472 static const insn16 t2a2_noop_insn
= 0x46c0;
473 static const insn32 t2a3_b_insn
= 0xea000000;
475 #ifndef ELFARM_NABI_C_INCLUDED
477 bfd_elf32_arm_allocate_interworking_sections (struct bfd_link_info
* info
)
481 struct elf32_arm_link_hash_table
* globals
;
483 globals
= elf32_arm_hash_table (info
);
485 BFD_ASSERT (globals
!= NULL
);
487 if (globals
->arm_glue_size
!= 0)
489 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
491 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
492 ARM2THUMB_GLUE_SECTION_NAME
);
494 BFD_ASSERT (s
!= NULL
);
496 foo
= bfd_alloc (globals
->bfd_of_glue_owner
, globals
->arm_glue_size
);
498 s
->size
= globals
->arm_glue_size
;
502 if (globals
->thumb_glue_size
!= 0)
504 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
506 s
= bfd_get_section_by_name
507 (globals
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
509 BFD_ASSERT (s
!= NULL
);
511 foo
= bfd_alloc (globals
->bfd_of_glue_owner
, globals
->thumb_glue_size
);
513 s
->size
= globals
->thumb_glue_size
;
521 record_arm_to_thumb_glue (struct bfd_link_info
* link_info
,
522 struct elf_link_hash_entry
* h
)
524 const char * name
= h
->root
.root
.string
;
527 struct elf_link_hash_entry
* myh
;
528 struct bfd_link_hash_entry
* bh
;
529 struct elf32_arm_link_hash_table
* globals
;
532 globals
= elf32_arm_hash_table (link_info
);
534 BFD_ASSERT (globals
!= NULL
);
535 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
537 s
= bfd_get_section_by_name
538 (globals
->bfd_of_glue_owner
, ARM2THUMB_GLUE_SECTION_NAME
);
540 BFD_ASSERT (s
!= NULL
);
542 tmp_name
= bfd_malloc ((bfd_size_type
) strlen (name
) + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1);
544 BFD_ASSERT (tmp_name
);
546 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
548 myh
= elf_link_hash_lookup
549 (&(globals
)->root
, tmp_name
, FALSE
, FALSE
, TRUE
);
553 /* We've already seen this guy. */
558 /* The only trick here is using hash_table->arm_glue_size as the value.
559 Even though the section isn't allocated yet, this is where we will be
562 val
= globals
->arm_glue_size
+ 1;
563 _bfd_generic_link_add_one_symbol (link_info
, globals
->bfd_of_glue_owner
,
564 tmp_name
, BSF_GLOBAL
, s
, val
,
565 NULL
, TRUE
, FALSE
, &bh
);
569 globals
->arm_glue_size
+= ARM2THUMB_GLUE_SIZE
;
575 record_thumb_to_arm_glue (struct bfd_link_info
*link_info
,
576 struct elf_link_hash_entry
*h
)
578 const char *name
= h
->root
.root
.string
;
581 struct elf_link_hash_entry
*myh
;
582 struct bfd_link_hash_entry
*bh
;
583 struct elf32_arm_link_hash_table
*hash_table
;
587 hash_table
= elf32_arm_hash_table (link_info
);
589 BFD_ASSERT (hash_table
!= NULL
);
590 BFD_ASSERT (hash_table
->bfd_of_glue_owner
!= NULL
);
592 s
= bfd_get_section_by_name
593 (hash_table
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
595 BFD_ASSERT (s
!= NULL
);
597 tmp_name
= bfd_malloc ((bfd_size_type
) strlen (name
)
598 + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1);
600 BFD_ASSERT (tmp_name
);
602 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
604 myh
= elf_link_hash_lookup
605 (&(hash_table
)->root
, tmp_name
, FALSE
, FALSE
, TRUE
);
609 /* We've already seen this guy. */
615 val
= hash_table
->thumb_glue_size
+ 1;
616 _bfd_generic_link_add_one_symbol (link_info
, hash_table
->bfd_of_glue_owner
,
617 tmp_name
, BSF_GLOBAL
, s
, val
,
618 NULL
, TRUE
, FALSE
, &bh
);
620 /* If we mark it 'Thumb', the disassembler will do a better job. */
621 myh
= (struct elf_link_hash_entry
*) bh
;
622 bind
= ELF_ST_BIND (myh
->type
);
623 myh
->type
= ELF_ST_INFO (bind
, STT_ARM_TFUNC
);
627 #define CHANGE_TO_ARM "__%s_change_to_arm"
628 #define BACK_FROM_ARM "__%s_back_from_arm"
630 /* Allocate another symbol to mark where we switch to Arm mode. */
631 tmp_name
= bfd_malloc ((bfd_size_type
) strlen (name
)
632 + strlen (CHANGE_TO_ARM
) + 1);
634 BFD_ASSERT (tmp_name
);
636 sprintf (tmp_name
, CHANGE_TO_ARM
, name
);
639 val
= hash_table
->thumb_glue_size
+ 4,
640 _bfd_generic_link_add_one_symbol (link_info
, hash_table
->bfd_of_glue_owner
,
641 tmp_name
, BSF_LOCAL
, s
, val
,
642 NULL
, TRUE
, FALSE
, &bh
);
646 hash_table
->thumb_glue_size
+= THUMB2ARM_GLUE_SIZE
;
651 /* Add the glue sections to ABFD. This function is called from the
652 linker scripts in ld/emultempl/{armelf}.em. */
655 bfd_elf32_arm_add_glue_sections_to_bfd (bfd
*abfd
,
656 struct bfd_link_info
*info
)
661 /* If we are only performing a partial
662 link do not bother adding the glue. */
663 if (info
->relocatable
)
666 sec
= bfd_get_section_by_name (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
670 /* Note: we do not include the flag SEC_LINKER_CREATED, as this
671 will prevent elf_link_input_bfd() from processing the contents
673 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_CODE
| SEC_READONLY
;
675 sec
= bfd_make_section (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
678 || !bfd_set_section_flags (abfd
, sec
, flags
)
679 || !bfd_set_section_alignment (abfd
, sec
, 2))
682 /* Set the gc mark to prevent the section from being removed by garbage
683 collection, despite the fact that no relocs refer to this section. */
687 sec
= bfd_get_section_by_name (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
691 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
692 | SEC_CODE
| SEC_READONLY
;
694 sec
= bfd_make_section (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
697 || !bfd_set_section_flags (abfd
, sec
, flags
)
698 || !bfd_set_section_alignment (abfd
, sec
, 2))
707 /* Select a BFD to be used to hold the sections used by the glue code.
708 This function is called from the linker scripts in ld/emultempl/
712 bfd_elf32_arm_get_bfd_for_interworking (bfd
*abfd
, struct bfd_link_info
*info
)
714 struct elf32_arm_link_hash_table
*globals
;
716 /* If we are only performing a partial link
717 do not bother getting a bfd to hold the glue. */
718 if (info
->relocatable
)
721 globals
= elf32_arm_hash_table (info
);
723 BFD_ASSERT (globals
!= NULL
);
725 if (globals
->bfd_of_glue_owner
!= NULL
)
728 /* Save the bfd for later use. */
729 globals
->bfd_of_glue_owner
= abfd
;
735 bfd_elf32_arm_process_before_allocation (bfd
*abfd
,
736 struct bfd_link_info
*link_info
,
737 int no_pipeline_knowledge
,
740 Elf_Internal_Shdr
*symtab_hdr
;
741 Elf_Internal_Rela
*internal_relocs
= NULL
;
742 Elf_Internal_Rela
*irel
, *irelend
;
743 bfd_byte
*contents
= NULL
;
746 struct elf32_arm_link_hash_table
*globals
;
748 /* If we are only performing a partial link do not bother
749 to construct any glue. */
750 if (link_info
->relocatable
)
753 /* Here we have a bfd that is to be included on the link. We have a hook
754 to do reloc rummaging, before section sizes are nailed down. */
755 globals
= elf32_arm_hash_table (link_info
);
757 BFD_ASSERT (globals
!= NULL
);
758 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
760 globals
->no_pipeline_knowledge
= no_pipeline_knowledge
;
761 if (byteswap_code
&& !bfd_big_endian (abfd
))
763 _bfd_error_handler (_("%B: BE8 images only valid in big-endian mode."),
767 globals
->byteswap_code
= byteswap_code
;
769 /* Rummage around all the relocs and map the glue vectors. */
770 sec
= abfd
->sections
;
775 for (; sec
!= NULL
; sec
= sec
->next
)
777 if (sec
->reloc_count
== 0)
780 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
782 /* Load the relocs. */
784 = _bfd_elf_link_read_relocs (abfd
, sec
, (void *) NULL
,
785 (Elf_Internal_Rela
*) NULL
, FALSE
);
787 if (internal_relocs
== NULL
)
790 irelend
= internal_relocs
+ sec
->reloc_count
;
791 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
794 unsigned long r_index
;
796 struct elf_link_hash_entry
*h
;
798 r_type
= ELF32_R_TYPE (irel
->r_info
);
799 r_index
= ELF32_R_SYM (irel
->r_info
);
801 /* These are the only relocation types we care about. */
802 if ( r_type
!= R_ARM_PC24
803 && r_type
!= R_ARM_THM_PC22
)
806 /* Get the section contents if we haven't done so already. */
807 if (contents
== NULL
)
809 /* Get cached copy if it exists. */
810 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
811 contents
= elf_section_data (sec
)->this_hdr
.contents
;
814 /* Go get them off disk. */
815 if (! bfd_malloc_and_get_section (abfd
, sec
, &contents
))
820 /* If the relocation is not against a symbol it cannot concern us. */
823 /* We don't care about local symbols. */
824 if (r_index
< symtab_hdr
->sh_info
)
827 /* This is an external symbol. */
828 r_index
-= symtab_hdr
->sh_info
;
829 h
= (struct elf_link_hash_entry
*)
830 elf_sym_hashes (abfd
)[r_index
];
832 /* If the relocation is against a static symbol it must be within
833 the current section and so cannot be a cross ARM/Thumb relocation. */
840 /* This one is a call from arm code. We need to look up
841 the target of the call. If it is a thumb target, we
843 if (ELF_ST_TYPE(h
->type
) == STT_ARM_TFUNC
)
844 record_arm_to_thumb_glue (link_info
, h
);
848 /* This one is a call from thumb code. We look
849 up the target of the call. If it is not a thumb
850 target, we insert glue. */
851 if (ELF_ST_TYPE (h
->type
) != STT_ARM_TFUNC
)
852 record_thumb_to_arm_glue (link_info
, h
);
861 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
865 if (internal_relocs
!= NULL
866 && elf_section_data (sec
)->relocs
!= internal_relocs
)
867 free (internal_relocs
);
868 internal_relocs
= NULL
;
875 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
877 if (internal_relocs
!= NULL
878 && elf_section_data (sec
)->relocs
!= internal_relocs
)
879 free (internal_relocs
);
885 /* The thumb form of a long branch is a bit finicky, because the offset
886 encoding is split over two fields, each in it's own instruction. They
887 can occur in any order. So given a thumb form of long branch, and an
888 offset, insert the offset into the thumb branch and return finished
891 It takes two thumb instructions to encode the target address. Each has
892 11 bits to invest. The upper 11 bits are stored in one (identified by
893 H-0.. see below), the lower 11 bits are stored in the other (identified
896 Combine together and shifted left by 1 (it's a half word address) and
900 H-0, upper address-0 = 000
902 H-1, lower address-0 = 800
904 They can be ordered either way, but the arm tools I've seen always put
905 the lower one first. It probably doesn't matter. krk@cygnus.com
907 XXX: Actually the order does matter. The second instruction (H-1)
908 moves the computed address into the PC, so it must be the second one
909 in the sequence. The problem, however is that whilst little endian code
910 stores the instructions in HI then LOW order, big endian code does the
911 reverse. nickc@cygnus.com. */
913 #define LOW_HI_ORDER 0xF800F000
914 #define HI_LOW_ORDER 0xF000F800
917 insert_thumb_branch (insn32 br_insn
, int rel_off
)
919 unsigned int low_bits
;
920 unsigned int high_bits
;
922 BFD_ASSERT ((rel_off
& 1) != 1);
924 rel_off
>>= 1; /* Half word aligned address. */
925 low_bits
= rel_off
& 0x000007FF; /* The bottom 11 bits. */
926 high_bits
= (rel_off
>> 11) & 0x000007FF; /* The top 11 bits. */
928 if ((br_insn
& LOW_HI_ORDER
) == LOW_HI_ORDER
)
929 br_insn
= LOW_HI_ORDER
| (low_bits
<< 16) | high_bits
;
930 else if ((br_insn
& HI_LOW_ORDER
) == HI_LOW_ORDER
)
931 br_insn
= HI_LOW_ORDER
| (high_bits
<< 16) | low_bits
;
933 /* FIXME: abort is probably not the right call. krk@cygnus.com */
934 abort (); /* Error - not a valid branch instruction form. */
939 /* Thumb code calling an ARM function. */
942 elf32_thumb_to_arm_stub (struct bfd_link_info
* info
,
946 asection
* input_section
,
950 bfd_signed_vma addend
,
955 unsigned long int tmp
;
957 struct elf_link_hash_entry
* myh
;
958 struct elf32_arm_link_hash_table
* globals
;
960 myh
= find_thumb_glue (info
, name
, input_bfd
);
964 globals
= elf32_arm_hash_table (info
);
966 BFD_ASSERT (globals
!= NULL
);
967 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
969 my_offset
= myh
->root
.u
.def
.value
;
971 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
972 THUMB2ARM_GLUE_SECTION_NAME
);
974 BFD_ASSERT (s
!= NULL
);
975 BFD_ASSERT (s
->contents
!= NULL
);
976 BFD_ASSERT (s
->output_section
!= NULL
);
978 if ((my_offset
& 0x01) == 0x01)
981 && sym_sec
->owner
!= NULL
982 && !INTERWORK_FLAG (sym_sec
->owner
))
984 (*_bfd_error_handler
)
985 (_("%B(%s): warning: interworking not enabled.\n"
986 " first occurrence: %B: thumb call to arm"),
987 sym_sec
->owner
, input_bfd
, name
);
993 myh
->root
.u
.def
.value
= my_offset
;
995 bfd_put_16 (output_bfd
, (bfd_vma
) t2a1_bx_pc_insn
,
996 s
->contents
+ my_offset
);
998 bfd_put_16 (output_bfd
, (bfd_vma
) t2a2_noop_insn
,
999 s
->contents
+ my_offset
+ 2);
1002 /* Address of destination of the stub. */
1003 ((bfd_signed_vma
) val
)
1005 /* Offset from the start of the current section
1006 to the start of the stubs. */
1008 /* Offset of the start of this stub from the start of the stubs. */
1010 /* Address of the start of the current section. */
1011 + s
->output_section
->vma
)
1012 /* The branch instruction is 4 bytes into the stub. */
1014 /* ARM branches work from the pc of the instruction + 8. */
1017 bfd_put_32 (output_bfd
,
1018 (bfd_vma
) t2a3_b_insn
| ((ret_offset
>> 2) & 0x00FFFFFF),
1019 s
->contents
+ my_offset
+ 4);
1022 BFD_ASSERT (my_offset
<= globals
->thumb_glue_size
);
1024 /* Now go back and fix up the original BL insn to point to here. */
1026 /* Address of where the stub is located. */
1027 (s
->output_section
->vma
+ s
->output_offset
+ my_offset
)
1028 /* Address of where the BL is located. */
1029 - (input_section
->output_section
->vma
+ input_section
->output_offset
1031 /* Addend in the relocation. */
1033 /* Biassing for PC-relative addressing. */
1036 tmp
= bfd_get_32 (input_bfd
, hit_data
1037 - input_section
->vma
);
1039 bfd_put_32 (output_bfd
,
1040 (bfd_vma
) insert_thumb_branch (tmp
, ret_offset
),
1041 hit_data
- input_section
->vma
);
1046 /* Arm code calling a Thumb function. */
1049 elf32_arm_to_thumb_stub (struct bfd_link_info
* info
,
1053 asection
* input_section
,
1054 bfd_byte
* hit_data
,
1057 bfd_signed_vma addend
,
1060 unsigned long int tmp
;
1063 long int ret_offset
;
1064 struct elf_link_hash_entry
* myh
;
1065 struct elf32_arm_link_hash_table
* globals
;
1067 myh
= find_arm_glue (info
, name
, input_bfd
);
1071 globals
= elf32_arm_hash_table (info
);
1073 BFD_ASSERT (globals
!= NULL
);
1074 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
1076 my_offset
= myh
->root
.u
.def
.value
;
1077 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
1078 ARM2THUMB_GLUE_SECTION_NAME
);
1079 BFD_ASSERT (s
!= NULL
);
1080 BFD_ASSERT (s
->contents
!= NULL
);
1081 BFD_ASSERT (s
->output_section
!= NULL
);
1083 if ((my_offset
& 0x01) == 0x01)
1086 && sym_sec
->owner
!= NULL
1087 && !INTERWORK_FLAG (sym_sec
->owner
))
1089 (*_bfd_error_handler
)
1090 (_("%B(%s): warning: interworking not enabled.\n"
1091 " first occurrence: %B: arm call to thumb"),
1092 sym_sec
->owner
, input_bfd
, name
);
1096 myh
->root
.u
.def
.value
= my_offset
;
1098 bfd_put_32 (output_bfd
, (bfd_vma
) a2t1_ldr_insn
,
1099 s
->contents
+ my_offset
);
1101 bfd_put_32 (output_bfd
, (bfd_vma
) a2t2_bx_r12_insn
,
1102 s
->contents
+ my_offset
+ 4);
1104 /* It's a thumb address. Add the low order bit. */
1105 bfd_put_32 (output_bfd
, val
| a2t3_func_addr_insn
,
1106 s
->contents
+ my_offset
+ 8);
1109 BFD_ASSERT (my_offset
<= globals
->arm_glue_size
);
1111 tmp
= bfd_get_32 (input_bfd
, hit_data
);
1112 tmp
= tmp
& 0xFF000000;
1114 /* Somehow these are both 4 too far, so subtract 8. */
1115 ret_offset
= (s
->output_offset
1117 + s
->output_section
->vma
1118 - (input_section
->output_offset
1119 + input_section
->output_section
->vma
1123 tmp
= tmp
| ((ret_offset
>> 2) & 0x00FFFFFF);
1125 bfd_put_32 (output_bfd
, (bfd_vma
) tmp
, hit_data
- input_section
->vma
);
1130 /* Perform a relocation as part of a final link. */
1132 static bfd_reloc_status_type
1133 elf32_arm_final_link_relocate (reloc_howto_type
* howto
,
1136 asection
* input_section
,
1137 bfd_byte
* contents
,
1138 Elf_Internal_Rela
* rel
,
1140 struct bfd_link_info
* info
,
1142 const char * sym_name
,
1144 struct elf_link_hash_entry
* h
)
1146 unsigned long r_type
= howto
->type
;
1147 unsigned long r_symndx
;
1148 bfd_byte
* hit_data
= contents
+ rel
->r_offset
;
1149 bfd
* dynobj
= NULL
;
1150 Elf_Internal_Shdr
* symtab_hdr
;
1151 struct elf_link_hash_entry
** sym_hashes
;
1152 bfd_vma
* local_got_offsets
;
1153 asection
* sgot
= NULL
;
1154 asection
* splt
= NULL
;
1155 asection
* sreloc
= NULL
;
1157 bfd_signed_vma signed_addend
;
1158 struct elf32_arm_link_hash_table
* globals
;
1160 /* If the start address has been set, then set the EF_ARM_HASENTRY
1161 flag. Setting this more than once is redundant, but the cost is
1162 not too high, and it keeps the code simple.
1164 The test is done here, rather than somewhere else, because the
1165 start address is only set just before the final link commences.
1167 Note - if the user deliberately sets a start address of 0, the
1168 flag will not be set. */
1169 if (bfd_get_start_address (output_bfd
) != 0)
1170 elf_elfheader (output_bfd
)->e_flags
|= EF_ARM_HASENTRY
;
1172 globals
= elf32_arm_hash_table (info
);
1174 dynobj
= elf_hash_table (info
)->dynobj
;
1177 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1178 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1180 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1181 sym_hashes
= elf_sym_hashes (input_bfd
);
1182 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1183 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1186 addend
= bfd_get_32 (input_bfd
, hit_data
) & howto
->src_mask
;
1188 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1191 signed_addend
&= ~ howto
->src_mask
;
1192 signed_addend
|= addend
;
1195 signed_addend
= addend
;
1197 addend
= signed_addend
= rel
->r_addend
;
1203 return bfd_reloc_ok
;
1212 /* r_symndx will be zero only for relocs against symbols
1213 from removed linkonce sections, or sections discarded by
1216 return bfd_reloc_ok
;
1218 /* Handle relocations which should use the PLT entry. ABS32/REL32
1219 will use the symbol's value, which may point to a PLT entry, but we
1220 don't need to handle that here. If we created a PLT entry, all
1221 branches in this object should go to it. */
1222 if ((r_type
!= R_ARM_ABS32
&& r_type
!= R_ARM_REL32
)
1225 && h
->plt
.offset
!= (bfd_vma
) -1)
1227 /* If we've created a .plt section, and assigned a PLT entry to
1228 this function, it should not be known to bind locally. If
1229 it were, we would have cleared the PLT entry. */
1230 BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info
, h
));
1232 value
= (splt
->output_section
->vma
1233 + splt
->output_offset
1235 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1236 contents
, rel
->r_offset
, value
,
1240 /* When generating a shared object, these relocations are copied
1241 into the output file to be resolved at run time. */
1243 && (input_section
->flags
& SEC_ALLOC
)
1244 && (r_type
!= R_ARM_REL32
1245 || !SYMBOL_CALLS_LOCAL (info
, h
))
1247 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
1248 || h
->root
.type
!= bfd_link_hash_undefweak
)
1249 && r_type
!= R_ARM_PC24
1250 && r_type
!= R_ARM_PLT32
)
1252 Elf_Internal_Rela outrel
;
1254 bfd_boolean skip
, relocate
;
1260 name
= (bfd_elf_string_from_elf_section
1262 elf_elfheader (input_bfd
)->e_shstrndx
,
1263 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1265 return bfd_reloc_notsupported
;
1267 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
1268 && strcmp (bfd_get_section_name (input_bfd
,
1272 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1273 BFD_ASSERT (sreloc
!= NULL
);
1280 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
1282 if (outrel
.r_offset
== (bfd_vma
) -1)
1284 else if (outrel
.r_offset
== (bfd_vma
) -2)
1285 skip
= TRUE
, relocate
= TRUE
;
1286 outrel
.r_offset
+= (input_section
->output_section
->vma
1287 + input_section
->output_offset
);
1290 memset (&outrel
, 0, sizeof outrel
);
1295 || (h
->elf_link_hash_flags
1296 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1297 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1300 /* This symbol is local, or marked to become local. */
1302 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1305 loc
= sreloc
->contents
;
1306 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
1307 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
1309 /* If this reloc is against an external symbol, we do not want to
1310 fiddle with the addend. Otherwise, we need to include the symbol
1311 value so that it becomes an addend for the dynamic reloc. */
1313 return bfd_reloc_ok
;
1315 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1316 contents
, rel
->r_offset
, value
,
1319 else switch (r_type
)
1322 case R_ARM_XPC25
: /* Arm BLX instruction. */
1324 case R_ARM_PC24
: /* Arm B/BL instruction */
1327 if (r_type
== R_ARM_XPC25
)
1329 /* Check for Arm calling Arm function. */
1330 /* FIXME: Should we translate the instruction into a BL
1331 instruction instead ? */
1332 if (sym_flags
!= STT_ARM_TFUNC
)
1333 (*_bfd_error_handler
)
1334 (_("\%B: Warning: Arm BLX instruction targets Arm function '%s'."),
1336 h
? h
->root
.root
.string
: "(local)");
1341 /* Check for Arm calling Thumb function. */
1342 if (sym_flags
== STT_ARM_TFUNC
)
1344 elf32_arm_to_thumb_stub (info
, sym_name
, input_bfd
,
1345 output_bfd
, input_section
,
1346 hit_data
, sym_sec
, rel
->r_offset
,
1347 signed_addend
, value
);
1348 return bfd_reloc_ok
;
1352 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1353 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0)
1355 /* The old way of doing things. Trearing the addend as a
1356 byte sized field and adding in the pipeline offset. */
1357 value
-= (input_section
->output_section
->vma
1358 + input_section
->output_offset
);
1359 value
-= rel
->r_offset
;
1362 if (! globals
->no_pipeline_knowledge
)
1367 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
1369 S is the address of the symbol in the relocation.
1370 P is address of the instruction being relocated.
1371 A is the addend (extracted from the instruction) in bytes.
1373 S is held in 'value'.
1374 P is the base address of the section containing the
1375 instruction plus the offset of the reloc into that
1377 (input_section->output_section->vma +
1378 input_section->output_offset +
1380 A is the addend, converted into bytes, ie:
1383 Note: None of these operations have knowledge of the pipeline
1384 size of the processor, thus it is up to the assembler to
1385 encode this information into the addend. */
1386 value
-= (input_section
->output_section
->vma
1387 + input_section
->output_offset
);
1388 value
-= rel
->r_offset
;
1389 value
+= (signed_addend
<< howto
->size
);
1391 /* Previous versions of this code also used to add in the
1392 pipeline offset here. This is wrong because the linker is
1393 not supposed to know about such things, and one day it might
1394 change. In order to support old binaries that need the old
1395 behaviour however, so we attempt to detect which ABI was
1396 used to create the reloc. */
1397 if (! globals
->no_pipeline_knowledge
)
1399 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form */
1401 i_ehdrp
= elf_elfheader (input_bfd
);
1403 if (i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1408 signed_addend
= value
;
1409 signed_addend
>>= howto
->rightshift
;
1411 /* It is not an error for an undefined weak reference to be
1412 out of range. Any program that branches to such a symbol
1413 is going to crash anyway, so there is no point worrying
1414 about getting the destination exactly right. */
1415 if (! h
|| h
->root
.type
!= bfd_link_hash_undefweak
)
1417 /* Perform a signed range check. */
1418 if ( signed_addend
> ((bfd_signed_vma
) (howto
->dst_mask
>> 1))
1419 || signed_addend
< - ((bfd_signed_vma
) ((howto
->dst_mask
+ 1) >> 1)))
1420 return bfd_reloc_overflow
;
1424 /* If necessary set the H bit in the BLX instruction. */
1425 if (r_type
== R_ARM_XPC25
&& ((value
& 2) == 2))
1426 value
= (signed_addend
& howto
->dst_mask
)
1427 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
))
1431 value
= (signed_addend
& howto
->dst_mask
)
1432 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1437 if (sym_flags
== STT_ARM_TFUNC
)
1442 value
-= (input_section
->output_section
->vma
1443 + input_section
->output_offset
+ rel
->r_offset
);
1448 bfd_put_32 (input_bfd
, value
, hit_data
);
1449 return bfd_reloc_ok
;
1453 if ((long) value
> 0x7f || (long) value
< -0x80)
1454 return bfd_reloc_overflow
;
1456 bfd_put_8 (input_bfd
, value
, hit_data
);
1457 return bfd_reloc_ok
;
1462 if ((long) value
> 0x7fff || (long) value
< -0x8000)
1463 return bfd_reloc_overflow
;
1465 bfd_put_16 (input_bfd
, value
, hit_data
);
1466 return bfd_reloc_ok
;
1469 /* Support ldr and str instruction for the arm */
1470 /* Also thumb b (unconditional branch). ??? Really? */
1473 if ((long) value
> 0x7ff || (long) value
< -0x800)
1474 return bfd_reloc_overflow
;
1476 value
|= (bfd_get_32 (input_bfd
, hit_data
) & 0xfffff000);
1477 bfd_put_32 (input_bfd
, value
, hit_data
);
1478 return bfd_reloc_ok
;
1480 case R_ARM_THM_ABS5
:
1481 /* Support ldr and str instructions for the thumb. */
1483 /* Need to refetch addend. */
1484 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1485 /* ??? Need to determine shift amount from operand size. */
1486 addend
>>= howto
->rightshift
;
1490 /* ??? Isn't value unsigned? */
1491 if ((long) value
> 0x1f || (long) value
< -0x10)
1492 return bfd_reloc_overflow
;
1494 /* ??? Value needs to be properly shifted into place first. */
1495 value
|= bfd_get_16 (input_bfd
, hit_data
) & 0xf83f;
1496 bfd_put_16 (input_bfd
, value
, hit_data
);
1497 return bfd_reloc_ok
;
1500 case R_ARM_THM_XPC22
:
1502 case R_ARM_THM_PC22
:
1503 /* Thumb BL (branch long instruction). */
1506 bfd_boolean overflow
= FALSE
;
1507 bfd_vma upper_insn
= bfd_get_16 (input_bfd
, hit_data
);
1508 bfd_vma lower_insn
= bfd_get_16 (input_bfd
, hit_data
+ 2);
1509 bfd_signed_vma reloc_signed_max
= ((1 << (howto
->bitsize
- 1)) - 1) >> howto
->rightshift
;
1510 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1512 bfd_signed_vma signed_check
;
1515 /* Need to refetch the addend and squish the two 11 bit pieces
1518 bfd_vma upper
= upper_insn
& 0x7ff;
1519 bfd_vma lower
= lower_insn
& 0x7ff;
1520 upper
= (upper
^ 0x400) - 0x400; /* Sign extend. */
1521 addend
= (upper
<< 12) | (lower
<< 1);
1522 signed_addend
= addend
;
1526 if (r_type
== R_ARM_THM_XPC22
)
1528 /* Check for Thumb to Thumb call. */
1529 /* FIXME: Should we translate the instruction into a BL
1530 instruction instead ? */
1531 if (sym_flags
== STT_ARM_TFUNC
)
1532 (*_bfd_error_handler
)
1533 (_("%B: Warning: Thumb BLX instruction targets thumb function '%s'."),
1535 h
? h
->root
.root
.string
: "(local)");
1540 /* If it is not a call to Thumb, assume call to Arm.
1541 If it is a call relative to a section name, then it is not a
1542 function call at all, but rather a long jump. */
1543 if (sym_flags
!= STT_ARM_TFUNC
&& sym_flags
!= STT_SECTION
)
1545 if (elf32_thumb_to_arm_stub
1546 (info
, sym_name
, input_bfd
, output_bfd
, input_section
,
1547 hit_data
, sym_sec
, rel
->r_offset
, signed_addend
, value
))
1548 return bfd_reloc_ok
;
1550 return bfd_reloc_dangerous
;
1554 relocation
= value
+ signed_addend
;
1556 relocation
-= (input_section
->output_section
->vma
1557 + input_section
->output_offset
1560 if (! globals
->no_pipeline_knowledge
)
1562 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form. */
1564 i_ehdrp
= elf_elfheader (input_bfd
);
1566 /* Previous versions of this code also used to add in the pipline
1567 offset here. This is wrong because the linker is not supposed
1568 to know about such things, and one day it might change. In order
1569 to support old binaries that need the old behaviour however, so
1570 we attempt to detect which ABI was used to create the reloc. */
1571 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1572 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0
1573 || i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1577 check
= relocation
>> howto
->rightshift
;
1579 /* If this is a signed value, the rightshift just dropped
1580 leading 1 bits (assuming twos complement). */
1581 if ((bfd_signed_vma
) relocation
>= 0)
1582 signed_check
= check
;
1584 signed_check
= check
| ~((bfd_vma
) -1 >> howto
->rightshift
);
1586 /* Assumes two's complement. */
1587 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1591 if (r_type
== R_ARM_THM_XPC22
1592 && ((lower_insn
& 0x1800) == 0x0800))
1593 /* For a BLX instruction, make sure that the relocation is rounded up
1594 to a word boundary. This follows the semantics of the instruction
1595 which specifies that bit 1 of the target address will come from bit
1596 1 of the base address. */
1597 relocation
= (relocation
+ 2) & ~ 3;
1599 /* Put RELOCATION back into the insn. */
1600 upper_insn
= (upper_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 12) & 0x7ff);
1601 lower_insn
= (lower_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 1) & 0x7ff);
1603 /* Put the relocated value back in the object file: */
1604 bfd_put_16 (input_bfd
, upper_insn
, hit_data
);
1605 bfd_put_16 (input_bfd
, lower_insn
, hit_data
+ 2);
1607 return (overflow
? bfd_reloc_overflow
: bfd_reloc_ok
);
1611 case R_ARM_THM_PC11
:
1612 /* Thumb B (branch) instruction). */
1614 bfd_signed_vma relocation
;
1615 bfd_signed_vma reloc_signed_max
= (1 << (howto
->bitsize
- 1)) - 1;
1616 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1617 bfd_signed_vma signed_check
;
1620 /* Need to refetch addend. */
1621 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1622 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1625 signed_addend
&= ~ howto
->src_mask
;
1626 signed_addend
|= addend
;
1629 signed_addend
= addend
;
1630 /* The value in the insn has been right shifted. We need to
1631 undo this, so that we can perform the address calculation
1632 in terms of bytes. */
1633 signed_addend
<<= howto
->rightshift
;
1635 relocation
= value
+ signed_addend
;
1637 relocation
-= (input_section
->output_section
->vma
1638 + input_section
->output_offset
1641 relocation
>>= howto
->rightshift
;
1642 signed_check
= relocation
;
1643 relocation
&= howto
->dst_mask
;
1644 relocation
|= (bfd_get_16 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1646 bfd_put_16 (input_bfd
, relocation
, hit_data
);
1648 /* Assumes two's complement. */
1649 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1650 return bfd_reloc_overflow
;
1652 return bfd_reloc_ok
;
1656 case R_ARM_ALU_PCREL7_0
:
1657 case R_ARM_ALU_PCREL15_8
:
1658 case R_ARM_ALU_PCREL23_15
:
1663 insn
= bfd_get_32 (input_bfd
, hit_data
);
1665 /* Extract the addend. */
1666 addend
= (insn
& 0xff) << ((insn
& 0xf00) >> 7);
1667 signed_addend
= addend
;
1669 relocation
= value
+ signed_addend
;
1671 relocation
-= (input_section
->output_section
->vma
1672 + input_section
->output_offset
1674 insn
= (insn
& ~0xfff)
1675 | ((howto
->bitpos
<< 7) & 0xf00)
1676 | ((relocation
>> howto
->bitpos
) & 0xff);
1677 bfd_put_32 (input_bfd
, value
, hit_data
);
1679 return bfd_reloc_ok
;
1682 case R_ARM_GNU_VTINHERIT
:
1683 case R_ARM_GNU_VTENTRY
:
1684 return bfd_reloc_ok
;
1687 return bfd_reloc_notsupported
;
1689 case R_ARM_GLOB_DAT
:
1690 return bfd_reloc_notsupported
;
1692 case R_ARM_JUMP_SLOT
:
1693 return bfd_reloc_notsupported
;
1695 case R_ARM_RELATIVE
:
1696 return bfd_reloc_notsupported
;
1699 /* Relocation is relative to the start of the
1700 global offset table. */
1702 BFD_ASSERT (sgot
!= NULL
);
1704 return bfd_reloc_notsupported
;
1706 /* If we are addressing a Thumb function, we need to adjust the
1707 address by one, so that attempts to call the function pointer will
1708 correctly interpret it as Thumb code. */
1709 if (sym_flags
== STT_ARM_TFUNC
)
1712 /* Note that sgot->output_offset is not involved in this
1713 calculation. We always want the start of .got. If we
1714 define _GLOBAL_OFFSET_TABLE in a different way, as is
1715 permitted by the ABI, we might have to change this
1717 value
-= sgot
->output_section
->vma
;
1718 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1719 contents
, rel
->r_offset
, value
,
1723 /* Use global offset table as symbol value. */
1724 BFD_ASSERT (sgot
!= NULL
);
1727 return bfd_reloc_notsupported
;
1729 value
= sgot
->output_section
->vma
;
1730 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1731 contents
, rel
->r_offset
, value
,
1735 /* Relocation is to the entry for this symbol in the
1736 global offset table. */
1738 return bfd_reloc_notsupported
;
1745 off
= h
->got
.offset
;
1746 BFD_ASSERT (off
!= (bfd_vma
) -1);
1747 dyn
= globals
->root
.dynamic_sections_created
;
1749 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
1751 && SYMBOL_REFERENCES_LOCAL (info
, h
))
1752 || (ELF_ST_VISIBILITY (h
->other
)
1753 && h
->root
.type
== bfd_link_hash_undefweak
))
1755 /* This is actually a static link, or it is a -Bsymbolic link
1756 and the symbol is defined locally. We must initialize this
1757 entry in the global offset table. Since the offset must
1758 always be a multiple of 4, we use the least significant bit
1759 to record whether we have initialized it already.
1761 When doing a dynamic link, we create a .rel.got relocation
1762 entry to initialize the value. This is done in the
1763 finish_dynamic_symbol routine. */
1768 /* If we are addressing a Thumb function, we need to
1769 adjust the address by one, so that attempts to
1770 call the function pointer will correctly
1771 interpret it as Thumb code. */
1772 if (sym_flags
== STT_ARM_TFUNC
)
1775 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1780 value
= sgot
->output_offset
+ off
;
1786 BFD_ASSERT (local_got_offsets
!= NULL
&&
1787 local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1789 off
= local_got_offsets
[r_symndx
];
1791 /* The offset must always be a multiple of 4. We use the
1792 least significant bit to record whether we have already
1793 generated the necessary reloc. */
1798 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1803 Elf_Internal_Rela outrel
;
1806 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
1807 BFD_ASSERT (srelgot
!= NULL
);
1809 outrel
.r_offset
= (sgot
->output_section
->vma
1810 + sgot
->output_offset
1812 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1813 loc
= srelgot
->contents
;
1814 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rel
);
1815 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
1818 local_got_offsets
[r_symndx
] |= 1;
1821 value
= sgot
->output_offset
+ off
;
1824 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1825 contents
, rel
->r_offset
, value
,
1829 return bfd_reloc_notsupported
;
1831 case R_ARM_AMP_VCALL9
:
1832 return bfd_reloc_notsupported
;
1834 case R_ARM_RSBREL32
:
1835 return bfd_reloc_notsupported
;
1837 case R_ARM_THM_RPC22
:
1838 return bfd_reloc_notsupported
;
1841 return bfd_reloc_notsupported
;
1844 return bfd_reloc_notsupported
;
1847 return bfd_reloc_notsupported
;
1850 return bfd_reloc_notsupported
;
1853 return bfd_reloc_notsupported
;
1858 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
1860 arm_add_to_rel (bfd
* abfd
,
1862 reloc_howto_type
* howto
,
1863 bfd_signed_vma increment
)
1865 bfd_signed_vma addend
;
1867 if (howto
->type
== R_ARM_THM_PC22
)
1869 int upper_insn
, lower_insn
;
1872 upper_insn
= bfd_get_16 (abfd
, address
);
1873 lower_insn
= bfd_get_16 (abfd
, address
+ 2);
1874 upper
= upper_insn
& 0x7ff;
1875 lower
= lower_insn
& 0x7ff;
1877 addend
= (upper
<< 12) | (lower
<< 1);
1878 addend
+= increment
;
1881 upper_insn
= (upper_insn
& 0xf800) | ((addend
>> 11) & 0x7ff);
1882 lower_insn
= (lower_insn
& 0xf800) | (addend
& 0x7ff);
1884 bfd_put_16 (abfd
, (bfd_vma
) upper_insn
, address
);
1885 bfd_put_16 (abfd
, (bfd_vma
) lower_insn
, address
+ 2);
1891 contents
= bfd_get_32 (abfd
, address
);
1893 /* Get the (signed) value from the instruction. */
1894 addend
= contents
& howto
->src_mask
;
1895 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1897 bfd_signed_vma mask
;
1900 mask
&= ~ howto
->src_mask
;
1904 /* Add in the increment, (which is a byte value). */
1905 switch (howto
->type
)
1908 addend
+= increment
;
1912 addend
<<= howto
->size
;
1913 addend
+= increment
;
1915 /* Should we check for overflow here ? */
1917 /* Drop any undesired bits. */
1918 addend
>>= howto
->rightshift
;
1922 contents
= (contents
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
1924 bfd_put_32 (abfd
, contents
, address
);
1927 #endif /* USE_REL */
1929 /* Relocate an ARM ELF section. */
1931 elf32_arm_relocate_section (bfd
* output_bfd
,
1932 struct bfd_link_info
* info
,
1934 asection
* input_section
,
1935 bfd_byte
* contents
,
1936 Elf_Internal_Rela
* relocs
,
1937 Elf_Internal_Sym
* local_syms
,
1938 asection
** local_sections
)
1940 Elf_Internal_Shdr
*symtab_hdr
;
1941 struct elf_link_hash_entry
**sym_hashes
;
1942 Elf_Internal_Rela
*rel
;
1943 Elf_Internal_Rela
*relend
;
1947 if (info
->relocatable
)
1951 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1952 sym_hashes
= elf_sym_hashes (input_bfd
);
1955 relend
= relocs
+ input_section
->reloc_count
;
1956 for (; rel
< relend
; rel
++)
1959 reloc_howto_type
* howto
;
1960 unsigned long r_symndx
;
1961 Elf_Internal_Sym
* sym
;
1963 struct elf_link_hash_entry
* h
;
1965 bfd_reloc_status_type r
;
1968 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1969 r_type
= ELF32_R_TYPE (rel
->r_info
);
1971 if ( r_type
== R_ARM_GNU_VTENTRY
1972 || r_type
== R_ARM_GNU_VTINHERIT
)
1975 elf32_arm_info_to_howto (input_bfd
, & bfd_reloc
, rel
);
1976 howto
= bfd_reloc
.howto
;
1979 if (info
->relocatable
)
1981 /* This is a relocatable link. We don't have to change
1982 anything, unless the reloc is against a section symbol,
1983 in which case we have to adjust according to where the
1984 section symbol winds up in the output section. */
1985 if (r_symndx
< symtab_hdr
->sh_info
)
1987 sym
= local_syms
+ r_symndx
;
1988 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1990 sec
= local_sections
[r_symndx
];
1991 arm_add_to_rel (input_bfd
, contents
+ rel
->r_offset
,
1993 (bfd_signed_vma
) (sec
->output_offset
2002 /* This is a final link. */
2007 if (r_symndx
< symtab_hdr
->sh_info
)
2009 sym
= local_syms
+ r_symndx
;
2010 sec
= local_sections
[r_symndx
];
2012 relocation
= (sec
->output_section
->vma
2013 + sec
->output_offset
2015 if ((sec
->flags
& SEC_MERGE
)
2016 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2019 bfd_vma addend
, value
;
2021 if (howto
->rightshift
)
2023 (*_bfd_error_handler
)
2024 (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
2025 input_bfd
, input_section
,
2026 (long) rel
->r_offset
, howto
->name
);
2030 value
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2032 /* Get the (signed) value from the instruction. */
2033 addend
= value
& howto
->src_mask
;
2034 if (addend
& ((howto
->src_mask
+ 1) >> 1))
2036 bfd_signed_vma mask
;
2039 mask
&= ~ howto
->src_mask
;
2044 _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
)
2046 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2047 value
= (value
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
2048 bfd_put_32 (input_bfd
, value
, contents
+ rel
->r_offset
);
2051 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2057 bfd_boolean unresolved_reloc
;
2059 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2060 r_symndx
, symtab_hdr
, sym_hashes
,
2062 unresolved_reloc
, warned
);
2064 if (unresolved_reloc
|| relocation
!= 0)
2066 /* In these cases, we don't need the relocation value.
2067 We check specially because in some obscure cases
2068 sec->output_section will be NULL. */
2073 case R_ARM_THM_PC22
:
2078 (!info
->symbolic
&& h
->dynindx
!= -1)
2079 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2081 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2082 && ((input_section
->flags
& SEC_ALLOC
) != 0
2083 /* DWARF will emit R_ARM_ABS32 relocations in its
2084 sections against symbols defined externally
2085 in shared libraries. We can't do anything
2087 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
2088 && (h
->elf_link_hash_flags
2089 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
2099 if ((WILL_CALL_FINISH_DYNAMIC_SYMBOL
2100 (elf_hash_table (info
)->dynamic_sections_created
,
2103 || (!info
->symbolic
&& h
->dynindx
!= -1)
2104 || (h
->elf_link_hash_flags
2105 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
2110 if (unresolved_reloc
)
2112 (_("%B(%A): warning: unresolvable relocation %d against symbol `%s'"),
2113 input_bfd
, input_section
,
2115 h
->root
.root
.string
);
2122 name
= h
->root
.root
.string
;
2125 name
= (bfd_elf_string_from_elf_section
2126 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2127 if (name
== NULL
|| *name
== '\0')
2128 name
= bfd_section_name (input_bfd
, sec
);
2131 r
= elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
2132 input_section
, contents
, rel
,
2133 relocation
, info
, sec
, name
,
2134 (h
? ELF_ST_TYPE (h
->type
) :
2135 ELF_ST_TYPE (sym
->st_info
)), h
);
2137 if (r
!= bfd_reloc_ok
)
2139 const char * msg
= (const char *) 0;
2143 case bfd_reloc_overflow
:
2144 /* If the overflowing reloc was to an undefined symbol,
2145 we have already printed one error message and there
2146 is no point complaining again. */
2148 h
->root
.type
!= bfd_link_hash_undefined
)
2149 && (!((*info
->callbacks
->reloc_overflow
)
2150 (info
, name
, howto
->name
, (bfd_vma
) 0,
2151 input_bfd
, input_section
, rel
->r_offset
))))
2155 case bfd_reloc_undefined
:
2156 if (!((*info
->callbacks
->undefined_symbol
)
2157 (info
, name
, input_bfd
, input_section
,
2158 rel
->r_offset
, TRUE
)))
2162 case bfd_reloc_outofrange
:
2163 msg
= _("internal error: out of range error");
2166 case bfd_reloc_notsupported
:
2167 msg
= _("internal error: unsupported relocation error");
2170 case bfd_reloc_dangerous
:
2171 msg
= _("internal error: dangerous error");
2175 msg
= _("internal error: unknown error");
2179 if (!((*info
->callbacks
->warning
)
2180 (info
, msg
, name
, input_bfd
, input_section
,
2191 /* Set the right machine number. */
2194 elf32_arm_object_p (bfd
*abfd
)
2198 mach
= bfd_arm_get_mach_from_notes (abfd
, ARM_NOTE_SECTION
);
2200 if (mach
!= bfd_mach_arm_unknown
)
2201 bfd_default_set_arch_mach (abfd
, bfd_arch_arm
, mach
);
2203 else if (elf_elfheader (abfd
)->e_flags
& EF_ARM_MAVERICK_FLOAT
)
2204 bfd_default_set_arch_mach (abfd
, bfd_arch_arm
, bfd_mach_arm_ep9312
);
2207 bfd_default_set_arch_mach (abfd
, bfd_arch_arm
, mach
);
2212 /* Function to keep ARM specific flags in the ELF header. */
2214 elf32_arm_set_private_flags (bfd
*abfd
, flagword flags
)
2216 if (elf_flags_init (abfd
)
2217 && elf_elfheader (abfd
)->e_flags
!= flags
)
2219 if (EF_ARM_EABI_VERSION (flags
) == EF_ARM_EABI_UNKNOWN
)
2221 if (flags
& EF_ARM_INTERWORK
)
2222 (*_bfd_error_handler
)
2223 (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
2227 (_("Warning: Clearing the interworking flag of %B due to outside request"),
2233 elf_elfheader (abfd
)->e_flags
= flags
;
2234 elf_flags_init (abfd
) = TRUE
;
2240 /* Copy backend specific data from one object module to another. */
2243 elf32_arm_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
2248 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2249 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2252 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2253 out_flags
= elf_elfheader (obfd
)->e_flags
;
2255 if (elf_flags_init (obfd
)
2256 && EF_ARM_EABI_VERSION (out_flags
) == EF_ARM_EABI_UNKNOWN
2257 && in_flags
!= out_flags
)
2259 /* Cannot mix APCS26 and APCS32 code. */
2260 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2263 /* Cannot mix float APCS and non-float APCS code. */
2264 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2267 /* If the src and dest have different interworking flags
2268 then turn off the interworking bit. */
2269 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2271 if (out_flags
& EF_ARM_INTERWORK
)
2273 (_("Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
2276 in_flags
&= ~EF_ARM_INTERWORK
;
2279 /* Likewise for PIC, though don't warn for this case. */
2280 if ((in_flags
& EF_ARM_PIC
) != (out_flags
& EF_ARM_PIC
))
2281 in_flags
&= ~EF_ARM_PIC
;
2284 elf_elfheader (obfd
)->e_flags
= in_flags
;
2285 elf_flags_init (obfd
) = TRUE
;
2290 /* Merge backend specific data from an object file to the output
2291 object file when linking. */
2294 elf32_arm_merge_private_bfd_data (bfd
* ibfd
, bfd
* obfd
)
2298 bfd_boolean flags_compatible
= TRUE
;
2301 /* Check if we have the same endianess. */
2302 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
2305 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2306 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2309 /* The input BFD must have had its flags initialised. */
2310 /* The following seems bogus to me -- The flags are initialized in
2311 the assembler but I don't think an elf_flags_init field is
2312 written into the object. */
2313 /* BFD_ASSERT (elf_flags_init (ibfd)); */
2315 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2316 out_flags
= elf_elfheader (obfd
)->e_flags
;
2318 if (!elf_flags_init (obfd
))
2320 /* If the input is the default architecture and had the default
2321 flags then do not bother setting the flags for the output
2322 architecture, instead allow future merges to do this. If no
2323 future merges ever set these flags then they will retain their
2324 uninitialised values, which surprise surprise, correspond
2325 to the default values. */
2326 if (bfd_get_arch_info (ibfd
)->the_default
2327 && elf_elfheader (ibfd
)->e_flags
== 0)
2330 elf_flags_init (obfd
) = TRUE
;
2331 elf_elfheader (obfd
)->e_flags
= in_flags
;
2333 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
2334 && bfd_get_arch_info (obfd
)->the_default
)
2335 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
), bfd_get_mach (ibfd
));
2340 /* Determine what should happen if the input ARM architecture
2341 does not match the output ARM architecture. */
2342 if (! bfd_arm_merge_machines (ibfd
, obfd
))
2345 /* Identical flags must be compatible. */
2346 if (in_flags
== out_flags
)
2349 /* Check to see if the input BFD actually contains any sections. If
2350 not, its flags may not have been initialised either, but it
2351 cannot actually cause any incompatibility. Do not short-circuit
2352 dynamic objects; their section list may be emptied by
2353 elf_link_add_object_symbols.
2355 Also check to see if there are no code sections in the input.
2356 In this case there is no need to check for code specific flags.
2357 XXX - do we need to worry about floating-point format compatability
2358 in data sections ? */
2359 if (!(ibfd
->flags
& DYNAMIC
))
2361 bfd_boolean null_input_bfd
= TRUE
;
2362 bfd_boolean only_data_sections
= TRUE
;
2364 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2366 /* Ignore synthetic glue sections. */
2367 if (strcmp (sec
->name
, ".glue_7")
2368 && strcmp (sec
->name
, ".glue_7t"))
2370 if ((bfd_get_section_flags (ibfd
, sec
)
2371 & (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
2372 == (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
2373 only_data_sections
= FALSE
;
2375 null_input_bfd
= FALSE
;
2380 if (null_input_bfd
|| only_data_sections
)
2384 /* Complain about various flag mismatches. */
2385 if (EF_ARM_EABI_VERSION (in_flags
) != EF_ARM_EABI_VERSION (out_flags
))
2388 (_("ERROR: %B is compiled for EABI version %d, whereas %B is compiled for version %d"),
2390 (in_flags
& EF_ARM_EABIMASK
) >> 24,
2391 (out_flags
& EF_ARM_EABIMASK
) >> 24);
2395 /* Not sure what needs to be checked for EABI versions >= 1. */
2396 if (EF_ARM_EABI_VERSION (in_flags
) == EF_ARM_EABI_UNKNOWN
)
2398 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2401 (_("ERROR: %B is compiled for APCS-%d, whereas target %B uses APCS-%d"),
2403 in_flags
& EF_ARM_APCS_26
? 26 : 32,
2404 out_flags
& EF_ARM_APCS_26
? 26 : 32);
2405 flags_compatible
= FALSE
;
2408 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2410 if (in_flags
& EF_ARM_APCS_FLOAT
)
2412 (_("ERROR: %B passes floats in float registers, whereas %B passes them in integer registers"),
2416 (_("ERROR: %B passes floats in integer registers, whereas %B passes them in float registers"),
2419 flags_compatible
= FALSE
;
2422 if ((in_flags
& EF_ARM_VFP_FLOAT
) != (out_flags
& EF_ARM_VFP_FLOAT
))
2424 if (in_flags
& EF_ARM_VFP_FLOAT
)
2426 (_("ERROR: %B uses VFP instructions, whereas %B does not"),
2430 (_("ERROR: %B uses FPA instructions, whereas %B does not"),
2433 flags_compatible
= FALSE
;
2436 if ((in_flags
& EF_ARM_MAVERICK_FLOAT
) != (out_flags
& EF_ARM_MAVERICK_FLOAT
))
2438 if (in_flags
& EF_ARM_MAVERICK_FLOAT
)
2440 (_("ERROR: %B uses Maverick instructions, whereas %B does not"),
2444 (_("ERROR: %B does not use Maverick instructions, whereas %B does"),
2447 flags_compatible
= FALSE
;
2450 #ifdef EF_ARM_SOFT_FLOAT
2451 if ((in_flags
& EF_ARM_SOFT_FLOAT
) != (out_flags
& EF_ARM_SOFT_FLOAT
))
2453 /* We can allow interworking between code that is VFP format
2454 layout, and uses either soft float or integer regs for
2455 passing floating point arguments and results. We already
2456 know that the APCS_FLOAT flags match; similarly for VFP
2458 if ((in_flags
& EF_ARM_APCS_FLOAT
) != 0
2459 || (in_flags
& EF_ARM_VFP_FLOAT
) == 0)
2461 if (in_flags
& EF_ARM_SOFT_FLOAT
)
2463 (_("ERROR: %B uses software FP, whereas %B uses hardware FP"),
2467 (_("ERROR: %B uses hardware FP, whereas %B uses software FP"),
2470 flags_compatible
= FALSE
;
2475 /* Interworking mismatch is only a warning. */
2476 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2478 if (in_flags
& EF_ARM_INTERWORK
)
2481 (_("Warning: %B supports interworking, whereas %B does not"),
2487 (_("Warning: %B does not support interworking, whereas %B does"),
2493 return flags_compatible
;
2496 /* Display the flags field. */
2499 elf32_arm_print_private_bfd_data (bfd
*abfd
, void * ptr
)
2501 FILE * file
= (FILE *) ptr
;
2502 unsigned long flags
;
2504 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
2506 /* Print normal ELF private data. */
2507 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
2509 flags
= elf_elfheader (abfd
)->e_flags
;
2510 /* Ignore init flag - it may not be set, despite the flags field
2511 containing valid data. */
2513 /* xgettext:c-format */
2514 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
2516 switch (EF_ARM_EABI_VERSION (flags
))
2518 case EF_ARM_EABI_UNKNOWN
:
2519 /* The following flag bits are GNU extensions and not part of the
2520 official ARM ELF extended ABI. Hence they are only decoded if
2521 the EABI version is not set. */
2522 if (flags
& EF_ARM_INTERWORK
)
2523 fprintf (file
, _(" [interworking enabled]"));
2525 if (flags
& EF_ARM_APCS_26
)
2526 fprintf (file
, " [APCS-26]");
2528 fprintf (file
, " [APCS-32]");
2530 if (flags
& EF_ARM_VFP_FLOAT
)
2531 fprintf (file
, _(" [VFP float format]"));
2532 else if (flags
& EF_ARM_MAVERICK_FLOAT
)
2533 fprintf (file
, _(" [Maverick float format]"));
2535 fprintf (file
, _(" [FPA float format]"));
2537 if (flags
& EF_ARM_APCS_FLOAT
)
2538 fprintf (file
, _(" [floats passed in float registers]"));
2540 if (flags
& EF_ARM_PIC
)
2541 fprintf (file
, _(" [position independent]"));
2543 if (flags
& EF_ARM_NEW_ABI
)
2544 fprintf (file
, _(" [new ABI]"));
2546 if (flags
& EF_ARM_OLD_ABI
)
2547 fprintf (file
, _(" [old ABI]"));
2549 if (flags
& EF_ARM_SOFT_FLOAT
)
2550 fprintf (file
, _(" [software FP]"));
2552 flags
&= ~(EF_ARM_INTERWORK
| EF_ARM_APCS_26
| EF_ARM_APCS_FLOAT
2553 | EF_ARM_PIC
| EF_ARM_NEW_ABI
| EF_ARM_OLD_ABI
2554 | EF_ARM_SOFT_FLOAT
| EF_ARM_VFP_FLOAT
2555 | EF_ARM_MAVERICK_FLOAT
);
2558 case EF_ARM_EABI_VER1
:
2559 fprintf (file
, _(" [Version1 EABI]"));
2561 if (flags
& EF_ARM_SYMSARESORTED
)
2562 fprintf (file
, _(" [sorted symbol table]"));
2564 fprintf (file
, _(" [unsorted symbol table]"));
2566 flags
&= ~ EF_ARM_SYMSARESORTED
;
2569 case EF_ARM_EABI_VER2
:
2570 fprintf (file
, _(" [Version2 EABI]"));
2572 if (flags
& EF_ARM_SYMSARESORTED
)
2573 fprintf (file
, _(" [sorted symbol table]"));
2575 fprintf (file
, _(" [unsorted symbol table]"));
2577 if (flags
& EF_ARM_DYNSYMSUSESEGIDX
)
2578 fprintf (file
, _(" [dynamic symbols use segment index]"));
2580 if (flags
& EF_ARM_MAPSYMSFIRST
)
2581 fprintf (file
, _(" [mapping symbols precede others]"));
2583 flags
&= ~(EF_ARM_SYMSARESORTED
| EF_ARM_DYNSYMSUSESEGIDX
2584 | EF_ARM_MAPSYMSFIRST
);
2587 case EF_ARM_EABI_VER3
:
2588 fprintf (file
, _(" [Version3 EABI]"));
2590 if (flags
& EF_ARM_BE8
)
2591 fprintf (file
, _(" [BE8]"));
2593 if (flags
& EF_ARM_LE8
)
2594 fprintf (file
, _(" [LE8]"));
2596 flags
&= ~(EF_ARM_LE8
| EF_ARM_BE8
);
2600 fprintf (file
, _(" <EABI version unrecognised>"));
2604 flags
&= ~ EF_ARM_EABIMASK
;
2606 if (flags
& EF_ARM_RELEXEC
)
2607 fprintf (file
, _(" [relocatable executable]"));
2609 if (flags
& EF_ARM_HASENTRY
)
2610 fprintf (file
, _(" [has entry point]"));
2612 flags
&= ~ (EF_ARM_RELEXEC
| EF_ARM_HASENTRY
);
2615 fprintf (file
, _("<Unrecognised flag bits set>"));
2623 elf32_arm_get_symbol_type (Elf_Internal_Sym
* elf_sym
, int type
)
2625 switch (ELF_ST_TYPE (elf_sym
->st_info
))
2628 return ELF_ST_TYPE (elf_sym
->st_info
);
2631 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2632 This allows us to distinguish between data used by Thumb instructions
2633 and non-data (which is probably code) inside Thumb regions of an
2635 if (type
!= STT_OBJECT
)
2636 return ELF_ST_TYPE (elf_sym
->st_info
);
2647 elf32_arm_gc_mark_hook (asection
* sec
,
2648 struct bfd_link_info
* info ATTRIBUTE_UNUSED
,
2649 Elf_Internal_Rela
* rel
,
2650 struct elf_link_hash_entry
* h
,
2651 Elf_Internal_Sym
* sym
)
2655 switch (ELF32_R_TYPE (rel
->r_info
))
2657 case R_ARM_GNU_VTINHERIT
:
2658 case R_ARM_GNU_VTENTRY
:
2662 switch (h
->root
.type
)
2664 case bfd_link_hash_defined
:
2665 case bfd_link_hash_defweak
:
2666 return h
->root
.u
.def
.section
;
2668 case bfd_link_hash_common
:
2669 return h
->root
.u
.c
.p
->section
;
2677 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
2682 /* Update the got entry reference counts for the section being removed. */
2685 elf32_arm_gc_sweep_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
2686 struct bfd_link_info
* info ATTRIBUTE_UNUSED
,
2687 asection
* sec ATTRIBUTE_UNUSED
,
2688 const Elf_Internal_Rela
* relocs ATTRIBUTE_UNUSED
)
2690 Elf_Internal_Shdr
*symtab_hdr
;
2691 struct elf_link_hash_entry
**sym_hashes
;
2692 bfd_signed_vma
*local_got_refcounts
;
2693 const Elf_Internal_Rela
*rel
, *relend
;
2694 unsigned long r_symndx
;
2695 struct elf_link_hash_entry
*h
;
2697 elf_section_data (sec
)->local_dynrel
= NULL
;
2699 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2700 sym_hashes
= elf_sym_hashes (abfd
);
2701 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2703 relend
= relocs
+ sec
->reloc_count
;
2704 for (rel
= relocs
; rel
< relend
; rel
++)
2705 switch (ELF32_R_TYPE (rel
->r_info
))
2708 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2709 if (r_symndx
>= symtab_hdr
->sh_info
)
2711 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2712 if (h
->got
.refcount
> 0)
2713 h
->got
.refcount
-= 1;
2715 else if (local_got_refcounts
!= NULL
)
2717 if (local_got_refcounts
[r_symndx
] > 0)
2718 local_got_refcounts
[r_symndx
] -= 1;
2726 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2727 if (r_symndx
>= symtab_hdr
->sh_info
)
2729 struct elf32_arm_link_hash_entry
*eh
;
2730 struct elf32_arm_relocs_copied
**pp
;
2731 struct elf32_arm_relocs_copied
*p
;
2733 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2735 if (h
->plt
.refcount
> 0)
2736 h
->plt
.refcount
-= 1;
2738 if (ELF32_R_TYPE (rel
->r_info
) == R_ARM_ABS32
2739 || ELF32_R_TYPE (rel
->r_info
) == R_ARM_REL32
)
2741 eh
= (struct elf32_arm_link_hash_entry
*) h
;
2743 for (pp
= &eh
->relocs_copied
; (p
= *pp
) != NULL
;
2745 if (p
->section
== sec
)
2763 /* Look through the relocs for a section during the first phase. */
2766 elf32_arm_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
2767 asection
*sec
, const Elf_Internal_Rela
*relocs
)
2769 Elf_Internal_Shdr
*symtab_hdr
;
2770 struct elf_link_hash_entry
**sym_hashes
;
2771 struct elf_link_hash_entry
**sym_hashes_end
;
2772 const Elf_Internal_Rela
*rel
;
2773 const Elf_Internal_Rela
*rel_end
;
2776 bfd_vma
*local_got_offsets
;
2777 struct elf32_arm_link_hash_table
*htab
;
2779 if (info
->relocatable
)
2782 htab
= elf32_arm_hash_table (info
);
2785 dynobj
= elf_hash_table (info
)->dynobj
;
2786 local_got_offsets
= elf_local_got_offsets (abfd
);
2788 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2789 sym_hashes
= elf_sym_hashes (abfd
);
2790 sym_hashes_end
= sym_hashes
2791 + symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
2793 if (!elf_bad_symtab (abfd
))
2794 sym_hashes_end
-= symtab_hdr
->sh_info
;
2796 rel_end
= relocs
+ sec
->reloc_count
;
2797 for (rel
= relocs
; rel
< rel_end
; rel
++)
2799 struct elf_link_hash_entry
*h
;
2800 unsigned long r_symndx
;
2802 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2803 if (r_symndx
< symtab_hdr
->sh_info
)
2806 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2808 switch (ELF32_R_TYPE (rel
->r_info
))
2811 /* This symbol requires a global offset table entry. */
2818 bfd_signed_vma
*local_got_refcounts
;
2820 /* This is a global offset table entry for a local symbol. */
2821 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2822 if (local_got_refcounts
== NULL
)
2826 size
= symtab_hdr
->sh_info
;
2827 size
*= (sizeof (bfd_signed_vma
) + sizeof (char));
2828 local_got_refcounts
= bfd_zalloc (abfd
, size
);
2829 if (local_got_refcounts
== NULL
)
2831 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
2833 local_got_refcounts
[r_symndx
] += 1;
2839 if (htab
->sgot
== NULL
)
2841 if (htab
->root
.dynobj
== NULL
)
2842 htab
->root
.dynobj
= abfd
;
2843 if (!create_got_section (htab
->root
.dynobj
, info
))
2854 /* If this reloc is in a read-only section, we might
2855 need a copy reloc. We can't check reliably at this
2856 stage whether the section is read-only, as input
2857 sections have not yet been mapped to output sections.
2858 Tentatively set the flag for now, and correct in
2859 adjust_dynamic_symbol. */
2861 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
2863 /* We may need a .plt entry if the function this reloc
2864 refers to is in a different object. We can't tell for
2865 sure yet, because something later might force the
2867 if (ELF32_R_TYPE (rel
->r_info
) == R_ARM_PC24
2868 || ELF32_R_TYPE (rel
->r_info
) == R_ARM_PLT32
)
2869 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2871 /* If we create a PLT entry, this relocation will reference
2872 it, even if it's an ABS32 relocation. */
2873 h
->plt
.refcount
+= 1;
2876 /* If we are creating a shared library, and this is a reloc
2877 against a global symbol, or a non PC relative reloc
2878 against a local symbol, then we need to copy the reloc
2879 into the shared library. However, if we are linking with
2880 -Bsymbolic, we do not need to copy a reloc against a
2881 global symbol which is defined in an object we are
2882 including in the link (i.e., DEF_REGULAR is set). At
2883 this point we have not seen all the input files, so it is
2884 possible that DEF_REGULAR is not set now but will be set
2885 later (it is never cleared). We account for that
2886 possibility below by storing information in the
2887 relocs_copied field of the hash table entry. */
2889 && (sec
->flags
& SEC_ALLOC
) != 0
2890 && ((ELF32_R_TYPE (rel
->r_info
) != R_ARM_PC24
2891 && ELF32_R_TYPE (rel
->r_info
) != R_ARM_PLT32
2892 && ELF32_R_TYPE (rel
->r_info
) != R_ARM_REL32
)
2894 && (! info
->symbolic
2895 || (h
->elf_link_hash_flags
2896 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
2898 struct elf32_arm_relocs_copied
*p
, **head
;
2900 /* When creating a shared object, we must copy these
2901 reloc types into the output file. We create a reloc
2902 section in dynobj and make room for this reloc. */
2907 name
= (bfd_elf_string_from_elf_section
2909 elf_elfheader (abfd
)->e_shstrndx
,
2910 elf_section_data (sec
)->rel_hdr
.sh_name
));
2914 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
2915 && strcmp (bfd_get_section_name (abfd
, sec
),
2918 sreloc
= bfd_get_section_by_name (dynobj
, name
);
2923 sreloc
= bfd_make_section (dynobj
, name
);
2924 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
2925 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
2926 if ((sec
->flags
& SEC_ALLOC
) != 0)
2927 flags
|= SEC_ALLOC
| SEC_LOAD
;
2929 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
2930 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
2934 elf_section_data (sec
)->sreloc
= sreloc
;
2937 /* If this is a global symbol, we count the number of
2938 relocations we need for this symbol. */
2941 head
= &((struct elf32_arm_link_hash_entry
*) h
)->relocs_copied
;
2945 /* Track dynamic relocs needed for local syms too.
2946 We really need local syms available to do this
2950 s
= bfd_section_from_r_symndx (abfd
, &htab
->sym_sec
,
2955 head
= ((struct elf32_arm_relocs_copied
**)
2956 &elf_section_data (s
)->local_dynrel
);
2960 if (p
== NULL
|| p
->section
!= sec
)
2962 bfd_size_type amt
= sizeof *p
;
2964 p
= bfd_alloc (htab
->root
.dynobj
, amt
);
2973 if (ELF32_R_TYPE (rel
->r_info
) == R_ARM_ABS32
2974 || ELF32_R_TYPE (rel
->r_info
) == R_ARM_REL32
)
2979 /* This relocation describes the C++ object vtable hierarchy.
2980 Reconstruct it for later use during GC. */
2981 case R_ARM_GNU_VTINHERIT
:
2982 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2986 /* This relocation describes which C++ vtable entries are actually
2987 used. Record for later use during GC. */
2988 case R_ARM_GNU_VTENTRY
:
2989 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
2999 is_arm_mapping_symbol_name (const char * name
)
3001 return (name
!= NULL
)
3003 && ((name
[1] == 'a') || (name
[1] == 't') || (name
[1] == 'd'))
3007 /* This is a copy of elf_find_function() from elf.c except that
3008 ARM mapping symbols are ignored when looking for function names
3009 and STT_ARM_TFUNC is considered to a function type. */
3012 arm_elf_find_function (bfd
* abfd ATTRIBUTE_UNUSED
,
3016 const char ** filename_ptr
,
3017 const char ** functionname_ptr
)
3019 const char * filename
= NULL
;
3020 asymbol
* func
= NULL
;
3021 bfd_vma low_func
= 0;
3024 for (p
= symbols
; *p
!= NULL
; p
++)
3028 q
= (elf_symbol_type
*) *p
;
3030 if (bfd_get_section (&q
->symbol
) != section
)
3033 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
3038 filename
= bfd_asymbol_name (&q
->symbol
);
3042 /* Skip $a and $t symbols. */
3043 if ((q
->symbol
.flags
& BSF_LOCAL
)
3044 && is_arm_mapping_symbol_name (q
->symbol
.name
))
3048 if (q
->symbol
.section
== section
3049 && q
->symbol
.value
>= low_func
3050 && q
->symbol
.value
<= offset
)
3052 func
= (asymbol
*) q
;
3053 low_func
= q
->symbol
.value
;
3063 *filename_ptr
= filename
;
3064 if (functionname_ptr
)
3065 *functionname_ptr
= bfd_asymbol_name (func
);
3071 /* Find the nearest line to a particular section and offset, for error
3072 reporting. This code is a duplicate of the code in elf.c, except
3073 that it uses arm_elf_find_function. */
3076 elf32_arm_find_nearest_line (bfd
* abfd
,
3080 const char ** filename_ptr
,
3081 const char ** functionname_ptr
,
3082 unsigned int * line_ptr
)
3084 bfd_boolean found
= FALSE
;
3086 /* We skip _bfd_dwarf1_find_nearest_line since no known ARM toolchain uses it. */
3088 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
3089 filename_ptr
, functionname_ptr
,
3091 & elf_tdata (abfd
)->dwarf2_find_line_info
))
3093 if (!*functionname_ptr
)
3094 arm_elf_find_function (abfd
, section
, symbols
, offset
,
3095 *filename_ptr
? NULL
: filename_ptr
,
3101 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
3102 & found
, filename_ptr
,
3103 functionname_ptr
, line_ptr
,
3104 & elf_tdata (abfd
)->line_info
))
3107 if (found
&& (*functionname_ptr
|| *line_ptr
))
3110 if (symbols
== NULL
)
3113 if (! arm_elf_find_function (abfd
, section
, symbols
, offset
,
3114 filename_ptr
, functionname_ptr
))
3121 /* Adjust a symbol defined by a dynamic object and referenced by a
3122 regular object. The current definition is in some section of the
3123 dynamic object, but we're not including those sections. We have to
3124 change the definition to something the rest of the link can
3128 elf32_arm_adjust_dynamic_symbol (struct bfd_link_info
* info
,
3129 struct elf_link_hash_entry
* h
)
3133 unsigned int power_of_two
;
3135 dynobj
= elf_hash_table (info
)->dynobj
;
3137 /* Make sure we know what is going on here. */
3138 BFD_ASSERT (dynobj
!= NULL
3139 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
3140 || h
->weakdef
!= NULL
3141 || ((h
->elf_link_hash_flags
3142 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
3143 && (h
->elf_link_hash_flags
3144 & ELF_LINK_HASH_REF_REGULAR
) != 0
3145 && (h
->elf_link_hash_flags
3146 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
3148 /* If this is a function, put it in the procedure linkage table. We
3149 will fill in the contents of the procedure linkage table later,
3150 when we know the address of the .got section. */
3151 if (h
->type
== STT_FUNC
3152 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
3154 if (h
->plt
.refcount
<= 0
3155 || SYMBOL_CALLS_LOCAL (info
, h
)
3156 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
3157 && h
->root
.type
== bfd_link_hash_undefweak
))
3159 /* This case can occur if we saw a PLT32 reloc in an input
3160 file, but the symbol was never referred to by a dynamic
3161 object, or if all references were garbage collected. In
3162 such a case, we don't actually need to build a procedure
3163 linkage table, and we can just do a PC24 reloc instead. */
3164 h
->plt
.offset
= (bfd_vma
) -1;
3165 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
3171 /* It's possible that we incorrectly decided a .plt reloc was
3172 needed for an R_ARM_PC24 reloc to a non-function sym in
3173 check_relocs. We can't decide accurately between function and
3174 non-function syms in check-relocs; Objects loaded later in
3175 the link may change h->type. So fix it now. */
3176 h
->plt
.offset
= (bfd_vma
) -1;
3178 /* If this is a weak symbol, and there is a real definition, the
3179 processor independent code will have arranged for us to see the
3180 real definition first, and we can just use the same value. */
3181 if (h
->weakdef
!= NULL
)
3183 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
3184 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
3185 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
3186 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
3190 /* This is a reference to a symbol defined by a dynamic object which
3191 is not a function. */
3193 /* If we are creating a shared library, we must presume that the
3194 only references to the symbol are via the global offset table.
3195 For such cases we need not do anything here; the relocations will
3196 be handled correctly by relocate_section. */
3200 /* We must allocate the symbol in our .dynbss section, which will
3201 become part of the .bss section of the executable. There will be
3202 an entry for this symbol in the .dynsym section. The dynamic
3203 object will contain position independent code, so all references
3204 from the dynamic object to this symbol will go through the global
3205 offset table. The dynamic linker will use the .dynsym entry to
3206 determine the address it must put in the global offset table, so
3207 both the dynamic object and the regular object will refer to the
3208 same memory location for the variable. */
3209 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
3210 BFD_ASSERT (s
!= NULL
);
3212 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
3213 copy the initial value out of the dynamic object and into the
3214 runtime process image. We need to remember the offset into the
3215 .rel.bss section we are going to use. */
3216 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
3220 srel
= bfd_get_section_by_name (dynobj
, ".rel.bss");
3221 BFD_ASSERT (srel
!= NULL
);
3222 srel
->size
+= sizeof (Elf32_External_Rel
);
3223 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
3226 /* We need to figure out the alignment required for this symbol. I
3227 have no idea how ELF linkers handle this. */
3228 power_of_two
= bfd_log2 (h
->size
);
3229 if (power_of_two
> 3)
3232 /* Apply the required alignment. */
3233 s
->size
= BFD_ALIGN (s
->size
, (bfd_size_type
) (1 << power_of_two
));
3234 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
3236 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
3240 /* Define the symbol as being at this point in the section. */
3241 h
->root
.u
.def
.section
= s
;
3242 h
->root
.u
.def
.value
= s
->size
;
3244 /* Increment the section size to make room for the symbol. */
3250 /* Allocate space in .plt, .got and associated reloc sections for
3254 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
3256 struct bfd_link_info
*info
;
3257 struct elf32_arm_link_hash_table
*htab
;
3258 struct elf32_arm_link_hash_entry
*eh
;
3259 struct elf32_arm_relocs_copied
*p
;
3261 if (h
->root
.type
== bfd_link_hash_indirect
)
3264 if (h
->root
.type
== bfd_link_hash_warning
)
3265 /* When warning symbols are created, they **replace** the "real"
3266 entry in the hash table, thus we never get to see the real
3267 symbol in a hash traversal. So look at it now. */
3268 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3270 info
= (struct bfd_link_info
*) inf
;
3271 htab
= elf32_arm_hash_table (info
);
3273 if (htab
->root
.dynamic_sections_created
3274 && h
->plt
.refcount
> 0)
3276 /* Make sure this symbol is output as a dynamic symbol.
3277 Undefined weak syms won't yet be marked as dynamic. */
3278 if (h
->dynindx
== -1
3279 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
3281 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3286 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
3288 asection
*s
= htab
->splt
;
3290 /* If this is the first .plt entry, make room for the special
3293 s
->size
+= PLT_HEADER_SIZE
;
3295 h
->plt
.offset
= s
->size
;
3297 /* If this symbol is not defined in a regular file, and we are
3298 not generating a shared library, then set the symbol to this
3299 location in the .plt. This is required to make function
3300 pointers compare as equal between the normal executable and
3301 the shared library. */
3303 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3305 h
->root
.u
.def
.section
= s
;
3306 h
->root
.u
.def
.value
= h
->plt
.offset
;
3309 /* Make room for this entry. */
3310 s
->size
+= PLT_ENTRY_SIZE
;
3312 /* We also need to make an entry in the .got.plt section, which
3313 will be placed in the .got section by the linker script. */
3314 htab
->sgotplt
->size
+= 4;
3316 /* We also need to make an entry in the .rel.plt section. */
3317 htab
->srelplt
->size
+= sizeof (Elf32_External_Rel
);
3321 h
->plt
.offset
= (bfd_vma
) -1;
3322 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
3327 h
->plt
.offset
= (bfd_vma
) -1;
3328 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
3331 if (h
->got
.refcount
> 0)
3336 /* Make sure this symbol is output as a dynamic symbol.
3337 Undefined weak syms won't yet be marked as dynamic. */
3338 if (h
->dynindx
== -1
3339 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
3341 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3346 h
->got
.offset
= s
->size
;
3348 dyn
= htab
->root
.dynamic_sections_created
;
3349 if ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3350 || h
->root
.type
!= bfd_link_hash_undefweak
)
3352 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
3353 htab
->srelgot
->size
+= sizeof (Elf32_External_Rel
);
3356 h
->got
.offset
= (bfd_vma
) -1;
3358 eh
= (struct elf32_arm_link_hash_entry
*) h
;
3359 if (eh
->relocs_copied
== NULL
)
3362 /* In the shared -Bsymbolic case, discard space allocated for
3363 dynamic pc-relative relocs against symbols which turn out to be
3364 defined in regular objects. For the normal shared case, discard
3365 space for pc-relative relocs that have become local due to symbol
3366 visibility changes. */
3370 /* Discard relocs on undefined weak syms with non-default
3372 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
3373 && h
->root
.type
== bfd_link_hash_undefweak
)
3374 eh
->relocs_copied
= NULL
;
3378 /* For the non-shared case, discard space for relocs against
3379 symbols which turn out to need copy relocs or are not
3382 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
3383 && (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
3384 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3385 || (htab
->root
.dynamic_sections_created
3386 && (h
->root
.type
== bfd_link_hash_undefweak
3387 || h
->root
.type
== bfd_link_hash_undefined
))))
3389 /* Make sure this symbol is output as a dynamic symbol.
3390 Undefined weak syms won't yet be marked as dynamic. */
3391 if (h
->dynindx
== -1
3392 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
3394 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3398 /* If that succeeded, we know we'll be keeping all the
3400 if (h
->dynindx
!= -1)
3404 eh
->relocs_copied
= NULL
;
3409 /* Finally, allocate space. */
3410 for (p
= eh
->relocs_copied
; p
!= NULL
; p
= p
->next
)
3412 asection
*sreloc
= elf_section_data (p
->section
)->sreloc
;
3413 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
3419 /* Set the sizes of the dynamic sections. */
3422 elf32_arm_size_dynamic_sections (bfd
* output_bfd ATTRIBUTE_UNUSED
,
3423 struct bfd_link_info
* info
)
3430 struct elf32_arm_link_hash_table
*htab
;
3432 htab
= elf32_arm_hash_table (info
);
3433 dynobj
= elf_hash_table (info
)->dynobj
;
3434 BFD_ASSERT (dynobj
!= NULL
);
3436 if (elf_hash_table (info
)->dynamic_sections_created
)
3438 /* Set the contents of the .interp section to the interpreter. */
3439 if (info
->executable
)
3441 s
= bfd_get_section_by_name (dynobj
, ".interp");
3442 BFD_ASSERT (s
!= NULL
);
3443 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
3444 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
3448 /* Set up .got offsets for local syms, and space for local dynamic
3450 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
3452 bfd_signed_vma
*local_got
;
3453 bfd_signed_vma
*end_local_got
;
3454 char *local_tls_type
;
3455 bfd_size_type locsymcount
;
3456 Elf_Internal_Shdr
*symtab_hdr
;
3459 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
3462 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3464 struct elf32_arm_relocs_copied
*p
;
3466 for (p
= *((struct elf32_arm_relocs_copied
**)
3467 &elf_section_data (s
)->local_dynrel
);
3471 if (!bfd_is_abs_section (p
->section
)
3472 && bfd_is_abs_section (p
->section
->output_section
))
3474 /* Input section has been discarded, either because
3475 it is a copy of a linkonce section or due to
3476 linker script /DISCARD/, so we'll be discarding
3479 else if (p
->count
!= 0)
3481 srel
= elf_section_data (p
->section
)->sreloc
;
3482 srel
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
3483 if ((p
->section
->output_section
->flags
& SEC_READONLY
) != 0)
3484 info
->flags
|= DF_TEXTREL
;
3489 local_got
= elf_local_got_refcounts (ibfd
);
3493 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
3494 locsymcount
= symtab_hdr
->sh_info
;
3495 end_local_got
= local_got
+ locsymcount
;
3497 srel
= htab
->srelgot
;
3498 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
3502 *local_got
= s
->size
;
3505 srel
->size
+= sizeof (Elf32_External_Rel
);
3508 *local_got
= (bfd_vma
) -1;
3512 /* Allocate global sym .plt and .got entries, and space for global
3513 sym dynamic relocs. */
3514 elf_link_hash_traverse (& htab
->root
, allocate_dynrelocs
, info
);
3516 /* The check_relocs and adjust_dynamic_symbol entry points have
3517 determined the sizes of the various dynamic sections. Allocate
3521 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3526 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3529 /* It's OK to base decisions on the section name, because none
3530 of the dynobj section names depend upon the input files. */
3531 name
= bfd_get_section_name (dynobj
, s
);
3535 if (strcmp (name
, ".plt") == 0)
3539 /* Strip this section if we don't need it; see the
3545 /* Remember whether there is a PLT. */
3549 else if (strncmp (name
, ".rel", 4) == 0)
3553 /* If we don't need this section, strip it from the
3554 output file. This is mostly to handle .rel.bss and
3555 .rel.plt. We must create both sections in
3556 create_dynamic_sections, because they must be created
3557 before the linker maps input sections to output
3558 sections. The linker does that before
3559 adjust_dynamic_symbol is called, and it is that
3560 function which decides whether anything needs to go
3561 into these sections. */
3566 /* Remember whether there are any reloc sections other
3568 if (strcmp (name
, ".rel.plt") != 0)
3571 /* We use the reloc_count field as a counter if we need
3572 to copy relocs into the output file. */
3576 else if (strncmp (name
, ".got", 4) != 0)
3578 /* It's not one of our sections, so don't allocate space. */
3584 _bfd_strip_section_from_output (info
, s
);
3588 /* Allocate memory for the section contents. */
3589 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3590 if (s
->contents
== NULL
&& s
->size
!= 0)
3594 if (elf_hash_table (info
)->dynamic_sections_created
)
3596 /* Add some entries to the .dynamic section. We fill in the
3597 values later, in elf32_arm_finish_dynamic_sections, but we
3598 must add the entries now so that we get the correct size for
3599 the .dynamic section. The DT_DEBUG entry is filled in by the
3600 dynamic linker and used by the debugger. */
3601 #define add_dynamic_entry(TAG, VAL) \
3602 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3606 if (!add_dynamic_entry (DT_DEBUG
, 0))
3612 if ( !add_dynamic_entry (DT_PLTGOT
, 0)
3613 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
3614 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
3615 || !add_dynamic_entry (DT_JMPREL
, 0))
3621 if ( !add_dynamic_entry (DT_REL
, 0)
3622 || !add_dynamic_entry (DT_RELSZ
, 0)
3623 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
3627 if ((info
->flags
& DF_TEXTREL
) != 0)
3629 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3631 info
->flags
|= DF_TEXTREL
;
3634 #undef add_synamic_entry
3639 /* Finish up dynamic symbol handling. We set the contents of various
3640 dynamic sections here. */
3643 elf32_arm_finish_dynamic_symbol (bfd
* output_bfd
, struct bfd_link_info
* info
,
3644 struct elf_link_hash_entry
* h
, Elf_Internal_Sym
* sym
)
3648 dynobj
= elf_hash_table (info
)->dynobj
;
3650 if (h
->plt
.offset
!= (bfd_vma
) -1)
3657 Elf_Internal_Rela rel
;
3659 bfd_vma got_displacement
;
3661 /* This symbol has an entry in the procedure linkage table. Set
3664 BFD_ASSERT (h
->dynindx
!= -1);
3666 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3667 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3668 srel
= bfd_get_section_by_name (dynobj
, ".rel.plt");
3669 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
3671 /* Get the index in the procedure linkage table which
3672 corresponds to this symbol. This is the index of this symbol
3673 in all the symbols for which we are making plt entries. The
3674 first entry in the procedure linkage table is reserved. */
3675 plt_index
= (h
->plt
.offset
- PLT_HEADER_SIZE
) / PLT_ENTRY_SIZE
;
3677 /* Get the offset into the .got table of the entry that
3678 corresponds to this function. Each .got entry is 4 bytes.
3679 The first three are reserved. */
3680 got_offset
= (plt_index
+ 3) * 4;
3682 /* Calculate the displacement between the PLT slot and the
3683 entry in the GOT. */
3684 got_displacement
= (sgot
->output_section
->vma
3685 + sgot
->output_offset
3687 - splt
->output_section
->vma
3688 - splt
->output_offset
3692 BFD_ASSERT ((got_displacement
& 0xf0000000) == 0);
3694 /* Fill in the entry in the procedure linkage table. */
3695 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[0] | ((got_displacement
& 0x0ff00000) >> 20),
3696 splt
->contents
+ h
->plt
.offset
+ 0);
3697 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[1] | ((got_displacement
& 0x000ff000) >> 12),
3698 splt
->contents
+ h
->plt
.offset
+ 4);
3699 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[2] | (got_displacement
& 0x00000fff),
3700 splt
->contents
+ h
->plt
.offset
+ 8);
3701 #ifdef FOUR_WORD_PLT
3702 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[3],
3703 splt
->contents
+ h
->plt
.offset
+ 12);
3706 /* Fill in the entry in the global offset table. */
3707 bfd_put_32 (output_bfd
,
3708 (splt
->output_section
->vma
3709 + splt
->output_offset
),
3710 sgot
->contents
+ got_offset
);
3712 /* Fill in the entry in the .rel.plt section. */
3713 rel
.r_offset
= (sgot
->output_section
->vma
3714 + sgot
->output_offset
3716 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_JUMP_SLOT
);
3717 loc
= srel
->contents
+ plt_index
* sizeof (Elf32_External_Rel
);
3718 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3720 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3722 /* Mark the symbol as undefined, rather than as defined in
3723 the .plt section. Leave the value alone. */
3724 sym
->st_shndx
= SHN_UNDEF
;
3725 /* If the symbol is weak, we do need to clear the value.
3726 Otherwise, the PLT entry would provide a definition for
3727 the symbol even if the symbol wasn't defined anywhere,
3728 and so the symbol would never be NULL. */
3729 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR_NONWEAK
)
3735 if (h
->got
.offset
!= (bfd_vma
) -1)
3739 Elf_Internal_Rela rel
;
3742 /* This symbol has an entry in the global offset table. Set it
3744 sgot
= bfd_get_section_by_name (dynobj
, ".got");
3745 srel
= bfd_get_section_by_name (dynobj
, ".rel.got");
3746 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
3748 rel
.r_offset
= (sgot
->output_section
->vma
3749 + sgot
->output_offset
3750 + (h
->got
.offset
&~ (bfd_vma
) 1));
3752 /* If this is a static link, or it is a -Bsymbolic link and the
3753 symbol is defined locally or was forced to be local because
3754 of a version file, we just want to emit a RELATIVE reloc.
3755 The entry in the global offset table will already have been
3756 initialized in the relocate_section function. */
3758 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3760 BFD_ASSERT((h
->got
.offset
& 1) != 0);
3761 rel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
3765 BFD_ASSERT((h
->got
.offset
& 1) == 0);
3766 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
3767 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_GLOB_DAT
);
3770 loc
= srel
->contents
+ srel
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3771 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3774 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
3777 Elf_Internal_Rela rel
;
3780 /* This symbol needs a copy reloc. Set it up. */
3781 BFD_ASSERT (h
->dynindx
!= -1
3782 && (h
->root
.type
== bfd_link_hash_defined
3783 || h
->root
.type
== bfd_link_hash_defweak
));
3785 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
3787 BFD_ASSERT (s
!= NULL
);
3789 rel
.r_offset
= (h
->root
.u
.def
.value
3790 + h
->root
.u
.def
.section
->output_section
->vma
3791 + h
->root
.u
.def
.section
->output_offset
);
3792 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_COPY
);
3793 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3794 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3797 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3798 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3799 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
3800 sym
->st_shndx
= SHN_ABS
;
3805 /* Finish up the dynamic sections. */
3808 elf32_arm_finish_dynamic_sections (bfd
* output_bfd
, struct bfd_link_info
* info
)
3814 dynobj
= elf_hash_table (info
)->dynobj
;
3816 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3817 BFD_ASSERT (sgot
!= NULL
);
3818 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3820 if (elf_hash_table (info
)->dynamic_sections_created
)
3823 Elf32_External_Dyn
*dyncon
, *dynconend
;
3825 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3826 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3828 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3829 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
3831 for (; dyncon
< dynconend
; dyncon
++)
3833 Elf_Internal_Dyn dyn
;
3837 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3850 s
= bfd_get_section_by_name (output_bfd
, name
);
3851 BFD_ASSERT (s
!= NULL
);
3852 dyn
.d_un
.d_ptr
= s
->vma
;
3853 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3857 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3858 BFD_ASSERT (s
!= NULL
);
3859 dyn
.d_un
.d_val
= s
->size
;
3860 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3864 /* My reading of the SVR4 ABI indicates that the
3865 procedure linkage table relocs (DT_JMPREL) should be
3866 included in the overall relocs (DT_REL). This is
3867 what Solaris does. However, UnixWare can not handle
3868 that case. Therefore, we override the DT_RELSZ entry
3869 here to make it not include the JMPREL relocs. Since
3870 the linker script arranges for .rel.plt to follow all
3871 other relocation sections, we don't have to worry
3872 about changing the DT_REL entry. */
3873 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3875 dyn
.d_un
.d_val
-= s
->size
;
3876 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3879 /* Set the bottom bit of DT_INIT/FINI if the
3880 corresponding function is Thumb. */
3882 name
= info
->init_function
;
3885 name
= info
->fini_function
;
3887 /* If it wasn't set by elf_bfd_final_link
3888 then there is nothing to adjust. */
3889 if (dyn
.d_un
.d_val
!= 0)
3891 struct elf_link_hash_entry
* eh
;
3893 eh
= elf_link_hash_lookup (elf_hash_table (info
), name
,
3894 FALSE
, FALSE
, TRUE
);
3895 if (eh
!= (struct elf_link_hash_entry
*) NULL
3896 && ELF_ST_TYPE (eh
->type
) == STT_ARM_TFUNC
)
3898 dyn
.d_un
.d_val
|= 1;
3899 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3906 /* Fill in the first entry in the procedure linkage table. */
3909 bfd_vma got_displacement
;
3911 /* Calculate the displacement between the PLT slot and &GOT[0]. */
3912 got_displacement
= (sgot
->output_section
->vma
3913 + sgot
->output_offset
3914 - splt
->output_section
->vma
3915 - splt
->output_offset
3918 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[0], splt
->contents
+ 0);
3919 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[1], splt
->contents
+ 4);
3920 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[2], splt
->contents
+ 8);
3921 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[3], splt
->contents
+ 12);
3922 #ifdef FOUR_WORD_PLT
3923 /* The displacement value goes in the otherwise-unused last word of
3924 the second entry. */
3925 bfd_put_32 (output_bfd
, got_displacement
, splt
->contents
+ 28);
3927 bfd_put_32 (output_bfd
, got_displacement
, splt
->contents
+ 16);
3931 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3932 really seem like the right value. */
3933 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
3936 /* Fill in the first three entries in the global offset table. */
3940 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
3942 bfd_put_32 (output_bfd
,
3943 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3945 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
3946 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
3949 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
3955 elf32_arm_post_process_headers (bfd
* abfd
, struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
)
3957 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
3958 struct elf32_arm_link_hash_table
*globals
;
3960 i_ehdrp
= elf_elfheader (abfd
);
3962 i_ehdrp
->e_ident
[EI_OSABI
] = ARM_ELF_OS_ABI_VERSION
;
3963 i_ehdrp
->e_ident
[EI_ABIVERSION
] = ARM_ELF_ABI_VERSION
;
3967 globals
= elf32_arm_hash_table (link_info
);
3968 if (globals
->byteswap_code
)
3969 i_ehdrp
->e_flags
|= EF_ARM_BE8
;
3973 static enum elf_reloc_type_class
3974 elf32_arm_reloc_type_class (const Elf_Internal_Rela
*rela
)
3976 switch ((int) ELF32_R_TYPE (rela
->r_info
))
3978 case R_ARM_RELATIVE
:
3979 return reloc_class_relative
;
3980 case R_ARM_JUMP_SLOT
:
3981 return reloc_class_plt
;
3983 return reloc_class_copy
;
3985 return reloc_class_normal
;
3989 static bfd_boolean
elf32_arm_section_flags (flagword
*, const Elf_Internal_Shdr
*);
3990 static void elf32_arm_final_write_processing (bfd
*, bfd_boolean
);
3992 /* Set the right machine number for an Arm ELF file. */
3995 elf32_arm_section_flags (flagword
*flags
, const Elf_Internal_Shdr
*hdr
)
3997 if (hdr
->sh_type
== SHT_NOTE
)
3998 *flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_CONTENTS
;
4004 elf32_arm_final_write_processing (bfd
*abfd
, bfd_boolean linker ATTRIBUTE_UNUSED
)
4006 bfd_arm_update_notes (abfd
, ARM_NOTE_SECTION
);
4010 /* Called for each symbol. Builds a section map based on mapping symbols.
4011 Does not alter any of the symbols. */
4014 elf32_arm_output_symbol_hook (struct bfd_link_info
*info
,
4016 Elf_Internal_Sym
*elfsym
,
4017 asection
*input_sec
,
4018 struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
4021 elf32_arm_section_map
*map
;
4022 struct elf32_arm_link_hash_table
*globals
;
4024 /* Only do this on final link. */
4025 if (info
->relocatable
)
4028 /* Only build a map if we need to byteswap code. */
4029 globals
= elf32_arm_hash_table (info
);
4030 if (!globals
->byteswap_code
)
4033 /* We only want mapping symbols. */
4034 if (! is_arm_mapping_symbol_name (name
))
4037 mapcount
= ++(elf32_arm_section_data (input_sec
)->mapcount
);
4038 map
= elf32_arm_section_data (input_sec
)->map
;
4039 /* TODO: This may be inefficient, but we probably don't usually have many
4040 mapping symbols per section. */
4041 map
= bfd_realloc (map
, mapcount
* sizeof (elf32_arm_section_map
));
4042 elf32_arm_section_data (input_sec
)->map
= map
;
4044 map
[mapcount
- 1].vma
= elfsym
->st_value
;
4045 map
[mapcount
- 1].type
= name
[1];
4050 /* Allocate target specific section data. */
4053 elf32_arm_new_section_hook (bfd
*abfd
, asection
*sec
)
4055 struct _arm_elf_section_data
*sdata
;
4056 bfd_size_type amt
= sizeof (*sdata
);
4058 sdata
= bfd_zalloc (abfd
, amt
);
4061 sec
->used_by_bfd
= sdata
;
4063 return _bfd_elf_new_section_hook (abfd
, sec
);
4067 /* Used to order a list of mapping symbols by address. */
4070 elf32_arm_compare_mapping (const void * a
, const void * b
)
4072 return ((const elf32_arm_section_map
*) a
)->vma
4073 > ((const elf32_arm_section_map
*) b
)->vma
;
4077 /* Do code byteswapping. Return FALSE afterwards so that the section is
4078 written out as normal. */
4081 elf32_arm_write_section (bfd
*output_bfd ATTRIBUTE_UNUSED
, asection
*sec
,
4085 elf32_arm_section_map
*map
;
4092 mapcount
= elf32_arm_section_data (sec
)->mapcount
;
4093 map
= elf32_arm_section_data (sec
)->map
;
4098 qsort (map
, mapcount
, sizeof (elf32_arm_section_map
),
4099 elf32_arm_compare_mapping
);
4101 offset
= sec
->output_section
->vma
+ sec
->output_offset
;
4102 ptr
= map
[0].vma
- offset
;
4103 for (i
= 0; i
< mapcount
; i
++)
4105 if (i
== mapcount
- 1)
4108 end
= map
[i
+ 1].vma
- offset
;
4110 switch (map
[i
].type
)
4113 /* Byte swap code words. */
4114 while (ptr
+ 3 < end
)
4116 tmp
= contents
[ptr
];
4117 contents
[ptr
] = contents
[ptr
+ 3];
4118 contents
[ptr
+ 3] = tmp
;
4119 tmp
= contents
[ptr
+ 1];
4120 contents
[ptr
+ 1] = contents
[ptr
+ 2];
4121 contents
[ptr
+ 2] = tmp
;
4127 /* Byte swap code halfwords. */
4128 while (ptr
+ 1 < end
)
4130 tmp
= contents
[ptr
];
4131 contents
[ptr
] = contents
[ptr
+ 1];
4132 contents
[ptr
+ 1] = tmp
;
4138 /* Leave data alone. */
4147 #define ELF_ARCH bfd_arch_arm
4148 #define ELF_MACHINE_CODE EM_ARM
4149 #ifdef __QNXTARGET__
4150 #define ELF_MAXPAGESIZE 0x1000
4152 #define ELF_MAXPAGESIZE 0x8000
4155 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
4156 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
4157 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
4158 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
4159 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
4160 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
4161 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
4162 #define bfd_elf32_new_section_hook elf32_arm_new_section_hook
4164 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
4165 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
4166 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
4167 #define elf_backend_check_relocs elf32_arm_check_relocs
4168 #define elf_backend_relocate_section elf32_arm_relocate_section
4169 #define elf_backend_write_section elf32_arm_write_section
4170 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
4171 #define elf_backend_create_dynamic_sections elf32_arm_create_dynamic_sections
4172 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
4173 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
4174 #define elf_backend_link_output_symbol_hook elf32_arm_output_symbol_hook
4175 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
4176 #define elf_backend_post_process_headers elf32_arm_post_process_headers
4177 #define elf_backend_reloc_type_class elf32_arm_reloc_type_class
4178 #define elf_backend_object_p elf32_arm_object_p
4179 #define elf_backend_section_flags elf32_arm_section_flags
4180 #define elf_backend_final_write_processing elf32_arm_final_write_processing
4181 #define elf_backend_copy_indirect_symbol elf32_arm_copy_indirect_symbol
4183 #define elf_backend_can_refcount 1
4184 #define elf_backend_can_gc_sections 1
4185 #define elf_backend_plt_readonly 1
4186 #define elf_backend_want_got_plt 1
4187 #define elf_backend_want_plt_sym 0
4189 #define elf_backend_rela_normal 1
4192 #define elf_backend_got_header_size 12
4194 #include "elf32-target.h"