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 lieu 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 first entry in a procedure linkage table looks like
50 this. It is set up so that any shared library function that is
51 called before the relocation has been set up calls the dynamic
53 static const bfd_vma elf32_arm_plt0_entry
[] =
55 0xe52de004, /* str lr, [sp, #-4]! */
56 0xe59fe010, /* ldr lr, [pc, #16] */
57 0xe08fe00e, /* add lr, pc, lr */
58 0xe5bef008, /* ldr pc, [lr, #8]! */
61 /* Subsequent entries in a procedure linkage table look like
63 static const bfd_vma elf32_arm_plt_entry
[] =
65 0xe28fc600, /* add ip, pc, #NN */
66 0xe28cca00, /* add ip, ip, #NN */
67 0xe5bcf000, /* ldr pc, [ip, #NN]! */
68 0x00000000, /* unused */
73 /* The first entry in a procedure linkage table looks like
74 this. It is set up so that any shared library function that is
75 called before the relocation has been set up calls the dynamic
77 static const bfd_vma elf32_arm_plt0_entry
[] =
79 0xe52de004, /* str lr, [sp, #-4]! */
80 0xe59fe004, /* ldr lr, [pc, #4] */
81 0xe08fe00e, /* add lr, pc, lr */
82 0xe5bef008, /* ldr pc, [lr, #8]! */
83 0x00000000, /* &GOT[0] - . */
86 /* Subsequent entries in a procedure linkage table look like
88 static const bfd_vma elf32_arm_plt_entry
[] =
90 0xe28fc600, /* add ip, pc, #0xNN00000 */
91 0xe28cca00, /* add ip, ip, #0xNN000 */
92 0xe5bcf000, /* ldr pc, [ip, #0xNNN]! */
97 /* The entries in a PLT when using a DLL-based target with multiple
99 static const bfd_vma elf32_arm_symbian_plt_entry
[] =
101 0xe51ff004, /* ldr pr, [pc, #-4] */
102 0x00000000, /* dcd R_ARM_GLOB_DAT(X) */
105 /* Used to build a map of a section. This is required for mixed-endian
108 typedef struct elf32_elf_section_map
113 elf32_arm_section_map
;
115 struct _arm_elf_section_data
117 struct bfd_elf_section_data elf
;
119 elf32_arm_section_map
*map
;
122 #define elf32_arm_section_data(sec) \
123 ((struct _arm_elf_section_data *) elf_section_data (sec))
125 /* The ARM linker needs to keep track of the number of relocs that it
126 decides to copy in check_relocs for each symbol. This is so that
127 it can discard PC relative relocs if it doesn't need them when
128 linking with -Bsymbolic. We store the information in a field
129 extending the regular ELF linker hash table. */
131 /* This structure keeps track of the number of PC relative relocs we
132 have copied for a given symbol. */
133 struct elf32_arm_relocs_copied
136 struct elf32_arm_relocs_copied
* next
;
137 /* A section in dynobj. */
139 /* Number of relocs copied in this section. */
143 /* Arm ELF linker hash entry. */
144 struct elf32_arm_link_hash_entry
146 struct elf_link_hash_entry root
;
148 /* Number of PC relative relocs copied for this symbol. */
149 struct elf32_arm_relocs_copied
* relocs_copied
;
152 /* Traverse an arm ELF linker hash table. */
153 #define elf32_arm_link_hash_traverse(table, func, info) \
154 (elf_link_hash_traverse \
156 (bfd_boolean (*) (struct elf_link_hash_entry *, void *))) (func), \
159 /* Get the ARM elf linker hash table from a link_info structure. */
160 #define elf32_arm_hash_table(info) \
161 ((struct elf32_arm_link_hash_table *) ((info)->hash))
163 /* ARM ELF linker hash table. */
164 struct elf32_arm_link_hash_table
166 /* The main hash table. */
167 struct elf_link_hash_table root
;
169 /* The size in bytes of the section containing the Thumb-to-ARM glue. */
170 bfd_size_type thumb_glue_size
;
172 /* The size in bytes of the section containing the ARM-to-Thumb glue. */
173 bfd_size_type arm_glue_size
;
175 /* An arbitrary input BFD chosen to hold the glue sections. */
176 bfd
* bfd_of_glue_owner
;
178 /* A boolean indicating whether knowledge of the ARM's pipeline
179 length should be applied by the linker. */
180 int no_pipeline_knowledge
;
182 /* Nonzero to output a BE8 image. */
185 /* Zero if R_ARM_TARGET1 means R_ARM_ABS32.
186 Nonzero if R_ARM_TARGET1 means R_ARM_ABS32. */
189 /* The relocation to use for R_ARM_TARGET2 relocations. */
192 /* The number of bytes in the initial entry in the PLT. */
193 bfd_size_type plt_header_size
;
195 /* The number of bytes in the subsequent PLT etries. */
196 bfd_size_type plt_entry_size
;
198 /* True if the target system is Symbian OS. */
201 /* Short-cuts to get to dynamic linker sections. */
210 /* Small local sym to section mapping cache. */
211 struct sym_sec_cache sym_sec
;
214 /* Create an entry in an ARM ELF linker hash table. */
216 static struct bfd_hash_entry
*
217 elf32_arm_link_hash_newfunc (struct bfd_hash_entry
* entry
,
218 struct bfd_hash_table
* table
,
221 struct elf32_arm_link_hash_entry
* ret
=
222 (struct elf32_arm_link_hash_entry
*) entry
;
224 /* Allocate the structure if it has not already been allocated by a
226 if (ret
== (struct elf32_arm_link_hash_entry
*) NULL
)
227 ret
= bfd_hash_allocate (table
, sizeof (struct elf32_arm_link_hash_entry
));
229 return (struct bfd_hash_entry
*) ret
;
231 /* Call the allocation method of the superclass. */
232 ret
= ((struct elf32_arm_link_hash_entry
*)
233 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
236 ret
->relocs_copied
= NULL
;
238 return (struct bfd_hash_entry
*) ret
;
241 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
242 shortcuts to them in our hash table. */
245 create_got_section (bfd
*dynobj
, struct bfd_link_info
*info
)
247 struct elf32_arm_link_hash_table
*htab
;
249 htab
= elf32_arm_hash_table (info
);
250 /* BPABI objects never have a GOT, or associated sections. */
254 if (! _bfd_elf_create_got_section (dynobj
, info
))
257 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
258 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
259 if (!htab
->sgot
|| !htab
->sgotplt
)
262 htab
->srelgot
= bfd_make_section (dynobj
, ".rel.got");
263 if (htab
->srelgot
== NULL
264 || ! bfd_set_section_flags (dynobj
, htab
->srelgot
,
265 (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
266 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
268 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 2))
273 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
274 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
278 elf32_arm_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
280 struct elf32_arm_link_hash_table
*htab
;
282 htab
= elf32_arm_hash_table (info
);
283 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
286 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
289 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
290 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rel.plt");
291 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
293 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rel.bss");
298 || (!info
->shared
&& !htab
->srelbss
))
304 /* Copy the extra info we tack onto an elf_link_hash_entry. */
307 elf32_arm_copy_indirect_symbol (const struct elf_backend_data
*bed
,
308 struct elf_link_hash_entry
*dir
,
309 struct elf_link_hash_entry
*ind
)
311 struct elf32_arm_link_hash_entry
*edir
, *eind
;
313 edir
= (struct elf32_arm_link_hash_entry
*) dir
;
314 eind
= (struct elf32_arm_link_hash_entry
*) ind
;
316 if (eind
->relocs_copied
!= NULL
)
318 if (edir
->relocs_copied
!= NULL
)
320 struct elf32_arm_relocs_copied
**pp
;
321 struct elf32_arm_relocs_copied
*p
;
323 if (ind
->root
.type
== bfd_link_hash_indirect
)
326 /* Add reloc counts against the weak sym to the strong sym
327 list. Merge any entries against the same section. */
328 for (pp
= &eind
->relocs_copied
; (p
= *pp
) != NULL
; )
330 struct elf32_arm_relocs_copied
*q
;
332 for (q
= edir
->relocs_copied
; q
!= NULL
; q
= q
->next
)
333 if (q
->section
== p
->section
)
335 q
->count
+= p
->count
;
342 *pp
= edir
->relocs_copied
;
345 edir
->relocs_copied
= eind
->relocs_copied
;
346 eind
->relocs_copied
= NULL
;
349 _bfd_elf_link_hash_copy_indirect (bed
, dir
, ind
);
352 /* Create an ARM elf linker hash table. */
354 static struct bfd_link_hash_table
*
355 elf32_arm_link_hash_table_create (bfd
*abfd
)
357 struct elf32_arm_link_hash_table
*ret
;
358 bfd_size_type amt
= sizeof (struct elf32_arm_link_hash_table
);
360 ret
= bfd_malloc (amt
);
364 if (!_bfd_elf_link_hash_table_init (& ret
->root
, abfd
,
365 elf32_arm_link_hash_newfunc
))
378 ret
->thumb_glue_size
= 0;
379 ret
->arm_glue_size
= 0;
380 ret
->bfd_of_glue_owner
= NULL
;
381 ret
->no_pipeline_knowledge
= 0;
382 ret
->byteswap_code
= 0;
383 ret
->target1_is_rel
= 0;
384 ret
->target2_reloc
= R_ARM_NONE
;
386 ret
->plt_header_size
= 16;
387 ret
->plt_entry_size
= 16;
389 ret
->plt_header_size
= 20;
390 ret
->plt_entry_size
= 12;
393 ret
->sym_sec
.abfd
= NULL
;
395 return &ret
->root
.root
;
398 /* Locate the Thumb encoded calling stub for NAME. */
400 static struct elf_link_hash_entry
*
401 find_thumb_glue (struct bfd_link_info
*link_info
,
406 struct elf_link_hash_entry
*hash
;
407 struct elf32_arm_link_hash_table
*hash_table
;
409 /* We need a pointer to the armelf specific hash table. */
410 hash_table
= elf32_arm_hash_table (link_info
);
412 tmp_name
= bfd_malloc ((bfd_size_type
) strlen (name
)
413 + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1);
415 BFD_ASSERT (tmp_name
);
417 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
419 hash
= elf_link_hash_lookup
420 (&(hash_table
)->root
, tmp_name
, FALSE
, FALSE
, TRUE
);
423 /* xgettext:c-format */
424 (*_bfd_error_handler
) (_("%B: unable to find THUMB glue '%s' for `%s'"),
425 input_bfd
, tmp_name
, name
);
432 /* Locate the ARM encoded calling stub for NAME. */
434 static struct elf_link_hash_entry
*
435 find_arm_glue (struct bfd_link_info
*link_info
,
440 struct elf_link_hash_entry
*myh
;
441 struct elf32_arm_link_hash_table
*hash_table
;
443 /* We need a pointer to the elfarm specific hash table. */
444 hash_table
= elf32_arm_hash_table (link_info
);
446 tmp_name
= bfd_malloc ((bfd_size_type
) strlen (name
)
447 + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1);
449 BFD_ASSERT (tmp_name
);
451 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
453 myh
= elf_link_hash_lookup
454 (&(hash_table
)->root
, tmp_name
, FALSE
, FALSE
, TRUE
);
457 /* xgettext:c-format */
458 (*_bfd_error_handler
) (_("%B: unable to find ARM glue '%s' for `%s'"),
459 input_bfd
, tmp_name
, name
);
473 .word func @ behave as if you saw a ARM_32 reloc. */
475 #define ARM2THUMB_GLUE_SIZE 12
476 static const insn32 a2t1_ldr_insn
= 0xe59fc000;
477 static const insn32 a2t2_bx_r12_insn
= 0xe12fff1c;
478 static const insn32 a2t3_func_addr_insn
= 0x00000001;
480 /* Thumb->ARM: Thumb->(non-interworking aware) ARM
484 __func_from_thumb: __func_from_thumb:
486 nop ldr r6, __func_addr
488 __func_change_to_arm: bx r6
490 __func_back_to_thumb:
496 #define THUMB2ARM_GLUE_SIZE 8
497 static const insn16 t2a1_bx_pc_insn
= 0x4778;
498 static const insn16 t2a2_noop_insn
= 0x46c0;
499 static const insn32 t2a3_b_insn
= 0xea000000;
501 #ifndef ELFARM_NABI_C_INCLUDED
503 bfd_elf32_arm_allocate_interworking_sections (struct bfd_link_info
* info
)
507 struct elf32_arm_link_hash_table
* globals
;
509 globals
= elf32_arm_hash_table (info
);
511 BFD_ASSERT (globals
!= NULL
);
513 if (globals
->arm_glue_size
!= 0)
515 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
517 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
518 ARM2THUMB_GLUE_SECTION_NAME
);
520 BFD_ASSERT (s
!= NULL
);
522 foo
= bfd_alloc (globals
->bfd_of_glue_owner
, globals
->arm_glue_size
);
524 s
->size
= globals
->arm_glue_size
;
528 if (globals
->thumb_glue_size
!= 0)
530 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
532 s
= bfd_get_section_by_name
533 (globals
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
535 BFD_ASSERT (s
!= NULL
);
537 foo
= bfd_alloc (globals
->bfd_of_glue_owner
, globals
->thumb_glue_size
);
539 s
->size
= globals
->thumb_glue_size
;
547 record_arm_to_thumb_glue (struct bfd_link_info
* link_info
,
548 struct elf_link_hash_entry
* h
)
550 const char * name
= h
->root
.root
.string
;
553 struct elf_link_hash_entry
* myh
;
554 struct bfd_link_hash_entry
* bh
;
555 struct elf32_arm_link_hash_table
* globals
;
558 globals
= elf32_arm_hash_table (link_info
);
560 BFD_ASSERT (globals
!= NULL
);
561 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
563 s
= bfd_get_section_by_name
564 (globals
->bfd_of_glue_owner
, ARM2THUMB_GLUE_SECTION_NAME
);
566 BFD_ASSERT (s
!= NULL
);
568 tmp_name
= bfd_malloc ((bfd_size_type
) strlen (name
) + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1);
570 BFD_ASSERT (tmp_name
);
572 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
574 myh
= elf_link_hash_lookup
575 (&(globals
)->root
, tmp_name
, FALSE
, FALSE
, TRUE
);
579 /* We've already seen this guy. */
584 /* The only trick here is using hash_table->arm_glue_size as the value.
585 Even though the section isn't allocated yet, this is where we will be
588 val
= globals
->arm_glue_size
+ 1;
589 _bfd_generic_link_add_one_symbol (link_info
, globals
->bfd_of_glue_owner
,
590 tmp_name
, BSF_GLOBAL
, s
, val
,
591 NULL
, TRUE
, FALSE
, &bh
);
595 globals
->arm_glue_size
+= ARM2THUMB_GLUE_SIZE
;
601 record_thumb_to_arm_glue (struct bfd_link_info
*link_info
,
602 struct elf_link_hash_entry
*h
)
604 const char *name
= h
->root
.root
.string
;
607 struct elf_link_hash_entry
*myh
;
608 struct bfd_link_hash_entry
*bh
;
609 struct elf32_arm_link_hash_table
*hash_table
;
613 hash_table
= elf32_arm_hash_table (link_info
);
615 BFD_ASSERT (hash_table
!= NULL
);
616 BFD_ASSERT (hash_table
->bfd_of_glue_owner
!= NULL
);
618 s
= bfd_get_section_by_name
619 (hash_table
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
621 BFD_ASSERT (s
!= NULL
);
623 tmp_name
= bfd_malloc ((bfd_size_type
) strlen (name
)
624 + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1);
626 BFD_ASSERT (tmp_name
);
628 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
630 myh
= elf_link_hash_lookup
631 (&(hash_table
)->root
, tmp_name
, FALSE
, FALSE
, TRUE
);
635 /* We've already seen this guy. */
641 val
= hash_table
->thumb_glue_size
+ 1;
642 _bfd_generic_link_add_one_symbol (link_info
, hash_table
->bfd_of_glue_owner
,
643 tmp_name
, BSF_GLOBAL
, s
, val
,
644 NULL
, TRUE
, FALSE
, &bh
);
646 /* If we mark it 'Thumb', the disassembler will do a better job. */
647 myh
= (struct elf_link_hash_entry
*) bh
;
648 bind
= ELF_ST_BIND (myh
->type
);
649 myh
->type
= ELF_ST_INFO (bind
, STT_ARM_TFUNC
);
653 #define CHANGE_TO_ARM "__%s_change_to_arm"
654 #define BACK_FROM_ARM "__%s_back_from_arm"
656 /* Allocate another symbol to mark where we switch to Arm mode. */
657 tmp_name
= bfd_malloc ((bfd_size_type
) strlen (name
)
658 + strlen (CHANGE_TO_ARM
) + 1);
660 BFD_ASSERT (tmp_name
);
662 sprintf (tmp_name
, CHANGE_TO_ARM
, name
);
665 val
= hash_table
->thumb_glue_size
+ 4,
666 _bfd_generic_link_add_one_symbol (link_info
, hash_table
->bfd_of_glue_owner
,
667 tmp_name
, BSF_LOCAL
, s
, val
,
668 NULL
, TRUE
, FALSE
, &bh
);
672 hash_table
->thumb_glue_size
+= THUMB2ARM_GLUE_SIZE
;
677 /* Add the glue sections to ABFD. This function is called from the
678 linker scripts in ld/emultempl/{armelf}.em. */
681 bfd_elf32_arm_add_glue_sections_to_bfd (bfd
*abfd
,
682 struct bfd_link_info
*info
)
687 /* If we are only performing a partial
688 link do not bother adding the glue. */
689 if (info
->relocatable
)
692 sec
= bfd_get_section_by_name (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
696 /* Note: we do not include the flag SEC_LINKER_CREATED, as this
697 will prevent elf_link_input_bfd() from processing the contents
699 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_CODE
| SEC_READONLY
;
701 sec
= bfd_make_section (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
704 || !bfd_set_section_flags (abfd
, sec
, flags
)
705 || !bfd_set_section_alignment (abfd
, sec
, 2))
708 /* Set the gc mark to prevent the section from being removed by garbage
709 collection, despite the fact that no relocs refer to this section. */
713 sec
= bfd_get_section_by_name (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
717 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
718 | SEC_CODE
| SEC_READONLY
;
720 sec
= bfd_make_section (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
723 || !bfd_set_section_flags (abfd
, sec
, flags
)
724 || !bfd_set_section_alignment (abfd
, sec
, 2))
733 /* Select a BFD to be used to hold the sections used by the glue code.
734 This function is called from the linker scripts in ld/emultempl/
738 bfd_elf32_arm_get_bfd_for_interworking (bfd
*abfd
, struct bfd_link_info
*info
)
740 struct elf32_arm_link_hash_table
*globals
;
742 /* If we are only performing a partial link
743 do not bother getting a bfd to hold the glue. */
744 if (info
->relocatable
)
747 globals
= elf32_arm_hash_table (info
);
749 BFD_ASSERT (globals
!= NULL
);
751 if (globals
->bfd_of_glue_owner
!= NULL
)
754 /* Save the bfd for later use. */
755 globals
->bfd_of_glue_owner
= abfd
;
761 bfd_elf32_arm_process_before_allocation (bfd
*abfd
,
762 struct bfd_link_info
*link_info
,
763 int no_pipeline_knowledge
,
766 Elf_Internal_Shdr
*symtab_hdr
;
767 Elf_Internal_Rela
*internal_relocs
= NULL
;
768 Elf_Internal_Rela
*irel
, *irelend
;
769 bfd_byte
*contents
= NULL
;
772 struct elf32_arm_link_hash_table
*globals
;
774 /* If we are only performing a partial link do not bother
775 to construct any glue. */
776 if (link_info
->relocatable
)
779 /* Here we have a bfd that is to be included on the link. We have a hook
780 to do reloc rummaging, before section sizes are nailed down. */
781 globals
= elf32_arm_hash_table (link_info
);
783 BFD_ASSERT (globals
!= NULL
);
784 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
786 globals
->no_pipeline_knowledge
= no_pipeline_knowledge
;
788 if (byteswap_code
&& !bfd_big_endian (abfd
))
790 _bfd_error_handler (_("%B: BE8 images only valid in big-endian mode."),
794 globals
->byteswap_code
= byteswap_code
;
796 /* Rummage around all the relocs and map the glue vectors. */
797 sec
= abfd
->sections
;
802 for (; sec
!= NULL
; sec
= sec
->next
)
804 if (sec
->reloc_count
== 0)
807 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
809 /* Load the relocs. */
811 = _bfd_elf_link_read_relocs (abfd
, sec
, (void *) NULL
,
812 (Elf_Internal_Rela
*) NULL
, FALSE
);
814 if (internal_relocs
== NULL
)
817 irelend
= internal_relocs
+ sec
->reloc_count
;
818 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
821 unsigned long r_index
;
823 struct elf_link_hash_entry
*h
;
825 r_type
= ELF32_R_TYPE (irel
->r_info
);
826 r_index
= ELF32_R_SYM (irel
->r_info
);
828 /* These are the only relocation types we care about. */
829 if ( r_type
!= R_ARM_PC24
830 && r_type
!= R_ARM_THM_PC22
)
833 /* Get the section contents if we haven't done so already. */
834 if (contents
== NULL
)
836 /* Get cached copy if it exists. */
837 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
838 contents
= elf_section_data (sec
)->this_hdr
.contents
;
841 /* Go get them off disk. */
842 if (! bfd_malloc_and_get_section (abfd
, sec
, &contents
))
847 /* If the relocation is not against a symbol it cannot concern us. */
850 /* We don't care about local symbols. */
851 if (r_index
< symtab_hdr
->sh_info
)
854 /* This is an external symbol. */
855 r_index
-= symtab_hdr
->sh_info
;
856 h
= (struct elf_link_hash_entry
*)
857 elf_sym_hashes (abfd
)[r_index
];
859 /* If the relocation is against a static symbol it must be within
860 the current section and so cannot be a cross ARM/Thumb relocation. */
867 /* This one is a call from arm code. We need to look up
868 the target of the call. If it is a thumb target, we
870 if (ELF_ST_TYPE(h
->type
) == STT_ARM_TFUNC
)
871 record_arm_to_thumb_glue (link_info
, h
);
875 /* This one is a call from thumb code. We look
876 up the target of the call. If it is not a thumb
877 target, we insert glue. */
878 if (ELF_ST_TYPE (h
->type
) != STT_ARM_TFUNC
)
879 record_thumb_to_arm_glue (link_info
, h
);
888 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
892 if (internal_relocs
!= NULL
893 && elf_section_data (sec
)->relocs
!= internal_relocs
)
894 free (internal_relocs
);
895 internal_relocs
= NULL
;
902 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
904 if (internal_relocs
!= NULL
905 && elf_section_data (sec
)->relocs
!= internal_relocs
)
906 free (internal_relocs
);
914 /* Set target relocation values needed during linking. */
917 bfd_elf32_arm_set_target_relocs (struct bfd_link_info
*link_info
,
921 struct elf32_arm_link_hash_table
*globals
;
923 globals
= elf32_arm_hash_table (link_info
);
925 globals
->target1_is_rel
= target1_is_rel
;
926 if (strcmp (target2_type
, "rel") == 0)
927 globals
->target2_reloc
= R_ARM_REL32
;
928 else if (strcmp (target2_type
, "abs") == 0)
929 globals
->target2_reloc
= R_ARM_ABS32
;
930 else if (strcmp (target2_type
, "got-rel") == 0)
931 globals
->target2_reloc
= R_ARM_GOT_PREL
;
934 _bfd_error_handler (_("Invalid TARGET2 relocation type '%s'."),
940 /* The thumb form of a long branch is a bit finicky, because the offset
941 encoding is split over two fields, each in it's own instruction. They
942 can occur in any order. So given a thumb form of long branch, and an
943 offset, insert the offset into the thumb branch and return finished
946 It takes two thumb instructions to encode the target address. Each has
947 11 bits to invest. The upper 11 bits are stored in one (identified by
948 H-0.. see below), the lower 11 bits are stored in the other (identified
951 Combine together and shifted left by 1 (it's a half word address) and
955 H-0, upper address-0 = 000
957 H-1, lower address-0 = 800
959 They can be ordered either way, but the arm tools I've seen always put
960 the lower one first. It probably doesn't matter. krk@cygnus.com
962 XXX: Actually the order does matter. The second instruction (H-1)
963 moves the computed address into the PC, so it must be the second one
964 in the sequence. The problem, however is that whilst little endian code
965 stores the instructions in HI then LOW order, big endian code does the
966 reverse. nickc@cygnus.com. */
968 #define LOW_HI_ORDER 0xF800F000
969 #define HI_LOW_ORDER 0xF000F800
972 insert_thumb_branch (insn32 br_insn
, int rel_off
)
974 unsigned int low_bits
;
975 unsigned int high_bits
;
977 BFD_ASSERT ((rel_off
& 1) != 1);
979 rel_off
>>= 1; /* Half word aligned address. */
980 low_bits
= rel_off
& 0x000007FF; /* The bottom 11 bits. */
981 high_bits
= (rel_off
>> 11) & 0x000007FF; /* The top 11 bits. */
983 if ((br_insn
& LOW_HI_ORDER
) == LOW_HI_ORDER
)
984 br_insn
= LOW_HI_ORDER
| (low_bits
<< 16) | high_bits
;
985 else if ((br_insn
& HI_LOW_ORDER
) == HI_LOW_ORDER
)
986 br_insn
= HI_LOW_ORDER
| (high_bits
<< 16) | low_bits
;
988 /* FIXME: abort is probably not the right call. krk@cygnus.com */
989 abort (); /* Error - not a valid branch instruction form. */
994 /* Thumb code calling an ARM function. */
997 elf32_thumb_to_arm_stub (struct bfd_link_info
* info
,
1001 asection
* input_section
,
1002 bfd_byte
* hit_data
,
1005 bfd_signed_vma addend
,
1010 unsigned long int tmp
;
1011 long int ret_offset
;
1012 struct elf_link_hash_entry
* myh
;
1013 struct elf32_arm_link_hash_table
* globals
;
1015 myh
= find_thumb_glue (info
, name
, input_bfd
);
1019 globals
= elf32_arm_hash_table (info
);
1021 BFD_ASSERT (globals
!= NULL
);
1022 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
1024 my_offset
= myh
->root
.u
.def
.value
;
1026 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
1027 THUMB2ARM_GLUE_SECTION_NAME
);
1029 BFD_ASSERT (s
!= NULL
);
1030 BFD_ASSERT (s
->contents
!= NULL
);
1031 BFD_ASSERT (s
->output_section
!= NULL
);
1033 if ((my_offset
& 0x01) == 0x01)
1036 && sym_sec
->owner
!= NULL
1037 && !INTERWORK_FLAG (sym_sec
->owner
))
1039 (*_bfd_error_handler
)
1040 (_("%B(%s): warning: interworking not enabled.\n"
1041 " first occurrence: %B: thumb call to arm"),
1042 sym_sec
->owner
, input_bfd
, name
);
1048 myh
->root
.u
.def
.value
= my_offset
;
1050 bfd_put_16 (output_bfd
, (bfd_vma
) t2a1_bx_pc_insn
,
1051 s
->contents
+ my_offset
);
1053 bfd_put_16 (output_bfd
, (bfd_vma
) t2a2_noop_insn
,
1054 s
->contents
+ my_offset
+ 2);
1057 /* Address of destination of the stub. */
1058 ((bfd_signed_vma
) val
)
1060 /* Offset from the start of the current section
1061 to the start of the stubs. */
1063 /* Offset of the start of this stub from the start of the stubs. */
1065 /* Address of the start of the current section. */
1066 + s
->output_section
->vma
)
1067 /* The branch instruction is 4 bytes into the stub. */
1069 /* ARM branches work from the pc of the instruction + 8. */
1072 bfd_put_32 (output_bfd
,
1073 (bfd_vma
) t2a3_b_insn
| ((ret_offset
>> 2) & 0x00FFFFFF),
1074 s
->contents
+ my_offset
+ 4);
1077 BFD_ASSERT (my_offset
<= globals
->thumb_glue_size
);
1079 /* Now go back and fix up the original BL insn to point to here. */
1081 /* Address of where the stub is located. */
1082 (s
->output_section
->vma
+ s
->output_offset
+ my_offset
)
1083 /* Address of where the BL is located. */
1084 - (input_section
->output_section
->vma
+ input_section
->output_offset
1086 /* Addend in the relocation. */
1088 /* Biassing for PC-relative addressing. */
1091 tmp
= bfd_get_32 (input_bfd
, hit_data
1092 - input_section
->vma
);
1094 bfd_put_32 (output_bfd
,
1095 (bfd_vma
) insert_thumb_branch (tmp
, ret_offset
),
1096 hit_data
- input_section
->vma
);
1101 /* Arm code calling a Thumb function. */
1104 elf32_arm_to_thumb_stub (struct bfd_link_info
* info
,
1108 asection
* input_section
,
1109 bfd_byte
* hit_data
,
1112 bfd_signed_vma addend
,
1115 unsigned long int tmp
;
1118 long int ret_offset
;
1119 struct elf_link_hash_entry
* myh
;
1120 struct elf32_arm_link_hash_table
* globals
;
1122 myh
= find_arm_glue (info
, name
, input_bfd
);
1126 globals
= elf32_arm_hash_table (info
);
1128 BFD_ASSERT (globals
!= NULL
);
1129 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
1131 my_offset
= myh
->root
.u
.def
.value
;
1132 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
1133 ARM2THUMB_GLUE_SECTION_NAME
);
1134 BFD_ASSERT (s
!= NULL
);
1135 BFD_ASSERT (s
->contents
!= NULL
);
1136 BFD_ASSERT (s
->output_section
!= NULL
);
1138 if ((my_offset
& 0x01) == 0x01)
1141 && sym_sec
->owner
!= NULL
1142 && !INTERWORK_FLAG (sym_sec
->owner
))
1144 (*_bfd_error_handler
)
1145 (_("%B(%s): warning: interworking not enabled.\n"
1146 " first occurrence: %B: arm call to thumb"),
1147 sym_sec
->owner
, input_bfd
, name
);
1151 myh
->root
.u
.def
.value
= my_offset
;
1153 bfd_put_32 (output_bfd
, (bfd_vma
) a2t1_ldr_insn
,
1154 s
->contents
+ my_offset
);
1156 bfd_put_32 (output_bfd
, (bfd_vma
) a2t2_bx_r12_insn
,
1157 s
->contents
+ my_offset
+ 4);
1159 /* It's a thumb address. Add the low order bit. */
1160 bfd_put_32 (output_bfd
, val
| a2t3_func_addr_insn
,
1161 s
->contents
+ my_offset
+ 8);
1164 BFD_ASSERT (my_offset
<= globals
->arm_glue_size
);
1166 tmp
= bfd_get_32 (input_bfd
, hit_data
);
1167 tmp
= tmp
& 0xFF000000;
1169 /* Somehow these are both 4 too far, so subtract 8. */
1170 ret_offset
= (s
->output_offset
1172 + s
->output_section
->vma
1173 - (input_section
->output_offset
1174 + input_section
->output_section
->vma
1178 tmp
= tmp
| ((ret_offset
>> 2) & 0x00FFFFFF);
1180 bfd_put_32 (output_bfd
, (bfd_vma
) tmp
, hit_data
- input_section
->vma
);
1187 /* Some relocations map to different relocations depending on the
1188 target. Return the real relocation. */
1190 arm_real_reloc_type (struct elf32_arm_link_hash_table
* globals
,
1196 if (globals
->target1_is_rel
)
1202 return globals
->target2_reloc
;
1208 #endif /* OLD_ARM_ABI */
1211 /* Perform a relocation as part of a final link. */
1213 static bfd_reloc_status_type
1214 elf32_arm_final_link_relocate (reloc_howto_type
* howto
,
1217 asection
* input_section
,
1218 bfd_byte
* contents
,
1219 Elf_Internal_Rela
* rel
,
1221 struct bfd_link_info
* info
,
1223 const char * sym_name
,
1225 struct elf_link_hash_entry
* h
)
1227 unsigned long r_type
= howto
->type
;
1228 unsigned long r_symndx
;
1229 bfd_byte
* hit_data
= contents
+ rel
->r_offset
;
1230 bfd
* dynobj
= NULL
;
1231 Elf_Internal_Shdr
* symtab_hdr
;
1232 struct elf_link_hash_entry
** sym_hashes
;
1233 bfd_vma
* local_got_offsets
;
1234 asection
* sgot
= NULL
;
1235 asection
* splt
= NULL
;
1236 asection
* sreloc
= NULL
;
1238 bfd_signed_vma signed_addend
;
1239 struct elf32_arm_link_hash_table
* globals
;
1241 globals
= elf32_arm_hash_table (info
);
1244 /* Some relocation type map to different relocations depending on the
1245 target. We pick the right one here. */
1246 r_type
= arm_real_reloc_type (globals
, r_type
);
1247 if (r_type
!= howto
->type
)
1248 howto
= elf32_arm_howto_from_type (r_type
);
1249 #endif /* OLD_ARM_ABI */
1251 /* If the start address has been set, then set the EF_ARM_HASENTRY
1252 flag. Setting this more than once is redundant, but the cost is
1253 not too high, and it keeps the code simple.
1255 The test is done here, rather than somewhere else, because the
1256 start address is only set just before the final link commences.
1258 Note - if the user deliberately sets a start address of 0, the
1259 flag will not be set. */
1260 if (bfd_get_start_address (output_bfd
) != 0)
1261 elf_elfheader (output_bfd
)->e_flags
|= EF_ARM_HASENTRY
;
1263 dynobj
= elf_hash_table (info
)->dynobj
;
1266 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1267 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1269 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1270 sym_hashes
= elf_sym_hashes (input_bfd
);
1271 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1272 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1275 addend
= bfd_get_32 (input_bfd
, hit_data
) & howto
->src_mask
;
1277 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1280 signed_addend
&= ~ howto
->src_mask
;
1281 signed_addend
|= addend
;
1284 signed_addend
= addend
;
1286 addend
= signed_addend
= rel
->r_addend
;
1292 return bfd_reloc_ok
;
1302 /* r_symndx will be zero only for relocs against symbols
1303 from removed linkonce sections, or sections discarded by
1306 return bfd_reloc_ok
;
1308 /* Handle relocations which should use the PLT entry. ABS32/REL32
1309 will use the symbol's value, which may point to a PLT entry, but we
1310 don't need to handle that here. If we created a PLT entry, all
1311 branches in this object should go to it. */
1312 if ((r_type
!= R_ARM_ABS32
&& r_type
!= R_ARM_REL32
1314 && r_type
!= R_ARM_PREL31
1319 && h
->plt
.offset
!= (bfd_vma
) -1)
1321 /* If we've created a .plt section, and assigned a PLT entry to
1322 this function, it should not be known to bind locally. If
1323 it were, we would have cleared the PLT entry. */
1324 BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info
, h
));
1326 value
= (splt
->output_section
->vma
1327 + splt
->output_offset
1329 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1330 contents
, rel
->r_offset
, value
,
1334 /* When generating a shared object, these relocations are copied
1335 into the output file to be resolved at run time. */
1337 && (input_section
->flags
& SEC_ALLOC
)
1338 && ((r_type
!= R_ARM_REL32
1340 && r_type
!= R_ARM_PREL31
1342 ) || !SYMBOL_CALLS_LOCAL (info
, h
))
1344 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
1345 || h
->root
.type
!= bfd_link_hash_undefweak
)
1346 && r_type
!= R_ARM_PC24
1347 && r_type
!= R_ARM_PLT32
)
1349 Elf_Internal_Rela outrel
;
1351 bfd_boolean skip
, relocate
;
1357 name
= (bfd_elf_string_from_elf_section
1359 elf_elfheader (input_bfd
)->e_shstrndx
,
1360 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1362 return bfd_reloc_notsupported
;
1364 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
1365 && strcmp (bfd_get_section_name (input_bfd
,
1369 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1370 BFD_ASSERT (sreloc
!= NULL
);
1377 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
1379 if (outrel
.r_offset
== (bfd_vma
) -1)
1381 else if (outrel
.r_offset
== (bfd_vma
) -2)
1382 skip
= TRUE
, relocate
= TRUE
;
1383 outrel
.r_offset
+= (input_section
->output_section
->vma
1384 + input_section
->output_offset
);
1387 memset (&outrel
, 0, sizeof outrel
);
1392 || !h
->def_regular
))
1393 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1396 /* This symbol is local, or marked to become local. */
1398 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1401 loc
= sreloc
->contents
;
1402 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
1403 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
1405 /* If this reloc is against an external symbol, we do not want to
1406 fiddle with the addend. Otherwise, we need to include the symbol
1407 value so that it becomes an addend for the dynamic reloc. */
1409 return bfd_reloc_ok
;
1411 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1412 contents
, rel
->r_offset
, value
,
1415 else switch (r_type
)
1418 case R_ARM_XPC25
: /* Arm BLX instruction. */
1420 case R_ARM_PC24
: /* Arm B/BL instruction */
1423 if (r_type
== R_ARM_XPC25
)
1425 /* Check for Arm calling Arm function. */
1426 /* FIXME: Should we translate the instruction into a BL
1427 instruction instead ? */
1428 if (sym_flags
!= STT_ARM_TFUNC
)
1429 (*_bfd_error_handler
)
1430 (_("\%B: Warning: Arm BLX instruction targets Arm function '%s'."),
1432 h
? h
->root
.root
.string
: "(local)");
1437 /* Check for Arm calling Thumb function. */
1438 if (sym_flags
== STT_ARM_TFUNC
)
1440 elf32_arm_to_thumb_stub (info
, sym_name
, input_bfd
,
1441 output_bfd
, input_section
,
1442 hit_data
, sym_sec
, rel
->r_offset
,
1443 signed_addend
, value
);
1444 return bfd_reloc_ok
;
1448 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1449 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0)
1451 /* The old way of doing things. Trearing the addend as a
1452 byte sized field and adding in the pipeline offset. */
1453 value
-= (input_section
->output_section
->vma
1454 + input_section
->output_offset
);
1455 value
-= rel
->r_offset
;
1458 if (! globals
->no_pipeline_knowledge
)
1463 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
1465 S is the address of the symbol in the relocation.
1466 P is address of the instruction being relocated.
1467 A is the addend (extracted from the instruction) in bytes.
1469 S is held in 'value'.
1470 P is the base address of the section containing the
1471 instruction plus the offset of the reloc into that
1473 (input_section->output_section->vma +
1474 input_section->output_offset +
1476 A is the addend, converted into bytes, ie:
1479 Note: None of these operations have knowledge of the pipeline
1480 size of the processor, thus it is up to the assembler to
1481 encode this information into the addend. */
1482 value
-= (input_section
->output_section
->vma
1483 + input_section
->output_offset
);
1484 value
-= rel
->r_offset
;
1485 value
+= (signed_addend
<< howto
->size
);
1487 /* Previous versions of this code also used to add in the
1488 pipeline offset here. This is wrong because the linker is
1489 not supposed to know about such things, and one day it might
1490 change. In order to support old binaries that need the old
1491 behaviour however, so we attempt to detect which ABI was
1492 used to create the reloc. */
1493 if (! globals
->no_pipeline_knowledge
)
1495 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form */
1497 i_ehdrp
= elf_elfheader (input_bfd
);
1499 if (i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1504 signed_addend
= value
;
1505 signed_addend
>>= howto
->rightshift
;
1507 /* It is not an error for an undefined weak reference to be
1508 out of range. Any program that branches to such a symbol
1509 is going to crash anyway, so there is no point worrying
1510 about getting the destination exactly right. */
1511 if (! h
|| h
->root
.type
!= bfd_link_hash_undefweak
)
1513 /* Perform a signed range check. */
1514 if ( signed_addend
> ((bfd_signed_vma
) (howto
->dst_mask
>> 1))
1515 || signed_addend
< - ((bfd_signed_vma
) ((howto
->dst_mask
+ 1) >> 1)))
1516 return bfd_reloc_overflow
;
1520 /* If necessary set the H bit in the BLX instruction. */
1521 if (r_type
== R_ARM_XPC25
&& ((value
& 2) == 2))
1522 value
= (signed_addend
& howto
->dst_mask
)
1523 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
))
1527 value
= (signed_addend
& howto
->dst_mask
)
1528 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1533 if (sym_flags
== STT_ARM_TFUNC
)
1538 value
-= (input_section
->output_section
->vma
1539 + input_section
->output_offset
+ rel
->r_offset
);
1545 value
-= (input_section
->output_section
->vma
1546 + input_section
->output_offset
+ rel
->r_offset
);
1547 value
+= signed_addend
;
1548 if (! h
|| h
->root
.type
!= bfd_link_hash_undefweak
)
1550 /* Check for overflow */
1551 if ((value
^ (value
>> 1)) & (1 << 30))
1552 return bfd_reloc_overflow
;
1554 value
&= 0x7fffffff;
1555 value
|= (bfd_get_32 (input_bfd
, hit_data
) & 0x80000000);
1556 if (sym_flags
== STT_ARM_TFUNC
)
1562 bfd_put_32 (input_bfd
, value
, hit_data
);
1563 return bfd_reloc_ok
;
1567 if ((long) value
> 0x7f || (long) value
< -0x80)
1568 return bfd_reloc_overflow
;
1570 bfd_put_8 (input_bfd
, value
, hit_data
);
1571 return bfd_reloc_ok
;
1576 if ((long) value
> 0x7fff || (long) value
< -0x8000)
1577 return bfd_reloc_overflow
;
1579 bfd_put_16 (input_bfd
, value
, hit_data
);
1580 return bfd_reloc_ok
;
1583 /* Support ldr and str instruction for the arm */
1584 /* Also thumb b (unconditional branch). ??? Really? */
1587 if ((long) value
> 0x7ff || (long) value
< -0x800)
1588 return bfd_reloc_overflow
;
1590 value
|= (bfd_get_32 (input_bfd
, hit_data
) & 0xfffff000);
1591 bfd_put_32 (input_bfd
, value
, hit_data
);
1592 return bfd_reloc_ok
;
1594 case R_ARM_THM_ABS5
:
1595 /* Support ldr and str instructions for the thumb. */
1597 /* Need to refetch addend. */
1598 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1599 /* ??? Need to determine shift amount from operand size. */
1600 addend
>>= howto
->rightshift
;
1604 /* ??? Isn't value unsigned? */
1605 if ((long) value
> 0x1f || (long) value
< -0x10)
1606 return bfd_reloc_overflow
;
1608 /* ??? Value needs to be properly shifted into place first. */
1609 value
|= bfd_get_16 (input_bfd
, hit_data
) & 0xf83f;
1610 bfd_put_16 (input_bfd
, value
, hit_data
);
1611 return bfd_reloc_ok
;
1614 case R_ARM_THM_XPC22
:
1616 case R_ARM_THM_PC22
:
1617 /* Thumb BL (branch long instruction). */
1620 bfd_boolean overflow
= FALSE
;
1621 bfd_vma upper_insn
= bfd_get_16 (input_bfd
, hit_data
);
1622 bfd_vma lower_insn
= bfd_get_16 (input_bfd
, hit_data
+ 2);
1623 bfd_signed_vma reloc_signed_max
= ((1 << (howto
->bitsize
- 1)) - 1) >> howto
->rightshift
;
1624 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1626 bfd_signed_vma signed_check
;
1629 /* Need to refetch the addend and squish the two 11 bit pieces
1632 bfd_vma upper
= upper_insn
& 0x7ff;
1633 bfd_vma lower
= lower_insn
& 0x7ff;
1634 upper
= (upper
^ 0x400) - 0x400; /* Sign extend. */
1635 addend
= (upper
<< 12) | (lower
<< 1);
1636 signed_addend
= addend
;
1640 if (r_type
== R_ARM_THM_XPC22
)
1642 /* Check for Thumb to Thumb call. */
1643 /* FIXME: Should we translate the instruction into a BL
1644 instruction instead ? */
1645 if (sym_flags
== STT_ARM_TFUNC
)
1646 (*_bfd_error_handler
)
1647 (_("%B: Warning: Thumb BLX instruction targets thumb function '%s'."),
1649 h
? h
->root
.root
.string
: "(local)");
1654 /* If it is not a call to Thumb, assume call to Arm.
1655 If it is a call relative to a section name, then it is not a
1656 function call at all, but rather a long jump. */
1657 if (sym_flags
!= STT_ARM_TFUNC
&& sym_flags
!= STT_SECTION
)
1659 if (elf32_thumb_to_arm_stub
1660 (info
, sym_name
, input_bfd
, output_bfd
, input_section
,
1661 hit_data
, sym_sec
, rel
->r_offset
, signed_addend
, value
))
1662 return bfd_reloc_ok
;
1664 return bfd_reloc_dangerous
;
1668 relocation
= value
+ signed_addend
;
1670 relocation
-= (input_section
->output_section
->vma
1671 + input_section
->output_offset
1674 if (! globals
->no_pipeline_knowledge
)
1676 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form. */
1678 i_ehdrp
= elf_elfheader (input_bfd
);
1680 /* Previous versions of this code also used to add in the pipline
1681 offset here. This is wrong because the linker is not supposed
1682 to know about such things, and one day it might change. In order
1683 to support old binaries that need the old behaviour however, so
1684 we attempt to detect which ABI was used to create the reloc. */
1685 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1686 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0
1687 || i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1691 check
= relocation
>> howto
->rightshift
;
1693 /* If this is a signed value, the rightshift just dropped
1694 leading 1 bits (assuming twos complement). */
1695 if ((bfd_signed_vma
) relocation
>= 0)
1696 signed_check
= check
;
1698 signed_check
= check
| ~((bfd_vma
) -1 >> howto
->rightshift
);
1700 /* Assumes two's complement. */
1701 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1705 if (r_type
== R_ARM_THM_XPC22
1706 && ((lower_insn
& 0x1800) == 0x0800))
1707 /* For a BLX instruction, make sure that the relocation is rounded up
1708 to a word boundary. This follows the semantics of the instruction
1709 which specifies that bit 1 of the target address will come from bit
1710 1 of the base address. */
1711 relocation
= (relocation
+ 2) & ~ 3;
1713 /* Put RELOCATION back into the insn. */
1714 upper_insn
= (upper_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 12) & 0x7ff);
1715 lower_insn
= (lower_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 1) & 0x7ff);
1717 /* Put the relocated value back in the object file: */
1718 bfd_put_16 (input_bfd
, upper_insn
, hit_data
);
1719 bfd_put_16 (input_bfd
, lower_insn
, hit_data
+ 2);
1721 return (overflow
? bfd_reloc_overflow
: bfd_reloc_ok
);
1725 case R_ARM_THM_PC11
:
1726 /* Thumb B (branch) instruction). */
1728 bfd_signed_vma relocation
;
1729 bfd_signed_vma reloc_signed_max
= (1 << (howto
->bitsize
- 1)) - 1;
1730 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1731 bfd_signed_vma signed_check
;
1734 /* Need to refetch addend. */
1735 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1736 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1739 signed_addend
&= ~ howto
->src_mask
;
1740 signed_addend
|= addend
;
1743 signed_addend
= addend
;
1744 /* The value in the insn has been right shifted. We need to
1745 undo this, so that we can perform the address calculation
1746 in terms of bytes. */
1747 signed_addend
<<= howto
->rightshift
;
1749 relocation
= value
+ signed_addend
;
1751 relocation
-= (input_section
->output_section
->vma
1752 + input_section
->output_offset
1755 relocation
>>= howto
->rightshift
;
1756 signed_check
= relocation
;
1757 relocation
&= howto
->dst_mask
;
1758 relocation
|= (bfd_get_16 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1760 bfd_put_16 (input_bfd
, relocation
, hit_data
);
1762 /* Assumes two's complement. */
1763 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1764 return bfd_reloc_overflow
;
1766 return bfd_reloc_ok
;
1770 case R_ARM_ALU_PCREL7_0
:
1771 case R_ARM_ALU_PCREL15_8
:
1772 case R_ARM_ALU_PCREL23_15
:
1777 insn
= bfd_get_32 (input_bfd
, hit_data
);
1779 /* Extract the addend. */
1780 addend
= (insn
& 0xff) << ((insn
& 0xf00) >> 7);
1781 signed_addend
= addend
;
1783 relocation
= value
+ signed_addend
;
1785 relocation
-= (input_section
->output_section
->vma
1786 + input_section
->output_offset
1788 insn
= (insn
& ~0xfff)
1789 | ((howto
->bitpos
<< 7) & 0xf00)
1790 | ((relocation
>> howto
->bitpos
) & 0xff);
1791 bfd_put_32 (input_bfd
, value
, hit_data
);
1793 return bfd_reloc_ok
;
1796 case R_ARM_GNU_VTINHERIT
:
1797 case R_ARM_GNU_VTENTRY
:
1798 return bfd_reloc_ok
;
1801 return bfd_reloc_notsupported
;
1803 case R_ARM_GLOB_DAT
:
1804 return bfd_reloc_notsupported
;
1806 case R_ARM_JUMP_SLOT
:
1807 return bfd_reloc_notsupported
;
1809 case R_ARM_RELATIVE
:
1810 return bfd_reloc_notsupported
;
1813 /* Relocation is relative to the start of the
1814 global offset table. */
1816 BFD_ASSERT (sgot
!= NULL
);
1818 return bfd_reloc_notsupported
;
1820 /* If we are addressing a Thumb function, we need to adjust the
1821 address by one, so that attempts to call the function pointer will
1822 correctly interpret it as Thumb code. */
1823 if (sym_flags
== STT_ARM_TFUNC
)
1826 /* Note that sgot->output_offset is not involved in this
1827 calculation. We always want the start of .got. If we
1828 define _GLOBAL_OFFSET_TABLE in a different way, as is
1829 permitted by the ABI, we might have to change this
1831 value
-= sgot
->output_section
->vma
;
1832 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1833 contents
, rel
->r_offset
, value
,
1837 /* Use global offset table as symbol value. */
1838 BFD_ASSERT (sgot
!= NULL
);
1841 return bfd_reloc_notsupported
;
1843 value
= sgot
->output_section
->vma
;
1844 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1845 contents
, rel
->r_offset
, value
,
1850 case R_ARM_GOT_PREL
:
1852 /* Relocation is to the entry for this symbol in the
1853 global offset table. */
1855 return bfd_reloc_notsupported
;
1862 off
= h
->got
.offset
;
1863 BFD_ASSERT (off
!= (bfd_vma
) -1);
1864 dyn
= globals
->root
.dynamic_sections_created
;
1866 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
1868 && SYMBOL_REFERENCES_LOCAL (info
, h
))
1869 || (ELF_ST_VISIBILITY (h
->other
)
1870 && h
->root
.type
== bfd_link_hash_undefweak
))
1872 /* This is actually a static link, or it is a -Bsymbolic link
1873 and the symbol is defined locally. We must initialize this
1874 entry in the global offset table. Since the offset must
1875 always be a multiple of 4, we use the least significant bit
1876 to record whether we have initialized it already.
1878 When doing a dynamic link, we create a .rel.got relocation
1879 entry to initialize the value. This is done in the
1880 finish_dynamic_symbol routine. */
1885 /* If we are addressing a Thumb function, we need to
1886 adjust the address by one, so that attempts to
1887 call the function pointer will correctly
1888 interpret it as Thumb code. */
1889 if (sym_flags
== STT_ARM_TFUNC
)
1892 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1897 value
= sgot
->output_offset
+ off
;
1903 BFD_ASSERT (local_got_offsets
!= NULL
&&
1904 local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1906 off
= local_got_offsets
[r_symndx
];
1908 /* The offset must always be a multiple of 4. We use the
1909 least significant bit to record whether we have already
1910 generated the necessary reloc. */
1915 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1920 Elf_Internal_Rela outrel
;
1923 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
1924 BFD_ASSERT (srelgot
!= NULL
);
1926 outrel
.r_offset
= (sgot
->output_section
->vma
1927 + sgot
->output_offset
1929 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1930 loc
= srelgot
->contents
;
1931 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rel
);
1932 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
1935 local_got_offsets
[r_symndx
] |= 1;
1938 value
= sgot
->output_offset
+ off
;
1940 if (r_type
!= R_ARM_GOT32
)
1941 value
+= sgot
->output_section
->vma
;
1943 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1944 contents
, rel
->r_offset
, value
,
1948 return bfd_reloc_notsupported
;
1950 case R_ARM_AMP_VCALL9
:
1951 return bfd_reloc_notsupported
;
1953 case R_ARM_RSBREL32
:
1954 return bfd_reloc_notsupported
;
1956 case R_ARM_THM_RPC22
:
1957 return bfd_reloc_notsupported
;
1960 return bfd_reloc_notsupported
;
1963 return bfd_reloc_notsupported
;
1966 return bfd_reloc_notsupported
;
1969 return bfd_reloc_notsupported
;
1972 return bfd_reloc_notsupported
;
1977 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
1979 arm_add_to_rel (bfd
* abfd
,
1981 reloc_howto_type
* howto
,
1982 bfd_signed_vma increment
)
1984 bfd_signed_vma addend
;
1986 if (howto
->type
== R_ARM_THM_PC22
)
1988 int upper_insn
, lower_insn
;
1991 upper_insn
= bfd_get_16 (abfd
, address
);
1992 lower_insn
= bfd_get_16 (abfd
, address
+ 2);
1993 upper
= upper_insn
& 0x7ff;
1994 lower
= lower_insn
& 0x7ff;
1996 addend
= (upper
<< 12) | (lower
<< 1);
1997 addend
+= increment
;
2000 upper_insn
= (upper_insn
& 0xf800) | ((addend
>> 11) & 0x7ff);
2001 lower_insn
= (lower_insn
& 0xf800) | (addend
& 0x7ff);
2003 bfd_put_16 (abfd
, (bfd_vma
) upper_insn
, address
);
2004 bfd_put_16 (abfd
, (bfd_vma
) lower_insn
, address
+ 2);
2010 contents
= bfd_get_32 (abfd
, address
);
2012 /* Get the (signed) value from the instruction. */
2013 addend
= contents
& howto
->src_mask
;
2014 if (addend
& ((howto
->src_mask
+ 1) >> 1))
2016 bfd_signed_vma mask
;
2019 mask
&= ~ howto
->src_mask
;
2023 /* Add in the increment, (which is a byte value). */
2024 switch (howto
->type
)
2027 addend
+= increment
;
2031 addend
<<= howto
->size
;
2032 addend
+= increment
;
2034 /* Should we check for overflow here ? */
2036 /* Drop any undesired bits. */
2037 addend
>>= howto
->rightshift
;
2041 contents
= (contents
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
2043 bfd_put_32 (abfd
, contents
, address
);
2046 #endif /* USE_REL */
2048 /* Relocate an ARM ELF section. */
2050 elf32_arm_relocate_section (bfd
* output_bfd
,
2051 struct bfd_link_info
* info
,
2053 asection
* input_section
,
2054 bfd_byte
* contents
,
2055 Elf_Internal_Rela
* relocs
,
2056 Elf_Internal_Sym
* local_syms
,
2057 asection
** local_sections
)
2059 Elf_Internal_Shdr
*symtab_hdr
;
2060 struct elf_link_hash_entry
**sym_hashes
;
2061 Elf_Internal_Rela
*rel
;
2062 Elf_Internal_Rela
*relend
;
2066 if (info
->relocatable
)
2070 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
2071 sym_hashes
= elf_sym_hashes (input_bfd
);
2074 relend
= relocs
+ input_section
->reloc_count
;
2075 for (; rel
< relend
; rel
++)
2078 reloc_howto_type
* howto
;
2079 unsigned long r_symndx
;
2080 Elf_Internal_Sym
* sym
;
2082 struct elf_link_hash_entry
* h
;
2084 bfd_reloc_status_type r
;
2087 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2088 r_type
= ELF32_R_TYPE (rel
->r_info
);
2090 if ( r_type
== R_ARM_GNU_VTENTRY
2091 || r_type
== R_ARM_GNU_VTINHERIT
)
2094 elf32_arm_info_to_howto (input_bfd
, & bfd_reloc
, rel
);
2095 howto
= bfd_reloc
.howto
;
2098 if (info
->relocatable
)
2100 /* This is a relocatable link. We don't have to change
2101 anything, unless the reloc is against a section symbol,
2102 in which case we have to adjust according to where the
2103 section symbol winds up in the output section. */
2104 if (r_symndx
< symtab_hdr
->sh_info
)
2106 sym
= local_syms
+ r_symndx
;
2107 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2109 sec
= local_sections
[r_symndx
];
2110 arm_add_to_rel (input_bfd
, contents
+ rel
->r_offset
,
2112 (bfd_signed_vma
) (sec
->output_offset
2121 /* This is a final link. */
2126 if (r_symndx
< symtab_hdr
->sh_info
)
2128 sym
= local_syms
+ r_symndx
;
2129 sec
= local_sections
[r_symndx
];
2131 relocation
= (sec
->output_section
->vma
2132 + sec
->output_offset
2134 if ((sec
->flags
& SEC_MERGE
)
2135 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2138 bfd_vma addend
, value
;
2140 if (howto
->rightshift
)
2142 (*_bfd_error_handler
)
2143 (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
2144 input_bfd
, input_section
,
2145 (long) rel
->r_offset
, howto
->name
);
2149 value
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2151 /* Get the (signed) value from the instruction. */
2152 addend
= value
& howto
->src_mask
;
2153 if (addend
& ((howto
->src_mask
+ 1) >> 1))
2155 bfd_signed_vma mask
;
2158 mask
&= ~ howto
->src_mask
;
2163 _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
)
2165 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2166 value
= (value
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
2167 bfd_put_32 (input_bfd
, value
, contents
+ rel
->r_offset
);
2170 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2176 bfd_boolean unresolved_reloc
;
2178 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2179 r_symndx
, symtab_hdr
, sym_hashes
,
2181 unresolved_reloc
, warned
);
2183 if (unresolved_reloc
|| relocation
!= 0)
2185 /* In these cases, we don't need the relocation value.
2186 We check specially because in some obscure cases
2187 sec->output_section will be NULL. */
2192 case R_ARM_THM_PC22
:
2196 && ((!info
->symbolic
&& h
->dynindx
!= -1)
2198 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2199 && ((input_section
->flags
& SEC_ALLOC
) != 0
2200 /* DWARF will emit R_ARM_ABS32 relocations in its
2201 sections against symbols defined externally
2202 in shared libraries. We can't do anything
2204 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
2216 case R_ARM_GOT_PREL
:
2218 if ((WILL_CALL_FINISH_DYNAMIC_SYMBOL
2219 (elf_hash_table (info
)->dynamic_sections_created
,
2222 || (!info
->symbolic
&& h
->dynindx
!= -1)
2223 || !h
->def_regular
))
2228 if (unresolved_reloc
)
2230 (_("%B(%A): warning: unresolvable relocation %d against symbol `%s'"),
2231 input_bfd
, input_section
,
2233 h
->root
.root
.string
);
2240 name
= h
->root
.root
.string
;
2243 name
= (bfd_elf_string_from_elf_section
2244 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2245 if (name
== NULL
|| *name
== '\0')
2246 name
= bfd_section_name (input_bfd
, sec
);
2249 r
= elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
2250 input_section
, contents
, rel
,
2251 relocation
, info
, sec
, name
,
2252 (h
? ELF_ST_TYPE (h
->type
) :
2253 ELF_ST_TYPE (sym
->st_info
)), h
);
2255 if (r
!= bfd_reloc_ok
)
2257 const char * msg
= (const char *) 0;
2261 case bfd_reloc_overflow
:
2262 /* If the overflowing reloc was to an undefined symbol,
2263 we have already printed one error message and there
2264 is no point complaining again. */
2266 h
->root
.type
!= bfd_link_hash_undefined
)
2267 && (!((*info
->callbacks
->reloc_overflow
)
2268 (info
, name
, howto
->name
, (bfd_vma
) 0,
2269 input_bfd
, input_section
, rel
->r_offset
))))
2273 case bfd_reloc_undefined
:
2274 if (!((*info
->callbacks
->undefined_symbol
)
2275 (info
, name
, input_bfd
, input_section
,
2276 rel
->r_offset
, TRUE
)))
2280 case bfd_reloc_outofrange
:
2281 msg
= _("internal error: out of range error");
2284 case bfd_reloc_notsupported
:
2285 msg
= _("internal error: unsupported relocation error");
2288 case bfd_reloc_dangerous
:
2289 msg
= _("internal error: dangerous error");
2293 msg
= _("internal error: unknown error");
2297 if (!((*info
->callbacks
->warning
)
2298 (info
, msg
, name
, input_bfd
, input_section
,
2309 /* Set the right machine number. */
2312 elf32_arm_object_p (bfd
*abfd
)
2316 mach
= bfd_arm_get_mach_from_notes (abfd
, ARM_NOTE_SECTION
);
2318 if (mach
!= bfd_mach_arm_unknown
)
2319 bfd_default_set_arch_mach (abfd
, bfd_arch_arm
, mach
);
2321 else if (elf_elfheader (abfd
)->e_flags
& EF_ARM_MAVERICK_FLOAT
)
2322 bfd_default_set_arch_mach (abfd
, bfd_arch_arm
, bfd_mach_arm_ep9312
);
2325 bfd_default_set_arch_mach (abfd
, bfd_arch_arm
, mach
);
2330 /* Function to keep ARM specific flags in the ELF header. */
2333 elf32_arm_set_private_flags (bfd
*abfd
, flagword flags
)
2335 if (elf_flags_init (abfd
)
2336 && elf_elfheader (abfd
)->e_flags
!= flags
)
2338 if (EF_ARM_EABI_VERSION (flags
) == EF_ARM_EABI_UNKNOWN
)
2340 if (flags
& EF_ARM_INTERWORK
)
2341 (*_bfd_error_handler
)
2342 (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
2346 (_("Warning: Clearing the interworking flag of %B due to outside request"),
2352 elf_elfheader (abfd
)->e_flags
= flags
;
2353 elf_flags_init (abfd
) = TRUE
;
2359 /* Copy backend specific data from one object module to another. */
2362 elf32_arm_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
2367 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2368 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2371 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2372 out_flags
= elf_elfheader (obfd
)->e_flags
;
2374 if (elf_flags_init (obfd
)
2375 && EF_ARM_EABI_VERSION (out_flags
) == EF_ARM_EABI_UNKNOWN
2376 && in_flags
!= out_flags
)
2378 /* Cannot mix APCS26 and APCS32 code. */
2379 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2382 /* Cannot mix float APCS and non-float APCS code. */
2383 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2386 /* If the src and dest have different interworking flags
2387 then turn off the interworking bit. */
2388 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2390 if (out_flags
& EF_ARM_INTERWORK
)
2392 (_("Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
2395 in_flags
&= ~EF_ARM_INTERWORK
;
2398 /* Likewise for PIC, though don't warn for this case. */
2399 if ((in_flags
& EF_ARM_PIC
) != (out_flags
& EF_ARM_PIC
))
2400 in_flags
&= ~EF_ARM_PIC
;
2403 elf_elfheader (obfd
)->e_flags
= in_flags
;
2404 elf_flags_init (obfd
) = TRUE
;
2409 /* Merge backend specific data from an object file to the output
2410 object file when linking. */
2413 elf32_arm_merge_private_bfd_data (bfd
* ibfd
, bfd
* obfd
)
2417 bfd_boolean flags_compatible
= TRUE
;
2420 /* Check if we have the same endianess. */
2421 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
2424 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2425 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2428 /* The input BFD must have had its flags initialised. */
2429 /* The following seems bogus to me -- The flags are initialized in
2430 the assembler but I don't think an elf_flags_init field is
2431 written into the object. */
2432 /* BFD_ASSERT (elf_flags_init (ibfd)); */
2434 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2435 out_flags
= elf_elfheader (obfd
)->e_flags
;
2437 if (!elf_flags_init (obfd
))
2439 /* If the input is the default architecture and had the default
2440 flags then do not bother setting the flags for the output
2441 architecture, instead allow future merges to do this. If no
2442 future merges ever set these flags then they will retain their
2443 uninitialised values, which surprise surprise, correspond
2444 to the default values. */
2445 if (bfd_get_arch_info (ibfd
)->the_default
2446 && elf_elfheader (ibfd
)->e_flags
== 0)
2449 elf_flags_init (obfd
) = TRUE
;
2450 elf_elfheader (obfd
)->e_flags
= in_flags
;
2452 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
2453 && bfd_get_arch_info (obfd
)->the_default
)
2454 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
), bfd_get_mach (ibfd
));
2459 /* Determine what should happen if the input ARM architecture
2460 does not match the output ARM architecture. */
2461 if (! bfd_arm_merge_machines (ibfd
, obfd
))
2464 /* Identical flags must be compatible. */
2465 if (in_flags
== out_flags
)
2468 /* Check to see if the input BFD actually contains any sections. If
2469 not, its flags may not have been initialised either, but it
2470 cannot actually cause any incompatibility. Do not short-circuit
2471 dynamic objects; their section list may be emptied by
2472 elf_link_add_object_symbols.
2474 Also check to see if there are no code sections in the input.
2475 In this case there is no need to check for code specific flags.
2476 XXX - do we need to worry about floating-point format compatability
2477 in data sections ? */
2478 if (!(ibfd
->flags
& DYNAMIC
))
2480 bfd_boolean null_input_bfd
= TRUE
;
2481 bfd_boolean only_data_sections
= TRUE
;
2483 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2485 /* Ignore synthetic glue sections. */
2486 if (strcmp (sec
->name
, ".glue_7")
2487 && strcmp (sec
->name
, ".glue_7t"))
2489 if ((bfd_get_section_flags (ibfd
, sec
)
2490 & (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
2491 == (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
2492 only_data_sections
= FALSE
;
2494 null_input_bfd
= FALSE
;
2499 if (null_input_bfd
|| only_data_sections
)
2503 /* Complain about various flag mismatches. */
2504 if (EF_ARM_EABI_VERSION (in_flags
) != EF_ARM_EABI_VERSION (out_flags
))
2507 (_("ERROR: %B is compiled for EABI version %d, whereas %B is compiled for version %d"),
2509 (in_flags
& EF_ARM_EABIMASK
) >> 24,
2510 (out_flags
& EF_ARM_EABIMASK
) >> 24);
2514 /* Not sure what needs to be checked for EABI versions >= 1. */
2515 if (EF_ARM_EABI_VERSION (in_flags
) == EF_ARM_EABI_UNKNOWN
)
2517 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2520 (_("ERROR: %B is compiled for APCS-%d, whereas target %B uses APCS-%d"),
2522 in_flags
& EF_ARM_APCS_26
? 26 : 32,
2523 out_flags
& EF_ARM_APCS_26
? 26 : 32);
2524 flags_compatible
= FALSE
;
2527 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2529 if (in_flags
& EF_ARM_APCS_FLOAT
)
2531 (_("ERROR: %B passes floats in float registers, whereas %B passes them in integer registers"),
2535 (_("ERROR: %B passes floats in integer registers, whereas %B passes them in float registers"),
2538 flags_compatible
= FALSE
;
2541 if ((in_flags
& EF_ARM_VFP_FLOAT
) != (out_flags
& EF_ARM_VFP_FLOAT
))
2543 if (in_flags
& EF_ARM_VFP_FLOAT
)
2545 (_("ERROR: %B uses VFP instructions, whereas %B does not"),
2549 (_("ERROR: %B uses FPA instructions, whereas %B does not"),
2552 flags_compatible
= FALSE
;
2555 if ((in_flags
& EF_ARM_MAVERICK_FLOAT
) != (out_flags
& EF_ARM_MAVERICK_FLOAT
))
2557 if (in_flags
& EF_ARM_MAVERICK_FLOAT
)
2559 (_("ERROR: %B uses Maverick instructions, whereas %B does not"),
2563 (_("ERROR: %B does not use Maverick instructions, whereas %B does"),
2566 flags_compatible
= FALSE
;
2569 #ifdef EF_ARM_SOFT_FLOAT
2570 if ((in_flags
& EF_ARM_SOFT_FLOAT
) != (out_flags
& EF_ARM_SOFT_FLOAT
))
2572 /* We can allow interworking between code that is VFP format
2573 layout, and uses either soft float or integer regs for
2574 passing floating point arguments and results. We already
2575 know that the APCS_FLOAT flags match; similarly for VFP
2577 if ((in_flags
& EF_ARM_APCS_FLOAT
) != 0
2578 || (in_flags
& EF_ARM_VFP_FLOAT
) == 0)
2580 if (in_flags
& EF_ARM_SOFT_FLOAT
)
2582 (_("ERROR: %B uses software FP, whereas %B uses hardware FP"),
2586 (_("ERROR: %B uses hardware FP, whereas %B uses software FP"),
2589 flags_compatible
= FALSE
;
2594 /* Interworking mismatch is only a warning. */
2595 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2597 if (in_flags
& EF_ARM_INTERWORK
)
2600 (_("Warning: %B supports interworking, whereas %B does not"),
2606 (_("Warning: %B does not support interworking, whereas %B does"),
2612 return flags_compatible
;
2615 /* Display the flags field. */
2618 elf32_arm_print_private_bfd_data (bfd
*abfd
, void * ptr
)
2620 FILE * file
= (FILE *) ptr
;
2621 unsigned long flags
;
2623 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
2625 /* Print normal ELF private data. */
2626 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
2628 flags
= elf_elfheader (abfd
)->e_flags
;
2629 /* Ignore init flag - it may not be set, despite the flags field
2630 containing valid data. */
2632 /* xgettext:c-format */
2633 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
2635 switch (EF_ARM_EABI_VERSION (flags
))
2637 case EF_ARM_EABI_UNKNOWN
:
2638 /* The following flag bits are GNU extensions and not part of the
2639 official ARM ELF extended ABI. Hence they are only decoded if
2640 the EABI version is not set. */
2641 if (flags
& EF_ARM_INTERWORK
)
2642 fprintf (file
, _(" [interworking enabled]"));
2644 if (flags
& EF_ARM_APCS_26
)
2645 fprintf (file
, " [APCS-26]");
2647 fprintf (file
, " [APCS-32]");
2649 if (flags
& EF_ARM_VFP_FLOAT
)
2650 fprintf (file
, _(" [VFP float format]"));
2651 else if (flags
& EF_ARM_MAVERICK_FLOAT
)
2652 fprintf (file
, _(" [Maverick float format]"));
2654 fprintf (file
, _(" [FPA float format]"));
2656 if (flags
& EF_ARM_APCS_FLOAT
)
2657 fprintf (file
, _(" [floats passed in float registers]"));
2659 if (flags
& EF_ARM_PIC
)
2660 fprintf (file
, _(" [position independent]"));
2662 if (flags
& EF_ARM_NEW_ABI
)
2663 fprintf (file
, _(" [new ABI]"));
2665 if (flags
& EF_ARM_OLD_ABI
)
2666 fprintf (file
, _(" [old ABI]"));
2668 if (flags
& EF_ARM_SOFT_FLOAT
)
2669 fprintf (file
, _(" [software FP]"));
2671 flags
&= ~(EF_ARM_INTERWORK
| EF_ARM_APCS_26
| EF_ARM_APCS_FLOAT
2672 | EF_ARM_PIC
| EF_ARM_NEW_ABI
| EF_ARM_OLD_ABI
2673 | EF_ARM_SOFT_FLOAT
| EF_ARM_VFP_FLOAT
2674 | EF_ARM_MAVERICK_FLOAT
);
2677 case EF_ARM_EABI_VER1
:
2678 fprintf (file
, _(" [Version1 EABI]"));
2680 if (flags
& EF_ARM_SYMSARESORTED
)
2681 fprintf (file
, _(" [sorted symbol table]"));
2683 fprintf (file
, _(" [unsorted symbol table]"));
2685 flags
&= ~ EF_ARM_SYMSARESORTED
;
2688 case EF_ARM_EABI_VER2
:
2689 fprintf (file
, _(" [Version2 EABI]"));
2691 if (flags
& EF_ARM_SYMSARESORTED
)
2692 fprintf (file
, _(" [sorted symbol table]"));
2694 fprintf (file
, _(" [unsorted symbol table]"));
2696 if (flags
& EF_ARM_DYNSYMSUSESEGIDX
)
2697 fprintf (file
, _(" [dynamic symbols use segment index]"));
2699 if (flags
& EF_ARM_MAPSYMSFIRST
)
2700 fprintf (file
, _(" [mapping symbols precede others]"));
2702 flags
&= ~(EF_ARM_SYMSARESORTED
| EF_ARM_DYNSYMSUSESEGIDX
2703 | EF_ARM_MAPSYMSFIRST
);
2706 case EF_ARM_EABI_VER3
:
2707 fprintf (file
, _(" [Version3 EABI]"));
2709 if (flags
& EF_ARM_BE8
)
2710 fprintf (file
, _(" [BE8]"));
2712 if (flags
& EF_ARM_LE8
)
2713 fprintf (file
, _(" [LE8]"));
2715 flags
&= ~(EF_ARM_LE8
| EF_ARM_BE8
);
2719 fprintf (file
, _(" <EABI version unrecognised>"));
2723 flags
&= ~ EF_ARM_EABIMASK
;
2725 if (flags
& EF_ARM_RELEXEC
)
2726 fprintf (file
, _(" [relocatable executable]"));
2728 if (flags
& EF_ARM_HASENTRY
)
2729 fprintf (file
, _(" [has entry point]"));
2731 flags
&= ~ (EF_ARM_RELEXEC
| EF_ARM_HASENTRY
);
2734 fprintf (file
, _("<Unrecognised flag bits set>"));
2742 elf32_arm_get_symbol_type (Elf_Internal_Sym
* elf_sym
, int type
)
2744 switch (ELF_ST_TYPE (elf_sym
->st_info
))
2747 return ELF_ST_TYPE (elf_sym
->st_info
);
2750 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2751 This allows us to distinguish between data used by Thumb instructions
2752 and non-data (which is probably code) inside Thumb regions of an
2754 if (type
!= STT_OBJECT
)
2755 return ELF_ST_TYPE (elf_sym
->st_info
);
2766 elf32_arm_gc_mark_hook (asection
* sec
,
2767 struct bfd_link_info
* info ATTRIBUTE_UNUSED
,
2768 Elf_Internal_Rela
* rel
,
2769 struct elf_link_hash_entry
* h
,
2770 Elf_Internal_Sym
* sym
)
2774 switch (ELF32_R_TYPE (rel
->r_info
))
2776 case R_ARM_GNU_VTINHERIT
:
2777 case R_ARM_GNU_VTENTRY
:
2781 switch (h
->root
.type
)
2783 case bfd_link_hash_defined
:
2784 case bfd_link_hash_defweak
:
2785 return h
->root
.u
.def
.section
;
2787 case bfd_link_hash_common
:
2788 return h
->root
.u
.c
.p
->section
;
2796 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
2801 /* Update the got entry reference counts for the section being removed. */
2804 elf32_arm_gc_sweep_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
2805 struct bfd_link_info
* info ATTRIBUTE_UNUSED
,
2806 asection
* sec ATTRIBUTE_UNUSED
,
2807 const Elf_Internal_Rela
* relocs ATTRIBUTE_UNUSED
)
2809 Elf_Internal_Shdr
*symtab_hdr
;
2810 struct elf_link_hash_entry
**sym_hashes
;
2811 bfd_signed_vma
*local_got_refcounts
;
2812 const Elf_Internal_Rela
*rel
, *relend
;
2813 unsigned long r_symndx
;
2814 struct elf_link_hash_entry
*h
;
2815 struct elf32_arm_link_hash_table
* globals
;
2817 globals
= elf32_arm_hash_table (info
);
2819 elf_section_data (sec
)->local_dynrel
= NULL
;
2821 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2822 sym_hashes
= elf_sym_hashes (abfd
);
2823 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2825 relend
= relocs
+ sec
->reloc_count
;
2826 for (rel
= relocs
; rel
< relend
; rel
++)
2830 r_type
= ELF32_R_TYPE (rel
->r_info
);
2832 r_type
= arm_real_reloc_type (globals
, r_type
);
2838 case R_ARM_GOT_PREL
:
2840 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2841 if (r_symndx
>= symtab_hdr
->sh_info
)
2843 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2844 if (h
->got
.refcount
> 0)
2845 h
->got
.refcount
-= 1;
2847 else if (local_got_refcounts
!= NULL
)
2849 if (local_got_refcounts
[r_symndx
] > 0)
2850 local_got_refcounts
[r_symndx
] -= 1;
2861 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2862 if (r_symndx
>= symtab_hdr
->sh_info
)
2864 struct elf32_arm_link_hash_entry
*eh
;
2865 struct elf32_arm_relocs_copied
**pp
;
2866 struct elf32_arm_relocs_copied
*p
;
2868 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2870 if (h
->plt
.refcount
> 0)
2871 h
->plt
.refcount
-= 1;
2873 if (r_type
== R_ARM_ABS32
2875 || r_type
== R_ARM_PREL31
2877 || r_type
== R_ARM_REL32
)
2879 eh
= (struct elf32_arm_link_hash_entry
*) h
;
2881 for (pp
= &eh
->relocs_copied
; (p
= *pp
) != NULL
;
2883 if (p
->section
== sec
)
2902 /* Look through the relocs for a section during the first phase. */
2905 elf32_arm_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
2906 asection
*sec
, const Elf_Internal_Rela
*relocs
)
2908 Elf_Internal_Shdr
*symtab_hdr
;
2909 struct elf_link_hash_entry
**sym_hashes
;
2910 struct elf_link_hash_entry
**sym_hashes_end
;
2911 const Elf_Internal_Rela
*rel
;
2912 const Elf_Internal_Rela
*rel_end
;
2915 bfd_vma
*local_got_offsets
;
2916 struct elf32_arm_link_hash_table
*htab
;
2918 if (info
->relocatable
)
2921 htab
= elf32_arm_hash_table (info
);
2924 dynobj
= elf_hash_table (info
)->dynobj
;
2925 local_got_offsets
= elf_local_got_offsets (abfd
);
2927 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2928 sym_hashes
= elf_sym_hashes (abfd
);
2929 sym_hashes_end
= sym_hashes
2930 + symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
2932 if (!elf_bad_symtab (abfd
))
2933 sym_hashes_end
-= symtab_hdr
->sh_info
;
2935 rel_end
= relocs
+ sec
->reloc_count
;
2936 for (rel
= relocs
; rel
< rel_end
; rel
++)
2938 struct elf_link_hash_entry
*h
;
2939 unsigned long r_symndx
;
2942 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2943 r_type
= ELF32_R_TYPE (rel
->r_info
);
2945 r_type
= arm_real_reloc_type (htab
, r_type
);
2947 if (r_symndx
< symtab_hdr
->sh_info
)
2950 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2956 case R_ARM_GOT_PREL
:
2958 /* This symbol requires a global offset table entry. */
2965 bfd_signed_vma
*local_got_refcounts
;
2967 /* This is a global offset table entry for a local symbol. */
2968 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2969 if (local_got_refcounts
== NULL
)
2973 size
= symtab_hdr
->sh_info
;
2974 size
*= (sizeof (bfd_signed_vma
) + sizeof (char));
2975 local_got_refcounts
= bfd_zalloc (abfd
, size
);
2976 if (local_got_refcounts
== NULL
)
2978 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
2980 local_got_refcounts
[r_symndx
] += 1;
2982 if (r_type
== R_ARM_GOT32
)
2988 if (htab
->sgot
== NULL
)
2990 if (htab
->root
.dynobj
== NULL
)
2991 htab
->root
.dynobj
= abfd
;
2992 if (!create_got_section (htab
->root
.dynobj
, info
))
3006 /* If this reloc is in a read-only section, we might
3007 need a copy reloc. We can't check reliably at this
3008 stage whether the section is read-only, as input
3009 sections have not yet been mapped to output sections.
3010 Tentatively set the flag for now, and correct in
3011 adjust_dynamic_symbol. */
3015 /* We may need a .plt entry if the function this reloc
3016 refers to is in a different object. We can't tell for
3017 sure yet, because something later might force the
3019 if (r_type
== R_ARM_PC24
3020 || r_type
== R_ARM_PLT32
)
3023 /* If we create a PLT entry, this relocation will reference
3024 it, even if it's an ABS32 relocation. */
3025 h
->plt
.refcount
+= 1;
3028 /* If we are creating a shared library, and this is a reloc
3029 against a global symbol, or a non PC relative reloc
3030 against a local symbol, then we need to copy the reloc
3031 into the shared library. However, if we are linking with
3032 -Bsymbolic, we do not need to copy a reloc against a
3033 global symbol which is defined in an object we are
3034 including in the link (i.e., DEF_REGULAR is set). At
3035 this point we have not seen all the input files, so it is
3036 possible that DEF_REGULAR is not set now but will be set
3037 later (it is never cleared). We account for that
3038 possibility below by storing information in the
3039 relocs_copied field of the hash table entry. */
3041 && (sec
->flags
& SEC_ALLOC
) != 0
3042 && ((r_type
!= R_ARM_PC24
3043 && r_type
!= R_ARM_PLT32
3045 && r_type
!= R_ARM_PREL31
3047 && r_type
!= R_ARM_REL32
)
3049 && (! info
->symbolic
3050 || !h
->def_regular
))))
3052 struct elf32_arm_relocs_copied
*p
, **head
;
3054 /* When creating a shared object, we must copy these
3055 reloc types into the output file. We create a reloc
3056 section in dynobj and make room for this reloc. */
3061 name
= (bfd_elf_string_from_elf_section
3063 elf_elfheader (abfd
)->e_shstrndx
,
3064 elf_section_data (sec
)->rel_hdr
.sh_name
));
3068 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
3069 && strcmp (bfd_get_section_name (abfd
, sec
),
3072 sreloc
= bfd_get_section_by_name (dynobj
, name
);
3077 sreloc
= bfd_make_section (dynobj
, name
);
3078 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
3079 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3080 if ((sec
->flags
& SEC_ALLOC
) != 0
3081 /* BPABI objects never have dynamic
3082 relocations mapped. */
3083 && !htab
->symbian_p
)
3084 flags
|= SEC_ALLOC
| SEC_LOAD
;
3086 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
3087 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
3091 elf_section_data (sec
)->sreloc
= sreloc
;
3094 /* If this is a global symbol, we count the number of
3095 relocations we need for this symbol. */
3098 head
= &((struct elf32_arm_link_hash_entry
*) h
)->relocs_copied
;
3102 /* Track dynamic relocs needed for local syms too.
3103 We really need local syms available to do this
3107 s
= bfd_section_from_r_symndx (abfd
, &htab
->sym_sec
,
3112 head
= ((struct elf32_arm_relocs_copied
**)
3113 &elf_section_data (s
)->local_dynrel
);
3117 if (p
== NULL
|| p
->section
!= sec
)
3119 bfd_size_type amt
= sizeof *p
;
3121 p
= bfd_alloc (htab
->root
.dynobj
, amt
);
3130 if (r_type
== R_ARM_ABS32
3132 || r_type
== R_ARM_PREL31
3134 || r_type
== R_ARM_REL32
)
3139 /* This relocation describes the C++ object vtable hierarchy.
3140 Reconstruct it for later use during GC. */
3141 case R_ARM_GNU_VTINHERIT
:
3142 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
3146 /* This relocation describes which C++ vtable entries are actually
3147 used. Record for later use during GC. */
3148 case R_ARM_GNU_VTENTRY
:
3149 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
3159 is_arm_mapping_symbol_name (const char * name
)
3161 return (name
!= NULL
)
3163 && ((name
[1] == 'a') || (name
[1] == 't') || (name
[1] == 'd'))
3167 /* Treat mapping symbols as special target symbols. */
3170 elf32_arm_is_target_special_symbol (bfd
* abfd ATTRIBUTE_UNUSED
, asymbol
* sym
)
3172 return is_arm_mapping_symbol_name (sym
->name
);
3175 /* This is a copy of elf_find_function() from elf.c except that
3176 ARM mapping symbols are ignored when looking for function names
3177 and STT_ARM_TFUNC is considered to a function type. */
3180 arm_elf_find_function (bfd
* abfd ATTRIBUTE_UNUSED
,
3184 const char ** filename_ptr
,
3185 const char ** functionname_ptr
)
3187 const char * filename
= NULL
;
3188 asymbol
* func
= NULL
;
3189 bfd_vma low_func
= 0;
3192 for (p
= symbols
; *p
!= NULL
; p
++)
3196 q
= (elf_symbol_type
*) *p
;
3198 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
3203 filename
= bfd_asymbol_name (&q
->symbol
);
3207 /* Skip $a and $t symbols. */
3208 if ((q
->symbol
.flags
& BSF_LOCAL
)
3209 && is_arm_mapping_symbol_name (q
->symbol
.name
))
3213 if (bfd_get_section (&q
->symbol
) == section
3214 && q
->symbol
.value
>= low_func
3215 && q
->symbol
.value
<= offset
)
3217 func
= (asymbol
*) q
;
3218 low_func
= q
->symbol
.value
;
3228 *filename_ptr
= filename
;
3229 if (functionname_ptr
)
3230 *functionname_ptr
= bfd_asymbol_name (func
);
3236 /* Find the nearest line to a particular section and offset, for error
3237 reporting. This code is a duplicate of the code in elf.c, except
3238 that it uses arm_elf_find_function. */
3241 elf32_arm_find_nearest_line (bfd
* abfd
,
3245 const char ** filename_ptr
,
3246 const char ** functionname_ptr
,
3247 unsigned int * line_ptr
)
3249 bfd_boolean found
= FALSE
;
3251 /* We skip _bfd_dwarf1_find_nearest_line since no known ARM toolchain uses it. */
3253 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
3254 filename_ptr
, functionname_ptr
,
3256 & elf_tdata (abfd
)->dwarf2_find_line_info
))
3258 if (!*functionname_ptr
)
3259 arm_elf_find_function (abfd
, section
, symbols
, offset
,
3260 *filename_ptr
? NULL
: filename_ptr
,
3266 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
3267 & found
, filename_ptr
,
3268 functionname_ptr
, line_ptr
,
3269 & elf_tdata (abfd
)->line_info
))
3272 if (found
&& (*functionname_ptr
|| *line_ptr
))
3275 if (symbols
== NULL
)
3278 if (! arm_elf_find_function (abfd
, section
, symbols
, offset
,
3279 filename_ptr
, functionname_ptr
))
3286 /* Adjust a symbol defined by a dynamic object and referenced by a
3287 regular object. The current definition is in some section of the
3288 dynamic object, but we're not including those sections. We have to
3289 change the definition to something the rest of the link can
3293 elf32_arm_adjust_dynamic_symbol (struct bfd_link_info
* info
,
3294 struct elf_link_hash_entry
* h
)
3298 unsigned int power_of_two
;
3300 dynobj
= elf_hash_table (info
)->dynobj
;
3302 /* Make sure we know what is going on here. */
3303 BFD_ASSERT (dynobj
!= NULL
3305 || h
->u
.weakdef
!= NULL
3308 && !h
->def_regular
)));
3310 /* If this is a function, put it in the procedure linkage table. We
3311 will fill in the contents of the procedure linkage table later,
3312 when we know the address of the .got section. */
3313 if (h
->type
== STT_FUNC
3316 if (h
->plt
.refcount
<= 0
3317 || SYMBOL_CALLS_LOCAL (info
, h
)
3318 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
3319 && h
->root
.type
== bfd_link_hash_undefweak
))
3321 /* This case can occur if we saw a PLT32 reloc in an input
3322 file, but the symbol was never referred to by a dynamic
3323 object, or if all references were garbage collected. In
3324 such a case, we don't actually need to build a procedure
3325 linkage table, and we can just do a PC24 reloc instead. */
3326 h
->plt
.offset
= (bfd_vma
) -1;
3333 /* It's possible that we incorrectly decided a .plt reloc was
3334 needed for an R_ARM_PC24 reloc to a non-function sym in
3335 check_relocs. We can't decide accurately between function and
3336 non-function syms in check-relocs; Objects loaded later in
3337 the link may change h->type. So fix it now. */
3338 h
->plt
.offset
= (bfd_vma
) -1;
3340 /* If this is a weak symbol, and there is a real definition, the
3341 processor independent code will have arranged for us to see the
3342 real definition first, and we can just use the same value. */
3343 if (h
->u
.weakdef
!= NULL
)
3345 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
3346 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
3347 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
3348 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
3352 /* This is a reference to a symbol defined by a dynamic object which
3353 is not a function. */
3355 /* If we are creating a shared library, we must presume that the
3356 only references to the symbol are via the global offset table.
3357 For such cases we need not do anything here; the relocations will
3358 be handled correctly by relocate_section. */
3362 /* We must allocate the symbol in our .dynbss section, which will
3363 become part of the .bss section of the executable. There will be
3364 an entry for this symbol in the .dynsym section. The dynamic
3365 object will contain position independent code, so all references
3366 from the dynamic object to this symbol will go through the global
3367 offset table. The dynamic linker will use the .dynsym entry to
3368 determine the address it must put in the global offset table, so
3369 both the dynamic object and the regular object will refer to the
3370 same memory location for the variable. */
3371 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
3372 BFD_ASSERT (s
!= NULL
);
3374 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
3375 copy the initial value out of the dynamic object and into the
3376 runtime process image. We need to remember the offset into the
3377 .rel.bss section we are going to use. */
3378 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
3382 srel
= bfd_get_section_by_name (dynobj
, ".rel.bss");
3383 BFD_ASSERT (srel
!= NULL
);
3384 srel
->size
+= sizeof (Elf32_External_Rel
);
3388 /* We need to figure out the alignment required for this symbol. I
3389 have no idea how ELF linkers handle this. */
3390 power_of_two
= bfd_log2 (h
->size
);
3391 if (power_of_two
> 3)
3394 /* Apply the required alignment. */
3395 s
->size
= BFD_ALIGN (s
->size
, (bfd_size_type
) (1 << power_of_two
));
3396 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
3398 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
3402 /* Define the symbol as being at this point in the section. */
3403 h
->root
.u
.def
.section
= s
;
3404 h
->root
.u
.def
.value
= s
->size
;
3406 /* Increment the section size to make room for the symbol. */
3412 /* Allocate space in .plt, .got and associated reloc sections for
3416 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
3418 struct bfd_link_info
*info
;
3419 struct elf32_arm_link_hash_table
*htab
;
3420 struct elf32_arm_link_hash_entry
*eh
;
3421 struct elf32_arm_relocs_copied
*p
;
3423 if (h
->root
.type
== bfd_link_hash_indirect
)
3426 if (h
->root
.type
== bfd_link_hash_warning
)
3427 /* When warning symbols are created, they **replace** the "real"
3428 entry in the hash table, thus we never get to see the real
3429 symbol in a hash traversal. So look at it now. */
3430 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3432 info
= (struct bfd_link_info
*) inf
;
3433 htab
= elf32_arm_hash_table (info
);
3435 if (htab
->root
.dynamic_sections_created
3436 && h
->plt
.refcount
> 0)
3438 /* Make sure this symbol is output as a dynamic symbol.
3439 Undefined weak syms won't yet be marked as dynamic. */
3440 if (h
->dynindx
== -1
3441 && !h
->forced_local
)
3443 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3448 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
3450 asection
*s
= htab
->splt
;
3452 /* If this is the first .plt entry, make room for the special
3455 s
->size
+= htab
->plt_header_size
;
3457 h
->plt
.offset
= s
->size
;
3459 /* If this symbol is not defined in a regular file, and we are
3460 not generating a shared library, then set the symbol to this
3461 location in the .plt. This is required to make function
3462 pointers compare as equal between the normal executable and
3463 the shared library. */
3467 h
->root
.u
.def
.section
= s
;
3468 h
->root
.u
.def
.value
= h
->plt
.offset
;
3471 /* Make room for this entry. */
3472 s
->size
+= htab
->plt_entry_size
;
3474 if (!htab
->symbian_p
)
3475 /* We also need to make an entry in the .got.plt section, which
3476 will be placed in the .got section by the linker script. */
3477 htab
->sgotplt
->size
+= 4;
3479 /* We also need to make an entry in the .rel.plt section. */
3480 htab
->srelplt
->size
+= sizeof (Elf32_External_Rel
);
3484 h
->plt
.offset
= (bfd_vma
) -1;
3490 h
->plt
.offset
= (bfd_vma
) -1;
3494 if (h
->got
.refcount
> 0)
3499 /* Make sure this symbol is output as a dynamic symbol.
3500 Undefined weak syms won't yet be marked as dynamic. */
3501 if (h
->dynindx
== -1
3502 && !h
->forced_local
)
3504 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3508 if (!htab
->symbian_p
)
3511 h
->got
.offset
= s
->size
;
3513 dyn
= htab
->root
.dynamic_sections_created
;
3514 if ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3515 || h
->root
.type
!= bfd_link_hash_undefweak
)
3517 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
3518 htab
->srelgot
->size
+= sizeof (Elf32_External_Rel
);
3522 h
->got
.offset
= (bfd_vma
) -1;
3524 eh
= (struct elf32_arm_link_hash_entry
*) h
;
3525 if (eh
->relocs_copied
== NULL
)
3528 /* In the shared -Bsymbolic case, discard space allocated for
3529 dynamic pc-relative relocs against symbols which turn out to be
3530 defined in regular objects. For the normal shared case, discard
3531 space for pc-relative relocs that have become local due to symbol
3532 visibility changes. */
3536 /* Discard relocs on undefined weak syms with non-default
3538 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
3539 && h
->root
.type
== bfd_link_hash_undefweak
)
3540 eh
->relocs_copied
= NULL
;
3544 /* For the non-shared case, discard space for relocs against
3545 symbols which turn out to need copy relocs or are not
3551 || (htab
->root
.dynamic_sections_created
3552 && (h
->root
.type
== bfd_link_hash_undefweak
3553 || h
->root
.type
== bfd_link_hash_undefined
))))
3555 /* Make sure this symbol is output as a dynamic symbol.
3556 Undefined weak syms won't yet be marked as dynamic. */
3557 if (h
->dynindx
== -1
3558 && !h
->forced_local
)
3560 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3564 /* If that succeeded, we know we'll be keeping all the
3566 if (h
->dynindx
!= -1)
3570 eh
->relocs_copied
= NULL
;
3575 /* Finally, allocate space. */
3576 for (p
= eh
->relocs_copied
; p
!= NULL
; p
= p
->next
)
3578 asection
*sreloc
= elf_section_data (p
->section
)->sreloc
;
3579 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
3585 /* Set the sizes of the dynamic sections. */
3588 elf32_arm_size_dynamic_sections (bfd
* output_bfd ATTRIBUTE_UNUSED
,
3589 struct bfd_link_info
* info
)
3596 struct elf32_arm_link_hash_table
*htab
;
3598 htab
= elf32_arm_hash_table (info
);
3599 dynobj
= elf_hash_table (info
)->dynobj
;
3600 BFD_ASSERT (dynobj
!= NULL
);
3602 if (elf_hash_table (info
)->dynamic_sections_created
)
3604 /* Set the contents of the .interp section to the interpreter. */
3605 if (info
->executable
)
3607 s
= bfd_get_section_by_name (dynobj
, ".interp");
3608 BFD_ASSERT (s
!= NULL
);
3609 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
3610 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
3614 /* Set up .got offsets for local syms, and space for local dynamic
3616 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
3618 bfd_signed_vma
*local_got
;
3619 bfd_signed_vma
*end_local_got
;
3620 char *local_tls_type
;
3621 bfd_size_type locsymcount
;
3622 Elf_Internal_Shdr
*symtab_hdr
;
3625 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
3628 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3630 struct elf32_arm_relocs_copied
*p
;
3632 for (p
= *((struct elf32_arm_relocs_copied
**)
3633 &elf_section_data (s
)->local_dynrel
);
3637 if (!bfd_is_abs_section (p
->section
)
3638 && bfd_is_abs_section (p
->section
->output_section
))
3640 /* Input section has been discarded, either because
3641 it is a copy of a linkonce section or due to
3642 linker script /DISCARD/, so we'll be discarding
3645 else if (p
->count
!= 0)
3647 srel
= elf_section_data (p
->section
)->sreloc
;
3648 srel
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
3649 if ((p
->section
->output_section
->flags
& SEC_READONLY
) != 0)
3650 info
->flags
|= DF_TEXTREL
;
3655 local_got
= elf_local_got_refcounts (ibfd
);
3659 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
3660 locsymcount
= symtab_hdr
->sh_info
;
3661 end_local_got
= local_got
+ locsymcount
;
3663 srel
= htab
->srelgot
;
3664 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
3668 *local_got
= s
->size
;
3671 srel
->size
+= sizeof (Elf32_External_Rel
);
3674 *local_got
= (bfd_vma
) -1;
3678 /* Allocate global sym .plt and .got entries, and space for global
3679 sym dynamic relocs. */
3680 elf_link_hash_traverse (& htab
->root
, allocate_dynrelocs
, info
);
3682 /* The check_relocs and adjust_dynamic_symbol entry points have
3683 determined the sizes of the various dynamic sections. Allocate
3687 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3692 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3695 /* It's OK to base decisions on the section name, because none
3696 of the dynobj section names depend upon the input files. */
3697 name
= bfd_get_section_name (dynobj
, s
);
3701 if (strcmp (name
, ".plt") == 0)
3705 /* Strip this section if we don't need it; see the
3711 /* Remember whether there is a PLT. */
3715 else if (strncmp (name
, ".rel", 4) == 0)
3719 /* If we don't need this section, strip it from the
3720 output file. This is mostly to handle .rel.bss and
3721 .rel.plt. We must create both sections in
3722 create_dynamic_sections, because they must be created
3723 before the linker maps input sections to output
3724 sections. The linker does that before
3725 adjust_dynamic_symbol is called, and it is that
3726 function which decides whether anything needs to go
3727 into these sections. */
3732 /* Remember whether there are any reloc sections other
3734 if (strcmp (name
, ".rel.plt") != 0)
3737 /* We use the reloc_count field as a counter if we need
3738 to copy relocs into the output file. */
3742 else if (strncmp (name
, ".got", 4) != 0)
3744 /* It's not one of our sections, so don't allocate space. */
3750 _bfd_strip_section_from_output (info
, s
);
3754 /* Allocate memory for the section contents. */
3755 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3756 if (s
->contents
== NULL
&& s
->size
!= 0)
3760 if (elf_hash_table (info
)->dynamic_sections_created
)
3762 /* Add some entries to the .dynamic section. We fill in the
3763 values later, in elf32_arm_finish_dynamic_sections, but we
3764 must add the entries now so that we get the correct size for
3765 the .dynamic section. The DT_DEBUG entry is filled in by the
3766 dynamic linker and used by the debugger. */
3767 #define add_dynamic_entry(TAG, VAL) \
3768 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3772 if (!add_dynamic_entry (DT_DEBUG
, 0))
3778 if ( !add_dynamic_entry (DT_PLTGOT
, 0)
3779 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
3780 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
3781 || !add_dynamic_entry (DT_JMPREL
, 0))
3787 if ( !add_dynamic_entry (DT_REL
, 0)
3788 || !add_dynamic_entry (DT_RELSZ
, 0)
3789 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
3793 if ((info
->flags
& DF_TEXTREL
) != 0)
3795 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3797 info
->flags
|= DF_TEXTREL
;
3800 #undef add_synamic_entry
3805 /* Finish up dynamic symbol handling. We set the contents of various
3806 dynamic sections here. */
3809 elf32_arm_finish_dynamic_symbol (bfd
* output_bfd
, struct bfd_link_info
* info
,
3810 struct elf_link_hash_entry
* h
, Elf_Internal_Sym
* sym
)
3813 struct elf32_arm_link_hash_table
*htab
;
3815 dynobj
= elf_hash_table (info
)->dynobj
;
3816 htab
= elf32_arm_hash_table (info
);
3818 if (h
->plt
.offset
!= (bfd_vma
) -1)
3824 Elf_Internal_Rela rel
;
3826 /* This symbol has an entry in the procedure linkage table. Set
3829 BFD_ASSERT (h
->dynindx
!= -1);
3831 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3832 srel
= bfd_get_section_by_name (dynobj
, ".rel.plt");
3833 BFD_ASSERT (splt
!= NULL
&& srel
!= NULL
);
3835 /* Get the index in the procedure linkage table which
3836 corresponds to this symbol. This is the index of this symbol
3837 in all the symbols for which we are making plt entries. The
3838 first entry in the procedure linkage table is reserved. */
3839 plt_index
= ((h
->plt
.offset
- htab
->plt_header_size
)
3840 / htab
->plt_entry_size
);
3842 /* Fill in the entry in the procedure linkage table. */
3843 if (htab
->symbian_p
)
3846 for (i
= 0; i
< htab
->plt_entry_size
/ 4; ++i
)
3847 bfd_put_32 (output_bfd
,
3848 elf32_arm_symbian_plt_entry
[i
],
3849 splt
->contents
+ h
->plt
.offset
+ 4 * i
);
3851 /* Fill in the entry in the .rel.plt section. */
3852 rel
.r_offset
= (splt
->output_offset
3853 + h
->plt
.offset
+ 4 * (i
- 1));
3854 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_GLOB_DAT
);
3859 bfd_vma got_displacement
;
3862 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3863 BFD_ASSERT (sgot
!= NULL
);
3865 /* Get the offset into the .got table of the entry that
3866 corresponds to this function. Each .got entry is 4 bytes.
3867 The first three are reserved. */
3868 got_offset
= (plt_index
+ 3) * 4;
3870 /* Calculate the displacement between the PLT slot and the
3871 entry in the GOT. */
3872 got_displacement
= (sgot
->output_section
->vma
3873 + sgot
->output_offset
3875 - splt
->output_section
->vma
3876 - splt
->output_offset
3880 BFD_ASSERT ((got_displacement
& 0xf0000000) == 0);
3882 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[0] | ((got_displacement
& 0x0ff00000) >> 20),
3883 splt
->contents
+ h
->plt
.offset
+ 0);
3884 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[1] | ((got_displacement
& 0x000ff000) >> 12),
3885 splt
->contents
+ h
->plt
.offset
+ 4);
3886 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[2] | (got_displacement
& 0x00000fff),
3887 splt
->contents
+ h
->plt
.offset
+ 8);
3888 #ifdef FOUR_WORD_PLT
3889 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[3],
3890 splt
->contents
+ h
->plt
.offset
+ 12);
3893 /* Fill in the entry in the global offset table. */
3894 bfd_put_32 (output_bfd
,
3895 (splt
->output_section
->vma
3896 + splt
->output_offset
),
3897 sgot
->contents
+ got_offset
);
3899 /* Fill in the entry in the .rel.plt section. */
3900 rel
.r_offset
= (sgot
->output_section
->vma
3901 + sgot
->output_offset
3903 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_JUMP_SLOT
);
3906 loc
= srel
->contents
+ plt_index
* sizeof (Elf32_External_Rel
);
3907 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3909 if (!h
->def_regular
)
3911 /* Mark the symbol as undefined, rather than as defined in
3912 the .plt section. Leave the value alone. */
3913 sym
->st_shndx
= SHN_UNDEF
;
3914 /* If the symbol is weak, we do need to clear the value.
3915 Otherwise, the PLT entry would provide a definition for
3916 the symbol even if the symbol wasn't defined anywhere,
3917 and so the symbol would never be NULL. */
3918 if (!h
->ref_regular_nonweak
)
3923 if (h
->got
.offset
!= (bfd_vma
) -1)
3927 Elf_Internal_Rela rel
;
3930 /* This symbol has an entry in the global offset table. Set it
3932 sgot
= bfd_get_section_by_name (dynobj
, ".got");
3933 srel
= bfd_get_section_by_name (dynobj
, ".rel.got");
3934 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
3936 rel
.r_offset
= (sgot
->output_section
->vma
3937 + sgot
->output_offset
3938 + (h
->got
.offset
&~ (bfd_vma
) 1));
3940 /* If this is a static link, or it is a -Bsymbolic link and the
3941 symbol is defined locally or was forced to be local because
3942 of a version file, we just want to emit a RELATIVE reloc.
3943 The entry in the global offset table will already have been
3944 initialized in the relocate_section function. */
3946 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3948 BFD_ASSERT((h
->got
.offset
& 1) != 0);
3949 rel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
3953 BFD_ASSERT((h
->got
.offset
& 1) == 0);
3954 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
3955 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_GLOB_DAT
);
3958 loc
= srel
->contents
+ srel
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3959 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3965 Elf_Internal_Rela rel
;
3968 /* This symbol needs a copy reloc. Set it up. */
3969 BFD_ASSERT (h
->dynindx
!= -1
3970 && (h
->root
.type
== bfd_link_hash_defined
3971 || h
->root
.type
== bfd_link_hash_defweak
));
3973 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
3975 BFD_ASSERT (s
!= NULL
);
3977 rel
.r_offset
= (h
->root
.u
.def
.value
3978 + h
->root
.u
.def
.section
->output_section
->vma
3979 + h
->root
.u
.def
.section
->output_offset
);
3980 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_COPY
);
3981 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3982 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3985 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3986 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3987 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
3988 sym
->st_shndx
= SHN_ABS
;
3993 /* Finish up the dynamic sections. */
3996 elf32_arm_finish_dynamic_sections (bfd
* output_bfd
, struct bfd_link_info
* info
)
4002 dynobj
= elf_hash_table (info
)->dynobj
;
4004 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
4005 BFD_ASSERT (elf32_arm_hash_table (info
)->symbian_p
|| sgot
!= NULL
);
4006 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
4008 if (elf_hash_table (info
)->dynamic_sections_created
)
4011 Elf32_External_Dyn
*dyncon
, *dynconend
;
4012 struct elf32_arm_link_hash_table
*htab
;
4014 htab
= elf32_arm_hash_table (info
);
4015 splt
= bfd_get_section_by_name (dynobj
, ".plt");
4016 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
4018 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
4019 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4021 for (; dyncon
< dynconend
; dyncon
++)
4023 Elf_Internal_Dyn dyn
;
4027 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4038 goto get_vma_if_bpabi
;
4041 goto get_vma_if_bpabi
;
4044 goto get_vma_if_bpabi
;
4052 s
= bfd_get_section_by_name (output_bfd
, name
);
4053 BFD_ASSERT (s
!= NULL
);
4054 if (!htab
->symbian_p
)
4055 dyn
.d_un
.d_ptr
= s
->vma
;
4057 /* In the BPABI, tags in the PT_DYNAMIC section point
4058 at the file offset, not the memory address, for the
4059 convenience of the post linker. */
4060 dyn
.d_un
.d_ptr
= s
->filepos
;
4061 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4065 if (htab
->symbian_p
)
4070 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
4071 BFD_ASSERT (s
!= NULL
);
4072 dyn
.d_un
.d_val
= s
->size
;
4073 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4077 if (!htab
->symbian_p
)
4079 /* My reading of the SVR4 ABI indicates that the
4080 procedure linkage table relocs (DT_JMPREL) should be
4081 included in the overall relocs (DT_REL). This is
4082 what Solaris does. However, UnixWare can not handle
4083 that case. Therefore, we override the DT_RELSZ entry
4084 here to make it not include the JMPREL relocs. Since
4085 the linker script arranges for .rel.plt to follow all
4086 other relocation sections, we don't have to worry
4087 about changing the DT_REL entry. */
4088 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
4090 dyn
.d_un
.d_val
-= s
->size
;
4091 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4099 /* In the BPABI, the DT_REL tag must point at the file
4100 offset, not the VMA, of the first relocation
4101 section. So, we use code similar to that in
4102 elflink.c, but do not check for SHF_ALLOC on the
4103 relcoation section, since relocations sections are
4104 never allocated under the BPABI. The comments above
4105 about Unixware notwithstanding, we include all of the
4106 relocations here. */
4107 if (htab
->symbian_p
)
4110 type
= ((dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
4111 ? SHT_REL
: SHT_RELA
);
4113 for (i
= 1; i
< elf_numsections (output_bfd
); i
++)
4115 Elf_Internal_Shdr
*hdr
4116 = elf_elfsections (output_bfd
)[i
];
4117 if (hdr
->sh_type
== type
)
4119 if (dyn
.d_tag
== DT_RELSZ
4120 || dyn
.d_tag
== DT_RELASZ
)
4121 dyn
.d_un
.d_val
+= hdr
->sh_size
;
4122 else if (dyn
.d_un
.d_val
== 0
4123 || hdr
->sh_offset
< dyn
.d_un
.d_val
)
4124 dyn
.d_un
.d_val
= hdr
->sh_offset
;
4127 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4131 /* Set the bottom bit of DT_INIT/FINI if the
4132 corresponding function is Thumb. */
4134 name
= info
->init_function
;
4137 name
= info
->fini_function
;
4139 /* If it wasn't set by elf_bfd_final_link
4140 then there is nothing to adjust. */
4141 if (dyn
.d_un
.d_val
!= 0)
4143 struct elf_link_hash_entry
* eh
;
4145 eh
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4146 FALSE
, FALSE
, TRUE
);
4147 if (eh
!= (struct elf_link_hash_entry
*) NULL
4148 && ELF_ST_TYPE (eh
->type
) == STT_ARM_TFUNC
)
4150 dyn
.d_un
.d_val
|= 1;
4151 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4158 /* Fill in the first entry in the procedure linkage table. */
4159 if (splt
->size
> 0 && elf32_arm_hash_table (info
)->plt_header_size
)
4161 bfd_vma got_displacement
;
4163 /* Calculate the displacement between the PLT slot and &GOT[0]. */
4164 got_displacement
= (sgot
->output_section
->vma
4165 + sgot
->output_offset
4166 - splt
->output_section
->vma
4167 - splt
->output_offset
4170 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[0], splt
->contents
+ 0);
4171 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[1], splt
->contents
+ 4);
4172 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[2], splt
->contents
+ 8);
4173 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[3], splt
->contents
+ 12);
4174 #ifdef FOUR_WORD_PLT
4175 /* The displacement value goes in the otherwise-unused last word of
4176 the second entry. */
4177 bfd_put_32 (output_bfd
, got_displacement
, splt
->contents
+ 28);
4179 bfd_put_32 (output_bfd
, got_displacement
, splt
->contents
+ 16);
4183 /* UnixWare sets the entsize of .plt to 4, although that doesn't
4184 really seem like the right value. */
4185 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
4188 /* Fill in the first three entries in the global offset table. */
4194 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
4196 bfd_put_32 (output_bfd
,
4197 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
4199 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
4200 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
4203 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
4210 elf32_arm_post_process_headers (bfd
* abfd
, struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
)
4212 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
4213 struct elf32_arm_link_hash_table
*globals
;
4215 i_ehdrp
= elf_elfheader (abfd
);
4217 i_ehdrp
->e_ident
[EI_OSABI
] = ARM_ELF_OS_ABI_VERSION
;
4218 i_ehdrp
->e_ident
[EI_ABIVERSION
] = ARM_ELF_ABI_VERSION
;
4222 globals
= elf32_arm_hash_table (link_info
);
4223 if (globals
->byteswap_code
)
4224 i_ehdrp
->e_flags
|= EF_ARM_BE8
;
4228 static enum elf_reloc_type_class
4229 elf32_arm_reloc_type_class (const Elf_Internal_Rela
*rela
)
4231 switch ((int) ELF32_R_TYPE (rela
->r_info
))
4233 case R_ARM_RELATIVE
:
4234 return reloc_class_relative
;
4235 case R_ARM_JUMP_SLOT
:
4236 return reloc_class_plt
;
4238 return reloc_class_copy
;
4240 return reloc_class_normal
;
4244 /* Set the right machine number for an Arm ELF file. */
4247 elf32_arm_section_flags (flagword
*flags
, const Elf_Internal_Shdr
*hdr
)
4249 if (hdr
->sh_type
== SHT_NOTE
)
4250 *flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_CONTENTS
;
4256 elf32_arm_final_write_processing (bfd
*abfd
, bfd_boolean linker ATTRIBUTE_UNUSED
)
4258 bfd_arm_update_notes (abfd
, ARM_NOTE_SECTION
);
4261 /* Return TRUE if this is an unwinding table entry. */
4264 is_arm_elf_unwind_section_name (bfd
* abfd ATTRIBUTE_UNUSED
, const char * name
)
4268 len1
= sizeof (ELF_STRING_ARM_unwind
) - 1;
4269 len2
= sizeof (ELF_STRING_ARM_unwind_once
) - 1;
4270 return (strncmp (name
, ELF_STRING_ARM_unwind
, len1
) == 0
4271 || strncmp (name
, ELF_STRING_ARM_unwind_once
, len2
) == 0);
4275 /* Set the type and flags for an ARM section. We do this by
4276 the section name, which is a hack, but ought to work. */
4279 elf32_arm_fake_sections (bfd
* abfd
, Elf_Internal_Shdr
* hdr
, asection
* sec
)
4283 name
= bfd_get_section_name (abfd
, sec
);
4285 if (is_arm_elf_unwind_section_name (abfd
, name
))
4287 hdr
->sh_type
= SHT_ARM_EXIDX
;
4288 hdr
->sh_flags
|= SHF_LINK_ORDER
;
4293 /* Handle an ARM specific section when reading an object file.
4294 This is called when elf.c finds a section with an unknown type. */
4297 elf32_arm_section_from_shdr (bfd
*abfd
,
4298 Elf_Internal_Shdr
* hdr
,
4301 /* There ought to be a place to keep ELF backend specific flags, but
4302 at the moment there isn't one. We just keep track of the
4303 sections by their name, instead. Fortunately, the ABI gives
4304 names for all the ARM specific sections, so we will probably get
4306 switch (hdr
->sh_type
)
4315 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
4321 /* Called for each symbol. Builds a section map based on mapping symbols.
4322 Does not alter any of the symbols. */
4325 elf32_arm_output_symbol_hook (struct bfd_link_info
*info
,
4327 Elf_Internal_Sym
*elfsym
,
4328 asection
*input_sec
,
4329 struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
4332 elf32_arm_section_map
*map
;
4333 struct elf32_arm_link_hash_table
*globals
;
4335 /* Only do this on final link. */
4336 if (info
->relocatable
)
4339 /* Only build a map if we need to byteswap code. */
4340 globals
= elf32_arm_hash_table (info
);
4341 if (!globals
->byteswap_code
)
4344 /* We only want mapping symbols. */
4345 if (! is_arm_mapping_symbol_name (name
))
4348 mapcount
= ++(elf32_arm_section_data (input_sec
)->mapcount
);
4349 map
= elf32_arm_section_data (input_sec
)->map
;
4350 /* TODO: This may be inefficient, but we probably don't usually have many
4351 mapping symbols per section. */
4352 map
= bfd_realloc (map
, mapcount
* sizeof (elf32_arm_section_map
));
4353 elf32_arm_section_data (input_sec
)->map
= map
;
4355 map
[mapcount
- 1].vma
= elfsym
->st_value
;
4356 map
[mapcount
- 1].type
= name
[1];
4361 /* Allocate target specific section data. */
4364 elf32_arm_new_section_hook (bfd
*abfd
, asection
*sec
)
4366 struct _arm_elf_section_data
*sdata
;
4367 bfd_size_type amt
= sizeof (*sdata
);
4369 sdata
= bfd_zalloc (abfd
, amt
);
4372 sec
->used_by_bfd
= sdata
;
4374 return _bfd_elf_new_section_hook (abfd
, sec
);
4378 /* Used to order a list of mapping symbols by address. */
4381 elf32_arm_compare_mapping (const void * a
, const void * b
)
4383 return ((const elf32_arm_section_map
*) a
)->vma
4384 > ((const elf32_arm_section_map
*) b
)->vma
;
4388 /* Do code byteswapping. Return FALSE afterwards so that the section is
4389 written out as normal. */
4392 elf32_arm_write_section (bfd
*output_bfd ATTRIBUTE_UNUSED
, asection
*sec
,
4396 elf32_arm_section_map
*map
;
4403 mapcount
= elf32_arm_section_data (sec
)->mapcount
;
4404 map
= elf32_arm_section_data (sec
)->map
;
4409 qsort (map
, mapcount
, sizeof (elf32_arm_section_map
),
4410 elf32_arm_compare_mapping
);
4412 offset
= sec
->output_section
->vma
+ sec
->output_offset
;
4413 ptr
= map
[0].vma
- offset
;
4414 for (i
= 0; i
< mapcount
; i
++)
4416 if (i
== mapcount
- 1)
4419 end
= map
[i
+ 1].vma
- offset
;
4421 switch (map
[i
].type
)
4424 /* Byte swap code words. */
4425 while (ptr
+ 3 < end
)
4427 tmp
= contents
[ptr
];
4428 contents
[ptr
] = contents
[ptr
+ 3];
4429 contents
[ptr
+ 3] = tmp
;
4430 tmp
= contents
[ptr
+ 1];
4431 contents
[ptr
+ 1] = contents
[ptr
+ 2];
4432 contents
[ptr
+ 2] = tmp
;
4438 /* Byte swap code halfwords. */
4439 while (ptr
+ 1 < end
)
4441 tmp
= contents
[ptr
];
4442 contents
[ptr
] = contents
[ptr
+ 1];
4443 contents
[ptr
+ 1] = tmp
;
4449 /* Leave data alone. */
4458 #define ELF_ARCH bfd_arch_arm
4459 #define ELF_MACHINE_CODE EM_ARM
4460 #ifdef __QNXTARGET__
4461 #define ELF_MAXPAGESIZE 0x1000
4463 #define ELF_MAXPAGESIZE 0x8000
4466 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
4467 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
4468 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
4469 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
4470 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
4471 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
4472 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
4473 #define bfd_elf32_new_section_hook elf32_arm_new_section_hook
4474 #define bfd_elf32_bfd_is_target_special_symbol elf32_arm_is_target_special_symbol
4476 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
4477 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
4478 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
4479 #define elf_backend_check_relocs elf32_arm_check_relocs
4480 #define elf_backend_relocate_section elf32_arm_relocate_section
4481 #define elf_backend_write_section elf32_arm_write_section
4482 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
4483 #define elf_backend_create_dynamic_sections elf32_arm_create_dynamic_sections
4484 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
4485 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
4486 #define elf_backend_link_output_symbol_hook elf32_arm_output_symbol_hook
4487 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
4488 #define elf_backend_post_process_headers elf32_arm_post_process_headers
4489 #define elf_backend_reloc_type_class elf32_arm_reloc_type_class
4490 #define elf_backend_object_p elf32_arm_object_p
4491 #define elf_backend_section_flags elf32_arm_section_flags
4492 #define elf_backend_fake_sections elf32_arm_fake_sections
4493 #define elf_backend_section_from_shdr elf32_arm_section_from_shdr
4494 #define elf_backend_final_write_processing elf32_arm_final_write_processing
4495 #define elf_backend_copy_indirect_symbol elf32_arm_copy_indirect_symbol
4497 #define elf_backend_can_refcount 1
4498 #define elf_backend_can_gc_sections 1
4499 #define elf_backend_plt_readonly 1
4500 #define elf_backend_want_got_plt 1
4501 #define elf_backend_want_plt_sym 0
4503 #define elf_backend_rela_normal 1
4506 #define elf_backend_got_header_size 12
4508 #include "elf32-target.h"