1 /* 32-bit ELF support for ARM
2 Copyright 1998, 1999, 2000, 2001 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 *, unsigned char, 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
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 unsigned long 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 unsigned long 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 long int thumb_glue_size
;
189 /* The size in bytes of the section containg the ARM-to-Thumb glue. */
190 long int 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
;
238 ret
= ((struct elf32_arm_link_hash_table
*)
239 bfd_alloc (abfd
, sizeof (struct elf32_arm_link_hash_table
)));
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
))
246 bfd_release (abfd
, ret
);
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
);
274 bfd_malloc (strlen (name
) + 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_get_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
);
309 bfd_malloc (strlen (name
) + 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_get_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
387 (globals
->bfd_of_glue_owner
, ARM2THUMB_GLUE_SECTION_NAME
);
389 BFD_ASSERT (s
!= NULL
);
391 foo
= (bfd_byte
*) bfd_alloc
392 (globals
->bfd_of_glue_owner
, 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
408 (globals
->bfd_of_glue_owner
, 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
;
423 register asection
* s
;
425 struct elf_link_hash_entry
* myh
;
426 struct elf32_arm_link_hash_table
* globals
;
428 globals
= elf32_arm_hash_table (link_info
);
430 BFD_ASSERT (globals
!= NULL
);
431 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
433 s
= bfd_get_section_by_name
434 (globals
->bfd_of_glue_owner
, ARM2THUMB_GLUE_SECTION_NAME
);
436 BFD_ASSERT (s
!= NULL
);
439 bfd_malloc (strlen (name
) + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1));
441 BFD_ASSERT (tmp_name
);
443 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
445 myh
= elf_link_hash_lookup
446 (&(globals
)->root
, tmp_name
, false, false, true);
450 /* We've already seen this guy. */
455 /* The only trick here is using hash_table->arm_glue_size as the value. Even
456 though the section isn't allocated yet, this is where we will be putting
458 _bfd_generic_link_add_one_symbol (link_info
, globals
->bfd_of_glue_owner
, tmp_name
,
460 s
, globals
->arm_glue_size
+ 1,
462 (struct bfd_link_hash_entry
**) &myh
);
466 globals
->arm_glue_size
+= ARM2THUMB_GLUE_SIZE
;
472 record_thumb_to_arm_glue (link_info
, h
)
473 struct bfd_link_info
*link_info
;
474 struct elf_link_hash_entry
*h
;
476 const char *name
= h
->root
.root
.string
;
477 register asection
*s
;
479 struct elf_link_hash_entry
*myh
;
480 struct elf32_arm_link_hash_table
*hash_table
;
483 hash_table
= elf32_arm_hash_table (link_info
);
485 BFD_ASSERT (hash_table
!= NULL
);
486 BFD_ASSERT (hash_table
->bfd_of_glue_owner
!= NULL
);
488 s
= bfd_get_section_by_name
489 (hash_table
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
491 BFD_ASSERT (s
!= NULL
);
493 tmp_name
= (char *) bfd_malloc (strlen (name
) + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1);
495 BFD_ASSERT (tmp_name
);
497 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
499 myh
= elf_link_hash_lookup
500 (&(hash_table
)->root
, tmp_name
, false, false, true);
504 /* We've already seen this guy. */
509 _bfd_generic_link_add_one_symbol (link_info
, hash_table
->bfd_of_glue_owner
, tmp_name
,
510 BSF_GLOBAL
, s
, hash_table
->thumb_glue_size
+ 1,
512 (struct bfd_link_hash_entry
**) &myh
);
514 /* If we mark it 'Thumb', the disassembler will do a better job. */
515 bind
= ELF_ST_BIND (myh
->type
);
516 myh
->type
= ELF_ST_INFO (bind
, STT_ARM_TFUNC
);
520 #define CHANGE_TO_ARM "__%s_change_to_arm"
521 #define BACK_FROM_ARM "__%s_back_from_arm"
523 /* Allocate another symbol to mark where we switch to Arm mode. */
524 tmp_name
= (char *) bfd_malloc (strlen (name
) + strlen (CHANGE_TO_ARM
) + 1);
526 BFD_ASSERT (tmp_name
);
528 sprintf (tmp_name
, CHANGE_TO_ARM
, name
);
532 _bfd_generic_link_add_one_symbol (link_info
, hash_table
->bfd_of_glue_owner
, tmp_name
,
533 BSF_LOCAL
, s
, hash_table
->thumb_glue_size
+ 4,
535 (struct bfd_link_hash_entry
**) &myh
);
539 hash_table
->thumb_glue_size
+= THUMB2ARM_GLUE_SIZE
;
544 /* Select a BFD to be used to hold the sections used by the glue code.
545 This function is called from the linker scripts in ld/emultempl/
549 bfd_elf32_arm_get_bfd_for_interworking (abfd
, info
)
551 struct bfd_link_info
*info
;
553 struct elf32_arm_link_hash_table
*globals
;
557 /* If we are only performing a partial link do not bother
558 getting a bfd to hold the glue. */
559 if (info
->relocateable
)
562 globals
= elf32_arm_hash_table (info
);
564 BFD_ASSERT (globals
!= NULL
);
566 if (globals
->bfd_of_glue_owner
!= NULL
)
569 sec
= bfd_get_section_by_name (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
573 /* Note: we do not include the flag SEC_LINKER_CREATED, as this
574 will prevent elf_link_input_bfd() from processing the contents
576 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_CODE
| SEC_READONLY
;
578 sec
= bfd_make_section (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
581 || !bfd_set_section_flags (abfd
, sec
, flags
)
582 || !bfd_set_section_alignment (abfd
, sec
, 2))
585 /* Set the gc mark to prevent the section from being removed by garbage
586 collection, despite the fact that no relocs refer to this section. */
590 sec
= bfd_get_section_by_name (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
594 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_CODE
| SEC_READONLY
;
596 sec
= bfd_make_section (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
599 || !bfd_set_section_flags (abfd
, sec
, flags
)
600 || !bfd_set_section_alignment (abfd
, sec
, 2))
606 /* Save the bfd for later use. */
607 globals
->bfd_of_glue_owner
= abfd
;
613 bfd_elf32_arm_process_before_allocation (abfd
, link_info
, no_pipeline_knowledge
)
615 struct bfd_link_info
*link_info
;
616 int no_pipeline_knowledge
;
618 Elf_Internal_Shdr
*symtab_hdr
;
619 Elf_Internal_Rela
*free_relocs
= NULL
;
620 Elf_Internal_Rela
*irel
, *irelend
;
621 bfd_byte
*contents
= NULL
;
622 bfd_byte
*free_contents
= NULL
;
623 Elf32_External_Sym
*extsyms
= NULL
;
624 Elf32_External_Sym
*free_extsyms
= NULL
;
627 struct elf32_arm_link_hash_table
*globals
;
629 /* If we are only performing a partial link do not bother
630 to construct any glue. */
631 if (link_info
->relocateable
)
634 /* Here we have a bfd that is to be included on the link. We have a hook
635 to do reloc rummaging, before section sizes are nailed down. */
636 globals
= elf32_arm_hash_table (link_info
);
638 BFD_ASSERT (globals
!= NULL
);
639 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
641 globals
->no_pipeline_knowledge
= no_pipeline_knowledge
;
643 /* Rummage around all the relocs and map the glue vectors. */
644 sec
= abfd
->sections
;
649 for (; sec
!= NULL
; sec
= sec
->next
)
651 if (sec
->reloc_count
== 0)
654 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
656 /* Load the relocs. */
657 irel
= (_bfd_elf32_link_read_relocs (abfd
, sec
, (PTR
) NULL
,
658 (Elf_Internal_Rela
*) NULL
, false));
660 BFD_ASSERT (irel
!= 0);
662 irelend
= irel
+ sec
->reloc_count
;
663 for (; irel
< irelend
; irel
++)
666 unsigned long r_index
;
668 struct elf_link_hash_entry
*h
;
670 r_type
= ELF32_R_TYPE (irel
->r_info
);
671 r_index
= ELF32_R_SYM (irel
->r_info
);
673 /* These are the only relocation types we care about. */
674 if ( r_type
!= R_ARM_PC24
675 && r_type
!= R_ARM_THM_PC22
)
678 /* Get the section contents if we haven't done so already. */
679 if (contents
== NULL
)
681 /* Get cached copy if it exists. */
682 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
683 contents
= elf_section_data (sec
)->this_hdr
.contents
;
686 /* Go get them off disk. */
687 contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
688 if (contents
== NULL
)
691 free_contents
= contents
;
693 if (!bfd_get_section_contents (abfd
, sec
, contents
,
694 (file_ptr
) 0, sec
->_raw_size
))
699 /* Read this BFD's symbols if we haven't done so already. */
702 /* Get cached copy if it exists. */
703 if (symtab_hdr
->contents
!= NULL
)
704 extsyms
= (Elf32_External_Sym
*) symtab_hdr
->contents
;
707 /* Go get them off disk. */
708 extsyms
= ((Elf32_External_Sym
*)
709 bfd_malloc (symtab_hdr
->sh_size
));
713 free_extsyms
= extsyms
;
715 if (bfd_seek (abfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
716 || (bfd_read (extsyms
, 1, symtab_hdr
->sh_size
, abfd
)
717 != symtab_hdr
->sh_size
))
722 /* If the relocation is not against a symbol it cannot concern us. */
725 /* We don't care about local symbols. */
726 if (r_index
< symtab_hdr
->sh_info
)
729 /* This is an external symbol. */
730 r_index
-= symtab_hdr
->sh_info
;
731 h
= (struct elf_link_hash_entry
*)
732 elf_sym_hashes (abfd
)[r_index
];
734 /* If the relocation is against a static symbol it must be within
735 the current section and so cannot be a cross ARM/Thumb relocation. */
742 /* This one is a call from arm code. We need to look up
743 the target of the call. If it is a thumb target, we
745 if (ELF_ST_TYPE(h
->type
) == STT_ARM_TFUNC
)
746 record_arm_to_thumb_glue (link_info
, h
);
750 /* This one is a call from thumb code. We look
751 up the target of the call. If it is not a thumb
752 target, we insert glue. */
753 if (ELF_ST_TYPE (h
->type
) != STT_ARM_TFUNC
)
754 record_thumb_to_arm_glue (link_info
, h
);
766 if (free_relocs
!= NULL
)
768 if (free_contents
!= NULL
)
769 free (free_contents
);
770 if (free_extsyms
!= NULL
)
776 /* The thumb form of a long branch is a bit finicky, because the offset
777 encoding is split over two fields, each in it's own instruction. They
778 can occur in any order. So given a thumb form of long branch, and an
779 offset, insert the offset into the thumb branch and return finished
782 It takes two thumb instructions to encode the target address. Each has
783 11 bits to invest. The upper 11 bits are stored in one (identifed by
784 H-0.. see below), the lower 11 bits are stored in the other (identified
787 Combine together and shifted left by 1 (it's a half word address) and
791 H-0, upper address-0 = 000
793 H-1, lower address-0 = 800
795 They can be ordered either way, but the arm tools I've seen always put
796 the lower one first. It probably doesn't matter. krk@cygnus.com
798 XXX: Actually the order does matter. The second instruction (H-1)
799 moves the computed address into the PC, so it must be the second one
800 in the sequence. The problem, however is that whilst little endian code
801 stores the instructions in HI then LOW order, big endian code does the
802 reverse. nickc@cygnus.com. */
804 #define LOW_HI_ORDER 0xF800F000
805 #define HI_LOW_ORDER 0xF000F800
808 insert_thumb_branch (br_insn
, rel_off
)
812 unsigned int low_bits
;
813 unsigned int high_bits
;
815 BFD_ASSERT ((rel_off
& 1) != 1);
817 rel_off
>>= 1; /* Half word aligned address. */
818 low_bits
= rel_off
& 0x000007FF; /* The bottom 11 bits. */
819 high_bits
= (rel_off
>> 11) & 0x000007FF; /* The top 11 bits. */
821 if ((br_insn
& LOW_HI_ORDER
) == LOW_HI_ORDER
)
822 br_insn
= LOW_HI_ORDER
| (low_bits
<< 16) | high_bits
;
823 else if ((br_insn
& HI_LOW_ORDER
) == HI_LOW_ORDER
)
824 br_insn
= HI_LOW_ORDER
| (high_bits
<< 16) | low_bits
;
826 /* FIXME: abort is probably not the right call. krk@cygnus.com */
827 abort (); /* error - not a valid branch instruction form. */
832 /* Thumb code calling an ARM function. */
835 elf32_thumb_to_arm_stub (info
, name
, input_bfd
, output_bfd
, input_section
,
836 hit_data
, sym_sec
, offset
, addend
, val
)
837 struct bfd_link_info
* info
;
841 asection
* input_section
;
845 bfd_signed_vma addend
;
850 unsigned long int tmp
;
852 struct elf_link_hash_entry
* myh
;
853 struct elf32_arm_link_hash_table
* globals
;
855 myh
= find_thumb_glue (info
, name
, input_bfd
);
859 globals
= elf32_arm_hash_table (info
);
861 BFD_ASSERT (globals
!= NULL
);
862 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
864 my_offset
= myh
->root
.u
.def
.value
;
866 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
867 THUMB2ARM_GLUE_SECTION_NAME
);
869 BFD_ASSERT (s
!= NULL
);
870 BFD_ASSERT (s
->contents
!= NULL
);
871 BFD_ASSERT (s
->output_section
!= NULL
);
873 if ((my_offset
& 0x01) == 0x01)
876 && sym_sec
->owner
!= NULL
877 && !INTERWORK_FLAG (sym_sec
->owner
))
880 (_("%s(%s): warning: interworking not enabled."),
881 bfd_get_filename (sym_sec
->owner
), name
);
883 (_(" first occurrence: %s: thumb call to arm"),
884 bfd_get_filename (input_bfd
));
890 myh
->root
.u
.def
.value
= my_offset
;
892 bfd_put_16 (output_bfd
, t2a1_bx_pc_insn
,
893 s
->contents
+ my_offset
);
895 bfd_put_16 (output_bfd
, t2a2_noop_insn
,
896 s
->contents
+ my_offset
+ 2);
899 /* Address of destination of the stub. */
900 ((bfd_signed_vma
) val
)
902 /* Offset from the start of the current section to the start of the stubs. */
904 /* Offset of the start of this stub from the start of the stubs. */
906 /* Address of the start of the current section. */
907 + s
->output_section
->vma
)
908 /* The branch instruction is 4 bytes into the stub. */
910 /* ARM branches work from the pc of the instruction + 8. */
913 bfd_put_32 (output_bfd
,
914 t2a3_b_insn
| ((ret_offset
>> 2) & 0x00FFFFFF),
915 s
->contents
+ my_offset
+ 4);
918 BFD_ASSERT (my_offset
<= globals
->thumb_glue_size
);
920 /* Now go back and fix up the original BL insn to point
925 - (input_section
->output_offset
929 tmp
= bfd_get_32 (input_bfd
, hit_data
930 - input_section
->vma
);
932 bfd_put_32 (output_bfd
,
933 insert_thumb_branch (tmp
, ret_offset
),
934 hit_data
- input_section
->vma
);
939 /* Arm code calling a Thumb function. */
942 elf32_arm_to_thumb_stub (info
, name
, input_bfd
, output_bfd
, input_section
,
943 hit_data
, sym_sec
, offset
, addend
, val
)
944 struct bfd_link_info
* info
;
948 asection
* input_section
;
952 bfd_signed_vma addend
;
955 unsigned long int tmp
;
959 struct elf_link_hash_entry
* myh
;
960 struct elf32_arm_link_hash_table
* globals
;
962 myh
= find_arm_glue (info
, name
, input_bfd
);
966 globals
= elf32_arm_hash_table (info
);
968 BFD_ASSERT (globals
!= NULL
);
969 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
971 my_offset
= myh
->root
.u
.def
.value
;
972 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
973 ARM2THUMB_GLUE_SECTION_NAME
);
974 BFD_ASSERT (s
!= NULL
);
975 BFD_ASSERT (s
->contents
!= NULL
);
976 BFD_ASSERT (s
->output_section
!= NULL
);
978 if ((my_offset
& 0x01) == 0x01)
981 && sym_sec
->owner
!= NULL
982 && !INTERWORK_FLAG (sym_sec
->owner
))
985 (_("%s(%s): warning: interworking not enabled."),
986 bfd_get_filename (sym_sec
->owner
), name
);
988 (_(" first occurrence: %s: arm call to thumb"),
989 bfd_get_filename (input_bfd
));
993 myh
->root
.u
.def
.value
= my_offset
;
995 bfd_put_32 (output_bfd
, a2t1_ldr_insn
,
996 s
->contents
+ my_offset
);
998 bfd_put_32 (output_bfd
, a2t2_bx_r12_insn
,
999 s
->contents
+ my_offset
+ 4);
1001 /* It's a thumb address. Add the low order bit. */
1002 bfd_put_32 (output_bfd
, val
| a2t3_func_addr_insn
,
1003 s
->contents
+ my_offset
+ 8);
1006 BFD_ASSERT (my_offset
<= globals
->arm_glue_size
);
1008 tmp
= bfd_get_32 (input_bfd
, hit_data
);
1009 tmp
= tmp
& 0xFF000000;
1011 /* Somehow these are both 4 too far, so subtract 8. */
1012 ret_offset
= s
->output_offset
1014 + s
->output_section
->vma
1015 - (input_section
->output_offset
1016 + input_section
->output_section
->vma
1020 tmp
= tmp
| ((ret_offset
>> 2) & 0x00FFFFFF);
1022 bfd_put_32 (output_bfd
, tmp
, hit_data
1023 - input_section
->vma
);
1028 /* Perform a relocation as part of a final link. */
1030 static bfd_reloc_status_type
1031 elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
1032 input_section
, contents
, rel
, value
,
1033 info
, sym_sec
, sym_name
, sym_flags
, h
)
1034 reloc_howto_type
* howto
;
1037 asection
* input_section
;
1038 bfd_byte
* contents
;
1039 Elf_Internal_Rela
* rel
;
1041 struct bfd_link_info
* info
;
1043 const char * sym_name
;
1044 unsigned char sym_flags
;
1045 struct elf_link_hash_entry
* h
;
1047 unsigned long r_type
= howto
->type
;
1048 unsigned long r_symndx
;
1049 bfd_byte
* hit_data
= contents
+ rel
->r_offset
;
1050 bfd
* dynobj
= NULL
;
1051 Elf_Internal_Shdr
* symtab_hdr
;
1052 struct elf_link_hash_entry
** sym_hashes
;
1053 bfd_vma
* local_got_offsets
;
1054 asection
* sgot
= NULL
;
1055 asection
* splt
= NULL
;
1056 asection
* sreloc
= NULL
;
1058 bfd_signed_vma signed_addend
;
1059 struct elf32_arm_link_hash_table
* globals
;
1061 /* If the start address has been set, then set the EF_ARM_HASENTRY
1062 flag. Setting this more than once is redundant, but the cost is
1063 not too high, and it keeps the code simple.
1065 The test is done here, rather than somewhere else, because the
1066 start address is only set just before the final link commences.
1068 Note - if the user deliberately sets a start address of 0, the
1069 flag will not be set. */
1070 if (bfd_get_start_address (output_bfd
) != 0)
1071 elf_elfheader (output_bfd
)->e_flags
|= EF_ARM_HASENTRY
;
1073 globals
= elf32_arm_hash_table (info
);
1075 dynobj
= elf_hash_table (info
)->dynobj
;
1078 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1079 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1081 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1082 sym_hashes
= elf_sym_hashes (input_bfd
);
1083 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1084 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1087 addend
= bfd_get_32 (input_bfd
, hit_data
) & howto
->src_mask
;
1089 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1092 signed_addend
&= ~ howto
->src_mask
;
1093 signed_addend
|= addend
;
1096 signed_addend
= addend
;
1098 addend
= signed_addend
= rel
->r_addend
;
1104 return bfd_reloc_ok
;
1112 /* When generating a shared object, these relocations are copied
1113 into the output file to be resolved at run time. */
1115 && (r_type
!= R_ARM_PC24
1118 && (! info
->symbolic
1119 || (h
->elf_link_hash_flags
1120 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1122 Elf_Internal_Rel outrel
;
1123 boolean skip
, relocate
;
1129 name
= (bfd_elf_string_from_elf_section
1131 elf_elfheader (input_bfd
)->e_shstrndx
,
1132 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1134 return bfd_reloc_notsupported
;
1136 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
1137 && strcmp (bfd_get_section_name (input_bfd
,
1141 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1142 BFD_ASSERT (sreloc
!= NULL
);
1147 if (elf_section_data (input_section
)->stab_info
== NULL
)
1148 outrel
.r_offset
= rel
->r_offset
;
1153 off
= (_bfd_stab_section_offset
1154 (output_bfd
, &elf_hash_table (info
)->stab_info
,
1156 & elf_section_data (input_section
)->stab_info
,
1158 if (off
== (bfd_vma
) -1)
1160 outrel
.r_offset
= off
;
1163 outrel
.r_offset
+= (input_section
->output_section
->vma
1164 + input_section
->output_offset
);
1168 memset (&outrel
, 0, sizeof outrel
);
1171 else if (r_type
== R_ARM_PC24
)
1173 BFD_ASSERT (h
!= NULL
&& h
->dynindx
!= -1);
1174 if ((input_section
->flags
& SEC_ALLOC
) != 0)
1178 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_PC24
);
1183 || ((info
->symbolic
|| h
->dynindx
== -1)
1184 && (h
->elf_link_hash_flags
1185 & ELF_LINK_HASH_DEF_REGULAR
) != 0))
1188 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1192 BFD_ASSERT (h
->dynindx
!= -1);
1193 if ((input_section
->flags
& SEC_ALLOC
) != 0)
1197 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_ABS32
);
1201 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1202 (((Elf32_External_Rel
*)
1204 + sreloc
->reloc_count
));
1205 ++sreloc
->reloc_count
;
1207 /* If this reloc is against an external symbol, we do not want to
1208 fiddle with the addend. Otherwise, we need to include the symbol
1209 value so that it becomes an addend for the dynamic reloc. */
1211 return bfd_reloc_ok
;
1213 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1214 contents
, rel
->r_offset
, value
,
1217 else switch (r_type
)
1220 case R_ARM_XPC25
: /* Arm BLX instruction. */
1222 case R_ARM_PC24
: /* Arm B/BL instruction */
1224 if (r_type
== R_ARM_XPC25
)
1226 /* Check for Arm calling Arm function. */
1227 /* FIXME: Should we translate the instruction into a BL
1228 instruction instead ? */
1229 if (sym_flags
!= STT_ARM_TFUNC
)
1230 _bfd_error_handler (_("\
1231 %s: Warning: Arm BLX instruction targets Arm function '%s'."),
1232 bfd_get_filename (input_bfd
),
1233 h
? h
->root
.root
.string
: "(local)");
1238 /* Check for Arm calling Thumb function. */
1239 if (sym_flags
== STT_ARM_TFUNC
)
1241 elf32_arm_to_thumb_stub (info
, sym_name
, input_bfd
, output_bfd
,
1242 input_section
, hit_data
, sym_sec
, rel
->r_offset
,
1243 signed_addend
, value
);
1244 return bfd_reloc_ok
;
1248 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1249 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0)
1251 /* The old way of doing things. Trearing the addend as a
1252 byte sized field and adding in the pipeline offset. */
1253 value
-= (input_section
->output_section
->vma
1254 + input_section
->output_offset
);
1255 value
-= rel
->r_offset
;
1258 if (! globals
->no_pipeline_knowledge
)
1263 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
1265 S is the address of the symbol in the relocation.
1266 P is address of the instruction being relocated.
1267 A is the addend (extracted from the instruction) in bytes.
1269 S is held in 'value'.
1270 P is the base address of the section containing the instruction
1271 plus the offset of the reloc into that section, ie:
1272 (input_section->output_section->vma +
1273 input_section->output_offset +
1275 A is the addend, converted into bytes, ie:
1278 Note: None of these operations have knowledge of the pipeline
1279 size of the processor, thus it is up to the assembler to encode
1280 this information into the addend. */
1281 value
-= (input_section
->output_section
->vma
1282 + input_section
->output_offset
);
1283 value
-= rel
->r_offset
;
1284 value
+= (signed_addend
<< howto
->size
);
1286 /* Previous versions of this code also used to add in the pipeline
1287 offset here. This is wrong because the linker is not supposed
1288 to know about such things, and one day it might change. In order
1289 to support old binaries that need the old behaviour however, so
1290 we attempt to detect which ABI was used to create the reloc. */
1291 if (! globals
->no_pipeline_knowledge
)
1293 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form */
1295 i_ehdrp
= elf_elfheader (input_bfd
);
1297 if (i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1302 signed_addend
= value
;
1303 signed_addend
>>= howto
->rightshift
;
1305 /* It is not an error for an undefined weak reference to be
1306 out of range. Any program that branches to such a symbol
1307 is going to crash anyway, so there is no point worrying
1308 about getting the destination exactly right. */
1309 if (! h
|| h
->root
.type
!= bfd_link_hash_undefweak
)
1311 /* Perform a signed range check. */
1312 if ( signed_addend
> ((bfd_signed_vma
) (howto
->dst_mask
>> 1))
1313 || signed_addend
< - ((bfd_signed_vma
) ((howto
->dst_mask
+ 1) >> 1)))
1314 return bfd_reloc_overflow
;
1318 /* If necessary set the H bit in the BLX instruction. */
1319 if (r_type
== R_ARM_XPC25
&& ((value
& 2) == 2))
1320 value
= (signed_addend
& howto
->dst_mask
)
1321 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
))
1325 value
= (signed_addend
& howto
->dst_mask
)
1326 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1331 if (sym_flags
== STT_ARM_TFUNC
)
1336 value
-= (input_section
->output_section
->vma
1337 + input_section
->output_offset
+ rel
->r_offset
);
1342 bfd_put_32 (input_bfd
, value
, hit_data
);
1343 return bfd_reloc_ok
;
1347 if ((long) value
> 0x7f || (long) value
< -0x80)
1348 return bfd_reloc_overflow
;
1350 bfd_put_8 (input_bfd
, value
, hit_data
);
1351 return bfd_reloc_ok
;
1356 if ((long) value
> 0x7fff || (long) value
< -0x8000)
1357 return bfd_reloc_overflow
;
1359 bfd_put_16 (input_bfd
, value
, hit_data
);
1360 return bfd_reloc_ok
;
1363 /* Support ldr and str instruction for the arm */
1364 /* Also thumb b (unconditional branch). ??? Really? */
1367 if ((long) value
> 0x7ff || (long) value
< -0x800)
1368 return bfd_reloc_overflow
;
1370 value
|= (bfd_get_32 (input_bfd
, hit_data
) & 0xfffff000);
1371 bfd_put_32 (input_bfd
, value
, hit_data
);
1372 return bfd_reloc_ok
;
1374 case R_ARM_THM_ABS5
:
1375 /* Support ldr and str instructions for the thumb. */
1377 /* Need to refetch addend. */
1378 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1379 /* ??? Need to determine shift amount from operand size. */
1380 addend
>>= howto
->rightshift
;
1384 /* ??? Isn't value unsigned? */
1385 if ((long) value
> 0x1f || (long) value
< -0x10)
1386 return bfd_reloc_overflow
;
1388 /* ??? Value needs to be properly shifted into place first. */
1389 value
|= bfd_get_16 (input_bfd
, hit_data
) & 0xf83f;
1390 bfd_put_16 (input_bfd
, value
, hit_data
);
1391 return bfd_reloc_ok
;
1394 case R_ARM_THM_XPC22
:
1396 case R_ARM_THM_PC22
:
1397 /* Thumb BL (branch long instruction). */
1400 boolean overflow
= false;
1401 bfd_vma upper_insn
= bfd_get_16 (input_bfd
, hit_data
);
1402 bfd_vma lower_insn
= bfd_get_16 (input_bfd
, hit_data
+ 2);
1403 bfd_signed_vma reloc_signed_max
= (1 << (howto
->bitsize
- 1)) - 1;
1404 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1406 bfd_signed_vma signed_check
;
1409 /* Need to refetch the addend and squish the two 11 bit pieces
1412 bfd_vma upper
= upper_insn
& 0x7ff;
1413 bfd_vma lower
= lower_insn
& 0x7ff;
1414 upper
= (upper
^ 0x400) - 0x400; /* Sign extend. */
1415 addend
= (upper
<< 12) | (lower
<< 1);
1416 signed_addend
= addend
;
1420 if (r_type
== R_ARM_THM_XPC22
)
1422 /* Check for Thumb to Thumb call. */
1423 /* FIXME: Should we translate the instruction into a BL
1424 instruction instead ? */
1425 if (sym_flags
== STT_ARM_TFUNC
)
1426 _bfd_error_handler (_("\
1427 %s: Warning: Thumb BLX instruction targets thumb function '%s'."),
1428 bfd_get_filename (input_bfd
),
1429 h
? h
->root
.root
.string
: "(local)");
1434 /* If it is not a call to Thumb, assume call to Arm.
1435 If it is a call relative to a section name, then it is not a
1436 function call at all, but rather a long jump. */
1437 if (sym_flags
!= STT_ARM_TFUNC
&& sym_flags
!= STT_SECTION
)
1439 if (elf32_thumb_to_arm_stub
1440 (info
, sym_name
, input_bfd
, output_bfd
, input_section
,
1441 hit_data
, sym_sec
, rel
->r_offset
, signed_addend
, value
))
1442 return bfd_reloc_ok
;
1444 return bfd_reloc_dangerous
;
1448 relocation
= value
+ signed_addend
;
1450 relocation
-= (input_section
->output_section
->vma
1451 + input_section
->output_offset
1454 if (! globals
->no_pipeline_knowledge
)
1456 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form. */
1458 i_ehdrp
= elf_elfheader (input_bfd
);
1460 /* Previous versions of this code also used to add in the pipline
1461 offset here. This is wrong because the linker is not supposed
1462 to know about such things, and one day it might change. In order
1463 to support old binaries that need the old behaviour however, so
1464 we attempt to detect which ABI was used to create the reloc. */
1465 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1466 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0
1467 || i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1471 check
= relocation
>> howto
->rightshift
;
1473 /* If this is a signed value, the rightshift just dropped
1474 leading 1 bits (assuming twos complement). */
1475 if ((bfd_signed_vma
) relocation
>= 0)
1476 signed_check
= check
;
1478 signed_check
= check
| ~((bfd_vma
) -1 >> howto
->rightshift
);
1480 /* Assumes two's complement. */
1481 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1484 /* Put RELOCATION back into the insn. */
1485 upper_insn
= (upper_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 12) & 0x7ff);
1486 lower_insn
= (lower_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 1) & 0x7ff);
1489 if (r_type
== R_ARM_THM_XPC22
1490 && ((lower_insn
& 0x1800) == 0x0800))
1491 /* Remove bit zero of the adjusted offset. Bit zero can only be
1492 set if the upper insn is at a half-word boundary, since the
1493 destination address, an ARM instruction, must always be on a
1494 word boundary. The semantics of the BLX (1) instruction, however,
1495 are that bit zero in the offset must always be zero, and the
1496 corresponding bit one in the target address will be set from bit
1497 one of the source address. */
1500 /* Put the relocated value back in the object file: */
1501 bfd_put_16 (input_bfd
, upper_insn
, hit_data
);
1502 bfd_put_16 (input_bfd
, lower_insn
, hit_data
+ 2);
1504 return (overflow
? bfd_reloc_overflow
: bfd_reloc_ok
);
1508 case R_ARM_GNU_VTINHERIT
:
1509 case R_ARM_GNU_VTENTRY
:
1510 return bfd_reloc_ok
;
1513 return bfd_reloc_notsupported
;
1515 case R_ARM_GLOB_DAT
:
1516 return bfd_reloc_notsupported
;
1518 case R_ARM_JUMP_SLOT
:
1519 return bfd_reloc_notsupported
;
1521 case R_ARM_RELATIVE
:
1522 return bfd_reloc_notsupported
;
1525 /* Relocation is relative to the start of the
1526 global offset table. */
1528 BFD_ASSERT (sgot
!= NULL
);
1530 return bfd_reloc_notsupported
;
1532 /* Note that sgot->output_offset is not involved in this
1533 calculation. We always want the start of .got. If we
1534 define _GLOBAL_OFFSET_TABLE in a different way, as is
1535 permitted by the ABI, we might have to change this
1537 value
-= sgot
->output_section
->vma
;
1538 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1539 contents
, rel
->r_offset
, value
,
1543 /* Use global offset table as symbol value. */
1544 BFD_ASSERT (sgot
!= NULL
);
1547 return bfd_reloc_notsupported
;
1549 value
= sgot
->output_section
->vma
;
1550 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1551 contents
, rel
->r_offset
, value
,
1555 /* Relocation is to the entry for this symbol in the
1556 global offset table. */
1558 return bfd_reloc_notsupported
;
1564 off
= h
->got
.offset
;
1565 BFD_ASSERT (off
!= (bfd_vma
) -1);
1567 if (!elf_hash_table (info
)->dynamic_sections_created
||
1568 (info
->shared
&& (info
->symbolic
|| h
->dynindx
== -1)
1569 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1571 /* This is actually a static link, or it is a -Bsymbolic link
1572 and the symbol is defined locally. We must initialize this
1573 entry in the global offset table. Since the offset must
1574 always be a multiple of 4, we use the least significant bit
1575 to record whether we have initialized it already.
1577 When doing a dynamic link, we create a .rel.got relocation
1578 entry to initialize the value. This is done in the
1579 finish_dynamic_symbol routine. */
1584 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1589 value
= sgot
->output_offset
+ off
;
1595 BFD_ASSERT (local_got_offsets
!= NULL
&&
1596 local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1598 off
= local_got_offsets
[r_symndx
];
1600 /* The offset must always be a multiple of 4. We use the
1601 least significant bit to record whether we have already
1602 generated the necessary reloc. */
1607 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1612 Elf_Internal_Rel outrel
;
1614 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
1615 BFD_ASSERT (srelgot
!= NULL
);
1617 outrel
.r_offset
= (sgot
->output_section
->vma
1618 + sgot
->output_offset
1620 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1621 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1622 (((Elf32_External_Rel
*)
1624 + srelgot
->reloc_count
));
1625 ++srelgot
->reloc_count
;
1628 local_got_offsets
[r_symndx
] |= 1;
1631 value
= sgot
->output_offset
+ off
;
1634 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1635 contents
, rel
->r_offset
, value
,
1639 /* Relocation is to the entry for this symbol in the
1640 procedure linkage table. */
1642 /* Resolve a PLT32 reloc against a local symbol directly,
1643 without using the procedure linkage table. */
1645 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1646 contents
, rel
->r_offset
, value
,
1649 if (h
->plt
.offset
== (bfd_vma
) -1)
1650 /* We didn't make a PLT entry for this symbol. This
1651 happens when statically linking PIC code, or when
1652 using -Bsymbolic. */
1653 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1654 contents
, rel
->r_offset
, value
,
1657 BFD_ASSERT(splt
!= NULL
);
1659 return bfd_reloc_notsupported
;
1661 value
= (splt
->output_section
->vma
1662 + splt
->output_offset
1664 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1665 contents
, rel
->r_offset
, value
,
1669 return bfd_reloc_notsupported
;
1671 case R_ARM_AMP_VCALL9
:
1672 return bfd_reloc_notsupported
;
1674 case R_ARM_RSBREL32
:
1675 return bfd_reloc_notsupported
;
1677 case R_ARM_THM_RPC22
:
1678 return bfd_reloc_notsupported
;
1681 return bfd_reloc_notsupported
;
1684 return bfd_reloc_notsupported
;
1687 return bfd_reloc_notsupported
;
1690 return bfd_reloc_notsupported
;
1693 return bfd_reloc_notsupported
;
1698 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
1700 arm_add_to_rel (abfd
, address
, howto
, increment
)
1703 reloc_howto_type
* howto
;
1704 bfd_signed_vma increment
;
1706 bfd_signed_vma addend
;
1708 if (howto
->type
== R_ARM_THM_PC22
)
1710 int upper_insn
, lower_insn
;
1713 upper_insn
= bfd_get_16 (abfd
, address
);
1714 lower_insn
= bfd_get_16 (abfd
, address
+ 2);
1715 upper
= upper_insn
& 0x7ff;
1716 lower
= lower_insn
& 0x7ff;
1718 addend
= (upper
<< 12) | (lower
<< 1);
1719 addend
+= increment
;
1722 upper_insn
= (upper_insn
& 0xf800) | ((addend
>> 11) & 0x7ff);
1723 lower_insn
= (lower_insn
& 0xf800) | (addend
& 0x7ff);
1725 bfd_put_16 (abfd
, upper_insn
, address
);
1726 bfd_put_16 (abfd
, lower_insn
, address
+ 2);
1732 contents
= bfd_get_32 (abfd
, address
);
1734 /* Get the (signed) value from the instruction. */
1735 addend
= contents
& howto
->src_mask
;
1736 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1738 bfd_signed_vma mask
;
1741 mask
&= ~ howto
->src_mask
;
1745 /* Add in the increment, (which is a byte value). */
1746 switch (howto
->type
)
1749 addend
+= increment
;
1753 addend
<<= howto
->size
;
1754 addend
+= increment
;
1756 /* Should we check for overflow here ? */
1758 /* Drop any undesired bits. */
1759 addend
>>= howto
->rightshift
;
1763 contents
= (contents
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
1765 bfd_put_32 (abfd
, contents
, address
);
1768 #endif /* USE_REL */
1770 /* Relocate an ARM ELF section. */
1772 elf32_arm_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1773 contents
, relocs
, local_syms
, local_sections
)
1775 struct bfd_link_info
* info
;
1777 asection
* input_section
;
1778 bfd_byte
* contents
;
1779 Elf_Internal_Rela
* relocs
;
1780 Elf_Internal_Sym
* local_syms
;
1781 asection
** local_sections
;
1783 Elf_Internal_Shdr
* symtab_hdr
;
1784 struct elf_link_hash_entry
** sym_hashes
;
1785 Elf_Internal_Rela
* rel
;
1786 Elf_Internal_Rela
* relend
;
1789 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1790 sym_hashes
= elf_sym_hashes (input_bfd
);
1793 relend
= relocs
+ input_section
->reloc_count
;
1794 for (; rel
< relend
; rel
++)
1797 reloc_howto_type
* howto
;
1798 unsigned long r_symndx
;
1799 Elf_Internal_Sym
* sym
;
1801 struct elf_link_hash_entry
* h
;
1803 bfd_reloc_status_type r
;
1806 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1807 r_type
= ELF32_R_TYPE (rel
->r_info
);
1809 if ( r_type
== R_ARM_GNU_VTENTRY
1810 || r_type
== R_ARM_GNU_VTINHERIT
)
1813 elf32_arm_info_to_howto (input_bfd
, & bfd_reloc
, rel
);
1814 howto
= bfd_reloc
.howto
;
1816 if (info
->relocateable
)
1818 /* This is a relocateable link. We don't have to change
1819 anything, unless the reloc is against a section symbol,
1820 in which case we have to adjust according to where the
1821 section symbol winds up in the output section. */
1822 if (r_symndx
< symtab_hdr
->sh_info
)
1824 sym
= local_syms
+ r_symndx
;
1825 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1827 sec
= local_sections
[r_symndx
];
1829 arm_add_to_rel (input_bfd
, contents
+ rel
->r_offset
,
1830 howto
, sec
->output_offset
+ sym
->st_value
);
1832 rel
->r_addend
+= (sec
->output_offset
+ sym
->st_value
)
1833 >> howto
->rightshift
;
1841 /* This is a final link. */
1846 if (r_symndx
< symtab_hdr
->sh_info
)
1848 sym
= local_syms
+ r_symndx
;
1849 sec
= local_sections
[r_symndx
];
1850 relocation
= (sec
->output_section
->vma
1851 + sec
->output_offset
1856 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1858 while ( h
->root
.type
== bfd_link_hash_indirect
1859 || h
->root
.type
== bfd_link_hash_warning
)
1860 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1862 if ( h
->root
.type
== bfd_link_hash_defined
1863 || h
->root
.type
== bfd_link_hash_defweak
)
1865 int relocation_needed
= 1;
1867 sec
= h
->root
.u
.def
.section
;
1869 /* In these cases, we don't need the relocation value.
1870 We check specially because in some obscure cases
1871 sec->output_section will be NULL. */
1878 (!info
->symbolic
&& h
->dynindx
!= -1)
1879 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1881 && ((input_section
->flags
& SEC_ALLOC
) != 0
1882 /* DWARF will emit R_ARM_ABS32 relocations in its
1883 sections against symbols defined externally
1884 in shared libraries. We can't do anything
1886 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
1887 && (h
->elf_link_hash_flags
1888 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
1890 relocation_needed
= 0;
1894 relocation_needed
= 0;
1898 if (elf_hash_table(info
)->dynamic_sections_created
1900 || (!info
->symbolic
&& h
->dynindx
!= -1)
1901 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1904 relocation_needed
= 0;
1908 if (h
->plt
.offset
!= (bfd_vma
)-1)
1909 relocation_needed
= 0;
1913 if (sec
->output_section
== NULL
)
1915 (*_bfd_error_handler
)
1916 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1917 bfd_get_filename (input_bfd
), h
->root
.root
.string
,
1918 bfd_get_section_name (input_bfd
, input_section
));
1919 relocation_needed
= 0;
1923 if (relocation_needed
)
1924 relocation
= h
->root
.u
.def
.value
1925 + sec
->output_section
->vma
1926 + sec
->output_offset
;
1930 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1932 else if (info
->shared
&& !info
->symbolic
1933 && !info
->no_undefined
1934 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1938 if (!((*info
->callbacks
->undefined_symbol
)
1939 (info
, h
->root
.root
.string
, input_bfd
,
1940 input_section
, rel
->r_offset
,
1941 (!info
->shared
|| info
->no_undefined
1942 || ELF_ST_VISIBILITY (h
->other
)))))
1949 name
= h
->root
.root
.string
;
1952 name
= (bfd_elf_string_from_elf_section
1953 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
1954 if (name
== NULL
|| *name
== '\0')
1955 name
= bfd_section_name (input_bfd
, sec
);
1958 r
= elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
1959 input_section
, contents
, rel
,
1960 relocation
, info
, sec
, name
,
1961 (h
? ELF_ST_TYPE (h
->type
) :
1962 ELF_ST_TYPE (sym
->st_info
)), h
);
1964 if (r
!= bfd_reloc_ok
)
1966 const char * msg
= (const char *) 0;
1970 case bfd_reloc_overflow
:
1971 /* If the overflowing reloc was to an undefined symbol,
1972 we have already printed one error message and there
1973 is no point complaining again. */
1975 h
->root
.type
!= bfd_link_hash_undefined
)
1976 && (!((*info
->callbacks
->reloc_overflow
)
1977 (info
, name
, howto
->name
, (bfd_vma
) 0,
1978 input_bfd
, input_section
, rel
->r_offset
))))
1982 case bfd_reloc_undefined
:
1983 if (!((*info
->callbacks
->undefined_symbol
)
1984 (info
, name
, input_bfd
, input_section
,
1985 rel
->r_offset
, true)))
1989 case bfd_reloc_outofrange
:
1990 msg
= _("internal error: out of range error");
1993 case bfd_reloc_notsupported
:
1994 msg
= _("internal error: unsupported relocation error");
1997 case bfd_reloc_dangerous
:
1998 msg
= _("internal error: dangerous error");
2002 msg
= _("internal error: unknown error");
2006 if (!((*info
->callbacks
->warning
)
2007 (info
, msg
, name
, input_bfd
, input_section
,
2018 /* Function to keep ARM specific flags in the ELF header. */
2020 elf32_arm_set_private_flags (abfd
, flags
)
2024 if (elf_flags_init (abfd
)
2025 && elf_elfheader (abfd
)->e_flags
!= flags
)
2027 if (EF_ARM_EABI_VERSION (flags
) == EF_ARM_EABI_UNKNOWN
)
2029 if (flags
& EF_ARM_INTERWORK
)
2030 _bfd_error_handler (_("\
2031 Warning: Not setting interwork flag of %s since it has already been specified as non-interworking"),
2032 bfd_get_filename (abfd
));
2034 _bfd_error_handler (_("\
2035 Warning: Clearing the interwork flag of %s due to outside request"),
2036 bfd_get_filename (abfd
));
2041 elf_elfheader (abfd
)->e_flags
= flags
;
2042 elf_flags_init (abfd
) = true;
2048 /* Copy backend specific data from one object module to another. */
2051 elf32_arm_copy_private_bfd_data (ibfd
, obfd
)
2058 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2059 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2062 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2063 out_flags
= elf_elfheader (obfd
)->e_flags
;
2065 if (elf_flags_init (obfd
)
2066 && EF_ARM_EABI_VERSION (out_flags
) == EF_ARM_EABI_UNKNOWN
2067 && in_flags
!= out_flags
)
2069 /* Cannot mix APCS26 and APCS32 code. */
2070 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2073 /* Cannot mix float APCS and non-float APCS code. */
2074 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2077 /* If the src and dest have different interworking flags
2078 then turn off the interworking bit. */
2079 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2081 if (out_flags
& EF_ARM_INTERWORK
)
2082 _bfd_error_handler (_("\
2083 Warning: Clearing the interwork flag in %s because non-interworking code in %s has been linked with it"),
2084 bfd_get_filename (obfd
), bfd_get_filename (ibfd
));
2086 in_flags
&= ~EF_ARM_INTERWORK
;
2089 /* Likewise for PIC, though don't warn for this case. */
2090 if ((in_flags
& EF_ARM_PIC
) != (out_flags
& EF_ARM_PIC
))
2091 in_flags
&= ~EF_ARM_PIC
;
2094 elf_elfheader (obfd
)->e_flags
= in_flags
;
2095 elf_flags_init (obfd
) = true;
2100 /* Merge backend specific data from an object file to the output
2101 object file when linking. */
2104 elf32_arm_merge_private_bfd_data (ibfd
, obfd
)
2110 boolean flags_compatible
= true;
2111 boolean null_input_bfd
= true;
2114 /* Check if we have the same endianess. */
2115 if (_bfd_generic_verify_endian_match (ibfd
, obfd
) == false)
2118 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2119 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2122 /* The input BFD must have had its flags initialised. */
2123 /* The following seems bogus to me -- The flags are initialized in
2124 the assembler but I don't think an elf_flags_init field is
2125 written into the object. */
2126 /* BFD_ASSERT (elf_flags_init (ibfd)); */
2128 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2129 out_flags
= elf_elfheader (obfd
)->e_flags
;
2131 if (!elf_flags_init (obfd
))
2133 /* If the input is the default architecture and had the default
2134 flags then do not bother setting the flags for the output
2135 architecture, instead allow future merges to do this. If no
2136 future merges ever set these flags then they will retain their
2137 uninitialised values, which surprise surprise, correspond
2138 to the default values. */
2139 if (bfd_get_arch_info (ibfd
)->the_default
2140 && elf_elfheader (ibfd
)->e_flags
== 0)
2143 elf_flags_init (obfd
) = true;
2144 elf_elfheader (obfd
)->e_flags
= in_flags
;
2146 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
2147 && bfd_get_arch_info (obfd
)->the_default
)
2148 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
), bfd_get_mach (ibfd
));
2153 /* Identical flags must be compatible. */
2154 if (in_flags
== out_flags
)
2157 /* Check to see if the input BFD actually contains any sections.
2158 If not, its flags may not have been initialised either, but it cannot
2159 actually cause any incompatibility. */
2160 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2162 /* Ignore synthetic glue sections. */
2163 if (strcmp (sec
->name
, ".glue_7")
2164 && strcmp (sec
->name
, ".glue_7t"))
2166 null_input_bfd
= false;
2173 /* Complain about various flag mismatches. */
2174 if (EF_ARM_EABI_VERSION (in_flags
) != EF_ARM_EABI_VERSION (out_flags
))
2176 _bfd_error_handler (_("\
2177 Error: %s compiled for EABI version %d, whereas %s is compiled for version %d"),
2178 bfd_get_filename (ibfd
),
2179 (in_flags
& EF_ARM_EABIMASK
) >> 24,
2180 bfd_get_filename (obfd
),
2181 (out_flags
& EF_ARM_EABIMASK
) >> 24);
2185 /* Not sure what needs to be checked for EABI versions >= 1. */
2186 if (EF_ARM_EABI_VERSION (in_flags
) == EF_ARM_EABI_UNKNOWN
)
2188 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2190 _bfd_error_handler (_("\
2191 Error: %s compiled for APCS-%d, whereas %s is compiled for APCS-%d"),
2192 bfd_get_filename (ibfd
),
2193 in_flags
& EF_ARM_APCS_26
? 26 : 32,
2194 bfd_get_filename (obfd
),
2195 out_flags
& EF_ARM_APCS_26
? 26 : 32);
2196 flags_compatible
= false;
2199 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2201 _bfd_error_handler (_("\
2202 Error: %s passes floats in %s registers, whereas %s passes them in %s registers"),
2203 bfd_get_filename (ibfd
),
2204 in_flags
& EF_ARM_APCS_FLOAT
? _("float") : _("integer"),
2205 bfd_get_filename (obfd
),
2206 out_flags
& EF_ARM_APCS_26
? _("float") : _("integer"));
2207 flags_compatible
= false;
2210 #ifdef EF_ARM_SOFT_FLOAT
2211 if ((in_flags
& EF_ARM_SOFT_FLOAT
) != (out_flags
& EF_ARM_SOFT_FLOAT
))
2213 _bfd_error_handler (_ ("\
2214 Error: %s uses %s floating point, whereas %s uses %s floating point"),
2215 bfd_get_filename (ibfd
),
2216 in_flags
& EF_ARM_SOFT_FLOAT
? _("soft") : _("hard"),
2217 bfd_get_filename (obfd
),
2218 out_flags
& EF_ARM_SOFT_FLOAT
? _("soft") : _("hard"));
2219 flags_compatible
= false;
2223 /* Interworking mismatch is only a warning. */
2224 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2225 _bfd_error_handler (_("\
2226 Warning: %s %s interworking, whereas %s %s"),
2227 bfd_get_filename (ibfd
),
2228 in_flags
& EF_ARM_INTERWORK
? _("supports") : _("does not support"),
2229 bfd_get_filename (obfd
),
2230 out_flags
& EF_ARM_INTERWORK
? _("does") : _("does not"));
2233 return flags_compatible
;
2236 /* Display the flags field. */
2239 elf32_arm_print_private_bfd_data (abfd
, ptr
)
2243 FILE * file
= (FILE *) ptr
;
2244 unsigned long flags
;
2246 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
2248 /* Print normal ELF private data. */
2249 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
2251 flags
= elf_elfheader (abfd
)->e_flags
;
2252 /* Ignore init flag - it may not be set, despite the flags field
2253 containing valid data. */
2255 /* xgettext:c-format */
2256 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
2258 switch (EF_ARM_EABI_VERSION (flags
))
2260 case EF_ARM_EABI_UNKNOWN
:
2261 /* The following flag bits are GNU extenstions and not part of the
2262 official ARM ELF extended ABI. Hence they are only decoded if
2263 the EABI version is not set. */
2264 if (flags
& EF_ARM_INTERWORK
)
2265 fprintf (file
, _(" [interworking enabled]"));
2267 if (flags
& EF_ARM_APCS_26
)
2268 fprintf (file
, _(" [APCS-26]"));
2270 fprintf (file
, _(" [APCS-32]"));
2272 if (flags
& EF_ARM_APCS_FLOAT
)
2273 fprintf (file
, _(" [floats passed in float registers]"));
2275 if (flags
& EF_ARM_PIC
)
2276 fprintf (file
, _(" [position independent]"));
2278 if (flags
& EF_ARM_NEW_ABI
)
2279 fprintf (file
, _(" [new ABI]"));
2281 if (flags
& EF_ARM_OLD_ABI
)
2282 fprintf (file
, _(" [old ABI]"));
2284 if (flags
& EF_ARM_SOFT_FLOAT
)
2285 fprintf (file
, _(" [software FP]"));
2287 flags
&= ~(EF_ARM_INTERWORK
| EF_ARM_APCS_26
| EF_ARM_APCS_FLOAT
| EF_ARM_PIC
2288 | EF_ARM_NEW_ABI
| EF_ARM_OLD_ABI
| EF_ARM_SOFT_FLOAT
);
2291 case EF_ARM_EABI_VER1
:
2292 fprintf (file
, _(" [Version1 EABI]"));
2294 if (flags
& EF_ARM_SYMSARESORTED
)
2295 fprintf (file
, _(" [sorted symbol table]"));
2297 fprintf (file
, _(" [unsorted symbol table]"));
2299 flags
&= ~ EF_ARM_SYMSARESORTED
;
2302 case EF_ARM_EABI_VER2
:
2303 fprintf (file
, _(" [Version2 EABI]"));
2305 if (flags
& EF_ARM_SYMSARESORTED
)
2306 fprintf (file
, _(" [sorted symbol table]"));
2308 fprintf (file
, _(" [unsorted symbol table]"));
2310 if (flags
& EF_ARM_DYNSYMSUSESEGIDX
)
2311 fprintf (file
, _(" [dynamic symbols use segment index]"));
2313 if (flags
& EF_ARM_MAPSYMSFIRST
)
2314 fprintf (file
, _(" [mapping symbols precede others]"));
2316 flags
&= ~(EF_ARM_SYMSARESORTED
| EF_ARM_DYNSYMSUSESEGIDX
2317 | EF_ARM_MAPSYMSFIRST
);
2321 fprintf (file
, _(" <EABI version unrecognised>"));
2325 flags
&= ~ EF_ARM_EABIMASK
;
2327 if (flags
& EF_ARM_RELEXEC
)
2328 fprintf (file
, _(" [relocatable executable]"));
2330 if (flags
& EF_ARM_HASENTRY
)
2331 fprintf (file
, _(" [has entry point]"));
2333 flags
&= ~ (EF_ARM_RELEXEC
| EF_ARM_HASENTRY
);
2336 fprintf (file
, _("<Unrecognised flag bits set>"));
2344 elf32_arm_get_symbol_type (elf_sym
, type
)
2345 Elf_Internal_Sym
* elf_sym
;
2348 switch (ELF_ST_TYPE (elf_sym
->st_info
))
2351 return ELF_ST_TYPE (elf_sym
->st_info
);
2354 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2355 This allows us to distinguish between data used by Thumb instructions
2356 and non-data (which is probably code) inside Thumb regions of an
2358 if (type
!= STT_OBJECT
)
2359 return ELF_ST_TYPE (elf_sym
->st_info
);
2370 elf32_arm_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
2372 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2373 Elf_Internal_Rela
*rel
;
2374 struct elf_link_hash_entry
*h
;
2375 Elf_Internal_Sym
*sym
;
2379 switch (ELF32_R_TYPE (rel
->r_info
))
2381 case R_ARM_GNU_VTINHERIT
:
2382 case R_ARM_GNU_VTENTRY
:
2386 switch (h
->root
.type
)
2388 case bfd_link_hash_defined
:
2389 case bfd_link_hash_defweak
:
2390 return h
->root
.u
.def
.section
;
2392 case bfd_link_hash_common
:
2393 return h
->root
.u
.c
.p
->section
;
2402 if (!(elf_bad_symtab (abfd
)
2403 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
2404 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
2405 && sym
->st_shndx
!= SHN_COMMON
))
2407 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
2413 /* Update the got entry reference counts for the section being removed. */
2416 elf32_arm_gc_sweep_hook (abfd
, info
, sec
, relocs
)
2417 bfd
*abfd ATTRIBUTE_UNUSED
;
2418 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2419 asection
*sec ATTRIBUTE_UNUSED
;
2420 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
;
2422 /* We don't support garbage collection of GOT and PLT relocs yet. */
2426 /* Look through the relocs for a section during the first phase. */
2429 elf32_arm_check_relocs (abfd
, info
, sec
, relocs
)
2431 struct bfd_link_info
* info
;
2433 const Elf_Internal_Rela
* relocs
;
2435 Elf_Internal_Shdr
* symtab_hdr
;
2436 struct elf_link_hash_entry
** sym_hashes
;
2437 struct elf_link_hash_entry
** sym_hashes_end
;
2438 const Elf_Internal_Rela
* rel
;
2439 const Elf_Internal_Rela
* rel_end
;
2441 asection
* sgot
, *srelgot
, *sreloc
;
2442 bfd_vma
* local_got_offsets
;
2444 if (info
->relocateable
)
2447 sgot
= srelgot
= sreloc
= NULL
;
2449 dynobj
= elf_hash_table (info
)->dynobj
;
2450 local_got_offsets
= elf_local_got_offsets (abfd
);
2452 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2453 sym_hashes
= elf_sym_hashes (abfd
);
2454 sym_hashes_end
= sym_hashes
2455 + symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
2457 if (!elf_bad_symtab (abfd
))
2458 sym_hashes_end
-= symtab_hdr
->sh_info
;
2460 rel_end
= relocs
+ sec
->reloc_count
;
2461 for (rel
= relocs
; rel
< rel_end
; rel
++)
2463 struct elf_link_hash_entry
*h
;
2464 unsigned long r_symndx
;
2466 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2467 if (r_symndx
< symtab_hdr
->sh_info
)
2470 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2472 /* Some relocs require a global offset table. */
2475 switch (ELF32_R_TYPE (rel
->r_info
))
2480 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
2481 if (! _bfd_elf_create_got_section (dynobj
, info
))
2490 switch (ELF32_R_TYPE (rel
->r_info
))
2493 /* This symbol requires a global offset table entry. */
2496 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2497 BFD_ASSERT (sgot
!= NULL
);
2500 /* Get the got relocation section if necessary. */
2502 && (h
!= NULL
|| info
->shared
))
2504 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
2506 /* If no got relocation section, make one and initialize. */
2507 if (srelgot
== NULL
)
2509 srelgot
= bfd_make_section (dynobj
, ".rel.got");
2511 || ! bfd_set_section_flags (dynobj
, srelgot
,
2516 | SEC_LINKER_CREATED
2518 || ! bfd_set_section_alignment (dynobj
, srelgot
, 2))
2525 if (h
->got
.offset
!= (bfd_vma
) -1)
2526 /* We have already allocated space in the .got. */
2529 h
->got
.offset
= sgot
->_raw_size
;
2531 /* Make sure this symbol is output as a dynamic symbol. */
2532 if (h
->dynindx
== -1)
2533 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2536 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2540 /* This is a global offset table entry for a local
2542 if (local_got_offsets
== NULL
)
2545 register unsigned int i
;
2547 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
2548 local_got_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
2549 if (local_got_offsets
== NULL
)
2551 elf_local_got_offsets (abfd
) = local_got_offsets
;
2552 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
2553 local_got_offsets
[i
] = (bfd_vma
) -1;
2556 if (local_got_offsets
[r_symndx
] != (bfd_vma
) -1)
2557 /* We have already allocated space in the .got. */
2560 local_got_offsets
[r_symndx
] = sgot
->_raw_size
;
2563 /* If we are generating a shared object, we need to
2564 output a R_ARM_RELATIVE reloc so that the dynamic
2565 linker can adjust this GOT entry. */
2566 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2569 sgot
->_raw_size
+= 4;
2573 /* This symbol requires a procedure linkage table entry. We
2574 actually build the entry in adjust_dynamic_symbol,
2575 because this might be a case of linking PIC code which is
2576 never referenced by a dynamic object, in which case we
2577 don't need to generate a procedure linkage table entry
2580 /* If this is a local symbol, we resolve it directly without
2581 creating a procedure linkage table entry. */
2585 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2591 /* If we are creating a shared library, and this is a reloc
2592 against a global symbol, or a non PC relative reloc
2593 against a local symbol, then we need to copy the reloc
2594 into the shared library. However, if we are linking with
2595 -Bsymbolic, we do not need to copy a reloc against a
2596 global symbol which is defined in an object we are
2597 including in the link (i.e., DEF_REGULAR is set). At
2598 this point we have not seen all the input files, so it is
2599 possible that DEF_REGULAR is not set now but will be set
2600 later (it is never cleared). We account for that
2601 possibility below by storing information in the
2602 pcrel_relocs_copied field of the hash table entry. */
2604 && (ELF32_R_TYPE (rel
->r_info
) != R_ARM_PC24
2606 && (! info
->symbolic
2607 || (h
->elf_link_hash_flags
2608 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
2610 /* When creating a shared object, we must copy these
2611 reloc types into the output file. We create a reloc
2612 section in dynobj and make room for this reloc. */
2617 name
= (bfd_elf_string_from_elf_section
2619 elf_elfheader (abfd
)->e_shstrndx
,
2620 elf_section_data (sec
)->rel_hdr
.sh_name
));
2624 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
2625 && strcmp (bfd_get_section_name (abfd
, sec
),
2628 sreloc
= bfd_get_section_by_name (dynobj
, name
);
2633 sreloc
= bfd_make_section (dynobj
, name
);
2634 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
2635 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
2636 if ((sec
->flags
& SEC_ALLOC
) != 0)
2637 flags
|= SEC_ALLOC
| SEC_LOAD
;
2639 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
2640 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
2643 if (sec
->flags
& SEC_READONLY
)
2644 info
->flags
|= DF_TEXTREL
;
2647 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
2648 /* If we are linking with -Bsymbolic, and this is a
2649 global symbol, we count the number of PC relative
2650 relocations we have entered for this symbol, so that
2651 we can discard them again if the symbol is later
2652 defined by a regular object. Note that this function
2653 is only called if we are using an elf_i386 linker
2654 hash table, which means that h is really a pointer to
2655 an elf_i386_link_hash_entry. */
2656 if (h
!= NULL
&& info
->symbolic
2657 && ELF32_R_TYPE (rel
->r_info
) == R_ARM_PC24
)
2659 struct elf32_arm_link_hash_entry
* eh
;
2660 struct elf32_arm_pcrel_relocs_copied
* p
;
2662 eh
= (struct elf32_arm_link_hash_entry
*) h
;
2664 for (p
= eh
->pcrel_relocs_copied
; p
!= NULL
; p
= p
->next
)
2665 if (p
->section
== sreloc
)
2670 p
= ((struct elf32_arm_pcrel_relocs_copied
*)
2671 bfd_alloc (dynobj
, sizeof * p
));
2675 p
->next
= eh
->pcrel_relocs_copied
;
2676 eh
->pcrel_relocs_copied
= p
;
2677 p
->section
= sreloc
;
2686 /* This relocation describes the C++ object vtable hierarchy.
2687 Reconstruct it for later use during GC. */
2688 case R_ARM_GNU_VTINHERIT
:
2689 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2693 /* This relocation describes which C++ vtable entries are actually
2694 used. Record for later use during GC. */
2695 case R_ARM_GNU_VTENTRY
:
2696 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
2705 /* Find the nearest line to a particular section and offset, for error
2706 reporting. This code is a duplicate of the code in elf.c, except
2707 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
2710 elf32_arm_find_nearest_line
2711 (abfd
, section
, symbols
, offset
, filename_ptr
, functionname_ptr
, line_ptr
)
2716 const char ** filename_ptr
;
2717 const char ** functionname_ptr
;
2718 unsigned int * line_ptr
;
2721 const char * filename
;
2726 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
2727 filename_ptr
, functionname_ptr
,
2729 &elf_tdata (abfd
)->dwarf2_find_line_info
))
2732 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2733 &found
, filename_ptr
,
2734 functionname_ptr
, line_ptr
,
2735 &elf_tdata (abfd
)->line_info
))
2741 if (symbols
== NULL
)
2748 for (p
= symbols
; *p
!= NULL
; p
++)
2752 q
= (elf_symbol_type
*) *p
;
2754 if (bfd_get_section (&q
->symbol
) != section
)
2757 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
2762 filename
= bfd_asymbol_name (&q
->symbol
);
2767 if (q
->symbol
.section
== section
2768 && q
->symbol
.value
>= low_func
2769 && q
->symbol
.value
<= offset
)
2771 func
= (asymbol
*) q
;
2772 low_func
= q
->symbol
.value
;
2781 *filename_ptr
= filename
;
2782 *functionname_ptr
= bfd_asymbol_name (func
);
2788 /* Adjust a symbol defined by a dynamic object and referenced by a
2789 regular object. The current definition is in some section of the
2790 dynamic object, but we're not including those sections. We have to
2791 change the definition to something the rest of the link can
2795 elf32_arm_adjust_dynamic_symbol (info
, h
)
2796 struct bfd_link_info
* info
;
2797 struct elf_link_hash_entry
* h
;
2801 unsigned int power_of_two
;
2803 dynobj
= elf_hash_table (info
)->dynobj
;
2805 /* Make sure we know what is going on here. */
2806 BFD_ASSERT (dynobj
!= NULL
2807 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
2808 || h
->weakdef
!= NULL
2809 || ((h
->elf_link_hash_flags
2810 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2811 && (h
->elf_link_hash_flags
2812 & ELF_LINK_HASH_REF_REGULAR
) != 0
2813 && (h
->elf_link_hash_flags
2814 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
2816 /* If this is a function, put it in the procedure linkage table. We
2817 will fill in the contents of the procedure linkage table later,
2818 when we know the address of the .got section. */
2819 if (h
->type
== STT_FUNC
2820 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
2823 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
2824 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0)
2826 /* This case can occur if we saw a PLT32 reloc in an input
2827 file, but the symbol was never referred to by a dynamic
2828 object. In such a case, we don't actually need to build
2829 a procedure linkage table, and we can just do a PC32
2831 BFD_ASSERT ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0);
2835 /* Make sure this symbol is output as a dynamic symbol. */
2836 if (h
->dynindx
== -1)
2838 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2842 s
= bfd_get_section_by_name (dynobj
, ".plt");
2843 BFD_ASSERT (s
!= NULL
);
2845 /* If this is the first .plt entry, make room for the special
2847 if (s
->_raw_size
== 0)
2848 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2850 /* If this symbol is not defined in a regular file, and we are
2851 not generating a shared library, then set the symbol to this
2852 location in the .plt. This is required to make function
2853 pointers compare as equal between the normal executable and
2854 the shared library. */
2856 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2858 h
->root
.u
.def
.section
= s
;
2859 h
->root
.u
.def
.value
= s
->_raw_size
;
2862 h
->plt
.offset
= s
->_raw_size
;
2864 /* Make room for this entry. */
2865 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2867 /* We also need to make an entry in the .got.plt section, which
2868 will be placed in the .got section by the linker script. */
2869 s
= bfd_get_section_by_name (dynobj
, ".got.plt");
2870 BFD_ASSERT (s
!= NULL
);
2873 /* We also need to make an entry in the .rel.plt section. */
2875 s
= bfd_get_section_by_name (dynobj
, ".rel.plt");
2876 BFD_ASSERT (s
!= NULL
);
2877 s
->_raw_size
+= sizeof (Elf32_External_Rel
);
2882 /* If this is a weak symbol, and there is a real definition, the
2883 processor independent code will have arranged for us to see the
2884 real definition first, and we can just use the same value. */
2885 if (h
->weakdef
!= NULL
)
2887 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
2888 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
2889 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
2890 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
2894 /* This is a reference to a symbol defined by a dynamic object which
2895 is not a function. */
2897 /* If we are creating a shared library, we must presume that the
2898 only references to the symbol are via the global offset table.
2899 For such cases we need not do anything here; the relocations will
2900 be handled correctly by relocate_section. */
2904 /* We must allocate the symbol in our .dynbss section, which will
2905 become part of the .bss section of the executable. There will be
2906 an entry for this symbol in the .dynsym section. The dynamic
2907 object will contain position independent code, so all references
2908 from the dynamic object to this symbol will go through the global
2909 offset table. The dynamic linker will use the .dynsym entry to
2910 determine the address it must put in the global offset table, so
2911 both the dynamic object and the regular object will refer to the
2912 same memory location for the variable. */
2913 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
2914 BFD_ASSERT (s
!= NULL
);
2916 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
2917 copy the initial value out of the dynamic object and into the
2918 runtime process image. We need to remember the offset into the
2919 .rel.bss section we are going to use. */
2920 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2924 srel
= bfd_get_section_by_name (dynobj
, ".rel.bss");
2925 BFD_ASSERT (srel
!= NULL
);
2926 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
2927 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
2930 /* We need to figure out the alignment required for this symbol. I
2931 have no idea how ELF linkers handle this. */
2932 power_of_two
= bfd_log2 (h
->size
);
2933 if (power_of_two
> 3)
2936 /* Apply the required alignment. */
2937 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
2938 (bfd_size_type
) (1 << power_of_two
));
2939 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
2941 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
2945 /* Define the symbol as being at this point in the section. */
2946 h
->root
.u
.def
.section
= s
;
2947 h
->root
.u
.def
.value
= s
->_raw_size
;
2949 /* Increment the section size to make room for the symbol. */
2950 s
->_raw_size
+= h
->size
;
2955 /* Set the sizes of the dynamic sections. */
2958 elf32_arm_size_dynamic_sections (output_bfd
, info
)
2959 bfd
* output_bfd ATTRIBUTE_UNUSED
;
2960 struct bfd_link_info
* info
;
2967 dynobj
= elf_hash_table (info
)->dynobj
;
2968 BFD_ASSERT (dynobj
!= NULL
);
2970 if (elf_hash_table (info
)->dynamic_sections_created
)
2972 /* Set the contents of the .interp section to the interpreter. */
2975 s
= bfd_get_section_by_name (dynobj
, ".interp");
2976 BFD_ASSERT (s
!= NULL
);
2977 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2978 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2983 /* We may have created entries in the .rel.got section.
2984 However, if we are not creating the dynamic sections, we will
2985 not actually use these entries. Reset the size of .rel.got,
2986 which will cause it to get stripped from the output file
2988 s
= bfd_get_section_by_name (dynobj
, ".rel.got");
2993 /* If this is a -Bsymbolic shared link, then we need to discard all
2994 PC relative relocs against symbols defined in a regular object.
2995 We allocated space for them in the check_relocs routine, but we
2996 will not fill them in in the relocate_section routine. */
2997 if (info
->shared
&& info
->symbolic
)
2998 elf32_arm_link_hash_traverse (elf32_arm_hash_table (info
),
2999 elf32_arm_discard_copies
,
3002 /* The check_relocs and adjust_dynamic_symbol entry points have
3003 determined the sizes of the various dynamic sections. Allocate
3007 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3012 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3015 /* It's OK to base decisions on the section name, because none
3016 of the dynobj section names depend upon the input files. */
3017 name
= bfd_get_section_name (dynobj
, s
);
3021 if (strcmp (name
, ".plt") == 0)
3023 if (s
->_raw_size
== 0)
3025 /* Strip this section if we don't need it; see the
3031 /* Remember whether there is a PLT. */
3035 else if (strncmp (name
, ".rel", 4) == 0)
3037 if (s
->_raw_size
== 0)
3039 /* If we don't need this section, strip it from the
3040 output file. This is mostly to handle .rel.bss and
3041 .rel.plt. We must create both sections in
3042 create_dynamic_sections, because they must be created
3043 before the linker maps input sections to output
3044 sections. The linker does that before
3045 adjust_dynamic_symbol is called, and it is that
3046 function which decides whether anything needs to go
3047 into these sections. */
3052 /* Remember whether there are any reloc sections other
3054 if (strcmp (name
, ".rel.plt") != 0)
3057 /* We use the reloc_count field as a counter if we need
3058 to copy relocs into the output file. */
3062 else if (strncmp (name
, ".got", 4) != 0)
3064 /* It's not one of our sections, so don't allocate space. */
3072 for (spp
= &s
->output_section
->owner
->sections
;
3073 *spp
!= s
->output_section
;
3074 spp
= &(*spp
)->next
)
3076 *spp
= s
->output_section
->next
;
3077 --s
->output_section
->owner
->section_count
;
3082 /* Allocate memory for the section contents. */
3083 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
3084 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
3088 if (elf_hash_table (info
)->dynamic_sections_created
)
3090 /* Add some entries to the .dynamic section. We fill in the
3091 values later, in elf32_arm_finish_dynamic_sections, but we
3092 must add the entries now so that we get the correct size for
3093 the .dynamic section. The DT_DEBUG entry is filled in by the
3094 dynamic linker and used by the debugger. */
3097 if (! bfd_elf32_add_dynamic_entry (info
, DT_DEBUG
, 0))
3103 if ( ! bfd_elf32_add_dynamic_entry (info
, DT_PLTGOT
, 0)
3104 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
3105 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTREL
, DT_REL
)
3106 || ! bfd_elf32_add_dynamic_entry (info
, DT_JMPREL
, 0))
3112 if ( ! bfd_elf32_add_dynamic_entry (info
, DT_REL
, 0)
3113 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELSZ
, 0)
3114 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELENT
,
3115 sizeof (Elf32_External_Rel
)))
3119 if ((info
->flags
& DF_TEXTREL
) != 0)
3121 if (! bfd_elf32_add_dynamic_entry (info
, DT_TEXTREL
, 0))
3123 info
->flags
|= DF_TEXTREL
;
3130 /* This function is called via elf32_arm_link_hash_traverse if we are
3131 creating a shared object with -Bsymbolic. It discards the space
3132 allocated to copy PC relative relocs against symbols which are
3133 defined in regular objects. We allocated space for them in the
3134 check_relocs routine, but we won't fill them in in the
3135 relocate_section routine. */
3138 elf32_arm_discard_copies (h
, ignore
)
3139 struct elf32_arm_link_hash_entry
* h
;
3140 PTR ignore ATTRIBUTE_UNUSED
;
3142 struct elf32_arm_pcrel_relocs_copied
* s
;
3144 /* We only discard relocs for symbols defined in a regular object. */
3145 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3148 for (s
= h
->pcrel_relocs_copied
; s
!= NULL
; s
= s
->next
)
3149 s
->section
->_raw_size
-= s
->count
* sizeof (Elf32_External_Rel
);
3154 /* Finish up dynamic symbol handling. We set the contents of various
3155 dynamic sections here. */
3158 elf32_arm_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
3160 struct bfd_link_info
* info
;
3161 struct elf_link_hash_entry
* h
;
3162 Elf_Internal_Sym
* sym
;
3166 dynobj
= elf_hash_table (info
)->dynobj
;
3168 if (h
->plt
.offset
!= (bfd_vma
) -1)
3175 Elf_Internal_Rel rel
;
3177 /* This symbol has an entry in the procedure linkage table. Set
3180 BFD_ASSERT (h
->dynindx
!= -1);
3182 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3183 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3184 srel
= bfd_get_section_by_name (dynobj
, ".rel.plt");
3185 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
3187 /* Get the index in the procedure linkage table which
3188 corresponds to this symbol. This is the index of this symbol
3189 in all the symbols for which we are making plt entries. The
3190 first entry in the procedure linkage table is reserved. */
3191 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
3193 /* Get the offset into the .got table of the entry that
3194 corresponds to this function. Each .got entry is 4 bytes.
3195 The first three are reserved. */
3196 got_offset
= (plt_index
+ 3) * 4;
3198 /* Fill in the entry in the procedure linkage table. */
3199 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[0],
3200 splt
->contents
+ h
->plt
.offset
+ 0);
3201 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[1],
3202 splt
->contents
+ h
->plt
.offset
+ 4);
3203 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[2],
3204 splt
->contents
+ h
->plt
.offset
+ 8);
3205 bfd_put_32 (output_bfd
,
3206 (sgot
->output_section
->vma
3207 + sgot
->output_offset
3209 - splt
->output_section
->vma
3210 - splt
->output_offset
3211 - h
->plt
.offset
- 12),
3212 splt
->contents
+ h
->plt
.offset
+ 12);
3214 /* Fill in the entry in the global offset table. */
3215 bfd_put_32 (output_bfd
,
3216 (splt
->output_section
->vma
3217 + splt
->output_offset
),
3218 sgot
->contents
+ got_offset
);
3220 /* Fill in the entry in the .rel.plt section. */
3221 rel
.r_offset
= (sgot
->output_section
->vma
3222 + sgot
->output_offset
3224 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_JUMP_SLOT
);
3225 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3226 ((Elf32_External_Rel
*) srel
->contents
3229 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3231 /* Mark the symbol as undefined, rather than as defined in
3232 the .plt section. Leave the value alone. */
3233 sym
->st_shndx
= SHN_UNDEF
;
3234 /* If the symbol is weak, we do need to clear the value.
3235 Otherwise, the PLT entry would provide a definition for
3236 the symbol even if the symbol wasn't defined anywhere,
3237 and so the symbol would never be NULL. */
3238 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR_NONWEAK
)
3244 if (h
->got
.offset
!= (bfd_vma
) -1)
3248 Elf_Internal_Rel rel
;
3250 /* This symbol has an entry in the global offset table. Set it
3252 sgot
= bfd_get_section_by_name (dynobj
, ".got");
3253 srel
= bfd_get_section_by_name (dynobj
, ".rel.got");
3254 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
3256 rel
.r_offset
= (sgot
->output_section
->vma
3257 + sgot
->output_offset
3258 + (h
->got
.offset
&~ 1));
3260 /* If this is a -Bsymbolic link, and the symbol is defined
3261 locally, we just want to emit a RELATIVE reloc. The entry in
3262 the global offset table will already have been initialized in
3263 the relocate_section function. */
3265 && (info
->symbolic
|| h
->dynindx
== -1)
3266 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
3267 rel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
3270 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
3271 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_GLOB_DAT
);
3274 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3275 ((Elf32_External_Rel
*) srel
->contents
3276 + srel
->reloc_count
));
3277 ++srel
->reloc_count
;
3280 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
3283 Elf_Internal_Rel rel
;
3285 /* This symbol needs a copy reloc. Set it up. */
3286 BFD_ASSERT (h
->dynindx
!= -1
3287 && (h
->root
.type
== bfd_link_hash_defined
3288 || h
->root
.type
== bfd_link_hash_defweak
));
3290 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
3292 BFD_ASSERT (s
!= NULL
);
3294 rel
.r_offset
= (h
->root
.u
.def
.value
3295 + h
->root
.u
.def
.section
->output_section
->vma
3296 + h
->root
.u
.def
.section
->output_offset
);
3297 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_COPY
);
3298 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3299 ((Elf32_External_Rel
*) s
->contents
3304 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3305 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3306 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
3307 sym
->st_shndx
= SHN_ABS
;
3312 /* Finish up the dynamic sections. */
3315 elf32_arm_finish_dynamic_sections (output_bfd
, info
)
3317 struct bfd_link_info
* info
;
3323 dynobj
= elf_hash_table (info
)->dynobj
;
3325 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3326 BFD_ASSERT (sgot
!= NULL
);
3327 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3329 if (elf_hash_table (info
)->dynamic_sections_created
)
3332 Elf32_External_Dyn
*dyncon
, *dynconend
;
3334 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3335 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3337 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3338 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
3340 for (; dyncon
< dynconend
; dyncon
++)
3342 Elf_Internal_Dyn dyn
;
3346 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3359 s
= bfd_get_section_by_name (output_bfd
, name
);
3360 BFD_ASSERT (s
!= NULL
);
3361 dyn
.d_un
.d_ptr
= s
->vma
;
3362 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3366 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3367 BFD_ASSERT (s
!= NULL
);
3368 if (s
->_cooked_size
!= 0)
3369 dyn
.d_un
.d_val
= s
->_cooked_size
;
3371 dyn
.d_un
.d_val
= s
->_raw_size
;
3372 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3376 /* My reading of the SVR4 ABI indicates that the
3377 procedure linkage table relocs (DT_JMPREL) should be
3378 included in the overall relocs (DT_REL). This is
3379 what Solaris does. However, UnixWare can not handle
3380 that case. Therefore, we override the DT_RELSZ entry
3381 here to make it not include the JMPREL relocs. Since
3382 the linker script arranges for .rel.plt to follow all
3383 other relocation sections, we don't have to worry
3384 about changing the DT_REL entry. */
3385 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3388 if (s
->_cooked_size
!= 0)
3389 dyn
.d_un
.d_val
-= s
->_cooked_size
;
3391 dyn
.d_un
.d_val
-= s
->_raw_size
;
3393 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3398 /* Fill in the first entry in the procedure linkage table. */
3399 if (splt
->_raw_size
> 0)
3401 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[0], splt
->contents
+ 0);
3402 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[1], splt
->contents
+ 4);
3403 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[2], splt
->contents
+ 8);
3404 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[3], splt
->contents
+ 12);
3407 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3408 really seem like the right value. */
3409 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
3412 /* Fill in the first three entries in the global offset table. */
3413 if (sgot
->_raw_size
> 0)
3416 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
3418 bfd_put_32 (output_bfd
,
3419 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3421 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
3422 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
3425 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
3431 elf32_arm_post_process_headers (abfd
, link_info
)
3433 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
;
3435 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
3437 i_ehdrp
= elf_elfheader (abfd
);
3439 i_ehdrp
->e_ident
[EI_OSABI
] = ARM_ELF_OS_ABI_VERSION
;
3440 i_ehdrp
->e_ident
[EI_ABIVERSION
] = ARM_ELF_ABI_VERSION
;
3443 static enum elf_reloc_type_class
3444 elf32_arm_reloc_type_class (type
)
3449 case R_ARM_RELATIVE
:
3450 return reloc_class_relative
;
3451 case R_ARM_JUMP_SLOT
:
3452 return reloc_class_plt
;
3454 return reloc_class_copy
;
3456 return reloc_class_normal
;
3461 #define ELF_ARCH bfd_arch_arm
3462 #define ELF_MACHINE_CODE EM_ARM
3463 #define ELF_MAXPAGESIZE 0x8000
3465 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
3466 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
3467 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
3468 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
3469 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
3470 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
3471 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
3473 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
3474 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
3475 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
3476 #define elf_backend_check_relocs elf32_arm_check_relocs
3477 #define elf_backend_relocate_section elf32_arm_relocate_section
3478 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
3479 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
3480 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
3481 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
3482 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
3483 #define elf_backend_post_process_headers elf32_arm_post_process_headers
3484 #define elf_backend_reloc_type_class elf32_arm_reloc_type_class
3486 #define elf_backend_can_gc_sections 1
3487 #define elf_backend_plt_readonly 1
3488 #define elf_backend_want_got_plt 1
3489 #define elf_backend_want_plt_sym 0
3491 #define elf_backend_got_header_size 12
3492 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
3494 #include "elf32-target.h"