1 /* 32-bit ELF support for ARM
2 Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20 typedef unsigned long int insn32
;
21 typedef unsigned short int insn16
;
23 static boolean elf32_arm_set_private_flags
24 PARAMS ((bfd
*, flagword
));
25 static boolean elf32_arm_copy_private_bfd_data
26 PARAMS ((bfd
*, bfd
*));
27 static boolean elf32_arm_merge_private_bfd_data
28 PARAMS ((bfd
*, bfd
*));
29 static boolean elf32_arm_print_private_bfd_data
30 PARAMS ((bfd
*, PTR
));
31 static int elf32_arm_get_symbol_type
32 PARAMS (( Elf_Internal_Sym
*, int));
33 static struct bfd_link_hash_table
*elf32_arm_link_hash_table_create
35 static bfd_reloc_status_type elf32_arm_final_link_relocate
36 PARAMS ((reloc_howto_type
*, bfd
*, bfd
*, asection
*, bfd_byte
*,
37 Elf_Internal_Rela
*, bfd_vma
, struct bfd_link_info
*, asection
*,
38 const char *, int, struct elf_link_hash_entry
*));
39 static insn32 insert_thumb_branch
40 PARAMS ((insn32
, int));
41 static struct elf_link_hash_entry
*find_thumb_glue
42 PARAMS ((struct bfd_link_info
*, const char *, bfd
*));
43 static struct elf_link_hash_entry
*find_arm_glue
44 PARAMS ((struct bfd_link_info
*, const char *, bfd
*));
45 static void elf32_arm_post_process_headers
46 PARAMS ((bfd
*, struct bfd_link_info
*));
47 static int elf32_arm_to_thumb_stub
48 PARAMS ((struct bfd_link_info
*, const char *, bfd
*, bfd
*, asection
*,
49 bfd_byte
*, asection
*, bfd_vma
, bfd_signed_vma
, bfd_vma
));
50 static int elf32_thumb_to_arm_stub
51 PARAMS ((struct bfd_link_info
*, const char *, bfd
*, bfd
*, asection
*,
52 bfd_byte
*, asection
*, bfd_vma
, bfd_signed_vma
, bfd_vma
));
53 static boolean elf32_arm_relocate_section
54 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
55 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
56 static asection
* elf32_arm_gc_mark_hook
57 PARAMS ((asection
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
58 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
59 static boolean elf32_arm_gc_sweep_hook
60 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
61 const Elf_Internal_Rela
*));
62 static boolean elf32_arm_check_relocs
63 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
64 const Elf_Internal_Rela
*));
65 static boolean elf32_arm_find_nearest_line
66 PARAMS ((bfd
*, asection
*, asymbol
**, bfd_vma
, const char **,
67 const char **, unsigned int *));
68 static boolean elf32_arm_adjust_dynamic_symbol
69 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
70 static boolean elf32_arm_size_dynamic_sections
71 PARAMS ((bfd
*, struct bfd_link_info
*));
72 static boolean elf32_arm_finish_dynamic_symbol
73 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
75 static boolean elf32_arm_finish_dynamic_sections
76 PARAMS ((bfd
*, struct bfd_link_info
*));
77 static struct bfd_hash_entry
* elf32_arm_link_hash_newfunc
78 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
80 static void arm_add_to_rel
81 PARAMS ((bfd
*, bfd_byte
*, reloc_howto_type
*, bfd_signed_vma
));
83 static enum elf_reloc_type_class elf32_arm_reloc_type_class
84 PARAMS ((const Elf_Internal_Rela
*));
86 #ifndef ELFARM_NABI_C_INCLUDED
87 static void record_arm_to_thumb_glue
88 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
89 static void record_thumb_to_arm_glue
90 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
91 boolean bfd_elf32_arm_allocate_interworking_sections
92 PARAMS ((struct bfd_link_info
*));
93 boolean bfd_elf32_arm_get_bfd_for_interworking
94 PARAMS ((bfd
*, struct bfd_link_info
*));
95 boolean bfd_elf32_arm_process_before_allocation
96 PARAMS ((bfd
*, struct bfd_link_info
*, int));
100 #define INTERWORK_FLAG(abfd) (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK)
102 /* The linker script knows the section names for placement.
103 The entry_names are used to do simple name mangling on the stubs.
104 Given a function name, and its type, the stub can be found. The
105 name can be changed. The only requirement is the %s be present. */
106 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
107 #define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
109 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
110 #define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
112 /* The name of the dynamic interpreter. This is put in the .interp
114 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
116 /* The size in bytes of an entry in the procedure linkage table. */
117 #define PLT_ENTRY_SIZE 16
119 /* The first entry in a procedure linkage table looks like
120 this. It is set up so that any shared library function that is
121 called before the relocation has been set up calls the dynamic
123 static const bfd_vma elf32_arm_plt0_entry
[PLT_ENTRY_SIZE
/ 4] =
125 0xe52de004, /* str lr, [sp, #-4]! */
126 0xe59fe010, /* ldr lr, [pc, #16] */
127 0xe08fe00e, /* add lr, pc, lr */
128 0xe5bef008 /* ldr pc, [lr, #8]! */
131 /* Subsequent entries in a procedure linkage table look like
133 static const bfd_vma elf32_arm_plt_entry
[PLT_ENTRY_SIZE
/ 4] =
135 0xe59fc004, /* ldr ip, [pc, #4] */
136 0xe08fc00c, /* add ip, pc, ip */
137 0xe59cf000, /* ldr pc, [ip] */
138 0x00000000 /* offset to symbol in got */
141 /* The ARM linker needs to keep track of the number of relocs that it
142 decides to copy in check_relocs for each symbol. This is so that
143 it can discard PC relative relocs if it doesn't need them when
144 linking with -Bsymbolic. We store the information in a field
145 extending the regular ELF linker hash table. */
147 /* This structure keeps track of the number of PC relative relocs we
148 have copied for a given symbol. */
149 struct elf32_arm_pcrel_relocs_copied
152 struct elf32_arm_pcrel_relocs_copied
* next
;
153 /* A section in dynobj. */
155 /* Number of relocs copied in this section. */
159 /* Arm ELF linker hash entry. */
160 struct elf32_arm_link_hash_entry
162 struct elf_link_hash_entry root
;
164 /* Number of PC relative relocs copied for this symbol. */
165 struct elf32_arm_pcrel_relocs_copied
* pcrel_relocs_copied
;
168 /* Declare this now that the above structures are defined. */
169 static boolean elf32_arm_discard_copies
170 PARAMS ((struct elf32_arm_link_hash_entry
*, PTR
));
172 /* Traverse an arm ELF linker hash table. */
173 #define elf32_arm_link_hash_traverse(table, func, info) \
174 (elf_link_hash_traverse \
176 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
179 /* Get the ARM elf linker hash table from a link_info structure. */
180 #define elf32_arm_hash_table(info) \
181 ((struct elf32_arm_link_hash_table *) ((info)->hash))
183 /* ARM ELF linker hash table. */
184 struct elf32_arm_link_hash_table
186 /* The main hash table. */
187 struct elf_link_hash_table root
;
189 /* The size in bytes of the section containg the Thumb-to-ARM glue. */
190 bfd_size_type thumb_glue_size
;
192 /* The size in bytes of the section containg the ARM-to-Thumb glue. */
193 bfd_size_type arm_glue_size
;
195 /* An arbitary input BFD chosen to hold the glue sections. */
196 bfd
* bfd_of_glue_owner
;
198 /* A boolean indicating whether knowledge of the ARM's pipeline
199 length should be applied by the linker. */
200 int no_pipeline_knowledge
;
203 /* Create an entry in an ARM ELF linker hash table. */
205 static struct bfd_hash_entry
*
206 elf32_arm_link_hash_newfunc (entry
, table
, string
)
207 struct bfd_hash_entry
* entry
;
208 struct bfd_hash_table
* table
;
211 struct elf32_arm_link_hash_entry
* ret
=
212 (struct elf32_arm_link_hash_entry
*) entry
;
214 /* Allocate the structure if it has not already been allocated by a
216 if (ret
== (struct elf32_arm_link_hash_entry
*) NULL
)
217 ret
= ((struct elf32_arm_link_hash_entry
*)
218 bfd_hash_allocate (table
,
219 sizeof (struct elf32_arm_link_hash_entry
)));
220 if (ret
== (struct elf32_arm_link_hash_entry
*) NULL
)
221 return (struct bfd_hash_entry
*) ret
;
223 /* Call the allocation method of the superclass. */
224 ret
= ((struct elf32_arm_link_hash_entry
*)
225 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
227 if (ret
!= (struct elf32_arm_link_hash_entry
*) NULL
)
228 ret
->pcrel_relocs_copied
= NULL
;
230 return (struct bfd_hash_entry
*) ret
;
233 /* Create an ARM elf linker hash table. */
235 static struct bfd_link_hash_table
*
236 elf32_arm_link_hash_table_create (abfd
)
239 struct elf32_arm_link_hash_table
*ret
;
240 bfd_size_type amt
= sizeof (struct elf32_arm_link_hash_table
);
242 ret
= (struct elf32_arm_link_hash_table
*) bfd_malloc (amt
);
243 if (ret
== (struct elf32_arm_link_hash_table
*) NULL
)
246 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
247 elf32_arm_link_hash_newfunc
))
253 ret
->thumb_glue_size
= 0;
254 ret
->arm_glue_size
= 0;
255 ret
->bfd_of_glue_owner
= NULL
;
256 ret
->no_pipeline_knowledge
= 0;
258 return &ret
->root
.root
;
261 /* Locate the Thumb encoded calling stub for NAME. */
263 static struct elf_link_hash_entry
*
264 find_thumb_glue (link_info
, name
, input_bfd
)
265 struct bfd_link_info
*link_info
;
270 struct elf_link_hash_entry
*hash
;
271 struct elf32_arm_link_hash_table
*hash_table
;
273 /* We need a pointer to the armelf specific hash table. */
274 hash_table
= elf32_arm_hash_table (link_info
);
276 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
277 + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1);
279 BFD_ASSERT (tmp_name
);
281 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
283 hash
= elf_link_hash_lookup
284 (&(hash_table
)->root
, tmp_name
, false, false, true);
287 /* xgettext:c-format */
288 (*_bfd_error_handler
) (_("%s: unable to find THUMB glue '%s' for `%s'"),
289 bfd_archive_filename (input_bfd
), tmp_name
, name
);
296 /* Locate the ARM encoded calling stub for NAME. */
298 static struct elf_link_hash_entry
*
299 find_arm_glue (link_info
, name
, input_bfd
)
300 struct bfd_link_info
*link_info
;
305 struct elf_link_hash_entry
*myh
;
306 struct elf32_arm_link_hash_table
*hash_table
;
308 /* We need a pointer to the elfarm specific hash table. */
309 hash_table
= elf32_arm_hash_table (link_info
);
311 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
312 + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1);
314 BFD_ASSERT (tmp_name
);
316 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
318 myh
= elf_link_hash_lookup
319 (&(hash_table
)->root
, tmp_name
, false, false, true);
322 /* xgettext:c-format */
323 (*_bfd_error_handler
) (_("%s: unable to find ARM glue '%s' for `%s'"),
324 bfd_archive_filename (input_bfd
), tmp_name
, name
);
338 .word func @ behave as if you saw a ARM_32 reloc. */
340 #define ARM2THUMB_GLUE_SIZE 12
341 static const insn32 a2t1_ldr_insn
= 0xe59fc000;
342 static const insn32 a2t2_bx_r12_insn
= 0xe12fff1c;
343 static const insn32 a2t3_func_addr_insn
= 0x00000001;
345 /* Thumb->ARM: Thumb->(non-interworking aware) ARM
349 __func_from_thumb: __func_from_thumb:
351 nop ldr r6, __func_addr
353 __func_change_to_arm: bx r6
355 __func_back_to_thumb:
361 #define THUMB2ARM_GLUE_SIZE 8
362 static const insn16 t2a1_bx_pc_insn
= 0x4778;
363 static const insn16 t2a2_noop_insn
= 0x46c0;
364 static const insn32 t2a3_b_insn
= 0xea000000;
366 static const insn16 t2a1_push_insn
= 0xb540;
367 static const insn16 t2a2_ldr_insn
= 0x4e03;
368 static const insn16 t2a3_mov_insn
= 0x46fe;
369 static const insn16 t2a4_bx_insn
= 0x4730;
370 static const insn32 t2a5_pop_insn
= 0xe8bd4040;
371 static const insn32 t2a6_bx_insn
= 0xe12fff1e;
373 #ifndef ELFARM_NABI_C_INCLUDED
375 bfd_elf32_arm_allocate_interworking_sections (info
)
376 struct bfd_link_info
* info
;
380 struct elf32_arm_link_hash_table
* globals
;
382 globals
= elf32_arm_hash_table (info
);
384 BFD_ASSERT (globals
!= NULL
);
386 if (globals
->arm_glue_size
!= 0)
388 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
390 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
391 ARM2THUMB_GLUE_SECTION_NAME
);
393 BFD_ASSERT (s
!= NULL
);
395 foo
= (bfd_byte
*) bfd_alloc (globals
->bfd_of_glue_owner
,
396 globals
->arm_glue_size
);
398 s
->_raw_size
= s
->_cooked_size
= globals
->arm_glue_size
;
402 if (globals
->thumb_glue_size
!= 0)
404 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
406 s
= bfd_get_section_by_name
407 (globals
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
409 BFD_ASSERT (s
!= NULL
);
411 foo
= (bfd_byte
*) bfd_alloc (globals
->bfd_of_glue_owner
,
412 globals
->thumb_glue_size
);
414 s
->_raw_size
= s
->_cooked_size
= globals
->thumb_glue_size
;
422 record_arm_to_thumb_glue (link_info
, h
)
423 struct bfd_link_info
* link_info
;
424 struct elf_link_hash_entry
* h
;
426 const char * name
= h
->root
.root
.string
;
429 struct elf_link_hash_entry
* myh
;
430 struct bfd_link_hash_entry
* bh
;
431 struct elf32_arm_link_hash_table
* globals
;
434 globals
= elf32_arm_hash_table (link_info
);
436 BFD_ASSERT (globals
!= NULL
);
437 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
439 s
= bfd_get_section_by_name
440 (globals
->bfd_of_glue_owner
, ARM2THUMB_GLUE_SECTION_NAME
);
442 BFD_ASSERT (s
!= NULL
);
444 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
445 + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1);
447 BFD_ASSERT (tmp_name
);
449 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
451 myh
= elf_link_hash_lookup
452 (&(globals
)->root
, tmp_name
, false, false, true);
456 /* We've already seen this guy. */
461 /* The only trick here is using hash_table->arm_glue_size as the value. Even
462 though the section isn't allocated yet, this is where we will be putting
465 val
= globals
->arm_glue_size
+ 1;
466 _bfd_generic_link_add_one_symbol (link_info
, globals
->bfd_of_glue_owner
,
467 tmp_name
, BSF_GLOBAL
, s
, val
,
468 NULL
, true, false, &bh
);
472 globals
->arm_glue_size
+= ARM2THUMB_GLUE_SIZE
;
478 record_thumb_to_arm_glue (link_info
, h
)
479 struct bfd_link_info
*link_info
;
480 struct elf_link_hash_entry
*h
;
482 const char *name
= h
->root
.root
.string
;
485 struct elf_link_hash_entry
*myh
;
486 struct bfd_link_hash_entry
*bh
;
487 struct elf32_arm_link_hash_table
*hash_table
;
491 hash_table
= elf32_arm_hash_table (link_info
);
493 BFD_ASSERT (hash_table
!= NULL
);
494 BFD_ASSERT (hash_table
->bfd_of_glue_owner
!= NULL
);
496 s
= bfd_get_section_by_name
497 (hash_table
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
499 BFD_ASSERT (s
!= NULL
);
501 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
502 + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1);
504 BFD_ASSERT (tmp_name
);
506 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
508 myh
= elf_link_hash_lookup
509 (&(hash_table
)->root
, tmp_name
, false, false, true);
513 /* We've already seen this guy. */
519 val
= hash_table
->thumb_glue_size
+ 1;
520 _bfd_generic_link_add_one_symbol (link_info
, hash_table
->bfd_of_glue_owner
,
521 tmp_name
, BSF_GLOBAL
, s
, val
,
522 NULL
, true, false, &bh
);
524 /* If we mark it 'Thumb', the disassembler will do a better job. */
525 myh
= (struct elf_link_hash_entry
*) bh
;
526 bind
= ELF_ST_BIND (myh
->type
);
527 myh
->type
= ELF_ST_INFO (bind
, STT_ARM_TFUNC
);
531 #define CHANGE_TO_ARM "__%s_change_to_arm"
532 #define BACK_FROM_ARM "__%s_back_from_arm"
534 /* Allocate another symbol to mark where we switch to Arm mode. */
535 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
536 + strlen (CHANGE_TO_ARM
) + 1);
538 BFD_ASSERT (tmp_name
);
540 sprintf (tmp_name
, CHANGE_TO_ARM
, name
);
543 val
= hash_table
->thumb_glue_size
+ 4,
544 _bfd_generic_link_add_one_symbol (link_info
, hash_table
->bfd_of_glue_owner
,
545 tmp_name
, BSF_LOCAL
, s
, val
,
546 NULL
, true, false, &bh
);
550 hash_table
->thumb_glue_size
+= THUMB2ARM_GLUE_SIZE
;
555 /* Add the glue sections to ABFD. This function is called from the
556 linker scripts in ld/emultempl/{armelf}.em. */
559 bfd_elf32_arm_add_glue_sections_to_bfd (abfd
, info
)
561 struct bfd_link_info
*info
;
566 /* If we are only performing a partial
567 link do not bother adding the glue. */
568 if (info
->relocateable
)
571 sec
= bfd_get_section_by_name (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
575 /* Note: we do not include the flag SEC_LINKER_CREATED, as this
576 will prevent elf_link_input_bfd() from processing the contents
578 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_CODE
| SEC_READONLY
;
580 sec
= bfd_make_section (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
583 || !bfd_set_section_flags (abfd
, sec
, flags
)
584 || !bfd_set_section_alignment (abfd
, sec
, 2))
587 /* Set the gc mark to prevent the section from being removed by garbage
588 collection, despite the fact that no relocs refer to this section. */
592 sec
= bfd_get_section_by_name (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
596 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_CODE
| SEC_READONLY
;
598 sec
= bfd_make_section (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
601 || !bfd_set_section_flags (abfd
, sec
, flags
)
602 || !bfd_set_section_alignment (abfd
, sec
, 2))
611 /* Select a BFD to be used to hold the sections used by the glue code.
612 This function is called from the linker scripts in ld/emultempl/
616 bfd_elf32_arm_get_bfd_for_interworking (abfd
, info
)
618 struct bfd_link_info
*info
;
620 struct elf32_arm_link_hash_table
*globals
;
622 /* If we are only performing a partial link
623 do not bother getting a bfd to hold the glue. */
624 if (info
->relocateable
)
627 globals
= elf32_arm_hash_table (info
);
629 BFD_ASSERT (globals
!= NULL
);
631 if (globals
->bfd_of_glue_owner
!= NULL
)
634 /* Save the bfd for later use. */
635 globals
->bfd_of_glue_owner
= abfd
;
641 bfd_elf32_arm_process_before_allocation (abfd
, link_info
, no_pipeline_knowledge
)
643 struct bfd_link_info
*link_info
;
644 int no_pipeline_knowledge
;
646 Elf_Internal_Shdr
*symtab_hdr
;
647 Elf_Internal_Rela
*internal_relocs
= NULL
;
648 Elf_Internal_Rela
*irel
, *irelend
;
649 bfd_byte
*contents
= NULL
;
652 struct elf32_arm_link_hash_table
*globals
;
654 /* If we are only performing a partial link do not bother
655 to construct any glue. */
656 if (link_info
->relocateable
)
659 /* Here we have a bfd that is to be included on the link. We have a hook
660 to do reloc rummaging, before section sizes are nailed down. */
661 globals
= elf32_arm_hash_table (link_info
);
663 BFD_ASSERT (globals
!= NULL
);
664 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
666 globals
->no_pipeline_knowledge
= no_pipeline_knowledge
;
668 /* Rummage around all the relocs and map the glue vectors. */
669 sec
= abfd
->sections
;
674 for (; sec
!= NULL
; sec
= sec
->next
)
676 if (sec
->reloc_count
== 0)
679 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
681 /* Load the relocs. */
683 = _bfd_elf32_link_read_relocs (abfd
, sec
, (PTR
) NULL
,
684 (Elf_Internal_Rela
*) NULL
, false);
686 if (internal_relocs
== NULL
)
689 irelend
= internal_relocs
+ sec
->reloc_count
;
690 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
693 unsigned long r_index
;
695 struct elf_link_hash_entry
*h
;
697 r_type
= ELF32_R_TYPE (irel
->r_info
);
698 r_index
= ELF32_R_SYM (irel
->r_info
);
700 /* These are the only relocation types we care about. */
701 if ( r_type
!= R_ARM_PC24
702 && r_type
!= R_ARM_THM_PC22
)
705 /* Get the section contents if we haven't done so already. */
706 if (contents
== NULL
)
708 /* Get cached copy if it exists. */
709 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
710 contents
= elf_section_data (sec
)->this_hdr
.contents
;
713 /* Go get them off disk. */
714 contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
715 if (contents
== NULL
)
718 if (!bfd_get_section_contents (abfd
, sec
, contents
,
719 (file_ptr
) 0, sec
->_raw_size
))
724 /* If the relocation is not against a symbol it cannot concern us. */
727 /* We don't care about local symbols. */
728 if (r_index
< symtab_hdr
->sh_info
)
731 /* This is an external symbol. */
732 r_index
-= symtab_hdr
->sh_info
;
733 h
= (struct elf_link_hash_entry
*)
734 elf_sym_hashes (abfd
)[r_index
];
736 /* If the relocation is against a static symbol it must be within
737 the current section and so cannot be a cross ARM/Thumb relocation. */
744 /* This one is a call from arm code. We need to look up
745 the target of the call. If it is a thumb target, we
747 if (ELF_ST_TYPE(h
->type
) == STT_ARM_TFUNC
)
748 record_arm_to_thumb_glue (link_info
, h
);
752 /* This one is a call from thumb code. We look
753 up the target of the call. If it is not a thumb
754 target, we insert glue. */
755 if (ELF_ST_TYPE (h
->type
) != STT_ARM_TFUNC
)
756 record_thumb_to_arm_glue (link_info
, h
);
765 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
769 if (internal_relocs
!= NULL
770 && elf_section_data (sec
)->relocs
!= internal_relocs
)
771 free (internal_relocs
);
772 internal_relocs
= NULL
;
779 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
781 if (internal_relocs
!= NULL
782 && elf_section_data (sec
)->relocs
!= internal_relocs
)
783 free (internal_relocs
);
789 /* The thumb form of a long branch is a bit finicky, because the offset
790 encoding is split over two fields, each in it's own instruction. They
791 can occur in any order. So given a thumb form of long branch, and an
792 offset, insert the offset into the thumb branch and return finished
795 It takes two thumb instructions to encode the target address. Each has
796 11 bits to invest. The upper 11 bits are stored in one (identifed by
797 H-0.. see below), the lower 11 bits are stored in the other (identified
800 Combine together and shifted left by 1 (it's a half word address) and
804 H-0, upper address-0 = 000
806 H-1, lower address-0 = 800
808 They can be ordered either way, but the arm tools I've seen always put
809 the lower one first. It probably doesn't matter. krk@cygnus.com
811 XXX: Actually the order does matter. The second instruction (H-1)
812 moves the computed address into the PC, so it must be the second one
813 in the sequence. The problem, however is that whilst little endian code
814 stores the instructions in HI then LOW order, big endian code does the
815 reverse. nickc@cygnus.com. */
817 #define LOW_HI_ORDER 0xF800F000
818 #define HI_LOW_ORDER 0xF000F800
821 insert_thumb_branch (br_insn
, rel_off
)
825 unsigned int low_bits
;
826 unsigned int high_bits
;
828 BFD_ASSERT ((rel_off
& 1) != 1);
830 rel_off
>>= 1; /* Half word aligned address. */
831 low_bits
= rel_off
& 0x000007FF; /* The bottom 11 bits. */
832 high_bits
= (rel_off
>> 11) & 0x000007FF; /* The top 11 bits. */
834 if ((br_insn
& LOW_HI_ORDER
) == LOW_HI_ORDER
)
835 br_insn
= LOW_HI_ORDER
| (low_bits
<< 16) | high_bits
;
836 else if ((br_insn
& HI_LOW_ORDER
) == HI_LOW_ORDER
)
837 br_insn
= HI_LOW_ORDER
| (high_bits
<< 16) | low_bits
;
839 /* FIXME: abort is probably not the right call. krk@cygnus.com */
840 abort (); /* error - not a valid branch instruction form. */
845 /* Thumb code calling an ARM function. */
848 elf32_thumb_to_arm_stub (info
, name
, input_bfd
, output_bfd
, input_section
,
849 hit_data
, sym_sec
, offset
, addend
, val
)
850 struct bfd_link_info
* info
;
854 asection
* input_section
;
858 bfd_signed_vma addend
;
863 unsigned long int tmp
;
865 struct elf_link_hash_entry
* myh
;
866 struct elf32_arm_link_hash_table
* globals
;
868 myh
= find_thumb_glue (info
, name
, input_bfd
);
872 globals
= elf32_arm_hash_table (info
);
874 BFD_ASSERT (globals
!= NULL
);
875 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
877 my_offset
= myh
->root
.u
.def
.value
;
879 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
880 THUMB2ARM_GLUE_SECTION_NAME
);
882 BFD_ASSERT (s
!= NULL
);
883 BFD_ASSERT (s
->contents
!= NULL
);
884 BFD_ASSERT (s
->output_section
!= NULL
);
886 if ((my_offset
& 0x01) == 0x01)
889 && sym_sec
->owner
!= NULL
890 && !INTERWORK_FLAG (sym_sec
->owner
))
892 (*_bfd_error_handler
)
893 (_("%s(%s): warning: interworking not enabled."),
894 bfd_archive_filename (sym_sec
->owner
), name
);
895 (*_bfd_error_handler
)
896 (_(" first occurrence: %s: thumb call to arm"),
897 bfd_archive_filename (input_bfd
));
903 myh
->root
.u
.def
.value
= my_offset
;
905 bfd_put_16 (output_bfd
, (bfd_vma
) t2a1_bx_pc_insn
,
906 s
->contents
+ my_offset
);
908 bfd_put_16 (output_bfd
, (bfd_vma
) t2a2_noop_insn
,
909 s
->contents
+ my_offset
+ 2);
912 /* Address of destination of the stub. */
913 ((bfd_signed_vma
) val
)
915 /* Offset from the start of the current section to the start of the stubs. */
917 /* Offset of the start of this stub from the start of the stubs. */
919 /* Address of the start of the current section. */
920 + s
->output_section
->vma
)
921 /* The branch instruction is 4 bytes into the stub. */
923 /* ARM branches work from the pc of the instruction + 8. */
926 bfd_put_32 (output_bfd
,
927 (bfd_vma
) t2a3_b_insn
| ((ret_offset
>> 2) & 0x00FFFFFF),
928 s
->contents
+ my_offset
+ 4);
931 BFD_ASSERT (my_offset
<= globals
->thumb_glue_size
);
933 /* Now go back and fix up the original BL insn to point
935 ret_offset
= (s
->output_offset
937 - (input_section
->output_offset
941 tmp
= bfd_get_32 (input_bfd
, hit_data
942 - input_section
->vma
);
944 bfd_put_32 (output_bfd
,
945 (bfd_vma
) insert_thumb_branch (tmp
, ret_offset
),
946 hit_data
- input_section
->vma
);
951 /* Arm code calling a Thumb function. */
954 elf32_arm_to_thumb_stub (info
, name
, input_bfd
, output_bfd
, input_section
,
955 hit_data
, sym_sec
, offset
, addend
, val
)
956 struct bfd_link_info
* info
;
960 asection
* input_section
;
964 bfd_signed_vma addend
;
967 unsigned long int tmp
;
971 struct elf_link_hash_entry
* myh
;
972 struct elf32_arm_link_hash_table
* globals
;
974 myh
= find_arm_glue (info
, name
, input_bfd
);
978 globals
= elf32_arm_hash_table (info
);
980 BFD_ASSERT (globals
!= NULL
);
981 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
983 my_offset
= myh
->root
.u
.def
.value
;
984 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
985 ARM2THUMB_GLUE_SECTION_NAME
);
986 BFD_ASSERT (s
!= NULL
);
987 BFD_ASSERT (s
->contents
!= NULL
);
988 BFD_ASSERT (s
->output_section
!= NULL
);
990 if ((my_offset
& 0x01) == 0x01)
993 && sym_sec
->owner
!= NULL
994 && !INTERWORK_FLAG (sym_sec
->owner
))
996 (*_bfd_error_handler
)
997 (_("%s(%s): warning: interworking not enabled."),
998 bfd_archive_filename (sym_sec
->owner
), name
);
999 (*_bfd_error_handler
)
1000 (_(" first occurrence: %s: arm call to thumb"),
1001 bfd_archive_filename (input_bfd
));
1005 myh
->root
.u
.def
.value
= my_offset
;
1007 bfd_put_32 (output_bfd
, (bfd_vma
) a2t1_ldr_insn
,
1008 s
->contents
+ my_offset
);
1010 bfd_put_32 (output_bfd
, (bfd_vma
) a2t2_bx_r12_insn
,
1011 s
->contents
+ my_offset
+ 4);
1013 /* It's a thumb address. Add the low order bit. */
1014 bfd_put_32 (output_bfd
, val
| a2t3_func_addr_insn
,
1015 s
->contents
+ my_offset
+ 8);
1018 BFD_ASSERT (my_offset
<= globals
->arm_glue_size
);
1020 tmp
= bfd_get_32 (input_bfd
, hit_data
);
1021 tmp
= tmp
& 0xFF000000;
1023 /* Somehow these are both 4 too far, so subtract 8. */
1024 ret_offset
= (s
->output_offset
1026 + s
->output_section
->vma
1027 - (input_section
->output_offset
1028 + input_section
->output_section
->vma
1032 tmp
= tmp
| ((ret_offset
>> 2) & 0x00FFFFFF);
1034 bfd_put_32 (output_bfd
, (bfd_vma
) tmp
, hit_data
- input_section
->vma
);
1039 /* Perform a relocation as part of a final link. */
1041 static bfd_reloc_status_type
1042 elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
1043 input_section
, contents
, rel
, value
,
1044 info
, sym_sec
, sym_name
, sym_flags
, h
)
1045 reloc_howto_type
* howto
;
1048 asection
* input_section
;
1049 bfd_byte
* contents
;
1050 Elf_Internal_Rela
* rel
;
1052 struct bfd_link_info
* info
;
1054 const char * sym_name
;
1056 struct elf_link_hash_entry
* h
;
1058 unsigned long r_type
= howto
->type
;
1059 unsigned long r_symndx
;
1060 bfd_byte
* hit_data
= contents
+ rel
->r_offset
;
1061 bfd
* dynobj
= NULL
;
1062 Elf_Internal_Shdr
* symtab_hdr
;
1063 struct elf_link_hash_entry
** sym_hashes
;
1064 bfd_vma
* local_got_offsets
;
1065 asection
* sgot
= NULL
;
1066 asection
* splt
= NULL
;
1067 asection
* sreloc
= NULL
;
1069 bfd_signed_vma signed_addend
;
1070 struct elf32_arm_link_hash_table
* globals
;
1072 /* If the start address has been set, then set the EF_ARM_HASENTRY
1073 flag. Setting this more than once is redundant, but the cost is
1074 not too high, and it keeps the code simple.
1076 The test is done here, rather than somewhere else, because the
1077 start address is only set just before the final link commences.
1079 Note - if the user deliberately sets a start address of 0, the
1080 flag will not be set. */
1081 if (bfd_get_start_address (output_bfd
) != 0)
1082 elf_elfheader (output_bfd
)->e_flags
|= EF_ARM_HASENTRY
;
1084 globals
= elf32_arm_hash_table (info
);
1086 dynobj
= elf_hash_table (info
)->dynobj
;
1089 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1090 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1092 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1093 sym_hashes
= elf_sym_hashes (input_bfd
);
1094 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1095 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1098 addend
= bfd_get_32 (input_bfd
, hit_data
) & howto
->src_mask
;
1100 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1103 signed_addend
&= ~ howto
->src_mask
;
1104 signed_addend
|= addend
;
1107 signed_addend
= addend
;
1109 addend
= signed_addend
= rel
->r_addend
;
1115 return bfd_reloc_ok
;
1123 /* When generating a shared object, these relocations are copied
1124 into the output file to be resolved at run time. */
1127 && (r_type
!= R_ARM_PC24
1130 && (! info
->symbolic
1131 || (h
->elf_link_hash_flags
1132 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1134 Elf_Internal_Rel outrel
;
1135 boolean skip
, relocate
;
1141 name
= (bfd_elf_string_from_elf_section
1143 elf_elfheader (input_bfd
)->e_shstrndx
,
1144 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1146 return bfd_reloc_notsupported
;
1148 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
1149 && strcmp (bfd_get_section_name (input_bfd
,
1153 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1154 BFD_ASSERT (sreloc
!= NULL
);
1161 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
1163 if (outrel
.r_offset
== (bfd_vma
) -1)
1165 else if (outrel
.r_offset
== (bfd_vma
) -2)
1166 skip
= true, relocate
= true;
1167 outrel
.r_offset
+= (input_section
->output_section
->vma
1168 + input_section
->output_offset
);
1171 memset (&outrel
, 0, sizeof outrel
);
1172 else if (r_type
== R_ARM_PC24
)
1174 BFD_ASSERT (h
!= NULL
&& h
->dynindx
!= -1);
1175 if ((input_section
->flags
& SEC_ALLOC
) == 0)
1177 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_PC24
);
1182 || ((info
->symbolic
|| h
->dynindx
== -1)
1183 && (h
->elf_link_hash_flags
1184 & ELF_LINK_HASH_DEF_REGULAR
) != 0))
1187 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1191 BFD_ASSERT (h
->dynindx
!= -1);
1192 if ((input_section
->flags
& SEC_ALLOC
) == 0)
1194 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_ABS32
);
1198 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1199 (((Elf32_External_Rel
*)
1201 + sreloc
->reloc_count
));
1202 ++sreloc
->reloc_count
;
1204 /* If this reloc is against an external symbol, we do not want to
1205 fiddle with the addend. Otherwise, we need to include the symbol
1206 value so that it becomes an addend for the dynamic reloc. */
1208 return bfd_reloc_ok
;
1210 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1211 contents
, rel
->r_offset
, value
,
1214 else switch (r_type
)
1217 case R_ARM_XPC25
: /* Arm BLX instruction. */
1219 case R_ARM_PC24
: /* Arm B/BL instruction */
1221 if (r_type
== R_ARM_XPC25
)
1223 /* Check for Arm calling Arm function. */
1224 /* FIXME: Should we translate the instruction into a BL
1225 instruction instead ? */
1226 if (sym_flags
!= STT_ARM_TFUNC
)
1227 (*_bfd_error_handler
) (_("\
1228 %s: Warning: Arm BLX instruction targets Arm function '%s'."),
1229 bfd_archive_filename (input_bfd
),
1230 h
? h
->root
.root
.string
: "(local)");
1235 /* Check for Arm calling Thumb function. */
1236 if (sym_flags
== STT_ARM_TFUNC
)
1238 elf32_arm_to_thumb_stub (info
, sym_name
, input_bfd
, output_bfd
,
1239 input_section
, hit_data
, sym_sec
, rel
->r_offset
,
1240 signed_addend
, value
);
1241 return bfd_reloc_ok
;
1245 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1246 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0)
1248 /* The old way of doing things. Trearing the addend as a
1249 byte sized field and adding in the pipeline offset. */
1250 value
-= (input_section
->output_section
->vma
1251 + input_section
->output_offset
);
1252 value
-= rel
->r_offset
;
1255 if (! globals
->no_pipeline_knowledge
)
1260 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
1262 S is the address of the symbol in the relocation.
1263 P is address of the instruction being relocated.
1264 A is the addend (extracted from the instruction) in bytes.
1266 S is held in 'value'.
1267 P is the base address of the section containing the instruction
1268 plus the offset of the reloc into that section, ie:
1269 (input_section->output_section->vma +
1270 input_section->output_offset +
1272 A is the addend, converted into bytes, ie:
1275 Note: None of these operations have knowledge of the pipeline
1276 size of the processor, thus it is up to the assembler to encode
1277 this information into the addend. */
1278 value
-= (input_section
->output_section
->vma
1279 + input_section
->output_offset
);
1280 value
-= rel
->r_offset
;
1281 value
+= (signed_addend
<< howto
->size
);
1283 /* Previous versions of this code also used to add in the pipeline
1284 offset here. This is wrong because the linker is not supposed
1285 to know about such things, and one day it might change. In order
1286 to support old binaries that need the old behaviour however, so
1287 we attempt to detect which ABI was used to create the reloc. */
1288 if (! globals
->no_pipeline_knowledge
)
1290 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form */
1292 i_ehdrp
= elf_elfheader (input_bfd
);
1294 if (i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1299 signed_addend
= value
;
1300 signed_addend
>>= howto
->rightshift
;
1302 /* It is not an error for an undefined weak reference to be
1303 out of range. Any program that branches to such a symbol
1304 is going to crash anyway, so there is no point worrying
1305 about getting the destination exactly right. */
1306 if (! h
|| h
->root
.type
!= bfd_link_hash_undefweak
)
1308 /* Perform a signed range check. */
1309 if ( signed_addend
> ((bfd_signed_vma
) (howto
->dst_mask
>> 1))
1310 || signed_addend
< - ((bfd_signed_vma
) ((howto
->dst_mask
+ 1) >> 1)))
1311 return bfd_reloc_overflow
;
1315 /* If necessary set the H bit in the BLX instruction. */
1316 if (r_type
== R_ARM_XPC25
&& ((value
& 2) == 2))
1317 value
= (signed_addend
& howto
->dst_mask
)
1318 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
))
1322 value
= (signed_addend
& howto
->dst_mask
)
1323 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1328 if (sym_flags
== STT_ARM_TFUNC
)
1333 value
-= (input_section
->output_section
->vma
1334 + input_section
->output_offset
+ rel
->r_offset
);
1339 bfd_put_32 (input_bfd
, value
, hit_data
);
1340 return bfd_reloc_ok
;
1344 if ((long) value
> 0x7f || (long) value
< -0x80)
1345 return bfd_reloc_overflow
;
1347 bfd_put_8 (input_bfd
, value
, hit_data
);
1348 return bfd_reloc_ok
;
1353 if ((long) value
> 0x7fff || (long) value
< -0x8000)
1354 return bfd_reloc_overflow
;
1356 bfd_put_16 (input_bfd
, value
, hit_data
);
1357 return bfd_reloc_ok
;
1360 /* Support ldr and str instruction for the arm */
1361 /* Also thumb b (unconditional branch). ??? Really? */
1364 if ((long) value
> 0x7ff || (long) value
< -0x800)
1365 return bfd_reloc_overflow
;
1367 value
|= (bfd_get_32 (input_bfd
, hit_data
) & 0xfffff000);
1368 bfd_put_32 (input_bfd
, value
, hit_data
);
1369 return bfd_reloc_ok
;
1371 case R_ARM_THM_ABS5
:
1372 /* Support ldr and str instructions for the thumb. */
1374 /* Need to refetch addend. */
1375 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1376 /* ??? Need to determine shift amount from operand size. */
1377 addend
>>= howto
->rightshift
;
1381 /* ??? Isn't value unsigned? */
1382 if ((long) value
> 0x1f || (long) value
< -0x10)
1383 return bfd_reloc_overflow
;
1385 /* ??? Value needs to be properly shifted into place first. */
1386 value
|= bfd_get_16 (input_bfd
, hit_data
) & 0xf83f;
1387 bfd_put_16 (input_bfd
, value
, hit_data
);
1388 return bfd_reloc_ok
;
1391 case R_ARM_THM_XPC22
:
1393 case R_ARM_THM_PC22
:
1394 /* Thumb BL (branch long instruction). */
1397 boolean overflow
= false;
1398 bfd_vma upper_insn
= bfd_get_16 (input_bfd
, hit_data
);
1399 bfd_vma lower_insn
= bfd_get_16 (input_bfd
, hit_data
+ 2);
1400 bfd_signed_vma reloc_signed_max
= ((1 << (howto
->bitsize
- 1)) - 1) >> howto
->rightshift
;
1401 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1403 bfd_signed_vma signed_check
;
1406 /* Need to refetch the addend and squish the two 11 bit pieces
1409 bfd_vma upper
= upper_insn
& 0x7ff;
1410 bfd_vma lower
= lower_insn
& 0x7ff;
1411 upper
= (upper
^ 0x400) - 0x400; /* Sign extend. */
1412 addend
= (upper
<< 12) | (lower
<< 1);
1413 signed_addend
= addend
;
1417 if (r_type
== R_ARM_THM_XPC22
)
1419 /* Check for Thumb to Thumb call. */
1420 /* FIXME: Should we translate the instruction into a BL
1421 instruction instead ? */
1422 if (sym_flags
== STT_ARM_TFUNC
)
1423 (*_bfd_error_handler
) (_("\
1424 %s: Warning: Thumb BLX instruction targets thumb function '%s'."),
1425 bfd_archive_filename (input_bfd
),
1426 h
? h
->root
.root
.string
: "(local)");
1431 /* If it is not a call to Thumb, assume call to Arm.
1432 If it is a call relative to a section name, then it is not a
1433 function call at all, but rather a long jump. */
1434 if (sym_flags
!= STT_ARM_TFUNC
&& sym_flags
!= STT_SECTION
)
1436 if (elf32_thumb_to_arm_stub
1437 (info
, sym_name
, input_bfd
, output_bfd
, input_section
,
1438 hit_data
, sym_sec
, rel
->r_offset
, signed_addend
, value
))
1439 return bfd_reloc_ok
;
1441 return bfd_reloc_dangerous
;
1445 relocation
= value
+ signed_addend
;
1447 relocation
-= (input_section
->output_section
->vma
1448 + input_section
->output_offset
1451 if (! globals
->no_pipeline_knowledge
)
1453 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form. */
1455 i_ehdrp
= elf_elfheader (input_bfd
);
1457 /* Previous versions of this code also used to add in the pipline
1458 offset here. This is wrong because the linker is not supposed
1459 to know about such things, and one day it might change. In order
1460 to support old binaries that need the old behaviour however, so
1461 we attempt to detect which ABI was used to create the reloc. */
1462 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1463 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0
1464 || i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1468 check
= relocation
>> howto
->rightshift
;
1470 /* If this is a signed value, the rightshift just dropped
1471 leading 1 bits (assuming twos complement). */
1472 if ((bfd_signed_vma
) relocation
>= 0)
1473 signed_check
= check
;
1475 signed_check
= check
| ~((bfd_vma
) -1 >> howto
->rightshift
);
1477 /* Assumes two's complement. */
1478 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1482 if (r_type
== R_ARM_THM_XPC22
1483 && ((lower_insn
& 0x1800) == 0x0800))
1484 /* For a BLX instruction, make sure that the relocation is rounded up
1485 to a word boundary. This follows the semantics of the instruction
1486 which specifies that bit 1 of the target address will come from bit
1487 1 of the base address. */
1488 relocation
= (relocation
+ 2) & ~ 3;
1490 /* Put RELOCATION back into the insn. */
1491 upper_insn
= (upper_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 12) & 0x7ff);
1492 lower_insn
= (lower_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 1) & 0x7ff);
1494 /* Put the relocated value back in the object file: */
1495 bfd_put_16 (input_bfd
, upper_insn
, hit_data
);
1496 bfd_put_16 (input_bfd
, lower_insn
, hit_data
+ 2);
1498 return (overflow
? bfd_reloc_overflow
: bfd_reloc_ok
);
1502 case R_ARM_THM_PC11
:
1503 /* Thumb B (branch) instruction). */
1505 bfd_signed_vma relocation
;
1506 bfd_signed_vma reloc_signed_max
= (1 << (howto
->bitsize
- 1)) - 1;
1507 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1508 bfd_signed_vma signed_check
;
1511 /* Need to refetch addend. */
1512 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1513 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1516 signed_addend
&= ~ howto
->src_mask
;
1517 signed_addend
|= addend
;
1520 signed_addend
= addend
;
1521 /* The value in the insn has been right shifted. We need to
1522 undo this, so that we can perform the address calculation
1523 in terms of bytes. */
1524 signed_addend
<<= howto
->rightshift
;
1526 relocation
= value
+ signed_addend
;
1528 relocation
-= (input_section
->output_section
->vma
1529 + input_section
->output_offset
1532 relocation
>>= howto
->rightshift
;
1533 signed_check
= relocation
;
1534 relocation
&= howto
->dst_mask
;
1535 relocation
|= (bfd_get_16 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1537 bfd_put_16 (input_bfd
, relocation
, hit_data
);
1539 /* Assumes two's complement. */
1540 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1541 return bfd_reloc_overflow
;
1543 return bfd_reloc_ok
;
1546 case R_ARM_GNU_VTINHERIT
:
1547 case R_ARM_GNU_VTENTRY
:
1548 return bfd_reloc_ok
;
1551 return bfd_reloc_notsupported
;
1553 case R_ARM_GLOB_DAT
:
1554 return bfd_reloc_notsupported
;
1556 case R_ARM_JUMP_SLOT
:
1557 return bfd_reloc_notsupported
;
1559 case R_ARM_RELATIVE
:
1560 return bfd_reloc_notsupported
;
1563 /* Relocation is relative to the start of the
1564 global offset table. */
1566 BFD_ASSERT (sgot
!= NULL
);
1568 return bfd_reloc_notsupported
;
1570 /* If we are addressing a Thumb function, we need to adjust the
1571 address by one, so that attempts to call the function pointer will
1572 correctly interpret it as Thumb code. */
1573 if (sym_flags
== STT_ARM_TFUNC
)
1576 /* Note that sgot->output_offset is not involved in this
1577 calculation. We always want the start of .got. If we
1578 define _GLOBAL_OFFSET_TABLE in a different way, as is
1579 permitted by the ABI, we might have to change this
1581 value
-= sgot
->output_section
->vma
;
1582 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1583 contents
, rel
->r_offset
, value
,
1587 /* Use global offset table as symbol value. */
1588 BFD_ASSERT (sgot
!= NULL
);
1591 return bfd_reloc_notsupported
;
1593 value
= sgot
->output_section
->vma
;
1594 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1595 contents
, rel
->r_offset
, value
,
1599 /* Relocation is to the entry for this symbol in the
1600 global offset table. */
1602 return bfd_reloc_notsupported
;
1608 off
= h
->got
.offset
;
1609 BFD_ASSERT (off
!= (bfd_vma
) -1);
1611 if (!elf_hash_table (info
)->dynamic_sections_created
||
1612 (info
->shared
&& (info
->symbolic
|| h
->dynindx
== -1)
1613 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1615 /* This is actually a static link, or it is a -Bsymbolic link
1616 and the symbol is defined locally. We must initialize this
1617 entry in the global offset table. Since the offset must
1618 always be a multiple of 4, we use the least significant bit
1619 to record whether we have initialized it already.
1621 When doing a dynamic link, we create a .rel.got relocation
1622 entry to initialize the value. This is done in the
1623 finish_dynamic_symbol routine. */
1628 /* If we are addressing a Thumb function, we need to
1629 adjust the address by one, so that attempts to
1630 call the function pointer will correctly
1631 interpret it as Thumb code. */
1632 if (sym_flags
== STT_ARM_TFUNC
)
1635 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1640 value
= sgot
->output_offset
+ off
;
1646 BFD_ASSERT (local_got_offsets
!= NULL
&&
1647 local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1649 off
= local_got_offsets
[r_symndx
];
1651 /* The offset must always be a multiple of 4. We use the
1652 least significant bit to record whether we have already
1653 generated the necessary reloc. */
1658 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1663 Elf_Internal_Rel outrel
;
1665 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
1666 BFD_ASSERT (srelgot
!= NULL
);
1668 outrel
.r_offset
= (sgot
->output_section
->vma
1669 + sgot
->output_offset
1671 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1672 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1673 (((Elf32_External_Rel
*)
1675 + srelgot
->reloc_count
));
1676 ++srelgot
->reloc_count
;
1679 local_got_offsets
[r_symndx
] |= 1;
1682 value
= sgot
->output_offset
+ off
;
1685 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1686 contents
, rel
->r_offset
, value
,
1690 /* Relocation is to the entry for this symbol in the
1691 procedure linkage table. */
1693 /* Resolve a PLT32 reloc against a local symbol directly,
1694 without using the procedure linkage table. */
1696 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1697 contents
, rel
->r_offset
, value
,
1700 if (h
->plt
.offset
== (bfd_vma
) -1)
1701 /* We didn't make a PLT entry for this symbol. This
1702 happens when statically linking PIC code, or when
1703 using -Bsymbolic. */
1704 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1705 contents
, rel
->r_offset
, value
,
1708 BFD_ASSERT(splt
!= NULL
);
1710 return bfd_reloc_notsupported
;
1712 value
= (splt
->output_section
->vma
1713 + splt
->output_offset
1715 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1716 contents
, rel
->r_offset
, value
,
1720 return bfd_reloc_notsupported
;
1722 case R_ARM_AMP_VCALL9
:
1723 return bfd_reloc_notsupported
;
1725 case R_ARM_RSBREL32
:
1726 return bfd_reloc_notsupported
;
1728 case R_ARM_THM_RPC22
:
1729 return bfd_reloc_notsupported
;
1732 return bfd_reloc_notsupported
;
1735 return bfd_reloc_notsupported
;
1738 return bfd_reloc_notsupported
;
1741 return bfd_reloc_notsupported
;
1744 return bfd_reloc_notsupported
;
1749 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
1751 arm_add_to_rel (abfd
, address
, howto
, increment
)
1754 reloc_howto_type
* howto
;
1755 bfd_signed_vma increment
;
1757 bfd_signed_vma addend
;
1759 if (howto
->type
== R_ARM_THM_PC22
)
1761 int upper_insn
, lower_insn
;
1764 upper_insn
= bfd_get_16 (abfd
, address
);
1765 lower_insn
= bfd_get_16 (abfd
, address
+ 2);
1766 upper
= upper_insn
& 0x7ff;
1767 lower
= lower_insn
& 0x7ff;
1769 addend
= (upper
<< 12) | (lower
<< 1);
1770 addend
+= increment
;
1773 upper_insn
= (upper_insn
& 0xf800) | ((addend
>> 11) & 0x7ff);
1774 lower_insn
= (lower_insn
& 0xf800) | (addend
& 0x7ff);
1776 bfd_put_16 (abfd
, (bfd_vma
) upper_insn
, address
);
1777 bfd_put_16 (abfd
, (bfd_vma
) lower_insn
, address
+ 2);
1783 contents
= bfd_get_32 (abfd
, address
);
1785 /* Get the (signed) value from the instruction. */
1786 addend
= contents
& howto
->src_mask
;
1787 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1789 bfd_signed_vma mask
;
1792 mask
&= ~ howto
->src_mask
;
1796 /* Add in the increment, (which is a byte value). */
1797 switch (howto
->type
)
1800 addend
+= increment
;
1804 addend
<<= howto
->size
;
1805 addend
+= increment
;
1807 /* Should we check for overflow here ? */
1809 /* Drop any undesired bits. */
1810 addend
>>= howto
->rightshift
;
1814 contents
= (contents
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
1816 bfd_put_32 (abfd
, contents
, address
);
1819 #endif /* USE_REL */
1821 /* Relocate an ARM ELF section. */
1823 elf32_arm_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1824 contents
, relocs
, local_syms
, local_sections
)
1826 struct bfd_link_info
* info
;
1828 asection
* input_section
;
1829 bfd_byte
* contents
;
1830 Elf_Internal_Rela
* relocs
;
1831 Elf_Internal_Sym
* local_syms
;
1832 asection
** local_sections
;
1834 Elf_Internal_Shdr
* symtab_hdr
;
1835 struct elf_link_hash_entry
** sym_hashes
;
1836 Elf_Internal_Rela
* rel
;
1837 Elf_Internal_Rela
* relend
;
1841 if (info
->relocateable
)
1845 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1846 sym_hashes
= elf_sym_hashes (input_bfd
);
1849 relend
= relocs
+ input_section
->reloc_count
;
1850 for (; rel
< relend
; rel
++)
1853 reloc_howto_type
* howto
;
1854 unsigned long r_symndx
;
1855 Elf_Internal_Sym
* sym
;
1857 struct elf_link_hash_entry
* h
;
1859 bfd_reloc_status_type r
;
1862 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1863 r_type
= ELF32_R_TYPE (rel
->r_info
);
1865 if ( r_type
== R_ARM_GNU_VTENTRY
1866 || r_type
== R_ARM_GNU_VTINHERIT
)
1870 elf32_arm_info_to_howto (input_bfd
, & bfd_reloc
,
1871 (Elf_Internal_Rel
*) rel
);
1873 elf32_arm_info_to_howto (input_bfd
, & bfd_reloc
, rel
);
1875 howto
= bfd_reloc
.howto
;
1878 if (info
->relocateable
)
1880 /* This is a relocateable link. We don't have to change
1881 anything, unless the reloc is against a section symbol,
1882 in which case we have to adjust according to where the
1883 section symbol winds up in the output section. */
1884 if (r_symndx
< symtab_hdr
->sh_info
)
1886 sym
= local_syms
+ r_symndx
;
1887 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1889 sec
= local_sections
[r_symndx
];
1890 arm_add_to_rel (input_bfd
, contents
+ rel
->r_offset
,
1892 (bfd_signed_vma
) (sec
->output_offset
1901 /* This is a final link. */
1906 if (r_symndx
< symtab_hdr
->sh_info
)
1908 sym
= local_syms
+ r_symndx
;
1909 sec
= local_sections
[r_symndx
];
1911 relocation
= (sec
->output_section
->vma
1912 + sec
->output_offset
1914 if ((sec
->flags
& SEC_MERGE
)
1915 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1918 bfd_vma addend
, value
;
1920 if (howto
->rightshift
)
1922 (*_bfd_error_handler
)
1923 (_("%s(%s+0x%lx): %s relocation against SEC_MERGE section"),
1924 bfd_archive_filename (input_bfd
),
1925 bfd_get_section_name (input_bfd
, input_section
),
1926 (long) rel
->r_offset
, howto
->name
);
1930 value
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1932 /* Get the (signed) value from the instruction. */
1933 addend
= value
& howto
->src_mask
;
1934 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1936 bfd_signed_vma mask
;
1939 mask
&= ~ howto
->src_mask
;
1944 _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
)
1946 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
1947 value
= (value
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
1948 bfd_put_32 (input_bfd
, value
, contents
+ rel
->r_offset
);
1951 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, sec
, rel
);
1956 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1958 while ( h
->root
.type
== bfd_link_hash_indirect
1959 || h
->root
.type
== bfd_link_hash_warning
)
1960 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1962 if ( h
->root
.type
== bfd_link_hash_defined
1963 || h
->root
.type
== bfd_link_hash_defweak
)
1965 int relocation_needed
= 1;
1967 sec
= h
->root
.u
.def
.section
;
1969 /* In these cases, we don't need the relocation value.
1970 We check specially because in some obscure cases
1971 sec->output_section will be NULL. */
1976 case R_ARM_THM_PC22
:
1979 (!info
->symbolic
&& h
->dynindx
!= -1)
1980 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1982 && ((input_section
->flags
& SEC_ALLOC
) != 0
1983 /* DWARF will emit R_ARM_ABS32 relocations in its
1984 sections against symbols defined externally
1985 in shared libraries. We can't do anything
1987 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
1988 && (h
->elf_link_hash_flags
1989 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
1991 relocation_needed
= 0;
1995 relocation_needed
= 0;
1999 if (elf_hash_table(info
)->dynamic_sections_created
2001 || (!info
->symbolic
&& h
->dynindx
!= -1)
2002 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2005 relocation_needed
= 0;
2009 if (h
->plt
.offset
!= (bfd_vma
)-1)
2010 relocation_needed
= 0;
2014 if (sec
->output_section
== NULL
)
2016 (*_bfd_error_handler
)
2017 (_("%s: warning: unresolvable relocation %d against symbol `%s' from %s section"),
2018 bfd_archive_filename (input_bfd
),
2020 h
->root
.root
.string
,
2021 bfd_get_section_name (input_bfd
, input_section
));
2022 relocation_needed
= 0;
2026 if (relocation_needed
)
2027 relocation
= h
->root
.u
.def
.value
2028 + sec
->output_section
->vma
2029 + sec
->output_offset
;
2033 else if (h
->root
.type
== bfd_link_hash_undefweak
)
2035 else if (info
->shared
&& !info
->symbolic
2036 && !info
->no_undefined
2037 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
2041 if (!((*info
->callbacks
->undefined_symbol
)
2042 (info
, h
->root
.root
.string
, input_bfd
,
2043 input_section
, rel
->r_offset
,
2044 (!info
->shared
|| info
->no_undefined
2045 || ELF_ST_VISIBILITY (h
->other
)))))
2052 name
= h
->root
.root
.string
;
2055 name
= (bfd_elf_string_from_elf_section
2056 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2057 if (name
== NULL
|| *name
== '\0')
2058 name
= bfd_section_name (input_bfd
, sec
);
2061 r
= elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
2062 input_section
, contents
, rel
,
2063 relocation
, info
, sec
, name
,
2064 (h
? ELF_ST_TYPE (h
->type
) :
2065 ELF_ST_TYPE (sym
->st_info
)), h
);
2067 if (r
!= bfd_reloc_ok
)
2069 const char * msg
= (const char *) 0;
2073 case bfd_reloc_overflow
:
2074 /* If the overflowing reloc was to an undefined symbol,
2075 we have already printed one error message and there
2076 is no point complaining again. */
2078 h
->root
.type
!= bfd_link_hash_undefined
)
2079 && (!((*info
->callbacks
->reloc_overflow
)
2080 (info
, name
, howto
->name
, (bfd_vma
) 0,
2081 input_bfd
, input_section
, rel
->r_offset
))))
2085 case bfd_reloc_undefined
:
2086 if (!((*info
->callbacks
->undefined_symbol
)
2087 (info
, name
, input_bfd
, input_section
,
2088 rel
->r_offset
, true)))
2092 case bfd_reloc_outofrange
:
2093 msg
= _("internal error: out of range error");
2096 case bfd_reloc_notsupported
:
2097 msg
= _("internal error: unsupported relocation error");
2100 case bfd_reloc_dangerous
:
2101 msg
= _("internal error: dangerous error");
2105 msg
= _("internal error: unknown error");
2109 if (!((*info
->callbacks
->warning
)
2110 (info
, msg
, name
, input_bfd
, input_section
,
2121 /* Function to keep ARM specific flags in the ELF header. */
2123 elf32_arm_set_private_flags (abfd
, flags
)
2127 if (elf_flags_init (abfd
)
2128 && elf_elfheader (abfd
)->e_flags
!= flags
)
2130 if (EF_ARM_EABI_VERSION (flags
) == EF_ARM_EABI_UNKNOWN
)
2132 if (flags
& EF_ARM_INTERWORK
)
2133 (*_bfd_error_handler
) (_("\
2134 Warning: Not setting interworking flag of %s since it has already been specified as non-interworking"),
2135 bfd_archive_filename (abfd
));
2137 _bfd_error_handler (_("\
2138 Warning: Clearing the interworking flag of %s due to outside request"),
2139 bfd_archive_filename (abfd
));
2144 elf_elfheader (abfd
)->e_flags
= flags
;
2145 elf_flags_init (abfd
) = true;
2151 /* Copy backend specific data from one object module to another. */
2154 elf32_arm_copy_private_bfd_data (ibfd
, obfd
)
2161 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2162 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2165 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2166 out_flags
= elf_elfheader (obfd
)->e_flags
;
2168 if (elf_flags_init (obfd
)
2169 && EF_ARM_EABI_VERSION (out_flags
) == EF_ARM_EABI_UNKNOWN
2170 && in_flags
!= out_flags
)
2172 /* Cannot mix APCS26 and APCS32 code. */
2173 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2176 /* Cannot mix float APCS and non-float APCS code. */
2177 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2180 /* If the src and dest have different interworking flags
2181 then turn off the interworking bit. */
2182 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2184 if (out_flags
& EF_ARM_INTERWORK
)
2185 _bfd_error_handler (_("\
2186 Warning: Clearing the interworking flag of %s because non-interworking code in %s has been linked with it"),
2187 bfd_get_filename (obfd
),
2188 bfd_archive_filename (ibfd
));
2190 in_flags
&= ~EF_ARM_INTERWORK
;
2193 /* Likewise for PIC, though don't warn for this case. */
2194 if ((in_flags
& EF_ARM_PIC
) != (out_flags
& EF_ARM_PIC
))
2195 in_flags
&= ~EF_ARM_PIC
;
2198 elf_elfheader (obfd
)->e_flags
= in_flags
;
2199 elf_flags_init (obfd
) = true;
2204 /* Merge backend specific data from an object file to the output
2205 object file when linking. */
2208 elf32_arm_merge_private_bfd_data (ibfd
, obfd
)
2214 boolean flags_compatible
= true;
2215 boolean null_input_bfd
= true;
2218 /* Check if we have the same endianess. */
2219 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
2222 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2223 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2226 /* The input BFD must have had its flags initialised. */
2227 /* The following seems bogus to me -- The flags are initialized in
2228 the assembler but I don't think an elf_flags_init field is
2229 written into the object. */
2230 /* BFD_ASSERT (elf_flags_init (ibfd)); */
2232 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2233 out_flags
= elf_elfheader (obfd
)->e_flags
;
2235 if (!elf_flags_init (obfd
))
2237 /* If the input is the default architecture and had the default
2238 flags then do not bother setting the flags for the output
2239 architecture, instead allow future merges to do this. If no
2240 future merges ever set these flags then they will retain their
2241 uninitialised values, which surprise surprise, correspond
2242 to the default values. */
2243 if (bfd_get_arch_info (ibfd
)->the_default
2244 && elf_elfheader (ibfd
)->e_flags
== 0)
2247 elf_flags_init (obfd
) = true;
2248 elf_elfheader (obfd
)->e_flags
= in_flags
;
2250 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
2251 && bfd_get_arch_info (obfd
)->the_default
)
2252 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
), bfd_get_mach (ibfd
));
2257 /* Identical flags must be compatible. */
2258 if (in_flags
== out_flags
)
2261 /* Check to see if the input BFD actually contains any sections.
2262 If not, its flags may not have been initialised either, but it cannot
2263 actually cause any incompatibility. */
2264 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2266 /* Ignore synthetic glue sections. */
2267 if (strcmp (sec
->name
, ".glue_7")
2268 && strcmp (sec
->name
, ".glue_7t"))
2270 null_input_bfd
= false;
2277 /* Complain about various flag mismatches. */
2278 if (EF_ARM_EABI_VERSION (in_flags
) != EF_ARM_EABI_VERSION (out_flags
))
2280 _bfd_error_handler (_("\
2281 ERROR: %s is compiled for EABI version %d, whereas %s is compiled for version %d"),
2282 bfd_archive_filename (ibfd
),
2283 (in_flags
& EF_ARM_EABIMASK
) >> 24,
2284 bfd_get_filename (obfd
),
2285 (out_flags
& EF_ARM_EABIMASK
) >> 24);
2289 /* Not sure what needs to be checked for EABI versions >= 1. */
2290 if (EF_ARM_EABI_VERSION (in_flags
) == EF_ARM_EABI_UNKNOWN
)
2292 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2294 _bfd_error_handler (_("\
2295 ERROR: %s is compiled for APCS-%d, whereas target %s uses APCS-%d"),
2296 bfd_archive_filename (ibfd
),
2297 in_flags
& EF_ARM_APCS_26
? 26 : 32,
2298 bfd_get_filename (obfd
),
2299 out_flags
& EF_ARM_APCS_26
? 26 : 32);
2300 flags_compatible
= false;
2303 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2305 if (in_flags
& EF_ARM_APCS_FLOAT
)
2306 _bfd_error_handler (_("\
2307 ERROR: %s passes floats in float registers, whereas %s passes them in integer registers"),
2308 bfd_archive_filename (ibfd
),
2309 bfd_get_filename (obfd
));
2311 _bfd_error_handler (_("\
2312 ERROR: %s passes floats in integer registers, whereas %s passes them in float registers"),
2313 bfd_archive_filename (ibfd
),
2314 bfd_get_filename (obfd
));
2316 flags_compatible
= false;
2319 if ((in_flags
& EF_ARM_VFP_FLOAT
) != (out_flags
& EF_ARM_VFP_FLOAT
))
2321 if (in_flags
& EF_ARM_VFP_FLOAT
)
2322 _bfd_error_handler (_("\
2323 ERROR: %s uses VFP instructions, whereas %s uses FPA instructions"),
2324 bfd_archive_filename (ibfd
),
2325 bfd_get_filename (obfd
));
2327 _bfd_error_handler (_("\
2328 ERROR: %s uses FPA instructions, whereas %s uses VFP instructions"),
2329 bfd_archive_filename (ibfd
),
2330 bfd_get_filename (obfd
));
2332 flags_compatible
= false;
2335 #ifdef EF_ARM_SOFT_FLOAT
2336 if ((in_flags
& EF_ARM_SOFT_FLOAT
) != (out_flags
& EF_ARM_SOFT_FLOAT
))
2338 /* We can allow interworking between code that is VFP format
2339 layout, and uses either soft float or integer regs for
2340 passing floating point arguments and results. We already
2341 know that the APCS_FLOAT flags match; similarly for VFP
2343 if ((in_flags
& EF_ARM_APCS_FLOAT
) != 0
2344 || (in_flags
& EF_ARM_VFP_FLOAT
) == 0)
2346 if (in_flags
& EF_ARM_SOFT_FLOAT
)
2347 _bfd_error_handler (_("\
2348 ERROR: %s uses software FP, whereas %s uses hardware FP"),
2349 bfd_archive_filename (ibfd
),
2350 bfd_get_filename (obfd
));
2352 _bfd_error_handler (_("\
2353 ERROR: %s uses hardware FP, whereas %s uses software FP"),
2354 bfd_archive_filename (ibfd
),
2355 bfd_get_filename (obfd
));
2357 flags_compatible
= false;
2362 /* Interworking mismatch is only a warning. */
2363 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2365 if (in_flags
& EF_ARM_INTERWORK
)
2367 _bfd_error_handler (_("\
2368 Warning: %s supports interworking, whereas %s does not"),
2369 bfd_archive_filename (ibfd
),
2370 bfd_get_filename (obfd
));
2374 _bfd_error_handler (_("\
2375 Warning: %s does not support interworking, whereas %s does"),
2376 bfd_archive_filename (ibfd
),
2377 bfd_get_filename (obfd
));
2382 return flags_compatible
;
2385 /* Display the flags field. */
2388 elf32_arm_print_private_bfd_data (abfd
, ptr
)
2392 FILE * file
= (FILE *) ptr
;
2393 unsigned long flags
;
2395 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
2397 /* Print normal ELF private data. */
2398 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
2400 flags
= elf_elfheader (abfd
)->e_flags
;
2401 /* Ignore init flag - it may not be set, despite the flags field
2402 containing valid data. */
2404 /* xgettext:c-format */
2405 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
2407 switch (EF_ARM_EABI_VERSION (flags
))
2409 case EF_ARM_EABI_UNKNOWN
:
2410 /* The following flag bits are GNU extenstions and not part of the
2411 official ARM ELF extended ABI. Hence they are only decoded if
2412 the EABI version is not set. */
2413 if (flags
& EF_ARM_INTERWORK
)
2414 fprintf (file
, _(" [interworking enabled]"));
2416 if (flags
& EF_ARM_APCS_26
)
2417 fprintf (file
, " [APCS-26]");
2419 fprintf (file
, " [APCS-32]");
2421 if (flags
& EF_ARM_VFP_FLOAT
)
2422 fprintf (file
, _(" [VFP float format]"));
2424 fprintf (file
, _(" [FPA float format]"));
2426 if (flags
& EF_ARM_APCS_FLOAT
)
2427 fprintf (file
, _(" [floats passed in float registers]"));
2429 if (flags
& EF_ARM_PIC
)
2430 fprintf (file
, _(" [position independent]"));
2432 if (flags
& EF_ARM_NEW_ABI
)
2433 fprintf (file
, _(" [new ABI]"));
2435 if (flags
& EF_ARM_OLD_ABI
)
2436 fprintf (file
, _(" [old ABI]"));
2438 if (flags
& EF_ARM_SOFT_FLOAT
)
2439 fprintf (file
, _(" [software FP]"));
2441 flags
&= ~(EF_ARM_INTERWORK
| EF_ARM_APCS_26
| EF_ARM_APCS_FLOAT
2442 | EF_ARM_PIC
| EF_ARM_NEW_ABI
| EF_ARM_OLD_ABI
2443 | EF_ARM_SOFT_FLOAT
| EF_ARM_VFP_FLOAT
);
2446 case EF_ARM_EABI_VER1
:
2447 fprintf (file
, _(" [Version1 EABI]"));
2449 if (flags
& EF_ARM_SYMSARESORTED
)
2450 fprintf (file
, _(" [sorted symbol table]"));
2452 fprintf (file
, _(" [unsorted symbol table]"));
2454 flags
&= ~ EF_ARM_SYMSARESORTED
;
2457 case EF_ARM_EABI_VER2
:
2458 fprintf (file
, _(" [Version2 EABI]"));
2460 if (flags
& EF_ARM_SYMSARESORTED
)
2461 fprintf (file
, _(" [sorted symbol table]"));
2463 fprintf (file
, _(" [unsorted symbol table]"));
2465 if (flags
& EF_ARM_DYNSYMSUSESEGIDX
)
2466 fprintf (file
, _(" [dynamic symbols use segment index]"));
2468 if (flags
& EF_ARM_MAPSYMSFIRST
)
2469 fprintf (file
, _(" [mapping symbols precede others]"));
2471 flags
&= ~(EF_ARM_SYMSARESORTED
| EF_ARM_DYNSYMSUSESEGIDX
2472 | EF_ARM_MAPSYMSFIRST
);
2476 fprintf (file
, _(" <EABI version unrecognised>"));
2480 flags
&= ~ EF_ARM_EABIMASK
;
2482 if (flags
& EF_ARM_RELEXEC
)
2483 fprintf (file
, _(" [relocatable executable]"));
2485 if (flags
& EF_ARM_HASENTRY
)
2486 fprintf (file
, _(" [has entry point]"));
2488 flags
&= ~ (EF_ARM_RELEXEC
| EF_ARM_HASENTRY
);
2491 fprintf (file
, _("<Unrecognised flag bits set>"));
2499 elf32_arm_get_symbol_type (elf_sym
, type
)
2500 Elf_Internal_Sym
* elf_sym
;
2503 switch (ELF_ST_TYPE (elf_sym
->st_info
))
2506 return ELF_ST_TYPE (elf_sym
->st_info
);
2509 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2510 This allows us to distinguish between data used by Thumb instructions
2511 and non-data (which is probably code) inside Thumb regions of an
2513 if (type
!= STT_OBJECT
)
2514 return ELF_ST_TYPE (elf_sym
->st_info
);
2525 elf32_arm_gc_mark_hook (sec
, info
, rel
, h
, sym
)
2527 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2528 Elf_Internal_Rela
*rel
;
2529 struct elf_link_hash_entry
*h
;
2530 Elf_Internal_Sym
*sym
;
2534 switch (ELF32_R_TYPE (rel
->r_info
))
2536 case R_ARM_GNU_VTINHERIT
:
2537 case R_ARM_GNU_VTENTRY
:
2541 switch (h
->root
.type
)
2543 case bfd_link_hash_defined
:
2544 case bfd_link_hash_defweak
:
2545 return h
->root
.u
.def
.section
;
2547 case bfd_link_hash_common
:
2548 return h
->root
.u
.c
.p
->section
;
2556 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
2561 /* Update the got entry reference counts for the section being removed. */
2564 elf32_arm_gc_sweep_hook (abfd
, info
, sec
, relocs
)
2565 bfd
*abfd ATTRIBUTE_UNUSED
;
2566 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2567 asection
*sec ATTRIBUTE_UNUSED
;
2568 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
;
2570 /* We don't support garbage collection of GOT and PLT relocs yet. */
2574 /* Look through the relocs for a section during the first phase. */
2577 elf32_arm_check_relocs (abfd
, info
, sec
, relocs
)
2579 struct bfd_link_info
* info
;
2581 const Elf_Internal_Rela
* relocs
;
2583 Elf_Internal_Shdr
* symtab_hdr
;
2584 struct elf_link_hash_entry
** sym_hashes
;
2585 struct elf_link_hash_entry
** sym_hashes_end
;
2586 const Elf_Internal_Rela
* rel
;
2587 const Elf_Internal_Rela
* rel_end
;
2589 asection
* sgot
, *srelgot
, *sreloc
;
2590 bfd_vma
* local_got_offsets
;
2592 if (info
->relocateable
)
2595 sgot
= srelgot
= sreloc
= NULL
;
2597 dynobj
= elf_hash_table (info
)->dynobj
;
2598 local_got_offsets
= elf_local_got_offsets (abfd
);
2600 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2601 sym_hashes
= elf_sym_hashes (abfd
);
2602 sym_hashes_end
= sym_hashes
2603 + symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
2605 if (!elf_bad_symtab (abfd
))
2606 sym_hashes_end
-= symtab_hdr
->sh_info
;
2608 rel_end
= relocs
+ sec
->reloc_count
;
2609 for (rel
= relocs
; rel
< rel_end
; rel
++)
2611 struct elf_link_hash_entry
*h
;
2612 unsigned long r_symndx
;
2614 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2615 if (r_symndx
< symtab_hdr
->sh_info
)
2618 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2620 /* Some relocs require a global offset table. */
2623 switch (ELF32_R_TYPE (rel
->r_info
))
2628 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
2629 if (! _bfd_elf_create_got_section (dynobj
, info
))
2638 switch (ELF32_R_TYPE (rel
->r_info
))
2641 /* This symbol requires a global offset table entry. */
2644 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2645 BFD_ASSERT (sgot
!= NULL
);
2648 /* Get the got relocation section if necessary. */
2650 && (h
!= NULL
|| info
->shared
))
2652 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
2654 /* If no got relocation section, make one and initialize. */
2655 if (srelgot
== NULL
)
2657 srelgot
= bfd_make_section (dynobj
, ".rel.got");
2659 || ! bfd_set_section_flags (dynobj
, srelgot
,
2664 | SEC_LINKER_CREATED
2666 || ! bfd_set_section_alignment (dynobj
, srelgot
, 2))
2673 if (h
->got
.offset
!= (bfd_vma
) -1)
2674 /* We have already allocated space in the .got. */
2677 h
->got
.offset
= sgot
->_raw_size
;
2679 /* Make sure this symbol is output as a dynamic symbol. */
2680 if (h
->dynindx
== -1)
2681 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2684 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2688 /* This is a global offset table entry for a local
2690 if (local_got_offsets
== NULL
)
2695 size
= symtab_hdr
->sh_info
;
2696 size
*= sizeof (bfd_vma
);
2697 local_got_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
2698 if (local_got_offsets
== NULL
)
2700 elf_local_got_offsets (abfd
) = local_got_offsets
;
2701 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
2702 local_got_offsets
[i
] = (bfd_vma
) -1;
2705 if (local_got_offsets
[r_symndx
] != (bfd_vma
) -1)
2706 /* We have already allocated space in the .got. */
2709 local_got_offsets
[r_symndx
] = sgot
->_raw_size
;
2712 /* If we are generating a shared object, we need to
2713 output a R_ARM_RELATIVE reloc so that the dynamic
2714 linker can adjust this GOT entry. */
2715 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2718 sgot
->_raw_size
+= 4;
2722 /* This symbol requires a procedure linkage table entry. We
2723 actually build the entry in adjust_dynamic_symbol,
2724 because this might be a case of linking PIC code which is
2725 never referenced by a dynamic object, in which case we
2726 don't need to generate a procedure linkage table entry
2729 /* If this is a local symbol, we resolve it directly without
2730 creating a procedure linkage table entry. */
2734 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2740 /* If we are creating a shared library, and this is a reloc
2741 against a global symbol, or a non PC relative reloc
2742 against a local symbol, then we need to copy the reloc
2743 into the shared library. However, if we are linking with
2744 -Bsymbolic, we do not need to copy a reloc against a
2745 global symbol which is defined in an object we are
2746 including in the link (i.e., DEF_REGULAR is set). At
2747 this point we have not seen all the input files, so it is
2748 possible that DEF_REGULAR is not set now but will be set
2749 later (it is never cleared). We account for that
2750 possibility below by storing information in the
2751 pcrel_relocs_copied field of the hash table entry. */
2753 && (ELF32_R_TYPE (rel
->r_info
) != R_ARM_PC24
2755 && (! info
->symbolic
2756 || (h
->elf_link_hash_flags
2757 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
2759 /* When creating a shared object, we must copy these
2760 reloc types into the output file. We create a reloc
2761 section in dynobj and make room for this reloc. */
2766 name
= (bfd_elf_string_from_elf_section
2768 elf_elfheader (abfd
)->e_shstrndx
,
2769 elf_section_data (sec
)->rel_hdr
.sh_name
));
2773 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
2774 && strcmp (bfd_get_section_name (abfd
, sec
),
2777 sreloc
= bfd_get_section_by_name (dynobj
, name
);
2782 sreloc
= bfd_make_section (dynobj
, name
);
2783 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
2784 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
2785 if ((sec
->flags
& SEC_ALLOC
) != 0)
2786 flags
|= SEC_ALLOC
| SEC_LOAD
;
2788 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
2789 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
2792 if (sec
->flags
& SEC_READONLY
)
2793 info
->flags
|= DF_TEXTREL
;
2796 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
2797 /* If we are linking with -Bsymbolic, and this is a
2798 global symbol, we count the number of PC relative
2799 relocations we have entered for this symbol, so that
2800 we can discard them again if the symbol is later
2801 defined by a regular object. Note that this function
2802 is only called if we are using an elf_i386 linker
2803 hash table, which means that h is really a pointer to
2804 an elf_i386_link_hash_entry. */
2805 if (h
!= NULL
&& info
->symbolic
2806 && ELF32_R_TYPE (rel
->r_info
) == R_ARM_PC24
)
2808 struct elf32_arm_link_hash_entry
* eh
;
2809 struct elf32_arm_pcrel_relocs_copied
* p
;
2811 eh
= (struct elf32_arm_link_hash_entry
*) h
;
2813 for (p
= eh
->pcrel_relocs_copied
; p
!= NULL
; p
= p
->next
)
2814 if (p
->section
== sreloc
)
2819 p
= ((struct elf32_arm_pcrel_relocs_copied
*)
2820 bfd_alloc (dynobj
, (bfd_size_type
) sizeof * p
));
2823 p
->next
= eh
->pcrel_relocs_copied
;
2824 eh
->pcrel_relocs_copied
= p
;
2825 p
->section
= sreloc
;
2834 /* This relocation describes the C++ object vtable hierarchy.
2835 Reconstruct it for later use during GC. */
2836 case R_ARM_GNU_VTINHERIT
:
2837 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2841 /* This relocation describes which C++ vtable entries are actually
2842 used. Record for later use during GC. */
2843 case R_ARM_GNU_VTENTRY
:
2844 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
2853 /* Find the nearest line to a particular section and offset, for error
2854 reporting. This code is a duplicate of the code in elf.c, except
2855 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
2858 elf32_arm_find_nearest_line
2859 (abfd
, section
, symbols
, offset
, filename_ptr
, functionname_ptr
, line_ptr
)
2864 const char ** filename_ptr
;
2865 const char ** functionname_ptr
;
2866 unsigned int * line_ptr
;
2869 const char * filename
;
2874 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
2875 filename_ptr
, functionname_ptr
,
2877 &elf_tdata (abfd
)->dwarf2_find_line_info
))
2880 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2881 &found
, filename_ptr
,
2882 functionname_ptr
, line_ptr
,
2883 &elf_tdata (abfd
)->line_info
))
2889 if (symbols
== NULL
)
2896 for (p
= symbols
; *p
!= NULL
; p
++)
2900 q
= (elf_symbol_type
*) *p
;
2902 if (bfd_get_section (&q
->symbol
) != section
)
2905 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
2910 filename
= bfd_asymbol_name (&q
->symbol
);
2915 if (q
->symbol
.section
== section
2916 && q
->symbol
.value
>= low_func
2917 && q
->symbol
.value
<= offset
)
2919 func
= (asymbol
*) q
;
2920 low_func
= q
->symbol
.value
;
2929 *filename_ptr
= filename
;
2930 *functionname_ptr
= bfd_asymbol_name (func
);
2936 /* Adjust a symbol defined by a dynamic object and referenced by a
2937 regular object. The current definition is in some section of the
2938 dynamic object, but we're not including those sections. We have to
2939 change the definition to something the rest of the link can
2943 elf32_arm_adjust_dynamic_symbol (info
, h
)
2944 struct bfd_link_info
* info
;
2945 struct elf_link_hash_entry
* h
;
2949 unsigned int power_of_two
;
2951 dynobj
= elf_hash_table (info
)->dynobj
;
2953 /* Make sure we know what is going on here. */
2954 BFD_ASSERT (dynobj
!= NULL
2955 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
2956 || h
->weakdef
!= NULL
2957 || ((h
->elf_link_hash_flags
2958 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2959 && (h
->elf_link_hash_flags
2960 & ELF_LINK_HASH_REF_REGULAR
) != 0
2961 && (h
->elf_link_hash_flags
2962 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
2964 /* If this is a function, put it in the procedure linkage table. We
2965 will fill in the contents of the procedure linkage table later,
2966 when we know the address of the .got section. */
2967 if (h
->type
== STT_FUNC
2968 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
2970 /* If we link a program (not a DSO), we'll get rid of unnecessary
2971 PLT entries; we point to the actual symbols -- even for pic
2972 relocs, because a program built with -fpic should have the same
2973 result as one built without -fpic, specifically considering weak
2975 FIXME: m68k and i386 differ here, for unclear reasons. */
2977 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0)
2979 /* This case can occur if we saw a PLT32 reloc in an input
2980 file, but the symbol was not defined by a dynamic object.
2981 In such a case, we don't actually need to build a
2982 procedure linkage table, and we can just do a PC32 reloc
2984 BFD_ASSERT ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0);
2985 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
2989 /* Make sure this symbol is output as a dynamic symbol. */
2990 if (h
->dynindx
== -1)
2992 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2996 s
= bfd_get_section_by_name (dynobj
, ".plt");
2997 BFD_ASSERT (s
!= NULL
);
2999 /* If this is the first .plt entry, make room for the special
3001 if (s
->_raw_size
== 0)
3002 s
->_raw_size
+= PLT_ENTRY_SIZE
;
3004 /* If this symbol is not defined in a regular file, and we are
3005 not generating a shared library, then set the symbol to this
3006 location in the .plt. This is required to make function
3007 pointers compare as equal between the normal executable and
3008 the shared library. */
3010 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3012 h
->root
.u
.def
.section
= s
;
3013 h
->root
.u
.def
.value
= s
->_raw_size
;
3016 h
->plt
.offset
= s
->_raw_size
;
3018 /* Make room for this entry. */
3019 s
->_raw_size
+= PLT_ENTRY_SIZE
;
3021 /* We also need to make an entry in the .got.plt section, which
3022 will be placed in the .got section by the linker script. */
3023 s
= bfd_get_section_by_name (dynobj
, ".got.plt");
3024 BFD_ASSERT (s
!= NULL
);
3027 /* We also need to make an entry in the .rel.plt section. */
3029 s
= bfd_get_section_by_name (dynobj
, ".rel.plt");
3030 BFD_ASSERT (s
!= NULL
);
3031 s
->_raw_size
+= sizeof (Elf32_External_Rel
);
3036 /* If this is a weak symbol, and there is a real definition, the
3037 processor independent code will have arranged for us to see the
3038 real definition first, and we can just use the same value. */
3039 if (h
->weakdef
!= NULL
)
3041 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
3042 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
3043 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
3044 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
3048 /* This is a reference to a symbol defined by a dynamic object which
3049 is not a function. */
3051 /* If we are creating a shared library, we must presume that the
3052 only references to the symbol are via the global offset table.
3053 For such cases we need not do anything here; the relocations will
3054 be handled correctly by relocate_section. */
3058 /* We must allocate the symbol in our .dynbss section, which will
3059 become part of the .bss section of the executable. There will be
3060 an entry for this symbol in the .dynsym section. The dynamic
3061 object will contain position independent code, so all references
3062 from the dynamic object to this symbol will go through the global
3063 offset table. The dynamic linker will use the .dynsym entry to
3064 determine the address it must put in the global offset table, so
3065 both the dynamic object and the regular object will refer to the
3066 same memory location for the variable. */
3067 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
3068 BFD_ASSERT (s
!= NULL
);
3070 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
3071 copy the initial value out of the dynamic object and into the
3072 runtime process image. We need to remember the offset into the
3073 .rel.bss section we are going to use. */
3074 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
3078 srel
= bfd_get_section_by_name (dynobj
, ".rel.bss");
3079 BFD_ASSERT (srel
!= NULL
);
3080 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
3081 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
3084 /* We need to figure out the alignment required for this symbol. I
3085 have no idea how ELF linkers handle this. */
3086 power_of_two
= bfd_log2 (h
->size
);
3087 if (power_of_two
> 3)
3090 /* Apply the required alignment. */
3091 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
3092 (bfd_size_type
) (1 << power_of_two
));
3093 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
3095 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
3099 /* Define the symbol as being at this point in the section. */
3100 h
->root
.u
.def
.section
= s
;
3101 h
->root
.u
.def
.value
= s
->_raw_size
;
3103 /* Increment the section size to make room for the symbol. */
3104 s
->_raw_size
+= h
->size
;
3109 /* Set the sizes of the dynamic sections. */
3112 elf32_arm_size_dynamic_sections (output_bfd
, info
)
3113 bfd
* output_bfd ATTRIBUTE_UNUSED
;
3114 struct bfd_link_info
* info
;
3121 dynobj
= elf_hash_table (info
)->dynobj
;
3122 BFD_ASSERT (dynobj
!= NULL
);
3124 if (elf_hash_table (info
)->dynamic_sections_created
)
3126 /* Set the contents of the .interp section to the interpreter. */
3129 s
= bfd_get_section_by_name (dynobj
, ".interp");
3130 BFD_ASSERT (s
!= NULL
);
3131 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
3132 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
3137 /* We may have created entries in the .rel.got section.
3138 However, if we are not creating the dynamic sections, we will
3139 not actually use these entries. Reset the size of .rel.got,
3140 which will cause it to get stripped from the output file
3142 s
= bfd_get_section_by_name (dynobj
, ".rel.got");
3147 /* If this is a -Bsymbolic shared link, then we need to discard all
3148 PC relative relocs against symbols defined in a regular object.
3149 We allocated space for them in the check_relocs routine, but we
3150 will not fill them in in the relocate_section routine. */
3151 if (info
->shared
&& info
->symbolic
)
3152 elf32_arm_link_hash_traverse (elf32_arm_hash_table (info
),
3153 elf32_arm_discard_copies
,
3156 /* The check_relocs and adjust_dynamic_symbol entry points have
3157 determined the sizes of the various dynamic sections. Allocate
3161 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3166 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3169 /* It's OK to base decisions on the section name, because none
3170 of the dynobj section names depend upon the input files. */
3171 name
= bfd_get_section_name (dynobj
, s
);
3175 if (strcmp (name
, ".plt") == 0)
3177 if (s
->_raw_size
== 0)
3179 /* Strip this section if we don't need it; see the
3185 /* Remember whether there is a PLT. */
3189 else if (strncmp (name
, ".rel", 4) == 0)
3191 if (s
->_raw_size
== 0)
3193 /* If we don't need this section, strip it from the
3194 output file. This is mostly to handle .rel.bss and
3195 .rel.plt. We must create both sections in
3196 create_dynamic_sections, because they must be created
3197 before the linker maps input sections to output
3198 sections. The linker does that before
3199 adjust_dynamic_symbol is called, and it is that
3200 function which decides whether anything needs to go
3201 into these sections. */
3206 /* Remember whether there are any reloc sections other
3208 if (strcmp (name
, ".rel.plt") != 0)
3211 /* We use the reloc_count field as a counter if we need
3212 to copy relocs into the output file. */
3216 else if (strncmp (name
, ".got", 4) != 0)
3218 /* It's not one of our sections, so don't allocate space. */
3226 for (spp
= &s
->output_section
->owner
->sections
;
3228 spp
= &(*spp
)->next
)
3230 if (*spp
== s
->output_section
)
3232 bfd_section_list_remove (s
->output_section
->owner
, spp
);
3233 --s
->output_section
->owner
->section_count
;
3240 /* Allocate memory for the section contents. */
3241 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
3242 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
3246 if (elf_hash_table (info
)->dynamic_sections_created
)
3248 /* Add some entries to the .dynamic section. We fill in the
3249 values later, in elf32_arm_finish_dynamic_sections, but we
3250 must add the entries now so that we get the correct size for
3251 the .dynamic section. The DT_DEBUG entry is filled in by the
3252 dynamic linker and used by the debugger. */
3253 #define add_dynamic_entry(TAG, VAL) \
3254 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
3258 if (!add_dynamic_entry (DT_DEBUG
, 0))
3264 if ( !add_dynamic_entry (DT_PLTGOT
, 0)
3265 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
3266 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
3267 || !add_dynamic_entry (DT_JMPREL
, 0))
3273 if ( !add_dynamic_entry (DT_REL
, 0)
3274 || !add_dynamic_entry (DT_RELSZ
, 0)
3275 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
3279 if ((info
->flags
& DF_TEXTREL
) != 0)
3281 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3283 info
->flags
|= DF_TEXTREL
;
3286 #undef add_synamic_entry
3291 /* This function is called via elf32_arm_link_hash_traverse if we are
3292 creating a shared object with -Bsymbolic. It discards the space
3293 allocated to copy PC relative relocs against symbols which are
3294 defined in regular objects. We allocated space for them in the
3295 check_relocs routine, but we won't fill them in in the
3296 relocate_section routine. */
3299 elf32_arm_discard_copies (h
, ignore
)
3300 struct elf32_arm_link_hash_entry
* h
;
3301 PTR ignore ATTRIBUTE_UNUSED
;
3303 struct elf32_arm_pcrel_relocs_copied
* s
;
3305 if (h
->root
.root
.type
== bfd_link_hash_warning
)
3306 h
= (struct elf32_arm_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3308 /* We only discard relocs for symbols defined in a regular object. */
3309 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3312 for (s
= h
->pcrel_relocs_copied
; s
!= NULL
; s
= s
->next
)
3313 s
->section
->_raw_size
-= s
->count
* sizeof (Elf32_External_Rel
);
3318 /* Finish up dynamic symbol handling. We set the contents of various
3319 dynamic sections here. */
3322 elf32_arm_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
3324 struct bfd_link_info
* info
;
3325 struct elf_link_hash_entry
* h
;
3326 Elf_Internal_Sym
* sym
;
3330 dynobj
= elf_hash_table (info
)->dynobj
;
3332 if (h
->plt
.offset
!= (bfd_vma
) -1)
3339 Elf_Internal_Rel rel
;
3341 /* This symbol has an entry in the procedure linkage table. Set
3344 BFD_ASSERT (h
->dynindx
!= -1);
3346 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3347 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3348 srel
= bfd_get_section_by_name (dynobj
, ".rel.plt");
3349 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
3351 /* Get the index in the procedure linkage table which
3352 corresponds to this symbol. This is the index of this symbol
3353 in all the symbols for which we are making plt entries. The
3354 first entry in the procedure linkage table is reserved. */
3355 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
3357 /* Get the offset into the .got table of the entry that
3358 corresponds to this function. Each .got entry is 4 bytes.
3359 The first three are reserved. */
3360 got_offset
= (plt_index
+ 3) * 4;
3362 /* Fill in the entry in the procedure linkage table. */
3363 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[0],
3364 splt
->contents
+ h
->plt
.offset
+ 0);
3365 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[1],
3366 splt
->contents
+ h
->plt
.offset
+ 4);
3367 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[2],
3368 splt
->contents
+ h
->plt
.offset
+ 8);
3369 bfd_put_32 (output_bfd
,
3370 (sgot
->output_section
->vma
3371 + sgot
->output_offset
3373 - splt
->output_section
->vma
3374 - splt
->output_offset
3375 - h
->plt
.offset
- 12),
3376 splt
->contents
+ h
->plt
.offset
+ 12);
3378 /* Fill in the entry in the global offset table. */
3379 bfd_put_32 (output_bfd
,
3380 (splt
->output_section
->vma
3381 + splt
->output_offset
),
3382 sgot
->contents
+ got_offset
);
3384 /* Fill in the entry in the .rel.plt section. */
3385 rel
.r_offset
= (sgot
->output_section
->vma
3386 + sgot
->output_offset
3388 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_JUMP_SLOT
);
3389 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3390 ((Elf32_External_Rel
*) srel
->contents
3393 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3395 /* Mark the symbol as undefined, rather than as defined in
3396 the .plt section. Leave the value alone. */
3397 sym
->st_shndx
= SHN_UNDEF
;
3398 /* If the symbol is weak, we do need to clear the value.
3399 Otherwise, the PLT entry would provide a definition for
3400 the symbol even if the symbol wasn't defined anywhere,
3401 and so the symbol would never be NULL. */
3402 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR_NONWEAK
)
3408 if (h
->got
.offset
!= (bfd_vma
) -1)
3412 Elf_Internal_Rel rel
;
3414 /* This symbol has an entry in the global offset table. Set it
3416 sgot
= bfd_get_section_by_name (dynobj
, ".got");
3417 srel
= bfd_get_section_by_name (dynobj
, ".rel.got");
3418 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
3420 rel
.r_offset
= (sgot
->output_section
->vma
3421 + sgot
->output_offset
3422 + (h
->got
.offset
&~ (bfd_vma
) 1));
3424 /* If this is a -Bsymbolic link, and the symbol is defined
3425 locally, we just want to emit a RELATIVE reloc. The entry in
3426 the global offset table will already have been initialized in
3427 the relocate_section function. */
3429 && (info
->symbolic
|| h
->dynindx
== -1)
3430 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
3431 rel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
3434 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
3435 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_GLOB_DAT
);
3438 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3439 ((Elf32_External_Rel
*) srel
->contents
3440 + srel
->reloc_count
));
3441 ++srel
->reloc_count
;
3444 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
3447 Elf_Internal_Rel rel
;
3449 /* This symbol needs a copy reloc. Set it up. */
3450 BFD_ASSERT (h
->dynindx
!= -1
3451 && (h
->root
.type
== bfd_link_hash_defined
3452 || h
->root
.type
== bfd_link_hash_defweak
));
3454 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
3456 BFD_ASSERT (s
!= NULL
);
3458 rel
.r_offset
= (h
->root
.u
.def
.value
3459 + h
->root
.u
.def
.section
->output_section
->vma
3460 + h
->root
.u
.def
.section
->output_offset
);
3461 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_COPY
);
3462 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3463 ((Elf32_External_Rel
*) s
->contents
3468 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3469 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3470 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
3471 sym
->st_shndx
= SHN_ABS
;
3476 /* Finish up the dynamic sections. */
3479 elf32_arm_finish_dynamic_sections (output_bfd
, info
)
3481 struct bfd_link_info
* info
;
3487 dynobj
= elf_hash_table (info
)->dynobj
;
3489 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3490 BFD_ASSERT (sgot
!= NULL
);
3491 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3493 if (elf_hash_table (info
)->dynamic_sections_created
)
3496 Elf32_External_Dyn
*dyncon
, *dynconend
;
3498 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3499 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3501 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3502 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
3504 for (; dyncon
< dynconend
; dyncon
++)
3506 Elf_Internal_Dyn dyn
;
3510 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3523 s
= bfd_get_section_by_name (output_bfd
, name
);
3524 BFD_ASSERT (s
!= NULL
);
3525 dyn
.d_un
.d_ptr
= s
->vma
;
3526 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3530 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3531 BFD_ASSERT (s
!= NULL
);
3532 if (s
->_cooked_size
!= 0)
3533 dyn
.d_un
.d_val
= s
->_cooked_size
;
3535 dyn
.d_un
.d_val
= s
->_raw_size
;
3536 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3540 /* My reading of the SVR4 ABI indicates that the
3541 procedure linkage table relocs (DT_JMPREL) should be
3542 included in the overall relocs (DT_REL). This is
3543 what Solaris does. However, UnixWare can not handle
3544 that case. Therefore, we override the DT_RELSZ entry
3545 here to make it not include the JMPREL relocs. Since
3546 the linker script arranges for .rel.plt to follow all
3547 other relocation sections, we don't have to worry
3548 about changing the DT_REL entry. */
3549 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3552 if (s
->_cooked_size
!= 0)
3553 dyn
.d_un
.d_val
-= s
->_cooked_size
;
3555 dyn
.d_un
.d_val
-= s
->_raw_size
;
3557 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3560 /* Set the bottom bit of DT_INIT/FINI if the
3561 corresponding function is Thumb. */
3563 name
= info
->init_function
;
3566 name
= info
->fini_function
;
3568 /* If it wasn't set by elf_bfd_final_link
3569 then there is nothing to ajdust. */
3570 if (dyn
.d_un
.d_val
!= 0)
3572 struct elf_link_hash_entry
* eh
;
3574 eh
= elf_link_hash_lookup (elf_hash_table (info
), name
,
3575 false, false, true);
3576 if (eh
!= (struct elf_link_hash_entry
*) NULL
3577 && ELF_ST_TYPE (eh
->type
) == STT_ARM_TFUNC
)
3579 dyn
.d_un
.d_val
|= 1;
3580 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3587 /* Fill in the first entry in the procedure linkage table. */
3588 if (splt
->_raw_size
> 0)
3590 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[0], splt
->contents
+ 0);
3591 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[1], splt
->contents
+ 4);
3592 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[2], splt
->contents
+ 8);
3593 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[3], splt
->contents
+ 12);
3596 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3597 really seem like the right value. */
3598 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
3601 /* Fill in the first three entries in the global offset table. */
3602 if (sgot
->_raw_size
> 0)
3605 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
3607 bfd_put_32 (output_bfd
,
3608 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3610 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
3611 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
3614 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
3620 elf32_arm_post_process_headers (abfd
, link_info
)
3622 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
;
3624 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
3626 i_ehdrp
= elf_elfheader (abfd
);
3628 i_ehdrp
->e_ident
[EI_OSABI
] = ARM_ELF_OS_ABI_VERSION
;
3629 i_ehdrp
->e_ident
[EI_ABIVERSION
] = ARM_ELF_ABI_VERSION
;
3632 static enum elf_reloc_type_class
3633 elf32_arm_reloc_type_class (rela
)
3634 const Elf_Internal_Rela
*rela
;
3636 switch ((int) ELF32_R_TYPE (rela
->r_info
))
3638 case R_ARM_RELATIVE
:
3639 return reloc_class_relative
;
3640 case R_ARM_JUMP_SLOT
:
3641 return reloc_class_plt
;
3643 return reloc_class_copy
;
3645 return reloc_class_normal
;
3650 #define ELF_ARCH bfd_arch_arm
3651 #define ELF_MACHINE_CODE EM_ARM
3652 #ifndef ELF_MAXPAGESIZE
3653 #define ELF_MAXPAGESIZE 0x8000
3656 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
3657 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
3658 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
3659 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
3660 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
3661 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
3662 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
3664 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
3665 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
3666 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
3667 #define elf_backend_check_relocs elf32_arm_check_relocs
3668 #define elf_backend_relocate_section elf32_arm_relocate_section
3669 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
3670 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
3671 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
3672 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
3673 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
3674 #define elf_backend_post_process_headers elf32_arm_post_process_headers
3675 #define elf_backend_reloc_type_class elf32_arm_reloc_type_class
3677 #define elf_backend_can_gc_sections 1
3678 #define elf_backend_plt_readonly 1
3679 #define elf_backend_want_got_plt 1
3680 #define elf_backend_want_plt_sym 0
3682 #define elf_backend_rela_normal 1
3685 #define elf_backend_got_header_size 12
3686 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
3688 #include "elf32-target.h"