1 /* 32-bit ELF support for ARM
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 typedef unsigned long int insn32
;
26 typedef unsigned short int insn16
;
28 static bfd_boolean elf32_arm_set_private_flags
29 PARAMS ((bfd
*, flagword
));
30 static bfd_boolean elf32_arm_copy_private_bfd_data
31 PARAMS ((bfd
*, bfd
*));
32 static bfd_boolean elf32_arm_merge_private_bfd_data
33 PARAMS ((bfd
*, bfd
*));
34 static bfd_boolean elf32_arm_print_private_bfd_data
35 PARAMS ((bfd
*, PTR
));
36 static int elf32_arm_get_symbol_type
37 PARAMS (( Elf_Internal_Sym
*, int));
38 static struct bfd_link_hash_table
*elf32_arm_link_hash_table_create
40 static bfd_reloc_status_type elf32_arm_final_link_relocate
41 PARAMS ((reloc_howto_type
*, bfd
*, bfd
*, asection
*, bfd_byte
*,
42 Elf_Internal_Rela
*, bfd_vma
, struct bfd_link_info
*, asection
*,
43 const char *, int, struct elf_link_hash_entry
*));
44 static insn32 insert_thumb_branch
45 PARAMS ((insn32
, int));
46 static struct elf_link_hash_entry
*find_thumb_glue
47 PARAMS ((struct bfd_link_info
*, const char *, bfd
*));
48 static struct elf_link_hash_entry
*find_arm_glue
49 PARAMS ((struct bfd_link_info
*, const char *, bfd
*));
50 static void elf32_arm_post_process_headers
51 PARAMS ((bfd
*, struct bfd_link_info
*));
52 static int elf32_arm_to_thumb_stub
53 PARAMS ((struct bfd_link_info
*, const char *, bfd
*, bfd
*, asection
*,
54 bfd_byte
*, asection
*, bfd_vma
, bfd_signed_vma
, bfd_vma
));
55 static int elf32_thumb_to_arm_stub
56 PARAMS ((struct bfd_link_info
*, const char *, bfd
*, bfd
*, asection
*,
57 bfd_byte
*, asection
*, bfd_vma
, bfd_signed_vma
, bfd_vma
));
58 static bfd_boolean elf32_arm_relocate_section
59 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
60 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
61 static asection
* elf32_arm_gc_mark_hook
62 PARAMS ((asection
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
63 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
64 static bfd_boolean elf32_arm_gc_sweep_hook
65 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
66 const Elf_Internal_Rela
*));
67 static bfd_boolean elf32_arm_check_relocs
68 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
69 const Elf_Internal_Rela
*));
70 static bfd_boolean elf32_arm_find_nearest_line
71 PARAMS ((bfd
*, asection
*, asymbol
**, bfd_vma
, const char **,
72 const char **, unsigned int *));
73 static bfd_boolean elf32_arm_adjust_dynamic_symbol
74 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
75 static bfd_boolean elf32_arm_size_dynamic_sections
76 PARAMS ((bfd
*, struct bfd_link_info
*));
77 static bfd_boolean elf32_arm_finish_dynamic_symbol
78 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
80 static bfd_boolean elf32_arm_finish_dynamic_sections
81 PARAMS ((bfd
*, struct bfd_link_info
*));
82 static struct bfd_hash_entry
* elf32_arm_link_hash_newfunc
83 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
85 static void arm_add_to_rel
86 PARAMS ((bfd
*, bfd_byte
*, reloc_howto_type
*, bfd_signed_vma
));
88 static bfd_boolean allocate_dynrelocs
89 PARAMS ((struct elf_link_hash_entry
*h
, PTR inf
));
90 static bfd_boolean create_got_section
91 PARAMS ((bfd
* dynobj
, struct bfd_link_info
* info
));
92 static bfd_boolean elf32_arm_create_dynamic_sections
93 PARAMS ((bfd
* dynobj
, struct bfd_link_info
* info
));
94 static enum elf_reloc_type_class elf32_arm_reloc_type_class
95 PARAMS ((const Elf_Internal_Rela
*));
96 static bfd_boolean elf32_arm_object_p
99 #ifndef ELFARM_NABI_C_INCLUDED
100 static void record_arm_to_thumb_glue
101 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
102 static void record_thumb_to_arm_glue
103 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
104 bfd_boolean bfd_elf32_arm_allocate_interworking_sections
105 PARAMS ((struct bfd_link_info
*));
106 bfd_boolean bfd_elf32_arm_get_bfd_for_interworking
107 PARAMS ((bfd
*, struct bfd_link_info
*));
108 bfd_boolean bfd_elf32_arm_process_before_allocation
109 PARAMS ((bfd
*, struct bfd_link_info
*, int, int));
113 #define INTERWORK_FLAG(abfd) (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK)
115 /* The linker script knows the section names for placement.
116 The entry_names are used to do simple name mangling on the stubs.
117 Given a function name, and its type, the stub can be found. The
118 name can be changed. The only requirement is the %s be present. */
119 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
120 #define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
122 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
123 #define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
125 /* The name of the dynamic interpreter. This is put in the .interp
127 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
131 /* The size in bytes of the special first entry in the procedure
133 #define PLT_HEADER_SIZE 16
135 /* The size in bytes of an entry in the procedure linkage table. */
136 #define PLT_ENTRY_SIZE 16
138 /* The first entry in a procedure linkage table looks like
139 this. It is set up so that any shared library function that is
140 called before the relocation has been set up calls the dynamic
142 static const bfd_vma elf32_arm_plt0_entry
[PLT_HEADER_SIZE
/ 4] =
144 0xe52de004, /* str lr, [sp, #-4]! */
145 0xe59fe010, /* ldr lr, [pc, #16] */
146 0xe08fe00e, /* add lr, pc, lr */
147 0xe5bef008, /* ldr pc, [lr, #8]! */
150 /* Subsequent entries in a procedure linkage table look like
152 static const bfd_vma elf32_arm_plt_entry
[PLT_ENTRY_SIZE
/ 4] =
154 0xe28fc600, /* add ip, pc, #NN */
155 0xe28cca00, /* add ip, ip, #NN */
156 0xe5bcf000, /* ldr pc, [ip, #NN]! */
157 0x00000000, /* unused */
162 /* The size in bytes of the special first entry in the procedure
164 #define PLT_HEADER_SIZE 20
166 /* The size in bytes of an entry in the procedure linkage table. */
167 #define PLT_ENTRY_SIZE 12
169 /* The first entry in a procedure linkage table looks like
170 this. It is set up so that any shared library function that is
171 called before the relocation has been set up calls the dynamic
173 static const bfd_vma elf32_arm_plt0_entry
[PLT_HEADER_SIZE
/ 4] =
175 0xe52de004, /* str lr, [sp, #-4]! */
176 0xe59fe004, /* ldr lr, [pc, #4] */
177 0xe08fe00e, /* add lr, pc, lr */
178 0xe5bef008, /* ldr pc, [lr, #8]! */
179 0x00000000, /* &GOT[0] - . */
182 /* Subsequent entries in a procedure linkage table look like
184 static const bfd_vma elf32_arm_plt_entry
[PLT_ENTRY_SIZE
/ 4] =
186 0xe28fc600, /* add ip, pc, #0xNN00000 */
187 0xe28cca00, /* add ip, ip, #0xNN000 */
188 0xe5bcf000, /* ldr pc, [ip, #0xNNN]! */
193 /* Used to build a map of a section. This is required for mixed-endian
196 typedef struct elf32_elf_section_map
201 elf32_arm_section_map
;
203 struct _arm_elf_section_data
205 struct bfd_elf_section_data elf
;
207 elf32_arm_section_map
*map
;
210 #define elf32_arm_section_data(sec) \
211 ((struct _arm_elf_section_data *) elf_section_data (sec))
213 /* The ARM linker needs to keep track of the number of relocs that it
214 decides to copy in check_relocs for each symbol. This is so that
215 it can discard PC relative relocs if it doesn't need them when
216 linking with -Bsymbolic. We store the information in a field
217 extending the regular ELF linker hash table. */
219 /* This structure keeps track of the number of PC relative relocs we
220 have copied for a given symbol. */
221 struct elf32_arm_relocs_copied
224 struct elf32_arm_relocs_copied
* next
;
225 /* A section in dynobj. */
227 /* Number of relocs copied in this section. */
231 /* Arm ELF linker hash entry. */
232 struct elf32_arm_link_hash_entry
234 struct elf_link_hash_entry root
;
236 /* Number of PC relative relocs copied for this symbol. */
237 struct elf32_arm_relocs_copied
* relocs_copied
;
240 /* Traverse an arm ELF linker hash table. */
241 #define elf32_arm_link_hash_traverse(table, func, info) \
242 (elf_link_hash_traverse \
244 (bfd_boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
247 /* Get the ARM elf linker hash table from a link_info structure. */
248 #define elf32_arm_hash_table(info) \
249 ((struct elf32_arm_link_hash_table *) ((info)->hash))
251 /* ARM ELF linker hash table. */
252 struct elf32_arm_link_hash_table
254 /* The main hash table. */
255 struct elf_link_hash_table root
;
257 /* The size in bytes of the section containing the Thumb-to-ARM glue. */
258 bfd_size_type thumb_glue_size
;
260 /* The size in bytes of the section containing the ARM-to-Thumb glue. */
261 bfd_size_type arm_glue_size
;
263 /* An arbitrary input BFD chosen to hold the glue sections. */
264 bfd
* bfd_of_glue_owner
;
266 /* A boolean indicating whether knowledge of the ARM's pipeline
267 length should be applied by the linker. */
268 int no_pipeline_knowledge
;
270 /* Nonzero to output a BE8 image. */
273 /* Short-cuts to get to dynamic linker sections. */
282 /* Small local sym to section mapping cache. */
283 struct sym_sec_cache sym_sec
;
286 /* Create an entry in an ARM ELF linker hash table. */
288 static struct bfd_hash_entry
*
289 elf32_arm_link_hash_newfunc (entry
, table
, string
)
290 struct bfd_hash_entry
* entry
;
291 struct bfd_hash_table
* table
;
294 struct elf32_arm_link_hash_entry
* ret
=
295 (struct elf32_arm_link_hash_entry
*) entry
;
297 /* Allocate the structure if it has not already been allocated by a
299 if (ret
== (struct elf32_arm_link_hash_entry
*) NULL
)
300 ret
= ((struct elf32_arm_link_hash_entry
*)
301 bfd_hash_allocate (table
,
302 sizeof (struct elf32_arm_link_hash_entry
)));
303 if (ret
== (struct elf32_arm_link_hash_entry
*) NULL
)
304 return (struct bfd_hash_entry
*) ret
;
306 /* Call the allocation method of the superclass. */
307 ret
= ((struct elf32_arm_link_hash_entry
*)
308 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
310 if (ret
!= (struct elf32_arm_link_hash_entry
*) NULL
)
311 ret
->relocs_copied
= NULL
;
313 return (struct bfd_hash_entry
*) ret
;
316 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
317 shortcuts to them in our hash table. */
320 create_got_section (dynobj
, info
)
322 struct bfd_link_info
*info
;
324 struct elf32_arm_link_hash_table
*htab
;
326 if (! _bfd_elf_create_got_section (dynobj
, info
))
329 htab
= elf32_arm_hash_table (info
);
330 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
331 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
332 if (!htab
->sgot
|| !htab
->sgotplt
)
335 htab
->srelgot
= bfd_make_section (dynobj
, ".rel.got");
336 if (htab
->srelgot
== NULL
337 || ! bfd_set_section_flags (dynobj
, htab
->srelgot
,
338 (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
339 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
341 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 2))
346 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
347 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
351 elf32_arm_create_dynamic_sections (dynobj
, info
)
353 struct bfd_link_info
*info
;
355 struct elf32_arm_link_hash_table
*htab
;
357 htab
= elf32_arm_hash_table (info
);
358 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
361 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
364 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
365 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rel.plt");
366 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
368 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rel.bss");
370 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
371 || (!info
->shared
&& !htab
->srelbss
))
377 /* Copy the extra info we tack onto an elf_link_hash_entry. */
380 elf32_arm_copy_indirect_symbol (const struct elf_backend_data
*bed
,
381 struct elf_link_hash_entry
*dir
,
382 struct elf_link_hash_entry
*ind
)
384 struct elf32_arm_link_hash_entry
*edir
, *eind
;
386 edir
= (struct elf32_arm_link_hash_entry
*) dir
;
387 eind
= (struct elf32_arm_link_hash_entry
*) ind
;
389 if (eind
->relocs_copied
!= NULL
)
391 if (edir
->relocs_copied
!= NULL
)
393 struct elf32_arm_relocs_copied
**pp
;
394 struct elf32_arm_relocs_copied
*p
;
396 if (ind
->root
.type
== bfd_link_hash_indirect
)
399 /* Add reloc counts against the weak sym to the strong sym
400 list. Merge any entries against the same section. */
401 for (pp
= &eind
->relocs_copied
; (p
= *pp
) != NULL
; )
403 struct elf32_arm_relocs_copied
*q
;
405 for (q
= edir
->relocs_copied
; q
!= NULL
; q
= q
->next
)
406 if (q
->section
== p
->section
)
408 q
->count
+= p
->count
;
415 *pp
= edir
->relocs_copied
;
418 edir
->relocs_copied
= eind
->relocs_copied
;
419 eind
->relocs_copied
= NULL
;
422 _bfd_elf_link_hash_copy_indirect (bed
, dir
, ind
);
425 /* Create an ARM elf linker hash table. */
427 static struct bfd_link_hash_table
*
428 elf32_arm_link_hash_table_create (abfd
)
431 struct elf32_arm_link_hash_table
*ret
;
432 bfd_size_type amt
= sizeof (struct elf32_arm_link_hash_table
);
434 ret
= (struct elf32_arm_link_hash_table
*) bfd_malloc (amt
);
435 if (ret
== (struct elf32_arm_link_hash_table
*) NULL
)
438 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
439 elf32_arm_link_hash_newfunc
))
452 ret
->thumb_glue_size
= 0;
453 ret
->arm_glue_size
= 0;
454 ret
->bfd_of_glue_owner
= NULL
;
455 ret
->no_pipeline_knowledge
= 0;
456 ret
->byteswap_code
= 0;
457 ret
->sym_sec
.abfd
= NULL
;
459 return &ret
->root
.root
;
462 /* Locate the Thumb encoded calling stub for NAME. */
464 static struct elf_link_hash_entry
*
465 find_thumb_glue (link_info
, name
, input_bfd
)
466 struct bfd_link_info
*link_info
;
471 struct elf_link_hash_entry
*hash
;
472 struct elf32_arm_link_hash_table
*hash_table
;
474 /* We need a pointer to the armelf specific hash table. */
475 hash_table
= elf32_arm_hash_table (link_info
);
477 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
478 + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1);
480 BFD_ASSERT (tmp_name
);
482 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
484 hash
= elf_link_hash_lookup
485 (&(hash_table
)->root
, tmp_name
, FALSE
, FALSE
, TRUE
);
488 /* xgettext:c-format */
489 (*_bfd_error_handler
) (_("%B: unable to find THUMB glue '%s' for `%s'"),
490 input_bfd
, tmp_name
, name
);
497 /* Locate the ARM encoded calling stub for NAME. */
499 static struct elf_link_hash_entry
*
500 find_arm_glue (link_info
, name
, input_bfd
)
501 struct bfd_link_info
*link_info
;
506 struct elf_link_hash_entry
*myh
;
507 struct elf32_arm_link_hash_table
*hash_table
;
509 /* We need a pointer to the elfarm specific hash table. */
510 hash_table
= elf32_arm_hash_table (link_info
);
512 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
513 + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1);
515 BFD_ASSERT (tmp_name
);
517 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
519 myh
= elf_link_hash_lookup
520 (&(hash_table
)->root
, tmp_name
, FALSE
, FALSE
, TRUE
);
523 /* xgettext:c-format */
524 (*_bfd_error_handler
) (_("%B: unable to find ARM glue '%s' for `%s'"),
525 input_bfd
, tmp_name
, name
);
539 .word func @ behave as if you saw a ARM_32 reloc. */
541 #define ARM2THUMB_GLUE_SIZE 12
542 static const insn32 a2t1_ldr_insn
= 0xe59fc000;
543 static const insn32 a2t2_bx_r12_insn
= 0xe12fff1c;
544 static const insn32 a2t3_func_addr_insn
= 0x00000001;
546 /* Thumb->ARM: Thumb->(non-interworking aware) ARM
550 __func_from_thumb: __func_from_thumb:
552 nop ldr r6, __func_addr
554 __func_change_to_arm: bx r6
556 __func_back_to_thumb:
562 #define THUMB2ARM_GLUE_SIZE 8
563 static const insn16 t2a1_bx_pc_insn
= 0x4778;
564 static const insn16 t2a2_noop_insn
= 0x46c0;
565 static const insn32 t2a3_b_insn
= 0xea000000;
567 #ifndef ELFARM_NABI_C_INCLUDED
569 bfd_elf32_arm_allocate_interworking_sections (info
)
570 struct bfd_link_info
* info
;
574 struct elf32_arm_link_hash_table
* globals
;
576 globals
= elf32_arm_hash_table (info
);
578 BFD_ASSERT (globals
!= NULL
);
580 if (globals
->arm_glue_size
!= 0)
582 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
584 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
585 ARM2THUMB_GLUE_SECTION_NAME
);
587 BFD_ASSERT (s
!= NULL
);
589 foo
= (bfd_byte
*) bfd_alloc (globals
->bfd_of_glue_owner
,
590 globals
->arm_glue_size
);
592 s
->size
= globals
->arm_glue_size
;
596 if (globals
->thumb_glue_size
!= 0)
598 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
600 s
= bfd_get_section_by_name
601 (globals
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
603 BFD_ASSERT (s
!= NULL
);
605 foo
= (bfd_byte
*) bfd_alloc (globals
->bfd_of_glue_owner
,
606 globals
->thumb_glue_size
);
608 s
->size
= globals
->thumb_glue_size
;
616 record_arm_to_thumb_glue (link_info
, h
)
617 struct bfd_link_info
* link_info
;
618 struct elf_link_hash_entry
* h
;
620 const char * name
= h
->root
.root
.string
;
623 struct elf_link_hash_entry
* myh
;
624 struct bfd_link_hash_entry
* bh
;
625 struct elf32_arm_link_hash_table
* globals
;
628 globals
= elf32_arm_hash_table (link_info
);
630 BFD_ASSERT (globals
!= NULL
);
631 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
633 s
= bfd_get_section_by_name
634 (globals
->bfd_of_glue_owner
, ARM2THUMB_GLUE_SECTION_NAME
);
636 BFD_ASSERT (s
!= NULL
);
638 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
639 + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1);
641 BFD_ASSERT (tmp_name
);
643 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
645 myh
= elf_link_hash_lookup
646 (&(globals
)->root
, tmp_name
, FALSE
, FALSE
, TRUE
);
650 /* We've already seen this guy. */
655 /* The only trick here is using hash_table->arm_glue_size as the value. Even
656 though the section isn't allocated yet, this is where we will be putting
659 val
= globals
->arm_glue_size
+ 1;
660 _bfd_generic_link_add_one_symbol (link_info
, globals
->bfd_of_glue_owner
,
661 tmp_name
, BSF_GLOBAL
, s
, val
,
662 NULL
, TRUE
, FALSE
, &bh
);
666 globals
->arm_glue_size
+= ARM2THUMB_GLUE_SIZE
;
672 record_thumb_to_arm_glue (link_info
, h
)
673 struct bfd_link_info
*link_info
;
674 struct elf_link_hash_entry
*h
;
676 const char *name
= h
->root
.root
.string
;
679 struct elf_link_hash_entry
*myh
;
680 struct bfd_link_hash_entry
*bh
;
681 struct elf32_arm_link_hash_table
*hash_table
;
685 hash_table
= elf32_arm_hash_table (link_info
);
687 BFD_ASSERT (hash_table
!= NULL
);
688 BFD_ASSERT (hash_table
->bfd_of_glue_owner
!= NULL
);
690 s
= bfd_get_section_by_name
691 (hash_table
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
693 BFD_ASSERT (s
!= NULL
);
695 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
696 + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1);
698 BFD_ASSERT (tmp_name
);
700 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
702 myh
= elf_link_hash_lookup
703 (&(hash_table
)->root
, tmp_name
, FALSE
, FALSE
, TRUE
);
707 /* We've already seen this guy. */
713 val
= hash_table
->thumb_glue_size
+ 1;
714 _bfd_generic_link_add_one_symbol (link_info
, hash_table
->bfd_of_glue_owner
,
715 tmp_name
, BSF_GLOBAL
, s
, val
,
716 NULL
, TRUE
, FALSE
, &bh
);
718 /* If we mark it 'Thumb', the disassembler will do a better job. */
719 myh
= (struct elf_link_hash_entry
*) bh
;
720 bind
= ELF_ST_BIND (myh
->type
);
721 myh
->type
= ELF_ST_INFO (bind
, STT_ARM_TFUNC
);
725 #define CHANGE_TO_ARM "__%s_change_to_arm"
726 #define BACK_FROM_ARM "__%s_back_from_arm"
728 /* Allocate another symbol to mark where we switch to Arm mode. */
729 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
730 + strlen (CHANGE_TO_ARM
) + 1);
732 BFD_ASSERT (tmp_name
);
734 sprintf (tmp_name
, CHANGE_TO_ARM
, name
);
737 val
= hash_table
->thumb_glue_size
+ 4,
738 _bfd_generic_link_add_one_symbol (link_info
, hash_table
->bfd_of_glue_owner
,
739 tmp_name
, BSF_LOCAL
, s
, val
,
740 NULL
, TRUE
, FALSE
, &bh
);
744 hash_table
->thumb_glue_size
+= THUMB2ARM_GLUE_SIZE
;
749 /* Add the glue sections to ABFD. This function is called from the
750 linker scripts in ld/emultempl/{armelf}.em. */
753 bfd_elf32_arm_add_glue_sections_to_bfd (abfd
, info
)
755 struct bfd_link_info
*info
;
760 /* If we are only performing a partial
761 link do not bother adding the glue. */
762 if (info
->relocatable
)
765 sec
= bfd_get_section_by_name (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
769 /* Note: we do not include the flag SEC_LINKER_CREATED, as this
770 will prevent elf_link_input_bfd() from processing the contents
772 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_CODE
| SEC_READONLY
;
774 sec
= bfd_make_section (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
777 || !bfd_set_section_flags (abfd
, sec
, flags
)
778 || !bfd_set_section_alignment (abfd
, sec
, 2))
781 /* Set the gc mark to prevent the section from being removed by garbage
782 collection, despite the fact that no relocs refer to this section. */
786 sec
= bfd_get_section_by_name (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
790 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_CODE
| SEC_READONLY
;
792 sec
= bfd_make_section (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
795 || !bfd_set_section_flags (abfd
, sec
, flags
)
796 || !bfd_set_section_alignment (abfd
, sec
, 2))
805 /* Select a BFD to be used to hold the sections used by the glue code.
806 This function is called from the linker scripts in ld/emultempl/
810 bfd_elf32_arm_get_bfd_for_interworking (abfd
, info
)
812 struct bfd_link_info
*info
;
814 struct elf32_arm_link_hash_table
*globals
;
816 /* If we are only performing a partial link
817 do not bother getting a bfd to hold the glue. */
818 if (info
->relocatable
)
821 globals
= elf32_arm_hash_table (info
);
823 BFD_ASSERT (globals
!= NULL
);
825 if (globals
->bfd_of_glue_owner
!= NULL
)
828 /* Save the bfd for later use. */
829 globals
->bfd_of_glue_owner
= abfd
;
835 bfd_elf32_arm_process_before_allocation (abfd
, link_info
,
836 no_pipeline_knowledge
,
839 struct bfd_link_info
*link_info
;
840 int no_pipeline_knowledge
;
843 Elf_Internal_Shdr
*symtab_hdr
;
844 Elf_Internal_Rela
*internal_relocs
= NULL
;
845 Elf_Internal_Rela
*irel
, *irelend
;
846 bfd_byte
*contents
= NULL
;
849 struct elf32_arm_link_hash_table
*globals
;
851 /* If we are only performing a partial link do not bother
852 to construct any glue. */
853 if (link_info
->relocatable
)
856 /* Here we have a bfd that is to be included on the link. We have a hook
857 to do reloc rummaging, before section sizes are nailed down. */
858 globals
= elf32_arm_hash_table (link_info
);
860 BFD_ASSERT (globals
!= NULL
);
861 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
863 globals
->no_pipeline_knowledge
= no_pipeline_knowledge
;
864 if (byteswap_code
&& !bfd_big_endian (abfd
))
866 _bfd_error_handler (_("%B: BE8 images only valid in big-endian mode."),
870 globals
->byteswap_code
= byteswap_code
;
872 /* Rummage around all the relocs and map the glue vectors. */
873 sec
= abfd
->sections
;
878 for (; sec
!= NULL
; sec
= sec
->next
)
880 if (sec
->reloc_count
== 0)
883 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
885 /* Load the relocs. */
887 = _bfd_elf_link_read_relocs (abfd
, sec
, (PTR
) NULL
,
888 (Elf_Internal_Rela
*) NULL
, FALSE
);
890 if (internal_relocs
== NULL
)
893 irelend
= internal_relocs
+ sec
->reloc_count
;
894 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
897 unsigned long r_index
;
899 struct elf_link_hash_entry
*h
;
901 r_type
= ELF32_R_TYPE (irel
->r_info
);
902 r_index
= ELF32_R_SYM (irel
->r_info
);
904 /* These are the only relocation types we care about. */
905 if ( r_type
!= R_ARM_PC24
906 && r_type
!= R_ARM_THM_PC22
)
909 /* Get the section contents if we haven't done so already. */
910 if (contents
== NULL
)
912 /* Get cached copy if it exists. */
913 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
914 contents
= elf_section_data (sec
)->this_hdr
.contents
;
917 /* Go get them off disk. */
918 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
923 /* If the relocation is not against a symbol it cannot concern us. */
926 /* We don't care about local symbols. */
927 if (r_index
< symtab_hdr
->sh_info
)
930 /* This is an external symbol. */
931 r_index
-= symtab_hdr
->sh_info
;
932 h
= (struct elf_link_hash_entry
*)
933 elf_sym_hashes (abfd
)[r_index
];
935 /* If the relocation is against a static symbol it must be within
936 the current section and so cannot be a cross ARM/Thumb relocation. */
943 /* This one is a call from arm code. We need to look up
944 the target of the call. If it is a thumb target, we
946 if (ELF_ST_TYPE(h
->type
) == STT_ARM_TFUNC
)
947 record_arm_to_thumb_glue (link_info
, h
);
951 /* This one is a call from thumb code. We look
952 up the target of the call. If it is not a thumb
953 target, we insert glue. */
954 if (ELF_ST_TYPE (h
->type
) != STT_ARM_TFUNC
)
955 record_thumb_to_arm_glue (link_info
, h
);
964 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
968 if (internal_relocs
!= NULL
969 && elf_section_data (sec
)->relocs
!= internal_relocs
)
970 free (internal_relocs
);
971 internal_relocs
= NULL
;
978 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
980 if (internal_relocs
!= NULL
981 && elf_section_data (sec
)->relocs
!= internal_relocs
)
982 free (internal_relocs
);
988 /* The thumb form of a long branch is a bit finicky, because the offset
989 encoding is split over two fields, each in it's own instruction. They
990 can occur in any order. So given a thumb form of long branch, and an
991 offset, insert the offset into the thumb branch and return finished
994 It takes two thumb instructions to encode the target address. Each has
995 11 bits to invest. The upper 11 bits are stored in one (identified by
996 H-0.. see below), the lower 11 bits are stored in the other (identified
999 Combine together and shifted left by 1 (it's a half word address) and
1003 H-0, upper address-0 = 000
1005 H-1, lower address-0 = 800
1007 They can be ordered either way, but the arm tools I've seen always put
1008 the lower one first. It probably doesn't matter. krk@cygnus.com
1010 XXX: Actually the order does matter. The second instruction (H-1)
1011 moves the computed address into the PC, so it must be the second one
1012 in the sequence. The problem, however is that whilst little endian code
1013 stores the instructions in HI then LOW order, big endian code does the
1014 reverse. nickc@cygnus.com. */
1016 #define LOW_HI_ORDER 0xF800F000
1017 #define HI_LOW_ORDER 0xF000F800
1020 insert_thumb_branch (br_insn
, rel_off
)
1024 unsigned int low_bits
;
1025 unsigned int high_bits
;
1027 BFD_ASSERT ((rel_off
& 1) != 1);
1029 rel_off
>>= 1; /* Half word aligned address. */
1030 low_bits
= rel_off
& 0x000007FF; /* The bottom 11 bits. */
1031 high_bits
= (rel_off
>> 11) & 0x000007FF; /* The top 11 bits. */
1033 if ((br_insn
& LOW_HI_ORDER
) == LOW_HI_ORDER
)
1034 br_insn
= LOW_HI_ORDER
| (low_bits
<< 16) | high_bits
;
1035 else if ((br_insn
& HI_LOW_ORDER
) == HI_LOW_ORDER
)
1036 br_insn
= HI_LOW_ORDER
| (high_bits
<< 16) | low_bits
;
1038 /* FIXME: abort is probably not the right call. krk@cygnus.com */
1039 abort (); /* error - not a valid branch instruction form. */
1044 /* Thumb code calling an ARM function. */
1047 elf32_thumb_to_arm_stub (info
, name
, input_bfd
, output_bfd
, input_section
,
1048 hit_data
, sym_sec
, offset
, addend
, val
)
1049 struct bfd_link_info
* info
;
1053 asection
* input_section
;
1054 bfd_byte
* hit_data
;
1057 bfd_signed_vma addend
;
1062 unsigned long int tmp
;
1063 long int ret_offset
;
1064 struct elf_link_hash_entry
* myh
;
1065 struct elf32_arm_link_hash_table
* globals
;
1067 myh
= find_thumb_glue (info
, name
, input_bfd
);
1071 globals
= elf32_arm_hash_table (info
);
1073 BFD_ASSERT (globals
!= NULL
);
1074 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
1076 my_offset
= myh
->root
.u
.def
.value
;
1078 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
1079 THUMB2ARM_GLUE_SECTION_NAME
);
1081 BFD_ASSERT (s
!= NULL
);
1082 BFD_ASSERT (s
->contents
!= NULL
);
1083 BFD_ASSERT (s
->output_section
!= NULL
);
1085 if ((my_offset
& 0x01) == 0x01)
1088 && sym_sec
->owner
!= NULL
1089 && !INTERWORK_FLAG (sym_sec
->owner
))
1091 (*_bfd_error_handler
)
1092 (_("%B(%s): warning: interworking not enabled.\n"
1093 " first occurrence: %B: thumb call to arm"),
1094 sym_sec
->owner
, input_bfd
, name
);
1100 myh
->root
.u
.def
.value
= my_offset
;
1102 bfd_put_16 (output_bfd
, (bfd_vma
) t2a1_bx_pc_insn
,
1103 s
->contents
+ my_offset
);
1105 bfd_put_16 (output_bfd
, (bfd_vma
) t2a2_noop_insn
,
1106 s
->contents
+ my_offset
+ 2);
1109 /* Address of destination of the stub. */
1110 ((bfd_signed_vma
) val
)
1112 /* Offset from the start of the current section to the start of the stubs. */
1114 /* Offset of the start of this stub from the start of the stubs. */
1116 /* Address of the start of the current section. */
1117 + s
->output_section
->vma
)
1118 /* The branch instruction is 4 bytes into the stub. */
1120 /* ARM branches work from the pc of the instruction + 8. */
1123 bfd_put_32 (output_bfd
,
1124 (bfd_vma
) t2a3_b_insn
| ((ret_offset
>> 2) & 0x00FFFFFF),
1125 s
->contents
+ my_offset
+ 4);
1128 BFD_ASSERT (my_offset
<= globals
->thumb_glue_size
);
1130 /* Now go back and fix up the original BL insn to point to here. */
1132 /* Address of where the stub is located. */
1133 (s
->output_section
->vma
+ s
->output_offset
+ my_offset
)
1134 /* Address of where the BL is located. */
1135 - (input_section
->output_section
->vma
+ input_section
->output_offset
+ offset
)
1136 /* Addend in the relocation. */
1138 /* Biassing for PC-relative addressing. */
1141 tmp
= bfd_get_32 (input_bfd
, hit_data
1142 - input_section
->vma
);
1144 bfd_put_32 (output_bfd
,
1145 (bfd_vma
) insert_thumb_branch (tmp
, ret_offset
),
1146 hit_data
- input_section
->vma
);
1151 /* Arm code calling a Thumb function. */
1154 elf32_arm_to_thumb_stub (info
, name
, input_bfd
, output_bfd
, input_section
,
1155 hit_data
, sym_sec
, offset
, addend
, val
)
1156 struct bfd_link_info
* info
;
1160 asection
* input_section
;
1161 bfd_byte
* hit_data
;
1164 bfd_signed_vma addend
;
1167 unsigned long int tmp
;
1170 long int ret_offset
;
1171 struct elf_link_hash_entry
* myh
;
1172 struct elf32_arm_link_hash_table
* globals
;
1174 myh
= find_arm_glue (info
, name
, input_bfd
);
1178 globals
= elf32_arm_hash_table (info
);
1180 BFD_ASSERT (globals
!= NULL
);
1181 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
1183 my_offset
= myh
->root
.u
.def
.value
;
1184 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
1185 ARM2THUMB_GLUE_SECTION_NAME
);
1186 BFD_ASSERT (s
!= NULL
);
1187 BFD_ASSERT (s
->contents
!= NULL
);
1188 BFD_ASSERT (s
->output_section
!= NULL
);
1190 if ((my_offset
& 0x01) == 0x01)
1193 && sym_sec
->owner
!= NULL
1194 && !INTERWORK_FLAG (sym_sec
->owner
))
1196 (*_bfd_error_handler
)
1197 (_("%B(%s): warning: interworking not enabled.\n"
1198 " first occurrence: %B: arm call to thumb"),
1199 sym_sec
->owner
, input_bfd
, name
);
1203 myh
->root
.u
.def
.value
= my_offset
;
1205 bfd_put_32 (output_bfd
, (bfd_vma
) a2t1_ldr_insn
,
1206 s
->contents
+ my_offset
);
1208 bfd_put_32 (output_bfd
, (bfd_vma
) a2t2_bx_r12_insn
,
1209 s
->contents
+ my_offset
+ 4);
1211 /* It's a thumb address. Add the low order bit. */
1212 bfd_put_32 (output_bfd
, val
| a2t3_func_addr_insn
,
1213 s
->contents
+ my_offset
+ 8);
1216 BFD_ASSERT (my_offset
<= globals
->arm_glue_size
);
1218 tmp
= bfd_get_32 (input_bfd
, hit_data
);
1219 tmp
= tmp
& 0xFF000000;
1221 /* Somehow these are both 4 too far, so subtract 8. */
1222 ret_offset
= (s
->output_offset
1224 + s
->output_section
->vma
1225 - (input_section
->output_offset
1226 + input_section
->output_section
->vma
1230 tmp
= tmp
| ((ret_offset
>> 2) & 0x00FFFFFF);
1232 bfd_put_32 (output_bfd
, (bfd_vma
) tmp
, hit_data
- input_section
->vma
);
1237 /* Perform a relocation as part of a final link. */
1239 static bfd_reloc_status_type
1240 elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
1241 input_section
, contents
, rel
, value
,
1242 info
, sym_sec
, sym_name
, sym_flags
, h
)
1243 reloc_howto_type
* howto
;
1246 asection
* input_section
;
1247 bfd_byte
* contents
;
1248 Elf_Internal_Rela
* rel
;
1250 struct bfd_link_info
* info
;
1252 const char * sym_name
;
1254 struct elf_link_hash_entry
* h
;
1256 unsigned long r_type
= howto
->type
;
1257 unsigned long r_symndx
;
1258 bfd_byte
* hit_data
= contents
+ rel
->r_offset
;
1259 bfd
* dynobj
= NULL
;
1260 Elf_Internal_Shdr
* symtab_hdr
;
1261 struct elf_link_hash_entry
** sym_hashes
;
1262 bfd_vma
* local_got_offsets
;
1263 asection
* sgot
= NULL
;
1264 asection
* splt
= NULL
;
1265 asection
* sreloc
= NULL
;
1267 bfd_signed_vma signed_addend
;
1268 struct elf32_arm_link_hash_table
* globals
;
1270 /* If the start address has been set, then set the EF_ARM_HASENTRY
1271 flag. Setting this more than once is redundant, but the cost is
1272 not too high, and it keeps the code simple.
1274 The test is done here, rather than somewhere else, because the
1275 start address is only set just before the final link commences.
1277 Note - if the user deliberately sets a start address of 0, the
1278 flag will not be set. */
1279 if (bfd_get_start_address (output_bfd
) != 0)
1280 elf_elfheader (output_bfd
)->e_flags
|= EF_ARM_HASENTRY
;
1282 globals
= elf32_arm_hash_table (info
);
1284 dynobj
= elf_hash_table (info
)->dynobj
;
1287 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1288 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1290 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1291 sym_hashes
= elf_sym_hashes (input_bfd
);
1292 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1293 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1296 addend
= bfd_get_32 (input_bfd
, hit_data
) & howto
->src_mask
;
1298 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1301 signed_addend
&= ~ howto
->src_mask
;
1302 signed_addend
|= addend
;
1305 signed_addend
= addend
;
1307 addend
= signed_addend
= rel
->r_addend
;
1313 return bfd_reloc_ok
;
1322 /* r_symndx will be zero only for relocs against symbols
1323 from removed linkonce sections, or sections discarded by
1326 return bfd_reloc_ok
;
1328 /* Handle relocations which should use the PLT entry. ABS32/REL32
1329 will use the symbol's value, which may point to a PLT entry, but we
1330 don't need to handle that here. If we created a PLT entry, all
1331 branches in this object should go to it. */
1332 if ((r_type
!= R_ARM_ABS32
&& r_type
!= R_ARM_REL32
)
1335 && h
->plt
.offset
!= (bfd_vma
) -1)
1337 /* If we've created a .plt section, and assigned a PLT entry to
1338 this function, it should not be known to bind locally. If
1339 it were, we would have cleared the PLT entry. */
1340 BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info
, h
));
1342 value
= (splt
->output_section
->vma
1343 + splt
->output_offset
1345 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1346 contents
, rel
->r_offset
, value
,
1350 /* When generating a shared object, these relocations are copied
1351 into the output file to be resolved at run time. */
1353 && (input_section
->flags
& SEC_ALLOC
)
1354 && (r_type
!= R_ARM_REL32
1355 || !SYMBOL_CALLS_LOCAL (info
, h
))
1357 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
1358 || h
->root
.type
!= bfd_link_hash_undefweak
)
1359 && r_type
!= R_ARM_PC24
1360 && r_type
!= R_ARM_PLT32
)
1362 Elf_Internal_Rela outrel
;
1364 bfd_boolean skip
, relocate
;
1370 name
= (bfd_elf_string_from_elf_section
1372 elf_elfheader (input_bfd
)->e_shstrndx
,
1373 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1375 return bfd_reloc_notsupported
;
1377 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
1378 && strcmp (bfd_get_section_name (input_bfd
,
1382 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1383 BFD_ASSERT (sreloc
!= NULL
);
1390 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
1392 if (outrel
.r_offset
== (bfd_vma
) -1)
1394 else if (outrel
.r_offset
== (bfd_vma
) -2)
1395 skip
= TRUE
, relocate
= TRUE
;
1396 outrel
.r_offset
+= (input_section
->output_section
->vma
1397 + input_section
->output_offset
);
1400 memset (&outrel
, 0, sizeof outrel
);
1405 || (h
->elf_link_hash_flags
1406 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1407 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1410 /* This symbol is local, or marked to become local. */
1412 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1415 loc
= sreloc
->contents
;
1416 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
1417 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
1419 /* If this reloc is against an external symbol, we do not want to
1420 fiddle with the addend. Otherwise, we need to include the symbol
1421 value so that it becomes an addend for the dynamic reloc. */
1423 return bfd_reloc_ok
;
1425 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1426 contents
, rel
->r_offset
, value
,
1429 else switch (r_type
)
1432 case R_ARM_XPC25
: /* Arm BLX instruction. */
1434 case R_ARM_PC24
: /* Arm B/BL instruction */
1437 if (r_type
== R_ARM_XPC25
)
1439 /* Check for Arm calling Arm function. */
1440 /* FIXME: Should we translate the instruction into a BL
1441 instruction instead ? */
1442 if (sym_flags
!= STT_ARM_TFUNC
)
1443 (*_bfd_error_handler
)
1444 (_("\%B: Warning: Arm BLX instruction targets Arm function '%s'."),
1446 h
? h
->root
.root
.string
: "(local)");
1451 /* Check for Arm calling Thumb function. */
1452 if (sym_flags
== STT_ARM_TFUNC
)
1454 elf32_arm_to_thumb_stub (info
, sym_name
, input_bfd
, output_bfd
,
1455 input_section
, hit_data
, sym_sec
, rel
->r_offset
,
1456 signed_addend
, value
);
1457 return bfd_reloc_ok
;
1461 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1462 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0)
1464 /* The old way of doing things. Trearing the addend as a
1465 byte sized field and adding in the pipeline offset. */
1466 value
-= (input_section
->output_section
->vma
1467 + input_section
->output_offset
);
1468 value
-= rel
->r_offset
;
1471 if (! globals
->no_pipeline_knowledge
)
1476 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
1478 S is the address of the symbol in the relocation.
1479 P is address of the instruction being relocated.
1480 A is the addend (extracted from the instruction) in bytes.
1482 S is held in 'value'.
1483 P is the base address of the section containing the instruction
1484 plus the offset of the reloc into that section, ie:
1485 (input_section->output_section->vma +
1486 input_section->output_offset +
1488 A is the addend, converted into bytes, ie:
1491 Note: None of these operations have knowledge of the pipeline
1492 size of the processor, thus it is up to the assembler to encode
1493 this information into the addend. */
1494 value
-= (input_section
->output_section
->vma
1495 + input_section
->output_offset
);
1496 value
-= rel
->r_offset
;
1497 value
+= (signed_addend
<< howto
->size
);
1499 /* Previous versions of this code also used to add in the pipeline
1500 offset here. This is wrong because the linker is not supposed
1501 to know about such things, and one day it might change. In order
1502 to support old binaries that need the old behaviour however, so
1503 we attempt to detect which ABI was used to create the reloc. */
1504 if (! globals
->no_pipeline_knowledge
)
1506 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form */
1508 i_ehdrp
= elf_elfheader (input_bfd
);
1510 if (i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1515 signed_addend
= value
;
1516 signed_addend
>>= howto
->rightshift
;
1518 /* It is not an error for an undefined weak reference to be
1519 out of range. Any program that branches to such a symbol
1520 is going to crash anyway, so there is no point worrying
1521 about getting the destination exactly right. */
1522 if (! h
|| h
->root
.type
!= bfd_link_hash_undefweak
)
1524 /* Perform a signed range check. */
1525 if ( signed_addend
> ((bfd_signed_vma
) (howto
->dst_mask
>> 1))
1526 || signed_addend
< - ((bfd_signed_vma
) ((howto
->dst_mask
+ 1) >> 1)))
1527 return bfd_reloc_overflow
;
1531 /* If necessary set the H bit in the BLX instruction. */
1532 if (r_type
== R_ARM_XPC25
&& ((value
& 2) == 2))
1533 value
= (signed_addend
& howto
->dst_mask
)
1534 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
))
1538 value
= (signed_addend
& howto
->dst_mask
)
1539 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1544 if (sym_flags
== STT_ARM_TFUNC
)
1549 value
-= (input_section
->output_section
->vma
1550 + input_section
->output_offset
+ rel
->r_offset
);
1555 bfd_put_32 (input_bfd
, value
, hit_data
);
1556 return bfd_reloc_ok
;
1560 if ((long) value
> 0x7f || (long) value
< -0x80)
1561 return bfd_reloc_overflow
;
1563 bfd_put_8 (input_bfd
, value
, hit_data
);
1564 return bfd_reloc_ok
;
1569 if ((long) value
> 0x7fff || (long) value
< -0x8000)
1570 return bfd_reloc_overflow
;
1572 bfd_put_16 (input_bfd
, value
, hit_data
);
1573 return bfd_reloc_ok
;
1576 /* Support ldr and str instruction for the arm */
1577 /* Also thumb b (unconditional branch). ??? Really? */
1580 if ((long) value
> 0x7ff || (long) value
< -0x800)
1581 return bfd_reloc_overflow
;
1583 value
|= (bfd_get_32 (input_bfd
, hit_data
) & 0xfffff000);
1584 bfd_put_32 (input_bfd
, value
, hit_data
);
1585 return bfd_reloc_ok
;
1587 case R_ARM_THM_ABS5
:
1588 /* Support ldr and str instructions for the thumb. */
1590 /* Need to refetch addend. */
1591 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1592 /* ??? Need to determine shift amount from operand size. */
1593 addend
>>= howto
->rightshift
;
1597 /* ??? Isn't value unsigned? */
1598 if ((long) value
> 0x1f || (long) value
< -0x10)
1599 return bfd_reloc_overflow
;
1601 /* ??? Value needs to be properly shifted into place first. */
1602 value
|= bfd_get_16 (input_bfd
, hit_data
) & 0xf83f;
1603 bfd_put_16 (input_bfd
, value
, hit_data
);
1604 return bfd_reloc_ok
;
1607 case R_ARM_THM_XPC22
:
1609 case R_ARM_THM_PC22
:
1610 /* Thumb BL (branch long instruction). */
1613 bfd_boolean overflow
= FALSE
;
1614 bfd_vma upper_insn
= bfd_get_16 (input_bfd
, hit_data
);
1615 bfd_vma lower_insn
= bfd_get_16 (input_bfd
, hit_data
+ 2);
1616 bfd_signed_vma reloc_signed_max
= ((1 << (howto
->bitsize
- 1)) - 1) >> howto
->rightshift
;
1617 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1619 bfd_signed_vma signed_check
;
1622 /* Need to refetch the addend and squish the two 11 bit pieces
1625 bfd_vma upper
= upper_insn
& 0x7ff;
1626 bfd_vma lower
= lower_insn
& 0x7ff;
1627 upper
= (upper
^ 0x400) - 0x400; /* Sign extend. */
1628 addend
= (upper
<< 12) | (lower
<< 1);
1629 signed_addend
= addend
;
1633 if (r_type
== R_ARM_THM_XPC22
)
1635 /* Check for Thumb to Thumb call. */
1636 /* FIXME: Should we translate the instruction into a BL
1637 instruction instead ? */
1638 if (sym_flags
== STT_ARM_TFUNC
)
1639 (*_bfd_error_handler
)
1640 (_("%B: Warning: Thumb BLX instruction targets thumb function '%s'."),
1642 h
? h
->root
.root
.string
: "(local)");
1647 /* If it is not a call to Thumb, assume call to Arm.
1648 If it is a call relative to a section name, then it is not a
1649 function call at all, but rather a long jump. */
1650 if (sym_flags
!= STT_ARM_TFUNC
&& sym_flags
!= STT_SECTION
)
1652 if (elf32_thumb_to_arm_stub
1653 (info
, sym_name
, input_bfd
, output_bfd
, input_section
,
1654 hit_data
, sym_sec
, rel
->r_offset
, signed_addend
, value
))
1655 return bfd_reloc_ok
;
1657 return bfd_reloc_dangerous
;
1661 relocation
= value
+ signed_addend
;
1663 relocation
-= (input_section
->output_section
->vma
1664 + input_section
->output_offset
1667 if (! globals
->no_pipeline_knowledge
)
1669 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form. */
1671 i_ehdrp
= elf_elfheader (input_bfd
);
1673 /* Previous versions of this code also used to add in the pipline
1674 offset here. This is wrong because the linker is not supposed
1675 to know about such things, and one day it might change. In order
1676 to support old binaries that need the old behaviour however, so
1677 we attempt to detect which ABI was used to create the reloc. */
1678 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1679 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0
1680 || i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1684 check
= relocation
>> howto
->rightshift
;
1686 /* If this is a signed value, the rightshift just dropped
1687 leading 1 bits (assuming twos complement). */
1688 if ((bfd_signed_vma
) relocation
>= 0)
1689 signed_check
= check
;
1691 signed_check
= check
| ~((bfd_vma
) -1 >> howto
->rightshift
);
1693 /* Assumes two's complement. */
1694 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1698 if (r_type
== R_ARM_THM_XPC22
1699 && ((lower_insn
& 0x1800) == 0x0800))
1700 /* For a BLX instruction, make sure that the relocation is rounded up
1701 to a word boundary. This follows the semantics of the instruction
1702 which specifies that bit 1 of the target address will come from bit
1703 1 of the base address. */
1704 relocation
= (relocation
+ 2) & ~ 3;
1706 /* Put RELOCATION back into the insn. */
1707 upper_insn
= (upper_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 12) & 0x7ff);
1708 lower_insn
= (lower_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 1) & 0x7ff);
1710 /* Put the relocated value back in the object file: */
1711 bfd_put_16 (input_bfd
, upper_insn
, hit_data
);
1712 bfd_put_16 (input_bfd
, lower_insn
, hit_data
+ 2);
1714 return (overflow
? bfd_reloc_overflow
: bfd_reloc_ok
);
1718 case R_ARM_THM_PC11
:
1719 /* Thumb B (branch) instruction). */
1721 bfd_signed_vma relocation
;
1722 bfd_signed_vma reloc_signed_max
= (1 << (howto
->bitsize
- 1)) - 1;
1723 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1724 bfd_signed_vma signed_check
;
1727 /* Need to refetch addend. */
1728 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1729 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1732 signed_addend
&= ~ howto
->src_mask
;
1733 signed_addend
|= addend
;
1736 signed_addend
= addend
;
1737 /* The value in the insn has been right shifted. We need to
1738 undo this, so that we can perform the address calculation
1739 in terms of bytes. */
1740 signed_addend
<<= howto
->rightshift
;
1742 relocation
= value
+ signed_addend
;
1744 relocation
-= (input_section
->output_section
->vma
1745 + input_section
->output_offset
1748 relocation
>>= howto
->rightshift
;
1749 signed_check
= relocation
;
1750 relocation
&= howto
->dst_mask
;
1751 relocation
|= (bfd_get_16 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1753 bfd_put_16 (input_bfd
, relocation
, hit_data
);
1755 /* Assumes two's complement. */
1756 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1757 return bfd_reloc_overflow
;
1759 return bfd_reloc_ok
;
1763 case R_ARM_ALU_PCREL7_0
:
1764 case R_ARM_ALU_PCREL15_8
:
1765 case R_ARM_ALU_PCREL23_15
:
1770 insn
= bfd_get_32 (input_bfd
, hit_data
);
1772 /* Extract the addend. */
1773 addend
= (insn
& 0xff) << ((insn
& 0xf00) >> 7);
1774 signed_addend
= addend
;
1776 relocation
= value
+ signed_addend
;
1778 relocation
-= (input_section
->output_section
->vma
1779 + input_section
->output_offset
1781 insn
= (insn
& ~0xfff)
1782 | ((howto
->bitpos
<< 7) & 0xf00)
1783 | ((relocation
>> howto
->bitpos
) & 0xff);
1784 bfd_put_32 (input_bfd
, value
, hit_data
);
1786 return bfd_reloc_ok
;
1789 case R_ARM_GNU_VTINHERIT
:
1790 case R_ARM_GNU_VTENTRY
:
1791 return bfd_reloc_ok
;
1794 return bfd_reloc_notsupported
;
1796 case R_ARM_GLOB_DAT
:
1797 return bfd_reloc_notsupported
;
1799 case R_ARM_JUMP_SLOT
:
1800 return bfd_reloc_notsupported
;
1802 case R_ARM_RELATIVE
:
1803 return bfd_reloc_notsupported
;
1806 /* Relocation is relative to the start of the
1807 global offset table. */
1809 BFD_ASSERT (sgot
!= NULL
);
1811 return bfd_reloc_notsupported
;
1813 /* If we are addressing a Thumb function, we need to adjust the
1814 address by one, so that attempts to call the function pointer will
1815 correctly interpret it as Thumb code. */
1816 if (sym_flags
== STT_ARM_TFUNC
)
1819 /* Note that sgot->output_offset is not involved in this
1820 calculation. We always want the start of .got. If we
1821 define _GLOBAL_OFFSET_TABLE in a different way, as is
1822 permitted by the ABI, we might have to change this
1824 value
-= sgot
->output_section
->vma
;
1825 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1826 contents
, rel
->r_offset
, value
,
1830 /* Use global offset table as symbol value. */
1831 BFD_ASSERT (sgot
!= NULL
);
1834 return bfd_reloc_notsupported
;
1836 value
= sgot
->output_section
->vma
;
1837 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1838 contents
, rel
->r_offset
, value
,
1842 /* Relocation is to the entry for this symbol in the
1843 global offset table. */
1845 return bfd_reloc_notsupported
;
1852 off
= h
->got
.offset
;
1853 BFD_ASSERT (off
!= (bfd_vma
) -1);
1854 dyn
= globals
->root
.dynamic_sections_created
;
1856 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
1858 && SYMBOL_REFERENCES_LOCAL (info
, h
))
1859 || (ELF_ST_VISIBILITY (h
->other
)
1860 && h
->root
.type
== bfd_link_hash_undefweak
))
1862 /* This is actually a static link, or it is a -Bsymbolic link
1863 and the symbol is defined locally. We must initialize this
1864 entry in the global offset table. Since the offset must
1865 always be a multiple of 4, we use the least significant bit
1866 to record whether we have initialized it already.
1868 When doing a dynamic link, we create a .rel.got relocation
1869 entry to initialize the value. This is done in the
1870 finish_dynamic_symbol routine. */
1875 /* If we are addressing a Thumb function, we need to
1876 adjust the address by one, so that attempts to
1877 call the function pointer will correctly
1878 interpret it as Thumb code. */
1879 if (sym_flags
== STT_ARM_TFUNC
)
1882 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1887 value
= sgot
->output_offset
+ off
;
1893 BFD_ASSERT (local_got_offsets
!= NULL
&&
1894 local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1896 off
= local_got_offsets
[r_symndx
];
1898 /* The offset must always be a multiple of 4. We use the
1899 least significant bit to record whether we have already
1900 generated the necessary reloc. */
1905 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1910 Elf_Internal_Rela outrel
;
1913 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
1914 BFD_ASSERT (srelgot
!= NULL
);
1916 outrel
.r_offset
= (sgot
->output_section
->vma
1917 + sgot
->output_offset
1919 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1920 loc
= srelgot
->contents
;
1921 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rel
);
1922 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
1925 local_got_offsets
[r_symndx
] |= 1;
1928 value
= sgot
->output_offset
+ off
;
1931 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1932 contents
, rel
->r_offset
, value
,
1936 return bfd_reloc_notsupported
;
1938 case R_ARM_AMP_VCALL9
:
1939 return bfd_reloc_notsupported
;
1941 case R_ARM_RSBREL32
:
1942 return bfd_reloc_notsupported
;
1944 case R_ARM_THM_RPC22
:
1945 return bfd_reloc_notsupported
;
1948 return bfd_reloc_notsupported
;
1951 return bfd_reloc_notsupported
;
1954 return bfd_reloc_notsupported
;
1957 return bfd_reloc_notsupported
;
1960 return bfd_reloc_notsupported
;
1965 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
1967 arm_add_to_rel (abfd
, address
, howto
, increment
)
1970 reloc_howto_type
* howto
;
1971 bfd_signed_vma increment
;
1973 bfd_signed_vma addend
;
1975 if (howto
->type
== R_ARM_THM_PC22
)
1977 int upper_insn
, lower_insn
;
1980 upper_insn
= bfd_get_16 (abfd
, address
);
1981 lower_insn
= bfd_get_16 (abfd
, address
+ 2);
1982 upper
= upper_insn
& 0x7ff;
1983 lower
= lower_insn
& 0x7ff;
1985 addend
= (upper
<< 12) | (lower
<< 1);
1986 addend
+= increment
;
1989 upper_insn
= (upper_insn
& 0xf800) | ((addend
>> 11) & 0x7ff);
1990 lower_insn
= (lower_insn
& 0xf800) | (addend
& 0x7ff);
1992 bfd_put_16 (abfd
, (bfd_vma
) upper_insn
, address
);
1993 bfd_put_16 (abfd
, (bfd_vma
) lower_insn
, address
+ 2);
1999 contents
= bfd_get_32 (abfd
, address
);
2001 /* Get the (signed) value from the instruction. */
2002 addend
= contents
& howto
->src_mask
;
2003 if (addend
& ((howto
->src_mask
+ 1) >> 1))
2005 bfd_signed_vma mask
;
2008 mask
&= ~ howto
->src_mask
;
2012 /* Add in the increment, (which is a byte value). */
2013 switch (howto
->type
)
2016 addend
+= increment
;
2020 addend
<<= howto
->size
;
2021 addend
+= increment
;
2023 /* Should we check for overflow here ? */
2025 /* Drop any undesired bits. */
2026 addend
>>= howto
->rightshift
;
2030 contents
= (contents
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
2032 bfd_put_32 (abfd
, contents
, address
);
2035 #endif /* USE_REL */
2037 /* Relocate an ARM ELF section. */
2039 elf32_arm_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
2040 contents
, relocs
, local_syms
, local_sections
)
2042 struct bfd_link_info
*info
;
2044 asection
*input_section
;
2046 Elf_Internal_Rela
*relocs
;
2047 Elf_Internal_Sym
*local_syms
;
2048 asection
**local_sections
;
2050 Elf_Internal_Shdr
*symtab_hdr
;
2051 struct elf_link_hash_entry
**sym_hashes
;
2052 Elf_Internal_Rela
*rel
;
2053 Elf_Internal_Rela
*relend
;
2057 if (info
->relocatable
)
2061 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
2062 sym_hashes
= elf_sym_hashes (input_bfd
);
2065 relend
= relocs
+ input_section
->reloc_count
;
2066 for (; rel
< relend
; rel
++)
2069 reloc_howto_type
* howto
;
2070 unsigned long r_symndx
;
2071 Elf_Internal_Sym
* sym
;
2073 struct elf_link_hash_entry
* h
;
2075 bfd_reloc_status_type r
;
2078 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2079 r_type
= ELF32_R_TYPE (rel
->r_info
);
2081 if ( r_type
== R_ARM_GNU_VTENTRY
2082 || r_type
== R_ARM_GNU_VTINHERIT
)
2085 elf32_arm_info_to_howto (input_bfd
, & bfd_reloc
, rel
);
2086 howto
= bfd_reloc
.howto
;
2089 if (info
->relocatable
)
2091 /* This is a relocatable link. We don't have to change
2092 anything, unless the reloc is against a section symbol,
2093 in which case we have to adjust according to where the
2094 section symbol winds up in the output section. */
2095 if (r_symndx
< symtab_hdr
->sh_info
)
2097 sym
= local_syms
+ r_symndx
;
2098 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2100 sec
= local_sections
[r_symndx
];
2101 arm_add_to_rel (input_bfd
, contents
+ rel
->r_offset
,
2103 (bfd_signed_vma
) (sec
->output_offset
2112 /* This is a final link. */
2117 if (r_symndx
< symtab_hdr
->sh_info
)
2119 sym
= local_syms
+ r_symndx
;
2120 sec
= local_sections
[r_symndx
];
2122 relocation
= (sec
->output_section
->vma
2123 + sec
->output_offset
2125 if ((sec
->flags
& SEC_MERGE
)
2126 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2129 bfd_vma addend
, value
;
2131 if (howto
->rightshift
)
2133 (*_bfd_error_handler
)
2134 (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
2135 input_bfd
, input_section
,
2136 (long) rel
->r_offset
, howto
->name
);
2140 value
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2142 /* Get the (signed) value from the instruction. */
2143 addend
= value
& howto
->src_mask
;
2144 if (addend
& ((howto
->src_mask
+ 1) >> 1))
2146 bfd_signed_vma mask
;
2149 mask
&= ~ howto
->src_mask
;
2154 _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
)
2156 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2157 value
= (value
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
2158 bfd_put_32 (input_bfd
, value
, contents
+ rel
->r_offset
);
2161 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2167 bfd_boolean unresolved_reloc
;
2169 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2170 r_symndx
, symtab_hdr
, sym_hashes
,
2172 unresolved_reloc
, warned
);
2174 if (unresolved_reloc
|| relocation
!= 0)
2176 /* In these cases, we don't need the relocation value.
2177 We check specially because in some obscure cases
2178 sec->output_section will be NULL. */
2183 case R_ARM_THM_PC22
:
2188 (!info
->symbolic
&& h
->dynindx
!= -1)
2189 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2191 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2192 && ((input_section
->flags
& SEC_ALLOC
) != 0
2193 /* DWARF will emit R_ARM_ABS32 relocations in its
2194 sections against symbols defined externally
2195 in shared libraries. We can't do anything
2197 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
2198 && (h
->elf_link_hash_flags
2199 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
2209 if ((WILL_CALL_FINISH_DYNAMIC_SYMBOL
2210 (elf_hash_table (info
)->dynamic_sections_created
,
2213 || (!info
->symbolic
&& h
->dynindx
!= -1)
2214 || (h
->elf_link_hash_flags
2215 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
2220 if (unresolved_reloc
)
2222 (_("%B(%A): warning: unresolvable relocation %d against symbol `%s'"),
2223 input_bfd
, input_section
,
2225 h
->root
.root
.string
);
2232 name
= h
->root
.root
.string
;
2235 name
= (bfd_elf_string_from_elf_section
2236 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2237 if (name
== NULL
|| *name
== '\0')
2238 name
= bfd_section_name (input_bfd
, sec
);
2241 r
= elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
2242 input_section
, contents
, rel
,
2243 relocation
, info
, sec
, name
,
2244 (h
? ELF_ST_TYPE (h
->type
) :
2245 ELF_ST_TYPE (sym
->st_info
)), h
);
2247 if (r
!= bfd_reloc_ok
)
2249 const char * msg
= (const char *) 0;
2253 case bfd_reloc_overflow
:
2254 /* If the overflowing reloc was to an undefined symbol,
2255 we have already printed one error message and there
2256 is no point complaining again. */
2258 h
->root
.type
!= bfd_link_hash_undefined
)
2259 && (!((*info
->callbacks
->reloc_overflow
)
2260 (info
, name
, howto
->name
, (bfd_vma
) 0,
2261 input_bfd
, input_section
, rel
->r_offset
))))
2265 case bfd_reloc_undefined
:
2266 if (!((*info
->callbacks
->undefined_symbol
)
2267 (info
, name
, input_bfd
, input_section
,
2268 rel
->r_offset
, TRUE
)))
2272 case bfd_reloc_outofrange
:
2273 msg
= _("internal error: out of range error");
2276 case bfd_reloc_notsupported
:
2277 msg
= _("internal error: unsupported relocation error");
2280 case bfd_reloc_dangerous
:
2281 msg
= _("internal error: dangerous error");
2285 msg
= _("internal error: unknown error");
2289 if (!((*info
->callbacks
->warning
)
2290 (info
, msg
, name
, input_bfd
, input_section
,
2301 /* Set the right machine number. */
2304 elf32_arm_object_p (abfd
)
2309 mach
= bfd_arm_get_mach_from_notes (abfd
, ARM_NOTE_SECTION
);
2311 if (mach
!= bfd_mach_arm_unknown
)
2312 bfd_default_set_arch_mach (abfd
, bfd_arch_arm
, mach
);
2314 else if (elf_elfheader (abfd
)->e_flags
& EF_ARM_MAVERICK_FLOAT
)
2315 bfd_default_set_arch_mach (abfd
, bfd_arch_arm
, bfd_mach_arm_ep9312
);
2318 bfd_default_set_arch_mach (abfd
, bfd_arch_arm
, mach
);
2323 /* Function to keep ARM specific flags in the ELF header. */
2325 elf32_arm_set_private_flags (abfd
, flags
)
2329 if (elf_flags_init (abfd
)
2330 && elf_elfheader (abfd
)->e_flags
!= flags
)
2332 if (EF_ARM_EABI_VERSION (flags
) == EF_ARM_EABI_UNKNOWN
)
2334 if (flags
& EF_ARM_INTERWORK
)
2335 (*_bfd_error_handler
)
2336 (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
2340 (_("Warning: Clearing the interworking flag of %B due to outside request"),
2346 elf_elfheader (abfd
)->e_flags
= flags
;
2347 elf_flags_init (abfd
) = TRUE
;
2353 /* Copy backend specific data from one object module to another. */
2356 elf32_arm_copy_private_bfd_data (ibfd
, obfd
)
2363 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2364 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2367 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2368 out_flags
= elf_elfheader (obfd
)->e_flags
;
2370 if (elf_flags_init (obfd
)
2371 && EF_ARM_EABI_VERSION (out_flags
) == EF_ARM_EABI_UNKNOWN
2372 && in_flags
!= out_flags
)
2374 /* Cannot mix APCS26 and APCS32 code. */
2375 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2378 /* Cannot mix float APCS and non-float APCS code. */
2379 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2382 /* If the src and dest have different interworking flags
2383 then turn off the interworking bit. */
2384 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2386 if (out_flags
& EF_ARM_INTERWORK
)
2388 (_("Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
2391 in_flags
&= ~EF_ARM_INTERWORK
;
2394 /* Likewise for PIC, though don't warn for this case. */
2395 if ((in_flags
& EF_ARM_PIC
) != (out_flags
& EF_ARM_PIC
))
2396 in_flags
&= ~EF_ARM_PIC
;
2399 elf_elfheader (obfd
)->e_flags
= in_flags
;
2400 elf_flags_init (obfd
) = TRUE
;
2405 /* Merge backend specific data from an object file to the output
2406 object file when linking. */
2409 elf32_arm_merge_private_bfd_data (ibfd
, obfd
)
2415 bfd_boolean flags_compatible
= TRUE
;
2418 /* Check if we have the same endianess. */
2419 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
2422 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2423 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2426 /* The input BFD must have had its flags initialised. */
2427 /* The following seems bogus to me -- The flags are initialized in
2428 the assembler but I don't think an elf_flags_init field is
2429 written into the object. */
2430 /* BFD_ASSERT (elf_flags_init (ibfd)); */
2432 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2433 out_flags
= elf_elfheader (obfd
)->e_flags
;
2435 if (!elf_flags_init (obfd
))
2437 /* If the input is the default architecture and had the default
2438 flags then do not bother setting the flags for the output
2439 architecture, instead allow future merges to do this. If no
2440 future merges ever set these flags then they will retain their
2441 uninitialised values, which surprise surprise, correspond
2442 to the default values. */
2443 if (bfd_get_arch_info (ibfd
)->the_default
2444 && elf_elfheader (ibfd
)->e_flags
== 0)
2447 elf_flags_init (obfd
) = TRUE
;
2448 elf_elfheader (obfd
)->e_flags
= in_flags
;
2450 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
2451 && bfd_get_arch_info (obfd
)->the_default
)
2452 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
), bfd_get_mach (ibfd
));
2457 /* Determine what should happen if the input ARM architecture
2458 does not match the output ARM architecture. */
2459 if (! bfd_arm_merge_machines (ibfd
, obfd
))
2462 /* Identical flags must be compatible. */
2463 if (in_flags
== out_flags
)
2466 /* Check to see if the input BFD actually contains any sections. If
2467 not, its flags may not have been initialised either, but it
2468 cannot actually cause any incompatibility. Do not short-circuit
2469 dynamic objects; their section list may be emptied by
2470 elf_link_add_object_symbols.
2472 Also check to see if there are no code sections in the input.
2473 In this case there is no need to check for code specific flags.
2474 XXX - do we need to worry about floating-point format compatability
2475 in data sections ? */
2476 if (!(ibfd
->flags
& DYNAMIC
))
2478 bfd_boolean null_input_bfd
= TRUE
;
2479 bfd_boolean only_data_sections
= TRUE
;
2481 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2483 /* Ignore synthetic glue sections. */
2484 if (strcmp (sec
->name
, ".glue_7")
2485 && strcmp (sec
->name
, ".glue_7t"))
2487 if ((bfd_get_section_flags (ibfd
, sec
)
2488 & (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
2489 == (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
2490 only_data_sections
= FALSE
;
2492 null_input_bfd
= FALSE
;
2497 if (null_input_bfd
|| only_data_sections
)
2501 /* Complain about various flag mismatches. */
2502 if (EF_ARM_EABI_VERSION (in_flags
) != EF_ARM_EABI_VERSION (out_flags
))
2505 (_("ERROR: %B is compiled for EABI version %d, whereas %B is compiled for version %d"),
2507 (in_flags
& EF_ARM_EABIMASK
) >> 24,
2508 (out_flags
& EF_ARM_EABIMASK
) >> 24);
2512 /* Not sure what needs to be checked for EABI versions >= 1. */
2513 if (EF_ARM_EABI_VERSION (in_flags
) == EF_ARM_EABI_UNKNOWN
)
2515 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2518 (_("ERROR: %B is compiled for APCS-%d, whereas target %B uses APCS-%d"),
2520 in_flags
& EF_ARM_APCS_26
? 26 : 32,
2521 out_flags
& EF_ARM_APCS_26
? 26 : 32);
2522 flags_compatible
= FALSE
;
2525 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2527 if (in_flags
& EF_ARM_APCS_FLOAT
)
2529 (_("ERROR: %B passes floats in float registers, whereas %B passes them in integer registers"),
2533 (_("ERROR: %B passes floats in integer registers, whereas %B passes them in float registers"),
2536 flags_compatible
= FALSE
;
2539 if ((in_flags
& EF_ARM_VFP_FLOAT
) != (out_flags
& EF_ARM_VFP_FLOAT
))
2541 if (in_flags
& EF_ARM_VFP_FLOAT
)
2543 (_("ERROR: %B uses VFP instructions, whereas %B does not"),
2547 (_("ERROR: %B uses FPA instructions, whereas %B does not"),
2550 flags_compatible
= FALSE
;
2553 if ((in_flags
& EF_ARM_MAVERICK_FLOAT
) != (out_flags
& EF_ARM_MAVERICK_FLOAT
))
2555 if (in_flags
& EF_ARM_MAVERICK_FLOAT
)
2557 (_("ERROR: %B uses Maverick instructions, whereas %B does not"),
2561 (_("ERROR: %B does not use Maverick instructions, whereas %B does"),
2564 flags_compatible
= FALSE
;
2567 #ifdef EF_ARM_SOFT_FLOAT
2568 if ((in_flags
& EF_ARM_SOFT_FLOAT
) != (out_flags
& EF_ARM_SOFT_FLOAT
))
2570 /* We can allow interworking between code that is VFP format
2571 layout, and uses either soft float or integer regs for
2572 passing floating point arguments and results. We already
2573 know that the APCS_FLOAT flags match; similarly for VFP
2575 if ((in_flags
& EF_ARM_APCS_FLOAT
) != 0
2576 || (in_flags
& EF_ARM_VFP_FLOAT
) == 0)
2578 if (in_flags
& EF_ARM_SOFT_FLOAT
)
2580 (_("ERROR: %B uses software FP, whereas %B uses hardware FP"),
2584 (_("ERROR: %B uses hardware FP, whereas %B uses software FP"),
2587 flags_compatible
= FALSE
;
2592 /* Interworking mismatch is only a warning. */
2593 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2595 if (in_flags
& EF_ARM_INTERWORK
)
2598 (_("Warning: %B supports interworking, whereas %B does not"),
2604 (_("Warning: %B does not support interworking, whereas %B does"),
2610 return flags_compatible
;
2613 /* Display the flags field. */
2616 elf32_arm_print_private_bfd_data (abfd
, ptr
)
2620 FILE * file
= (FILE *) ptr
;
2621 unsigned long flags
;
2623 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
2625 /* Print normal ELF private data. */
2626 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
2628 flags
= elf_elfheader (abfd
)->e_flags
;
2629 /* Ignore init flag - it may not be set, despite the flags field
2630 containing valid data. */
2632 /* xgettext:c-format */
2633 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
2635 switch (EF_ARM_EABI_VERSION (flags
))
2637 case EF_ARM_EABI_UNKNOWN
:
2638 /* The following flag bits are GNU extensions and not part of the
2639 official ARM ELF extended ABI. Hence they are only decoded if
2640 the EABI version is not set. */
2641 if (flags
& EF_ARM_INTERWORK
)
2642 fprintf (file
, _(" [interworking enabled]"));
2644 if (flags
& EF_ARM_APCS_26
)
2645 fprintf (file
, " [APCS-26]");
2647 fprintf (file
, " [APCS-32]");
2649 if (flags
& EF_ARM_VFP_FLOAT
)
2650 fprintf (file
, _(" [VFP float format]"));
2651 else if (flags
& EF_ARM_MAVERICK_FLOAT
)
2652 fprintf (file
, _(" [Maverick float format]"));
2654 fprintf (file
, _(" [FPA float format]"));
2656 if (flags
& EF_ARM_APCS_FLOAT
)
2657 fprintf (file
, _(" [floats passed in float registers]"));
2659 if (flags
& EF_ARM_PIC
)
2660 fprintf (file
, _(" [position independent]"));
2662 if (flags
& EF_ARM_NEW_ABI
)
2663 fprintf (file
, _(" [new ABI]"));
2665 if (flags
& EF_ARM_OLD_ABI
)
2666 fprintf (file
, _(" [old ABI]"));
2668 if (flags
& EF_ARM_SOFT_FLOAT
)
2669 fprintf (file
, _(" [software FP]"));
2671 flags
&= ~(EF_ARM_INTERWORK
| EF_ARM_APCS_26
| EF_ARM_APCS_FLOAT
2672 | EF_ARM_PIC
| EF_ARM_NEW_ABI
| EF_ARM_OLD_ABI
2673 | EF_ARM_SOFT_FLOAT
| EF_ARM_VFP_FLOAT
2674 | EF_ARM_MAVERICK_FLOAT
);
2677 case EF_ARM_EABI_VER1
:
2678 fprintf (file
, _(" [Version1 EABI]"));
2680 if (flags
& EF_ARM_SYMSARESORTED
)
2681 fprintf (file
, _(" [sorted symbol table]"));
2683 fprintf (file
, _(" [unsorted symbol table]"));
2685 flags
&= ~ EF_ARM_SYMSARESORTED
;
2688 case EF_ARM_EABI_VER2
:
2689 fprintf (file
, _(" [Version2 EABI]"));
2691 if (flags
& EF_ARM_SYMSARESORTED
)
2692 fprintf (file
, _(" [sorted symbol table]"));
2694 fprintf (file
, _(" [unsorted symbol table]"));
2696 if (flags
& EF_ARM_DYNSYMSUSESEGIDX
)
2697 fprintf (file
, _(" [dynamic symbols use segment index]"));
2699 if (flags
& EF_ARM_MAPSYMSFIRST
)
2700 fprintf (file
, _(" [mapping symbols precede others]"));
2702 flags
&= ~(EF_ARM_SYMSARESORTED
| EF_ARM_DYNSYMSUSESEGIDX
2703 | EF_ARM_MAPSYMSFIRST
);
2706 case EF_ARM_EABI_VER3
:
2707 fprintf (file
, _(" [Version3 EABI]"));
2709 if (flags
& EF_ARM_BE8
)
2710 fprintf (file
, _(" [BE8]"));
2712 if (flags
& EF_ARM_LE8
)
2713 fprintf (file
, _(" [LE8]"));
2715 flags
&= ~(EF_ARM_LE8
| EF_ARM_BE8
);
2719 fprintf (file
, _(" <EABI version unrecognised>"));
2723 flags
&= ~ EF_ARM_EABIMASK
;
2725 if (flags
& EF_ARM_RELEXEC
)
2726 fprintf (file
, _(" [relocatable executable]"));
2728 if (flags
& EF_ARM_HASENTRY
)
2729 fprintf (file
, _(" [has entry point]"));
2731 flags
&= ~ (EF_ARM_RELEXEC
| EF_ARM_HASENTRY
);
2734 fprintf (file
, _("<Unrecognised flag bits set>"));
2742 elf32_arm_get_symbol_type (elf_sym
, type
)
2743 Elf_Internal_Sym
* elf_sym
;
2746 switch (ELF_ST_TYPE (elf_sym
->st_info
))
2749 return ELF_ST_TYPE (elf_sym
->st_info
);
2752 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2753 This allows us to distinguish between data used by Thumb instructions
2754 and non-data (which is probably code) inside Thumb regions of an
2756 if (type
!= STT_OBJECT
)
2757 return ELF_ST_TYPE (elf_sym
->st_info
);
2768 elf32_arm_gc_mark_hook (sec
, info
, rel
, h
, sym
)
2770 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2771 Elf_Internal_Rela
*rel
;
2772 struct elf_link_hash_entry
*h
;
2773 Elf_Internal_Sym
*sym
;
2777 switch (ELF32_R_TYPE (rel
->r_info
))
2779 case R_ARM_GNU_VTINHERIT
:
2780 case R_ARM_GNU_VTENTRY
:
2784 switch (h
->root
.type
)
2786 case bfd_link_hash_defined
:
2787 case bfd_link_hash_defweak
:
2788 return h
->root
.u
.def
.section
;
2790 case bfd_link_hash_common
:
2791 return h
->root
.u
.c
.p
->section
;
2799 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
2804 /* Update the got entry reference counts for the section being removed. */
2807 elf32_arm_gc_sweep_hook (abfd
, info
, sec
, relocs
)
2808 bfd
*abfd ATTRIBUTE_UNUSED
;
2809 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2810 asection
*sec ATTRIBUTE_UNUSED
;
2811 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
;
2813 Elf_Internal_Shdr
*symtab_hdr
;
2814 struct elf_link_hash_entry
**sym_hashes
;
2815 bfd_signed_vma
*local_got_refcounts
;
2816 const Elf_Internal_Rela
*rel
, *relend
;
2817 unsigned long r_symndx
;
2818 struct elf_link_hash_entry
*h
;
2820 elf_section_data (sec
)->local_dynrel
= NULL
;
2822 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2823 sym_hashes
= elf_sym_hashes (abfd
);
2824 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2826 relend
= relocs
+ sec
->reloc_count
;
2827 for (rel
= relocs
; rel
< relend
; rel
++)
2828 switch (ELF32_R_TYPE (rel
->r_info
))
2831 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2832 if (r_symndx
>= symtab_hdr
->sh_info
)
2834 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2835 if (h
->got
.refcount
> 0)
2836 h
->got
.refcount
-= 1;
2838 else if (local_got_refcounts
!= NULL
)
2840 if (local_got_refcounts
[r_symndx
] > 0)
2841 local_got_refcounts
[r_symndx
] -= 1;
2849 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2850 if (r_symndx
>= symtab_hdr
->sh_info
)
2852 struct elf32_arm_link_hash_entry
*eh
;
2853 struct elf32_arm_relocs_copied
**pp
;
2854 struct elf32_arm_relocs_copied
*p
;
2856 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2858 if (h
->plt
.refcount
> 0)
2859 h
->plt
.refcount
-= 1;
2861 if (ELF32_R_TYPE (rel
->r_info
) == R_ARM_ABS32
2862 || ELF32_R_TYPE (rel
->r_info
) == R_ARM_REL32
)
2864 eh
= (struct elf32_arm_link_hash_entry
*) h
;
2866 for (pp
= &eh
->relocs_copied
; (p
= *pp
) != NULL
;
2868 if (p
->section
== sec
)
2886 /* Look through the relocs for a section during the first phase. */
2889 elf32_arm_check_relocs (abfd
, info
, sec
, relocs
)
2891 struct bfd_link_info
*info
;
2893 const Elf_Internal_Rela
*relocs
;
2895 Elf_Internal_Shdr
*symtab_hdr
;
2896 struct elf_link_hash_entry
**sym_hashes
;
2897 struct elf_link_hash_entry
**sym_hashes_end
;
2898 const Elf_Internal_Rela
*rel
;
2899 const Elf_Internal_Rela
*rel_end
;
2902 bfd_vma
*local_got_offsets
;
2903 struct elf32_arm_link_hash_table
*htab
;
2905 if (info
->relocatable
)
2908 htab
= elf32_arm_hash_table (info
);
2911 dynobj
= elf_hash_table (info
)->dynobj
;
2912 local_got_offsets
= elf_local_got_offsets (abfd
);
2914 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2915 sym_hashes
= elf_sym_hashes (abfd
);
2916 sym_hashes_end
= sym_hashes
2917 + symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
2919 if (!elf_bad_symtab (abfd
))
2920 sym_hashes_end
-= symtab_hdr
->sh_info
;
2922 rel_end
= relocs
+ sec
->reloc_count
;
2923 for (rel
= relocs
; rel
< rel_end
; rel
++)
2925 struct elf_link_hash_entry
*h
;
2926 unsigned long r_symndx
;
2928 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2929 if (r_symndx
< symtab_hdr
->sh_info
)
2932 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2934 switch (ELF32_R_TYPE (rel
->r_info
))
2937 /* This symbol requires a global offset table entry. */
2944 bfd_signed_vma
*local_got_refcounts
;
2946 /* This is a global offset table entry for a local symbol. */
2947 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2948 if (local_got_refcounts
== NULL
)
2952 size
= symtab_hdr
->sh_info
;
2953 size
*= (sizeof (bfd_signed_vma
) + sizeof(char));
2954 local_got_refcounts
= ((bfd_signed_vma
*)
2955 bfd_zalloc (abfd
, size
));
2956 if (local_got_refcounts
== NULL
)
2958 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
2960 local_got_refcounts
[r_symndx
] += 1;
2966 if (htab
->sgot
== NULL
)
2968 if (htab
->root
.dynobj
== NULL
)
2969 htab
->root
.dynobj
= abfd
;
2970 if (!create_got_section (htab
->root
.dynobj
, info
))
2981 /* If this reloc is in a read-only section, we might
2982 need a copy reloc. We can't check reliably at this
2983 stage whether the section is read-only, as input
2984 sections have not yet been mapped to output sections.
2985 Tentatively set the flag for now, and correct in
2986 adjust_dynamic_symbol. */
2988 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
2990 /* We may need a .plt entry if the function this reloc
2991 refers to is in a different object. We can't tell for
2992 sure yet, because something later might force the
2994 if (ELF32_R_TYPE (rel
->r_info
) == R_ARM_PC24
2995 || ELF32_R_TYPE (rel
->r_info
) == R_ARM_PLT32
)
2996 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2998 /* If we create a PLT entry, this relocation will reference
2999 it, even if it's an ABS32 relocation. */
3000 h
->plt
.refcount
+= 1;
3003 /* If we are creating a shared library, and this is a reloc
3004 against a global symbol, or a non PC relative reloc
3005 against a local symbol, then we need to copy the reloc
3006 into the shared library. However, if we are linking with
3007 -Bsymbolic, we do not need to copy a reloc against a
3008 global symbol which is defined in an object we are
3009 including in the link (i.e., DEF_REGULAR is set). At
3010 this point we have not seen all the input files, so it is
3011 possible that DEF_REGULAR is not set now but will be set
3012 later (it is never cleared). We account for that
3013 possibility below by storing information in the
3014 relocs_copied field of the hash table entry. */
3016 && (sec
->flags
& SEC_ALLOC
) != 0
3017 && ((ELF32_R_TYPE (rel
->r_info
) != R_ARM_PC24
3018 && ELF32_R_TYPE (rel
->r_info
) != R_ARM_PLT32
3019 && ELF32_R_TYPE (rel
->r_info
) != R_ARM_REL32
)
3021 && (! info
->symbolic
3022 || (h
->elf_link_hash_flags
3023 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
3025 struct elf32_arm_relocs_copied
*p
, **head
;
3027 /* When creating a shared object, we must copy these
3028 reloc types into the output file. We create a reloc
3029 section in dynobj and make room for this reloc. */
3034 name
= (bfd_elf_string_from_elf_section
3036 elf_elfheader (abfd
)->e_shstrndx
,
3037 elf_section_data (sec
)->rel_hdr
.sh_name
));
3041 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
3042 && strcmp (bfd_get_section_name (abfd
, sec
),
3045 sreloc
= bfd_get_section_by_name (dynobj
, name
);
3050 sreloc
= bfd_make_section (dynobj
, name
);
3051 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
3052 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3053 if ((sec
->flags
& SEC_ALLOC
) != 0)
3054 flags
|= SEC_ALLOC
| SEC_LOAD
;
3056 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
3057 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
3061 elf_section_data (sec
)->sreloc
= sreloc
;
3064 /* If this is a global symbol, we count the number of
3065 relocations we need for this symbol. */
3068 head
= &((struct elf32_arm_link_hash_entry
*) h
)->relocs_copied
;
3072 /* Track dynamic relocs needed for local syms too.
3073 We really need local syms available to do this
3077 s
= bfd_section_from_r_symndx (abfd
, &htab
->sym_sec
,
3082 head
= ((struct elf32_arm_relocs_copied
**)
3083 &elf_section_data (s
)->local_dynrel
);
3087 if (p
== NULL
|| p
->section
!= sec
)
3089 bfd_size_type amt
= sizeof *p
;
3090 p
= bfd_alloc (htab
->root
.dynobj
, amt
);
3099 if (ELF32_R_TYPE (rel
->r_info
) == R_ARM_ABS32
3100 || ELF32_R_TYPE (rel
->r_info
) == R_ARM_REL32
)
3105 /* This relocation describes the C++ object vtable hierarchy.
3106 Reconstruct it for later use during GC. */
3107 case R_ARM_GNU_VTINHERIT
:
3108 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
3112 /* This relocation describes which C++ vtable entries are actually
3113 used. Record for later use during GC. */
3114 case R_ARM_GNU_VTENTRY
:
3115 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
3124 /* Find the nearest line to a particular section and offset, for error
3125 reporting. This code is a duplicate of the code in elf.c, except
3126 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
3129 elf32_arm_find_nearest_line
3130 (abfd
, section
, symbols
, offset
, filename_ptr
, functionname_ptr
, line_ptr
)
3135 const char **filename_ptr
;
3136 const char **functionname_ptr
;
3137 unsigned int *line_ptr
;
3140 const char *filename
;
3145 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
3146 filename_ptr
, functionname_ptr
,
3148 &elf_tdata (abfd
)->dwarf2_find_line_info
))
3151 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
3152 &found
, filename_ptr
,
3153 functionname_ptr
, line_ptr
,
3154 &elf_tdata (abfd
)->line_info
))
3160 if (symbols
== NULL
)
3167 for (p
= symbols
; *p
!= NULL
; p
++)
3171 q
= (elf_symbol_type
*) *p
;
3173 if (bfd_get_section (&q
->symbol
) != section
)
3176 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
3181 filename
= bfd_asymbol_name (&q
->symbol
);
3186 if (q
->symbol
.section
== section
3187 && q
->symbol
.value
>= low_func
3188 && q
->symbol
.value
<= offset
)
3190 func
= (asymbol
*) q
;
3191 low_func
= q
->symbol
.value
;
3200 *filename_ptr
= filename
;
3201 *functionname_ptr
= bfd_asymbol_name (func
);
3207 /* Adjust a symbol defined by a dynamic object and referenced by a
3208 regular object. The current definition is in some section of the
3209 dynamic object, but we're not including those sections. We have to
3210 change the definition to something the rest of the link can
3214 elf32_arm_adjust_dynamic_symbol (info
, h
)
3215 struct bfd_link_info
* info
;
3216 struct elf_link_hash_entry
* h
;
3220 unsigned int power_of_two
;
3222 dynobj
= elf_hash_table (info
)->dynobj
;
3224 /* Make sure we know what is going on here. */
3225 BFD_ASSERT (dynobj
!= NULL
3226 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
3227 || h
->weakdef
!= NULL
3228 || ((h
->elf_link_hash_flags
3229 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
3230 && (h
->elf_link_hash_flags
3231 & ELF_LINK_HASH_REF_REGULAR
) != 0
3232 && (h
->elf_link_hash_flags
3233 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
3235 /* If this is a function, put it in the procedure linkage table. We
3236 will fill in the contents of the procedure linkage table later,
3237 when we know the address of the .got section. */
3238 if (h
->type
== STT_FUNC
3239 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
3241 if (h
->plt
.refcount
<= 0
3242 || SYMBOL_CALLS_LOCAL (info
, h
)
3243 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
3244 && h
->root
.type
== bfd_link_hash_undefweak
))
3246 /* This case can occur if we saw a PLT32 reloc in an input
3247 file, but the symbol was never referred to by a dynamic
3248 object, or if all references were garbage collected. In
3249 such a case, we don't actually need to build a procedure
3250 linkage table, and we can just do a PC24 reloc instead. */
3251 h
->plt
.offset
= (bfd_vma
) -1;
3252 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
3258 /* It's possible that we incorrectly decided a .plt reloc was
3259 needed for an R_ARM_PC24 reloc to a non-function sym in
3260 check_relocs. We can't decide accurately between function and
3261 non-function syms in check-relocs; Objects loaded later in
3262 the link may change h->type. So fix it now. */
3263 h
->plt
.offset
= (bfd_vma
) -1;
3265 /* If this is a weak symbol, and there is a real definition, the
3266 processor independent code will have arranged for us to see the
3267 real definition first, and we can just use the same value. */
3268 if (h
->weakdef
!= NULL
)
3270 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
3271 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
3272 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
3273 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
3277 /* This is a reference to a symbol defined by a dynamic object which
3278 is not a function. */
3280 /* If we are creating a shared library, we must presume that the
3281 only references to the symbol are via the global offset table.
3282 For such cases we need not do anything here; the relocations will
3283 be handled correctly by relocate_section. */
3287 /* We must allocate the symbol in our .dynbss section, which will
3288 become part of the .bss section of the executable. There will be
3289 an entry for this symbol in the .dynsym section. The dynamic
3290 object will contain position independent code, so all references
3291 from the dynamic object to this symbol will go through the global
3292 offset table. The dynamic linker will use the .dynsym entry to
3293 determine the address it must put in the global offset table, so
3294 both the dynamic object and the regular object will refer to the
3295 same memory location for the variable. */
3296 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
3297 BFD_ASSERT (s
!= NULL
);
3299 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
3300 copy the initial value out of the dynamic object and into the
3301 runtime process image. We need to remember the offset into the
3302 .rel.bss section we are going to use. */
3303 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
3307 srel
= bfd_get_section_by_name (dynobj
, ".rel.bss");
3308 BFD_ASSERT (srel
!= NULL
);
3309 srel
->size
+= sizeof (Elf32_External_Rel
);
3310 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
3313 /* We need to figure out the alignment required for this symbol. I
3314 have no idea how ELF linkers handle this. */
3315 power_of_two
= bfd_log2 (h
->size
);
3316 if (power_of_two
> 3)
3319 /* Apply the required alignment. */
3320 s
->size
= BFD_ALIGN (s
->size
, (bfd_size_type
) (1 << power_of_two
));
3321 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
3323 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
3327 /* Define the symbol as being at this point in the section. */
3328 h
->root
.u
.def
.section
= s
;
3329 h
->root
.u
.def
.value
= s
->size
;
3331 /* Increment the section size to make room for the symbol. */
3337 /* Allocate space in .plt, .got and associated reloc sections for
3341 allocate_dynrelocs (h
, inf
)
3342 struct elf_link_hash_entry
*h
;
3345 struct bfd_link_info
*info
;
3346 struct elf32_arm_link_hash_table
*htab
;
3347 struct elf32_arm_link_hash_entry
*eh
;
3348 struct elf32_arm_relocs_copied
*p
;
3350 if (h
->root
.type
== bfd_link_hash_indirect
)
3353 if (h
->root
.type
== bfd_link_hash_warning
)
3354 /* When warning symbols are created, they **replace** the "real"
3355 entry in the hash table, thus we never get to see the real
3356 symbol in a hash traversal. So look at it now. */
3357 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3359 info
= (struct bfd_link_info
*) inf
;
3360 htab
= elf32_arm_hash_table (info
);
3362 if (htab
->root
.dynamic_sections_created
3363 && h
->plt
.refcount
> 0)
3365 /* Make sure this symbol is output as a dynamic symbol.
3366 Undefined weak syms won't yet be marked as dynamic. */
3367 if (h
->dynindx
== -1
3368 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
3370 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3375 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
3377 asection
*s
= htab
->splt
;
3379 /* If this is the first .plt entry, make room for the special
3382 s
->size
+= PLT_HEADER_SIZE
;
3384 h
->plt
.offset
= s
->size
;
3386 /* If this symbol is not defined in a regular file, and we are
3387 not generating a shared library, then set the symbol to this
3388 location in the .plt. This is required to make function
3389 pointers compare as equal between the normal executable and
3390 the shared library. */
3392 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3394 h
->root
.u
.def
.section
= s
;
3395 h
->root
.u
.def
.value
= h
->plt
.offset
;
3398 /* Make room for this entry. */
3399 s
->size
+= PLT_ENTRY_SIZE
;
3401 /* We also need to make an entry in the .got.plt section, which
3402 will be placed in the .got section by the linker script. */
3403 htab
->sgotplt
->size
+= 4;
3405 /* We also need to make an entry in the .rel.plt section. */
3406 htab
->srelplt
->size
+= sizeof (Elf32_External_Rel
);
3410 h
->plt
.offset
= (bfd_vma
) -1;
3411 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
3416 h
->plt
.offset
= (bfd_vma
) -1;
3417 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
3420 if (h
->got
.refcount
> 0)
3425 /* Make sure this symbol is output as a dynamic symbol.
3426 Undefined weak syms won't yet be marked as dynamic. */
3427 if (h
->dynindx
== -1
3428 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
3430 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3435 h
->got
.offset
= s
->size
;
3437 dyn
= htab
->root
.dynamic_sections_created
;
3438 if ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3439 || h
->root
.type
!= bfd_link_hash_undefweak
)
3441 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
3442 htab
->srelgot
->size
+= sizeof (Elf32_External_Rel
);
3445 h
->got
.offset
= (bfd_vma
) -1;
3447 eh
= (struct elf32_arm_link_hash_entry
*) h
;
3448 if (eh
->relocs_copied
== NULL
)
3451 /* In the shared -Bsymbolic case, discard space allocated for
3452 dynamic pc-relative relocs against symbols which turn out to be
3453 defined in regular objects. For the normal shared case, discard
3454 space for pc-relative relocs that have become local due to symbol
3455 visibility changes. */
3459 /* Discard relocs on undefined weak syms with non-default
3461 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
3462 && h
->root
.type
== bfd_link_hash_undefweak
)
3463 eh
->relocs_copied
= NULL
;
3467 /* For the non-shared case, discard space for relocs against
3468 symbols which turn out to need copy relocs or are not
3471 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
3472 && (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
3473 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3474 || (htab
->root
.dynamic_sections_created
3475 && (h
->root
.type
== bfd_link_hash_undefweak
3476 || h
->root
.type
== bfd_link_hash_undefined
))))
3478 /* Make sure this symbol is output as a dynamic symbol.
3479 Undefined weak syms won't yet be marked as dynamic. */
3480 if (h
->dynindx
== -1
3481 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
3483 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3487 /* If that succeeded, we know we'll be keeping all the
3489 if (h
->dynindx
!= -1)
3493 eh
->relocs_copied
= NULL
;
3498 /* Finally, allocate space. */
3499 for (p
= eh
->relocs_copied
; p
!= NULL
; p
= p
->next
)
3501 asection
*sreloc
= elf_section_data (p
->section
)->sreloc
;
3502 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
3508 /* Set the sizes of the dynamic sections. */
3511 elf32_arm_size_dynamic_sections (output_bfd
, info
)
3512 bfd
* output_bfd ATTRIBUTE_UNUSED
;
3513 struct bfd_link_info
* info
;
3520 struct elf32_arm_link_hash_table
*htab
;
3522 htab
= elf32_arm_hash_table (info
);
3523 dynobj
= elf_hash_table (info
)->dynobj
;
3524 BFD_ASSERT (dynobj
!= NULL
);
3526 if (elf_hash_table (info
)->dynamic_sections_created
)
3528 /* Set the contents of the .interp section to the interpreter. */
3529 if (info
->executable
)
3531 s
= bfd_get_section_by_name (dynobj
, ".interp");
3532 BFD_ASSERT (s
!= NULL
);
3533 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
3534 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
3538 /* Set up .got offsets for local syms, and space for local dynamic
3540 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
3542 bfd_signed_vma
*local_got
;
3543 bfd_signed_vma
*end_local_got
;
3544 char *local_tls_type
;
3545 bfd_size_type locsymcount
;
3546 Elf_Internal_Shdr
*symtab_hdr
;
3549 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
3552 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3554 struct elf32_arm_relocs_copied
*p
;
3556 for (p
= *((struct elf32_arm_relocs_copied
**)
3557 &elf_section_data (s
)->local_dynrel
);
3561 if (!bfd_is_abs_section (p
->section
)
3562 && bfd_is_abs_section (p
->section
->output_section
))
3564 /* Input section has been discarded, either because
3565 it is a copy of a linkonce section or due to
3566 linker script /DISCARD/, so we'll be discarding
3569 else if (p
->count
!= 0)
3571 srel
= elf_section_data (p
->section
)->sreloc
;
3572 srel
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
3573 if ((p
->section
->output_section
->flags
& SEC_READONLY
) != 0)
3574 info
->flags
|= DF_TEXTREL
;
3579 local_got
= elf_local_got_refcounts (ibfd
);
3583 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
3584 locsymcount
= symtab_hdr
->sh_info
;
3585 end_local_got
= local_got
+ locsymcount
;
3587 srel
= htab
->srelgot
;
3588 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
3592 *local_got
= s
->size
;
3595 srel
->size
+= sizeof (Elf32_External_Rel
);
3598 *local_got
= (bfd_vma
) -1;
3602 /* Allocate global sym .plt and .got entries, and space for global
3603 sym dynamic relocs. */
3604 elf_link_hash_traverse (&htab
->root
, allocate_dynrelocs
, (PTR
) info
);
3606 /* The check_relocs and adjust_dynamic_symbol entry points have
3607 determined the sizes of the various dynamic sections. Allocate
3611 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3616 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3619 /* It's OK to base decisions on the section name, because none
3620 of the dynobj section names depend upon the input files. */
3621 name
= bfd_get_section_name (dynobj
, s
);
3625 if (strcmp (name
, ".plt") == 0)
3629 /* Strip this section if we don't need it; see the
3635 /* Remember whether there is a PLT. */
3639 else if (strncmp (name
, ".rel", 4) == 0)
3643 /* If we don't need this section, strip it from the
3644 output file. This is mostly to handle .rel.bss and
3645 .rel.plt. We must create both sections in
3646 create_dynamic_sections, because they must be created
3647 before the linker maps input sections to output
3648 sections. The linker does that before
3649 adjust_dynamic_symbol is called, and it is that
3650 function which decides whether anything needs to go
3651 into these sections. */
3656 /* Remember whether there are any reloc sections other
3658 if (strcmp (name
, ".rel.plt") != 0)
3661 /* We use the reloc_count field as a counter if we need
3662 to copy relocs into the output file. */
3666 else if (strncmp (name
, ".got", 4) != 0)
3668 /* It's not one of our sections, so don't allocate space. */
3674 _bfd_strip_section_from_output (info
, s
);
3678 /* Allocate memory for the section contents. */
3679 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3680 if (s
->contents
== NULL
&& s
->size
!= 0)
3684 if (elf_hash_table (info
)->dynamic_sections_created
)
3686 /* Add some entries to the .dynamic section. We fill in the
3687 values later, in elf32_arm_finish_dynamic_sections, but we
3688 must add the entries now so that we get the correct size for
3689 the .dynamic section. The DT_DEBUG entry is filled in by the
3690 dynamic linker and used by the debugger. */
3691 #define add_dynamic_entry(TAG, VAL) \
3692 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3696 if (!add_dynamic_entry (DT_DEBUG
, 0))
3702 if ( !add_dynamic_entry (DT_PLTGOT
, 0)
3703 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
3704 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
3705 || !add_dynamic_entry (DT_JMPREL
, 0))
3711 if ( !add_dynamic_entry (DT_REL
, 0)
3712 || !add_dynamic_entry (DT_RELSZ
, 0)
3713 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
3717 if ((info
->flags
& DF_TEXTREL
) != 0)
3719 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3721 info
->flags
|= DF_TEXTREL
;
3724 #undef add_synamic_entry
3729 /* Finish up dynamic symbol handling. We set the contents of various
3730 dynamic sections here. */
3733 elf32_arm_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
3735 struct bfd_link_info
* info
;
3736 struct elf_link_hash_entry
* h
;
3737 Elf_Internal_Sym
* sym
;
3741 dynobj
= elf_hash_table (info
)->dynobj
;
3743 if (h
->plt
.offset
!= (bfd_vma
) -1)
3750 Elf_Internal_Rela rel
;
3752 bfd_vma got_displacement
;
3754 /* This symbol has an entry in the procedure linkage table. Set
3757 BFD_ASSERT (h
->dynindx
!= -1);
3759 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3760 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3761 srel
= bfd_get_section_by_name (dynobj
, ".rel.plt");
3762 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
3764 /* Get the index in the procedure linkage table which
3765 corresponds to this symbol. This is the index of this symbol
3766 in all the symbols for which we are making plt entries. The
3767 first entry in the procedure linkage table is reserved. */
3768 plt_index
= (h
->plt
.offset
- PLT_HEADER_SIZE
) / PLT_ENTRY_SIZE
;
3770 /* Get the offset into the .got table of the entry that
3771 corresponds to this function. Each .got entry is 4 bytes.
3772 The first three are reserved. */
3773 got_offset
= (plt_index
+ 3) * 4;
3775 /* Calculate the displacement between the PLT slot and the
3776 entry in the GOT. */
3777 got_displacement
= (sgot
->output_section
->vma
3778 + sgot
->output_offset
3780 - splt
->output_section
->vma
3781 - splt
->output_offset
3785 BFD_ASSERT ((got_displacement
& 0xf0000000) == 0);
3787 /* Fill in the entry in the procedure linkage table. */
3788 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[0] | ((got_displacement
& 0x0ff00000) >> 20),
3789 splt
->contents
+ h
->plt
.offset
+ 0);
3790 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[1] | ((got_displacement
& 0x000ff000) >> 12),
3791 splt
->contents
+ h
->plt
.offset
+ 4);
3792 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[2] | (got_displacement
& 0x00000fff),
3793 splt
->contents
+ h
->plt
.offset
+ 8);
3794 #ifdef FOUR_WORD_PLT
3795 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[3],
3796 splt
->contents
+ h
->plt
.offset
+ 12);
3799 /* Fill in the entry in the global offset table. */
3800 bfd_put_32 (output_bfd
,
3801 (splt
->output_section
->vma
3802 + splt
->output_offset
),
3803 sgot
->contents
+ got_offset
);
3805 /* Fill in the entry in the .rel.plt section. */
3806 rel
.r_offset
= (sgot
->output_section
->vma
3807 + sgot
->output_offset
3809 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_JUMP_SLOT
);
3810 loc
= srel
->contents
+ plt_index
* sizeof (Elf32_External_Rel
);
3811 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3813 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3815 /* Mark the symbol as undefined, rather than as defined in
3816 the .plt section. Leave the value alone. */
3817 sym
->st_shndx
= SHN_UNDEF
;
3818 /* If the symbol is weak, we do need to clear the value.
3819 Otherwise, the PLT entry would provide a definition for
3820 the symbol even if the symbol wasn't defined anywhere,
3821 and so the symbol would never be NULL. */
3822 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR_NONWEAK
)
3828 if (h
->got
.offset
!= (bfd_vma
) -1)
3832 Elf_Internal_Rela rel
;
3835 /* This symbol has an entry in the global offset table. Set it
3837 sgot
= bfd_get_section_by_name (dynobj
, ".got");
3838 srel
= bfd_get_section_by_name (dynobj
, ".rel.got");
3839 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
3841 rel
.r_offset
= (sgot
->output_section
->vma
3842 + sgot
->output_offset
3843 + (h
->got
.offset
&~ (bfd_vma
) 1));
3845 /* If this is a static link, or it is a -Bsymbolic link and the
3846 symbol is defined locally or was forced to be local because
3847 of a version file, we just want to emit a RELATIVE reloc.
3848 The entry in the global offset table will already have been
3849 initialized in the relocate_section function. */
3851 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3853 BFD_ASSERT((h
->got
.offset
& 1) != 0);
3854 rel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
3858 BFD_ASSERT((h
->got
.offset
& 1) == 0);
3859 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
3860 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_GLOB_DAT
);
3863 loc
= srel
->contents
+ srel
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3864 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3867 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
3870 Elf_Internal_Rela rel
;
3873 /* This symbol needs a copy reloc. Set it up. */
3874 BFD_ASSERT (h
->dynindx
!= -1
3875 && (h
->root
.type
== bfd_link_hash_defined
3876 || h
->root
.type
== bfd_link_hash_defweak
));
3878 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
3880 BFD_ASSERT (s
!= NULL
);
3882 rel
.r_offset
= (h
->root
.u
.def
.value
3883 + h
->root
.u
.def
.section
->output_section
->vma
3884 + h
->root
.u
.def
.section
->output_offset
);
3885 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_COPY
);
3886 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3887 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3890 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3891 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3892 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
3893 sym
->st_shndx
= SHN_ABS
;
3898 /* Finish up the dynamic sections. */
3901 elf32_arm_finish_dynamic_sections (output_bfd
, info
)
3903 struct bfd_link_info
* info
;
3909 dynobj
= elf_hash_table (info
)->dynobj
;
3911 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3912 BFD_ASSERT (sgot
!= NULL
);
3913 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3915 if (elf_hash_table (info
)->dynamic_sections_created
)
3918 Elf32_External_Dyn
*dyncon
, *dynconend
;
3920 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3921 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3923 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3924 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
3926 for (; dyncon
< dynconend
; dyncon
++)
3928 Elf_Internal_Dyn dyn
;
3932 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3945 s
= bfd_get_section_by_name (output_bfd
, name
);
3946 BFD_ASSERT (s
!= NULL
);
3947 dyn
.d_un
.d_ptr
= s
->vma
;
3948 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3952 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3953 BFD_ASSERT (s
!= NULL
);
3954 dyn
.d_un
.d_val
= s
->size
;
3955 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3959 /* My reading of the SVR4 ABI indicates that the
3960 procedure linkage table relocs (DT_JMPREL) should be
3961 included in the overall relocs (DT_REL). This is
3962 what Solaris does. However, UnixWare can not handle
3963 that case. Therefore, we override the DT_RELSZ entry
3964 here to make it not include the JMPREL relocs. Since
3965 the linker script arranges for .rel.plt to follow all
3966 other relocation sections, we don't have to worry
3967 about changing the DT_REL entry. */
3968 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3970 dyn
.d_un
.d_val
-= s
->size
;
3971 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3974 /* Set the bottom bit of DT_INIT/FINI if the
3975 corresponding function is Thumb. */
3977 name
= info
->init_function
;
3980 name
= info
->fini_function
;
3982 /* If it wasn't set by elf_bfd_final_link
3983 then there is nothing to adjust. */
3984 if (dyn
.d_un
.d_val
!= 0)
3986 struct elf_link_hash_entry
* eh
;
3988 eh
= elf_link_hash_lookup (elf_hash_table (info
), name
,
3989 FALSE
, FALSE
, TRUE
);
3990 if (eh
!= (struct elf_link_hash_entry
*) NULL
3991 && ELF_ST_TYPE (eh
->type
) == STT_ARM_TFUNC
)
3993 dyn
.d_un
.d_val
|= 1;
3994 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4001 /* Fill in the first entry in the procedure linkage table. */
4004 bfd_vma got_displacement
;
4006 /* Calculate the displacement between the PLT slot and &GOT[0]. */
4007 got_displacement
= (sgot
->output_section
->vma
4008 + sgot
->output_offset
4009 - splt
->output_section
->vma
4010 - splt
->output_offset
4013 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[0], splt
->contents
+ 0);
4014 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[1], splt
->contents
+ 4);
4015 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[2], splt
->contents
+ 8);
4016 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[3], splt
->contents
+ 12);
4017 #ifdef FOUR_WORD_PLT
4018 /* The displacement value goes in the otherwise-unused last word of
4019 the second entry. */
4020 bfd_put_32 (output_bfd
, got_displacement
, splt
->contents
+ 28);
4022 bfd_put_32 (output_bfd
, got_displacement
, splt
->contents
+ 16);
4026 /* UnixWare sets the entsize of .plt to 4, although that doesn't
4027 really seem like the right value. */
4028 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
4031 /* Fill in the first three entries in the global offset table. */
4035 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
4037 bfd_put_32 (output_bfd
,
4038 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
4040 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
4041 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
4044 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
4050 elf32_arm_post_process_headers (abfd
, link_info
)
4052 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
;
4054 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
4055 struct elf32_arm_link_hash_table
*globals
;
4057 i_ehdrp
= elf_elfheader (abfd
);
4059 i_ehdrp
->e_ident
[EI_OSABI
] = ARM_ELF_OS_ABI_VERSION
;
4060 i_ehdrp
->e_ident
[EI_ABIVERSION
] = ARM_ELF_ABI_VERSION
;
4064 globals
= elf32_arm_hash_table (link_info
);
4065 if (globals
->byteswap_code
)
4066 i_ehdrp
->e_flags
|= EF_ARM_BE8
;
4070 static enum elf_reloc_type_class
4071 elf32_arm_reloc_type_class (rela
)
4072 const Elf_Internal_Rela
*rela
;
4074 switch ((int) ELF32_R_TYPE (rela
->r_info
))
4076 case R_ARM_RELATIVE
:
4077 return reloc_class_relative
;
4078 case R_ARM_JUMP_SLOT
:
4079 return reloc_class_plt
;
4081 return reloc_class_copy
;
4083 return reloc_class_normal
;
4087 static bfd_boolean elf32_arm_section_flags
PARAMS ((flagword
*, const Elf_Internal_Shdr
*));
4088 static void elf32_arm_final_write_processing
PARAMS ((bfd
*, bfd_boolean
));
4090 /* Set the right machine number for an Arm ELF file. */
4093 elf32_arm_section_flags (flags
, hdr
)
4095 const Elf_Internal_Shdr
*hdr
;
4097 if (hdr
->sh_type
== SHT_NOTE
)
4098 *flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_CONTENTS
;
4104 elf32_arm_final_write_processing (abfd
, linker
)
4106 bfd_boolean linker ATTRIBUTE_UNUSED
;
4108 bfd_arm_update_notes (abfd
, ARM_NOTE_SECTION
);
4112 /* Called for each symbol. Builds a section map based on mapping symbols.
4113 Does not alter any of the symbols. */
4116 elf32_arm_output_symbol_hook (struct bfd_link_info
*info
,
4118 Elf_Internal_Sym
*elfsym
,
4119 asection
*input_sec
,
4120 struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
4123 elf32_arm_section_map
*map
;
4124 struct elf32_arm_link_hash_table
*globals
;
4126 /* Only do this on final link. */
4127 if (info
->relocatable
)
4130 /* Only build a map if we need to byteswap code. */
4131 globals
= elf32_arm_hash_table (info
);
4132 if (!globals
->byteswap_code
)
4135 /* We only want mapping symbols. */
4143 mapcount
= ++(elf32_arm_section_data (input_sec
)->mapcount
);
4144 map
= elf32_arm_section_data (input_sec
)->map
;
4145 /* TODO: This may be inefficient, but we probably don't usually have many
4146 mapping symbols per section. */
4147 map
= bfd_realloc (map
, mapcount
* sizeof (elf32_arm_section_map
));
4148 elf32_arm_section_data (input_sec
)->map
= map
;
4150 map
[mapcount
- 1].vma
= elfsym
->st_value
;
4151 map
[mapcount
- 1].type
= name
[1];
4156 /* Allocate target specific section data. */
4159 elf32_arm_new_section_hook (bfd
*abfd
, asection
*sec
)
4161 struct _arm_elf_section_data
*sdata
;
4162 bfd_size_type amt
= sizeof (*sdata
);
4164 sdata
= bfd_zalloc (abfd
, amt
);
4167 sec
->used_by_bfd
= sdata
;
4169 return _bfd_elf_new_section_hook (abfd
, sec
);
4173 /* Used to order a list of mapping symbols by address. */
4176 elf32_arm_compare_mapping (const void * a
, const void * b
)
4178 return ((const elf32_arm_section_map
*) a
)->vma
4179 > ((const elf32_arm_section_map
*) b
)->vma
;
4183 /* Do code byteswapping. Return FALSE afterwards so that the section is
4184 written out as normal. */
4187 elf32_arm_write_section (bfd
*output_bfd ATTRIBUTE_UNUSED
, asection
*sec
,
4191 elf32_arm_section_map
*map
;
4198 mapcount
= elf32_arm_section_data (sec
)->mapcount
;
4199 map
= elf32_arm_section_data (sec
)->map
;
4204 qsort (map
, mapcount
, sizeof (elf32_arm_section_map
),
4205 elf32_arm_compare_mapping
);
4207 offset
= sec
->output_section
->vma
+ sec
->output_offset
;
4208 ptr
= map
[0].vma
- offset
;
4209 for (i
= 0; i
< mapcount
; i
++)
4211 if (i
== mapcount
- 1)
4214 end
= map
[i
+ 1].vma
- offset
;
4216 switch (map
[i
].type
)
4219 /* Byte swap code words. */
4220 while (ptr
+ 3 < end
)
4222 tmp
= contents
[ptr
];
4223 contents
[ptr
] = contents
[ptr
+ 3];
4224 contents
[ptr
+ 3] = tmp
;
4225 tmp
= contents
[ptr
+ 1];
4226 contents
[ptr
+ 1] = contents
[ptr
+ 2];
4227 contents
[ptr
+ 2] = tmp
;
4233 /* Byte swap code halfwords. */
4234 while (ptr
+ 1 < end
)
4236 tmp
= contents
[ptr
];
4237 contents
[ptr
] = contents
[ptr
+ 1];
4238 contents
[ptr
+ 1] = tmp
;
4244 /* Leave data alone. */
4253 #define ELF_ARCH bfd_arch_arm
4254 #define ELF_MACHINE_CODE EM_ARM
4255 #ifdef __QNXTARGET__
4256 #define ELF_MAXPAGESIZE 0x1000
4258 #define ELF_MAXPAGESIZE 0x8000
4261 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
4262 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
4263 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
4264 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
4265 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
4266 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
4267 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
4268 #define bfd_elf32_new_section_hook elf32_arm_new_section_hook
4270 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
4271 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
4272 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
4273 #define elf_backend_check_relocs elf32_arm_check_relocs
4274 #define elf_backend_relocate_section elf32_arm_relocate_section
4275 #define elf_backend_write_section elf32_arm_write_section
4276 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
4277 #define elf_backend_create_dynamic_sections elf32_arm_create_dynamic_sections
4278 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
4279 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
4280 #define elf_backend_link_output_symbol_hook elf32_arm_output_symbol_hook
4281 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
4282 #define elf_backend_post_process_headers elf32_arm_post_process_headers
4283 #define elf_backend_reloc_type_class elf32_arm_reloc_type_class
4284 #define elf_backend_object_p elf32_arm_object_p
4285 #define elf_backend_section_flags elf32_arm_section_flags
4286 #define elf_backend_final_write_processing elf32_arm_final_write_processing
4287 #define elf_backend_copy_indirect_symbol elf32_arm_copy_indirect_symbol
4289 #define elf_backend_can_refcount 1
4290 #define elf_backend_can_gc_sections 1
4291 #define elf_backend_plt_readonly 1
4292 #define elf_backend_want_got_plt 1
4293 #define elf_backend_want_plt_sym 0
4295 #define elf_backend_rela_normal 1
4298 #define elf_backend_got_header_size 12
4300 #include "elf32-target.h"