1 /* 32-bit ELF support for ARM
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003 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. */
24 typedef unsigned long int insn32
;
25 typedef unsigned short int insn16
;
27 static bfd_boolean elf32_arm_set_private_flags
28 PARAMS ((bfd
*, flagword
));
29 static bfd_boolean elf32_arm_copy_private_bfd_data
30 PARAMS ((bfd
*, bfd
*));
31 static bfd_boolean elf32_arm_merge_private_bfd_data
32 PARAMS ((bfd
*, bfd
*));
33 static bfd_boolean elf32_arm_print_private_bfd_data
34 PARAMS ((bfd
*, PTR
));
35 static int elf32_arm_get_symbol_type
36 PARAMS (( Elf_Internal_Sym
*, int));
37 static struct bfd_link_hash_table
*elf32_arm_link_hash_table_create
39 static bfd_reloc_status_type elf32_arm_final_link_relocate
40 PARAMS ((reloc_howto_type
*, bfd
*, bfd
*, asection
*, bfd_byte
*,
41 Elf_Internal_Rela
*, bfd_vma
, struct bfd_link_info
*, asection
*,
42 const char *, int, struct elf_link_hash_entry
*));
43 static insn32 insert_thumb_branch
44 PARAMS ((insn32
, int));
45 static struct elf_link_hash_entry
*find_thumb_glue
46 PARAMS ((struct bfd_link_info
*, const char *, bfd
*));
47 static struct elf_link_hash_entry
*find_arm_glue
48 PARAMS ((struct bfd_link_info
*, const char *, bfd
*));
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 bfd_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 ((asection
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
62 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
63 static bfd_boolean elf32_arm_gc_sweep_hook
64 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
65 const Elf_Internal_Rela
*));
66 static bfd_boolean elf32_arm_check_relocs
67 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
68 const Elf_Internal_Rela
*));
69 static bfd_boolean elf32_arm_find_nearest_line
70 PARAMS ((bfd
*, asection
*, asymbol
**, bfd_vma
, const char **,
71 const char **, unsigned int *));
72 static bfd_boolean elf32_arm_adjust_dynamic_symbol
73 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
74 static bfd_boolean elf32_arm_size_dynamic_sections
75 PARAMS ((bfd
*, struct bfd_link_info
*));
76 static bfd_boolean elf32_arm_finish_dynamic_symbol
77 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
79 static bfd_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
));
87 static bfd_boolean allocate_dynrelocs
88 PARAMS ((struct elf_link_hash_entry
*h
, PTR inf
));
89 static bfd_boolean create_got_section
90 PARAMS ((bfd
* dynobj
, struct bfd_link_info
* info
));
91 static bfd_boolean elf32_arm_create_dynamic_sections
92 PARAMS ((bfd
* dynobj
, struct bfd_link_info
* info
));
93 static enum elf_reloc_type_class elf32_arm_reloc_type_class
94 PARAMS ((const Elf_Internal_Rela
*));
95 static bfd_boolean elf32_arm_object_p
98 #ifndef ELFARM_NABI_C_INCLUDED
99 static void record_arm_to_thumb_glue
100 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
101 static void record_thumb_to_arm_glue
102 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
103 bfd_boolean bfd_elf32_arm_allocate_interworking_sections
104 PARAMS ((struct bfd_link_info
*));
105 bfd_boolean bfd_elf32_arm_get_bfd_for_interworking
106 PARAMS ((bfd
*, struct bfd_link_info
*));
107 bfd_boolean bfd_elf32_arm_process_before_allocation
108 PARAMS ((bfd
*, struct bfd_link_info
*, int));
112 #define INTERWORK_FLAG(abfd) (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK)
114 /* The linker script knows the section names for placement.
115 The entry_names are used to do simple name mangling on the stubs.
116 Given a function name, and its type, the stub can be found. The
117 name can be changed. The only requirement is the %s be present. */
118 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
119 #define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
121 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
122 #define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
124 /* The name of the dynamic interpreter. This is put in the .interp
126 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
130 /* The size in bytes of the special first entry in the procedure
132 #define PLT_HEADER_SIZE 16
134 /* The size in bytes of an entry in the procedure linkage table. */
135 #define PLT_ENTRY_SIZE 16
137 /* The first entry in a procedure linkage table looks like
138 this. It is set up so that any shared library function that is
139 called before the relocation has been set up calls the dynamic
141 static const bfd_vma elf32_arm_plt0_entry
[PLT_HEADER_SIZE
/ 4] =
143 0xe52de004, /* str lr, [sp, #-4]! */
144 0xe59fe010, /* ldr lr, [pc, #16] */
145 0xe08fe00e, /* add lr, pc, lr */
146 0xe5bef008, /* ldr pc, [lr, #8]! */
149 /* Subsequent entries in a procedure linkage table look like
151 static const bfd_vma elf32_arm_plt_entry
[PLT_ENTRY_SIZE
/ 4] =
153 0xe28fc600, /* add ip, pc, #NN */
154 0xe28cca00, /* add ip, ip, #NN */
155 0xe5bcf000, /* ldr pc, [ip, #NN]! */
156 0x00000000, /* unused */
161 /* The size in bytes of the special first entry in the procedure
163 #define PLT_HEADER_SIZE 20
165 /* The size in bytes of an entry in the procedure linkage table. */
166 #define PLT_ENTRY_SIZE 12
168 /* The first entry in a procedure linkage table looks like
169 this. It is set up so that any shared library function that is
170 called before the relocation has been set up calls the dynamic
172 static const bfd_vma elf32_arm_plt0_entry
[PLT_HEADER_SIZE
/ 4] =
174 0xe52de004, /* str lr, [sp, #-4]! */
175 0xe59fe004, /* ldr lr, [pc, #4] */
176 0xe08fe00e, /* add lr, pc, lr */
177 0xe5bef008, /* ldr pc, [lr, #8]! */
178 0x00000000, /* &GOT[0] - . */
181 /* Subsequent entries in a procedure linkage table look like
183 static const bfd_vma elf32_arm_plt_entry
[PLT_ENTRY_SIZE
/ 4] =
185 0xe28fc600, /* add ip, pc, #0xNN00000 */
186 0xe28cca00, /* add ip, ip, #0xNN000 */
187 0xe5bcf000, /* ldr pc, [ip, #0xNNN]! */
192 /* The ARM linker needs to keep track of the number of relocs that it
193 decides to copy in check_relocs for each symbol. This is so that
194 it can discard PC relative relocs if it doesn't need them when
195 linking with -Bsymbolic. We store the information in a field
196 extending the regular ELF linker hash table. */
198 /* This structure keeps track of the number of PC relative relocs we
199 have copied for a given symbol. */
200 struct elf32_arm_relocs_copied
203 struct elf32_arm_relocs_copied
* next
;
204 /* A section in dynobj. */
206 /* Number of relocs copied in this section. */
210 /* Arm ELF linker hash entry. */
211 struct elf32_arm_link_hash_entry
213 struct elf_link_hash_entry root
;
215 /* Number of PC relative relocs copied for this symbol. */
216 struct elf32_arm_relocs_copied
* relocs_copied
;
219 /* Traverse an arm ELF linker hash table. */
220 #define elf32_arm_link_hash_traverse(table, func, info) \
221 (elf_link_hash_traverse \
223 (bfd_boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
226 /* Get the ARM elf linker hash table from a link_info structure. */
227 #define elf32_arm_hash_table(info) \
228 ((struct elf32_arm_link_hash_table *) ((info)->hash))
230 /* ARM ELF linker hash table. */
231 struct elf32_arm_link_hash_table
233 /* The main hash table. */
234 struct elf_link_hash_table root
;
236 /* The size in bytes of the section containing the Thumb-to-ARM glue. */
237 bfd_size_type thumb_glue_size
;
239 /* The size in bytes of the section containing the ARM-to-Thumb glue. */
240 bfd_size_type arm_glue_size
;
242 /* An arbitrary input BFD chosen to hold the glue sections. */
243 bfd
* bfd_of_glue_owner
;
245 /* A boolean indicating whether knowledge of the ARM's pipeline
246 length should be applied by the linker. */
247 int no_pipeline_knowledge
;
249 /* Short-cuts to get to dynamic linker sections. */
258 /* Small local sym to section mapping cache. */
259 struct sym_sec_cache sym_sec
;
262 /* Create an entry in an ARM ELF linker hash table. */
264 static struct bfd_hash_entry
*
265 elf32_arm_link_hash_newfunc (entry
, table
, string
)
266 struct bfd_hash_entry
* entry
;
267 struct bfd_hash_table
* table
;
270 struct elf32_arm_link_hash_entry
* ret
=
271 (struct elf32_arm_link_hash_entry
*) entry
;
273 /* Allocate the structure if it has not already been allocated by a
275 if (ret
== (struct elf32_arm_link_hash_entry
*) NULL
)
276 ret
= ((struct elf32_arm_link_hash_entry
*)
277 bfd_hash_allocate (table
,
278 sizeof (struct elf32_arm_link_hash_entry
)));
279 if (ret
== (struct elf32_arm_link_hash_entry
*) NULL
)
280 return (struct bfd_hash_entry
*) ret
;
282 /* Call the allocation method of the superclass. */
283 ret
= ((struct elf32_arm_link_hash_entry
*)
284 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
286 if (ret
!= (struct elf32_arm_link_hash_entry
*) NULL
)
287 ret
->relocs_copied
= NULL
;
289 return (struct bfd_hash_entry
*) ret
;
292 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
293 shortcuts to them in our hash table. */
296 create_got_section (dynobj
, info
)
298 struct bfd_link_info
*info
;
300 struct elf32_arm_link_hash_table
*htab
;
302 if (! _bfd_elf_create_got_section (dynobj
, info
))
305 htab
= elf32_arm_hash_table (info
);
306 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
307 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
308 if (!htab
->sgot
|| !htab
->sgotplt
)
311 htab
->srelgot
= bfd_make_section (dynobj
, ".rel.got");
312 if (htab
->srelgot
== NULL
313 || ! bfd_set_section_flags (dynobj
, htab
->srelgot
,
314 (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
315 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
317 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 2))
322 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
323 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
327 elf32_arm_create_dynamic_sections (dynobj
, info
)
329 struct bfd_link_info
*info
;
331 struct elf32_arm_link_hash_table
*htab
;
333 htab
= elf32_arm_hash_table (info
);
334 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
337 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
340 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
341 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rel.plt");
342 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
344 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rel.bss");
346 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
347 || (!info
->shared
&& !htab
->srelbss
))
353 /* Copy the extra info we tack onto an elf_link_hash_entry. */
356 elf32_arm_copy_indirect_symbol (const struct elf_backend_data
*bed
,
357 struct elf_link_hash_entry
*dir
,
358 struct elf_link_hash_entry
*ind
)
360 struct elf32_arm_link_hash_entry
*edir
, *eind
;
362 edir
= (struct elf32_arm_link_hash_entry
*) dir
;
363 eind
= (struct elf32_arm_link_hash_entry
*) ind
;
365 if (eind
->relocs_copied
!= NULL
)
367 if (edir
->relocs_copied
!= NULL
)
369 struct elf32_arm_relocs_copied
**pp
;
370 struct elf32_arm_relocs_copied
*p
;
372 if (ind
->root
.type
== bfd_link_hash_indirect
)
375 /* Add reloc counts against the weak sym to the strong sym
376 list. Merge any entries against the same section. */
377 for (pp
= &eind
->relocs_copied
; (p
= *pp
) != NULL
; )
379 struct elf32_arm_relocs_copied
*q
;
381 for (q
= edir
->relocs_copied
; q
!= NULL
; q
= q
->next
)
382 if (q
->section
== p
->section
)
384 q
->count
+= p
->count
;
391 *pp
= edir
->relocs_copied
;
394 edir
->relocs_copied
= eind
->relocs_copied
;
395 eind
->relocs_copied
= NULL
;
398 _bfd_elf_link_hash_copy_indirect (bed
, dir
, ind
);
401 /* Create an ARM elf linker hash table. */
403 static struct bfd_link_hash_table
*
404 elf32_arm_link_hash_table_create (abfd
)
407 struct elf32_arm_link_hash_table
*ret
;
408 bfd_size_type amt
= sizeof (struct elf32_arm_link_hash_table
);
410 ret
= (struct elf32_arm_link_hash_table
*) bfd_malloc (amt
);
411 if (ret
== (struct elf32_arm_link_hash_table
*) NULL
)
414 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
415 elf32_arm_link_hash_newfunc
))
428 ret
->thumb_glue_size
= 0;
429 ret
->arm_glue_size
= 0;
430 ret
->bfd_of_glue_owner
= NULL
;
431 ret
->no_pipeline_knowledge
= 0;
432 ret
->sym_sec
.abfd
= NULL
;
434 return &ret
->root
.root
;
437 /* Locate the Thumb encoded calling stub for NAME. */
439 static struct elf_link_hash_entry
*
440 find_thumb_glue (link_info
, name
, input_bfd
)
441 struct bfd_link_info
*link_info
;
446 struct elf_link_hash_entry
*hash
;
447 struct elf32_arm_link_hash_table
*hash_table
;
449 /* We need a pointer to the armelf specific hash table. */
450 hash_table
= elf32_arm_hash_table (link_info
);
452 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
453 + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1);
455 BFD_ASSERT (tmp_name
);
457 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
459 hash
= elf_link_hash_lookup
460 (&(hash_table
)->root
, tmp_name
, FALSE
, FALSE
, TRUE
);
463 /* xgettext:c-format */
464 (*_bfd_error_handler
) (_("%s: unable to find THUMB glue '%s' for `%s'"),
465 bfd_archive_filename (input_bfd
), tmp_name
, name
);
472 /* Locate the ARM encoded calling stub for NAME. */
474 static struct elf_link_hash_entry
*
475 find_arm_glue (link_info
, name
, input_bfd
)
476 struct bfd_link_info
*link_info
;
481 struct elf_link_hash_entry
*myh
;
482 struct elf32_arm_link_hash_table
*hash_table
;
484 /* We need a pointer to the elfarm specific hash table. */
485 hash_table
= elf32_arm_hash_table (link_info
);
487 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
488 + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1);
490 BFD_ASSERT (tmp_name
);
492 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
494 myh
= elf_link_hash_lookup
495 (&(hash_table
)->root
, tmp_name
, FALSE
, FALSE
, TRUE
);
498 /* xgettext:c-format */
499 (*_bfd_error_handler
) (_("%s: unable to find ARM glue '%s' for `%s'"),
500 bfd_archive_filename (input_bfd
), tmp_name
, name
);
514 .word func @ behave as if you saw a ARM_32 reloc. */
516 #define ARM2THUMB_GLUE_SIZE 12
517 static const insn32 a2t1_ldr_insn
= 0xe59fc000;
518 static const insn32 a2t2_bx_r12_insn
= 0xe12fff1c;
519 static const insn32 a2t3_func_addr_insn
= 0x00000001;
521 /* Thumb->ARM: Thumb->(non-interworking aware) ARM
525 __func_from_thumb: __func_from_thumb:
527 nop ldr r6, __func_addr
529 __func_change_to_arm: bx r6
531 __func_back_to_thumb:
537 #define THUMB2ARM_GLUE_SIZE 8
538 static const insn16 t2a1_bx_pc_insn
= 0x4778;
539 static const insn16 t2a2_noop_insn
= 0x46c0;
540 static const insn32 t2a3_b_insn
= 0xea000000;
542 #ifndef ELFARM_NABI_C_INCLUDED
544 bfd_elf32_arm_allocate_interworking_sections (info
)
545 struct bfd_link_info
* info
;
549 struct elf32_arm_link_hash_table
* globals
;
551 globals
= elf32_arm_hash_table (info
);
553 BFD_ASSERT (globals
!= NULL
);
555 if (globals
->arm_glue_size
!= 0)
557 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
559 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
560 ARM2THUMB_GLUE_SECTION_NAME
);
562 BFD_ASSERT (s
!= NULL
);
564 foo
= (bfd_byte
*) bfd_alloc (globals
->bfd_of_glue_owner
,
565 globals
->arm_glue_size
);
567 s
->_raw_size
= s
->_cooked_size
= globals
->arm_glue_size
;
571 if (globals
->thumb_glue_size
!= 0)
573 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
575 s
= bfd_get_section_by_name
576 (globals
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
578 BFD_ASSERT (s
!= NULL
);
580 foo
= (bfd_byte
*) bfd_alloc (globals
->bfd_of_glue_owner
,
581 globals
->thumb_glue_size
);
583 s
->_raw_size
= s
->_cooked_size
= globals
->thumb_glue_size
;
591 record_arm_to_thumb_glue (link_info
, h
)
592 struct bfd_link_info
* link_info
;
593 struct elf_link_hash_entry
* h
;
595 const char * name
= h
->root
.root
.string
;
598 struct elf_link_hash_entry
* myh
;
599 struct bfd_link_hash_entry
* bh
;
600 struct elf32_arm_link_hash_table
* globals
;
603 globals
= elf32_arm_hash_table (link_info
);
605 BFD_ASSERT (globals
!= NULL
);
606 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
608 s
= bfd_get_section_by_name
609 (globals
->bfd_of_glue_owner
, ARM2THUMB_GLUE_SECTION_NAME
);
611 BFD_ASSERT (s
!= NULL
);
613 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
614 + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1);
616 BFD_ASSERT (tmp_name
);
618 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
620 myh
= elf_link_hash_lookup
621 (&(globals
)->root
, tmp_name
, FALSE
, FALSE
, TRUE
);
625 /* We've already seen this guy. */
630 /* The only trick here is using hash_table->arm_glue_size as the value. Even
631 though the section isn't allocated yet, this is where we will be putting
634 val
= globals
->arm_glue_size
+ 1;
635 _bfd_generic_link_add_one_symbol (link_info
, globals
->bfd_of_glue_owner
,
636 tmp_name
, BSF_GLOBAL
, s
, val
,
637 NULL
, TRUE
, FALSE
, &bh
);
641 globals
->arm_glue_size
+= ARM2THUMB_GLUE_SIZE
;
647 record_thumb_to_arm_glue (link_info
, h
)
648 struct bfd_link_info
*link_info
;
649 struct elf_link_hash_entry
*h
;
651 const char *name
= h
->root
.root
.string
;
654 struct elf_link_hash_entry
*myh
;
655 struct bfd_link_hash_entry
*bh
;
656 struct elf32_arm_link_hash_table
*hash_table
;
660 hash_table
= elf32_arm_hash_table (link_info
);
662 BFD_ASSERT (hash_table
!= NULL
);
663 BFD_ASSERT (hash_table
->bfd_of_glue_owner
!= NULL
);
665 s
= bfd_get_section_by_name
666 (hash_table
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
668 BFD_ASSERT (s
!= NULL
);
670 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
671 + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1);
673 BFD_ASSERT (tmp_name
);
675 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
677 myh
= elf_link_hash_lookup
678 (&(hash_table
)->root
, tmp_name
, FALSE
, FALSE
, TRUE
);
682 /* We've already seen this guy. */
688 val
= hash_table
->thumb_glue_size
+ 1;
689 _bfd_generic_link_add_one_symbol (link_info
, hash_table
->bfd_of_glue_owner
,
690 tmp_name
, BSF_GLOBAL
, s
, val
,
691 NULL
, TRUE
, FALSE
, &bh
);
693 /* If we mark it 'Thumb', the disassembler will do a better job. */
694 myh
= (struct elf_link_hash_entry
*) bh
;
695 bind
= ELF_ST_BIND (myh
->type
);
696 myh
->type
= ELF_ST_INFO (bind
, STT_ARM_TFUNC
);
700 #define CHANGE_TO_ARM "__%s_change_to_arm"
701 #define BACK_FROM_ARM "__%s_back_from_arm"
703 /* Allocate another symbol to mark where we switch to Arm mode. */
704 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
705 + strlen (CHANGE_TO_ARM
) + 1);
707 BFD_ASSERT (tmp_name
);
709 sprintf (tmp_name
, CHANGE_TO_ARM
, name
);
712 val
= hash_table
->thumb_glue_size
+ 4,
713 _bfd_generic_link_add_one_symbol (link_info
, hash_table
->bfd_of_glue_owner
,
714 tmp_name
, BSF_LOCAL
, s
, val
,
715 NULL
, TRUE
, FALSE
, &bh
);
719 hash_table
->thumb_glue_size
+= THUMB2ARM_GLUE_SIZE
;
724 /* Add the glue sections to ABFD. This function is called from the
725 linker scripts in ld/emultempl/{armelf}.em. */
728 bfd_elf32_arm_add_glue_sections_to_bfd (abfd
, info
)
730 struct bfd_link_info
*info
;
735 /* If we are only performing a partial
736 link do not bother adding the glue. */
737 if (info
->relocatable
)
740 sec
= bfd_get_section_by_name (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
744 /* Note: we do not include the flag SEC_LINKER_CREATED, as this
745 will prevent elf_link_input_bfd() from processing the contents
747 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_CODE
| SEC_READONLY
;
749 sec
= bfd_make_section (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
752 || !bfd_set_section_flags (abfd
, sec
, flags
)
753 || !bfd_set_section_alignment (abfd
, sec
, 2))
756 /* Set the gc mark to prevent the section from being removed by garbage
757 collection, despite the fact that no relocs refer to this section. */
761 sec
= bfd_get_section_by_name (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
765 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_CODE
| SEC_READONLY
;
767 sec
= bfd_make_section (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
770 || !bfd_set_section_flags (abfd
, sec
, flags
)
771 || !bfd_set_section_alignment (abfd
, sec
, 2))
780 /* Select a BFD to be used to hold the sections used by the glue code.
781 This function is called from the linker scripts in ld/emultempl/
785 bfd_elf32_arm_get_bfd_for_interworking (abfd
, info
)
787 struct bfd_link_info
*info
;
789 struct elf32_arm_link_hash_table
*globals
;
791 /* If we are only performing a partial link
792 do not bother getting a bfd to hold the glue. */
793 if (info
->relocatable
)
796 globals
= elf32_arm_hash_table (info
);
798 BFD_ASSERT (globals
!= NULL
);
800 if (globals
->bfd_of_glue_owner
!= NULL
)
803 /* Save the bfd for later use. */
804 globals
->bfd_of_glue_owner
= abfd
;
810 bfd_elf32_arm_process_before_allocation (abfd
, link_info
, no_pipeline_knowledge
)
812 struct bfd_link_info
*link_info
;
813 int no_pipeline_knowledge
;
815 Elf_Internal_Shdr
*symtab_hdr
;
816 Elf_Internal_Rela
*internal_relocs
= NULL
;
817 Elf_Internal_Rela
*irel
, *irelend
;
818 bfd_byte
*contents
= NULL
;
821 struct elf32_arm_link_hash_table
*globals
;
823 /* If we are only performing a partial link do not bother
824 to construct any glue. */
825 if (link_info
->relocatable
)
828 /* Here we have a bfd that is to be included on the link. We have a hook
829 to do reloc rummaging, before section sizes are nailed down. */
830 globals
= elf32_arm_hash_table (link_info
);
832 BFD_ASSERT (globals
!= NULL
);
833 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
835 globals
->no_pipeline_knowledge
= no_pipeline_knowledge
;
837 /* Rummage around all the relocs and map the glue vectors. */
838 sec
= abfd
->sections
;
843 for (; sec
!= NULL
; sec
= sec
->next
)
845 if (sec
->reloc_count
== 0)
848 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
850 /* Load the relocs. */
852 = _bfd_elf_link_read_relocs (abfd
, sec
, (PTR
) NULL
,
853 (Elf_Internal_Rela
*) NULL
, FALSE
);
855 if (internal_relocs
== NULL
)
858 irelend
= internal_relocs
+ sec
->reloc_count
;
859 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
862 unsigned long r_index
;
864 struct elf_link_hash_entry
*h
;
866 r_type
= ELF32_R_TYPE (irel
->r_info
);
867 r_index
= ELF32_R_SYM (irel
->r_info
);
869 /* These are the only relocation types we care about. */
870 if ( r_type
!= R_ARM_PC24
871 && r_type
!= R_ARM_THM_PC22
)
874 /* Get the section contents if we haven't done so already. */
875 if (contents
== NULL
)
877 /* Get cached copy if it exists. */
878 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
879 contents
= elf_section_data (sec
)->this_hdr
.contents
;
882 /* Go get them off disk. */
883 contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
884 if (contents
== NULL
)
887 if (!bfd_get_section_contents (abfd
, sec
, contents
,
888 (file_ptr
) 0, sec
->_raw_size
))
893 /* If the relocation is not against a symbol it cannot concern us. */
896 /* We don't care about local symbols. */
897 if (r_index
< symtab_hdr
->sh_info
)
900 /* This is an external symbol. */
901 r_index
-= symtab_hdr
->sh_info
;
902 h
= (struct elf_link_hash_entry
*)
903 elf_sym_hashes (abfd
)[r_index
];
905 /* If the relocation is against a static symbol it must be within
906 the current section and so cannot be a cross ARM/Thumb relocation. */
913 /* This one is a call from arm code. We need to look up
914 the target of the call. If it is a thumb target, we
916 if (ELF_ST_TYPE(h
->type
) == STT_ARM_TFUNC
)
917 record_arm_to_thumb_glue (link_info
, h
);
921 /* This one is a call from thumb code. We look
922 up the target of the call. If it is not a thumb
923 target, we insert glue. */
924 if (ELF_ST_TYPE (h
->type
) != STT_ARM_TFUNC
)
925 record_thumb_to_arm_glue (link_info
, h
);
934 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
938 if (internal_relocs
!= NULL
939 && elf_section_data (sec
)->relocs
!= internal_relocs
)
940 free (internal_relocs
);
941 internal_relocs
= NULL
;
948 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
950 if (internal_relocs
!= NULL
951 && elf_section_data (sec
)->relocs
!= internal_relocs
)
952 free (internal_relocs
);
958 /* The thumb form of a long branch is a bit finicky, because the offset
959 encoding is split over two fields, each in it's own instruction. They
960 can occur in any order. So given a thumb form of long branch, and an
961 offset, insert the offset into the thumb branch and return finished
964 It takes two thumb instructions to encode the target address. Each has
965 11 bits to invest. The upper 11 bits are stored in one (identified by
966 H-0.. see below), the lower 11 bits are stored in the other (identified
969 Combine together and shifted left by 1 (it's a half word address) and
973 H-0, upper address-0 = 000
975 H-1, lower address-0 = 800
977 They can be ordered either way, but the arm tools I've seen always put
978 the lower one first. It probably doesn't matter. krk@cygnus.com
980 XXX: Actually the order does matter. The second instruction (H-1)
981 moves the computed address into the PC, so it must be the second one
982 in the sequence. The problem, however is that whilst little endian code
983 stores the instructions in HI then LOW order, big endian code does the
984 reverse. nickc@cygnus.com. */
986 #define LOW_HI_ORDER 0xF800F000
987 #define HI_LOW_ORDER 0xF000F800
990 insert_thumb_branch (br_insn
, rel_off
)
994 unsigned int low_bits
;
995 unsigned int high_bits
;
997 BFD_ASSERT ((rel_off
& 1) != 1);
999 rel_off
>>= 1; /* Half word aligned address. */
1000 low_bits
= rel_off
& 0x000007FF; /* The bottom 11 bits. */
1001 high_bits
= (rel_off
>> 11) & 0x000007FF; /* The top 11 bits. */
1003 if ((br_insn
& LOW_HI_ORDER
) == LOW_HI_ORDER
)
1004 br_insn
= LOW_HI_ORDER
| (low_bits
<< 16) | high_bits
;
1005 else if ((br_insn
& HI_LOW_ORDER
) == HI_LOW_ORDER
)
1006 br_insn
= HI_LOW_ORDER
| (high_bits
<< 16) | low_bits
;
1008 /* FIXME: abort is probably not the right call. krk@cygnus.com */
1009 abort (); /* error - not a valid branch instruction form. */
1014 /* Thumb code calling an ARM function. */
1017 elf32_thumb_to_arm_stub (info
, name
, input_bfd
, output_bfd
, input_section
,
1018 hit_data
, sym_sec
, offset
, addend
, val
)
1019 struct bfd_link_info
* info
;
1023 asection
* input_section
;
1024 bfd_byte
* hit_data
;
1027 bfd_signed_vma addend
;
1032 unsigned long int tmp
;
1033 long int ret_offset
;
1034 struct elf_link_hash_entry
* myh
;
1035 struct elf32_arm_link_hash_table
* globals
;
1037 myh
= find_thumb_glue (info
, name
, input_bfd
);
1041 globals
= elf32_arm_hash_table (info
);
1043 BFD_ASSERT (globals
!= NULL
);
1044 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
1046 my_offset
= myh
->root
.u
.def
.value
;
1048 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
1049 THUMB2ARM_GLUE_SECTION_NAME
);
1051 BFD_ASSERT (s
!= NULL
);
1052 BFD_ASSERT (s
->contents
!= NULL
);
1053 BFD_ASSERT (s
->output_section
!= NULL
);
1055 if ((my_offset
& 0x01) == 0x01)
1058 && sym_sec
->owner
!= NULL
1059 && !INTERWORK_FLAG (sym_sec
->owner
))
1061 (*_bfd_error_handler
)
1062 (_("%s(%s): warning: interworking not enabled."),
1063 bfd_archive_filename (sym_sec
->owner
), name
);
1064 (*_bfd_error_handler
)
1065 (_(" first occurrence: %s: thumb call to arm"),
1066 bfd_archive_filename (input_bfd
));
1072 myh
->root
.u
.def
.value
= my_offset
;
1074 bfd_put_16 (output_bfd
, (bfd_vma
) t2a1_bx_pc_insn
,
1075 s
->contents
+ my_offset
);
1077 bfd_put_16 (output_bfd
, (bfd_vma
) t2a2_noop_insn
,
1078 s
->contents
+ my_offset
+ 2);
1081 /* Address of destination of the stub. */
1082 ((bfd_signed_vma
) val
)
1084 /* Offset from the start of the current section to the start of the stubs. */
1086 /* Offset of the start of this stub from the start of the stubs. */
1088 /* Address of the start of the current section. */
1089 + s
->output_section
->vma
)
1090 /* The branch instruction is 4 bytes into the stub. */
1092 /* ARM branches work from the pc of the instruction + 8. */
1095 bfd_put_32 (output_bfd
,
1096 (bfd_vma
) t2a3_b_insn
| ((ret_offset
>> 2) & 0x00FFFFFF),
1097 s
->contents
+ my_offset
+ 4);
1100 BFD_ASSERT (my_offset
<= globals
->thumb_glue_size
);
1102 /* Now go back and fix up the original BL insn to point to here. */
1104 /* Address of where the stub is located. */
1105 (s
->output_section
->vma
+ s
->output_offset
+ my_offset
)
1106 /* Address of where the BL is located. */
1107 - (input_section
->output_section
->vma
+ input_section
->output_offset
+ offset
)
1108 /* Addend in the relocation. */
1110 /* Biassing for PC-relative addressing. */
1113 tmp
= bfd_get_32 (input_bfd
, hit_data
1114 - input_section
->vma
);
1116 bfd_put_32 (output_bfd
,
1117 (bfd_vma
) insert_thumb_branch (tmp
, ret_offset
),
1118 hit_data
- input_section
->vma
);
1123 /* Arm code calling a Thumb function. */
1126 elf32_arm_to_thumb_stub (info
, name
, input_bfd
, output_bfd
, input_section
,
1127 hit_data
, sym_sec
, offset
, addend
, val
)
1128 struct bfd_link_info
* info
;
1132 asection
* input_section
;
1133 bfd_byte
* hit_data
;
1136 bfd_signed_vma addend
;
1139 unsigned long int tmp
;
1142 long int ret_offset
;
1143 struct elf_link_hash_entry
* myh
;
1144 struct elf32_arm_link_hash_table
* globals
;
1146 myh
= find_arm_glue (info
, name
, input_bfd
);
1150 globals
= elf32_arm_hash_table (info
);
1152 BFD_ASSERT (globals
!= NULL
);
1153 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
1155 my_offset
= myh
->root
.u
.def
.value
;
1156 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
1157 ARM2THUMB_GLUE_SECTION_NAME
);
1158 BFD_ASSERT (s
!= NULL
);
1159 BFD_ASSERT (s
->contents
!= NULL
);
1160 BFD_ASSERT (s
->output_section
!= NULL
);
1162 if ((my_offset
& 0x01) == 0x01)
1165 && sym_sec
->owner
!= NULL
1166 && !INTERWORK_FLAG (sym_sec
->owner
))
1168 (*_bfd_error_handler
)
1169 (_("%s(%s): warning: interworking not enabled."),
1170 bfd_archive_filename (sym_sec
->owner
), name
);
1171 (*_bfd_error_handler
)
1172 (_(" first occurrence: %s: arm call to thumb"),
1173 bfd_archive_filename (input_bfd
));
1177 myh
->root
.u
.def
.value
= my_offset
;
1179 bfd_put_32 (output_bfd
, (bfd_vma
) a2t1_ldr_insn
,
1180 s
->contents
+ my_offset
);
1182 bfd_put_32 (output_bfd
, (bfd_vma
) a2t2_bx_r12_insn
,
1183 s
->contents
+ my_offset
+ 4);
1185 /* It's a thumb address. Add the low order bit. */
1186 bfd_put_32 (output_bfd
, val
| a2t3_func_addr_insn
,
1187 s
->contents
+ my_offset
+ 8);
1190 BFD_ASSERT (my_offset
<= globals
->arm_glue_size
);
1192 tmp
= bfd_get_32 (input_bfd
, hit_data
);
1193 tmp
= tmp
& 0xFF000000;
1195 /* Somehow these are both 4 too far, so subtract 8. */
1196 ret_offset
= (s
->output_offset
1198 + s
->output_section
->vma
1199 - (input_section
->output_offset
1200 + input_section
->output_section
->vma
1204 tmp
= tmp
| ((ret_offset
>> 2) & 0x00FFFFFF);
1206 bfd_put_32 (output_bfd
, (bfd_vma
) tmp
, hit_data
- input_section
->vma
);
1211 /* This is the condition under which elf32_arm_finish_dynamic_symbol
1212 will be called from elflink.h. If elflink.h doesn't call our
1213 finish_dynamic_symbol routine, we'll need to do something about
1214 initializing any .plt and .got entries in elf32_arm_relocate_section
1215 and elf32_arm_final_link_relocate. */
1216 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, SHARED, H) \
1219 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1220 && ((H)->dynindx != -1 \
1221 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1223 /* Perform a relocation as part of a final link. */
1225 static bfd_reloc_status_type
1226 elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
1227 input_section
, contents
, rel
, value
,
1228 info
, sym_sec
, sym_name
, sym_flags
, h
)
1229 reloc_howto_type
* howto
;
1232 asection
* input_section
;
1233 bfd_byte
* contents
;
1234 Elf_Internal_Rela
* rel
;
1236 struct bfd_link_info
* info
;
1238 const char * sym_name
;
1240 struct elf_link_hash_entry
* h
;
1242 unsigned long r_type
= howto
->type
;
1243 unsigned long r_symndx
;
1244 bfd_byte
* hit_data
= contents
+ rel
->r_offset
;
1245 bfd
* dynobj
= NULL
;
1246 Elf_Internal_Shdr
* symtab_hdr
;
1247 struct elf_link_hash_entry
** sym_hashes
;
1248 bfd_vma
* local_got_offsets
;
1249 asection
* sgot
= NULL
;
1250 asection
* splt
= NULL
;
1251 asection
* sreloc
= NULL
;
1253 bfd_signed_vma signed_addend
;
1254 struct elf32_arm_link_hash_table
* globals
;
1256 /* If the start address has been set, then set the EF_ARM_HASENTRY
1257 flag. Setting this more than once is redundant, but the cost is
1258 not too high, and it keeps the code simple.
1260 The test is done here, rather than somewhere else, because the
1261 start address is only set just before the final link commences.
1263 Note - if the user deliberately sets a start address of 0, the
1264 flag will not be set. */
1265 if (bfd_get_start_address (output_bfd
) != 0)
1266 elf_elfheader (output_bfd
)->e_flags
|= EF_ARM_HASENTRY
;
1268 globals
= elf32_arm_hash_table (info
);
1270 dynobj
= elf_hash_table (info
)->dynobj
;
1273 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1274 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1276 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1277 sym_hashes
= elf_sym_hashes (input_bfd
);
1278 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1279 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1282 addend
= bfd_get_32 (input_bfd
, hit_data
) & howto
->src_mask
;
1284 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1287 signed_addend
&= ~ howto
->src_mask
;
1288 signed_addend
|= addend
;
1291 signed_addend
= addend
;
1293 addend
= signed_addend
= rel
->r_addend
;
1299 return bfd_reloc_ok
;
1308 /* r_symndx will be zero only for relocs against symbols
1309 from removed linkonce sections, or sections discarded by
1312 return bfd_reloc_ok
;
1314 /* Handle relocations which should use the PLT entry. ABS32/REL32
1315 will use the symbol's value, which may point to a PLT entry, but we
1316 don't need to handle that here. If we created a PLT entry, all
1317 branches in this object should go to it. */
1318 if ((r_type
!= R_ARM_ABS32
&& r_type
!= R_ARM_REL32
)
1320 && h
->plt
.offset
!= (bfd_vma
) -1)
1322 BFD_ASSERT (splt
!= NULL
);
1323 BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info
, h
));
1325 value
= (splt
->output_section
->vma
1326 + splt
->output_offset
1328 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1329 contents
, rel
->r_offset
, value
,
1333 /* When generating a shared object, these relocations are copied
1334 into the output file to be resolved at run time. */
1336 && (input_section
->flags
& SEC_ALLOC
)
1338 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
1339 || h
->root
.type
!= bfd_link_hash_undefweak
)
1340 && r_type
!= R_ARM_PC24
1341 && r_type
!= R_ARM_PLT32
)
1343 Elf_Internal_Rela outrel
;
1345 bfd_boolean skip
, relocate
;
1351 name
= (bfd_elf_string_from_elf_section
1353 elf_elfheader (input_bfd
)->e_shstrndx
,
1354 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1356 return bfd_reloc_notsupported
;
1358 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
1359 && strcmp (bfd_get_section_name (input_bfd
,
1363 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1364 BFD_ASSERT (sreloc
!= NULL
);
1371 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
1373 if (outrel
.r_offset
== (bfd_vma
) -1)
1375 else if (outrel
.r_offset
== (bfd_vma
) -2)
1376 skip
= TRUE
, relocate
= TRUE
;
1377 outrel
.r_offset
+= (input_section
->output_section
->vma
1378 + input_section
->output_offset
);
1381 memset (&outrel
, 0, sizeof outrel
);
1386 || (h
->elf_link_hash_flags
1387 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1388 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1391 /* This symbol is local, or marked to become local. */
1393 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1396 loc
= sreloc
->contents
;
1397 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
1398 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
1400 /* If this reloc is against an external symbol, we do not want to
1401 fiddle with the addend. Otherwise, we need to include the symbol
1402 value so that it becomes an addend for the dynamic reloc. */
1404 return bfd_reloc_ok
;
1406 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1407 contents
, rel
->r_offset
, value
,
1410 else switch (r_type
)
1413 case R_ARM_XPC25
: /* Arm BLX instruction. */
1415 case R_ARM_PC24
: /* Arm B/BL instruction */
1418 if (r_type
== R_ARM_XPC25
)
1420 /* Check for Arm calling Arm function. */
1421 /* FIXME: Should we translate the instruction into a BL
1422 instruction instead ? */
1423 if (sym_flags
!= STT_ARM_TFUNC
)
1424 (*_bfd_error_handler
) (_("\
1425 %s: Warning: Arm BLX instruction targets Arm function '%s'."),
1426 bfd_archive_filename (input_bfd
),
1427 h
? h
->root
.root
.string
: "(local)");
1432 /* Check for Arm calling Thumb function. */
1433 if (sym_flags
== STT_ARM_TFUNC
)
1435 elf32_arm_to_thumb_stub (info
, sym_name
, input_bfd
, output_bfd
,
1436 input_section
, hit_data
, sym_sec
, rel
->r_offset
,
1437 signed_addend
, value
);
1438 return bfd_reloc_ok
;
1442 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1443 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0)
1445 /* The old way of doing things. Trearing the addend as a
1446 byte sized field and adding in the pipeline offset. */
1447 value
-= (input_section
->output_section
->vma
1448 + input_section
->output_offset
);
1449 value
-= rel
->r_offset
;
1452 if (! globals
->no_pipeline_knowledge
)
1457 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
1459 S is the address of the symbol in the relocation.
1460 P is address of the instruction being relocated.
1461 A is the addend (extracted from the instruction) in bytes.
1463 S is held in 'value'.
1464 P is the base address of the section containing the instruction
1465 plus the offset of the reloc into that section, ie:
1466 (input_section->output_section->vma +
1467 input_section->output_offset +
1469 A is the addend, converted into bytes, ie:
1472 Note: None of these operations have knowledge of the pipeline
1473 size of the processor, thus it is up to the assembler to encode
1474 this information into the addend. */
1475 value
-= (input_section
->output_section
->vma
1476 + input_section
->output_offset
);
1477 value
-= rel
->r_offset
;
1478 value
+= (signed_addend
<< howto
->size
);
1480 /* Previous versions of this code also used to add in the pipeline
1481 offset here. This is wrong because the linker is not supposed
1482 to know about such things, and one day it might change. In order
1483 to support old binaries that need the old behaviour however, so
1484 we attempt to detect which ABI was used to create the reloc. */
1485 if (! globals
->no_pipeline_knowledge
)
1487 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form */
1489 i_ehdrp
= elf_elfheader (input_bfd
);
1491 if (i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1496 signed_addend
= value
;
1497 signed_addend
>>= howto
->rightshift
;
1499 /* It is not an error for an undefined weak reference to be
1500 out of range. Any program that branches to such a symbol
1501 is going to crash anyway, so there is no point worrying
1502 about getting the destination exactly right. */
1503 if (! h
|| h
->root
.type
!= bfd_link_hash_undefweak
)
1505 /* Perform a signed range check. */
1506 if ( signed_addend
> ((bfd_signed_vma
) (howto
->dst_mask
>> 1))
1507 || signed_addend
< - ((bfd_signed_vma
) ((howto
->dst_mask
+ 1) >> 1)))
1508 return bfd_reloc_overflow
;
1512 /* If necessary set the H bit in the BLX instruction. */
1513 if (r_type
== R_ARM_XPC25
&& ((value
& 2) == 2))
1514 value
= (signed_addend
& howto
->dst_mask
)
1515 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
))
1519 value
= (signed_addend
& howto
->dst_mask
)
1520 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1525 if (sym_flags
== STT_ARM_TFUNC
)
1530 value
-= (input_section
->output_section
->vma
1531 + input_section
->output_offset
+ rel
->r_offset
);
1536 bfd_put_32 (input_bfd
, value
, hit_data
);
1537 return bfd_reloc_ok
;
1541 if ((long) value
> 0x7f || (long) value
< -0x80)
1542 return bfd_reloc_overflow
;
1544 bfd_put_8 (input_bfd
, value
, hit_data
);
1545 return bfd_reloc_ok
;
1550 if ((long) value
> 0x7fff || (long) value
< -0x8000)
1551 return bfd_reloc_overflow
;
1553 bfd_put_16 (input_bfd
, value
, hit_data
);
1554 return bfd_reloc_ok
;
1557 /* Support ldr and str instruction for the arm */
1558 /* Also thumb b (unconditional branch). ??? Really? */
1561 if ((long) value
> 0x7ff || (long) value
< -0x800)
1562 return bfd_reloc_overflow
;
1564 value
|= (bfd_get_32 (input_bfd
, hit_data
) & 0xfffff000);
1565 bfd_put_32 (input_bfd
, value
, hit_data
);
1566 return bfd_reloc_ok
;
1568 case R_ARM_THM_ABS5
:
1569 /* Support ldr and str instructions for the thumb. */
1571 /* Need to refetch addend. */
1572 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1573 /* ??? Need to determine shift amount from operand size. */
1574 addend
>>= howto
->rightshift
;
1578 /* ??? Isn't value unsigned? */
1579 if ((long) value
> 0x1f || (long) value
< -0x10)
1580 return bfd_reloc_overflow
;
1582 /* ??? Value needs to be properly shifted into place first. */
1583 value
|= bfd_get_16 (input_bfd
, hit_data
) & 0xf83f;
1584 bfd_put_16 (input_bfd
, value
, hit_data
);
1585 return bfd_reloc_ok
;
1588 case R_ARM_THM_XPC22
:
1590 case R_ARM_THM_PC22
:
1591 /* Thumb BL (branch long instruction). */
1594 bfd_boolean overflow
= FALSE
;
1595 bfd_vma upper_insn
= bfd_get_16 (input_bfd
, hit_data
);
1596 bfd_vma lower_insn
= bfd_get_16 (input_bfd
, hit_data
+ 2);
1597 bfd_signed_vma reloc_signed_max
= ((1 << (howto
->bitsize
- 1)) - 1) >> howto
->rightshift
;
1598 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1600 bfd_signed_vma signed_check
;
1603 /* Need to refetch the addend and squish the two 11 bit pieces
1606 bfd_vma upper
= upper_insn
& 0x7ff;
1607 bfd_vma lower
= lower_insn
& 0x7ff;
1608 upper
= (upper
^ 0x400) - 0x400; /* Sign extend. */
1609 addend
= (upper
<< 12) | (lower
<< 1);
1610 signed_addend
= addend
;
1614 if (r_type
== R_ARM_THM_XPC22
)
1616 /* Check for Thumb to Thumb call. */
1617 /* FIXME: Should we translate the instruction into a BL
1618 instruction instead ? */
1619 if (sym_flags
== STT_ARM_TFUNC
)
1620 (*_bfd_error_handler
) (_("\
1621 %s: Warning: Thumb BLX instruction targets thumb function '%s'."),
1622 bfd_archive_filename (input_bfd
),
1623 h
? h
->root
.root
.string
: "(local)");
1628 /* If it is not a call to Thumb, assume call to Arm.
1629 If it is a call relative to a section name, then it is not a
1630 function call at all, but rather a long jump. */
1631 if (sym_flags
!= STT_ARM_TFUNC
&& sym_flags
!= STT_SECTION
)
1633 if (elf32_thumb_to_arm_stub
1634 (info
, sym_name
, input_bfd
, output_bfd
, input_section
,
1635 hit_data
, sym_sec
, rel
->r_offset
, signed_addend
, value
))
1636 return bfd_reloc_ok
;
1638 return bfd_reloc_dangerous
;
1642 relocation
= value
+ signed_addend
;
1644 relocation
-= (input_section
->output_section
->vma
1645 + input_section
->output_offset
1648 if (! globals
->no_pipeline_knowledge
)
1650 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form. */
1652 i_ehdrp
= elf_elfheader (input_bfd
);
1654 /* Previous versions of this code also used to add in the pipline
1655 offset here. This is wrong because the linker is not supposed
1656 to know about such things, and one day it might change. In order
1657 to support old binaries that need the old behaviour however, so
1658 we attempt to detect which ABI was used to create the reloc. */
1659 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1660 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0
1661 || i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1665 check
= relocation
>> howto
->rightshift
;
1667 /* If this is a signed value, the rightshift just dropped
1668 leading 1 bits (assuming twos complement). */
1669 if ((bfd_signed_vma
) relocation
>= 0)
1670 signed_check
= check
;
1672 signed_check
= check
| ~((bfd_vma
) -1 >> howto
->rightshift
);
1674 /* Assumes two's complement. */
1675 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1679 if (r_type
== R_ARM_THM_XPC22
1680 && ((lower_insn
& 0x1800) == 0x0800))
1681 /* For a BLX instruction, make sure that the relocation is rounded up
1682 to a word boundary. This follows the semantics of the instruction
1683 which specifies that bit 1 of the target address will come from bit
1684 1 of the base address. */
1685 relocation
= (relocation
+ 2) & ~ 3;
1687 /* Put RELOCATION back into the insn. */
1688 upper_insn
= (upper_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 12) & 0x7ff);
1689 lower_insn
= (lower_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 1) & 0x7ff);
1691 /* Put the relocated value back in the object file: */
1692 bfd_put_16 (input_bfd
, upper_insn
, hit_data
);
1693 bfd_put_16 (input_bfd
, lower_insn
, hit_data
+ 2);
1695 return (overflow
? bfd_reloc_overflow
: bfd_reloc_ok
);
1699 case R_ARM_THM_PC11
:
1700 /* Thumb B (branch) instruction). */
1702 bfd_signed_vma relocation
;
1703 bfd_signed_vma reloc_signed_max
= (1 << (howto
->bitsize
- 1)) - 1;
1704 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1705 bfd_signed_vma signed_check
;
1708 /* Need to refetch addend. */
1709 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1710 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1713 signed_addend
&= ~ howto
->src_mask
;
1714 signed_addend
|= addend
;
1717 signed_addend
= addend
;
1718 /* The value in the insn has been right shifted. We need to
1719 undo this, so that we can perform the address calculation
1720 in terms of bytes. */
1721 signed_addend
<<= howto
->rightshift
;
1723 relocation
= value
+ signed_addend
;
1725 relocation
-= (input_section
->output_section
->vma
1726 + input_section
->output_offset
1729 relocation
>>= howto
->rightshift
;
1730 signed_check
= relocation
;
1731 relocation
&= howto
->dst_mask
;
1732 relocation
|= (bfd_get_16 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1734 bfd_put_16 (input_bfd
, relocation
, hit_data
);
1736 /* Assumes two's complement. */
1737 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1738 return bfd_reloc_overflow
;
1740 return bfd_reloc_ok
;
1743 case R_ARM_GNU_VTINHERIT
:
1744 case R_ARM_GNU_VTENTRY
:
1745 return bfd_reloc_ok
;
1748 return bfd_reloc_notsupported
;
1750 case R_ARM_GLOB_DAT
:
1751 return bfd_reloc_notsupported
;
1753 case R_ARM_JUMP_SLOT
:
1754 return bfd_reloc_notsupported
;
1756 case R_ARM_RELATIVE
:
1757 return bfd_reloc_notsupported
;
1760 /* Relocation is relative to the start of the
1761 global offset table. */
1763 BFD_ASSERT (sgot
!= NULL
);
1765 return bfd_reloc_notsupported
;
1767 /* If we are addressing a Thumb function, we need to adjust the
1768 address by one, so that attempts to call the function pointer will
1769 correctly interpret it as Thumb code. */
1770 if (sym_flags
== STT_ARM_TFUNC
)
1773 /* Note that sgot->output_offset is not involved in this
1774 calculation. We always want the start of .got. If we
1775 define _GLOBAL_OFFSET_TABLE in a different way, as is
1776 permitted by the ABI, we might have to change this
1778 value
-= sgot
->output_section
->vma
;
1779 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1780 contents
, rel
->r_offset
, value
,
1784 /* Use global offset table as symbol value. */
1785 BFD_ASSERT (sgot
!= NULL
);
1788 return bfd_reloc_notsupported
;
1790 value
= sgot
->output_section
->vma
;
1791 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1792 contents
, rel
->r_offset
, value
,
1796 /* Relocation is to the entry for this symbol in the
1797 global offset table. */
1799 return bfd_reloc_notsupported
;
1806 off
= h
->got
.offset
;
1807 BFD_ASSERT (off
!= (bfd_vma
) -1);
1808 dyn
= globals
->root
.dynamic_sections_created
;
1810 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
1812 && SYMBOL_REFERENCES_LOCAL (info
, h
))
1813 || (ELF_ST_VISIBILITY (h
->other
)
1814 && h
->root
.type
== bfd_link_hash_undefweak
))
1816 /* This is actually a static link, or it is a -Bsymbolic link
1817 and the symbol is defined locally. We must initialize this
1818 entry in the global offset table. Since the offset must
1819 always be a multiple of 4, we use the least significant bit
1820 to record whether we have initialized it already.
1822 When doing a dynamic link, we create a .rel.got relocation
1823 entry to initialize the value. This is done in the
1824 finish_dynamic_symbol routine. */
1829 /* If we are addressing a Thumb function, we need to
1830 adjust the address by one, so that attempts to
1831 call the function pointer will correctly
1832 interpret it as Thumb code. */
1833 if (sym_flags
== STT_ARM_TFUNC
)
1836 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1841 value
= sgot
->output_offset
+ off
;
1847 BFD_ASSERT (local_got_offsets
!= NULL
&&
1848 local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1850 off
= local_got_offsets
[r_symndx
];
1852 /* The offset must always be a multiple of 4. We use the
1853 least significant bit to record whether we have already
1854 generated the necessary reloc. */
1859 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1864 Elf_Internal_Rela outrel
;
1867 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
1868 BFD_ASSERT (srelgot
!= NULL
);
1870 outrel
.r_offset
= (sgot
->output_section
->vma
1871 + sgot
->output_offset
1873 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1874 loc
= srelgot
->contents
;
1875 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rel
);
1876 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
1879 local_got_offsets
[r_symndx
] |= 1;
1882 value
= sgot
->output_offset
+ off
;
1885 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1886 contents
, rel
->r_offset
, value
,
1890 return bfd_reloc_notsupported
;
1892 case R_ARM_AMP_VCALL9
:
1893 return bfd_reloc_notsupported
;
1895 case R_ARM_RSBREL32
:
1896 return bfd_reloc_notsupported
;
1898 case R_ARM_THM_RPC22
:
1899 return bfd_reloc_notsupported
;
1902 return bfd_reloc_notsupported
;
1905 return bfd_reloc_notsupported
;
1908 return bfd_reloc_notsupported
;
1911 return bfd_reloc_notsupported
;
1914 return bfd_reloc_notsupported
;
1919 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
1921 arm_add_to_rel (abfd
, address
, howto
, increment
)
1924 reloc_howto_type
* howto
;
1925 bfd_signed_vma increment
;
1927 bfd_signed_vma addend
;
1929 if (howto
->type
== R_ARM_THM_PC22
)
1931 int upper_insn
, lower_insn
;
1934 upper_insn
= bfd_get_16 (abfd
, address
);
1935 lower_insn
= bfd_get_16 (abfd
, address
+ 2);
1936 upper
= upper_insn
& 0x7ff;
1937 lower
= lower_insn
& 0x7ff;
1939 addend
= (upper
<< 12) | (lower
<< 1);
1940 addend
+= increment
;
1943 upper_insn
= (upper_insn
& 0xf800) | ((addend
>> 11) & 0x7ff);
1944 lower_insn
= (lower_insn
& 0xf800) | (addend
& 0x7ff);
1946 bfd_put_16 (abfd
, (bfd_vma
) upper_insn
, address
);
1947 bfd_put_16 (abfd
, (bfd_vma
) lower_insn
, address
+ 2);
1953 contents
= bfd_get_32 (abfd
, address
);
1955 /* Get the (signed) value from the instruction. */
1956 addend
= contents
& howto
->src_mask
;
1957 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1959 bfd_signed_vma mask
;
1962 mask
&= ~ howto
->src_mask
;
1966 /* Add in the increment, (which is a byte value). */
1967 switch (howto
->type
)
1970 addend
+= increment
;
1974 addend
<<= howto
->size
;
1975 addend
+= increment
;
1977 /* Should we check for overflow here ? */
1979 /* Drop any undesired bits. */
1980 addend
>>= howto
->rightshift
;
1984 contents
= (contents
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
1986 bfd_put_32 (abfd
, contents
, address
);
1989 #endif /* USE_REL */
1991 /* Relocate an ARM ELF section. */
1993 elf32_arm_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1994 contents
, relocs
, local_syms
, local_sections
)
1996 struct bfd_link_info
*info
;
1998 asection
*input_section
;
2000 Elf_Internal_Rela
*relocs
;
2001 Elf_Internal_Sym
*local_syms
;
2002 asection
**local_sections
;
2004 Elf_Internal_Shdr
*symtab_hdr
;
2005 struct elf_link_hash_entry
**sym_hashes
;
2006 Elf_Internal_Rela
*rel
;
2007 Elf_Internal_Rela
*relend
;
2011 if (info
->relocatable
)
2015 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
2016 sym_hashes
= elf_sym_hashes (input_bfd
);
2019 relend
= relocs
+ input_section
->reloc_count
;
2020 for (; rel
< relend
; rel
++)
2023 reloc_howto_type
* howto
;
2024 unsigned long r_symndx
;
2025 Elf_Internal_Sym
* sym
;
2027 struct elf_link_hash_entry
* h
;
2029 bfd_reloc_status_type r
;
2032 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2033 r_type
= ELF32_R_TYPE (rel
->r_info
);
2035 if ( r_type
== R_ARM_GNU_VTENTRY
2036 || r_type
== R_ARM_GNU_VTINHERIT
)
2039 elf32_arm_info_to_howto (input_bfd
, & bfd_reloc
, rel
);
2040 howto
= bfd_reloc
.howto
;
2043 if (info
->relocatable
)
2045 /* This is a relocatable link. We don't have to change
2046 anything, unless the reloc is against a section symbol,
2047 in which case we have to adjust according to where the
2048 section symbol winds up in the output section. */
2049 if (r_symndx
< symtab_hdr
->sh_info
)
2051 sym
= local_syms
+ r_symndx
;
2052 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2054 sec
= local_sections
[r_symndx
];
2055 arm_add_to_rel (input_bfd
, contents
+ rel
->r_offset
,
2057 (bfd_signed_vma
) (sec
->output_offset
2066 /* This is a final link. */
2071 if (r_symndx
< symtab_hdr
->sh_info
)
2073 sym
= local_syms
+ r_symndx
;
2074 sec
= local_sections
[r_symndx
];
2076 relocation
= (sec
->output_section
->vma
2077 + sec
->output_offset
2079 if ((sec
->flags
& SEC_MERGE
)
2080 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2083 bfd_vma addend
, value
;
2085 if (howto
->rightshift
)
2087 (*_bfd_error_handler
)
2088 (_("%s(%s+0x%lx): %s relocation against SEC_MERGE section"),
2089 bfd_archive_filename (input_bfd
),
2090 bfd_get_section_name (input_bfd
, input_section
),
2091 (long) rel
->r_offset
, howto
->name
);
2095 value
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2097 /* Get the (signed) value from the instruction. */
2098 addend
= value
& howto
->src_mask
;
2099 if (addend
& ((howto
->src_mask
+ 1) >> 1))
2101 bfd_signed_vma mask
;
2104 mask
&= ~ howto
->src_mask
;
2109 _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
)
2111 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2112 value
= (value
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
2113 bfd_put_32 (input_bfd
, value
, contents
+ rel
->r_offset
);
2116 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2122 bfd_boolean unresolved_reloc
;
2124 RELOC_FOR_GLOBAL_SYMBOL (h
, sym_hashes
, r_symndx
,
2125 symtab_hdr
, relocation
,
2126 sec
, unresolved_reloc
, info
,
2129 if (unresolved_reloc
|| relocation
!= 0)
2131 /* In these cases, we don't need the relocation value.
2132 We check specially because in some obscure cases
2133 sec->output_section will be NULL. */
2138 case R_ARM_THM_PC22
:
2141 (!info
->symbolic
&& h
->dynindx
!= -1)
2142 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2144 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2145 && ((input_section
->flags
& SEC_ALLOC
) != 0
2146 /* DWARF will emit R_ARM_ABS32 relocations in its
2147 sections against symbols defined externally
2148 in shared libraries. We can't do anything
2150 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
2151 && (h
->elf_link_hash_flags
2152 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
2162 if ((WILL_CALL_FINISH_DYNAMIC_SYMBOL
2163 (elf_hash_table (info
)->dynamic_sections_created
,
2166 || (!info
->symbolic
&& h
->dynindx
!= -1)
2167 || (h
->elf_link_hash_flags
2168 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
2173 if (h
->plt
.offset
!= (bfd_vma
)-1)
2178 if (unresolved_reloc
)
2180 (_("%s: warning: unresolvable relocation %d against symbol `%s' from %s section"),
2181 bfd_archive_filename (input_bfd
),
2183 h
->root
.root
.string
,
2184 bfd_get_section_name (input_bfd
, input_section
));
2191 name
= h
->root
.root
.string
;
2194 name
= (bfd_elf_string_from_elf_section
2195 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2196 if (name
== NULL
|| *name
== '\0')
2197 name
= bfd_section_name (input_bfd
, sec
);
2200 r
= elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
2201 input_section
, contents
, rel
,
2202 relocation
, info
, sec
, name
,
2203 (h
? ELF_ST_TYPE (h
->type
) :
2204 ELF_ST_TYPE (sym
->st_info
)), h
);
2206 if (r
!= bfd_reloc_ok
)
2208 const char * msg
= (const char *) 0;
2212 case bfd_reloc_overflow
:
2213 /* If the overflowing reloc was to an undefined symbol,
2214 we have already printed one error message and there
2215 is no point complaining again. */
2217 h
->root
.type
!= bfd_link_hash_undefined
)
2218 && (!((*info
->callbacks
->reloc_overflow
)
2219 (info
, name
, howto
->name
, (bfd_vma
) 0,
2220 input_bfd
, input_section
, rel
->r_offset
))))
2224 case bfd_reloc_undefined
:
2225 if (!((*info
->callbacks
->undefined_symbol
)
2226 (info
, name
, input_bfd
, input_section
,
2227 rel
->r_offset
, TRUE
)))
2231 case bfd_reloc_outofrange
:
2232 msg
= _("internal error: out of range error");
2235 case bfd_reloc_notsupported
:
2236 msg
= _("internal error: unsupported relocation error");
2239 case bfd_reloc_dangerous
:
2240 msg
= _("internal error: dangerous error");
2244 msg
= _("internal error: unknown error");
2248 if (!((*info
->callbacks
->warning
)
2249 (info
, msg
, name
, input_bfd
, input_section
,
2260 /* Set the right machine number. */
2263 elf32_arm_object_p (abfd
)
2268 mach
= bfd_arm_get_mach_from_notes (abfd
, ARM_NOTE_SECTION
);
2270 if (mach
!= bfd_mach_arm_unknown
)
2271 bfd_default_set_arch_mach (abfd
, bfd_arch_arm
, mach
);
2273 else if (elf_elfheader (abfd
)->e_flags
& EF_ARM_MAVERICK_FLOAT
)
2274 bfd_default_set_arch_mach (abfd
, bfd_arch_arm
, bfd_mach_arm_ep9312
);
2277 bfd_default_set_arch_mach (abfd
, bfd_arch_arm
, mach
);
2282 /* Function to keep ARM specific flags in the ELF header. */
2284 elf32_arm_set_private_flags (abfd
, flags
)
2288 if (elf_flags_init (abfd
)
2289 && elf_elfheader (abfd
)->e_flags
!= flags
)
2291 if (EF_ARM_EABI_VERSION (flags
) == EF_ARM_EABI_UNKNOWN
)
2293 if (flags
& EF_ARM_INTERWORK
)
2294 (*_bfd_error_handler
) (_("\
2295 Warning: Not setting interworking flag of %s since it has already been specified as non-interworking"),
2296 bfd_archive_filename (abfd
));
2298 _bfd_error_handler (_("\
2299 Warning: Clearing the interworking flag of %s due to outside request"),
2300 bfd_archive_filename (abfd
));
2305 elf_elfheader (abfd
)->e_flags
= flags
;
2306 elf_flags_init (abfd
) = TRUE
;
2312 /* Copy backend specific data from one object module to another. */
2315 elf32_arm_copy_private_bfd_data (ibfd
, obfd
)
2322 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2323 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2326 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2327 out_flags
= elf_elfheader (obfd
)->e_flags
;
2329 if (elf_flags_init (obfd
)
2330 && EF_ARM_EABI_VERSION (out_flags
) == EF_ARM_EABI_UNKNOWN
2331 && in_flags
!= out_flags
)
2333 /* Cannot mix APCS26 and APCS32 code. */
2334 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2337 /* Cannot mix float APCS and non-float APCS code. */
2338 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2341 /* If the src and dest have different interworking flags
2342 then turn off the interworking bit. */
2343 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2345 if (out_flags
& EF_ARM_INTERWORK
)
2346 _bfd_error_handler (_("\
2347 Warning: Clearing the interworking flag of %s because non-interworking code in %s has been linked with it"),
2348 bfd_get_filename (obfd
),
2349 bfd_archive_filename (ibfd
));
2351 in_flags
&= ~EF_ARM_INTERWORK
;
2354 /* Likewise for PIC, though don't warn for this case. */
2355 if ((in_flags
& EF_ARM_PIC
) != (out_flags
& EF_ARM_PIC
))
2356 in_flags
&= ~EF_ARM_PIC
;
2359 elf_elfheader (obfd
)->e_flags
= in_flags
;
2360 elf_flags_init (obfd
) = TRUE
;
2365 /* Merge backend specific data from an object file to the output
2366 object file when linking. */
2369 elf32_arm_merge_private_bfd_data (ibfd
, obfd
)
2375 bfd_boolean flags_compatible
= TRUE
;
2378 /* Check if we have the same endianess. */
2379 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
2382 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2383 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2386 /* The input BFD must have had its flags initialised. */
2387 /* The following seems bogus to me -- The flags are initialized in
2388 the assembler but I don't think an elf_flags_init field is
2389 written into the object. */
2390 /* BFD_ASSERT (elf_flags_init (ibfd)); */
2392 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2393 out_flags
= elf_elfheader (obfd
)->e_flags
;
2395 if (!elf_flags_init (obfd
))
2397 /* If the input is the default architecture and had the default
2398 flags then do not bother setting the flags for the output
2399 architecture, instead allow future merges to do this. If no
2400 future merges ever set these flags then they will retain their
2401 uninitialised values, which surprise surprise, correspond
2402 to the default values. */
2403 if (bfd_get_arch_info (ibfd
)->the_default
2404 && elf_elfheader (ibfd
)->e_flags
== 0)
2407 elf_flags_init (obfd
) = TRUE
;
2408 elf_elfheader (obfd
)->e_flags
= in_flags
;
2410 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
2411 && bfd_get_arch_info (obfd
)->the_default
)
2412 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
), bfd_get_mach (ibfd
));
2417 /* Determine what should happen if the input ARM architecture
2418 does not match the output ARM architecture. */
2419 if (! bfd_arm_merge_machines (ibfd
, obfd
))
2422 /* Identical flags must be compatible. */
2423 if (in_flags
== out_flags
)
2426 /* Check to see if the input BFD actually contains any sections. If
2427 not, its flags may not have been initialised either, but it
2428 cannot actually cause any incompatibility. Do not short-circuit
2429 dynamic objects; their section list may be emptied by
2430 elf_link_add_object_symbols. */
2432 if (!(ibfd
->flags
& DYNAMIC
))
2434 bfd_boolean null_input_bfd
= TRUE
;
2436 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2438 /* Ignore synthetic glue sections. */
2439 if (strcmp (sec
->name
, ".glue_7")
2440 && strcmp (sec
->name
, ".glue_7t"))
2442 null_input_bfd
= FALSE
;
2450 /* Complain about various flag mismatches. */
2451 if (EF_ARM_EABI_VERSION (in_flags
) != EF_ARM_EABI_VERSION (out_flags
))
2453 _bfd_error_handler (_("\
2454 ERROR: %s is compiled for EABI version %d, whereas %s is compiled for version %d"),
2455 bfd_archive_filename (ibfd
),
2456 (in_flags
& EF_ARM_EABIMASK
) >> 24,
2457 bfd_get_filename (obfd
),
2458 (out_flags
& EF_ARM_EABIMASK
) >> 24);
2462 /* Not sure what needs to be checked for EABI versions >= 1. */
2463 if (EF_ARM_EABI_VERSION (in_flags
) == EF_ARM_EABI_UNKNOWN
)
2465 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2467 _bfd_error_handler (_("\
2468 ERROR: %s is compiled for APCS-%d, whereas target %s uses APCS-%d"),
2469 bfd_archive_filename (ibfd
),
2470 in_flags
& EF_ARM_APCS_26
? 26 : 32,
2471 bfd_get_filename (obfd
),
2472 out_flags
& EF_ARM_APCS_26
? 26 : 32);
2473 flags_compatible
= FALSE
;
2476 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2478 if (in_flags
& EF_ARM_APCS_FLOAT
)
2479 _bfd_error_handler (_("\
2480 ERROR: %s passes floats in float registers, whereas %s passes them in integer registers"),
2481 bfd_archive_filename (ibfd
),
2482 bfd_get_filename (obfd
));
2484 _bfd_error_handler (_("\
2485 ERROR: %s passes floats in integer registers, whereas %s passes them in float registers"),
2486 bfd_archive_filename (ibfd
),
2487 bfd_get_filename (obfd
));
2489 flags_compatible
= FALSE
;
2492 if ((in_flags
& EF_ARM_VFP_FLOAT
) != (out_flags
& EF_ARM_VFP_FLOAT
))
2494 if (in_flags
& EF_ARM_VFP_FLOAT
)
2495 _bfd_error_handler (_("\
2496 ERROR: %s uses VFP instructions, whereas %s does not"),
2497 bfd_archive_filename (ibfd
),
2498 bfd_get_filename (obfd
));
2500 _bfd_error_handler (_("\
2501 ERROR: %s uses FPA instructions, whereas %s does not"),
2502 bfd_archive_filename (ibfd
),
2503 bfd_get_filename (obfd
));
2505 flags_compatible
= FALSE
;
2508 if ((in_flags
& EF_ARM_MAVERICK_FLOAT
) != (out_flags
& EF_ARM_MAVERICK_FLOAT
))
2510 if (in_flags
& EF_ARM_MAVERICK_FLOAT
)
2511 _bfd_error_handler (_("\
2512 ERROR: %s uses Maverick instructions, whereas %s does not"),
2513 bfd_archive_filename (ibfd
),
2514 bfd_get_filename (obfd
));
2516 _bfd_error_handler (_("\
2517 ERROR: %s does not use Maverick instructions, whereas %s does"),
2518 bfd_archive_filename (ibfd
),
2519 bfd_get_filename (obfd
));
2521 flags_compatible
= FALSE
;
2524 #ifdef EF_ARM_SOFT_FLOAT
2525 if ((in_flags
& EF_ARM_SOFT_FLOAT
) != (out_flags
& EF_ARM_SOFT_FLOAT
))
2527 /* We can allow interworking between code that is VFP format
2528 layout, and uses either soft float or integer regs for
2529 passing floating point arguments and results. We already
2530 know that the APCS_FLOAT flags match; similarly for VFP
2532 if ((in_flags
& EF_ARM_APCS_FLOAT
) != 0
2533 || (in_flags
& EF_ARM_VFP_FLOAT
) == 0)
2535 if (in_flags
& EF_ARM_SOFT_FLOAT
)
2536 _bfd_error_handler (_("\
2537 ERROR: %s uses software FP, whereas %s uses hardware FP"),
2538 bfd_archive_filename (ibfd
),
2539 bfd_get_filename (obfd
));
2541 _bfd_error_handler (_("\
2542 ERROR: %s uses hardware FP, whereas %s uses software FP"),
2543 bfd_archive_filename (ibfd
),
2544 bfd_get_filename (obfd
));
2546 flags_compatible
= FALSE
;
2551 /* Interworking mismatch is only a warning. */
2552 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2554 if (in_flags
& EF_ARM_INTERWORK
)
2556 _bfd_error_handler (_("\
2557 Warning: %s supports interworking, whereas %s does not"),
2558 bfd_archive_filename (ibfd
),
2559 bfd_get_filename (obfd
));
2563 _bfd_error_handler (_("\
2564 Warning: %s does not support interworking, whereas %s does"),
2565 bfd_archive_filename (ibfd
),
2566 bfd_get_filename (obfd
));
2571 return flags_compatible
;
2574 /* Display the flags field. */
2577 elf32_arm_print_private_bfd_data (abfd
, ptr
)
2581 FILE * file
= (FILE *) ptr
;
2582 unsigned long flags
;
2584 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
2586 /* Print normal ELF private data. */
2587 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
2589 flags
= elf_elfheader (abfd
)->e_flags
;
2590 /* Ignore init flag - it may not be set, despite the flags field
2591 containing valid data. */
2593 /* xgettext:c-format */
2594 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
2596 switch (EF_ARM_EABI_VERSION (flags
))
2598 case EF_ARM_EABI_UNKNOWN
:
2599 /* The following flag bits are GNU extensions and not part of the
2600 official ARM ELF extended ABI. Hence they are only decoded if
2601 the EABI version is not set. */
2602 if (flags
& EF_ARM_INTERWORK
)
2603 fprintf (file
, _(" [interworking enabled]"));
2605 if (flags
& EF_ARM_APCS_26
)
2606 fprintf (file
, " [APCS-26]");
2608 fprintf (file
, " [APCS-32]");
2610 if (flags
& EF_ARM_VFP_FLOAT
)
2611 fprintf (file
, _(" [VFP float format]"));
2612 else if (flags
& EF_ARM_MAVERICK_FLOAT
)
2613 fprintf (file
, _(" [Maverick float format]"));
2615 fprintf (file
, _(" [FPA float format]"));
2617 if (flags
& EF_ARM_APCS_FLOAT
)
2618 fprintf (file
, _(" [floats passed in float registers]"));
2620 if (flags
& EF_ARM_PIC
)
2621 fprintf (file
, _(" [position independent]"));
2623 if (flags
& EF_ARM_NEW_ABI
)
2624 fprintf (file
, _(" [new ABI]"));
2626 if (flags
& EF_ARM_OLD_ABI
)
2627 fprintf (file
, _(" [old ABI]"));
2629 if (flags
& EF_ARM_SOFT_FLOAT
)
2630 fprintf (file
, _(" [software FP]"));
2632 flags
&= ~(EF_ARM_INTERWORK
| EF_ARM_APCS_26
| EF_ARM_APCS_FLOAT
2633 | EF_ARM_PIC
| EF_ARM_NEW_ABI
| EF_ARM_OLD_ABI
2634 | EF_ARM_SOFT_FLOAT
| EF_ARM_VFP_FLOAT
2635 | EF_ARM_MAVERICK_FLOAT
);
2638 case EF_ARM_EABI_VER1
:
2639 fprintf (file
, _(" [Version1 EABI]"));
2641 if (flags
& EF_ARM_SYMSARESORTED
)
2642 fprintf (file
, _(" [sorted symbol table]"));
2644 fprintf (file
, _(" [unsorted symbol table]"));
2646 flags
&= ~ EF_ARM_SYMSARESORTED
;
2649 case EF_ARM_EABI_VER2
:
2650 fprintf (file
, _(" [Version2 EABI]"));
2652 if (flags
& EF_ARM_SYMSARESORTED
)
2653 fprintf (file
, _(" [sorted symbol table]"));
2655 fprintf (file
, _(" [unsorted symbol table]"));
2657 if (flags
& EF_ARM_DYNSYMSUSESEGIDX
)
2658 fprintf (file
, _(" [dynamic symbols use segment index]"));
2660 if (flags
& EF_ARM_MAPSYMSFIRST
)
2661 fprintf (file
, _(" [mapping symbols precede others]"));
2663 flags
&= ~(EF_ARM_SYMSARESORTED
| EF_ARM_DYNSYMSUSESEGIDX
2664 | EF_ARM_MAPSYMSFIRST
);
2668 fprintf (file
, _(" <EABI version unrecognised>"));
2672 flags
&= ~ EF_ARM_EABIMASK
;
2674 if (flags
& EF_ARM_RELEXEC
)
2675 fprintf (file
, _(" [relocatable executable]"));
2677 if (flags
& EF_ARM_HASENTRY
)
2678 fprintf (file
, _(" [has entry point]"));
2680 flags
&= ~ (EF_ARM_RELEXEC
| EF_ARM_HASENTRY
);
2683 fprintf (file
, _("<Unrecognised flag bits set>"));
2691 elf32_arm_get_symbol_type (elf_sym
, type
)
2692 Elf_Internal_Sym
* elf_sym
;
2695 switch (ELF_ST_TYPE (elf_sym
->st_info
))
2698 return ELF_ST_TYPE (elf_sym
->st_info
);
2701 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2702 This allows us to distinguish between data used by Thumb instructions
2703 and non-data (which is probably code) inside Thumb regions of an
2705 if (type
!= STT_OBJECT
)
2706 return ELF_ST_TYPE (elf_sym
->st_info
);
2717 elf32_arm_gc_mark_hook (sec
, info
, rel
, h
, sym
)
2719 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2720 Elf_Internal_Rela
*rel
;
2721 struct elf_link_hash_entry
*h
;
2722 Elf_Internal_Sym
*sym
;
2726 switch (ELF32_R_TYPE (rel
->r_info
))
2728 case R_ARM_GNU_VTINHERIT
:
2729 case R_ARM_GNU_VTENTRY
:
2733 switch (h
->root
.type
)
2735 case bfd_link_hash_defined
:
2736 case bfd_link_hash_defweak
:
2737 return h
->root
.u
.def
.section
;
2739 case bfd_link_hash_common
:
2740 return h
->root
.u
.c
.p
->section
;
2748 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
2753 /* Update the got entry reference counts for the section being removed. */
2756 elf32_arm_gc_sweep_hook (abfd
, info
, sec
, relocs
)
2757 bfd
*abfd ATTRIBUTE_UNUSED
;
2758 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2759 asection
*sec ATTRIBUTE_UNUSED
;
2760 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
;
2762 Elf_Internal_Shdr
*symtab_hdr
;
2763 struct elf_link_hash_entry
**sym_hashes
;
2764 bfd_signed_vma
*local_got_refcounts
;
2765 const Elf_Internal_Rela
*rel
, *relend
;
2766 unsigned long r_symndx
;
2767 struct elf_link_hash_entry
*h
;
2769 elf_section_data (sec
)->local_dynrel
= NULL
;
2771 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2772 sym_hashes
= elf_sym_hashes (abfd
);
2773 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2775 relend
= relocs
+ sec
->reloc_count
;
2776 for (rel
= relocs
; rel
< relend
; rel
++)
2777 switch (ELF32_R_TYPE (rel
->r_info
))
2780 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2781 if (r_symndx
>= symtab_hdr
->sh_info
)
2783 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2784 if (h
->got
.refcount
> 0)
2785 h
->got
.refcount
-= 1;
2787 else if (local_got_refcounts
!= NULL
)
2789 if (local_got_refcounts
[r_symndx
] > 0)
2790 local_got_refcounts
[r_symndx
] -= 1;
2798 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2799 if (r_symndx
>= symtab_hdr
->sh_info
)
2801 struct elf32_arm_link_hash_entry
*eh
;
2802 struct elf32_arm_relocs_copied
**pp
;
2803 struct elf32_arm_relocs_copied
*p
;
2805 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2807 if (h
->plt
.refcount
> 0)
2808 h
->plt
.refcount
-= 1;
2810 if (ELF32_R_TYPE (rel
->r_info
) == R_ARM_ABS32
2811 || ELF32_R_TYPE (rel
->r_info
) == R_ARM_REL32
)
2813 eh
= (struct elf32_arm_link_hash_entry
*) h
;
2815 for (pp
= &eh
->relocs_copied
; (p
= *pp
) != NULL
;
2817 if (p
->section
== sec
)
2835 /* Look through the relocs for a section during the first phase. */
2838 elf32_arm_check_relocs (abfd
, info
, sec
, relocs
)
2840 struct bfd_link_info
*info
;
2842 const Elf_Internal_Rela
*relocs
;
2844 Elf_Internal_Shdr
*symtab_hdr
;
2845 struct elf_link_hash_entry
**sym_hashes
;
2846 struct elf_link_hash_entry
**sym_hashes_end
;
2847 const Elf_Internal_Rela
*rel
;
2848 const Elf_Internal_Rela
*rel_end
;
2851 bfd_vma
*local_got_offsets
;
2852 struct elf32_arm_link_hash_table
*htab
;
2854 if (info
->relocatable
)
2857 htab
= elf32_arm_hash_table (info
);
2860 dynobj
= elf_hash_table (info
)->dynobj
;
2861 local_got_offsets
= elf_local_got_offsets (abfd
);
2863 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2864 sym_hashes
= elf_sym_hashes (abfd
);
2865 sym_hashes_end
= sym_hashes
2866 + symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
2868 if (!elf_bad_symtab (abfd
))
2869 sym_hashes_end
-= symtab_hdr
->sh_info
;
2871 rel_end
= relocs
+ sec
->reloc_count
;
2872 for (rel
= relocs
; rel
< rel_end
; rel
++)
2874 struct elf_link_hash_entry
*h
;
2875 unsigned long r_symndx
;
2877 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2878 if (r_symndx
< symtab_hdr
->sh_info
)
2881 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2883 switch (ELF32_R_TYPE (rel
->r_info
))
2886 /* This symbol requires a global offset table entry. */
2893 bfd_signed_vma
*local_got_refcounts
;
2895 /* This is a global offset table entry for a local symbol. */
2896 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2897 if (local_got_refcounts
== NULL
)
2901 size
= symtab_hdr
->sh_info
;
2902 size
*= (sizeof (bfd_signed_vma
) + sizeof(char));
2903 local_got_refcounts
= ((bfd_signed_vma
*)
2904 bfd_zalloc (abfd
, size
));
2905 if (local_got_refcounts
== NULL
)
2907 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
2909 local_got_refcounts
[r_symndx
] += 1;
2915 if (htab
->sgot
== NULL
)
2917 if (htab
->root
.dynobj
== NULL
)
2918 htab
->root
.dynobj
= abfd
;
2919 if (!create_got_section (htab
->root
.dynobj
, info
))
2930 /* If this reloc is in a read-only section, we might
2931 need a copy reloc. We can't check reliably at this
2932 stage whether the section is read-only, as input
2933 sections have not yet been mapped to output sections.
2934 Tentatively set the flag for now, and correct in
2935 adjust_dynamic_symbol. */
2937 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
2939 /* We may need a .plt entry if the function this reloc
2940 refers to is in a different object. */
2941 if (ELF32_R_TYPE (rel
->r_info
) == R_ARM_PC24
2942 || ELF32_R_TYPE (rel
->r_info
) == R_ARM_PLT32
)
2943 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2945 h
->plt
.refcount
+= 1;
2948 /* If we are creating a shared library, and this is a reloc
2949 against a global symbol, or a non PC relative reloc
2950 against a local symbol, then we need to copy the reloc
2951 into the shared library. However, if we are linking with
2952 -Bsymbolic, we do not need to copy a reloc against a
2953 global symbol which is defined in an object we are
2954 including in the link (i.e., DEF_REGULAR is set). At
2955 this point we have not seen all the input files, so it is
2956 possible that DEF_REGULAR is not set now but will be set
2957 later (it is never cleared). We account for that
2958 possibility below by storing information in the
2959 relocs_copied field of the hash table entry. */
2961 && (sec
->flags
& SEC_ALLOC
) != 0
2962 && ((ELF32_R_TYPE (rel
->r_info
) != R_ARM_PC24
2963 && ELF32_R_TYPE (rel
->r_info
) != R_ARM_PLT32
)
2965 && (! info
->symbolic
2966 || (h
->elf_link_hash_flags
2967 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
2969 struct elf32_arm_relocs_copied
*p
, **head
;
2971 /* When creating a shared object, we must copy these
2972 reloc types into the output file. We create a reloc
2973 section in dynobj and make room for this reloc. */
2978 name
= (bfd_elf_string_from_elf_section
2980 elf_elfheader (abfd
)->e_shstrndx
,
2981 elf_section_data (sec
)->rel_hdr
.sh_name
));
2985 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
2986 && strcmp (bfd_get_section_name (abfd
, sec
),
2989 sreloc
= bfd_get_section_by_name (dynobj
, name
);
2994 sreloc
= bfd_make_section (dynobj
, name
);
2995 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
2996 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
2997 if ((sec
->flags
& SEC_ALLOC
) != 0)
2998 flags
|= SEC_ALLOC
| SEC_LOAD
;
3000 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
3001 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
3005 elf_section_data (sec
)->sreloc
= sreloc
;
3008 /* If this is a global symbol, we count the number of
3009 relocations we need for this symbol. */
3012 head
= &((struct elf32_arm_link_hash_entry
*) h
)->relocs_copied
;
3016 /* Track dynamic relocs needed for local syms too.
3017 We really need local syms available to do this
3021 s
= bfd_section_from_r_symndx (abfd
, &htab
->sym_sec
,
3026 head
= ((struct elf32_arm_relocs_copied
**)
3027 &elf_section_data (s
)->local_dynrel
);
3031 if (p
== NULL
|| p
->section
!= sec
)
3033 bfd_size_type amt
= sizeof *p
;
3034 p
= bfd_alloc (htab
->root
.dynobj
, amt
);
3043 if (ELF32_R_TYPE (rel
->r_info
) == R_ARM_ABS32
3044 || ELF32_R_TYPE (rel
->r_info
) == R_ARM_REL32
)
3049 /* This relocation describes the C++ object vtable hierarchy.
3050 Reconstruct it for later use during GC. */
3051 case R_ARM_GNU_VTINHERIT
:
3052 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
3056 /* This relocation describes which C++ vtable entries are actually
3057 used. Record for later use during GC. */
3058 case R_ARM_GNU_VTENTRY
:
3059 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
3068 /* Find the nearest line to a particular section and offset, for error
3069 reporting. This code is a duplicate of the code in elf.c, except
3070 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
3073 elf32_arm_find_nearest_line
3074 (abfd
, section
, symbols
, offset
, filename_ptr
, functionname_ptr
, line_ptr
)
3079 const char **filename_ptr
;
3080 const char **functionname_ptr
;
3081 unsigned int *line_ptr
;
3084 const char *filename
;
3089 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
3090 filename_ptr
, functionname_ptr
,
3092 &elf_tdata (abfd
)->dwarf2_find_line_info
))
3095 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
3096 &found
, filename_ptr
,
3097 functionname_ptr
, line_ptr
,
3098 &elf_tdata (abfd
)->line_info
))
3104 if (symbols
== NULL
)
3111 for (p
= symbols
; *p
!= NULL
; p
++)
3115 q
= (elf_symbol_type
*) *p
;
3117 if (bfd_get_section (&q
->symbol
) != section
)
3120 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
3125 filename
= bfd_asymbol_name (&q
->symbol
);
3130 if (q
->symbol
.section
== section
3131 && q
->symbol
.value
>= low_func
3132 && q
->symbol
.value
<= offset
)
3134 func
= (asymbol
*) q
;
3135 low_func
= q
->symbol
.value
;
3144 *filename_ptr
= filename
;
3145 *functionname_ptr
= bfd_asymbol_name (func
);
3151 /* Adjust a symbol defined by a dynamic object and referenced by a
3152 regular object. The current definition is in some section of the
3153 dynamic object, but we're not including those sections. We have to
3154 change the definition to something the rest of the link can
3158 elf32_arm_adjust_dynamic_symbol (info
, h
)
3159 struct bfd_link_info
* info
;
3160 struct elf_link_hash_entry
* h
;
3164 unsigned int power_of_two
;
3166 dynobj
= elf_hash_table (info
)->dynobj
;
3168 /* Make sure we know what is going on here. */
3169 BFD_ASSERT (dynobj
!= NULL
3170 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
3171 || h
->weakdef
!= NULL
3172 || ((h
->elf_link_hash_flags
3173 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
3174 && (h
->elf_link_hash_flags
3175 & ELF_LINK_HASH_REF_REGULAR
) != 0
3176 && (h
->elf_link_hash_flags
3177 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
3179 /* If this is a function, put it in the procedure linkage table. We
3180 will fill in the contents of the procedure linkage table later,
3181 when we know the address of the .got section. */
3182 if (h
->type
== STT_FUNC
3183 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
3185 if (h
->plt
.refcount
<= 0
3186 || SYMBOL_CALLS_LOCAL (info
, h
)
3187 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
3188 && h
->root
.type
== bfd_link_hash_undefweak
))
3190 /* This case can occur if we saw a PLT32 reloc in an input
3191 file, but the symbol was never referred to by a dynamic
3192 object, or if all references were garbage collected. In
3193 such a case, we don't actually need to build a procedure
3194 linkage table, and we can just do a PC24 reloc instead. */
3195 h
->plt
.offset
= (bfd_vma
) -1;
3196 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
3202 /* It's possible that we incorrectly decided a .plt reloc was
3203 needed for an R_ARM_PC24 reloc to a non-function sym in
3204 check_relocs. We can't decide accurately between function and
3205 non-function syms in check-relocs; Objects loaded later in
3206 the link may change h->type. So fix it now. */
3207 h
->plt
.offset
= (bfd_vma
) -1;
3209 /* If this is a weak symbol, and there is a real definition, the
3210 processor independent code will have arranged for us to see the
3211 real definition first, and we can just use the same value. */
3212 if (h
->weakdef
!= NULL
)
3214 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
3215 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
3216 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
3217 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
3221 /* This is a reference to a symbol defined by a dynamic object which
3222 is not a function. */
3224 /* If we are creating a shared library, we must presume that the
3225 only references to the symbol are via the global offset table.
3226 For such cases we need not do anything here; the relocations will
3227 be handled correctly by relocate_section. */
3231 /* We must allocate the symbol in our .dynbss section, which will
3232 become part of the .bss section of the executable. There will be
3233 an entry for this symbol in the .dynsym section. The dynamic
3234 object will contain position independent code, so all references
3235 from the dynamic object to this symbol will go through the global
3236 offset table. The dynamic linker will use the .dynsym entry to
3237 determine the address it must put in the global offset table, so
3238 both the dynamic object and the regular object will refer to the
3239 same memory location for the variable. */
3240 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
3241 BFD_ASSERT (s
!= NULL
);
3243 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
3244 copy the initial value out of the dynamic object and into the
3245 runtime process image. We need to remember the offset into the
3246 .rel.bss section we are going to use. */
3247 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
3251 srel
= bfd_get_section_by_name (dynobj
, ".rel.bss");
3252 BFD_ASSERT (srel
!= NULL
);
3253 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
3254 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
3257 /* We need to figure out the alignment required for this symbol. I
3258 have no idea how ELF linkers handle this. */
3259 power_of_two
= bfd_log2 (h
->size
);
3260 if (power_of_two
> 3)
3263 /* Apply the required alignment. */
3264 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
3265 (bfd_size_type
) (1 << power_of_two
));
3266 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
3268 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
3272 /* Define the symbol as being at this point in the section. */
3273 h
->root
.u
.def
.section
= s
;
3274 h
->root
.u
.def
.value
= s
->_raw_size
;
3276 /* Increment the section size to make room for the symbol. */
3277 s
->_raw_size
+= h
->size
;
3282 /* Allocate space in .plt, .got and associated reloc sections for
3286 allocate_dynrelocs (h
, inf
)
3287 struct elf_link_hash_entry
*h
;
3290 struct bfd_link_info
*info
;
3291 struct elf32_arm_link_hash_table
*htab
;
3292 struct elf32_arm_link_hash_entry
*eh
;
3293 struct elf32_arm_relocs_copied
*p
;
3295 if (h
->root
.type
== bfd_link_hash_indirect
)
3298 if (h
->root
.type
== bfd_link_hash_warning
)
3299 /* When warning symbols are created, they **replace** the "real"
3300 entry in the hash table, thus we never get to see the real
3301 symbol in a hash traversal. So look at it now. */
3302 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3304 info
= (struct bfd_link_info
*) inf
;
3305 htab
= elf32_arm_hash_table (info
);
3307 if (htab
->root
.dynamic_sections_created
3308 && h
->plt
.refcount
> 0)
3310 /* Make sure this symbol is output as a dynamic symbol.
3311 Undefined weak syms won't yet be marked as dynamic. */
3312 if (h
->dynindx
== -1
3313 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
3315 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
3320 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
3322 asection
*s
= htab
->splt
;
3324 /* If this is the first .plt entry, make room for the special
3326 if (s
->_raw_size
== 0)
3327 s
->_raw_size
+= PLT_HEADER_SIZE
;
3329 h
->plt
.offset
= s
->_raw_size
;
3331 /* If this symbol is not defined in a regular file, and we are
3332 not generating a shared library, then set the symbol to this
3333 location in the .plt. This is required to make function
3334 pointers compare as equal between the normal executable and
3335 the shared library. */
3337 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3339 h
->root
.u
.def
.section
= s
;
3340 h
->root
.u
.def
.value
= h
->plt
.offset
;
3343 /* Make room for this entry. */
3344 s
->_raw_size
+= PLT_ENTRY_SIZE
;
3346 /* We also need to make an entry in the .got.plt section, which
3347 will be placed in the .got section by the linker script. */
3348 htab
->sgotplt
->_raw_size
+= 4;
3350 /* We also need to make an entry in the .rel.plt section. */
3351 htab
->srelplt
->_raw_size
+= sizeof (Elf32_External_Rel
);
3355 h
->plt
.offset
= (bfd_vma
) -1;
3356 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
3361 h
->plt
.offset
= (bfd_vma
) -1;
3362 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
3365 if (h
->got
.refcount
> 0)
3370 /* Make sure this symbol is output as a dynamic symbol.
3371 Undefined weak syms won't yet be marked as dynamic. */
3372 if (h
->dynindx
== -1
3373 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
3375 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
3380 h
->got
.offset
= s
->_raw_size
;
3382 dyn
= htab
->root
.dynamic_sections_created
;
3383 if ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3384 || h
->root
.type
!= bfd_link_hash_undefweak
)
3386 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
3387 htab
->srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
3390 h
->got
.offset
= (bfd_vma
) -1;
3392 eh
= (struct elf32_arm_link_hash_entry
*) h
;
3393 if (eh
->relocs_copied
== NULL
)
3396 /* In the shared -Bsymbolic case, discard space allocated for
3397 dynamic pc-relative relocs against symbols which turn out to be
3398 defined in regular objects. For the normal shared case, discard
3399 space for pc-relative relocs that have become local due to symbol
3400 visibility changes. */
3404 /* Discard relocs on undefined weak syms with non-default
3406 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
3407 && h
->root
.type
== bfd_link_hash_undefweak
)
3408 eh
->relocs_copied
= NULL
;
3412 /* For the non-shared case, discard space for relocs against
3413 symbols which turn out to need copy relocs or are not
3416 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
3417 && (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
3418 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3419 || (htab
->root
.dynamic_sections_created
3420 && (h
->root
.type
== bfd_link_hash_undefweak
3421 || h
->root
.type
== bfd_link_hash_undefined
))))
3423 /* Make sure this symbol is output as a dynamic symbol.
3424 Undefined weak syms won't yet be marked as dynamic. */
3425 if (h
->dynindx
== -1
3426 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
3428 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
3432 /* If that succeeded, we know we'll be keeping all the
3434 if (h
->dynindx
!= -1)
3438 eh
->relocs_copied
= NULL
;
3443 /* Finally, allocate space. */
3444 for (p
= eh
->relocs_copied
; p
!= NULL
; p
= p
->next
)
3446 asection
*sreloc
= elf_section_data (p
->section
)->sreloc
;
3447 sreloc
->_raw_size
+= p
->count
* sizeof (Elf32_External_Rel
);
3453 /* Set the sizes of the dynamic sections. */
3456 elf32_arm_size_dynamic_sections (output_bfd
, info
)
3457 bfd
* output_bfd ATTRIBUTE_UNUSED
;
3458 struct bfd_link_info
* info
;
3465 struct elf32_arm_link_hash_table
*htab
;
3467 htab
= elf32_arm_hash_table (info
);
3468 dynobj
= elf_hash_table (info
)->dynobj
;
3469 BFD_ASSERT (dynobj
!= NULL
);
3471 if (elf_hash_table (info
)->dynamic_sections_created
)
3473 /* Set the contents of the .interp section to the interpreter. */
3474 if (info
->executable
)
3476 s
= bfd_get_section_by_name (dynobj
, ".interp");
3477 BFD_ASSERT (s
!= NULL
);
3478 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
3479 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
3483 /* Set up .got offsets for local syms, and space for local dynamic
3485 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
3487 bfd_signed_vma
*local_got
;
3488 bfd_signed_vma
*end_local_got
;
3489 char *local_tls_type
;
3490 bfd_size_type locsymcount
;
3491 Elf_Internal_Shdr
*symtab_hdr
;
3494 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
3497 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3499 struct elf32_arm_relocs_copied
*p
;
3501 for (p
= *((struct elf32_arm_relocs_copied
**)
3502 &elf_section_data (s
)->local_dynrel
);
3506 if (!bfd_is_abs_section (p
->section
)
3507 && bfd_is_abs_section (p
->section
->output_section
))
3509 /* Input section has been discarded, either because
3510 it is a copy of a linkonce section or due to
3511 linker script /DISCARD/, so we'll be discarding
3514 else if (p
->count
!= 0)
3516 srel
= elf_section_data (p
->section
)->sreloc
;
3517 srel
->_raw_size
+= p
->count
* sizeof (Elf32_External_Rel
);
3518 if ((p
->section
->output_section
->flags
& SEC_READONLY
) != 0)
3519 info
->flags
|= DF_TEXTREL
;
3524 local_got
= elf_local_got_refcounts (ibfd
);
3528 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
3529 locsymcount
= symtab_hdr
->sh_info
;
3530 end_local_got
= local_got
+ locsymcount
;
3532 srel
= htab
->srelgot
;
3533 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
3537 *local_got
= s
->_raw_size
;
3540 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
3543 *local_got
= (bfd_vma
) -1;
3547 /* Allocate global sym .plt and .got entries, and space for global
3548 sym dynamic relocs. */
3549 elf_link_hash_traverse (&htab
->root
, allocate_dynrelocs
, (PTR
) info
);
3551 /* The check_relocs and adjust_dynamic_symbol entry points have
3552 determined the sizes of the various dynamic sections. Allocate
3556 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3561 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3564 /* It's OK to base decisions on the section name, because none
3565 of the dynobj section names depend upon the input files. */
3566 name
= bfd_get_section_name (dynobj
, s
);
3570 if (strcmp (name
, ".plt") == 0)
3572 if (s
->_raw_size
== 0)
3574 /* Strip this section if we don't need it; see the
3580 /* Remember whether there is a PLT. */
3584 else if (strncmp (name
, ".rel", 4) == 0)
3586 if (s
->_raw_size
== 0)
3588 /* If we don't need this section, strip it from the
3589 output file. This is mostly to handle .rel.bss and
3590 .rel.plt. We must create both sections in
3591 create_dynamic_sections, because they must be created
3592 before the linker maps input sections to output
3593 sections. The linker does that before
3594 adjust_dynamic_symbol is called, and it is that
3595 function which decides whether anything needs to go
3596 into these sections. */
3601 /* Remember whether there are any reloc sections other
3603 if (strcmp (name
, ".rel.plt") != 0)
3606 /* We use the reloc_count field as a counter if we need
3607 to copy relocs into the output file. */
3611 else if (strncmp (name
, ".got", 4) != 0)
3613 /* It's not one of our sections, so don't allocate space. */
3619 _bfd_strip_section_from_output (info
, s
);
3623 /* Allocate memory for the section contents. */
3624 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
3625 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
3629 if (elf_hash_table (info
)->dynamic_sections_created
)
3631 /* Add some entries to the .dynamic section. We fill in the
3632 values later, in elf32_arm_finish_dynamic_sections, but we
3633 must add the entries now so that we get the correct size for
3634 the .dynamic section. The DT_DEBUG entry is filled in by the
3635 dynamic linker and used by the debugger. */
3636 #define add_dynamic_entry(TAG, VAL) \
3637 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
3641 if (!add_dynamic_entry (DT_DEBUG
, 0))
3647 if ( !add_dynamic_entry (DT_PLTGOT
, 0)
3648 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
3649 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
3650 || !add_dynamic_entry (DT_JMPREL
, 0))
3656 if ( !add_dynamic_entry (DT_REL
, 0)
3657 || !add_dynamic_entry (DT_RELSZ
, 0)
3658 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
3662 if ((info
->flags
& DF_TEXTREL
) != 0)
3664 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3666 info
->flags
|= DF_TEXTREL
;
3669 #undef add_synamic_entry
3674 /* Finish up dynamic symbol handling. We set the contents of various
3675 dynamic sections here. */
3678 elf32_arm_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
3680 struct bfd_link_info
* info
;
3681 struct elf_link_hash_entry
* h
;
3682 Elf_Internal_Sym
* sym
;
3686 dynobj
= elf_hash_table (info
)->dynobj
;
3688 if (h
->plt
.offset
!= (bfd_vma
) -1)
3695 Elf_Internal_Rela rel
;
3697 bfd_vma got_displacement
;
3699 /* This symbol has an entry in the procedure linkage table. Set
3702 BFD_ASSERT (h
->dynindx
!= -1);
3704 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3705 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3706 srel
= bfd_get_section_by_name (dynobj
, ".rel.plt");
3707 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
3709 /* Get the index in the procedure linkage table which
3710 corresponds to this symbol. This is the index of this symbol
3711 in all the symbols for which we are making plt entries. The
3712 first entry in the procedure linkage table is reserved. */
3713 plt_index
= (h
->plt
.offset
- PLT_HEADER_SIZE
) / PLT_ENTRY_SIZE
;
3715 /* Get the offset into the .got table of the entry that
3716 corresponds to this function. Each .got entry is 4 bytes.
3717 The first three are reserved. */
3718 got_offset
= (plt_index
+ 3) * 4;
3720 /* Calculate the displacement between the PLT slot and the
3721 entry in the GOT. */
3722 got_displacement
= (sgot
->output_section
->vma
3723 + sgot
->output_offset
3725 - splt
->output_section
->vma
3726 - splt
->output_offset
3730 BFD_ASSERT ((got_displacement
& 0xf0000000) == 0);
3732 /* Fill in the entry in the procedure linkage table. */
3733 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[0] | ((got_displacement
& 0x0ff00000) >> 20),
3734 splt
->contents
+ h
->plt
.offset
+ 0);
3735 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[1] | ((got_displacement
& 0x000ff000) >> 12),
3736 splt
->contents
+ h
->plt
.offset
+ 4);
3737 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[2] | (got_displacement
& 0x00000fff),
3738 splt
->contents
+ h
->plt
.offset
+ 8);
3739 #ifdef FOUR_WORD_PLT
3740 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[3],
3741 splt
->contents
+ h
->plt
.offset
+ 12);
3744 /* Fill in the entry in the global offset table. */
3745 bfd_put_32 (output_bfd
,
3746 (splt
->output_section
->vma
3747 + splt
->output_offset
),
3748 sgot
->contents
+ got_offset
);
3750 /* Fill in the entry in the .rel.plt section. */
3751 rel
.r_offset
= (sgot
->output_section
->vma
3752 + sgot
->output_offset
3754 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_JUMP_SLOT
);
3755 loc
= srel
->contents
+ plt_index
* sizeof (Elf32_External_Rel
);
3756 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3758 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3760 /* Mark the symbol as undefined, rather than as defined in
3761 the .plt section. Leave the value alone. */
3762 sym
->st_shndx
= SHN_UNDEF
;
3763 /* If the symbol is weak, we do need to clear the value.
3764 Otherwise, the PLT entry would provide a definition for
3765 the symbol even if the symbol wasn't defined anywhere,
3766 and so the symbol would never be NULL. */
3767 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR_NONWEAK
)
3773 if (h
->got
.offset
!= (bfd_vma
) -1)
3777 Elf_Internal_Rela rel
;
3780 /* This symbol has an entry in the global offset table. Set it
3782 sgot
= bfd_get_section_by_name (dynobj
, ".got");
3783 srel
= bfd_get_section_by_name (dynobj
, ".rel.got");
3784 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
3786 rel
.r_offset
= (sgot
->output_section
->vma
3787 + sgot
->output_offset
3788 + (h
->got
.offset
&~ (bfd_vma
) 1));
3790 /* If this is a static link, or it is a -Bsymbolic link and the
3791 symbol is defined locally or was forced to be local because
3792 of a version file, we just want to emit a RELATIVE reloc.
3793 The entry in the global offset table will already have been
3794 initialized in the relocate_section function. */
3796 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3798 BFD_ASSERT((h
->got
.offset
& 1) != 0);
3799 rel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
3803 BFD_ASSERT((h
->got
.offset
& 1) == 0);
3804 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
3805 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_GLOB_DAT
);
3808 loc
= srel
->contents
+ srel
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3809 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3812 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
3815 Elf_Internal_Rela rel
;
3818 /* This symbol needs a copy reloc. Set it up. */
3819 BFD_ASSERT (h
->dynindx
!= -1
3820 && (h
->root
.type
== bfd_link_hash_defined
3821 || h
->root
.type
== bfd_link_hash_defweak
));
3823 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
3825 BFD_ASSERT (s
!= NULL
);
3827 rel
.r_offset
= (h
->root
.u
.def
.value
3828 + h
->root
.u
.def
.section
->output_section
->vma
3829 + h
->root
.u
.def
.section
->output_offset
);
3830 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_COPY
);
3831 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3832 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3835 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3836 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3837 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
3838 sym
->st_shndx
= SHN_ABS
;
3843 /* Finish up the dynamic sections. */
3846 elf32_arm_finish_dynamic_sections (output_bfd
, info
)
3848 struct bfd_link_info
* info
;
3854 dynobj
= elf_hash_table (info
)->dynobj
;
3856 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3857 BFD_ASSERT (sgot
!= NULL
);
3858 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3860 if (elf_hash_table (info
)->dynamic_sections_created
)
3863 Elf32_External_Dyn
*dyncon
, *dynconend
;
3865 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3866 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3868 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3869 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
3871 for (; dyncon
< dynconend
; dyncon
++)
3873 Elf_Internal_Dyn dyn
;
3877 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3890 s
= bfd_get_section_by_name (output_bfd
, name
);
3891 BFD_ASSERT (s
!= NULL
);
3892 dyn
.d_un
.d_ptr
= s
->vma
;
3893 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3897 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3898 BFD_ASSERT (s
!= NULL
);
3899 if (s
->_cooked_size
!= 0)
3900 dyn
.d_un
.d_val
= s
->_cooked_size
;
3902 dyn
.d_un
.d_val
= s
->_raw_size
;
3903 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3907 /* My reading of the SVR4 ABI indicates that the
3908 procedure linkage table relocs (DT_JMPREL) should be
3909 included in the overall relocs (DT_REL). This is
3910 what Solaris does. However, UnixWare can not handle
3911 that case. Therefore, we override the DT_RELSZ entry
3912 here to make it not include the JMPREL relocs. Since
3913 the linker script arranges for .rel.plt to follow all
3914 other relocation sections, we don't have to worry
3915 about changing the DT_REL entry. */
3916 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3919 if (s
->_cooked_size
!= 0)
3920 dyn
.d_un
.d_val
-= s
->_cooked_size
;
3922 dyn
.d_un
.d_val
-= s
->_raw_size
;
3924 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3927 /* Set the bottom bit of DT_INIT/FINI if the
3928 corresponding function is Thumb. */
3930 name
= info
->init_function
;
3933 name
= info
->fini_function
;
3935 /* If it wasn't set by elf_bfd_final_link
3936 then there is nothing to adjust. */
3937 if (dyn
.d_un
.d_val
!= 0)
3939 struct elf_link_hash_entry
* eh
;
3941 eh
= elf_link_hash_lookup (elf_hash_table (info
), name
,
3942 FALSE
, FALSE
, TRUE
);
3943 if (eh
!= (struct elf_link_hash_entry
*) NULL
3944 && ELF_ST_TYPE (eh
->type
) == STT_ARM_TFUNC
)
3946 dyn
.d_un
.d_val
|= 1;
3947 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3954 /* Fill in the first entry in the procedure linkage table. */
3955 if (splt
->_raw_size
> 0)
3957 bfd_vma got_displacement
;
3959 /* Calculate the displacement between the PLT slot and &GOT[0]. */
3960 got_displacement
= (sgot
->output_section
->vma
3961 + sgot
->output_offset
3962 - splt
->output_section
->vma
3963 - splt
->output_offset
3966 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[0], splt
->contents
+ 0);
3967 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[1], splt
->contents
+ 4);
3968 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[2], splt
->contents
+ 8);
3969 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[3], splt
->contents
+ 12);
3970 #ifdef FOUR_WORD_PLT
3971 /* The displacement value goes in the otherwise-unused last word of
3972 the second entry. */
3973 bfd_put_32 (output_bfd
, got_displacement
, splt
->contents
+ 28);
3975 bfd_put_32 (output_bfd
, got_displacement
, splt
->contents
+ 16);
3979 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3980 really seem like the right value. */
3981 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
3984 /* Fill in the first three entries in the global offset table. */
3985 if (sgot
->_raw_size
> 0)
3988 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
3990 bfd_put_32 (output_bfd
,
3991 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3993 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
3994 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
3997 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
4003 elf32_arm_post_process_headers (abfd
, link_info
)
4005 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
;
4007 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
4009 i_ehdrp
= elf_elfheader (abfd
);
4011 i_ehdrp
->e_ident
[EI_OSABI
] = ARM_ELF_OS_ABI_VERSION
;
4012 i_ehdrp
->e_ident
[EI_ABIVERSION
] = ARM_ELF_ABI_VERSION
;
4015 static enum elf_reloc_type_class
4016 elf32_arm_reloc_type_class (rela
)
4017 const Elf_Internal_Rela
*rela
;
4019 switch ((int) ELF32_R_TYPE (rela
->r_info
))
4021 case R_ARM_RELATIVE
:
4022 return reloc_class_relative
;
4023 case R_ARM_JUMP_SLOT
:
4024 return reloc_class_plt
;
4026 return reloc_class_copy
;
4028 return reloc_class_normal
;
4032 static bfd_boolean elf32_arm_section_flags
PARAMS ((flagword
*, Elf_Internal_Shdr
*));
4033 static void elf32_arm_final_write_processing
PARAMS ((bfd
*, bfd_boolean
));
4035 /* Set the right machine number for an Arm ELF file. */
4038 elf32_arm_section_flags (flags
, hdr
)
4040 Elf_Internal_Shdr
*hdr
;
4042 if (hdr
->sh_type
== SHT_NOTE
)
4043 *flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_CONTENTS
;
4049 elf32_arm_final_write_processing (abfd
, linker
)
4051 bfd_boolean linker ATTRIBUTE_UNUSED
;
4053 bfd_arm_update_notes (abfd
, ARM_NOTE_SECTION
);
4056 #define ELF_ARCH bfd_arch_arm
4057 #define ELF_MACHINE_CODE EM_ARM
4058 #ifdef __QNXTARGET__
4059 #define ELF_MAXPAGESIZE 0x1000
4061 #define ELF_MAXPAGESIZE 0x8000
4064 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
4065 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
4066 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
4067 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
4068 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
4069 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
4070 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
4072 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
4073 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
4074 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
4075 #define elf_backend_check_relocs elf32_arm_check_relocs
4076 #define elf_backend_relocate_section elf32_arm_relocate_section
4077 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
4078 #define elf_backend_create_dynamic_sections elf32_arm_create_dynamic_sections
4079 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
4080 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
4081 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
4082 #define elf_backend_post_process_headers elf32_arm_post_process_headers
4083 #define elf_backend_reloc_type_class elf32_arm_reloc_type_class
4084 #define elf_backend_object_p elf32_arm_object_p
4085 #define elf_backend_section_flags elf32_arm_section_flags
4086 #define elf_backend_final_write_processing elf32_arm_final_write_processing
4087 #define elf_backend_copy_indirect_symbol elf32_arm_copy_indirect_symbol
4089 #define elf_backend_can_refcount 1
4090 #define elf_backend_can_gc_sections 1
4091 #define elf_backend_plt_readonly 1
4092 #define elf_backend_want_got_plt 1
4093 #define elf_backend_want_plt_sym 0
4095 #define elf_backend_rela_normal 1
4098 #define elf_backend_got_header_size 12
4100 #include "elf32-target.h"