1 /* 32-bit ELF support for ARM
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 typedef unsigned long int insn32
;
26 typedef unsigned short int insn16
;
28 /* In leiu of proper flags, assume all EABIv3 objects are interworkable. */
29 #define INTERWORK_FLAG(abfd) \
30 (EF_ARM_EABI_VERSION (elf_elfheader (abfd)->e_flags) == EF_ARM_EABI_VER3 \
31 || (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK))
33 /* The linker script knows the section names for placement.
34 The entry_names are used to do simple name mangling on the stubs.
35 Given a function name, and its type, the stub can be found. The
36 name can be changed. The only requirement is the %s be present. */
37 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
38 #define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
40 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
41 #define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
43 /* The name of the dynamic interpreter. This is put in the .interp
45 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
49 /* The 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
, "got-rel") == 0)
929 globals
->target2_reloc
= R_ARM_GOT_PREL
;
932 _bfd_error_handler (_("Invalid TARGET2 relocation type '%s'."),
938 /* The thumb form of a long branch is a bit finicky, because the offset
939 encoding is split over two fields, each in it's own instruction. They
940 can occur in any order. So given a thumb form of long branch, and an
941 offset, insert the offset into the thumb branch and return finished
944 It takes two thumb instructions to encode the target address. Each has
945 11 bits to invest. The upper 11 bits are stored in one (identified by
946 H-0.. see below), the lower 11 bits are stored in the other (identified
949 Combine together and shifted left by 1 (it's a half word address) and
953 H-0, upper address-0 = 000
955 H-1, lower address-0 = 800
957 They can be ordered either way, but the arm tools I've seen always put
958 the lower one first. It probably doesn't matter. krk@cygnus.com
960 XXX: Actually the order does matter. The second instruction (H-1)
961 moves the computed address into the PC, so it must be the second one
962 in the sequence. The problem, however is that whilst little endian code
963 stores the instructions in HI then LOW order, big endian code does the
964 reverse. nickc@cygnus.com. */
966 #define LOW_HI_ORDER 0xF800F000
967 #define HI_LOW_ORDER 0xF000F800
970 insert_thumb_branch (insn32 br_insn
, int rel_off
)
972 unsigned int low_bits
;
973 unsigned int high_bits
;
975 BFD_ASSERT ((rel_off
& 1) != 1);
977 rel_off
>>= 1; /* Half word aligned address. */
978 low_bits
= rel_off
& 0x000007FF; /* The bottom 11 bits. */
979 high_bits
= (rel_off
>> 11) & 0x000007FF; /* The top 11 bits. */
981 if ((br_insn
& LOW_HI_ORDER
) == LOW_HI_ORDER
)
982 br_insn
= LOW_HI_ORDER
| (low_bits
<< 16) | high_bits
;
983 else if ((br_insn
& HI_LOW_ORDER
) == HI_LOW_ORDER
)
984 br_insn
= HI_LOW_ORDER
| (high_bits
<< 16) | low_bits
;
986 /* FIXME: abort is probably not the right call. krk@cygnus.com */
987 abort (); /* Error - not a valid branch instruction form. */
992 /* Thumb code calling an ARM function. */
995 elf32_thumb_to_arm_stub (struct bfd_link_info
* info
,
999 asection
* input_section
,
1000 bfd_byte
* hit_data
,
1003 bfd_signed_vma addend
,
1008 unsigned long int tmp
;
1009 long int ret_offset
;
1010 struct elf_link_hash_entry
* myh
;
1011 struct elf32_arm_link_hash_table
* globals
;
1013 myh
= find_thumb_glue (info
, name
, input_bfd
);
1017 globals
= elf32_arm_hash_table (info
);
1019 BFD_ASSERT (globals
!= NULL
);
1020 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
1022 my_offset
= myh
->root
.u
.def
.value
;
1024 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
1025 THUMB2ARM_GLUE_SECTION_NAME
);
1027 BFD_ASSERT (s
!= NULL
);
1028 BFD_ASSERT (s
->contents
!= NULL
);
1029 BFD_ASSERT (s
->output_section
!= NULL
);
1031 if ((my_offset
& 0x01) == 0x01)
1034 && sym_sec
->owner
!= NULL
1035 && !INTERWORK_FLAG (sym_sec
->owner
))
1037 (*_bfd_error_handler
)
1038 (_("%B(%s): warning: interworking not enabled.\n"
1039 " first occurrence: %B: thumb call to arm"),
1040 sym_sec
->owner
, input_bfd
, name
);
1046 myh
->root
.u
.def
.value
= my_offset
;
1048 bfd_put_16 (output_bfd
, (bfd_vma
) t2a1_bx_pc_insn
,
1049 s
->contents
+ my_offset
);
1051 bfd_put_16 (output_bfd
, (bfd_vma
) t2a2_noop_insn
,
1052 s
->contents
+ my_offset
+ 2);
1055 /* Address of destination of the stub. */
1056 ((bfd_signed_vma
) val
)
1058 /* Offset from the start of the current section
1059 to the start of the stubs. */
1061 /* Offset of the start of this stub from the start of the stubs. */
1063 /* Address of the start of the current section. */
1064 + s
->output_section
->vma
)
1065 /* The branch instruction is 4 bytes into the stub. */
1067 /* ARM branches work from the pc of the instruction + 8. */
1070 bfd_put_32 (output_bfd
,
1071 (bfd_vma
) t2a3_b_insn
| ((ret_offset
>> 2) & 0x00FFFFFF),
1072 s
->contents
+ my_offset
+ 4);
1075 BFD_ASSERT (my_offset
<= globals
->thumb_glue_size
);
1077 /* Now go back and fix up the original BL insn to point to here. */
1079 /* Address of where the stub is located. */
1080 (s
->output_section
->vma
+ s
->output_offset
+ my_offset
)
1081 /* Address of where the BL is located. */
1082 - (input_section
->output_section
->vma
+ input_section
->output_offset
1084 /* Addend in the relocation. */
1086 /* Biassing for PC-relative addressing. */
1089 tmp
= bfd_get_32 (input_bfd
, hit_data
1090 - input_section
->vma
);
1092 bfd_put_32 (output_bfd
,
1093 (bfd_vma
) insert_thumb_branch (tmp
, ret_offset
),
1094 hit_data
- input_section
->vma
);
1099 /* Arm code calling a Thumb function. */
1102 elf32_arm_to_thumb_stub (struct bfd_link_info
* info
,
1106 asection
* input_section
,
1107 bfd_byte
* hit_data
,
1110 bfd_signed_vma addend
,
1113 unsigned long int tmp
;
1116 long int ret_offset
;
1117 struct elf_link_hash_entry
* myh
;
1118 struct elf32_arm_link_hash_table
* globals
;
1120 myh
= find_arm_glue (info
, name
, input_bfd
);
1124 globals
= elf32_arm_hash_table (info
);
1126 BFD_ASSERT (globals
!= NULL
);
1127 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
1129 my_offset
= myh
->root
.u
.def
.value
;
1130 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
1131 ARM2THUMB_GLUE_SECTION_NAME
);
1132 BFD_ASSERT (s
!= NULL
);
1133 BFD_ASSERT (s
->contents
!= NULL
);
1134 BFD_ASSERT (s
->output_section
!= NULL
);
1136 if ((my_offset
& 0x01) == 0x01)
1139 && sym_sec
->owner
!= NULL
1140 && !INTERWORK_FLAG (sym_sec
->owner
))
1142 (*_bfd_error_handler
)
1143 (_("%B(%s): warning: interworking not enabled.\n"
1144 " first occurrence: %B: arm call to thumb"),
1145 sym_sec
->owner
, input_bfd
, name
);
1149 myh
->root
.u
.def
.value
= my_offset
;
1151 bfd_put_32 (output_bfd
, (bfd_vma
) a2t1_ldr_insn
,
1152 s
->contents
+ my_offset
);
1154 bfd_put_32 (output_bfd
, (bfd_vma
) a2t2_bx_r12_insn
,
1155 s
->contents
+ my_offset
+ 4);
1157 /* It's a thumb address. Add the low order bit. */
1158 bfd_put_32 (output_bfd
, val
| a2t3_func_addr_insn
,
1159 s
->contents
+ my_offset
+ 8);
1162 BFD_ASSERT (my_offset
<= globals
->arm_glue_size
);
1164 tmp
= bfd_get_32 (input_bfd
, hit_data
);
1165 tmp
= tmp
& 0xFF000000;
1167 /* Somehow these are both 4 too far, so subtract 8. */
1168 ret_offset
= (s
->output_offset
1170 + s
->output_section
->vma
1171 - (input_section
->output_offset
1172 + input_section
->output_section
->vma
1176 tmp
= tmp
| ((ret_offset
>> 2) & 0x00FFFFFF);
1178 bfd_put_32 (output_bfd
, (bfd_vma
) tmp
, hit_data
- input_section
->vma
);
1185 /* Some relocations map to different relocations depending on the
1186 target. Return the real relocation. */
1188 arm_real_reloc_type (struct elf32_arm_link_hash_table
* globals
,
1194 if (globals
->target1_is_rel
)
1200 return globals
->target2_reloc
;
1206 #endif /* OLD_ARM_ABI */
1209 /* Perform a relocation as part of a final link. */
1211 static bfd_reloc_status_type
1212 elf32_arm_final_link_relocate (reloc_howto_type
* howto
,
1215 asection
* input_section
,
1216 bfd_byte
* contents
,
1217 Elf_Internal_Rela
* rel
,
1219 struct bfd_link_info
* info
,
1221 const char * sym_name
,
1223 struct elf_link_hash_entry
* h
)
1225 unsigned long r_type
= howto
->type
;
1226 unsigned long r_symndx
;
1227 bfd_byte
* hit_data
= contents
+ rel
->r_offset
;
1228 bfd
* dynobj
= NULL
;
1229 Elf_Internal_Shdr
* symtab_hdr
;
1230 struct elf_link_hash_entry
** sym_hashes
;
1231 bfd_vma
* local_got_offsets
;
1232 asection
* sgot
= NULL
;
1233 asection
* splt
= NULL
;
1234 asection
* sreloc
= NULL
;
1236 bfd_signed_vma signed_addend
;
1237 struct elf32_arm_link_hash_table
* globals
;
1239 globals
= elf32_arm_hash_table (info
);
1242 /* Some relocation type map to different relocations depending on the
1243 target. We pick the right one here. */
1244 r_type
= arm_real_reloc_type (globals
, r_type
);
1245 if (r_type
!= howto
->type
)
1246 howto
= elf32_arm_howto_from_type (r_type
);
1247 #endif /* OLD_ARM_ABI */
1249 /* If the start address has been set, then set the EF_ARM_HASENTRY
1250 flag. Setting this more than once is redundant, but the cost is
1251 not too high, and it keeps the code simple.
1253 The test is done here, rather than somewhere else, because the
1254 start address is only set just before the final link commences.
1256 Note - if the user deliberately sets a start address of 0, the
1257 flag will not be set. */
1258 if (bfd_get_start_address (output_bfd
) != 0)
1259 elf_elfheader (output_bfd
)->e_flags
|= EF_ARM_HASENTRY
;
1261 dynobj
= elf_hash_table (info
)->dynobj
;
1264 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1265 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1267 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1268 sym_hashes
= elf_sym_hashes (input_bfd
);
1269 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1270 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1273 addend
= bfd_get_32 (input_bfd
, hit_data
) & howto
->src_mask
;
1275 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1278 signed_addend
&= ~ howto
->src_mask
;
1279 signed_addend
|= addend
;
1282 signed_addend
= addend
;
1284 addend
= signed_addend
= rel
->r_addend
;
1290 return bfd_reloc_ok
;
1300 /* r_symndx will be zero only for relocs against symbols
1301 from removed linkonce sections, or sections discarded by
1304 return bfd_reloc_ok
;
1306 /* Handle relocations which should use the PLT entry. ABS32/REL32
1307 will use the symbol's value, which may point to a PLT entry, but we
1308 don't need to handle that here. If we created a PLT entry, all
1309 branches in this object should go to it. */
1310 if ((r_type
!= R_ARM_ABS32
&& r_type
!= R_ARM_REL32
1312 && r_type
!= R_ARM_PREL31
1317 && h
->plt
.offset
!= (bfd_vma
) -1)
1319 /* If we've created a .plt section, and assigned a PLT entry to
1320 this function, it should not be known to bind locally. If
1321 it were, we would have cleared the PLT entry. */
1322 BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info
, h
));
1324 value
= (splt
->output_section
->vma
1325 + splt
->output_offset
1327 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1328 contents
, rel
->r_offset
, value
,
1332 /* When generating a shared object, these relocations are copied
1333 into the output file to be resolved at run time. */
1335 && (input_section
->flags
& SEC_ALLOC
)
1336 && ((r_type
!= R_ARM_REL32
1338 && r_type
!= R_ARM_PREL31
1340 ) || !SYMBOL_CALLS_LOCAL (info
, h
))
1342 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
1343 || h
->root
.type
!= bfd_link_hash_undefweak
)
1344 && r_type
!= R_ARM_PC24
1345 && r_type
!= R_ARM_PLT32
)
1347 Elf_Internal_Rela outrel
;
1349 bfd_boolean skip
, relocate
;
1355 name
= (bfd_elf_string_from_elf_section
1357 elf_elfheader (input_bfd
)->e_shstrndx
,
1358 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1360 return bfd_reloc_notsupported
;
1362 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
1363 && strcmp (bfd_get_section_name (input_bfd
,
1367 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1368 BFD_ASSERT (sreloc
!= NULL
);
1375 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
1377 if (outrel
.r_offset
== (bfd_vma
) -1)
1379 else if (outrel
.r_offset
== (bfd_vma
) -2)
1380 skip
= TRUE
, relocate
= TRUE
;
1381 outrel
.r_offset
+= (input_section
->output_section
->vma
1382 + input_section
->output_offset
);
1385 memset (&outrel
, 0, sizeof outrel
);
1390 || !h
->def_regular
))
1391 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1394 /* This symbol is local, or marked to become local. */
1396 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1399 loc
= sreloc
->contents
;
1400 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
1401 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
1403 /* If this reloc is against an external symbol, we do not want to
1404 fiddle with the addend. Otherwise, we need to include the symbol
1405 value so that it becomes an addend for the dynamic reloc. */
1407 return bfd_reloc_ok
;
1409 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1410 contents
, rel
->r_offset
, value
,
1413 else switch (r_type
)
1416 case R_ARM_XPC25
: /* Arm BLX instruction. */
1418 case R_ARM_PC24
: /* Arm B/BL instruction */
1421 if (r_type
== R_ARM_XPC25
)
1423 /* Check for Arm calling Arm function. */
1424 /* FIXME: Should we translate the instruction into a BL
1425 instruction instead ? */
1426 if (sym_flags
!= STT_ARM_TFUNC
)
1427 (*_bfd_error_handler
)
1428 (_("\%B: Warning: Arm BLX instruction targets Arm function '%s'."),
1430 h
? h
->root
.root
.string
: "(local)");
1435 /* Check for Arm calling Thumb function. */
1436 if (sym_flags
== STT_ARM_TFUNC
)
1438 elf32_arm_to_thumb_stub (info
, sym_name
, input_bfd
,
1439 output_bfd
, input_section
,
1440 hit_data
, sym_sec
, rel
->r_offset
,
1441 signed_addend
, value
);
1442 return bfd_reloc_ok
;
1446 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1447 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0)
1449 /* The old way of doing things. Trearing the addend as a
1450 byte sized field and adding in the pipeline offset. */
1451 value
-= (input_section
->output_section
->vma
1452 + input_section
->output_offset
);
1453 value
-= rel
->r_offset
;
1456 if (! globals
->no_pipeline_knowledge
)
1461 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
1463 S is the address of the symbol in the relocation.
1464 P is address of the instruction being relocated.
1465 A is the addend (extracted from the instruction) in bytes.
1467 S is held in 'value'.
1468 P is the base address of the section containing the
1469 instruction plus the offset of the reloc into that
1471 (input_section->output_section->vma +
1472 input_section->output_offset +
1474 A is the addend, converted into bytes, ie:
1477 Note: None of these operations have knowledge of the pipeline
1478 size of the processor, thus it is up to the assembler to
1479 encode this information into the addend. */
1480 value
-= (input_section
->output_section
->vma
1481 + input_section
->output_offset
);
1482 value
-= rel
->r_offset
;
1483 value
+= (signed_addend
<< howto
->size
);
1485 /* Previous versions of this code also used to add in the
1486 pipeline offset here. This is wrong because the linker is
1487 not supposed to know about such things, and one day it might
1488 change. In order to support old binaries that need the old
1489 behaviour however, so we attempt to detect which ABI was
1490 used to create the reloc. */
1491 if (! globals
->no_pipeline_knowledge
)
1493 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form */
1495 i_ehdrp
= elf_elfheader (input_bfd
);
1497 if (i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1502 signed_addend
= value
;
1503 signed_addend
>>= howto
->rightshift
;
1505 /* It is not an error for an undefined weak reference to be
1506 out of range. Any program that branches to such a symbol
1507 is going to crash anyway, so there is no point worrying
1508 about getting the destination exactly right. */
1509 if (! h
|| h
->root
.type
!= bfd_link_hash_undefweak
)
1511 /* Perform a signed range check. */
1512 if ( signed_addend
> ((bfd_signed_vma
) (howto
->dst_mask
>> 1))
1513 || signed_addend
< - ((bfd_signed_vma
) ((howto
->dst_mask
+ 1) >> 1)))
1514 return bfd_reloc_overflow
;
1518 /* If necessary set the H bit in the BLX instruction. */
1519 if (r_type
== R_ARM_XPC25
&& ((value
& 2) == 2))
1520 value
= (signed_addend
& howto
->dst_mask
)
1521 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
))
1525 value
= (signed_addend
& howto
->dst_mask
)
1526 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1531 if (sym_flags
== STT_ARM_TFUNC
)
1536 value
-= (input_section
->output_section
->vma
1537 + input_section
->output_offset
+ rel
->r_offset
);
1543 value
-= (input_section
->output_section
->vma
1544 + input_section
->output_offset
+ rel
->r_offset
);
1545 value
+= signed_addend
;
1546 if (! h
|| h
->root
.type
!= bfd_link_hash_undefweak
)
1548 /* Check for overflow */
1549 if ((value
^ (value
>> 1)) & (1 << 30))
1550 return bfd_reloc_overflow
;
1552 value
&= 0x7fffffff;
1553 value
|= (bfd_get_32 (input_bfd
, hit_data
) & 0x80000000);
1554 if (sym_flags
== STT_ARM_TFUNC
)
1560 bfd_put_32 (input_bfd
, value
, hit_data
);
1561 return bfd_reloc_ok
;
1565 if ((long) value
> 0x7f || (long) value
< -0x80)
1566 return bfd_reloc_overflow
;
1568 bfd_put_8 (input_bfd
, value
, hit_data
);
1569 return bfd_reloc_ok
;
1574 if ((long) value
> 0x7fff || (long) value
< -0x8000)
1575 return bfd_reloc_overflow
;
1577 bfd_put_16 (input_bfd
, value
, hit_data
);
1578 return bfd_reloc_ok
;
1581 /* Support ldr and str instruction for the arm */
1582 /* Also thumb b (unconditional branch). ??? Really? */
1585 if ((long) value
> 0x7ff || (long) value
< -0x800)
1586 return bfd_reloc_overflow
;
1588 value
|= (bfd_get_32 (input_bfd
, hit_data
) & 0xfffff000);
1589 bfd_put_32 (input_bfd
, value
, hit_data
);
1590 return bfd_reloc_ok
;
1592 case R_ARM_THM_ABS5
:
1593 /* Support ldr and str instructions for the thumb. */
1595 /* Need to refetch addend. */
1596 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1597 /* ??? Need to determine shift amount from operand size. */
1598 addend
>>= howto
->rightshift
;
1602 /* ??? Isn't value unsigned? */
1603 if ((long) value
> 0x1f || (long) value
< -0x10)
1604 return bfd_reloc_overflow
;
1606 /* ??? Value needs to be properly shifted into place first. */
1607 value
|= bfd_get_16 (input_bfd
, hit_data
) & 0xf83f;
1608 bfd_put_16 (input_bfd
, value
, hit_data
);
1609 return bfd_reloc_ok
;
1612 case R_ARM_THM_XPC22
:
1614 case R_ARM_THM_PC22
:
1615 /* Thumb BL (branch long instruction). */
1618 bfd_boolean overflow
= FALSE
;
1619 bfd_vma upper_insn
= bfd_get_16 (input_bfd
, hit_data
);
1620 bfd_vma lower_insn
= bfd_get_16 (input_bfd
, hit_data
+ 2);
1621 bfd_signed_vma reloc_signed_max
= ((1 << (howto
->bitsize
- 1)) - 1) >> howto
->rightshift
;
1622 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1624 bfd_signed_vma signed_check
;
1627 /* Need to refetch the addend and squish the two 11 bit pieces
1630 bfd_vma upper
= upper_insn
& 0x7ff;
1631 bfd_vma lower
= lower_insn
& 0x7ff;
1632 upper
= (upper
^ 0x400) - 0x400; /* Sign extend. */
1633 addend
= (upper
<< 12) | (lower
<< 1);
1634 signed_addend
= addend
;
1638 if (r_type
== R_ARM_THM_XPC22
)
1640 /* Check for Thumb to Thumb call. */
1641 /* FIXME: Should we translate the instruction into a BL
1642 instruction instead ? */
1643 if (sym_flags
== STT_ARM_TFUNC
)
1644 (*_bfd_error_handler
)
1645 (_("%B: Warning: Thumb BLX instruction targets thumb function '%s'."),
1647 h
? h
->root
.root
.string
: "(local)");
1652 /* If it is not a call to Thumb, assume call to Arm.
1653 If it is a call relative to a section name, then it is not a
1654 function call at all, but rather a long jump. */
1655 if (sym_flags
!= STT_ARM_TFUNC
&& sym_flags
!= STT_SECTION
)
1657 if (elf32_thumb_to_arm_stub
1658 (info
, sym_name
, input_bfd
, output_bfd
, input_section
,
1659 hit_data
, sym_sec
, rel
->r_offset
, signed_addend
, value
))
1660 return bfd_reloc_ok
;
1662 return bfd_reloc_dangerous
;
1666 relocation
= value
+ signed_addend
;
1668 relocation
-= (input_section
->output_section
->vma
1669 + input_section
->output_offset
1672 if (! globals
->no_pipeline_knowledge
)
1674 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form. */
1676 i_ehdrp
= elf_elfheader (input_bfd
);
1678 /* Previous versions of this code also used to add in the pipline
1679 offset here. This is wrong because the linker is not supposed
1680 to know about such things, and one day it might change. In order
1681 to support old binaries that need the old behaviour however, so
1682 we attempt to detect which ABI was used to create the reloc. */
1683 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1684 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0
1685 || i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1689 check
= relocation
>> howto
->rightshift
;
1691 /* If this is a signed value, the rightshift just dropped
1692 leading 1 bits (assuming twos complement). */
1693 if ((bfd_signed_vma
) relocation
>= 0)
1694 signed_check
= check
;
1696 signed_check
= check
| ~((bfd_vma
) -1 >> howto
->rightshift
);
1698 /* Assumes two's complement. */
1699 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1703 if (r_type
== R_ARM_THM_XPC22
1704 && ((lower_insn
& 0x1800) == 0x0800))
1705 /* For a BLX instruction, make sure that the relocation is rounded up
1706 to a word boundary. This follows the semantics of the instruction
1707 which specifies that bit 1 of the target address will come from bit
1708 1 of the base address. */
1709 relocation
= (relocation
+ 2) & ~ 3;
1711 /* Put RELOCATION back into the insn. */
1712 upper_insn
= (upper_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 12) & 0x7ff);
1713 lower_insn
= (lower_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 1) & 0x7ff);
1715 /* Put the relocated value back in the object file: */
1716 bfd_put_16 (input_bfd
, upper_insn
, hit_data
);
1717 bfd_put_16 (input_bfd
, lower_insn
, hit_data
+ 2);
1719 return (overflow
? bfd_reloc_overflow
: bfd_reloc_ok
);
1723 case R_ARM_THM_PC11
:
1724 /* Thumb B (branch) instruction). */
1726 bfd_signed_vma relocation
;
1727 bfd_signed_vma reloc_signed_max
= (1 << (howto
->bitsize
- 1)) - 1;
1728 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1729 bfd_signed_vma signed_check
;
1732 /* Need to refetch addend. */
1733 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1734 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1737 signed_addend
&= ~ howto
->src_mask
;
1738 signed_addend
|= addend
;
1741 signed_addend
= addend
;
1742 /* The value in the insn has been right shifted. We need to
1743 undo this, so that we can perform the address calculation
1744 in terms of bytes. */
1745 signed_addend
<<= howto
->rightshift
;
1747 relocation
= value
+ signed_addend
;
1749 relocation
-= (input_section
->output_section
->vma
1750 + input_section
->output_offset
1753 relocation
>>= howto
->rightshift
;
1754 signed_check
= relocation
;
1755 relocation
&= howto
->dst_mask
;
1756 relocation
|= (bfd_get_16 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1758 bfd_put_16 (input_bfd
, relocation
, hit_data
);
1760 /* Assumes two's complement. */
1761 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1762 return bfd_reloc_overflow
;
1764 return bfd_reloc_ok
;
1768 case R_ARM_ALU_PCREL7_0
:
1769 case R_ARM_ALU_PCREL15_8
:
1770 case R_ARM_ALU_PCREL23_15
:
1775 insn
= bfd_get_32 (input_bfd
, hit_data
);
1777 /* Extract the addend. */
1778 addend
= (insn
& 0xff) << ((insn
& 0xf00) >> 7);
1779 signed_addend
= addend
;
1781 relocation
= value
+ signed_addend
;
1783 relocation
-= (input_section
->output_section
->vma
1784 + input_section
->output_offset
1786 insn
= (insn
& ~0xfff)
1787 | ((howto
->bitpos
<< 7) & 0xf00)
1788 | ((relocation
>> howto
->bitpos
) & 0xff);
1789 bfd_put_32 (input_bfd
, value
, hit_data
);
1791 return bfd_reloc_ok
;
1794 case R_ARM_GNU_VTINHERIT
:
1795 case R_ARM_GNU_VTENTRY
:
1796 return bfd_reloc_ok
;
1799 return bfd_reloc_notsupported
;
1801 case R_ARM_GLOB_DAT
:
1802 return bfd_reloc_notsupported
;
1804 case R_ARM_JUMP_SLOT
:
1805 return bfd_reloc_notsupported
;
1807 case R_ARM_RELATIVE
:
1808 return bfd_reloc_notsupported
;
1811 /* Relocation is relative to the start of the
1812 global offset table. */
1814 BFD_ASSERT (sgot
!= NULL
);
1816 return bfd_reloc_notsupported
;
1818 /* If we are addressing a Thumb function, we need to adjust the
1819 address by one, so that attempts to call the function pointer will
1820 correctly interpret it as Thumb code. */
1821 if (sym_flags
== STT_ARM_TFUNC
)
1824 /* Note that sgot->output_offset is not involved in this
1825 calculation. We always want the start of .got. If we
1826 define _GLOBAL_OFFSET_TABLE in a different way, as is
1827 permitted by the ABI, we might have to change this
1829 value
-= sgot
->output_section
->vma
;
1830 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1831 contents
, rel
->r_offset
, value
,
1835 /* Use global offset table as symbol value. */
1836 BFD_ASSERT (sgot
!= NULL
);
1839 return bfd_reloc_notsupported
;
1841 value
= sgot
->output_section
->vma
;
1842 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1843 contents
, rel
->r_offset
, value
,
1848 case R_ARM_GOT_PREL
:
1850 /* Relocation is to the entry for this symbol in the
1851 global offset table. */
1853 return bfd_reloc_notsupported
;
1860 off
= h
->got
.offset
;
1861 BFD_ASSERT (off
!= (bfd_vma
) -1);
1862 dyn
= globals
->root
.dynamic_sections_created
;
1864 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
1866 && SYMBOL_REFERENCES_LOCAL (info
, h
))
1867 || (ELF_ST_VISIBILITY (h
->other
)
1868 && h
->root
.type
== bfd_link_hash_undefweak
))
1870 /* This is actually a static link, or it is a -Bsymbolic link
1871 and the symbol is defined locally. We must initialize this
1872 entry in the global offset table. Since the offset must
1873 always be a multiple of 4, we use the least significant bit
1874 to record whether we have initialized it already.
1876 When doing a dynamic link, we create a .rel.got relocation
1877 entry to initialize the value. This is done in the
1878 finish_dynamic_symbol routine. */
1883 /* If we are addressing a Thumb function, we need to
1884 adjust the address by one, so that attempts to
1885 call the function pointer will correctly
1886 interpret it as Thumb code. */
1887 if (sym_flags
== STT_ARM_TFUNC
)
1890 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1895 value
= sgot
->output_offset
+ off
;
1901 BFD_ASSERT (local_got_offsets
!= NULL
&&
1902 local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1904 off
= local_got_offsets
[r_symndx
];
1906 /* The offset must always be a multiple of 4. We use the
1907 least significant bit to record whether we have already
1908 generated the necessary reloc. */
1913 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1918 Elf_Internal_Rela outrel
;
1921 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
1922 BFD_ASSERT (srelgot
!= NULL
);
1924 outrel
.r_offset
= (sgot
->output_section
->vma
1925 + sgot
->output_offset
1927 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1928 loc
= srelgot
->contents
;
1929 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rel
);
1930 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
1933 local_got_offsets
[r_symndx
] |= 1;
1936 value
= sgot
->output_offset
+ off
;
1938 if (r_type
!= R_ARM_GOT32
)
1939 value
+= sgot
->output_section
->vma
;
1941 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1942 contents
, rel
->r_offset
, value
,
1946 return bfd_reloc_notsupported
;
1948 case R_ARM_AMP_VCALL9
:
1949 return bfd_reloc_notsupported
;
1951 case R_ARM_RSBREL32
:
1952 return bfd_reloc_notsupported
;
1954 case R_ARM_THM_RPC22
:
1955 return bfd_reloc_notsupported
;
1958 return bfd_reloc_notsupported
;
1961 return bfd_reloc_notsupported
;
1964 return bfd_reloc_notsupported
;
1967 return bfd_reloc_notsupported
;
1970 return bfd_reloc_notsupported
;
1975 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
1977 arm_add_to_rel (bfd
* abfd
,
1979 reloc_howto_type
* howto
,
1980 bfd_signed_vma increment
)
1982 bfd_signed_vma addend
;
1984 if (howto
->type
== R_ARM_THM_PC22
)
1986 int upper_insn
, lower_insn
;
1989 upper_insn
= bfd_get_16 (abfd
, address
);
1990 lower_insn
= bfd_get_16 (abfd
, address
+ 2);
1991 upper
= upper_insn
& 0x7ff;
1992 lower
= lower_insn
& 0x7ff;
1994 addend
= (upper
<< 12) | (lower
<< 1);
1995 addend
+= increment
;
1998 upper_insn
= (upper_insn
& 0xf800) | ((addend
>> 11) & 0x7ff);
1999 lower_insn
= (lower_insn
& 0xf800) | (addend
& 0x7ff);
2001 bfd_put_16 (abfd
, (bfd_vma
) upper_insn
, address
);
2002 bfd_put_16 (abfd
, (bfd_vma
) lower_insn
, address
+ 2);
2008 contents
= bfd_get_32 (abfd
, address
);
2010 /* Get the (signed) value from the instruction. */
2011 addend
= contents
& howto
->src_mask
;
2012 if (addend
& ((howto
->src_mask
+ 1) >> 1))
2014 bfd_signed_vma mask
;
2017 mask
&= ~ howto
->src_mask
;
2021 /* Add in the increment, (which is a byte value). */
2022 switch (howto
->type
)
2025 addend
+= increment
;
2029 addend
<<= howto
->size
;
2030 addend
+= increment
;
2032 /* Should we check for overflow here ? */
2034 /* Drop any undesired bits. */
2035 addend
>>= howto
->rightshift
;
2039 contents
= (contents
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
2041 bfd_put_32 (abfd
, contents
, address
);
2044 #endif /* USE_REL */
2046 /* Relocate an ARM ELF section. */
2048 elf32_arm_relocate_section (bfd
* output_bfd
,
2049 struct bfd_link_info
* info
,
2051 asection
* input_section
,
2052 bfd_byte
* contents
,
2053 Elf_Internal_Rela
* relocs
,
2054 Elf_Internal_Sym
* local_syms
,
2055 asection
** local_sections
)
2057 Elf_Internal_Shdr
*symtab_hdr
;
2058 struct elf_link_hash_entry
**sym_hashes
;
2059 Elf_Internal_Rela
*rel
;
2060 Elf_Internal_Rela
*relend
;
2064 if (info
->relocatable
)
2068 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
2069 sym_hashes
= elf_sym_hashes (input_bfd
);
2072 relend
= relocs
+ input_section
->reloc_count
;
2073 for (; rel
< relend
; rel
++)
2076 reloc_howto_type
* howto
;
2077 unsigned long r_symndx
;
2078 Elf_Internal_Sym
* sym
;
2080 struct elf_link_hash_entry
* h
;
2082 bfd_reloc_status_type r
;
2085 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2086 r_type
= ELF32_R_TYPE (rel
->r_info
);
2088 if ( r_type
== R_ARM_GNU_VTENTRY
2089 || r_type
== R_ARM_GNU_VTINHERIT
)
2092 elf32_arm_info_to_howto (input_bfd
, & bfd_reloc
, rel
);
2093 howto
= bfd_reloc
.howto
;
2096 if (info
->relocatable
)
2098 /* This is a relocatable link. We don't have to change
2099 anything, unless the reloc is against a section symbol,
2100 in which case we have to adjust according to where the
2101 section symbol winds up in the output section. */
2102 if (r_symndx
< symtab_hdr
->sh_info
)
2104 sym
= local_syms
+ r_symndx
;
2105 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2107 sec
= local_sections
[r_symndx
];
2108 arm_add_to_rel (input_bfd
, contents
+ rel
->r_offset
,
2110 (bfd_signed_vma
) (sec
->output_offset
2119 /* This is a final link. */
2124 if (r_symndx
< symtab_hdr
->sh_info
)
2126 sym
= local_syms
+ r_symndx
;
2127 sec
= local_sections
[r_symndx
];
2129 relocation
= (sec
->output_section
->vma
2130 + sec
->output_offset
2132 if ((sec
->flags
& SEC_MERGE
)
2133 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2136 bfd_vma addend
, value
;
2138 if (howto
->rightshift
)
2140 (*_bfd_error_handler
)
2141 (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
2142 input_bfd
, input_section
,
2143 (long) rel
->r_offset
, howto
->name
);
2147 value
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2149 /* Get the (signed) value from the instruction. */
2150 addend
= value
& howto
->src_mask
;
2151 if (addend
& ((howto
->src_mask
+ 1) >> 1))
2153 bfd_signed_vma mask
;
2156 mask
&= ~ howto
->src_mask
;
2161 _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
)
2163 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2164 value
= (value
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
2165 bfd_put_32 (input_bfd
, value
, contents
+ rel
->r_offset
);
2168 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2174 bfd_boolean unresolved_reloc
;
2176 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2177 r_symndx
, symtab_hdr
, sym_hashes
,
2179 unresolved_reloc
, warned
);
2181 if (unresolved_reloc
|| relocation
!= 0)
2183 /* In these cases, we don't need the relocation value.
2184 We check specially because in some obscure cases
2185 sec->output_section will be NULL. */
2190 case R_ARM_THM_PC22
:
2194 && ((!info
->symbolic
&& h
->dynindx
!= -1)
2196 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2197 && ((input_section
->flags
& SEC_ALLOC
) != 0
2198 /* DWARF will emit R_ARM_ABS32 relocations in its
2199 sections against symbols defined externally
2200 in shared libraries. We can't do anything
2202 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
2214 case R_ARM_GOT_PREL
:
2216 if ((WILL_CALL_FINISH_DYNAMIC_SYMBOL
2217 (elf_hash_table (info
)->dynamic_sections_created
,
2220 || (!info
->symbolic
&& h
->dynindx
!= -1)
2221 || !h
->def_regular
))
2226 if (unresolved_reloc
)
2228 (_("%B(%A): warning: unresolvable relocation %d against symbol `%s'"),
2229 input_bfd
, input_section
,
2231 h
->root
.root
.string
);
2238 name
= h
->root
.root
.string
;
2241 name
= (bfd_elf_string_from_elf_section
2242 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2243 if (name
== NULL
|| *name
== '\0')
2244 name
= bfd_section_name (input_bfd
, sec
);
2247 r
= elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
2248 input_section
, contents
, rel
,
2249 relocation
, info
, sec
, name
,
2250 (h
? ELF_ST_TYPE (h
->type
) :
2251 ELF_ST_TYPE (sym
->st_info
)), h
);
2253 if (r
!= bfd_reloc_ok
)
2255 const char * msg
= (const char *) 0;
2259 case bfd_reloc_overflow
:
2260 /* If the overflowing reloc was to an undefined symbol,
2261 we have already printed one error message and there
2262 is no point complaining again. */
2264 h
->root
.type
!= bfd_link_hash_undefined
)
2265 && (!((*info
->callbacks
->reloc_overflow
)
2266 (info
, name
, howto
->name
, (bfd_vma
) 0,
2267 input_bfd
, input_section
, rel
->r_offset
))))
2271 case bfd_reloc_undefined
:
2272 if (!((*info
->callbacks
->undefined_symbol
)
2273 (info
, name
, input_bfd
, input_section
,
2274 rel
->r_offset
, TRUE
)))
2278 case bfd_reloc_outofrange
:
2279 msg
= _("internal error: out of range error");
2282 case bfd_reloc_notsupported
:
2283 msg
= _("internal error: unsupported relocation error");
2286 case bfd_reloc_dangerous
:
2287 msg
= _("internal error: dangerous error");
2291 msg
= _("internal error: unknown error");
2295 if (!((*info
->callbacks
->warning
)
2296 (info
, msg
, name
, input_bfd
, input_section
,
2307 /* Set the right machine number. */
2310 elf32_arm_object_p (bfd
*abfd
)
2314 mach
= bfd_arm_get_mach_from_notes (abfd
, ARM_NOTE_SECTION
);
2316 if (mach
!= bfd_mach_arm_unknown
)
2317 bfd_default_set_arch_mach (abfd
, bfd_arch_arm
, mach
);
2319 else if (elf_elfheader (abfd
)->e_flags
& EF_ARM_MAVERICK_FLOAT
)
2320 bfd_default_set_arch_mach (abfd
, bfd_arch_arm
, bfd_mach_arm_ep9312
);
2323 bfd_default_set_arch_mach (abfd
, bfd_arch_arm
, mach
);
2328 /* Function to keep ARM specific flags in the ELF header. */
2330 elf32_arm_set_private_flags (bfd
*abfd
, flagword flags
)
2332 if (elf_flags_init (abfd
)
2333 && elf_elfheader (abfd
)->e_flags
!= flags
)
2335 if (EF_ARM_EABI_VERSION (flags
) == EF_ARM_EABI_UNKNOWN
)
2337 if (flags
& EF_ARM_INTERWORK
)
2338 (*_bfd_error_handler
)
2339 (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
2343 (_("Warning: Clearing the interworking flag of %B due to outside request"),
2349 elf_elfheader (abfd
)->e_flags
= flags
;
2350 elf_flags_init (abfd
) = TRUE
;
2356 /* Copy backend specific data from one object module to another. */
2359 elf32_arm_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
2364 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2365 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2368 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2369 out_flags
= elf_elfheader (obfd
)->e_flags
;
2371 if (elf_flags_init (obfd
)
2372 && EF_ARM_EABI_VERSION (out_flags
) == EF_ARM_EABI_UNKNOWN
2373 && in_flags
!= out_flags
)
2375 /* Cannot mix APCS26 and APCS32 code. */
2376 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2379 /* Cannot mix float APCS and non-float APCS code. */
2380 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2383 /* If the src and dest have different interworking flags
2384 then turn off the interworking bit. */
2385 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2387 if (out_flags
& EF_ARM_INTERWORK
)
2389 (_("Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
2392 in_flags
&= ~EF_ARM_INTERWORK
;
2395 /* Likewise for PIC, though don't warn for this case. */
2396 if ((in_flags
& EF_ARM_PIC
) != (out_flags
& EF_ARM_PIC
))
2397 in_flags
&= ~EF_ARM_PIC
;
2400 elf_elfheader (obfd
)->e_flags
= in_flags
;
2401 elf_flags_init (obfd
) = TRUE
;
2406 /* Merge backend specific data from an object file to the output
2407 object file when linking. */
2410 elf32_arm_merge_private_bfd_data (bfd
* ibfd
, bfd
* obfd
)
2414 bfd_boolean flags_compatible
= TRUE
;
2417 /* Check if we have the same endianess. */
2418 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
2421 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2422 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2425 /* The input BFD must have had its flags initialised. */
2426 /* The following seems bogus to me -- The flags are initialized in
2427 the assembler but I don't think an elf_flags_init field is
2428 written into the object. */
2429 /* BFD_ASSERT (elf_flags_init (ibfd)); */
2431 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2432 out_flags
= elf_elfheader (obfd
)->e_flags
;
2434 if (!elf_flags_init (obfd
))
2436 /* If the input is the default architecture and had the default
2437 flags then do not bother setting the flags for the output
2438 architecture, instead allow future merges to do this. If no
2439 future merges ever set these flags then they will retain their
2440 uninitialised values, which surprise surprise, correspond
2441 to the default values. */
2442 if (bfd_get_arch_info (ibfd
)->the_default
2443 && elf_elfheader (ibfd
)->e_flags
== 0)
2446 elf_flags_init (obfd
) = TRUE
;
2447 elf_elfheader (obfd
)->e_flags
= in_flags
;
2449 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
2450 && bfd_get_arch_info (obfd
)->the_default
)
2451 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
), bfd_get_mach (ibfd
));
2456 /* Determine what should happen if the input ARM architecture
2457 does not match the output ARM architecture. */
2458 if (! bfd_arm_merge_machines (ibfd
, obfd
))
2461 /* Identical flags must be compatible. */
2462 if (in_flags
== out_flags
)
2465 /* Check to see if the input BFD actually contains any sections. If
2466 not, its flags may not have been initialised either, but it
2467 cannot actually cause any incompatibility. Do not short-circuit
2468 dynamic objects; their section list may be emptied by
2469 elf_link_add_object_symbols.
2471 Also check to see if there are no code sections in the input.
2472 In this case there is no need to check for code specific flags.
2473 XXX - do we need to worry about floating-point format compatability
2474 in data sections ? */
2475 if (!(ibfd
->flags
& DYNAMIC
))
2477 bfd_boolean null_input_bfd
= TRUE
;
2478 bfd_boolean only_data_sections
= TRUE
;
2480 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2482 /* Ignore synthetic glue sections. */
2483 if (strcmp (sec
->name
, ".glue_7")
2484 && strcmp (sec
->name
, ".glue_7t"))
2486 if ((bfd_get_section_flags (ibfd
, sec
)
2487 & (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
2488 == (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
2489 only_data_sections
= FALSE
;
2491 null_input_bfd
= FALSE
;
2496 if (null_input_bfd
|| only_data_sections
)
2500 /* Complain about various flag mismatches. */
2501 if (EF_ARM_EABI_VERSION (in_flags
) != EF_ARM_EABI_VERSION (out_flags
))
2504 (_("ERROR: %B is compiled for EABI version %d, whereas %B is compiled for version %d"),
2506 (in_flags
& EF_ARM_EABIMASK
) >> 24,
2507 (out_flags
& EF_ARM_EABIMASK
) >> 24);
2511 /* Not sure what needs to be checked for EABI versions >= 1. */
2512 if (EF_ARM_EABI_VERSION (in_flags
) == EF_ARM_EABI_UNKNOWN
)
2514 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2517 (_("ERROR: %B is compiled for APCS-%d, whereas target %B uses APCS-%d"),
2519 in_flags
& EF_ARM_APCS_26
? 26 : 32,
2520 out_flags
& EF_ARM_APCS_26
? 26 : 32);
2521 flags_compatible
= FALSE
;
2524 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2526 if (in_flags
& EF_ARM_APCS_FLOAT
)
2528 (_("ERROR: %B passes floats in float registers, whereas %B passes them in integer registers"),
2532 (_("ERROR: %B passes floats in integer registers, whereas %B passes them in float registers"),
2535 flags_compatible
= FALSE
;
2538 if ((in_flags
& EF_ARM_VFP_FLOAT
) != (out_flags
& EF_ARM_VFP_FLOAT
))
2540 if (in_flags
& EF_ARM_VFP_FLOAT
)
2542 (_("ERROR: %B uses VFP instructions, whereas %B does not"),
2546 (_("ERROR: %B uses FPA instructions, whereas %B does not"),
2549 flags_compatible
= FALSE
;
2552 if ((in_flags
& EF_ARM_MAVERICK_FLOAT
) != (out_flags
& EF_ARM_MAVERICK_FLOAT
))
2554 if (in_flags
& EF_ARM_MAVERICK_FLOAT
)
2556 (_("ERROR: %B uses Maverick instructions, whereas %B does not"),
2560 (_("ERROR: %B does not use Maverick instructions, whereas %B does"),
2563 flags_compatible
= FALSE
;
2566 #ifdef EF_ARM_SOFT_FLOAT
2567 if ((in_flags
& EF_ARM_SOFT_FLOAT
) != (out_flags
& EF_ARM_SOFT_FLOAT
))
2569 /* We can allow interworking between code that is VFP format
2570 layout, and uses either soft float or integer regs for
2571 passing floating point arguments and results. We already
2572 know that the APCS_FLOAT flags match; similarly for VFP
2574 if ((in_flags
& EF_ARM_APCS_FLOAT
) != 0
2575 || (in_flags
& EF_ARM_VFP_FLOAT
) == 0)
2577 if (in_flags
& EF_ARM_SOFT_FLOAT
)
2579 (_("ERROR: %B uses software FP, whereas %B uses hardware FP"),
2583 (_("ERROR: %B uses hardware FP, whereas %B uses software FP"),
2586 flags_compatible
= FALSE
;
2591 /* Interworking mismatch is only a warning. */
2592 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2594 if (in_flags
& EF_ARM_INTERWORK
)
2597 (_("Warning: %B supports interworking, whereas %B does not"),
2603 (_("Warning: %B does not support interworking, whereas %B does"),
2609 return flags_compatible
;
2612 /* Display the flags field. */
2615 elf32_arm_print_private_bfd_data (bfd
*abfd
, void * ptr
)
2617 FILE * file
= (FILE *) ptr
;
2618 unsigned long flags
;
2620 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
2622 /* Print normal ELF private data. */
2623 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
2625 flags
= elf_elfheader (abfd
)->e_flags
;
2626 /* Ignore init flag - it may not be set, despite the flags field
2627 containing valid data. */
2629 /* xgettext:c-format */
2630 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
2632 switch (EF_ARM_EABI_VERSION (flags
))
2634 case EF_ARM_EABI_UNKNOWN
:
2635 /* The following flag bits are GNU extensions and not part of the
2636 official ARM ELF extended ABI. Hence they are only decoded if
2637 the EABI version is not set. */
2638 if (flags
& EF_ARM_INTERWORK
)
2639 fprintf (file
, _(" [interworking enabled]"));
2641 if (flags
& EF_ARM_APCS_26
)
2642 fprintf (file
, " [APCS-26]");
2644 fprintf (file
, " [APCS-32]");
2646 if (flags
& EF_ARM_VFP_FLOAT
)
2647 fprintf (file
, _(" [VFP float format]"));
2648 else if (flags
& EF_ARM_MAVERICK_FLOAT
)
2649 fprintf (file
, _(" [Maverick float format]"));
2651 fprintf (file
, _(" [FPA float format]"));
2653 if (flags
& EF_ARM_APCS_FLOAT
)
2654 fprintf (file
, _(" [floats passed in float registers]"));
2656 if (flags
& EF_ARM_PIC
)
2657 fprintf (file
, _(" [position independent]"));
2659 if (flags
& EF_ARM_NEW_ABI
)
2660 fprintf (file
, _(" [new ABI]"));
2662 if (flags
& EF_ARM_OLD_ABI
)
2663 fprintf (file
, _(" [old ABI]"));
2665 if (flags
& EF_ARM_SOFT_FLOAT
)
2666 fprintf (file
, _(" [software FP]"));
2668 flags
&= ~(EF_ARM_INTERWORK
| EF_ARM_APCS_26
| EF_ARM_APCS_FLOAT
2669 | EF_ARM_PIC
| EF_ARM_NEW_ABI
| EF_ARM_OLD_ABI
2670 | EF_ARM_SOFT_FLOAT
| EF_ARM_VFP_FLOAT
2671 | EF_ARM_MAVERICK_FLOAT
);
2674 case EF_ARM_EABI_VER1
:
2675 fprintf (file
, _(" [Version1 EABI]"));
2677 if (flags
& EF_ARM_SYMSARESORTED
)
2678 fprintf (file
, _(" [sorted symbol table]"));
2680 fprintf (file
, _(" [unsorted symbol table]"));
2682 flags
&= ~ EF_ARM_SYMSARESORTED
;
2685 case EF_ARM_EABI_VER2
:
2686 fprintf (file
, _(" [Version2 EABI]"));
2688 if (flags
& EF_ARM_SYMSARESORTED
)
2689 fprintf (file
, _(" [sorted symbol table]"));
2691 fprintf (file
, _(" [unsorted symbol table]"));
2693 if (flags
& EF_ARM_DYNSYMSUSESEGIDX
)
2694 fprintf (file
, _(" [dynamic symbols use segment index]"));
2696 if (flags
& EF_ARM_MAPSYMSFIRST
)
2697 fprintf (file
, _(" [mapping symbols precede others]"));
2699 flags
&= ~(EF_ARM_SYMSARESORTED
| EF_ARM_DYNSYMSUSESEGIDX
2700 | EF_ARM_MAPSYMSFIRST
);
2703 case EF_ARM_EABI_VER3
:
2704 fprintf (file
, _(" [Version3 EABI]"));
2706 if (flags
& EF_ARM_BE8
)
2707 fprintf (file
, _(" [BE8]"));
2709 if (flags
& EF_ARM_LE8
)
2710 fprintf (file
, _(" [LE8]"));
2712 flags
&= ~(EF_ARM_LE8
| EF_ARM_BE8
);
2716 fprintf (file
, _(" <EABI version unrecognised>"));
2720 flags
&= ~ EF_ARM_EABIMASK
;
2722 if (flags
& EF_ARM_RELEXEC
)
2723 fprintf (file
, _(" [relocatable executable]"));
2725 if (flags
& EF_ARM_HASENTRY
)
2726 fprintf (file
, _(" [has entry point]"));
2728 flags
&= ~ (EF_ARM_RELEXEC
| EF_ARM_HASENTRY
);
2731 fprintf (file
, _("<Unrecognised flag bits set>"));
2739 elf32_arm_get_symbol_type (Elf_Internal_Sym
* elf_sym
, int type
)
2741 switch (ELF_ST_TYPE (elf_sym
->st_info
))
2744 return ELF_ST_TYPE (elf_sym
->st_info
);
2747 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2748 This allows us to distinguish between data used by Thumb instructions
2749 and non-data (which is probably code) inside Thumb regions of an
2751 if (type
!= STT_OBJECT
)
2752 return ELF_ST_TYPE (elf_sym
->st_info
);
2763 elf32_arm_gc_mark_hook (asection
* sec
,
2764 struct bfd_link_info
* info ATTRIBUTE_UNUSED
,
2765 Elf_Internal_Rela
* rel
,
2766 struct elf_link_hash_entry
* h
,
2767 Elf_Internal_Sym
* sym
)
2771 switch (ELF32_R_TYPE (rel
->r_info
))
2773 case R_ARM_GNU_VTINHERIT
:
2774 case R_ARM_GNU_VTENTRY
:
2778 switch (h
->root
.type
)
2780 case bfd_link_hash_defined
:
2781 case bfd_link_hash_defweak
:
2782 return h
->root
.u
.def
.section
;
2784 case bfd_link_hash_common
:
2785 return h
->root
.u
.c
.p
->section
;
2793 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
2798 /* Update the got entry reference counts for the section being removed. */
2801 elf32_arm_gc_sweep_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
2802 struct bfd_link_info
* info ATTRIBUTE_UNUSED
,
2803 asection
* sec ATTRIBUTE_UNUSED
,
2804 const Elf_Internal_Rela
* relocs ATTRIBUTE_UNUSED
)
2806 Elf_Internal_Shdr
*symtab_hdr
;
2807 struct elf_link_hash_entry
**sym_hashes
;
2808 bfd_signed_vma
*local_got_refcounts
;
2809 const Elf_Internal_Rela
*rel
, *relend
;
2810 unsigned long r_symndx
;
2811 struct elf_link_hash_entry
*h
;
2812 struct elf32_arm_link_hash_table
* globals
;
2814 globals
= elf32_arm_hash_table (info
);
2816 elf_section_data (sec
)->local_dynrel
= NULL
;
2818 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2819 sym_hashes
= elf_sym_hashes (abfd
);
2820 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2822 relend
= relocs
+ sec
->reloc_count
;
2823 for (rel
= relocs
; rel
< relend
; rel
++)
2827 r_type
= ELF32_R_TYPE (rel
->r_info
);
2829 r_type
= arm_real_reloc_type (globals
, r_type
);
2835 case R_ARM_GOT_PREL
:
2837 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2838 if (r_symndx
>= symtab_hdr
->sh_info
)
2840 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2841 if (h
->got
.refcount
> 0)
2842 h
->got
.refcount
-= 1;
2844 else if (local_got_refcounts
!= NULL
)
2846 if (local_got_refcounts
[r_symndx
] > 0)
2847 local_got_refcounts
[r_symndx
] -= 1;
2858 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2859 if (r_symndx
>= symtab_hdr
->sh_info
)
2861 struct elf32_arm_link_hash_entry
*eh
;
2862 struct elf32_arm_relocs_copied
**pp
;
2863 struct elf32_arm_relocs_copied
*p
;
2865 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2867 if (h
->plt
.refcount
> 0)
2868 h
->plt
.refcount
-= 1;
2870 if (r_type
== R_ARM_ABS32
2872 || r_type
== R_ARM_PREL31
2874 || r_type
== R_ARM_REL32
)
2876 eh
= (struct elf32_arm_link_hash_entry
*) h
;
2878 for (pp
= &eh
->relocs_copied
; (p
= *pp
) != NULL
;
2880 if (p
->section
== sec
)
2899 /* Look through the relocs for a section during the first phase. */
2902 elf32_arm_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
2903 asection
*sec
, const Elf_Internal_Rela
*relocs
)
2905 Elf_Internal_Shdr
*symtab_hdr
;
2906 struct elf_link_hash_entry
**sym_hashes
;
2907 struct elf_link_hash_entry
**sym_hashes_end
;
2908 const Elf_Internal_Rela
*rel
;
2909 const Elf_Internal_Rela
*rel_end
;
2912 bfd_vma
*local_got_offsets
;
2913 struct elf32_arm_link_hash_table
*htab
;
2915 if (info
->relocatable
)
2918 htab
= elf32_arm_hash_table (info
);
2921 dynobj
= elf_hash_table (info
)->dynobj
;
2922 local_got_offsets
= elf_local_got_offsets (abfd
);
2924 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2925 sym_hashes
= elf_sym_hashes (abfd
);
2926 sym_hashes_end
= sym_hashes
2927 + symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
2929 if (!elf_bad_symtab (abfd
))
2930 sym_hashes_end
-= symtab_hdr
->sh_info
;
2932 rel_end
= relocs
+ sec
->reloc_count
;
2933 for (rel
= relocs
; rel
< rel_end
; rel
++)
2935 struct elf_link_hash_entry
*h
;
2936 unsigned long r_symndx
;
2939 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2940 r_type
= ELF32_R_TYPE (rel
->r_info
);
2942 r_type
= arm_real_reloc_type (htab
, r_type
);
2944 if (r_symndx
< symtab_hdr
->sh_info
)
2947 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2953 case R_ARM_GOT_PREL
:
2955 /* This symbol requires a global offset table entry. */
2962 bfd_signed_vma
*local_got_refcounts
;
2964 /* This is a global offset table entry for a local symbol. */
2965 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2966 if (local_got_refcounts
== NULL
)
2970 size
= symtab_hdr
->sh_info
;
2971 size
*= (sizeof (bfd_signed_vma
) + sizeof (char));
2972 local_got_refcounts
= bfd_zalloc (abfd
, size
);
2973 if (local_got_refcounts
== NULL
)
2975 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
2977 local_got_refcounts
[r_symndx
] += 1;
2979 if (r_type
== R_ARM_GOT32
)
2985 if (htab
->sgot
== NULL
)
2987 if (htab
->root
.dynobj
== NULL
)
2988 htab
->root
.dynobj
= abfd
;
2989 if (!create_got_section (htab
->root
.dynobj
, info
))
3003 /* If this reloc is in a read-only section, we might
3004 need a copy reloc. We can't check reliably at this
3005 stage whether the section is read-only, as input
3006 sections have not yet been mapped to output sections.
3007 Tentatively set the flag for now, and correct in
3008 adjust_dynamic_symbol. */
3012 /* We may need a .plt entry if the function this reloc
3013 refers to is in a different object. We can't tell for
3014 sure yet, because something later might force the
3016 if (r_type
== R_ARM_PC24
3017 || r_type
== R_ARM_PLT32
)
3020 /* If we create a PLT entry, this relocation will reference
3021 it, even if it's an ABS32 relocation. */
3022 h
->plt
.refcount
+= 1;
3025 /* If we are creating a shared library, and this is a reloc
3026 against a global symbol, or a non PC relative reloc
3027 against a local symbol, then we need to copy the reloc
3028 into the shared library. However, if we are linking with
3029 -Bsymbolic, we do not need to copy a reloc against a
3030 global symbol which is defined in an object we are
3031 including in the link (i.e., DEF_REGULAR is set). At
3032 this point we have not seen all the input files, so it is
3033 possible that DEF_REGULAR is not set now but will be set
3034 later (it is never cleared). We account for that
3035 possibility below by storing information in the
3036 relocs_copied field of the hash table entry. */
3038 && (sec
->flags
& SEC_ALLOC
) != 0
3039 && ((r_type
!= R_ARM_PC24
3040 && r_type
!= R_ARM_PLT32
3042 && r_type
!= R_ARM_PREL31
3044 && r_type
!= R_ARM_REL32
)
3046 && (! info
->symbolic
3047 || !h
->def_regular
))))
3049 struct elf32_arm_relocs_copied
*p
, **head
;
3051 /* When creating a shared object, we must copy these
3052 reloc types into the output file. We create a reloc
3053 section in dynobj and make room for this reloc. */
3058 name
= (bfd_elf_string_from_elf_section
3060 elf_elfheader (abfd
)->e_shstrndx
,
3061 elf_section_data (sec
)->rel_hdr
.sh_name
));
3065 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
3066 && strcmp (bfd_get_section_name (abfd
, sec
),
3069 sreloc
= bfd_get_section_by_name (dynobj
, name
);
3074 sreloc
= bfd_make_section (dynobj
, name
);
3075 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
3076 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3077 if ((sec
->flags
& SEC_ALLOC
) != 0
3078 /* BPABI objects never have dynamic
3079 relocations mapped. */
3080 && !htab
->symbian_p
)
3081 flags
|= SEC_ALLOC
| SEC_LOAD
;
3083 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
3084 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
3088 elf_section_data (sec
)->sreloc
= sreloc
;
3091 /* If this is a global symbol, we count the number of
3092 relocations we need for this symbol. */
3095 head
= &((struct elf32_arm_link_hash_entry
*) h
)->relocs_copied
;
3099 /* Track dynamic relocs needed for local syms too.
3100 We really need local syms available to do this
3104 s
= bfd_section_from_r_symndx (abfd
, &htab
->sym_sec
,
3109 head
= ((struct elf32_arm_relocs_copied
**)
3110 &elf_section_data (s
)->local_dynrel
);
3114 if (p
== NULL
|| p
->section
!= sec
)
3116 bfd_size_type amt
= sizeof *p
;
3118 p
= bfd_alloc (htab
->root
.dynobj
, amt
);
3127 if (r_type
== R_ARM_ABS32
3129 || r_type
== R_ARM_PREL31
3131 || r_type
== R_ARM_REL32
)
3136 /* This relocation describes the C++ object vtable hierarchy.
3137 Reconstruct it for later use during GC. */
3138 case R_ARM_GNU_VTINHERIT
:
3139 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
3143 /* This relocation describes which C++ vtable entries are actually
3144 used. Record for later use during GC. */
3145 case R_ARM_GNU_VTENTRY
:
3146 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
3156 is_arm_mapping_symbol_name (const char * name
)
3158 return (name
!= NULL
)
3160 && ((name
[1] == 'a') || (name
[1] == 't') || (name
[1] == 'd'))
3164 /* This is a copy of elf_find_function() from elf.c except that
3165 ARM mapping symbols are ignored when looking for function names
3166 and STT_ARM_TFUNC is considered to a function type. */
3169 arm_elf_find_function (bfd
* abfd ATTRIBUTE_UNUSED
,
3173 const char ** filename_ptr
,
3174 const char ** functionname_ptr
)
3176 const char * filename
= NULL
;
3177 asymbol
* func
= NULL
;
3178 bfd_vma low_func
= 0;
3181 for (p
= symbols
; *p
!= NULL
; p
++)
3185 q
= (elf_symbol_type
*) *p
;
3187 if (bfd_get_section (&q
->symbol
) != section
)
3190 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
3195 filename
= bfd_asymbol_name (&q
->symbol
);
3199 /* Skip $a and $t symbols. */
3200 if ((q
->symbol
.flags
& BSF_LOCAL
)
3201 && is_arm_mapping_symbol_name (q
->symbol
.name
))
3205 if (q
->symbol
.section
== section
3206 && q
->symbol
.value
>= low_func
3207 && q
->symbol
.value
<= offset
)
3209 func
= (asymbol
*) q
;
3210 low_func
= q
->symbol
.value
;
3220 *filename_ptr
= filename
;
3221 if (functionname_ptr
)
3222 *functionname_ptr
= bfd_asymbol_name (func
);
3228 /* Find the nearest line to a particular section and offset, for error
3229 reporting. This code is a duplicate of the code in elf.c, except
3230 that it uses arm_elf_find_function. */
3233 elf32_arm_find_nearest_line (bfd
* abfd
,
3237 const char ** filename_ptr
,
3238 const char ** functionname_ptr
,
3239 unsigned int * line_ptr
)
3241 bfd_boolean found
= FALSE
;
3243 /* We skip _bfd_dwarf1_find_nearest_line since no known ARM toolchain uses it. */
3245 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
3246 filename_ptr
, functionname_ptr
,
3248 & elf_tdata (abfd
)->dwarf2_find_line_info
))
3250 if (!*functionname_ptr
)
3251 arm_elf_find_function (abfd
, section
, symbols
, offset
,
3252 *filename_ptr
? NULL
: filename_ptr
,
3258 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
3259 & found
, filename_ptr
,
3260 functionname_ptr
, line_ptr
,
3261 & elf_tdata (abfd
)->line_info
))
3264 if (found
&& (*functionname_ptr
|| *line_ptr
))
3267 if (symbols
== NULL
)
3270 if (! arm_elf_find_function (abfd
, section
, symbols
, offset
,
3271 filename_ptr
, functionname_ptr
))
3278 /* Adjust a symbol defined by a dynamic object and referenced by a
3279 regular object. The current definition is in some section of the
3280 dynamic object, but we're not including those sections. We have to
3281 change the definition to something the rest of the link can
3285 elf32_arm_adjust_dynamic_symbol (struct bfd_link_info
* info
,
3286 struct elf_link_hash_entry
* h
)
3290 unsigned int power_of_two
;
3292 dynobj
= elf_hash_table (info
)->dynobj
;
3294 /* Make sure we know what is going on here. */
3295 BFD_ASSERT (dynobj
!= NULL
3297 || h
->u
.weakdef
!= NULL
3300 && !h
->def_regular
)));
3302 /* If this is a function, put it in the procedure linkage table. We
3303 will fill in the contents of the procedure linkage table later,
3304 when we know the address of the .got section. */
3305 if (h
->type
== STT_FUNC
3308 if (h
->plt
.refcount
<= 0
3309 || SYMBOL_CALLS_LOCAL (info
, h
)
3310 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
3311 && h
->root
.type
== bfd_link_hash_undefweak
))
3313 /* This case can occur if we saw a PLT32 reloc in an input
3314 file, but the symbol was never referred to by a dynamic
3315 object, or if all references were garbage collected. In
3316 such a case, we don't actually need to build a procedure
3317 linkage table, and we can just do a PC24 reloc instead. */
3318 h
->plt
.offset
= (bfd_vma
) -1;
3325 /* It's possible that we incorrectly decided a .plt reloc was
3326 needed for an R_ARM_PC24 reloc to a non-function sym in
3327 check_relocs. We can't decide accurately between function and
3328 non-function syms in check-relocs; Objects loaded later in
3329 the link may change h->type. So fix it now. */
3330 h
->plt
.offset
= (bfd_vma
) -1;
3332 /* If this is a weak symbol, and there is a real definition, the
3333 processor independent code will have arranged for us to see the
3334 real definition first, and we can just use the same value. */
3335 if (h
->u
.weakdef
!= NULL
)
3337 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
3338 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
3339 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
3340 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
3344 /* This is a reference to a symbol defined by a dynamic object which
3345 is not a function. */
3347 /* If we are creating a shared library, we must presume that the
3348 only references to the symbol are via the global offset table.
3349 For such cases we need not do anything here; the relocations will
3350 be handled correctly by relocate_section. */
3354 /* We must allocate the symbol in our .dynbss section, which will
3355 become part of the .bss section of the executable. There will be
3356 an entry for this symbol in the .dynsym section. The dynamic
3357 object will contain position independent code, so all references
3358 from the dynamic object to this symbol will go through the global
3359 offset table. The dynamic linker will use the .dynsym entry to
3360 determine the address it must put in the global offset table, so
3361 both the dynamic object and the regular object will refer to the
3362 same memory location for the variable. */
3363 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
3364 BFD_ASSERT (s
!= NULL
);
3366 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
3367 copy the initial value out of the dynamic object and into the
3368 runtime process image. We need to remember the offset into the
3369 .rel.bss section we are going to use. */
3370 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
3374 srel
= bfd_get_section_by_name (dynobj
, ".rel.bss");
3375 BFD_ASSERT (srel
!= NULL
);
3376 srel
->size
+= sizeof (Elf32_External_Rel
);
3380 /* We need to figure out the alignment required for this symbol. I
3381 have no idea how ELF linkers handle this. */
3382 power_of_two
= bfd_log2 (h
->size
);
3383 if (power_of_two
> 3)
3386 /* Apply the required alignment. */
3387 s
->size
= BFD_ALIGN (s
->size
, (bfd_size_type
) (1 << power_of_two
));
3388 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
3390 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
3394 /* Define the symbol as being at this point in the section. */
3395 h
->root
.u
.def
.section
= s
;
3396 h
->root
.u
.def
.value
= s
->size
;
3398 /* Increment the section size to make room for the symbol. */
3404 /* Allocate space in .plt, .got and associated reloc sections for
3408 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
3410 struct bfd_link_info
*info
;
3411 struct elf32_arm_link_hash_table
*htab
;
3412 struct elf32_arm_link_hash_entry
*eh
;
3413 struct elf32_arm_relocs_copied
*p
;
3415 if (h
->root
.type
== bfd_link_hash_indirect
)
3418 if (h
->root
.type
== bfd_link_hash_warning
)
3419 /* When warning symbols are created, they **replace** the "real"
3420 entry in the hash table, thus we never get to see the real
3421 symbol in a hash traversal. So look at it now. */
3422 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3424 info
= (struct bfd_link_info
*) inf
;
3425 htab
= elf32_arm_hash_table (info
);
3427 if (htab
->root
.dynamic_sections_created
3428 && h
->plt
.refcount
> 0)
3430 /* Make sure this symbol is output as a dynamic symbol.
3431 Undefined weak syms won't yet be marked as dynamic. */
3432 if (h
->dynindx
== -1
3433 && !h
->forced_local
)
3435 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3440 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
3442 asection
*s
= htab
->splt
;
3444 /* If this is the first .plt entry, make room for the special
3447 s
->size
+= htab
->plt_header_size
;
3449 h
->plt
.offset
= s
->size
;
3451 /* If this symbol is not defined in a regular file, and we are
3452 not generating a shared library, then set the symbol to this
3453 location in the .plt. This is required to make function
3454 pointers compare as equal between the normal executable and
3455 the shared library. */
3459 h
->root
.u
.def
.section
= s
;
3460 h
->root
.u
.def
.value
= h
->plt
.offset
;
3463 /* Make room for this entry. */
3464 s
->size
+= htab
->plt_entry_size
;
3466 if (!htab
->symbian_p
)
3467 /* We also need to make an entry in the .got.plt section, which
3468 will be placed in the .got section by the linker script. */
3469 htab
->sgotplt
->size
+= 4;
3471 /* We also need to make an entry in the .rel.plt section. */
3472 htab
->srelplt
->size
+= sizeof (Elf32_External_Rel
);
3476 h
->plt
.offset
= (bfd_vma
) -1;
3482 h
->plt
.offset
= (bfd_vma
) -1;
3486 if (h
->got
.refcount
> 0)
3491 /* Make sure this symbol is output as a dynamic symbol.
3492 Undefined weak syms won't yet be marked as dynamic. */
3493 if (h
->dynindx
== -1
3494 && !h
->forced_local
)
3496 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3500 if (!htab
->symbian_p
)
3503 h
->got
.offset
= s
->size
;
3505 dyn
= htab
->root
.dynamic_sections_created
;
3506 if ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3507 || h
->root
.type
!= bfd_link_hash_undefweak
)
3509 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
3510 htab
->srelgot
->size
+= sizeof (Elf32_External_Rel
);
3514 h
->got
.offset
= (bfd_vma
) -1;
3516 eh
= (struct elf32_arm_link_hash_entry
*) h
;
3517 if (eh
->relocs_copied
== NULL
)
3520 /* In the shared -Bsymbolic case, discard space allocated for
3521 dynamic pc-relative relocs against symbols which turn out to be
3522 defined in regular objects. For the normal shared case, discard
3523 space for pc-relative relocs that have become local due to symbol
3524 visibility changes. */
3528 /* Discard relocs on undefined weak syms with non-default
3530 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
3531 && h
->root
.type
== bfd_link_hash_undefweak
)
3532 eh
->relocs_copied
= NULL
;
3536 /* For the non-shared case, discard space for relocs against
3537 symbols which turn out to need copy relocs or are not
3543 || (htab
->root
.dynamic_sections_created
3544 && (h
->root
.type
== bfd_link_hash_undefweak
3545 || h
->root
.type
== bfd_link_hash_undefined
))))
3547 /* Make sure this symbol is output as a dynamic symbol.
3548 Undefined weak syms won't yet be marked as dynamic. */
3549 if (h
->dynindx
== -1
3550 && !h
->forced_local
)
3552 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3556 /* If that succeeded, we know we'll be keeping all the
3558 if (h
->dynindx
!= -1)
3562 eh
->relocs_copied
= NULL
;
3567 /* Finally, allocate space. */
3568 for (p
= eh
->relocs_copied
; p
!= NULL
; p
= p
->next
)
3570 asection
*sreloc
= elf_section_data (p
->section
)->sreloc
;
3571 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
3577 /* Set the sizes of the dynamic sections. */
3580 elf32_arm_size_dynamic_sections (bfd
* output_bfd ATTRIBUTE_UNUSED
,
3581 struct bfd_link_info
* info
)
3588 struct elf32_arm_link_hash_table
*htab
;
3590 htab
= elf32_arm_hash_table (info
);
3591 dynobj
= elf_hash_table (info
)->dynobj
;
3592 BFD_ASSERT (dynobj
!= NULL
);
3594 if (elf_hash_table (info
)->dynamic_sections_created
)
3596 /* Set the contents of the .interp section to the interpreter. */
3597 if (info
->executable
)
3599 s
= bfd_get_section_by_name (dynobj
, ".interp");
3600 BFD_ASSERT (s
!= NULL
);
3601 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
3602 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
3606 /* Set up .got offsets for local syms, and space for local dynamic
3608 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
3610 bfd_signed_vma
*local_got
;
3611 bfd_signed_vma
*end_local_got
;
3612 char *local_tls_type
;
3613 bfd_size_type locsymcount
;
3614 Elf_Internal_Shdr
*symtab_hdr
;
3617 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
3620 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3622 struct elf32_arm_relocs_copied
*p
;
3624 for (p
= *((struct elf32_arm_relocs_copied
**)
3625 &elf_section_data (s
)->local_dynrel
);
3629 if (!bfd_is_abs_section (p
->section
)
3630 && bfd_is_abs_section (p
->section
->output_section
))
3632 /* Input section has been discarded, either because
3633 it is a copy of a linkonce section or due to
3634 linker script /DISCARD/, so we'll be discarding
3637 else if (p
->count
!= 0)
3639 srel
= elf_section_data (p
->section
)->sreloc
;
3640 srel
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
3641 if ((p
->section
->output_section
->flags
& SEC_READONLY
) != 0)
3642 info
->flags
|= DF_TEXTREL
;
3647 local_got
= elf_local_got_refcounts (ibfd
);
3651 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
3652 locsymcount
= symtab_hdr
->sh_info
;
3653 end_local_got
= local_got
+ locsymcount
;
3655 srel
= htab
->srelgot
;
3656 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
3660 *local_got
= s
->size
;
3663 srel
->size
+= sizeof (Elf32_External_Rel
);
3666 *local_got
= (bfd_vma
) -1;
3670 /* Allocate global sym .plt and .got entries, and space for global
3671 sym dynamic relocs. */
3672 elf_link_hash_traverse (& htab
->root
, allocate_dynrelocs
, info
);
3674 /* The check_relocs and adjust_dynamic_symbol entry points have
3675 determined the sizes of the various dynamic sections. Allocate
3679 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3684 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3687 /* It's OK to base decisions on the section name, because none
3688 of the dynobj section names depend upon the input files. */
3689 name
= bfd_get_section_name (dynobj
, s
);
3693 if (strcmp (name
, ".plt") == 0)
3697 /* Strip this section if we don't need it; see the
3703 /* Remember whether there is a PLT. */
3707 else if (strncmp (name
, ".rel", 4) == 0)
3711 /* If we don't need this section, strip it from the
3712 output file. This is mostly to handle .rel.bss and
3713 .rel.plt. We must create both sections in
3714 create_dynamic_sections, because they must be created
3715 before the linker maps input sections to output
3716 sections. The linker does that before
3717 adjust_dynamic_symbol is called, and it is that
3718 function which decides whether anything needs to go
3719 into these sections. */
3724 /* Remember whether there are any reloc sections other
3726 if (strcmp (name
, ".rel.plt") != 0)
3729 /* We use the reloc_count field as a counter if we need
3730 to copy relocs into the output file. */
3734 else if (strncmp (name
, ".got", 4) != 0)
3736 /* It's not one of our sections, so don't allocate space. */
3742 _bfd_strip_section_from_output (info
, s
);
3746 /* Allocate memory for the section contents. */
3747 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3748 if (s
->contents
== NULL
&& s
->size
!= 0)
3752 if (elf_hash_table (info
)->dynamic_sections_created
)
3754 /* Add some entries to the .dynamic section. We fill in the
3755 values later, in elf32_arm_finish_dynamic_sections, but we
3756 must add the entries now so that we get the correct size for
3757 the .dynamic section. The DT_DEBUG entry is filled in by the
3758 dynamic linker and used by the debugger. */
3759 #define add_dynamic_entry(TAG, VAL) \
3760 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3764 if (!add_dynamic_entry (DT_DEBUG
, 0))
3770 if ( !add_dynamic_entry (DT_PLTGOT
, 0)
3771 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
3772 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
3773 || !add_dynamic_entry (DT_JMPREL
, 0))
3779 if ( !add_dynamic_entry (DT_REL
, 0)
3780 || !add_dynamic_entry (DT_RELSZ
, 0)
3781 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
3785 if ((info
->flags
& DF_TEXTREL
) != 0)
3787 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3789 info
->flags
|= DF_TEXTREL
;
3792 #undef add_synamic_entry
3797 /* Finish up dynamic symbol handling. We set the contents of various
3798 dynamic sections here. */
3801 elf32_arm_finish_dynamic_symbol (bfd
* output_bfd
, struct bfd_link_info
* info
,
3802 struct elf_link_hash_entry
* h
, Elf_Internal_Sym
* sym
)
3805 struct elf32_arm_link_hash_table
*htab
;
3807 dynobj
= elf_hash_table (info
)->dynobj
;
3808 htab
= elf32_arm_hash_table (info
);
3810 if (h
->plt
.offset
!= (bfd_vma
) -1)
3816 Elf_Internal_Rela rel
;
3818 /* This symbol has an entry in the procedure linkage table. Set
3821 BFD_ASSERT (h
->dynindx
!= -1);
3823 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3824 srel
= bfd_get_section_by_name (dynobj
, ".rel.plt");
3825 BFD_ASSERT (splt
!= NULL
&& srel
!= NULL
);
3827 /* Get the index in the procedure linkage table which
3828 corresponds to this symbol. This is the index of this symbol
3829 in all the symbols for which we are making plt entries. The
3830 first entry in the procedure linkage table is reserved. */
3831 plt_index
= ((h
->plt
.offset
- htab
->plt_header_size
)
3832 / htab
->plt_entry_size
);
3834 /* Fill in the entry in the procedure linkage table. */
3835 if (htab
->symbian_p
)
3838 for (i
= 0; i
< htab
->plt_entry_size
/ 4; ++i
)
3839 bfd_put_32 (output_bfd
,
3840 elf32_arm_symbian_plt_entry
[i
],
3841 splt
->contents
+ h
->plt
.offset
+ 4 * i
);
3843 /* Fill in the entry in the .rel.plt section. */
3844 rel
.r_offset
= (splt
->output_offset
3845 + h
->plt
.offset
+ 4 * (i
- 1));
3846 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_GLOB_DAT
);
3851 bfd_vma got_displacement
;
3854 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3855 BFD_ASSERT (sgot
!= NULL
);
3857 /* Get the offset into the .got table of the entry that
3858 corresponds to this function. Each .got entry is 4 bytes.
3859 The first three are reserved. */
3860 got_offset
= (plt_index
+ 3) * 4;
3862 /* Calculate the displacement between the PLT slot and the
3863 entry in the GOT. */
3864 got_displacement
= (sgot
->output_section
->vma
3865 + sgot
->output_offset
3867 - splt
->output_section
->vma
3868 - splt
->output_offset
3872 BFD_ASSERT ((got_displacement
& 0xf0000000) == 0);
3874 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[0] | ((got_displacement
& 0x0ff00000) >> 20),
3875 splt
->contents
+ h
->plt
.offset
+ 0);
3876 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[1] | ((got_displacement
& 0x000ff000) >> 12),
3877 splt
->contents
+ h
->plt
.offset
+ 4);
3878 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[2] | (got_displacement
& 0x00000fff),
3879 splt
->contents
+ h
->plt
.offset
+ 8);
3880 #ifdef FOUR_WORD_PLT
3881 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[3],
3882 splt
->contents
+ h
->plt
.offset
+ 12);
3885 /* Fill in the entry in the global offset table. */
3886 bfd_put_32 (output_bfd
,
3887 (splt
->output_section
->vma
3888 + splt
->output_offset
),
3889 sgot
->contents
+ got_offset
);
3891 /* Fill in the entry in the .rel.plt section. */
3892 rel
.r_offset
= (sgot
->output_section
->vma
3893 + sgot
->output_offset
3895 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_JUMP_SLOT
);
3898 loc
= srel
->contents
+ plt_index
* sizeof (Elf32_External_Rel
);
3899 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3901 if (!h
->def_regular
)
3903 /* Mark the symbol as undefined, rather than as defined in
3904 the .plt section. Leave the value alone. */
3905 sym
->st_shndx
= SHN_UNDEF
;
3906 /* If the symbol is weak, we do need to clear the value.
3907 Otherwise, the PLT entry would provide a definition for
3908 the symbol even if the symbol wasn't defined anywhere,
3909 and so the symbol would never be NULL. */
3910 if (!h
->ref_regular_nonweak
)
3915 if (h
->got
.offset
!= (bfd_vma
) -1)
3919 Elf_Internal_Rela rel
;
3922 /* This symbol has an entry in the global offset table. Set it
3924 sgot
= bfd_get_section_by_name (dynobj
, ".got");
3925 srel
= bfd_get_section_by_name (dynobj
, ".rel.got");
3926 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
3928 rel
.r_offset
= (sgot
->output_section
->vma
3929 + sgot
->output_offset
3930 + (h
->got
.offset
&~ (bfd_vma
) 1));
3932 /* If this is a static link, or it is a -Bsymbolic link and the
3933 symbol is defined locally or was forced to be local because
3934 of a version file, we just want to emit a RELATIVE reloc.
3935 The entry in the global offset table will already have been
3936 initialized in the relocate_section function. */
3938 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3940 BFD_ASSERT((h
->got
.offset
& 1) != 0);
3941 rel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
3945 BFD_ASSERT((h
->got
.offset
& 1) == 0);
3946 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
3947 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_GLOB_DAT
);
3950 loc
= srel
->contents
+ srel
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3951 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3957 Elf_Internal_Rela rel
;
3960 /* This symbol needs a copy reloc. Set it up. */
3961 BFD_ASSERT (h
->dynindx
!= -1
3962 && (h
->root
.type
== bfd_link_hash_defined
3963 || h
->root
.type
== bfd_link_hash_defweak
));
3965 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
3967 BFD_ASSERT (s
!= NULL
);
3969 rel
.r_offset
= (h
->root
.u
.def
.value
3970 + h
->root
.u
.def
.section
->output_section
->vma
3971 + h
->root
.u
.def
.section
->output_offset
);
3972 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_COPY
);
3973 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3974 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3977 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3978 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3979 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
3980 sym
->st_shndx
= SHN_ABS
;
3985 /* Finish up the dynamic sections. */
3988 elf32_arm_finish_dynamic_sections (bfd
* output_bfd
, struct bfd_link_info
* info
)
3994 dynobj
= elf_hash_table (info
)->dynobj
;
3996 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3997 BFD_ASSERT (elf32_arm_hash_table (info
)->symbian_p
|| sgot
!= NULL
);
3998 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
4000 if (elf_hash_table (info
)->dynamic_sections_created
)
4003 Elf32_External_Dyn
*dyncon
, *dynconend
;
4004 struct elf32_arm_link_hash_table
*htab
;
4006 htab
= elf32_arm_hash_table (info
);
4007 splt
= bfd_get_section_by_name (dynobj
, ".plt");
4008 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
4010 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
4011 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4013 for (; dyncon
< dynconend
; dyncon
++)
4015 Elf_Internal_Dyn dyn
;
4019 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4030 goto get_vma_if_bpabi
;
4033 goto get_vma_if_bpabi
;
4036 goto get_vma_if_bpabi
;
4044 s
= bfd_get_section_by_name (output_bfd
, name
);
4045 BFD_ASSERT (s
!= NULL
);
4046 if (!htab
->symbian_p
)
4047 dyn
.d_un
.d_ptr
= s
->vma
;
4049 /* In the BPABI, tags in the PT_DYNAMIC section point
4050 at the file offset, not the memory address, for the
4051 convenience of the post linker. */
4052 dyn
.d_un
.d_ptr
= s
->filepos
;
4053 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4057 if (htab
->symbian_p
)
4062 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
4063 BFD_ASSERT (s
!= NULL
);
4064 dyn
.d_un
.d_val
= s
->size
;
4065 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4069 if (!htab
->symbian_p
)
4071 /* My reading of the SVR4 ABI indicates that the
4072 procedure linkage table relocs (DT_JMPREL) should be
4073 included in the overall relocs (DT_REL). This is
4074 what Solaris does. However, UnixWare can not handle
4075 that case. Therefore, we override the DT_RELSZ entry
4076 here to make it not include the JMPREL relocs. Since
4077 the linker script arranges for .rel.plt to follow all
4078 other relocation sections, we don't have to worry
4079 about changing the DT_REL entry. */
4080 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
4082 dyn
.d_un
.d_val
-= s
->size
;
4083 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4091 /* In the BPABI, the DT_REL tag must point at the file
4092 offset, not the VMA, of the first relocation
4093 section. So, we use code similar to that in
4094 elflink.c, but do not check for SHF_ALLOC on the
4095 relcoation section, since relocations sections are
4096 never allocated under the BPABI. The comments above
4097 about Unixware notwithstanding, we include all of the
4098 relocations here. */
4099 if (htab
->symbian_p
)
4102 type
= ((dyn
.d_tag
== DT_REL
|| dyn
.d_tag
== DT_RELSZ
)
4103 ? SHT_REL
: SHT_RELA
);
4105 for (i
= 1; i
< elf_numsections (output_bfd
); i
++)
4107 Elf_Internal_Shdr
*hdr
4108 = elf_elfsections (output_bfd
)[i
];
4109 if (hdr
->sh_type
== type
)
4111 if (dyn
.d_tag
== DT_RELSZ
4112 || dyn
.d_tag
== DT_RELASZ
)
4113 dyn
.d_un
.d_val
+= hdr
->sh_size
;
4114 else if (dyn
.d_un
.d_val
== 0
4115 || hdr
->sh_offset
< dyn
.d_un
.d_val
)
4116 dyn
.d_un
.d_val
= hdr
->sh_offset
;
4119 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4123 /* Set the bottom bit of DT_INIT/FINI if the
4124 corresponding function is Thumb. */
4126 name
= info
->init_function
;
4129 name
= info
->fini_function
;
4131 /* If it wasn't set by elf_bfd_final_link
4132 then there is nothing to adjust. */
4133 if (dyn
.d_un
.d_val
!= 0)
4135 struct elf_link_hash_entry
* eh
;
4137 eh
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4138 FALSE
, FALSE
, TRUE
);
4139 if (eh
!= (struct elf_link_hash_entry
*) NULL
4140 && ELF_ST_TYPE (eh
->type
) == STT_ARM_TFUNC
)
4142 dyn
.d_un
.d_val
|= 1;
4143 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4150 /* Fill in the first entry in the procedure linkage table. */
4151 if (splt
->size
> 0 && elf32_arm_hash_table (info
)->plt_header_size
)
4153 bfd_vma got_displacement
;
4155 /* Calculate the displacement between the PLT slot and &GOT[0]. */
4156 got_displacement
= (sgot
->output_section
->vma
4157 + sgot
->output_offset
4158 - splt
->output_section
->vma
4159 - splt
->output_offset
4162 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[0], splt
->contents
+ 0);
4163 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[1], splt
->contents
+ 4);
4164 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[2], splt
->contents
+ 8);
4165 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[3], splt
->contents
+ 12);
4166 #ifdef FOUR_WORD_PLT
4167 /* The displacement value goes in the otherwise-unused last word of
4168 the second entry. */
4169 bfd_put_32 (output_bfd
, got_displacement
, splt
->contents
+ 28);
4171 bfd_put_32 (output_bfd
, got_displacement
, splt
->contents
+ 16);
4175 /* UnixWare sets the entsize of .plt to 4, although that doesn't
4176 really seem like the right value. */
4177 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
4180 /* Fill in the first three entries in the global offset table. */
4186 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
4188 bfd_put_32 (output_bfd
,
4189 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
4191 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
4192 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
4195 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
4202 elf32_arm_post_process_headers (bfd
* abfd
, struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
)
4204 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
4205 struct elf32_arm_link_hash_table
*globals
;
4207 i_ehdrp
= elf_elfheader (abfd
);
4209 i_ehdrp
->e_ident
[EI_OSABI
] = ARM_ELF_OS_ABI_VERSION
;
4210 i_ehdrp
->e_ident
[EI_ABIVERSION
] = ARM_ELF_ABI_VERSION
;
4214 globals
= elf32_arm_hash_table (link_info
);
4215 if (globals
->byteswap_code
)
4216 i_ehdrp
->e_flags
|= EF_ARM_BE8
;
4220 static enum elf_reloc_type_class
4221 elf32_arm_reloc_type_class (const Elf_Internal_Rela
*rela
)
4223 switch ((int) ELF32_R_TYPE (rela
->r_info
))
4225 case R_ARM_RELATIVE
:
4226 return reloc_class_relative
;
4227 case R_ARM_JUMP_SLOT
:
4228 return reloc_class_plt
;
4230 return reloc_class_copy
;
4232 return reloc_class_normal
;
4236 static bfd_boolean
elf32_arm_section_flags (flagword
*, const Elf_Internal_Shdr
*);
4237 static void elf32_arm_final_write_processing (bfd
*, bfd_boolean
);
4239 /* Set the right machine number for an Arm ELF file. */
4242 elf32_arm_section_flags (flagword
*flags
, const Elf_Internal_Shdr
*hdr
)
4244 if (hdr
->sh_type
== SHT_NOTE
)
4245 *flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_CONTENTS
;
4251 elf32_arm_final_write_processing (bfd
*abfd
, bfd_boolean linker ATTRIBUTE_UNUSED
)
4253 bfd_arm_update_notes (abfd
, ARM_NOTE_SECTION
);
4257 /* Called for each symbol. Builds a section map based on mapping symbols.
4258 Does not alter any of the symbols. */
4261 elf32_arm_output_symbol_hook (struct bfd_link_info
*info
,
4263 Elf_Internal_Sym
*elfsym
,
4264 asection
*input_sec
,
4265 struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
4268 elf32_arm_section_map
*map
;
4269 struct elf32_arm_link_hash_table
*globals
;
4271 /* Only do this on final link. */
4272 if (info
->relocatable
)
4275 /* Only build a map if we need to byteswap code. */
4276 globals
= elf32_arm_hash_table (info
);
4277 if (!globals
->byteswap_code
)
4280 /* We only want mapping symbols. */
4281 if (! is_arm_mapping_symbol_name (name
))
4284 mapcount
= ++(elf32_arm_section_data (input_sec
)->mapcount
);
4285 map
= elf32_arm_section_data (input_sec
)->map
;
4286 /* TODO: This may be inefficient, but we probably don't usually have many
4287 mapping symbols per section. */
4288 map
= bfd_realloc (map
, mapcount
* sizeof (elf32_arm_section_map
));
4289 elf32_arm_section_data (input_sec
)->map
= map
;
4291 map
[mapcount
- 1].vma
= elfsym
->st_value
;
4292 map
[mapcount
- 1].type
= name
[1];
4297 /* Allocate target specific section data. */
4300 elf32_arm_new_section_hook (bfd
*abfd
, asection
*sec
)
4302 struct _arm_elf_section_data
*sdata
;
4303 bfd_size_type amt
= sizeof (*sdata
);
4305 sdata
= bfd_zalloc (abfd
, amt
);
4308 sec
->used_by_bfd
= sdata
;
4310 return _bfd_elf_new_section_hook (abfd
, sec
);
4314 /* Used to order a list of mapping symbols by address. */
4317 elf32_arm_compare_mapping (const void * a
, const void * b
)
4319 return ((const elf32_arm_section_map
*) a
)->vma
4320 > ((const elf32_arm_section_map
*) b
)->vma
;
4324 /* Do code byteswapping. Return FALSE afterwards so that the section is
4325 written out as normal. */
4328 elf32_arm_write_section (bfd
*output_bfd ATTRIBUTE_UNUSED
, asection
*sec
,
4332 elf32_arm_section_map
*map
;
4339 mapcount
= elf32_arm_section_data (sec
)->mapcount
;
4340 map
= elf32_arm_section_data (sec
)->map
;
4345 qsort (map
, mapcount
, sizeof (elf32_arm_section_map
),
4346 elf32_arm_compare_mapping
);
4348 offset
= sec
->output_section
->vma
+ sec
->output_offset
;
4349 ptr
= map
[0].vma
- offset
;
4350 for (i
= 0; i
< mapcount
; i
++)
4352 if (i
== mapcount
- 1)
4355 end
= map
[i
+ 1].vma
- offset
;
4357 switch (map
[i
].type
)
4360 /* Byte swap code words. */
4361 while (ptr
+ 3 < end
)
4363 tmp
= contents
[ptr
];
4364 contents
[ptr
] = contents
[ptr
+ 3];
4365 contents
[ptr
+ 3] = tmp
;
4366 tmp
= contents
[ptr
+ 1];
4367 contents
[ptr
+ 1] = contents
[ptr
+ 2];
4368 contents
[ptr
+ 2] = tmp
;
4374 /* Byte swap code halfwords. */
4375 while (ptr
+ 1 < end
)
4377 tmp
= contents
[ptr
];
4378 contents
[ptr
] = contents
[ptr
+ 1];
4379 contents
[ptr
+ 1] = tmp
;
4385 /* Leave data alone. */
4394 #define ELF_ARCH bfd_arch_arm
4395 #define ELF_MACHINE_CODE EM_ARM
4396 #ifdef __QNXTARGET__
4397 #define ELF_MAXPAGESIZE 0x1000
4399 #define ELF_MAXPAGESIZE 0x8000
4402 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
4403 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
4404 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
4405 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
4406 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
4407 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
4408 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
4409 #define bfd_elf32_new_section_hook elf32_arm_new_section_hook
4411 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
4412 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
4413 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
4414 #define elf_backend_check_relocs elf32_arm_check_relocs
4415 #define elf_backend_relocate_section elf32_arm_relocate_section
4416 #define elf_backend_write_section elf32_arm_write_section
4417 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
4418 #define elf_backend_create_dynamic_sections elf32_arm_create_dynamic_sections
4419 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
4420 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
4421 #define elf_backend_link_output_symbol_hook elf32_arm_output_symbol_hook
4422 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
4423 #define elf_backend_post_process_headers elf32_arm_post_process_headers
4424 #define elf_backend_reloc_type_class elf32_arm_reloc_type_class
4425 #define elf_backend_object_p elf32_arm_object_p
4426 #define elf_backend_section_flags elf32_arm_section_flags
4427 #define elf_backend_final_write_processing elf32_arm_final_write_processing
4428 #define elf_backend_copy_indirect_symbol elf32_arm_copy_indirect_symbol
4430 #define elf_backend_can_refcount 1
4431 #define elf_backend_can_gc_sections 1
4432 #define elf_backend_plt_readonly 1
4433 #define elf_backend_want_got_plt 1
4434 #define elf_backend_want_plt_sym 0
4436 #define elf_backend_rela_normal 1
4439 #define elf_backend_got_header_size 12
4441 #include "elf32-target.h"