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 record_arm_to_thumb_glue
46 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
47 static void record_thumb_to_arm_glue
48 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
49 static void elf32_arm_post_process_headers
50 PARAMS ((bfd
*, struct bfd_link_info
*));
51 static int elf32_arm_to_thumb_stub
52 PARAMS ((struct bfd_link_info
*, const char *, bfd
*, bfd
*, asection
*,
53 bfd_byte
*, asection
*, bfd_vma
, bfd_signed_vma
, bfd_vma
));
54 static int elf32_thumb_to_arm_stub
55 PARAMS ((struct bfd_link_info
*, const char *, bfd
*, bfd
*, asection
*,
56 bfd_byte
*, asection
*, bfd_vma
, bfd_signed_vma
, bfd_vma
));
57 static boolean elf32_arm_relocate_section
58 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
59 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
60 static asection
* elf32_arm_gc_mark_hook
61 PARAMS ((bfd
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
62 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
63 static boolean elf32_arm_gc_sweep_hook
64 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
65 const Elf_Internal_Rela
*));
66 static boolean elf32_arm_check_relocs
67 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
68 const Elf_Internal_Rela
*));
69 static boolean elf32_arm_find_nearest_line
70 PARAMS ((bfd
*, asection
*, asymbol
**, bfd_vma
, const char **,
71 const char **, unsigned int *));
72 static boolean elf32_arm_adjust_dynamic_symbol
73 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
74 static boolean elf32_arm_size_dynamic_sections
75 PARAMS ((bfd
*, struct bfd_link_info
*));
76 static boolean elf32_arm_finish_dynamic_symbol
77 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
79 static boolean elf32_arm_finish_dynamic_sections
80 PARAMS ((bfd
*, struct bfd_link_info
*));
81 static struct bfd_hash_entry
* elf32_arm_link_hash_newfunc
82 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
84 static void arm_add_to_rel
85 PARAMS ((bfd
*, bfd_byte
*, reloc_howto_type
*, bfd_signed_vma
));
88 boolean bfd_elf32_arm_allocate_interworking_sections
89 PARAMS ((struct bfd_link_info
*));
90 boolean bfd_elf32_arm_get_bfd_for_interworking
91 PARAMS ((bfd
*, struct bfd_link_info
*));
92 boolean bfd_elf32_arm_process_before_allocation
93 PARAMS ((bfd
*, struct bfd_link_info
*, int));
94 static enum elf_reloc_type_class elf32_arm_reloc_type_class
95 PARAMS ((const Elf_Internal_Rela
*));
97 #define INTERWORK_FLAG(abfd) (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK)
99 /* The linker script knows the section names for placement.
100 The entry_names are used to do simple name mangling on the stubs.
101 Given a function name, and its type, the stub can be found. The
102 name can be changed. The only requirement is the %s be present. */
103 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
104 #define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
106 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
107 #define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
109 /* The name of the dynamic interpreter. This is put in the .interp
111 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
113 /* The size in bytes of an entry in the procedure linkage table. */
114 #define PLT_ENTRY_SIZE 16
116 /* The first entry in a procedure linkage table looks like
117 this. It is set up so that any shared library function that is
118 called before the relocation has been set up calls the dynamic
120 static const bfd_vma elf32_arm_plt0_entry
[PLT_ENTRY_SIZE
/ 4] =
122 0xe52de004, /* str lr, [sp, #-4]! */
123 0xe59fe010, /* ldr lr, [pc, #16] */
124 0xe08fe00e, /* add lr, pc, lr */
125 0xe5bef008 /* ldr pc, [lr, #8]! */
128 /* Subsequent entries in a procedure linkage table look like
130 static const bfd_vma elf32_arm_plt_entry
[PLT_ENTRY_SIZE
/ 4] =
132 0xe59fc004, /* ldr ip, [pc, #4] */
133 0xe08fc00c, /* add ip, pc, ip */
134 0xe59cf000, /* ldr pc, [ip] */
135 0x00000000 /* offset to symbol in got */
138 /* The ARM linker needs to keep track of the number of relocs that it
139 decides to copy in check_relocs for each symbol. This is so that
140 it can discard PC relative relocs if it doesn't need them when
141 linking with -Bsymbolic. We store the information in a field
142 extending the regular ELF linker hash table. */
144 /* This structure keeps track of the number of PC relative relocs we
145 have copied for a given symbol. */
146 struct elf32_arm_pcrel_relocs_copied
149 struct elf32_arm_pcrel_relocs_copied
* next
;
150 /* A section in dynobj. */
152 /* Number of relocs copied in this section. */
156 /* Arm ELF linker hash entry. */
157 struct elf32_arm_link_hash_entry
159 struct elf_link_hash_entry root
;
161 /* Number of PC relative relocs copied for this symbol. */
162 struct elf32_arm_pcrel_relocs_copied
* pcrel_relocs_copied
;
165 /* Declare this now that the above structures are defined. */
166 static boolean elf32_arm_discard_copies
167 PARAMS ((struct elf32_arm_link_hash_entry
*, PTR
));
169 /* Traverse an arm ELF linker hash table. */
170 #define elf32_arm_link_hash_traverse(table, func, info) \
171 (elf_link_hash_traverse \
173 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
176 /* Get the ARM elf linker hash table from a link_info structure. */
177 #define elf32_arm_hash_table(info) \
178 ((struct elf32_arm_link_hash_table *) ((info)->hash))
180 /* ARM ELF linker hash table. */
181 struct elf32_arm_link_hash_table
183 /* The main hash table. */
184 struct elf_link_hash_table root
;
186 /* The size in bytes of the section containg the Thumb-to-ARM glue. */
187 bfd_size_type thumb_glue_size
;
189 /* The size in bytes of the section containg the ARM-to-Thumb glue. */
190 bfd_size_type arm_glue_size
;
192 /* An arbitary input BFD chosen to hold the glue sections. */
193 bfd
* bfd_of_glue_owner
;
195 /* A boolean indicating whether knowledge of the ARM's pipeline
196 length should be applied by the linker. */
197 int no_pipeline_knowledge
;
200 /* Create an entry in an ARM ELF linker hash table. */
202 static struct bfd_hash_entry
*
203 elf32_arm_link_hash_newfunc (entry
, table
, string
)
204 struct bfd_hash_entry
* entry
;
205 struct bfd_hash_table
* table
;
208 struct elf32_arm_link_hash_entry
* ret
=
209 (struct elf32_arm_link_hash_entry
*) entry
;
211 /* Allocate the structure if it has not already been allocated by a
213 if (ret
== (struct elf32_arm_link_hash_entry
*) NULL
)
214 ret
= ((struct elf32_arm_link_hash_entry
*)
215 bfd_hash_allocate (table
,
216 sizeof (struct elf32_arm_link_hash_entry
)));
217 if (ret
== (struct elf32_arm_link_hash_entry
*) NULL
)
218 return (struct bfd_hash_entry
*) ret
;
220 /* Call the allocation method of the superclass. */
221 ret
= ((struct elf32_arm_link_hash_entry
*)
222 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
224 if (ret
!= (struct elf32_arm_link_hash_entry
*) NULL
)
225 ret
->pcrel_relocs_copied
= NULL
;
227 return (struct bfd_hash_entry
*) ret
;
230 /* Create an ARM elf linker hash table. */
232 static struct bfd_link_hash_table
*
233 elf32_arm_link_hash_table_create (abfd
)
236 struct elf32_arm_link_hash_table
*ret
;
237 bfd_size_type amt
= sizeof (struct elf32_arm_link_hash_table
);
239 ret
= (struct elf32_arm_link_hash_table
*) bfd_malloc (amt
);
240 if (ret
== (struct elf32_arm_link_hash_table
*) NULL
)
243 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
244 elf32_arm_link_hash_newfunc
))
250 ret
->thumb_glue_size
= 0;
251 ret
->arm_glue_size
= 0;
252 ret
->bfd_of_glue_owner
= NULL
;
253 ret
->no_pipeline_knowledge
= 0;
255 return &ret
->root
.root
;
258 /* Locate the Thumb encoded calling stub for NAME. */
260 static struct elf_link_hash_entry
*
261 find_thumb_glue (link_info
, name
, input_bfd
)
262 struct bfd_link_info
*link_info
;
267 struct elf_link_hash_entry
*hash
;
268 struct elf32_arm_link_hash_table
*hash_table
;
270 /* We need a pointer to the armelf specific hash table. */
271 hash_table
= elf32_arm_hash_table (link_info
);
273 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
274 + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1);
276 BFD_ASSERT (tmp_name
);
278 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
280 hash
= elf_link_hash_lookup
281 (&(hash_table
)->root
, tmp_name
, false, false, true);
284 /* xgettext:c-format */
285 (*_bfd_error_handler
) (_("%s: unable to find THUMB glue '%s' for `%s'"),
286 bfd_archive_filename (input_bfd
), tmp_name
, name
);
293 /* Locate the ARM encoded calling stub for NAME. */
295 static struct elf_link_hash_entry
*
296 find_arm_glue (link_info
, name
, input_bfd
)
297 struct bfd_link_info
*link_info
;
302 struct elf_link_hash_entry
*myh
;
303 struct elf32_arm_link_hash_table
*hash_table
;
305 /* We need a pointer to the elfarm specific hash table. */
306 hash_table
= elf32_arm_hash_table (link_info
);
308 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
309 + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1);
311 BFD_ASSERT (tmp_name
);
313 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
315 myh
= elf_link_hash_lookup
316 (&(hash_table
)->root
, tmp_name
, false, false, true);
319 /* xgettext:c-format */
320 (*_bfd_error_handler
) (_("%s: unable to find ARM glue '%s' for `%s'"),
321 bfd_archive_filename (input_bfd
), tmp_name
, name
);
335 .word func @ behave as if you saw a ARM_32 reloc. */
337 #define ARM2THUMB_GLUE_SIZE 12
338 static const insn32 a2t1_ldr_insn
= 0xe59fc000;
339 static const insn32 a2t2_bx_r12_insn
= 0xe12fff1c;
340 static const insn32 a2t3_func_addr_insn
= 0x00000001;
342 /* Thumb->ARM: Thumb->(non-interworking aware) ARM
346 __func_from_thumb: __func_from_thumb:
348 nop ldr r6, __func_addr
350 __func_change_to_arm: bx r6
352 __func_back_to_thumb:
358 #define THUMB2ARM_GLUE_SIZE 8
359 static const insn16 t2a1_bx_pc_insn
= 0x4778;
360 static const insn16 t2a2_noop_insn
= 0x46c0;
361 static const insn32 t2a3_b_insn
= 0xea000000;
363 static const insn16 t2a1_push_insn
= 0xb540;
364 static const insn16 t2a2_ldr_insn
= 0x4e03;
365 static const insn16 t2a3_mov_insn
= 0x46fe;
366 static const insn16 t2a4_bx_insn
= 0x4730;
367 static const insn32 t2a5_pop_insn
= 0xe8bd4040;
368 static const insn32 t2a6_bx_insn
= 0xe12fff1e;
371 bfd_elf32_arm_allocate_interworking_sections (info
)
372 struct bfd_link_info
* info
;
376 struct elf32_arm_link_hash_table
* globals
;
378 globals
= elf32_arm_hash_table (info
);
380 BFD_ASSERT (globals
!= NULL
);
382 if (globals
->arm_glue_size
!= 0)
384 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
386 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
387 ARM2THUMB_GLUE_SECTION_NAME
);
389 BFD_ASSERT (s
!= NULL
);
391 foo
= (bfd_byte
*) bfd_alloc (globals
->bfd_of_glue_owner
,
392 globals
->arm_glue_size
);
394 s
->_raw_size
= s
->_cooked_size
= globals
->arm_glue_size
;
398 if (globals
->thumb_glue_size
!= 0)
400 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
402 s
= bfd_get_section_by_name
403 (globals
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
405 BFD_ASSERT (s
!= NULL
);
407 foo
= (bfd_byte
*) bfd_alloc (globals
->bfd_of_glue_owner
,
408 globals
->thumb_glue_size
);
410 s
->_raw_size
= s
->_cooked_size
= globals
->thumb_glue_size
;
418 record_arm_to_thumb_glue (link_info
, h
)
419 struct bfd_link_info
* link_info
;
420 struct elf_link_hash_entry
* h
;
422 const char * name
= h
->root
.root
.string
;
425 struct elf_link_hash_entry
* myh
;
426 struct elf32_arm_link_hash_table
* globals
;
429 globals
= elf32_arm_hash_table (link_info
);
431 BFD_ASSERT (globals
!= NULL
);
432 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
434 s
= bfd_get_section_by_name
435 (globals
->bfd_of_glue_owner
, ARM2THUMB_GLUE_SECTION_NAME
);
437 BFD_ASSERT (s
!= NULL
);
439 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
440 + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1);
442 BFD_ASSERT (tmp_name
);
444 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
446 myh
= elf_link_hash_lookup
447 (&(globals
)->root
, tmp_name
, false, false, true);
451 /* We've already seen this guy. */
456 /* The only trick here is using hash_table->arm_glue_size as the value. Even
457 though the section isn't allocated yet, this is where we will be putting
459 val
= globals
->arm_glue_size
+ 1;
460 _bfd_generic_link_add_one_symbol (link_info
, globals
->bfd_of_glue_owner
,
461 tmp_name
, BSF_GLOBAL
, s
, val
,
463 (struct bfd_link_hash_entry
**) &myh
);
467 globals
->arm_glue_size
+= ARM2THUMB_GLUE_SIZE
;
473 record_thumb_to_arm_glue (link_info
, h
)
474 struct bfd_link_info
*link_info
;
475 struct elf_link_hash_entry
*h
;
477 const char *name
= h
->root
.root
.string
;
480 struct elf_link_hash_entry
*myh
;
481 struct elf32_arm_link_hash_table
*hash_table
;
485 hash_table
= elf32_arm_hash_table (link_info
);
487 BFD_ASSERT (hash_table
!= NULL
);
488 BFD_ASSERT (hash_table
->bfd_of_glue_owner
!= NULL
);
490 s
= bfd_get_section_by_name
491 (hash_table
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
493 BFD_ASSERT (s
!= NULL
);
495 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
496 + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1);
498 BFD_ASSERT (tmp_name
);
500 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
502 myh
= elf_link_hash_lookup
503 (&(hash_table
)->root
, tmp_name
, false, false, true);
507 /* We've already seen this guy. */
512 val
= hash_table
->thumb_glue_size
+ 1;
513 _bfd_generic_link_add_one_symbol (link_info
, hash_table
->bfd_of_glue_owner
,
514 tmp_name
, BSF_GLOBAL
, s
, val
,
516 (struct bfd_link_hash_entry
**) &myh
);
518 /* If we mark it 'Thumb', the disassembler will do a better job. */
519 bind
= ELF_ST_BIND (myh
->type
);
520 myh
->type
= ELF_ST_INFO (bind
, STT_ARM_TFUNC
);
524 #define CHANGE_TO_ARM "__%s_change_to_arm"
525 #define BACK_FROM_ARM "__%s_back_from_arm"
527 /* Allocate another symbol to mark where we switch to Arm mode. */
528 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
529 + strlen (CHANGE_TO_ARM
) + 1);
531 BFD_ASSERT (tmp_name
);
533 sprintf (tmp_name
, CHANGE_TO_ARM
, name
);
537 val
= hash_table
->thumb_glue_size
+ 4,
538 _bfd_generic_link_add_one_symbol (link_info
, hash_table
->bfd_of_glue_owner
,
539 tmp_name
, BSF_LOCAL
, s
, val
,
541 (struct bfd_link_hash_entry
**) &myh
);
545 hash_table
->thumb_glue_size
+= THUMB2ARM_GLUE_SIZE
;
550 /* Select a BFD to be used to hold the sections used by the glue code.
551 This function is called from the linker scripts in ld/emultempl/
555 bfd_elf32_arm_get_bfd_for_interworking (abfd
, info
)
557 struct bfd_link_info
*info
;
559 struct elf32_arm_link_hash_table
*globals
;
563 /* If we are only performing a partial link do not bother
564 getting a bfd to hold the glue. */
565 if (info
->relocateable
)
568 globals
= elf32_arm_hash_table (info
);
570 BFD_ASSERT (globals
!= NULL
);
572 if (globals
->bfd_of_glue_owner
!= NULL
)
575 sec
= bfd_get_section_by_name (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
579 /* Note: we do not include the flag SEC_LINKER_CREATED, as this
580 will prevent elf_link_input_bfd() from processing the contents
582 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_CODE
| SEC_READONLY
;
584 sec
= bfd_make_section (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
587 || !bfd_set_section_flags (abfd
, sec
, flags
)
588 || !bfd_set_section_alignment (abfd
, sec
, 2))
591 /* Set the gc mark to prevent the section from being removed by garbage
592 collection, despite the fact that no relocs refer to this section. */
596 sec
= bfd_get_section_by_name (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
600 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_CODE
| SEC_READONLY
;
602 sec
= bfd_make_section (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
605 || !bfd_set_section_flags (abfd
, sec
, flags
)
606 || !bfd_set_section_alignment (abfd
, sec
, 2))
612 /* Save the bfd for later use. */
613 globals
->bfd_of_glue_owner
= abfd
;
619 bfd_elf32_arm_process_before_allocation (abfd
, link_info
, no_pipeline_knowledge
)
621 struct bfd_link_info
*link_info
;
622 int no_pipeline_knowledge
;
624 Elf_Internal_Shdr
*symtab_hdr
;
625 Elf_Internal_Rela
*free_relocs
= NULL
;
626 Elf_Internal_Rela
*irel
, *irelend
;
627 bfd_byte
*contents
= NULL
;
628 bfd_byte
*free_contents
= NULL
;
629 Elf32_External_Sym
*extsyms
= NULL
;
630 Elf32_External_Sym
*free_extsyms
= NULL
;
633 struct elf32_arm_link_hash_table
*globals
;
635 /* If we are only performing a partial link do not bother
636 to construct any glue. */
637 if (link_info
->relocateable
)
640 /* Here we have a bfd that is to be included on the link. We have a hook
641 to do reloc rummaging, before section sizes are nailed down. */
642 globals
= elf32_arm_hash_table (link_info
);
644 BFD_ASSERT (globals
!= NULL
);
645 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
647 globals
->no_pipeline_knowledge
= no_pipeline_knowledge
;
649 /* Rummage around all the relocs and map the glue vectors. */
650 sec
= abfd
->sections
;
655 for (; sec
!= NULL
; sec
= sec
->next
)
657 if (sec
->reloc_count
== 0)
660 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
662 /* Load the relocs. */
663 irel
= (_bfd_elf32_link_read_relocs (abfd
, sec
, (PTR
) NULL
,
664 (Elf_Internal_Rela
*) NULL
, false));
666 BFD_ASSERT (irel
!= 0);
668 irelend
= irel
+ sec
->reloc_count
;
669 for (; irel
< irelend
; irel
++)
672 unsigned long r_index
;
674 struct elf_link_hash_entry
*h
;
676 r_type
= ELF32_R_TYPE (irel
->r_info
);
677 r_index
= ELF32_R_SYM (irel
->r_info
);
679 /* These are the only relocation types we care about. */
680 if ( r_type
!= R_ARM_PC24
681 && r_type
!= R_ARM_THM_PC22
)
684 /* Get the section contents if we haven't done so already. */
685 if (contents
== NULL
)
687 /* Get cached copy if it exists. */
688 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
689 contents
= elf_section_data (sec
)->this_hdr
.contents
;
692 /* Go get them off disk. */
693 contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
694 if (contents
== NULL
)
697 free_contents
= contents
;
699 if (!bfd_get_section_contents (abfd
, sec
, contents
,
700 (file_ptr
) 0, sec
->_raw_size
))
705 /* Read this BFD's symbols if we haven't done so already. */
708 /* Get cached copy if it exists. */
709 if (symtab_hdr
->contents
!= NULL
)
710 extsyms
= (Elf32_External_Sym
*) symtab_hdr
->contents
;
713 /* Go get them off disk. */
714 extsyms
= ((Elf32_External_Sym
*)
715 bfd_malloc (symtab_hdr
->sh_size
));
719 free_extsyms
= extsyms
;
721 if (bfd_seek (abfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
722 || (bfd_bread (extsyms
, symtab_hdr
->sh_size
, abfd
)
723 != symtab_hdr
->sh_size
))
728 /* If the relocation is not against a symbol it cannot concern us. */
731 /* We don't care about local symbols. */
732 if (r_index
< symtab_hdr
->sh_info
)
735 /* This is an external symbol. */
736 r_index
-= symtab_hdr
->sh_info
;
737 h
= (struct elf_link_hash_entry
*)
738 elf_sym_hashes (abfd
)[r_index
];
740 /* If the relocation is against a static symbol it must be within
741 the current section and so cannot be a cross ARM/Thumb relocation. */
748 /* This one is a call from arm code. We need to look up
749 the target of the call. If it is a thumb target, we
751 if (ELF_ST_TYPE(h
->type
) == STT_ARM_TFUNC
)
752 record_arm_to_thumb_glue (link_info
, h
);
756 /* This one is a call from thumb code. We look
757 up the target of the call. If it is not a thumb
758 target, we insert glue. */
759 if (ELF_ST_TYPE (h
->type
) != STT_ARM_TFUNC
)
760 record_thumb_to_arm_glue (link_info
, h
);
772 if (free_relocs
!= NULL
)
774 if (free_contents
!= NULL
)
775 free (free_contents
);
776 if (free_extsyms
!= NULL
)
782 /* The thumb form of a long branch is a bit finicky, because the offset
783 encoding is split over two fields, each in it's own instruction. They
784 can occur in any order. So given a thumb form of long branch, and an
785 offset, insert the offset into the thumb branch and return finished
788 It takes two thumb instructions to encode the target address. Each has
789 11 bits to invest. The upper 11 bits are stored in one (identifed by
790 H-0.. see below), the lower 11 bits are stored in the other (identified
793 Combine together and shifted left by 1 (it's a half word address) and
797 H-0, upper address-0 = 000
799 H-1, lower address-0 = 800
801 They can be ordered either way, but the arm tools I've seen always put
802 the lower one first. It probably doesn't matter. krk@cygnus.com
804 XXX: Actually the order does matter. The second instruction (H-1)
805 moves the computed address into the PC, so it must be the second one
806 in the sequence. The problem, however is that whilst little endian code
807 stores the instructions in HI then LOW order, big endian code does the
808 reverse. nickc@cygnus.com. */
810 #define LOW_HI_ORDER 0xF800F000
811 #define HI_LOW_ORDER 0xF000F800
814 insert_thumb_branch (br_insn
, rel_off
)
818 unsigned int low_bits
;
819 unsigned int high_bits
;
821 BFD_ASSERT ((rel_off
& 1) != 1);
823 rel_off
>>= 1; /* Half word aligned address. */
824 low_bits
= rel_off
& 0x000007FF; /* The bottom 11 bits. */
825 high_bits
= (rel_off
>> 11) & 0x000007FF; /* The top 11 bits. */
827 if ((br_insn
& LOW_HI_ORDER
) == LOW_HI_ORDER
)
828 br_insn
= LOW_HI_ORDER
| (low_bits
<< 16) | high_bits
;
829 else if ((br_insn
& HI_LOW_ORDER
) == HI_LOW_ORDER
)
830 br_insn
= HI_LOW_ORDER
| (high_bits
<< 16) | low_bits
;
832 /* FIXME: abort is probably not the right call. krk@cygnus.com */
833 abort (); /* error - not a valid branch instruction form. */
838 /* Thumb code calling an ARM function. */
841 elf32_thumb_to_arm_stub (info
, name
, input_bfd
, output_bfd
, input_section
,
842 hit_data
, sym_sec
, offset
, addend
, val
)
843 struct bfd_link_info
* info
;
847 asection
* input_section
;
851 bfd_signed_vma addend
;
856 unsigned long int tmp
;
858 struct elf_link_hash_entry
* myh
;
859 struct elf32_arm_link_hash_table
* globals
;
861 myh
= find_thumb_glue (info
, name
, input_bfd
);
865 globals
= elf32_arm_hash_table (info
);
867 BFD_ASSERT (globals
!= NULL
);
868 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
870 my_offset
= myh
->root
.u
.def
.value
;
872 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
873 THUMB2ARM_GLUE_SECTION_NAME
);
875 BFD_ASSERT (s
!= NULL
);
876 BFD_ASSERT (s
->contents
!= NULL
);
877 BFD_ASSERT (s
->output_section
!= NULL
);
879 if ((my_offset
& 0x01) == 0x01)
882 && sym_sec
->owner
!= NULL
883 && !INTERWORK_FLAG (sym_sec
->owner
))
885 (*_bfd_error_handler
)
886 (_("%s(%s): warning: interworking not enabled."),
887 bfd_archive_filename (sym_sec
->owner
), name
);
888 (*_bfd_error_handler
)
889 (_(" first occurrence: %s: thumb call to arm"),
890 bfd_archive_filename (input_bfd
));
896 myh
->root
.u
.def
.value
= my_offset
;
898 bfd_put_16 (output_bfd
, (bfd_vma
) t2a1_bx_pc_insn
,
899 s
->contents
+ my_offset
);
901 bfd_put_16 (output_bfd
, (bfd_vma
) t2a2_noop_insn
,
902 s
->contents
+ my_offset
+ 2);
905 /* Address of destination of the stub. */
906 ((bfd_signed_vma
) val
)
908 /* Offset from the start of the current section to the start of the stubs. */
910 /* Offset of the start of this stub from the start of the stubs. */
912 /* Address of the start of the current section. */
913 + s
->output_section
->vma
)
914 /* The branch instruction is 4 bytes into the stub. */
916 /* ARM branches work from the pc of the instruction + 8. */
919 bfd_put_32 (output_bfd
,
920 (bfd_vma
) t2a3_b_insn
| ((ret_offset
>> 2) & 0x00FFFFFF),
921 s
->contents
+ my_offset
+ 4);
924 BFD_ASSERT (my_offset
<= globals
->thumb_glue_size
);
926 /* Now go back and fix up the original BL insn to point
928 ret_offset
= (s
->output_offset
930 - (input_section
->output_offset
934 tmp
= bfd_get_32 (input_bfd
, hit_data
935 - input_section
->vma
);
937 bfd_put_32 (output_bfd
,
938 (bfd_vma
) insert_thumb_branch (tmp
, ret_offset
),
939 hit_data
- input_section
->vma
);
944 /* Arm code calling a Thumb function. */
947 elf32_arm_to_thumb_stub (info
, name
, input_bfd
, output_bfd
, input_section
,
948 hit_data
, sym_sec
, offset
, addend
, val
)
949 struct bfd_link_info
* info
;
953 asection
* input_section
;
957 bfd_signed_vma addend
;
960 unsigned long int tmp
;
964 struct elf_link_hash_entry
* myh
;
965 struct elf32_arm_link_hash_table
* globals
;
967 myh
= find_arm_glue (info
, name
, input_bfd
);
971 globals
= elf32_arm_hash_table (info
);
973 BFD_ASSERT (globals
!= NULL
);
974 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
976 my_offset
= myh
->root
.u
.def
.value
;
977 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
978 ARM2THUMB_GLUE_SECTION_NAME
);
979 BFD_ASSERT (s
!= NULL
);
980 BFD_ASSERT (s
->contents
!= NULL
);
981 BFD_ASSERT (s
->output_section
!= NULL
);
983 if ((my_offset
& 0x01) == 0x01)
986 && sym_sec
->owner
!= NULL
987 && !INTERWORK_FLAG (sym_sec
->owner
))
989 (*_bfd_error_handler
)
990 (_("%s(%s): warning: interworking not enabled."),
991 bfd_archive_filename (sym_sec
->owner
), name
);
992 (*_bfd_error_handler
)
993 (_(" first occurrence: %s: arm call to thumb"),
994 bfd_archive_filename (input_bfd
));
998 myh
->root
.u
.def
.value
= my_offset
;
1000 bfd_put_32 (output_bfd
, (bfd_vma
) a2t1_ldr_insn
,
1001 s
->contents
+ my_offset
);
1003 bfd_put_32 (output_bfd
, (bfd_vma
) a2t2_bx_r12_insn
,
1004 s
->contents
+ my_offset
+ 4);
1006 /* It's a thumb address. Add the low order bit. */
1007 bfd_put_32 (output_bfd
, val
| a2t3_func_addr_insn
,
1008 s
->contents
+ my_offset
+ 8);
1011 BFD_ASSERT (my_offset
<= globals
->arm_glue_size
);
1013 tmp
= bfd_get_32 (input_bfd
, hit_data
);
1014 tmp
= tmp
& 0xFF000000;
1016 /* Somehow these are both 4 too far, so subtract 8. */
1017 ret_offset
= (s
->output_offset
1019 + s
->output_section
->vma
1020 - (input_section
->output_offset
1021 + input_section
->output_section
->vma
1025 tmp
= tmp
| ((ret_offset
>> 2) & 0x00FFFFFF);
1027 bfd_put_32 (output_bfd
, (bfd_vma
) tmp
, hit_data
- input_section
->vma
);
1032 /* Perform a relocation as part of a final link. */
1034 static bfd_reloc_status_type
1035 elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
1036 input_section
, contents
, rel
, value
,
1037 info
, sym_sec
, sym_name
, sym_flags
, h
)
1038 reloc_howto_type
* howto
;
1041 asection
* input_section
;
1042 bfd_byte
* contents
;
1043 Elf_Internal_Rela
* rel
;
1045 struct bfd_link_info
* info
;
1047 const char * sym_name
;
1049 struct elf_link_hash_entry
* h
;
1051 unsigned long r_type
= howto
->type
;
1052 unsigned long r_symndx
;
1053 bfd_byte
* hit_data
= contents
+ rel
->r_offset
;
1054 bfd
* dynobj
= NULL
;
1055 Elf_Internal_Shdr
* symtab_hdr
;
1056 struct elf_link_hash_entry
** sym_hashes
;
1057 bfd_vma
* local_got_offsets
;
1058 asection
* sgot
= NULL
;
1059 asection
* splt
= NULL
;
1060 asection
* sreloc
= NULL
;
1062 bfd_signed_vma signed_addend
;
1063 struct elf32_arm_link_hash_table
* globals
;
1065 /* If the start address has been set, then set the EF_ARM_HASENTRY
1066 flag. Setting this more than once is redundant, but the cost is
1067 not too high, and it keeps the code simple.
1069 The test is done here, rather than somewhere else, because the
1070 start address is only set just before the final link commences.
1072 Note - if the user deliberately sets a start address of 0, the
1073 flag will not be set. */
1074 if (bfd_get_start_address (output_bfd
) != 0)
1075 elf_elfheader (output_bfd
)->e_flags
|= EF_ARM_HASENTRY
;
1077 globals
= elf32_arm_hash_table (info
);
1079 dynobj
= elf_hash_table (info
)->dynobj
;
1082 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1083 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1085 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1086 sym_hashes
= elf_sym_hashes (input_bfd
);
1087 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1088 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1091 addend
= bfd_get_32 (input_bfd
, hit_data
) & howto
->src_mask
;
1093 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1096 signed_addend
&= ~ howto
->src_mask
;
1097 signed_addend
|= addend
;
1100 signed_addend
= addend
;
1102 addend
= signed_addend
= rel
->r_addend
;
1108 return bfd_reloc_ok
;
1116 /* When generating a shared object, these relocations are copied
1117 into the output file to be resolved at run time. */
1120 && (r_type
!= R_ARM_PC24
1123 && (! info
->symbolic
1124 || (h
->elf_link_hash_flags
1125 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1127 Elf_Internal_Rel outrel
;
1128 boolean skip
, relocate
;
1134 name
= (bfd_elf_string_from_elf_section
1136 elf_elfheader (input_bfd
)->e_shstrndx
,
1137 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1139 return bfd_reloc_notsupported
;
1141 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
1142 && strcmp (bfd_get_section_name (input_bfd
,
1146 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1147 BFD_ASSERT (sreloc
!= NULL
);
1154 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
1156 if (outrel
.r_offset
== (bfd_vma
) -1)
1158 else if (outrel
.r_offset
== (bfd_vma
) -2)
1159 skip
= true, relocate
= true;
1160 outrel
.r_offset
+= (input_section
->output_section
->vma
1161 + input_section
->output_offset
);
1164 memset (&outrel
, 0, sizeof outrel
);
1165 else if (r_type
== R_ARM_PC24
)
1167 BFD_ASSERT (h
!= NULL
&& h
->dynindx
!= -1);
1168 if ((input_section
->flags
& SEC_ALLOC
) == 0)
1170 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_PC24
);
1175 || ((info
->symbolic
|| h
->dynindx
== -1)
1176 && (h
->elf_link_hash_flags
1177 & ELF_LINK_HASH_DEF_REGULAR
) != 0))
1180 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1184 BFD_ASSERT (h
->dynindx
!= -1);
1185 if ((input_section
->flags
& SEC_ALLOC
) == 0)
1187 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_ABS32
);
1191 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1192 (((Elf32_External_Rel
*)
1194 + sreloc
->reloc_count
));
1195 ++sreloc
->reloc_count
;
1197 /* If this reloc is against an external symbol, we do not want to
1198 fiddle with the addend. Otherwise, we need to include the symbol
1199 value so that it becomes an addend for the dynamic reloc. */
1201 return bfd_reloc_ok
;
1203 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1204 contents
, rel
->r_offset
, value
,
1207 else switch (r_type
)
1210 case R_ARM_XPC25
: /* Arm BLX instruction. */
1212 case R_ARM_PC24
: /* Arm B/BL instruction */
1214 if (r_type
== R_ARM_XPC25
)
1216 /* Check for Arm calling Arm function. */
1217 /* FIXME: Should we translate the instruction into a BL
1218 instruction instead ? */
1219 if (sym_flags
!= STT_ARM_TFUNC
)
1220 (*_bfd_error_handler
) (_("\
1221 %s: Warning: Arm BLX instruction targets Arm function '%s'."),
1222 bfd_archive_filename (input_bfd
),
1223 h
? h
->root
.root
.string
: "(local)");
1228 /* Check for Arm calling Thumb function. */
1229 if (sym_flags
== STT_ARM_TFUNC
)
1231 elf32_arm_to_thumb_stub (info
, sym_name
, input_bfd
, output_bfd
,
1232 input_section
, hit_data
, sym_sec
, rel
->r_offset
,
1233 signed_addend
, value
);
1234 return bfd_reloc_ok
;
1238 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1239 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0)
1241 /* The old way of doing things. Trearing the addend as a
1242 byte sized field and adding in the pipeline offset. */
1243 value
-= (input_section
->output_section
->vma
1244 + input_section
->output_offset
);
1245 value
-= rel
->r_offset
;
1248 if (! globals
->no_pipeline_knowledge
)
1253 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
1255 S is the address of the symbol in the relocation.
1256 P is address of the instruction being relocated.
1257 A is the addend (extracted from the instruction) in bytes.
1259 S is held in 'value'.
1260 P is the base address of the section containing the instruction
1261 plus the offset of the reloc into that section, ie:
1262 (input_section->output_section->vma +
1263 input_section->output_offset +
1265 A is the addend, converted into bytes, ie:
1268 Note: None of these operations have knowledge of the pipeline
1269 size of the processor, thus it is up to the assembler to encode
1270 this information into the addend. */
1271 value
-= (input_section
->output_section
->vma
1272 + input_section
->output_offset
);
1273 value
-= rel
->r_offset
;
1274 value
+= (signed_addend
<< howto
->size
);
1276 /* Previous versions of this code also used to add in the pipeline
1277 offset here. This is wrong because the linker is not supposed
1278 to know about such things, and one day it might change. In order
1279 to support old binaries that need the old behaviour however, so
1280 we attempt to detect which ABI was used to create the reloc. */
1281 if (! globals
->no_pipeline_knowledge
)
1283 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form */
1285 i_ehdrp
= elf_elfheader (input_bfd
);
1287 if (i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1292 signed_addend
= value
;
1293 signed_addend
>>= howto
->rightshift
;
1295 /* It is not an error for an undefined weak reference to be
1296 out of range. Any program that branches to such a symbol
1297 is going to crash anyway, so there is no point worrying
1298 about getting the destination exactly right. */
1299 if (! h
|| h
->root
.type
!= bfd_link_hash_undefweak
)
1301 /* Perform a signed range check. */
1302 if ( signed_addend
> ((bfd_signed_vma
) (howto
->dst_mask
>> 1))
1303 || signed_addend
< - ((bfd_signed_vma
) ((howto
->dst_mask
+ 1) >> 1)))
1304 return bfd_reloc_overflow
;
1308 /* If necessary set the H bit in the BLX instruction. */
1309 if (r_type
== R_ARM_XPC25
&& ((value
& 2) == 2))
1310 value
= (signed_addend
& howto
->dst_mask
)
1311 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
))
1315 value
= (signed_addend
& howto
->dst_mask
)
1316 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1321 if (sym_flags
== STT_ARM_TFUNC
)
1326 value
-= (input_section
->output_section
->vma
1327 + input_section
->output_offset
+ rel
->r_offset
);
1332 bfd_put_32 (input_bfd
, value
, hit_data
);
1333 return bfd_reloc_ok
;
1337 if ((long) value
> 0x7f || (long) value
< -0x80)
1338 return bfd_reloc_overflow
;
1340 bfd_put_8 (input_bfd
, value
, hit_data
);
1341 return bfd_reloc_ok
;
1346 if ((long) value
> 0x7fff || (long) value
< -0x8000)
1347 return bfd_reloc_overflow
;
1349 bfd_put_16 (input_bfd
, value
, hit_data
);
1350 return bfd_reloc_ok
;
1353 /* Support ldr and str instruction for the arm */
1354 /* Also thumb b (unconditional branch). ??? Really? */
1357 if ((long) value
> 0x7ff || (long) value
< -0x800)
1358 return bfd_reloc_overflow
;
1360 value
|= (bfd_get_32 (input_bfd
, hit_data
) & 0xfffff000);
1361 bfd_put_32 (input_bfd
, value
, hit_data
);
1362 return bfd_reloc_ok
;
1364 case R_ARM_THM_ABS5
:
1365 /* Support ldr and str instructions for the thumb. */
1367 /* Need to refetch addend. */
1368 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1369 /* ??? Need to determine shift amount from operand size. */
1370 addend
>>= howto
->rightshift
;
1374 /* ??? Isn't value unsigned? */
1375 if ((long) value
> 0x1f || (long) value
< -0x10)
1376 return bfd_reloc_overflow
;
1378 /* ??? Value needs to be properly shifted into place first. */
1379 value
|= bfd_get_16 (input_bfd
, hit_data
) & 0xf83f;
1380 bfd_put_16 (input_bfd
, value
, hit_data
);
1381 return bfd_reloc_ok
;
1384 case R_ARM_THM_XPC22
:
1386 case R_ARM_THM_PC22
:
1387 /* Thumb BL (branch long instruction). */
1390 boolean overflow
= false;
1391 bfd_vma upper_insn
= bfd_get_16 (input_bfd
, hit_data
);
1392 bfd_vma lower_insn
= bfd_get_16 (input_bfd
, hit_data
+ 2);
1393 bfd_signed_vma reloc_signed_max
= ((1 << (howto
->bitsize
- 1)) - 1) >> howto
->rightshift
;
1394 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1396 bfd_signed_vma signed_check
;
1399 /* Need to refetch the addend and squish the two 11 bit pieces
1402 bfd_vma upper
= upper_insn
& 0x7ff;
1403 bfd_vma lower
= lower_insn
& 0x7ff;
1404 upper
= (upper
^ 0x400) - 0x400; /* Sign extend. */
1405 addend
= (upper
<< 12) | (lower
<< 1);
1406 signed_addend
= addend
;
1410 if (r_type
== R_ARM_THM_XPC22
)
1412 /* Check for Thumb to Thumb call. */
1413 /* FIXME: Should we translate the instruction into a BL
1414 instruction instead ? */
1415 if (sym_flags
== STT_ARM_TFUNC
)
1416 (*_bfd_error_handler
) (_("\
1417 %s: Warning: Thumb BLX instruction targets thumb function '%s'."),
1418 bfd_archive_filename (input_bfd
),
1419 h
? h
->root
.root
.string
: "(local)");
1424 /* If it is not a call to Thumb, assume call to Arm.
1425 If it is a call relative to a section name, then it is not a
1426 function call at all, but rather a long jump. */
1427 if (sym_flags
!= STT_ARM_TFUNC
&& sym_flags
!= STT_SECTION
)
1429 if (elf32_thumb_to_arm_stub
1430 (info
, sym_name
, input_bfd
, output_bfd
, input_section
,
1431 hit_data
, sym_sec
, rel
->r_offset
, signed_addend
, value
))
1432 return bfd_reloc_ok
;
1434 return bfd_reloc_dangerous
;
1438 relocation
= value
+ signed_addend
;
1440 relocation
-= (input_section
->output_section
->vma
1441 + input_section
->output_offset
1444 if (! globals
->no_pipeline_knowledge
)
1446 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form. */
1448 i_ehdrp
= elf_elfheader (input_bfd
);
1450 /* Previous versions of this code also used to add in the pipline
1451 offset here. This is wrong because the linker is not supposed
1452 to know about such things, and one day it might change. In order
1453 to support old binaries that need the old behaviour however, so
1454 we attempt to detect which ABI was used to create the reloc. */
1455 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1456 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0
1457 || i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1461 check
= relocation
>> howto
->rightshift
;
1463 /* If this is a signed value, the rightshift just dropped
1464 leading 1 bits (assuming twos complement). */
1465 if ((bfd_signed_vma
) relocation
>= 0)
1466 signed_check
= check
;
1468 signed_check
= check
| ~((bfd_vma
) -1 >> howto
->rightshift
);
1470 /* Assumes two's complement. */
1471 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1474 /* Put RELOCATION back into the insn. */
1475 upper_insn
= (upper_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 12) & 0x7ff);
1476 lower_insn
= (lower_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 1) & 0x7ff);
1479 if (r_type
== R_ARM_THM_XPC22
1480 && ((lower_insn
& 0x1800) == 0x0800))
1481 /* Remove bit zero of the adjusted offset. Bit zero can only be
1482 set if the upper insn is at a half-word boundary, since the
1483 destination address, an ARM instruction, must always be on a
1484 word boundary. The semantics of the BLX (1) instruction, however,
1485 are that bit zero in the offset must always be zero, and the
1486 corresponding bit one in the target address will be set from bit
1487 one of the source address. */
1490 /* Put the relocated value back in the object file: */
1491 bfd_put_16 (input_bfd
, upper_insn
, hit_data
);
1492 bfd_put_16 (input_bfd
, lower_insn
, hit_data
+ 2);
1494 return (overflow
? bfd_reloc_overflow
: bfd_reloc_ok
);
1498 case R_ARM_THM_PC11
:
1499 /* Thumb B (branch) instruction). */
1502 bfd_signed_vma reloc_signed_max
= (1 << (howto
->bitsize
- 1)) - 1;
1503 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1505 bfd_signed_vma signed_check
;
1508 /* Need to refetch addend. */
1509 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1510 /* ??? Need to determine shift amount from operand size. */
1511 addend
>>= howto
->rightshift
;
1513 relocation
= value
+ addend
;
1515 relocation
-= (input_section
->output_section
->vma
1516 + input_section
->output_offset
1519 check
= relocation
>> howto
->rightshift
;
1521 /* If this is a signed value, the rightshift just
1522 dropped leading 1 bits (assuming twos complement). */
1523 if ((bfd_signed_vma
) relocation
>= 0)
1524 signed_check
= check
;
1526 signed_check
= check
| ~((bfd_vma
) -1 >> howto
->rightshift
);
1528 relocation
|= (bfd_get_16 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1530 bfd_put_16 (input_bfd
, relocation
, hit_data
);
1532 /* Assumes two's complement. */
1533 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1534 return bfd_reloc_overflow
;
1536 return bfd_reloc_ok
;
1539 case R_ARM_GNU_VTINHERIT
:
1540 case R_ARM_GNU_VTENTRY
:
1541 return bfd_reloc_ok
;
1544 return bfd_reloc_notsupported
;
1546 case R_ARM_GLOB_DAT
:
1547 return bfd_reloc_notsupported
;
1549 case R_ARM_JUMP_SLOT
:
1550 return bfd_reloc_notsupported
;
1552 case R_ARM_RELATIVE
:
1553 return bfd_reloc_notsupported
;
1556 /* Relocation is relative to the start of the
1557 global offset table. */
1559 BFD_ASSERT (sgot
!= NULL
);
1561 return bfd_reloc_notsupported
;
1563 /* If we are addressing a Thumb function, we need to adjust the
1564 address by one, so that attempts to call the function pointer will
1565 correctly interpret it as Thumb code. */
1566 if (sym_flags
== STT_ARM_TFUNC
)
1569 /* Note that sgot->output_offset is not involved in this
1570 calculation. We always want the start of .got. If we
1571 define _GLOBAL_OFFSET_TABLE in a different way, as is
1572 permitted by the ABI, we might have to change this
1574 value
-= sgot
->output_section
->vma
;
1575 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1576 contents
, rel
->r_offset
, value
,
1580 /* Use global offset table as symbol value. */
1581 BFD_ASSERT (sgot
!= NULL
);
1584 return bfd_reloc_notsupported
;
1586 value
= sgot
->output_section
->vma
;
1587 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1588 contents
, rel
->r_offset
, value
,
1592 /* Relocation is to the entry for this symbol in the
1593 global offset table. */
1595 return bfd_reloc_notsupported
;
1601 off
= h
->got
.offset
;
1602 BFD_ASSERT (off
!= (bfd_vma
) -1);
1604 if (!elf_hash_table (info
)->dynamic_sections_created
||
1605 (info
->shared
&& (info
->symbolic
|| h
->dynindx
== -1)
1606 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1608 /* This is actually a static link, or it is a -Bsymbolic link
1609 and the symbol is defined locally. We must initialize this
1610 entry in the global offset table. Since the offset must
1611 always be a multiple of 4, we use the least significant bit
1612 to record whether we have initialized it already.
1614 When doing a dynamic link, we create a .rel.got relocation
1615 entry to initialize the value. This is done in the
1616 finish_dynamic_symbol routine. */
1621 /* If we are addressing a Thumb function, we need to
1622 adjust the address by one, so that attempts to
1623 call the function pointer will correctly
1624 interpret it as Thumb code. */
1625 if (sym_flags
== STT_ARM_TFUNC
)
1628 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1633 value
= sgot
->output_offset
+ off
;
1639 BFD_ASSERT (local_got_offsets
!= NULL
&&
1640 local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1642 off
= local_got_offsets
[r_symndx
];
1644 /* The offset must always be a multiple of 4. We use the
1645 least significant bit to record whether we have already
1646 generated the necessary reloc. */
1651 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1656 Elf_Internal_Rel outrel
;
1658 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
1659 BFD_ASSERT (srelgot
!= NULL
);
1661 outrel
.r_offset
= (sgot
->output_section
->vma
1662 + sgot
->output_offset
1664 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1665 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1666 (((Elf32_External_Rel
*)
1668 + srelgot
->reloc_count
));
1669 ++srelgot
->reloc_count
;
1672 local_got_offsets
[r_symndx
] |= 1;
1675 value
= sgot
->output_offset
+ off
;
1678 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1679 contents
, rel
->r_offset
, value
,
1683 /* Relocation is to the entry for this symbol in the
1684 procedure linkage table. */
1686 /* Resolve a PLT32 reloc against a local symbol directly,
1687 without using the procedure linkage table. */
1689 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1690 contents
, rel
->r_offset
, value
,
1693 if (h
->plt
.offset
== (bfd_vma
) -1)
1694 /* We didn't make a PLT entry for this symbol. This
1695 happens when statically linking PIC code, or when
1696 using -Bsymbolic. */
1697 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1698 contents
, rel
->r_offset
, value
,
1701 BFD_ASSERT(splt
!= NULL
);
1703 return bfd_reloc_notsupported
;
1705 value
= (splt
->output_section
->vma
1706 + splt
->output_offset
1708 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1709 contents
, rel
->r_offset
, value
,
1713 return bfd_reloc_notsupported
;
1715 case R_ARM_AMP_VCALL9
:
1716 return bfd_reloc_notsupported
;
1718 case R_ARM_RSBREL32
:
1719 return bfd_reloc_notsupported
;
1721 case R_ARM_THM_RPC22
:
1722 return bfd_reloc_notsupported
;
1725 return bfd_reloc_notsupported
;
1728 return bfd_reloc_notsupported
;
1731 return bfd_reloc_notsupported
;
1734 return bfd_reloc_notsupported
;
1737 return bfd_reloc_notsupported
;
1742 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
1744 arm_add_to_rel (abfd
, address
, howto
, increment
)
1747 reloc_howto_type
* howto
;
1748 bfd_signed_vma increment
;
1750 bfd_signed_vma addend
;
1752 if (howto
->type
== R_ARM_THM_PC22
)
1754 int upper_insn
, lower_insn
;
1757 upper_insn
= bfd_get_16 (abfd
, address
);
1758 lower_insn
= bfd_get_16 (abfd
, address
+ 2);
1759 upper
= upper_insn
& 0x7ff;
1760 lower
= lower_insn
& 0x7ff;
1762 addend
= (upper
<< 12) | (lower
<< 1);
1763 addend
+= increment
;
1766 upper_insn
= (upper_insn
& 0xf800) | ((addend
>> 11) & 0x7ff);
1767 lower_insn
= (lower_insn
& 0xf800) | (addend
& 0x7ff);
1769 bfd_put_16 (abfd
, (bfd_vma
) upper_insn
, address
);
1770 bfd_put_16 (abfd
, (bfd_vma
) lower_insn
, address
+ 2);
1776 contents
= bfd_get_32 (abfd
, address
);
1778 /* Get the (signed) value from the instruction. */
1779 addend
= contents
& howto
->src_mask
;
1780 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1782 bfd_signed_vma mask
;
1785 mask
&= ~ howto
->src_mask
;
1789 /* Add in the increment, (which is a byte value). */
1790 switch (howto
->type
)
1793 addend
+= increment
;
1797 addend
<<= howto
->size
;
1798 addend
+= increment
;
1800 /* Should we check for overflow here ? */
1802 /* Drop any undesired bits. */
1803 addend
>>= howto
->rightshift
;
1807 contents
= (contents
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
1809 bfd_put_32 (abfd
, contents
, address
);
1812 #endif /* USE_REL */
1814 /* Relocate an ARM ELF section. */
1816 elf32_arm_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1817 contents
, relocs
, local_syms
, local_sections
)
1819 struct bfd_link_info
* info
;
1821 asection
* input_section
;
1822 bfd_byte
* contents
;
1823 Elf_Internal_Rela
* relocs
;
1824 Elf_Internal_Sym
* local_syms
;
1825 asection
** local_sections
;
1827 Elf_Internal_Shdr
* symtab_hdr
;
1828 struct elf_link_hash_entry
** sym_hashes
;
1829 Elf_Internal_Rela
* rel
;
1830 Elf_Internal_Rela
* relend
;
1834 if (info
->relocateable
)
1838 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1839 sym_hashes
= elf_sym_hashes (input_bfd
);
1842 relend
= relocs
+ input_section
->reloc_count
;
1843 for (; rel
< relend
; rel
++)
1846 reloc_howto_type
* howto
;
1847 unsigned long r_symndx
;
1848 Elf_Internal_Sym
* sym
;
1850 struct elf_link_hash_entry
* h
;
1852 bfd_reloc_status_type r
;
1855 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1856 r_type
= ELF32_R_TYPE (rel
->r_info
);
1858 if ( r_type
== R_ARM_GNU_VTENTRY
1859 || r_type
== R_ARM_GNU_VTINHERIT
)
1863 elf32_arm_info_to_howto (input_bfd
, & bfd_reloc
,
1864 (Elf_Internal_Rel
*) rel
);
1866 elf32_arm_info_to_howto (input_bfd
, & bfd_reloc
, rel
);
1868 howto
= bfd_reloc
.howto
;
1871 if (info
->relocateable
)
1873 /* This is a relocateable link. We don't have to change
1874 anything, unless the reloc is against a section symbol,
1875 in which case we have to adjust according to where the
1876 section symbol winds up in the output section. */
1877 if (r_symndx
< symtab_hdr
->sh_info
)
1879 sym
= local_syms
+ r_symndx
;
1880 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1882 sec
= local_sections
[r_symndx
];
1883 arm_add_to_rel (input_bfd
, contents
+ rel
->r_offset
,
1885 (bfd_signed_vma
) (sec
->output_offset
1894 /* This is a final link. */
1899 if (r_symndx
< symtab_hdr
->sh_info
)
1901 sym
= local_syms
+ r_symndx
;
1902 sec
= local_sections
[r_symndx
];
1904 relocation
= (sec
->output_section
->vma
1905 + sec
->output_offset
1907 if ((sec
->flags
& SEC_MERGE
)
1908 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1911 bfd_vma addend
, value
;
1913 if (howto
->rightshift
)
1915 (*_bfd_error_handler
)
1916 (_("%s(%s+0x%lx): %s relocation against SEC_MERGE section"),
1917 bfd_archive_filename (input_bfd
),
1918 bfd_get_section_name (input_bfd
, input_section
),
1919 (long) rel
->r_offset
, howto
->name
);
1923 value
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1925 /* Get the (signed) value from the instruction. */
1926 addend
= value
& howto
->src_mask
;
1927 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1929 bfd_signed_vma mask
;
1932 mask
&= ~ howto
->src_mask
;
1937 _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
)
1939 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
1940 value
= (value
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
1941 bfd_put_32 (input_bfd
, value
, contents
+ rel
->r_offset
);
1944 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, sec
, rel
);
1949 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1951 while ( h
->root
.type
== bfd_link_hash_indirect
1952 || h
->root
.type
== bfd_link_hash_warning
)
1953 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1955 if ( h
->root
.type
== bfd_link_hash_defined
1956 || h
->root
.type
== bfd_link_hash_defweak
)
1958 int relocation_needed
= 1;
1960 sec
= h
->root
.u
.def
.section
;
1962 /* In these cases, we don't need the relocation value.
1963 We check specially because in some obscure cases
1964 sec->output_section will be NULL. */
1969 case R_ARM_THM_PC22
:
1972 (!info
->symbolic
&& h
->dynindx
!= -1)
1973 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1975 && ((input_section
->flags
& SEC_ALLOC
) != 0
1976 /* DWARF will emit R_ARM_ABS32 relocations in its
1977 sections against symbols defined externally
1978 in shared libraries. We can't do anything
1980 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
1981 && (h
->elf_link_hash_flags
1982 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
1984 relocation_needed
= 0;
1988 relocation_needed
= 0;
1992 if (elf_hash_table(info
)->dynamic_sections_created
1994 || (!info
->symbolic
&& h
->dynindx
!= -1)
1995 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1998 relocation_needed
= 0;
2002 if (h
->plt
.offset
!= (bfd_vma
)-1)
2003 relocation_needed
= 0;
2007 if (sec
->output_section
== NULL
)
2009 (*_bfd_error_handler
)
2010 (_("%s: warning: unresolvable relocation %d against symbol `%s' from %s section"),
2011 bfd_archive_filename (input_bfd
),
2013 h
->root
.root
.string
,
2014 bfd_get_section_name (input_bfd
, input_section
));
2015 relocation_needed
= 0;
2019 if (relocation_needed
)
2020 relocation
= h
->root
.u
.def
.value
2021 + sec
->output_section
->vma
2022 + sec
->output_offset
;
2026 else if (h
->root
.type
== bfd_link_hash_undefweak
)
2028 else if (info
->shared
&& !info
->symbolic
2029 && !info
->no_undefined
2030 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
2034 if (!((*info
->callbacks
->undefined_symbol
)
2035 (info
, h
->root
.root
.string
, input_bfd
,
2036 input_section
, rel
->r_offset
,
2037 (!info
->shared
|| info
->no_undefined
2038 || ELF_ST_VISIBILITY (h
->other
)))))
2045 name
= h
->root
.root
.string
;
2048 name
= (bfd_elf_string_from_elf_section
2049 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2050 if (name
== NULL
|| *name
== '\0')
2051 name
= bfd_section_name (input_bfd
, sec
);
2054 r
= elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
2055 input_section
, contents
, rel
,
2056 relocation
, info
, sec
, name
,
2057 (h
? ELF_ST_TYPE (h
->type
) :
2058 ELF_ST_TYPE (sym
->st_info
)), h
);
2060 if (r
!= bfd_reloc_ok
)
2062 const char * msg
= (const char *) 0;
2066 case bfd_reloc_overflow
:
2067 /* If the overflowing reloc was to an undefined symbol,
2068 we have already printed one error message and there
2069 is no point complaining again. */
2071 h
->root
.type
!= bfd_link_hash_undefined
)
2072 && (!((*info
->callbacks
->reloc_overflow
)
2073 (info
, name
, howto
->name
, (bfd_vma
) 0,
2074 input_bfd
, input_section
, rel
->r_offset
))))
2078 case bfd_reloc_undefined
:
2079 if (!((*info
->callbacks
->undefined_symbol
)
2080 (info
, name
, input_bfd
, input_section
,
2081 rel
->r_offset
, true)))
2085 case bfd_reloc_outofrange
:
2086 msg
= _("internal error: out of range error");
2089 case bfd_reloc_notsupported
:
2090 msg
= _("internal error: unsupported relocation error");
2093 case bfd_reloc_dangerous
:
2094 msg
= _("internal error: dangerous error");
2098 msg
= _("internal error: unknown error");
2102 if (!((*info
->callbacks
->warning
)
2103 (info
, msg
, name
, input_bfd
, input_section
,
2114 /* Function to keep ARM specific flags in the ELF header. */
2116 elf32_arm_set_private_flags (abfd
, flags
)
2120 if (elf_flags_init (abfd
)
2121 && elf_elfheader (abfd
)->e_flags
!= flags
)
2123 if (EF_ARM_EABI_VERSION (flags
) == EF_ARM_EABI_UNKNOWN
)
2125 if (flags
& EF_ARM_INTERWORK
)
2126 (*_bfd_error_handler
) (_("\
2127 Warning: Not setting interworking flag of %s since it has already been specified as non-interworking"),
2128 bfd_archive_filename (abfd
));
2130 _bfd_error_handler (_("\
2131 Warning: Clearing the interworking flag of %s due to outside request"),
2132 bfd_archive_filename (abfd
));
2137 elf_elfheader (abfd
)->e_flags
= flags
;
2138 elf_flags_init (abfd
) = true;
2144 /* Copy backend specific data from one object module to another. */
2147 elf32_arm_copy_private_bfd_data (ibfd
, obfd
)
2154 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2155 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2158 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2159 out_flags
= elf_elfheader (obfd
)->e_flags
;
2161 if (elf_flags_init (obfd
)
2162 && EF_ARM_EABI_VERSION (out_flags
) == EF_ARM_EABI_UNKNOWN
2163 && in_flags
!= out_flags
)
2165 /* Cannot mix APCS26 and APCS32 code. */
2166 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2169 /* Cannot mix float APCS and non-float APCS code. */
2170 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2173 /* If the src and dest have different interworking flags
2174 then turn off the interworking bit. */
2175 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2177 if (out_flags
& EF_ARM_INTERWORK
)
2178 _bfd_error_handler (_("\
2179 Warning: Clearing the interworking flag of %s because non-interworking code in %s has been linked with it"),
2180 bfd_get_filename (obfd
),
2181 bfd_archive_filename (ibfd
));
2183 in_flags
&= ~EF_ARM_INTERWORK
;
2186 /* Likewise for PIC, though don't warn for this case. */
2187 if ((in_flags
& EF_ARM_PIC
) != (out_flags
& EF_ARM_PIC
))
2188 in_flags
&= ~EF_ARM_PIC
;
2191 elf_elfheader (obfd
)->e_flags
= in_flags
;
2192 elf_flags_init (obfd
) = true;
2197 /* Merge backend specific data from an object file to the output
2198 object file when linking. */
2201 elf32_arm_merge_private_bfd_data (ibfd
, obfd
)
2207 boolean flags_compatible
= true;
2208 boolean null_input_bfd
= true;
2211 /* Check if we have the same endianess. */
2212 if (_bfd_generic_verify_endian_match (ibfd
, obfd
) == false)
2215 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2216 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2219 /* The input BFD must have had its flags initialised. */
2220 /* The following seems bogus to me -- The flags are initialized in
2221 the assembler but I don't think an elf_flags_init field is
2222 written into the object. */
2223 /* BFD_ASSERT (elf_flags_init (ibfd)); */
2225 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2226 out_flags
= elf_elfheader (obfd
)->e_flags
;
2228 if (!elf_flags_init (obfd
))
2230 /* If the input is the default architecture and had the default
2231 flags then do not bother setting the flags for the output
2232 architecture, instead allow future merges to do this. If no
2233 future merges ever set these flags then they will retain their
2234 uninitialised values, which surprise surprise, correspond
2235 to the default values. */
2236 if (bfd_get_arch_info (ibfd
)->the_default
2237 && elf_elfheader (ibfd
)->e_flags
== 0)
2240 elf_flags_init (obfd
) = true;
2241 elf_elfheader (obfd
)->e_flags
= in_flags
;
2243 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
2244 && bfd_get_arch_info (obfd
)->the_default
)
2245 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
), bfd_get_mach (ibfd
));
2250 /* Identical flags must be compatible. */
2251 if (in_flags
== out_flags
)
2254 /* Check to see if the input BFD actually contains any sections.
2255 If not, its flags may not have been initialised either, but it cannot
2256 actually cause any incompatibility. */
2257 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2259 /* Ignore synthetic glue sections. */
2260 if (strcmp (sec
->name
, ".glue_7")
2261 && strcmp (sec
->name
, ".glue_7t"))
2263 null_input_bfd
= false;
2270 /* Complain about various flag mismatches. */
2271 if (EF_ARM_EABI_VERSION (in_flags
) != EF_ARM_EABI_VERSION (out_flags
))
2273 _bfd_error_handler (_("\
2274 ERROR: %s is compiled for EABI version %d, whereas %s is compiled for version %d"),
2275 bfd_archive_filename (ibfd
),
2276 (in_flags
& EF_ARM_EABIMASK
) >> 24,
2277 bfd_get_filename (obfd
),
2278 (out_flags
& EF_ARM_EABIMASK
) >> 24);
2282 /* Not sure what needs to be checked for EABI versions >= 1. */
2283 if (EF_ARM_EABI_VERSION (in_flags
) == EF_ARM_EABI_UNKNOWN
)
2285 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2287 _bfd_error_handler (_("\
2288 ERROR: %s is compiled for APCS-%d, whereas target %s uses APCS-%d"),
2289 bfd_archive_filename (ibfd
),
2290 in_flags
& EF_ARM_APCS_26
? 26 : 32,
2291 bfd_get_filename (obfd
),
2292 out_flags
& EF_ARM_APCS_26
? 26 : 32);
2293 flags_compatible
= false;
2296 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2298 if (in_flags
& EF_ARM_APCS_FLOAT
)
2299 _bfd_error_handler (_("\
2300 ERROR: %s passes floats in float registers, whereas %s passes them in integer registers"),
2301 bfd_archive_filename (ibfd
),
2302 bfd_get_filename (obfd
));
2304 _bfd_error_handler (_("\
2305 ERROR: %s passes floats in integer registers, whereas %s passes them in float registers"),
2306 bfd_archive_filename (ibfd
),
2307 bfd_get_filename (obfd
));
2309 flags_compatible
= false;
2312 if ((in_flags
& EF_ARM_VFP_FLOAT
) != (out_flags
& EF_ARM_VFP_FLOAT
))
2314 if (in_flags
& EF_ARM_VFP_FLOAT
)
2315 _bfd_error_handler (_("\
2316 ERROR: %s uses VFP instructions, whereas %s uses FPA instructions"),
2317 bfd_archive_filename (ibfd
),
2318 bfd_get_filename (obfd
));
2320 _bfd_error_handler (_("\
2321 ERROR: %s uses FPA instructions, whereas %s uses VFP instructions"),
2322 bfd_archive_filename (ibfd
),
2323 bfd_get_filename (obfd
));
2325 flags_compatible
= false;
2328 #ifdef EF_ARM_SOFT_FLOAT
2329 if ((in_flags
& EF_ARM_SOFT_FLOAT
) != (out_flags
& EF_ARM_SOFT_FLOAT
))
2331 /* We can allow interworking between code that is VFP format
2332 layout, and uses either soft float or integer regs for
2333 passing floating point arguments and results. We already
2334 know that the APCS_FLOAT flags match; similarly for VFP
2336 if ((in_flags
& EF_ARM_APCS_FLOAT
) != 0
2337 || (in_flags
& EF_ARM_VFP_FLOAT
) == 0)
2339 if (in_flags
& EF_ARM_SOFT_FLOAT
)
2340 _bfd_error_handler (_("\
2341 ERROR: %s uses software FP, whereas %s uses hardware FP"),
2342 bfd_archive_filename (ibfd
),
2343 bfd_get_filename (obfd
));
2345 _bfd_error_handler (_("\
2346 ERROR: %s uses hardware FP, whereas %s uses software FP"),
2347 bfd_archive_filename (ibfd
),
2348 bfd_get_filename (obfd
));
2350 flags_compatible
= false;
2355 /* Interworking mismatch is only a warning. */
2356 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2358 if (in_flags
& EF_ARM_INTERWORK
)
2360 _bfd_error_handler (_("\
2361 Warning: %s supports interworking, whereas %s does not"),
2362 bfd_archive_filename (ibfd
),
2363 bfd_get_filename (obfd
));
2367 _bfd_error_handler (_("\
2368 Warning: %s does not support interworking, whereas %s does"),
2369 bfd_archive_filename (ibfd
),
2370 bfd_get_filename (obfd
));
2375 return flags_compatible
;
2378 /* Display the flags field. */
2381 elf32_arm_print_private_bfd_data (abfd
, ptr
)
2385 FILE * file
= (FILE *) ptr
;
2386 unsigned long flags
;
2388 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
2390 /* Print normal ELF private data. */
2391 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
2393 flags
= elf_elfheader (abfd
)->e_flags
;
2394 /* Ignore init flag - it may not be set, despite the flags field
2395 containing valid data. */
2397 /* xgettext:c-format */
2398 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
2400 switch (EF_ARM_EABI_VERSION (flags
))
2402 case EF_ARM_EABI_UNKNOWN
:
2403 /* The following flag bits are GNU extenstions and not part of the
2404 official ARM ELF extended ABI. Hence they are only decoded if
2405 the EABI version is not set. */
2406 if (flags
& EF_ARM_INTERWORK
)
2407 fprintf (file
, _(" [interworking enabled]"));
2409 if (flags
& EF_ARM_APCS_26
)
2410 fprintf (file
, " [APCS-26]");
2412 fprintf (file
, " [APCS-32]");
2414 if (flags
& EF_ARM_VFP_FLOAT
)
2415 fprintf (file
, _(" [VFP float format]"));
2417 fprintf (file
, _(" [FPA float format]"));
2419 if (flags
& EF_ARM_APCS_FLOAT
)
2420 fprintf (file
, _(" [floats passed in float registers]"));
2422 if (flags
& EF_ARM_PIC
)
2423 fprintf (file
, _(" [position independent]"));
2425 if (flags
& EF_ARM_NEW_ABI
)
2426 fprintf (file
, _(" [new ABI]"));
2428 if (flags
& EF_ARM_OLD_ABI
)
2429 fprintf (file
, _(" [old ABI]"));
2431 if (flags
& EF_ARM_SOFT_FLOAT
)
2432 fprintf (file
, _(" [software FP]"));
2434 flags
&= ~(EF_ARM_INTERWORK
| EF_ARM_APCS_26
| EF_ARM_APCS_FLOAT
2435 | EF_ARM_PIC
| EF_ARM_NEW_ABI
| EF_ARM_OLD_ABI
2436 | EF_ARM_SOFT_FLOAT
| EF_ARM_VFP_FLOAT
);
2439 case EF_ARM_EABI_VER1
:
2440 fprintf (file
, _(" [Version1 EABI]"));
2442 if (flags
& EF_ARM_SYMSARESORTED
)
2443 fprintf (file
, _(" [sorted symbol table]"));
2445 fprintf (file
, _(" [unsorted symbol table]"));
2447 flags
&= ~ EF_ARM_SYMSARESORTED
;
2450 case EF_ARM_EABI_VER2
:
2451 fprintf (file
, _(" [Version2 EABI]"));
2453 if (flags
& EF_ARM_SYMSARESORTED
)
2454 fprintf (file
, _(" [sorted symbol table]"));
2456 fprintf (file
, _(" [unsorted symbol table]"));
2458 if (flags
& EF_ARM_DYNSYMSUSESEGIDX
)
2459 fprintf (file
, _(" [dynamic symbols use segment index]"));
2461 if (flags
& EF_ARM_MAPSYMSFIRST
)
2462 fprintf (file
, _(" [mapping symbols precede others]"));
2464 flags
&= ~(EF_ARM_SYMSARESORTED
| EF_ARM_DYNSYMSUSESEGIDX
2465 | EF_ARM_MAPSYMSFIRST
);
2469 fprintf (file
, _(" <EABI version unrecognised>"));
2473 flags
&= ~ EF_ARM_EABIMASK
;
2475 if (flags
& EF_ARM_RELEXEC
)
2476 fprintf (file
, _(" [relocatable executable]"));
2478 if (flags
& EF_ARM_HASENTRY
)
2479 fprintf (file
, _(" [has entry point]"));
2481 flags
&= ~ (EF_ARM_RELEXEC
| EF_ARM_HASENTRY
);
2484 fprintf (file
, _("<Unrecognised flag bits set>"));
2492 elf32_arm_get_symbol_type (elf_sym
, type
)
2493 Elf_Internal_Sym
* elf_sym
;
2496 switch (ELF_ST_TYPE (elf_sym
->st_info
))
2499 return ELF_ST_TYPE (elf_sym
->st_info
);
2502 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2503 This allows us to distinguish between data used by Thumb instructions
2504 and non-data (which is probably code) inside Thumb regions of an
2506 if (type
!= STT_OBJECT
)
2507 return ELF_ST_TYPE (elf_sym
->st_info
);
2518 elf32_arm_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
2520 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2521 Elf_Internal_Rela
*rel
;
2522 struct elf_link_hash_entry
*h
;
2523 Elf_Internal_Sym
*sym
;
2527 switch (ELF32_R_TYPE (rel
->r_info
))
2529 case R_ARM_GNU_VTINHERIT
:
2530 case R_ARM_GNU_VTENTRY
:
2534 switch (h
->root
.type
)
2536 case bfd_link_hash_defined
:
2537 case bfd_link_hash_defweak
:
2538 return h
->root
.u
.def
.section
;
2540 case bfd_link_hash_common
:
2541 return h
->root
.u
.c
.p
->section
;
2550 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
2556 /* Update the got entry reference counts for the section being removed. */
2559 elf32_arm_gc_sweep_hook (abfd
, info
, sec
, relocs
)
2560 bfd
*abfd ATTRIBUTE_UNUSED
;
2561 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2562 asection
*sec ATTRIBUTE_UNUSED
;
2563 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
;
2565 /* We don't support garbage collection of GOT and PLT relocs yet. */
2569 /* Look through the relocs for a section during the first phase. */
2572 elf32_arm_check_relocs (abfd
, info
, sec
, relocs
)
2574 struct bfd_link_info
* info
;
2576 const Elf_Internal_Rela
* relocs
;
2578 Elf_Internal_Shdr
* symtab_hdr
;
2579 struct elf_link_hash_entry
** sym_hashes
;
2580 struct elf_link_hash_entry
** sym_hashes_end
;
2581 const Elf_Internal_Rela
* rel
;
2582 const Elf_Internal_Rela
* rel_end
;
2584 asection
* sgot
, *srelgot
, *sreloc
;
2585 bfd_vma
* local_got_offsets
;
2587 if (info
->relocateable
)
2590 sgot
= srelgot
= sreloc
= NULL
;
2592 dynobj
= elf_hash_table (info
)->dynobj
;
2593 local_got_offsets
= elf_local_got_offsets (abfd
);
2595 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2596 sym_hashes
= elf_sym_hashes (abfd
);
2597 sym_hashes_end
= sym_hashes
2598 + symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
2600 if (!elf_bad_symtab (abfd
))
2601 sym_hashes_end
-= symtab_hdr
->sh_info
;
2603 rel_end
= relocs
+ sec
->reloc_count
;
2604 for (rel
= relocs
; rel
< rel_end
; rel
++)
2606 struct elf_link_hash_entry
*h
;
2607 unsigned long r_symndx
;
2609 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2610 if (r_symndx
< symtab_hdr
->sh_info
)
2613 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2615 /* Some relocs require a global offset table. */
2618 switch (ELF32_R_TYPE (rel
->r_info
))
2623 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
2624 if (! _bfd_elf_create_got_section (dynobj
, info
))
2633 switch (ELF32_R_TYPE (rel
->r_info
))
2636 /* This symbol requires a global offset table entry. */
2639 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2640 BFD_ASSERT (sgot
!= NULL
);
2643 /* Get the got relocation section if necessary. */
2645 && (h
!= NULL
|| info
->shared
))
2647 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
2649 /* If no got relocation section, make one and initialize. */
2650 if (srelgot
== NULL
)
2652 srelgot
= bfd_make_section (dynobj
, ".rel.got");
2654 || ! bfd_set_section_flags (dynobj
, srelgot
,
2659 | SEC_LINKER_CREATED
2661 || ! bfd_set_section_alignment (dynobj
, srelgot
, 2))
2668 if (h
->got
.offset
!= (bfd_vma
) -1)
2669 /* We have already allocated space in the .got. */
2672 h
->got
.offset
= sgot
->_raw_size
;
2674 /* Make sure this symbol is output as a dynamic symbol. */
2675 if (h
->dynindx
== -1)
2676 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2679 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2683 /* This is a global offset table entry for a local
2685 if (local_got_offsets
== NULL
)
2690 size
= symtab_hdr
->sh_info
;
2691 size
*= sizeof (bfd_vma
);
2692 local_got_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
2693 if (local_got_offsets
== NULL
)
2695 elf_local_got_offsets (abfd
) = local_got_offsets
;
2696 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
2697 local_got_offsets
[i
] = (bfd_vma
) -1;
2700 if (local_got_offsets
[r_symndx
] != (bfd_vma
) -1)
2701 /* We have already allocated space in the .got. */
2704 local_got_offsets
[r_symndx
] = sgot
->_raw_size
;
2707 /* If we are generating a shared object, we need to
2708 output a R_ARM_RELATIVE reloc so that the dynamic
2709 linker can adjust this GOT entry. */
2710 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2713 sgot
->_raw_size
+= 4;
2717 /* This symbol requires a procedure linkage table entry. We
2718 actually build the entry in adjust_dynamic_symbol,
2719 because this might be a case of linking PIC code which is
2720 never referenced by a dynamic object, in which case we
2721 don't need to generate a procedure linkage table entry
2724 /* If this is a local symbol, we resolve it directly without
2725 creating a procedure linkage table entry. */
2729 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2735 /* If we are creating a shared library, and this is a reloc
2736 against a global symbol, or a non PC relative reloc
2737 against a local symbol, then we need to copy the reloc
2738 into the shared library. However, if we are linking with
2739 -Bsymbolic, we do not need to copy a reloc against a
2740 global symbol which is defined in an object we are
2741 including in the link (i.e., DEF_REGULAR is set). At
2742 this point we have not seen all the input files, so it is
2743 possible that DEF_REGULAR is not set now but will be set
2744 later (it is never cleared). We account for that
2745 possibility below by storing information in the
2746 pcrel_relocs_copied field of the hash table entry. */
2748 && (ELF32_R_TYPE (rel
->r_info
) != R_ARM_PC24
2750 && (! info
->symbolic
2751 || (h
->elf_link_hash_flags
2752 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
2754 /* When creating a shared object, we must copy these
2755 reloc types into the output file. We create a reloc
2756 section in dynobj and make room for this reloc. */
2761 name
= (bfd_elf_string_from_elf_section
2763 elf_elfheader (abfd
)->e_shstrndx
,
2764 elf_section_data (sec
)->rel_hdr
.sh_name
));
2768 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
2769 && strcmp (bfd_get_section_name (abfd
, sec
),
2772 sreloc
= bfd_get_section_by_name (dynobj
, name
);
2777 sreloc
= bfd_make_section (dynobj
, name
);
2778 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
2779 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
2780 if ((sec
->flags
& SEC_ALLOC
) != 0)
2781 flags
|= SEC_ALLOC
| SEC_LOAD
;
2783 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
2784 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
2787 if (sec
->flags
& SEC_READONLY
)
2788 info
->flags
|= DF_TEXTREL
;
2791 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
2792 /* If we are linking with -Bsymbolic, and this is a
2793 global symbol, we count the number of PC relative
2794 relocations we have entered for this symbol, so that
2795 we can discard them again if the symbol is later
2796 defined by a regular object. Note that this function
2797 is only called if we are using an elf_i386 linker
2798 hash table, which means that h is really a pointer to
2799 an elf_i386_link_hash_entry. */
2800 if (h
!= NULL
&& info
->symbolic
2801 && ELF32_R_TYPE (rel
->r_info
) == R_ARM_PC24
)
2803 struct elf32_arm_link_hash_entry
* eh
;
2804 struct elf32_arm_pcrel_relocs_copied
* p
;
2806 eh
= (struct elf32_arm_link_hash_entry
*) h
;
2808 for (p
= eh
->pcrel_relocs_copied
; p
!= NULL
; p
= p
->next
)
2809 if (p
->section
== sreloc
)
2814 p
= ((struct elf32_arm_pcrel_relocs_copied
*)
2815 bfd_alloc (dynobj
, (bfd_size_type
) sizeof * p
));
2818 p
->next
= eh
->pcrel_relocs_copied
;
2819 eh
->pcrel_relocs_copied
= p
;
2820 p
->section
= sreloc
;
2829 /* This relocation describes the C++ object vtable hierarchy.
2830 Reconstruct it for later use during GC. */
2831 case R_ARM_GNU_VTINHERIT
:
2832 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2836 /* This relocation describes which C++ vtable entries are actually
2837 used. Record for later use during GC. */
2838 case R_ARM_GNU_VTENTRY
:
2839 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
2848 /* Find the nearest line to a particular section and offset, for error
2849 reporting. This code is a duplicate of the code in elf.c, except
2850 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
2853 elf32_arm_find_nearest_line
2854 (abfd
, section
, symbols
, offset
, filename_ptr
, functionname_ptr
, line_ptr
)
2859 const char ** filename_ptr
;
2860 const char ** functionname_ptr
;
2861 unsigned int * line_ptr
;
2864 const char * filename
;
2869 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
2870 filename_ptr
, functionname_ptr
,
2872 &elf_tdata (abfd
)->dwarf2_find_line_info
))
2875 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2876 &found
, filename_ptr
,
2877 functionname_ptr
, line_ptr
,
2878 &elf_tdata (abfd
)->line_info
))
2884 if (symbols
== NULL
)
2891 for (p
= symbols
; *p
!= NULL
; p
++)
2895 q
= (elf_symbol_type
*) *p
;
2897 if (bfd_get_section (&q
->symbol
) != section
)
2900 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
2905 filename
= bfd_asymbol_name (&q
->symbol
);
2910 if (q
->symbol
.section
== section
2911 && q
->symbol
.value
>= low_func
2912 && q
->symbol
.value
<= offset
)
2914 func
= (asymbol
*) q
;
2915 low_func
= q
->symbol
.value
;
2924 *filename_ptr
= filename
;
2925 *functionname_ptr
= bfd_asymbol_name (func
);
2931 /* Adjust a symbol defined by a dynamic object and referenced by a
2932 regular object. The current definition is in some section of the
2933 dynamic object, but we're not including those sections. We have to
2934 change the definition to something the rest of the link can
2938 elf32_arm_adjust_dynamic_symbol (info
, h
)
2939 struct bfd_link_info
* info
;
2940 struct elf_link_hash_entry
* h
;
2944 unsigned int power_of_two
;
2946 dynobj
= elf_hash_table (info
)->dynobj
;
2948 /* Make sure we know what is going on here. */
2949 BFD_ASSERT (dynobj
!= NULL
2950 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
2951 || h
->weakdef
!= NULL
2952 || ((h
->elf_link_hash_flags
2953 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2954 && (h
->elf_link_hash_flags
2955 & ELF_LINK_HASH_REF_REGULAR
) != 0
2956 && (h
->elf_link_hash_flags
2957 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
2959 /* If this is a function, put it in the procedure linkage table. We
2960 will fill in the contents of the procedure linkage table later,
2961 when we know the address of the .got section. */
2962 if (h
->type
== STT_FUNC
2963 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
2966 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
2967 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0)
2969 /* This case can occur if we saw a PLT32 reloc in an input
2970 file, but the symbol was never referred to by a dynamic
2971 object. In such a case, we don't actually need to build
2972 a procedure linkage table, and we can just do a PC32
2974 BFD_ASSERT ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0);
2978 /* Make sure this symbol is output as a dynamic symbol. */
2979 if (h
->dynindx
== -1)
2981 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2985 s
= bfd_get_section_by_name (dynobj
, ".plt");
2986 BFD_ASSERT (s
!= NULL
);
2988 /* If this is the first .plt entry, make room for the special
2990 if (s
->_raw_size
== 0)
2991 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2993 /* If this symbol is not defined in a regular file, and we are
2994 not generating a shared library, then set the symbol to this
2995 location in the .plt. This is required to make function
2996 pointers compare as equal between the normal executable and
2997 the shared library. */
2999 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3001 h
->root
.u
.def
.section
= s
;
3002 h
->root
.u
.def
.value
= s
->_raw_size
;
3005 h
->plt
.offset
= s
->_raw_size
;
3007 /* Make room for this entry. */
3008 s
->_raw_size
+= PLT_ENTRY_SIZE
;
3010 /* We also need to make an entry in the .got.plt section, which
3011 will be placed in the .got section by the linker script. */
3012 s
= bfd_get_section_by_name (dynobj
, ".got.plt");
3013 BFD_ASSERT (s
!= NULL
);
3016 /* We also need to make an entry in the .rel.plt section. */
3018 s
= bfd_get_section_by_name (dynobj
, ".rel.plt");
3019 BFD_ASSERT (s
!= NULL
);
3020 s
->_raw_size
+= sizeof (Elf32_External_Rel
);
3025 /* If this is a weak symbol, and there is a real definition, the
3026 processor independent code will have arranged for us to see the
3027 real definition first, and we can just use the same value. */
3028 if (h
->weakdef
!= NULL
)
3030 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
3031 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
3032 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
3033 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
3037 /* This is a reference to a symbol defined by a dynamic object which
3038 is not a function. */
3040 /* If we are creating a shared library, we must presume that the
3041 only references to the symbol are via the global offset table.
3042 For such cases we need not do anything here; the relocations will
3043 be handled correctly by relocate_section. */
3047 /* We must allocate the symbol in our .dynbss section, which will
3048 become part of the .bss section of the executable. There will be
3049 an entry for this symbol in the .dynsym section. The dynamic
3050 object will contain position independent code, so all references
3051 from the dynamic object to this symbol will go through the global
3052 offset table. The dynamic linker will use the .dynsym entry to
3053 determine the address it must put in the global offset table, so
3054 both the dynamic object and the regular object will refer to the
3055 same memory location for the variable. */
3056 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
3057 BFD_ASSERT (s
!= NULL
);
3059 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
3060 copy the initial value out of the dynamic object and into the
3061 runtime process image. We need to remember the offset into the
3062 .rel.bss section we are going to use. */
3063 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
3067 srel
= bfd_get_section_by_name (dynobj
, ".rel.bss");
3068 BFD_ASSERT (srel
!= NULL
);
3069 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
3070 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
3073 /* We need to figure out the alignment required for this symbol. I
3074 have no idea how ELF linkers handle this. */
3075 power_of_two
= bfd_log2 (h
->size
);
3076 if (power_of_two
> 3)
3079 /* Apply the required alignment. */
3080 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
3081 (bfd_size_type
) (1 << power_of_two
));
3082 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
3084 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
3088 /* Define the symbol as being at this point in the section. */
3089 h
->root
.u
.def
.section
= s
;
3090 h
->root
.u
.def
.value
= s
->_raw_size
;
3092 /* Increment the section size to make room for the symbol. */
3093 s
->_raw_size
+= h
->size
;
3098 /* Set the sizes of the dynamic sections. */
3101 elf32_arm_size_dynamic_sections (output_bfd
, info
)
3102 bfd
* output_bfd ATTRIBUTE_UNUSED
;
3103 struct bfd_link_info
* info
;
3110 dynobj
= elf_hash_table (info
)->dynobj
;
3111 BFD_ASSERT (dynobj
!= NULL
);
3113 if (elf_hash_table (info
)->dynamic_sections_created
)
3115 /* Set the contents of the .interp section to the interpreter. */
3118 s
= bfd_get_section_by_name (dynobj
, ".interp");
3119 BFD_ASSERT (s
!= NULL
);
3120 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
3121 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
3126 /* We may have created entries in the .rel.got section.
3127 However, if we are not creating the dynamic sections, we will
3128 not actually use these entries. Reset the size of .rel.got,
3129 which will cause it to get stripped from the output file
3131 s
= bfd_get_section_by_name (dynobj
, ".rel.got");
3136 /* If this is a -Bsymbolic shared link, then we need to discard all
3137 PC relative relocs against symbols defined in a regular object.
3138 We allocated space for them in the check_relocs routine, but we
3139 will not fill them in in the relocate_section routine. */
3140 if (info
->shared
&& info
->symbolic
)
3141 elf32_arm_link_hash_traverse (elf32_arm_hash_table (info
),
3142 elf32_arm_discard_copies
,
3145 /* The check_relocs and adjust_dynamic_symbol entry points have
3146 determined the sizes of the various dynamic sections. Allocate
3150 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3155 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3158 /* It's OK to base decisions on the section name, because none
3159 of the dynobj section names depend upon the input files. */
3160 name
= bfd_get_section_name (dynobj
, s
);
3164 if (strcmp (name
, ".plt") == 0)
3166 if (s
->_raw_size
== 0)
3168 /* Strip this section if we don't need it; see the
3174 /* Remember whether there is a PLT. */
3178 else if (strncmp (name
, ".rel", 4) == 0)
3180 if (s
->_raw_size
== 0)
3182 /* If we don't need this section, strip it from the
3183 output file. This is mostly to handle .rel.bss and
3184 .rel.plt. We must create both sections in
3185 create_dynamic_sections, because they must be created
3186 before the linker maps input sections to output
3187 sections. The linker does that before
3188 adjust_dynamic_symbol is called, and it is that
3189 function which decides whether anything needs to go
3190 into these sections. */
3195 /* Remember whether there are any reloc sections other
3197 if (strcmp (name
, ".rel.plt") != 0)
3200 /* We use the reloc_count field as a counter if we need
3201 to copy relocs into the output file. */
3205 else if (strncmp (name
, ".got", 4) != 0)
3207 /* It's not one of our sections, so don't allocate space. */
3215 for (spp
= &s
->output_section
->owner
->sections
;
3217 spp
= &(*spp
)->next
)
3219 if (*spp
== s
->output_section
)
3221 bfd_section_list_remove (s
->output_section
->owner
, spp
);
3222 --s
->output_section
->owner
->section_count
;
3229 /* Allocate memory for the section contents. */
3230 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
3231 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
3235 if (elf_hash_table (info
)->dynamic_sections_created
)
3237 /* Add some entries to the .dynamic section. We fill in the
3238 values later, in elf32_arm_finish_dynamic_sections, but we
3239 must add the entries now so that we get the correct size for
3240 the .dynamic section. The DT_DEBUG entry is filled in by the
3241 dynamic linker and used by the debugger. */
3242 #define add_dynamic_entry(TAG, VAL) \
3243 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
3247 if (!add_dynamic_entry (DT_DEBUG
, 0))
3253 if ( !add_dynamic_entry (DT_PLTGOT
, 0)
3254 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
3255 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
3256 || !add_dynamic_entry (DT_JMPREL
, 0))
3262 if ( !add_dynamic_entry (DT_REL
, 0)
3263 || !add_dynamic_entry (DT_RELSZ
, 0)
3264 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
3268 if ((info
->flags
& DF_TEXTREL
) != 0)
3270 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3272 info
->flags
|= DF_TEXTREL
;
3275 #undef add_synamic_entry
3280 /* This function is called via elf32_arm_link_hash_traverse if we are
3281 creating a shared object with -Bsymbolic. It discards the space
3282 allocated to copy PC relative relocs against symbols which are
3283 defined in regular objects. We allocated space for them in the
3284 check_relocs routine, but we won't fill them in in the
3285 relocate_section routine. */
3288 elf32_arm_discard_copies (h
, ignore
)
3289 struct elf32_arm_link_hash_entry
* h
;
3290 PTR ignore ATTRIBUTE_UNUSED
;
3292 struct elf32_arm_pcrel_relocs_copied
* s
;
3294 if (h
->root
.root
.type
== bfd_link_hash_warning
)
3295 h
= (struct elf32_arm_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3297 /* We only discard relocs for symbols defined in a regular object. */
3298 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3301 for (s
= h
->pcrel_relocs_copied
; s
!= NULL
; s
= s
->next
)
3302 s
->section
->_raw_size
-= s
->count
* sizeof (Elf32_External_Rel
);
3307 /* Finish up dynamic symbol handling. We set the contents of various
3308 dynamic sections here. */
3311 elf32_arm_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
3313 struct bfd_link_info
* info
;
3314 struct elf_link_hash_entry
* h
;
3315 Elf_Internal_Sym
* sym
;
3319 dynobj
= elf_hash_table (info
)->dynobj
;
3321 if (h
->plt
.offset
!= (bfd_vma
) -1)
3328 Elf_Internal_Rel rel
;
3330 /* This symbol has an entry in the procedure linkage table. Set
3333 BFD_ASSERT (h
->dynindx
!= -1);
3335 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3336 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3337 srel
= bfd_get_section_by_name (dynobj
, ".rel.plt");
3338 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
3340 /* Get the index in the procedure linkage table which
3341 corresponds to this symbol. This is the index of this symbol
3342 in all the symbols for which we are making plt entries. The
3343 first entry in the procedure linkage table is reserved. */
3344 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
3346 /* Get the offset into the .got table of the entry that
3347 corresponds to this function. Each .got entry is 4 bytes.
3348 The first three are reserved. */
3349 got_offset
= (plt_index
+ 3) * 4;
3351 /* Fill in the entry in the procedure linkage table. */
3352 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[0],
3353 splt
->contents
+ h
->plt
.offset
+ 0);
3354 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[1],
3355 splt
->contents
+ h
->plt
.offset
+ 4);
3356 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[2],
3357 splt
->contents
+ h
->plt
.offset
+ 8);
3358 bfd_put_32 (output_bfd
,
3359 (sgot
->output_section
->vma
3360 + sgot
->output_offset
3362 - splt
->output_section
->vma
3363 - splt
->output_offset
3364 - h
->plt
.offset
- 12),
3365 splt
->contents
+ h
->plt
.offset
+ 12);
3367 /* Fill in the entry in the global offset table. */
3368 bfd_put_32 (output_bfd
,
3369 (splt
->output_section
->vma
3370 + splt
->output_offset
),
3371 sgot
->contents
+ got_offset
);
3373 /* Fill in the entry in the .rel.plt section. */
3374 rel
.r_offset
= (sgot
->output_section
->vma
3375 + sgot
->output_offset
3377 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_JUMP_SLOT
);
3378 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3379 ((Elf32_External_Rel
*) srel
->contents
3382 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3384 /* Mark the symbol as undefined, rather than as defined in
3385 the .plt section. Leave the value alone. */
3386 sym
->st_shndx
= SHN_UNDEF
;
3387 /* If the symbol is weak, we do need to clear the value.
3388 Otherwise, the PLT entry would provide a definition for
3389 the symbol even if the symbol wasn't defined anywhere,
3390 and so the symbol would never be NULL. */
3391 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR_NONWEAK
)
3397 if (h
->got
.offset
!= (bfd_vma
) -1)
3401 Elf_Internal_Rel rel
;
3403 /* This symbol has an entry in the global offset table. Set it
3405 sgot
= bfd_get_section_by_name (dynobj
, ".got");
3406 srel
= bfd_get_section_by_name (dynobj
, ".rel.got");
3407 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
3409 rel
.r_offset
= (sgot
->output_section
->vma
3410 + sgot
->output_offset
3411 + (h
->got
.offset
&~ (bfd_vma
) 1));
3413 /* If this is a -Bsymbolic link, and the symbol is defined
3414 locally, we just want to emit a RELATIVE reloc. The entry in
3415 the global offset table will already have been initialized in
3416 the relocate_section function. */
3418 && (info
->symbolic
|| h
->dynindx
== -1)
3419 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
3420 rel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
3423 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
3424 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_GLOB_DAT
);
3427 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3428 ((Elf32_External_Rel
*) srel
->contents
3429 + srel
->reloc_count
));
3430 ++srel
->reloc_count
;
3433 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
3436 Elf_Internal_Rel rel
;
3438 /* This symbol needs a copy reloc. Set it up. */
3439 BFD_ASSERT (h
->dynindx
!= -1
3440 && (h
->root
.type
== bfd_link_hash_defined
3441 || h
->root
.type
== bfd_link_hash_defweak
));
3443 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
3445 BFD_ASSERT (s
!= NULL
);
3447 rel
.r_offset
= (h
->root
.u
.def
.value
3448 + h
->root
.u
.def
.section
->output_section
->vma
3449 + h
->root
.u
.def
.section
->output_offset
);
3450 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_COPY
);
3451 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3452 ((Elf32_External_Rel
*) s
->contents
3457 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3458 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3459 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
3460 sym
->st_shndx
= SHN_ABS
;
3465 /* Finish up the dynamic sections. */
3468 elf32_arm_finish_dynamic_sections (output_bfd
, info
)
3470 struct bfd_link_info
* info
;
3476 dynobj
= elf_hash_table (info
)->dynobj
;
3478 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3479 BFD_ASSERT (sgot
!= NULL
);
3480 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3482 if (elf_hash_table (info
)->dynamic_sections_created
)
3485 Elf32_External_Dyn
*dyncon
, *dynconend
;
3487 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3488 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3490 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3491 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
3493 for (; dyncon
< dynconend
; dyncon
++)
3495 Elf_Internal_Dyn dyn
;
3499 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3512 s
= bfd_get_section_by_name (output_bfd
, name
);
3513 BFD_ASSERT (s
!= NULL
);
3514 dyn
.d_un
.d_ptr
= s
->vma
;
3515 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3519 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3520 BFD_ASSERT (s
!= NULL
);
3521 if (s
->_cooked_size
!= 0)
3522 dyn
.d_un
.d_val
= s
->_cooked_size
;
3524 dyn
.d_un
.d_val
= s
->_raw_size
;
3525 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3529 /* My reading of the SVR4 ABI indicates that the
3530 procedure linkage table relocs (DT_JMPREL) should be
3531 included in the overall relocs (DT_REL). This is
3532 what Solaris does. However, UnixWare can not handle
3533 that case. Therefore, we override the DT_RELSZ entry
3534 here to make it not include the JMPREL relocs. Since
3535 the linker script arranges for .rel.plt to follow all
3536 other relocation sections, we don't have to worry
3537 about changing the DT_REL entry. */
3538 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3541 if (s
->_cooked_size
!= 0)
3542 dyn
.d_un
.d_val
-= s
->_cooked_size
;
3544 dyn
.d_un
.d_val
-= s
->_raw_size
;
3546 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3551 /* Fill in the first entry in the procedure linkage table. */
3552 if (splt
->_raw_size
> 0)
3554 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[0], splt
->contents
+ 0);
3555 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[1], splt
->contents
+ 4);
3556 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[2], splt
->contents
+ 8);
3557 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[3], splt
->contents
+ 12);
3560 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3561 really seem like the right value. */
3562 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
3565 /* Fill in the first three entries in the global offset table. */
3566 if (sgot
->_raw_size
> 0)
3569 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
3571 bfd_put_32 (output_bfd
,
3572 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3574 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
3575 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
3578 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
3584 elf32_arm_post_process_headers (abfd
, link_info
)
3586 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
;
3588 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
3590 i_ehdrp
= elf_elfheader (abfd
);
3592 i_ehdrp
->e_ident
[EI_OSABI
] = ARM_ELF_OS_ABI_VERSION
;
3593 i_ehdrp
->e_ident
[EI_ABIVERSION
] = ARM_ELF_ABI_VERSION
;
3596 static enum elf_reloc_type_class
3597 elf32_arm_reloc_type_class (rela
)
3598 const Elf_Internal_Rela
*rela
;
3600 switch ((int) ELF32_R_TYPE (rela
->r_info
))
3602 case R_ARM_RELATIVE
:
3603 return reloc_class_relative
;
3604 case R_ARM_JUMP_SLOT
:
3605 return reloc_class_plt
;
3607 return reloc_class_copy
;
3609 return reloc_class_normal
;
3614 #define ELF_ARCH bfd_arch_arm
3615 #define ELF_MACHINE_CODE EM_ARM
3616 #define ELF_MAXPAGESIZE 0x8000
3618 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
3619 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
3620 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
3621 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
3622 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
3623 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
3624 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
3626 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
3627 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
3628 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
3629 #define elf_backend_check_relocs elf32_arm_check_relocs
3630 #define elf_backend_relocate_section elf32_arm_relocate_section
3631 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
3632 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
3633 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
3634 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
3635 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
3636 #define elf_backend_post_process_headers elf32_arm_post_process_headers
3637 #define elf_backend_reloc_type_class elf32_arm_reloc_type_class
3639 #define elf_backend_can_gc_sections 1
3640 #define elf_backend_plt_readonly 1
3641 #define elf_backend_want_got_plt 1
3642 #define elf_backend_want_plt_sym 0
3644 #define elf_backend_rela_normal 1
3647 #define elf_backend_got_header_size 12
3648 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
3650 #include "elf32-target.h"