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
) (_("%s: unable to find THUMB glue '%s' for `%s'"),
490 bfd_archive_filename (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
) (_("%s: unable to find ARM glue '%s' for `%s'"),
525 bfd_archive_filename (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
))
867 _("%s: BE8 images only valid in big-endian mode."),
868 bfd_archive_filename (abfd
));
871 globals
->byteswap_code
= byteswap_code
;
873 /* Rummage around all the relocs and map the glue vectors. */
874 sec
= abfd
->sections
;
879 for (; sec
!= NULL
; sec
= sec
->next
)
881 if (sec
->reloc_count
== 0)
884 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
886 /* Load the relocs. */
888 = _bfd_elf_link_read_relocs (abfd
, sec
, (PTR
) NULL
,
889 (Elf_Internal_Rela
*) NULL
, FALSE
);
891 if (internal_relocs
== NULL
)
894 irelend
= internal_relocs
+ sec
->reloc_count
;
895 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
898 unsigned long r_index
;
900 struct elf_link_hash_entry
*h
;
902 r_type
= ELF32_R_TYPE (irel
->r_info
);
903 r_index
= ELF32_R_SYM (irel
->r_info
);
905 /* These are the only relocation types we care about. */
906 if ( r_type
!= R_ARM_PC24
907 && r_type
!= R_ARM_THM_PC22
)
910 /* Get the section contents if we haven't done so already. */
911 if (contents
== NULL
)
913 /* Get cached copy if it exists. */
914 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
915 contents
= elf_section_data (sec
)->this_hdr
.contents
;
918 /* Go get them off disk. */
919 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
924 /* If the relocation is not against a symbol it cannot concern us. */
927 /* We don't care about local symbols. */
928 if (r_index
< symtab_hdr
->sh_info
)
931 /* This is an external symbol. */
932 r_index
-= symtab_hdr
->sh_info
;
933 h
= (struct elf_link_hash_entry
*)
934 elf_sym_hashes (abfd
)[r_index
];
936 /* If the relocation is against a static symbol it must be within
937 the current section and so cannot be a cross ARM/Thumb relocation. */
944 /* This one is a call from arm code. We need to look up
945 the target of the call. If it is a thumb target, we
947 if (ELF_ST_TYPE(h
->type
) == STT_ARM_TFUNC
)
948 record_arm_to_thumb_glue (link_info
, h
);
952 /* This one is a call from thumb code. We look
953 up the target of the call. If it is not a thumb
954 target, we insert glue. */
955 if (ELF_ST_TYPE (h
->type
) != STT_ARM_TFUNC
)
956 record_thumb_to_arm_glue (link_info
, h
);
965 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
969 if (internal_relocs
!= NULL
970 && elf_section_data (sec
)->relocs
!= internal_relocs
)
971 free (internal_relocs
);
972 internal_relocs
= NULL
;
979 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
981 if (internal_relocs
!= NULL
982 && elf_section_data (sec
)->relocs
!= internal_relocs
)
983 free (internal_relocs
);
989 /* The thumb form of a long branch is a bit finicky, because the offset
990 encoding is split over two fields, each in it's own instruction. They
991 can occur in any order. So given a thumb form of long branch, and an
992 offset, insert the offset into the thumb branch and return finished
995 It takes two thumb instructions to encode the target address. Each has
996 11 bits to invest. The upper 11 bits are stored in one (identified by
997 H-0.. see below), the lower 11 bits are stored in the other (identified
1000 Combine together and shifted left by 1 (it's a half word address) and
1004 H-0, upper address-0 = 000
1006 H-1, lower address-0 = 800
1008 They can be ordered either way, but the arm tools I've seen always put
1009 the lower one first. It probably doesn't matter. krk@cygnus.com
1011 XXX: Actually the order does matter. The second instruction (H-1)
1012 moves the computed address into the PC, so it must be the second one
1013 in the sequence. The problem, however is that whilst little endian code
1014 stores the instructions in HI then LOW order, big endian code does the
1015 reverse. nickc@cygnus.com. */
1017 #define LOW_HI_ORDER 0xF800F000
1018 #define HI_LOW_ORDER 0xF000F800
1021 insert_thumb_branch (br_insn
, rel_off
)
1025 unsigned int low_bits
;
1026 unsigned int high_bits
;
1028 BFD_ASSERT ((rel_off
& 1) != 1);
1030 rel_off
>>= 1; /* Half word aligned address. */
1031 low_bits
= rel_off
& 0x000007FF; /* The bottom 11 bits. */
1032 high_bits
= (rel_off
>> 11) & 0x000007FF; /* The top 11 bits. */
1034 if ((br_insn
& LOW_HI_ORDER
) == LOW_HI_ORDER
)
1035 br_insn
= LOW_HI_ORDER
| (low_bits
<< 16) | high_bits
;
1036 else if ((br_insn
& HI_LOW_ORDER
) == HI_LOW_ORDER
)
1037 br_insn
= HI_LOW_ORDER
| (high_bits
<< 16) | low_bits
;
1039 /* FIXME: abort is probably not the right call. krk@cygnus.com */
1040 abort (); /* error - not a valid branch instruction form. */
1045 /* Thumb code calling an ARM function. */
1048 elf32_thumb_to_arm_stub (info
, name
, input_bfd
, output_bfd
, input_section
,
1049 hit_data
, sym_sec
, offset
, addend
, val
)
1050 struct bfd_link_info
* info
;
1054 asection
* input_section
;
1055 bfd_byte
* hit_data
;
1058 bfd_signed_vma addend
;
1063 unsigned long int tmp
;
1064 long int ret_offset
;
1065 struct elf_link_hash_entry
* myh
;
1066 struct elf32_arm_link_hash_table
* globals
;
1068 myh
= find_thumb_glue (info
, name
, input_bfd
);
1072 globals
= elf32_arm_hash_table (info
);
1074 BFD_ASSERT (globals
!= NULL
);
1075 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
1077 my_offset
= myh
->root
.u
.def
.value
;
1079 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
1080 THUMB2ARM_GLUE_SECTION_NAME
);
1082 BFD_ASSERT (s
!= NULL
);
1083 BFD_ASSERT (s
->contents
!= NULL
);
1084 BFD_ASSERT (s
->output_section
!= NULL
);
1086 if ((my_offset
& 0x01) == 0x01)
1089 && sym_sec
->owner
!= NULL
1090 && !INTERWORK_FLAG (sym_sec
->owner
))
1092 (*_bfd_error_handler
)
1093 (_("%s(%s): warning: interworking not enabled."),
1094 bfd_archive_filename (sym_sec
->owner
), name
);
1095 (*_bfd_error_handler
)
1096 (_(" first occurrence: %s: thumb call to arm"),
1097 bfd_archive_filename (input_bfd
));
1103 myh
->root
.u
.def
.value
= my_offset
;
1105 bfd_put_16 (output_bfd
, (bfd_vma
) t2a1_bx_pc_insn
,
1106 s
->contents
+ my_offset
);
1108 bfd_put_16 (output_bfd
, (bfd_vma
) t2a2_noop_insn
,
1109 s
->contents
+ my_offset
+ 2);
1112 /* Address of destination of the stub. */
1113 ((bfd_signed_vma
) val
)
1115 /* Offset from the start of the current section to the start of the stubs. */
1117 /* Offset of the start of this stub from the start of the stubs. */
1119 /* Address of the start of the current section. */
1120 + s
->output_section
->vma
)
1121 /* The branch instruction is 4 bytes into the stub. */
1123 /* ARM branches work from the pc of the instruction + 8. */
1126 bfd_put_32 (output_bfd
,
1127 (bfd_vma
) t2a3_b_insn
| ((ret_offset
>> 2) & 0x00FFFFFF),
1128 s
->contents
+ my_offset
+ 4);
1131 BFD_ASSERT (my_offset
<= globals
->thumb_glue_size
);
1133 /* Now go back and fix up the original BL insn to point to here. */
1135 /* Address of where the stub is located. */
1136 (s
->output_section
->vma
+ s
->output_offset
+ my_offset
)
1137 /* Address of where the BL is located. */
1138 - (input_section
->output_section
->vma
+ input_section
->output_offset
+ offset
)
1139 /* Addend in the relocation. */
1141 /* Biassing for PC-relative addressing. */
1144 tmp
= bfd_get_32 (input_bfd
, hit_data
1145 - input_section
->vma
);
1147 bfd_put_32 (output_bfd
,
1148 (bfd_vma
) insert_thumb_branch (tmp
, ret_offset
),
1149 hit_data
- input_section
->vma
);
1154 /* Arm code calling a Thumb function. */
1157 elf32_arm_to_thumb_stub (info
, name
, input_bfd
, output_bfd
, input_section
,
1158 hit_data
, sym_sec
, offset
, addend
, val
)
1159 struct bfd_link_info
* info
;
1163 asection
* input_section
;
1164 bfd_byte
* hit_data
;
1167 bfd_signed_vma addend
;
1170 unsigned long int tmp
;
1173 long int ret_offset
;
1174 struct elf_link_hash_entry
* myh
;
1175 struct elf32_arm_link_hash_table
* globals
;
1177 myh
= find_arm_glue (info
, name
, input_bfd
);
1181 globals
= elf32_arm_hash_table (info
);
1183 BFD_ASSERT (globals
!= NULL
);
1184 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
1186 my_offset
= myh
->root
.u
.def
.value
;
1187 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
1188 ARM2THUMB_GLUE_SECTION_NAME
);
1189 BFD_ASSERT (s
!= NULL
);
1190 BFD_ASSERT (s
->contents
!= NULL
);
1191 BFD_ASSERT (s
->output_section
!= NULL
);
1193 if ((my_offset
& 0x01) == 0x01)
1196 && sym_sec
->owner
!= NULL
1197 && !INTERWORK_FLAG (sym_sec
->owner
))
1199 (*_bfd_error_handler
)
1200 (_("%s(%s): warning: interworking not enabled."),
1201 bfd_archive_filename (sym_sec
->owner
), name
);
1202 (*_bfd_error_handler
)
1203 (_(" first occurrence: %s: arm call to thumb"),
1204 bfd_archive_filename (input_bfd
));
1208 myh
->root
.u
.def
.value
= my_offset
;
1210 bfd_put_32 (output_bfd
, (bfd_vma
) a2t1_ldr_insn
,
1211 s
->contents
+ my_offset
);
1213 bfd_put_32 (output_bfd
, (bfd_vma
) a2t2_bx_r12_insn
,
1214 s
->contents
+ my_offset
+ 4);
1216 /* It's a thumb address. Add the low order bit. */
1217 bfd_put_32 (output_bfd
, val
| a2t3_func_addr_insn
,
1218 s
->contents
+ my_offset
+ 8);
1221 BFD_ASSERT (my_offset
<= globals
->arm_glue_size
);
1223 tmp
= bfd_get_32 (input_bfd
, hit_data
);
1224 tmp
= tmp
& 0xFF000000;
1226 /* Somehow these are both 4 too far, so subtract 8. */
1227 ret_offset
= (s
->output_offset
1229 + s
->output_section
->vma
1230 - (input_section
->output_offset
1231 + input_section
->output_section
->vma
1235 tmp
= tmp
| ((ret_offset
>> 2) & 0x00FFFFFF);
1237 bfd_put_32 (output_bfd
, (bfd_vma
) tmp
, hit_data
- input_section
->vma
);
1242 /* Perform a relocation as part of a final link. */
1244 static bfd_reloc_status_type
1245 elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
1246 input_section
, contents
, rel
, value
,
1247 info
, sym_sec
, sym_name
, sym_flags
, h
)
1248 reloc_howto_type
* howto
;
1251 asection
* input_section
;
1252 bfd_byte
* contents
;
1253 Elf_Internal_Rela
* rel
;
1255 struct bfd_link_info
* info
;
1257 const char * sym_name
;
1259 struct elf_link_hash_entry
* h
;
1261 unsigned long r_type
= howto
->type
;
1262 unsigned long r_symndx
;
1263 bfd_byte
* hit_data
= contents
+ rel
->r_offset
;
1264 bfd
* dynobj
= NULL
;
1265 Elf_Internal_Shdr
* symtab_hdr
;
1266 struct elf_link_hash_entry
** sym_hashes
;
1267 bfd_vma
* local_got_offsets
;
1268 asection
* sgot
= NULL
;
1269 asection
* splt
= NULL
;
1270 asection
* sreloc
= NULL
;
1272 bfd_signed_vma signed_addend
;
1273 struct elf32_arm_link_hash_table
* globals
;
1275 /* If the start address has been set, then set the EF_ARM_HASENTRY
1276 flag. Setting this more than once is redundant, but the cost is
1277 not too high, and it keeps the code simple.
1279 The test is done here, rather than somewhere else, because the
1280 start address is only set just before the final link commences.
1282 Note - if the user deliberately sets a start address of 0, the
1283 flag will not be set. */
1284 if (bfd_get_start_address (output_bfd
) != 0)
1285 elf_elfheader (output_bfd
)->e_flags
|= EF_ARM_HASENTRY
;
1287 globals
= elf32_arm_hash_table (info
);
1289 dynobj
= elf_hash_table (info
)->dynobj
;
1292 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1293 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1295 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1296 sym_hashes
= elf_sym_hashes (input_bfd
);
1297 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1298 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1301 addend
= bfd_get_32 (input_bfd
, hit_data
) & howto
->src_mask
;
1303 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1306 signed_addend
&= ~ howto
->src_mask
;
1307 signed_addend
|= addend
;
1310 signed_addend
= addend
;
1312 addend
= signed_addend
= rel
->r_addend
;
1318 return bfd_reloc_ok
;
1327 /* r_symndx will be zero only for relocs against symbols
1328 from removed linkonce sections, or sections discarded by
1331 return bfd_reloc_ok
;
1333 /* Handle relocations which should use the PLT entry. ABS32/REL32
1334 will use the symbol's value, which may point to a PLT entry, but we
1335 don't need to handle that here. If we created a PLT entry, all
1336 branches in this object should go to it. */
1337 if ((r_type
!= R_ARM_ABS32
&& r_type
!= R_ARM_REL32
)
1340 && h
->plt
.offset
!= (bfd_vma
) -1)
1342 /* If we've created a .plt section, and assigned a PLT entry to
1343 this function, it should not be known to bind locally. If
1344 it were, we would have cleared the PLT entry. */
1345 BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info
, h
));
1347 value
= (splt
->output_section
->vma
1348 + splt
->output_offset
1350 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1351 contents
, rel
->r_offset
, value
,
1355 /* When generating a shared object, these relocations are copied
1356 into the output file to be resolved at run time. */
1358 && (input_section
->flags
& SEC_ALLOC
)
1359 && (r_type
!= R_ARM_REL32
1360 || !SYMBOL_CALLS_LOCAL (info
, h
))
1362 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
1363 || h
->root
.type
!= bfd_link_hash_undefweak
)
1364 && r_type
!= R_ARM_PC24
1365 && r_type
!= R_ARM_PLT32
)
1367 Elf_Internal_Rela outrel
;
1369 bfd_boolean skip
, relocate
;
1375 name
= (bfd_elf_string_from_elf_section
1377 elf_elfheader (input_bfd
)->e_shstrndx
,
1378 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1380 return bfd_reloc_notsupported
;
1382 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
1383 && strcmp (bfd_get_section_name (input_bfd
,
1387 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1388 BFD_ASSERT (sreloc
!= NULL
);
1395 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
1397 if (outrel
.r_offset
== (bfd_vma
) -1)
1399 else if (outrel
.r_offset
== (bfd_vma
) -2)
1400 skip
= TRUE
, relocate
= TRUE
;
1401 outrel
.r_offset
+= (input_section
->output_section
->vma
1402 + input_section
->output_offset
);
1405 memset (&outrel
, 0, sizeof outrel
);
1410 || (h
->elf_link_hash_flags
1411 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1412 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1415 /* This symbol is local, or marked to become local. */
1417 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1420 loc
= sreloc
->contents
;
1421 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
1422 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
1424 /* If this reloc is against an external symbol, we do not want to
1425 fiddle with the addend. Otherwise, we need to include the symbol
1426 value so that it becomes an addend for the dynamic reloc. */
1428 return bfd_reloc_ok
;
1430 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1431 contents
, rel
->r_offset
, value
,
1434 else switch (r_type
)
1437 case R_ARM_XPC25
: /* Arm BLX instruction. */
1439 case R_ARM_PC24
: /* Arm B/BL instruction */
1442 if (r_type
== R_ARM_XPC25
)
1444 /* Check for Arm calling Arm function. */
1445 /* FIXME: Should we translate the instruction into a BL
1446 instruction instead ? */
1447 if (sym_flags
!= STT_ARM_TFUNC
)
1448 (*_bfd_error_handler
) (_("\
1449 %s: Warning: Arm BLX instruction targets Arm function '%s'."),
1450 bfd_archive_filename (input_bfd
),
1451 h
? h
->root
.root
.string
: "(local)");
1456 /* Check for Arm calling Thumb function. */
1457 if (sym_flags
== STT_ARM_TFUNC
)
1459 elf32_arm_to_thumb_stub (info
, sym_name
, input_bfd
, output_bfd
,
1460 input_section
, hit_data
, sym_sec
, rel
->r_offset
,
1461 signed_addend
, value
);
1462 return bfd_reloc_ok
;
1466 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1467 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0)
1469 /* The old way of doing things. Trearing the addend as a
1470 byte sized field and adding in the pipeline offset. */
1471 value
-= (input_section
->output_section
->vma
1472 + input_section
->output_offset
);
1473 value
-= rel
->r_offset
;
1476 if (! globals
->no_pipeline_knowledge
)
1481 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
1483 S is the address of the symbol in the relocation.
1484 P is address of the instruction being relocated.
1485 A is the addend (extracted from the instruction) in bytes.
1487 S is held in 'value'.
1488 P is the base address of the section containing the instruction
1489 plus the offset of the reloc into that section, ie:
1490 (input_section->output_section->vma +
1491 input_section->output_offset +
1493 A is the addend, converted into bytes, ie:
1496 Note: None of these operations have knowledge of the pipeline
1497 size of the processor, thus it is up to the assembler to encode
1498 this information into the addend. */
1499 value
-= (input_section
->output_section
->vma
1500 + input_section
->output_offset
);
1501 value
-= rel
->r_offset
;
1502 value
+= (signed_addend
<< howto
->size
);
1504 /* Previous versions of this code also used to add in the pipeline
1505 offset here. This is wrong because the linker is not supposed
1506 to know about such things, and one day it might change. In order
1507 to support old binaries that need the old behaviour however, so
1508 we attempt to detect which ABI was used to create the reloc. */
1509 if (! globals
->no_pipeline_knowledge
)
1511 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form */
1513 i_ehdrp
= elf_elfheader (input_bfd
);
1515 if (i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1520 signed_addend
= value
;
1521 signed_addend
>>= howto
->rightshift
;
1523 /* It is not an error for an undefined weak reference to be
1524 out of range. Any program that branches to such a symbol
1525 is going to crash anyway, so there is no point worrying
1526 about getting the destination exactly right. */
1527 if (! h
|| h
->root
.type
!= bfd_link_hash_undefweak
)
1529 /* Perform a signed range check. */
1530 if ( signed_addend
> ((bfd_signed_vma
) (howto
->dst_mask
>> 1))
1531 || signed_addend
< - ((bfd_signed_vma
) ((howto
->dst_mask
+ 1) >> 1)))
1532 return bfd_reloc_overflow
;
1536 /* If necessary set the H bit in the BLX instruction. */
1537 if (r_type
== R_ARM_XPC25
&& ((value
& 2) == 2))
1538 value
= (signed_addend
& howto
->dst_mask
)
1539 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
))
1543 value
= (signed_addend
& howto
->dst_mask
)
1544 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1549 if (sym_flags
== STT_ARM_TFUNC
)
1554 value
-= (input_section
->output_section
->vma
1555 + input_section
->output_offset
+ rel
->r_offset
);
1560 bfd_put_32 (input_bfd
, value
, hit_data
);
1561 return bfd_reloc_ok
;
1565 if ((long) value
> 0x7f || (long) value
< -0x80)
1566 return bfd_reloc_overflow
;
1568 bfd_put_8 (input_bfd
, value
, hit_data
);
1569 return bfd_reloc_ok
;
1574 if ((long) value
> 0x7fff || (long) value
< -0x8000)
1575 return bfd_reloc_overflow
;
1577 bfd_put_16 (input_bfd
, value
, hit_data
);
1578 return bfd_reloc_ok
;
1581 /* Support ldr and str instruction for the arm */
1582 /* Also thumb b (unconditional branch). ??? Really? */
1585 if ((long) value
> 0x7ff || (long) value
< -0x800)
1586 return bfd_reloc_overflow
;
1588 value
|= (bfd_get_32 (input_bfd
, hit_data
) & 0xfffff000);
1589 bfd_put_32 (input_bfd
, value
, hit_data
);
1590 return bfd_reloc_ok
;
1592 case R_ARM_THM_ABS5
:
1593 /* Support ldr and str instructions for the thumb. */
1595 /* Need to refetch addend. */
1596 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1597 /* ??? Need to determine shift amount from operand size. */
1598 addend
>>= howto
->rightshift
;
1602 /* ??? Isn't value unsigned? */
1603 if ((long) value
> 0x1f || (long) value
< -0x10)
1604 return bfd_reloc_overflow
;
1606 /* ??? Value needs to be properly shifted into place first. */
1607 value
|= bfd_get_16 (input_bfd
, hit_data
) & 0xf83f;
1608 bfd_put_16 (input_bfd
, value
, hit_data
);
1609 return bfd_reloc_ok
;
1612 case R_ARM_THM_XPC22
:
1614 case R_ARM_THM_PC22
:
1615 /* Thumb BL (branch long instruction). */
1618 bfd_boolean overflow
= FALSE
;
1619 bfd_vma upper_insn
= bfd_get_16 (input_bfd
, hit_data
);
1620 bfd_vma lower_insn
= bfd_get_16 (input_bfd
, hit_data
+ 2);
1621 bfd_signed_vma reloc_signed_max
= ((1 << (howto
->bitsize
- 1)) - 1) >> howto
->rightshift
;
1622 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1624 bfd_signed_vma signed_check
;
1627 /* Need to refetch the addend and squish the two 11 bit pieces
1630 bfd_vma upper
= upper_insn
& 0x7ff;
1631 bfd_vma lower
= lower_insn
& 0x7ff;
1632 upper
= (upper
^ 0x400) - 0x400; /* Sign extend. */
1633 addend
= (upper
<< 12) | (lower
<< 1);
1634 signed_addend
= addend
;
1638 if (r_type
== R_ARM_THM_XPC22
)
1640 /* Check for Thumb to Thumb call. */
1641 /* FIXME: Should we translate the instruction into a BL
1642 instruction instead ? */
1643 if (sym_flags
== STT_ARM_TFUNC
)
1644 (*_bfd_error_handler
) (_("\
1645 %s: Warning: Thumb BLX instruction targets thumb function '%s'."),
1646 bfd_archive_filename (input_bfd
),
1647 h
? h
->root
.root
.string
: "(local)");
1652 /* If it is not a call to Thumb, assume call to Arm.
1653 If it is a call relative to a section name, then it is not a
1654 function call at all, but rather a long jump. */
1655 if (sym_flags
!= STT_ARM_TFUNC
&& sym_flags
!= STT_SECTION
)
1657 if (elf32_thumb_to_arm_stub
1658 (info
, sym_name
, input_bfd
, output_bfd
, input_section
,
1659 hit_data
, sym_sec
, rel
->r_offset
, signed_addend
, value
))
1660 return bfd_reloc_ok
;
1662 return bfd_reloc_dangerous
;
1666 relocation
= value
+ signed_addend
;
1668 relocation
-= (input_section
->output_section
->vma
1669 + input_section
->output_offset
1672 if (! globals
->no_pipeline_knowledge
)
1674 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form. */
1676 i_ehdrp
= elf_elfheader (input_bfd
);
1678 /* Previous versions of this code also used to add in the pipline
1679 offset here. This is wrong because the linker is not supposed
1680 to know about such things, and one day it might change. In order
1681 to support old binaries that need the old behaviour however, so
1682 we attempt to detect which ABI was used to create the reloc. */
1683 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1684 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0
1685 || i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1689 check
= relocation
>> howto
->rightshift
;
1691 /* If this is a signed value, the rightshift just dropped
1692 leading 1 bits (assuming twos complement). */
1693 if ((bfd_signed_vma
) relocation
>= 0)
1694 signed_check
= check
;
1696 signed_check
= check
| ~((bfd_vma
) -1 >> howto
->rightshift
);
1698 /* Assumes two's complement. */
1699 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1703 if (r_type
== R_ARM_THM_XPC22
1704 && ((lower_insn
& 0x1800) == 0x0800))
1705 /* For a BLX instruction, make sure that the relocation is rounded up
1706 to a word boundary. This follows the semantics of the instruction
1707 which specifies that bit 1 of the target address will come from bit
1708 1 of the base address. */
1709 relocation
= (relocation
+ 2) & ~ 3;
1711 /* Put RELOCATION back into the insn. */
1712 upper_insn
= (upper_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 12) & 0x7ff);
1713 lower_insn
= (lower_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 1) & 0x7ff);
1715 /* Put the relocated value back in the object file: */
1716 bfd_put_16 (input_bfd
, upper_insn
, hit_data
);
1717 bfd_put_16 (input_bfd
, lower_insn
, hit_data
+ 2);
1719 return (overflow
? bfd_reloc_overflow
: bfd_reloc_ok
);
1723 case R_ARM_THM_PC11
:
1724 /* Thumb B (branch) instruction). */
1726 bfd_signed_vma relocation
;
1727 bfd_signed_vma reloc_signed_max
= (1 << (howto
->bitsize
- 1)) - 1;
1728 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1729 bfd_signed_vma signed_check
;
1732 /* Need to refetch addend. */
1733 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1734 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1737 signed_addend
&= ~ howto
->src_mask
;
1738 signed_addend
|= addend
;
1741 signed_addend
= addend
;
1742 /* The value in the insn has been right shifted. We need to
1743 undo this, so that we can perform the address calculation
1744 in terms of bytes. */
1745 signed_addend
<<= howto
->rightshift
;
1747 relocation
= value
+ signed_addend
;
1749 relocation
-= (input_section
->output_section
->vma
1750 + input_section
->output_offset
1753 relocation
>>= howto
->rightshift
;
1754 signed_check
= relocation
;
1755 relocation
&= howto
->dst_mask
;
1756 relocation
|= (bfd_get_16 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1758 bfd_put_16 (input_bfd
, relocation
, hit_data
);
1760 /* Assumes two's complement. */
1761 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1762 return bfd_reloc_overflow
;
1764 return bfd_reloc_ok
;
1768 case R_ARM_ALU_PCREL7_0
:
1769 case R_ARM_ALU_PCREL15_8
:
1770 case R_ARM_ALU_PCREL23_15
:
1775 insn
= bfd_get_32 (input_bfd
, hit_data
);
1777 /* Extract the addend. */
1778 addend
= (insn
& 0xff) << ((insn
& 0xf00) >> 7);
1779 signed_addend
= addend
;
1781 relocation
= value
+ signed_addend
;
1783 relocation
-= (input_section
->output_section
->vma
1784 + input_section
->output_offset
1786 insn
= (insn
& ~0xfff)
1787 | ((howto
->bitpos
<< 7) & 0xf00)
1788 | ((relocation
>> howto
->bitpos
) & 0xff);
1789 bfd_put_32 (input_bfd
, value
, hit_data
);
1791 return bfd_reloc_ok
;
1794 case R_ARM_GNU_VTINHERIT
:
1795 case R_ARM_GNU_VTENTRY
:
1796 return bfd_reloc_ok
;
1799 return bfd_reloc_notsupported
;
1801 case R_ARM_GLOB_DAT
:
1802 return bfd_reloc_notsupported
;
1804 case R_ARM_JUMP_SLOT
:
1805 return bfd_reloc_notsupported
;
1807 case R_ARM_RELATIVE
:
1808 return bfd_reloc_notsupported
;
1811 /* Relocation is relative to the start of the
1812 global offset table. */
1814 BFD_ASSERT (sgot
!= NULL
);
1816 return bfd_reloc_notsupported
;
1818 /* If we are addressing a Thumb function, we need to adjust the
1819 address by one, so that attempts to call the function pointer will
1820 correctly interpret it as Thumb code. */
1821 if (sym_flags
== STT_ARM_TFUNC
)
1824 /* Note that sgot->output_offset is not involved in this
1825 calculation. We always want the start of .got. If we
1826 define _GLOBAL_OFFSET_TABLE in a different way, as is
1827 permitted by the ABI, we might have to change this
1829 value
-= sgot
->output_section
->vma
;
1830 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1831 contents
, rel
->r_offset
, value
,
1835 /* Use global offset table as symbol value. */
1836 BFD_ASSERT (sgot
!= NULL
);
1839 return bfd_reloc_notsupported
;
1841 value
= sgot
->output_section
->vma
;
1842 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1843 contents
, rel
->r_offset
, value
,
1847 /* Relocation is to the entry for this symbol in the
1848 global offset table. */
1850 return bfd_reloc_notsupported
;
1857 off
= h
->got
.offset
;
1858 BFD_ASSERT (off
!= (bfd_vma
) -1);
1859 dyn
= globals
->root
.dynamic_sections_created
;
1861 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
1863 && SYMBOL_REFERENCES_LOCAL (info
, h
))
1864 || (ELF_ST_VISIBILITY (h
->other
)
1865 && h
->root
.type
== bfd_link_hash_undefweak
))
1867 /* This is actually a static link, or it is a -Bsymbolic link
1868 and the symbol is defined locally. We must initialize this
1869 entry in the global offset table. Since the offset must
1870 always be a multiple of 4, we use the least significant bit
1871 to record whether we have initialized it already.
1873 When doing a dynamic link, we create a .rel.got relocation
1874 entry to initialize the value. This is done in the
1875 finish_dynamic_symbol routine. */
1880 /* If we are addressing a Thumb function, we need to
1881 adjust the address by one, so that attempts to
1882 call the function pointer will correctly
1883 interpret it as Thumb code. */
1884 if (sym_flags
== STT_ARM_TFUNC
)
1887 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1892 value
= sgot
->output_offset
+ off
;
1898 BFD_ASSERT (local_got_offsets
!= NULL
&&
1899 local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1901 off
= local_got_offsets
[r_symndx
];
1903 /* The offset must always be a multiple of 4. We use the
1904 least significant bit to record whether we have already
1905 generated the necessary reloc. */
1910 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1915 Elf_Internal_Rela outrel
;
1918 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
1919 BFD_ASSERT (srelgot
!= NULL
);
1921 outrel
.r_offset
= (sgot
->output_section
->vma
1922 + sgot
->output_offset
1924 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1925 loc
= srelgot
->contents
;
1926 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rel
);
1927 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
1930 local_got_offsets
[r_symndx
] |= 1;
1933 value
= sgot
->output_offset
+ off
;
1936 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1937 contents
, rel
->r_offset
, value
,
1941 return bfd_reloc_notsupported
;
1943 case R_ARM_AMP_VCALL9
:
1944 return bfd_reloc_notsupported
;
1946 case R_ARM_RSBREL32
:
1947 return bfd_reloc_notsupported
;
1949 case R_ARM_THM_RPC22
:
1950 return bfd_reloc_notsupported
;
1953 return bfd_reloc_notsupported
;
1956 return bfd_reloc_notsupported
;
1959 return bfd_reloc_notsupported
;
1962 return bfd_reloc_notsupported
;
1965 return bfd_reloc_notsupported
;
1970 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
1972 arm_add_to_rel (abfd
, address
, howto
, increment
)
1975 reloc_howto_type
* howto
;
1976 bfd_signed_vma increment
;
1978 bfd_signed_vma addend
;
1980 if (howto
->type
== R_ARM_THM_PC22
)
1982 int upper_insn
, lower_insn
;
1985 upper_insn
= bfd_get_16 (abfd
, address
);
1986 lower_insn
= bfd_get_16 (abfd
, address
+ 2);
1987 upper
= upper_insn
& 0x7ff;
1988 lower
= lower_insn
& 0x7ff;
1990 addend
= (upper
<< 12) | (lower
<< 1);
1991 addend
+= increment
;
1994 upper_insn
= (upper_insn
& 0xf800) | ((addend
>> 11) & 0x7ff);
1995 lower_insn
= (lower_insn
& 0xf800) | (addend
& 0x7ff);
1997 bfd_put_16 (abfd
, (bfd_vma
) upper_insn
, address
);
1998 bfd_put_16 (abfd
, (bfd_vma
) lower_insn
, address
+ 2);
2004 contents
= bfd_get_32 (abfd
, address
);
2006 /* Get the (signed) value from the instruction. */
2007 addend
= contents
& howto
->src_mask
;
2008 if (addend
& ((howto
->src_mask
+ 1) >> 1))
2010 bfd_signed_vma mask
;
2013 mask
&= ~ howto
->src_mask
;
2017 /* Add in the increment, (which is a byte value). */
2018 switch (howto
->type
)
2021 addend
+= increment
;
2025 addend
<<= howto
->size
;
2026 addend
+= increment
;
2028 /* Should we check for overflow here ? */
2030 /* Drop any undesired bits. */
2031 addend
>>= howto
->rightshift
;
2035 contents
= (contents
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
2037 bfd_put_32 (abfd
, contents
, address
);
2040 #endif /* USE_REL */
2042 /* Relocate an ARM ELF section. */
2044 elf32_arm_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
2045 contents
, relocs
, local_syms
, local_sections
)
2047 struct bfd_link_info
*info
;
2049 asection
*input_section
;
2051 Elf_Internal_Rela
*relocs
;
2052 Elf_Internal_Sym
*local_syms
;
2053 asection
**local_sections
;
2055 Elf_Internal_Shdr
*symtab_hdr
;
2056 struct elf_link_hash_entry
**sym_hashes
;
2057 Elf_Internal_Rela
*rel
;
2058 Elf_Internal_Rela
*relend
;
2062 if (info
->relocatable
)
2066 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
2067 sym_hashes
= elf_sym_hashes (input_bfd
);
2070 relend
= relocs
+ input_section
->reloc_count
;
2071 for (; rel
< relend
; rel
++)
2074 reloc_howto_type
* howto
;
2075 unsigned long r_symndx
;
2076 Elf_Internal_Sym
* sym
;
2078 struct elf_link_hash_entry
* h
;
2080 bfd_reloc_status_type r
;
2083 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2084 r_type
= ELF32_R_TYPE (rel
->r_info
);
2086 if ( r_type
== R_ARM_GNU_VTENTRY
2087 || r_type
== R_ARM_GNU_VTINHERIT
)
2090 elf32_arm_info_to_howto (input_bfd
, & bfd_reloc
, rel
);
2091 howto
= bfd_reloc
.howto
;
2094 if (info
->relocatable
)
2096 /* This is a relocatable link. We don't have to change
2097 anything, unless the reloc is against a section symbol,
2098 in which case we have to adjust according to where the
2099 section symbol winds up in the output section. */
2100 if (r_symndx
< symtab_hdr
->sh_info
)
2102 sym
= local_syms
+ r_symndx
;
2103 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2105 sec
= local_sections
[r_symndx
];
2106 arm_add_to_rel (input_bfd
, contents
+ rel
->r_offset
,
2108 (bfd_signed_vma
) (sec
->output_offset
2117 /* This is a final link. */
2122 if (r_symndx
< symtab_hdr
->sh_info
)
2124 sym
= local_syms
+ r_symndx
;
2125 sec
= local_sections
[r_symndx
];
2127 relocation
= (sec
->output_section
->vma
2128 + sec
->output_offset
2130 if ((sec
->flags
& SEC_MERGE
)
2131 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2134 bfd_vma addend
, value
;
2136 if (howto
->rightshift
)
2138 (*_bfd_error_handler
)
2139 (_("%s(%s+0x%lx): %s relocation against SEC_MERGE section"),
2140 bfd_archive_filename (input_bfd
),
2141 bfd_get_section_name (input_bfd
, input_section
),
2142 (long) rel
->r_offset
, howto
->name
);
2146 value
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2148 /* Get the (signed) value from the instruction. */
2149 addend
= value
& howto
->src_mask
;
2150 if (addend
& ((howto
->src_mask
+ 1) >> 1))
2152 bfd_signed_vma mask
;
2155 mask
&= ~ howto
->src_mask
;
2160 _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
)
2162 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2163 value
= (value
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
2164 bfd_put_32 (input_bfd
, value
, contents
+ rel
->r_offset
);
2167 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2173 bfd_boolean unresolved_reloc
;
2175 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2176 r_symndx
, symtab_hdr
, sym_hashes
,
2178 unresolved_reloc
, warned
);
2180 if (unresolved_reloc
|| relocation
!= 0)
2182 /* In these cases, we don't need the relocation value.
2183 We check specially because in some obscure cases
2184 sec->output_section will be NULL. */
2189 case R_ARM_THM_PC22
:
2194 (!info
->symbolic
&& h
->dynindx
!= -1)
2195 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2197 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2198 && ((input_section
->flags
& SEC_ALLOC
) != 0
2199 /* DWARF will emit R_ARM_ABS32 relocations in its
2200 sections against symbols defined externally
2201 in shared libraries. We can't do anything
2203 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
2204 && (h
->elf_link_hash_flags
2205 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
2215 if ((WILL_CALL_FINISH_DYNAMIC_SYMBOL
2216 (elf_hash_table (info
)->dynamic_sections_created
,
2219 || (!info
->symbolic
&& h
->dynindx
!= -1)
2220 || (h
->elf_link_hash_flags
2221 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
2226 if (unresolved_reloc
)
2228 (_("%s: warning: unresolvable relocation %d against symbol `%s' from %s section"),
2229 bfd_archive_filename (input_bfd
),
2231 h
->root
.root
.string
,
2232 bfd_get_section_name (input_bfd
, input_section
));
2239 name
= h
->root
.root
.string
;
2242 name
= (bfd_elf_string_from_elf_section
2243 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2244 if (name
== NULL
|| *name
== '\0')
2245 name
= bfd_section_name (input_bfd
, sec
);
2248 r
= elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
2249 input_section
, contents
, rel
,
2250 relocation
, info
, sec
, name
,
2251 (h
? ELF_ST_TYPE (h
->type
) :
2252 ELF_ST_TYPE (sym
->st_info
)), h
);
2254 if (r
!= bfd_reloc_ok
)
2256 const char * msg
= (const char *) 0;
2260 case bfd_reloc_overflow
:
2261 /* If the overflowing reloc was to an undefined symbol,
2262 we have already printed one error message and there
2263 is no point complaining again. */
2265 h
->root
.type
!= bfd_link_hash_undefined
)
2266 && (!((*info
->callbacks
->reloc_overflow
)
2267 (info
, name
, howto
->name
, (bfd_vma
) 0,
2268 input_bfd
, input_section
, rel
->r_offset
))))
2272 case bfd_reloc_undefined
:
2273 if (!((*info
->callbacks
->undefined_symbol
)
2274 (info
, name
, input_bfd
, input_section
,
2275 rel
->r_offset
, TRUE
)))
2279 case bfd_reloc_outofrange
:
2280 msg
= _("internal error: out of range error");
2283 case bfd_reloc_notsupported
:
2284 msg
= _("internal error: unsupported relocation error");
2287 case bfd_reloc_dangerous
:
2288 msg
= _("internal error: dangerous error");
2292 msg
= _("internal error: unknown error");
2296 if (!((*info
->callbacks
->warning
)
2297 (info
, msg
, name
, input_bfd
, input_section
,
2308 /* Set the right machine number. */
2311 elf32_arm_object_p (abfd
)
2316 mach
= bfd_arm_get_mach_from_notes (abfd
, ARM_NOTE_SECTION
);
2318 if (mach
!= bfd_mach_arm_unknown
)
2319 bfd_default_set_arch_mach (abfd
, bfd_arch_arm
, mach
);
2321 else if (elf_elfheader (abfd
)->e_flags
& EF_ARM_MAVERICK_FLOAT
)
2322 bfd_default_set_arch_mach (abfd
, bfd_arch_arm
, bfd_mach_arm_ep9312
);
2325 bfd_default_set_arch_mach (abfd
, bfd_arch_arm
, mach
);
2330 /* Function to keep ARM specific flags in the ELF header. */
2332 elf32_arm_set_private_flags (abfd
, flags
)
2336 if (elf_flags_init (abfd
)
2337 && elf_elfheader (abfd
)->e_flags
!= flags
)
2339 if (EF_ARM_EABI_VERSION (flags
) == EF_ARM_EABI_UNKNOWN
)
2341 if (flags
& EF_ARM_INTERWORK
)
2342 (*_bfd_error_handler
) (_("\
2343 Warning: Not setting interworking flag of %s since it has already been specified as non-interworking"),
2344 bfd_archive_filename (abfd
));
2346 _bfd_error_handler (_("\
2347 Warning: Clearing the interworking flag of %s due to outside request"),
2348 bfd_archive_filename (abfd
));
2353 elf_elfheader (abfd
)->e_flags
= flags
;
2354 elf_flags_init (abfd
) = TRUE
;
2360 /* Copy backend specific data from one object module to another. */
2363 elf32_arm_copy_private_bfd_data (ibfd
, obfd
)
2370 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2371 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2374 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2375 out_flags
= elf_elfheader (obfd
)->e_flags
;
2377 if (elf_flags_init (obfd
)
2378 && EF_ARM_EABI_VERSION (out_flags
) == EF_ARM_EABI_UNKNOWN
2379 && in_flags
!= out_flags
)
2381 /* Cannot mix APCS26 and APCS32 code. */
2382 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2385 /* Cannot mix float APCS and non-float APCS code. */
2386 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2389 /* If the src and dest have different interworking flags
2390 then turn off the interworking bit. */
2391 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2393 if (out_flags
& EF_ARM_INTERWORK
)
2394 _bfd_error_handler (_("\
2395 Warning: Clearing the interworking flag of %s because non-interworking code in %s has been linked with it"),
2396 bfd_get_filename (obfd
),
2397 bfd_archive_filename (ibfd
));
2399 in_flags
&= ~EF_ARM_INTERWORK
;
2402 /* Likewise for PIC, though don't warn for this case. */
2403 if ((in_flags
& EF_ARM_PIC
) != (out_flags
& EF_ARM_PIC
))
2404 in_flags
&= ~EF_ARM_PIC
;
2407 elf_elfheader (obfd
)->e_flags
= in_flags
;
2408 elf_flags_init (obfd
) = TRUE
;
2413 /* Merge backend specific data from an object file to the output
2414 object file when linking. */
2417 elf32_arm_merge_private_bfd_data (ibfd
, obfd
)
2423 bfd_boolean flags_compatible
= TRUE
;
2426 /* Check if we have the same endianess. */
2427 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
2430 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2431 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2434 /* The input BFD must have had its flags initialised. */
2435 /* The following seems bogus to me -- The flags are initialized in
2436 the assembler but I don't think an elf_flags_init field is
2437 written into the object. */
2438 /* BFD_ASSERT (elf_flags_init (ibfd)); */
2440 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2441 out_flags
= elf_elfheader (obfd
)->e_flags
;
2443 if (!elf_flags_init (obfd
))
2445 /* If the input is the default architecture and had the default
2446 flags then do not bother setting the flags for the output
2447 architecture, instead allow future merges to do this. If no
2448 future merges ever set these flags then they will retain their
2449 uninitialised values, which surprise surprise, correspond
2450 to the default values. */
2451 if (bfd_get_arch_info (ibfd
)->the_default
2452 && elf_elfheader (ibfd
)->e_flags
== 0)
2455 elf_flags_init (obfd
) = TRUE
;
2456 elf_elfheader (obfd
)->e_flags
= in_flags
;
2458 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
2459 && bfd_get_arch_info (obfd
)->the_default
)
2460 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
), bfd_get_mach (ibfd
));
2465 /* Determine what should happen if the input ARM architecture
2466 does not match the output ARM architecture. */
2467 if (! bfd_arm_merge_machines (ibfd
, obfd
))
2470 /* Identical flags must be compatible. */
2471 if (in_flags
== out_flags
)
2474 /* Check to see if the input BFD actually contains any sections. If
2475 not, its flags may not have been initialised either, but it
2476 cannot actually cause any incompatibility. Do not short-circuit
2477 dynamic objects; their section list may be emptied by
2478 elf_link_add_object_symbols.
2480 Also check to see if there are no code sections in the input.
2481 In this case there is no need to check for code specific flags.
2482 XXX - do we need to worry about floating-point format compatability
2483 in data sections ? */
2484 if (!(ibfd
->flags
& DYNAMIC
))
2486 bfd_boolean null_input_bfd
= TRUE
;
2487 bfd_boolean only_data_sections
= TRUE
;
2489 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2491 /* Ignore synthetic glue sections. */
2492 if (strcmp (sec
->name
, ".glue_7")
2493 && strcmp (sec
->name
, ".glue_7t"))
2495 if ((bfd_get_section_flags (ibfd
, sec
)
2496 & (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
2497 == (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
2498 only_data_sections
= FALSE
;
2500 null_input_bfd
= FALSE
;
2505 if (null_input_bfd
|| only_data_sections
)
2509 /* Complain about various flag mismatches. */
2510 if (EF_ARM_EABI_VERSION (in_flags
) != EF_ARM_EABI_VERSION (out_flags
))
2512 _bfd_error_handler (_("\
2513 ERROR: %s is compiled for EABI version %d, whereas %s is compiled for version %d"),
2514 bfd_archive_filename (ibfd
),
2515 (in_flags
& EF_ARM_EABIMASK
) >> 24,
2516 bfd_get_filename (obfd
),
2517 (out_flags
& EF_ARM_EABIMASK
) >> 24);
2521 /* Not sure what needs to be checked for EABI versions >= 1. */
2522 if (EF_ARM_EABI_VERSION (in_flags
) == EF_ARM_EABI_UNKNOWN
)
2524 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2526 _bfd_error_handler (_("\
2527 ERROR: %s is compiled for APCS-%d, whereas target %s uses APCS-%d"),
2528 bfd_archive_filename (ibfd
),
2529 in_flags
& EF_ARM_APCS_26
? 26 : 32,
2530 bfd_get_filename (obfd
),
2531 out_flags
& EF_ARM_APCS_26
? 26 : 32);
2532 flags_compatible
= FALSE
;
2535 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2537 if (in_flags
& EF_ARM_APCS_FLOAT
)
2538 _bfd_error_handler (_("\
2539 ERROR: %s passes floats in float registers, whereas %s passes them in integer registers"),
2540 bfd_archive_filename (ibfd
),
2541 bfd_get_filename (obfd
));
2543 _bfd_error_handler (_("\
2544 ERROR: %s passes floats in integer registers, whereas %s passes them in float registers"),
2545 bfd_archive_filename (ibfd
),
2546 bfd_get_filename (obfd
));
2548 flags_compatible
= FALSE
;
2551 if ((in_flags
& EF_ARM_VFP_FLOAT
) != (out_flags
& EF_ARM_VFP_FLOAT
))
2553 if (in_flags
& EF_ARM_VFP_FLOAT
)
2554 _bfd_error_handler (_("\
2555 ERROR: %s uses VFP instructions, whereas %s does not"),
2556 bfd_archive_filename (ibfd
),
2557 bfd_get_filename (obfd
));
2559 _bfd_error_handler (_("\
2560 ERROR: %s uses FPA instructions, whereas %s does not"),
2561 bfd_archive_filename (ibfd
),
2562 bfd_get_filename (obfd
));
2564 flags_compatible
= FALSE
;
2567 if ((in_flags
& EF_ARM_MAVERICK_FLOAT
) != (out_flags
& EF_ARM_MAVERICK_FLOAT
))
2569 if (in_flags
& EF_ARM_MAVERICK_FLOAT
)
2570 _bfd_error_handler (_("\
2571 ERROR: %s uses Maverick instructions, whereas %s does not"),
2572 bfd_archive_filename (ibfd
),
2573 bfd_get_filename (obfd
));
2575 _bfd_error_handler (_("\
2576 ERROR: %s does not use Maverick instructions, whereas %s does"),
2577 bfd_archive_filename (ibfd
),
2578 bfd_get_filename (obfd
));
2580 flags_compatible
= FALSE
;
2583 #ifdef EF_ARM_SOFT_FLOAT
2584 if ((in_flags
& EF_ARM_SOFT_FLOAT
) != (out_flags
& EF_ARM_SOFT_FLOAT
))
2586 /* We can allow interworking between code that is VFP format
2587 layout, and uses either soft float or integer regs for
2588 passing floating point arguments and results. We already
2589 know that the APCS_FLOAT flags match; similarly for VFP
2591 if ((in_flags
& EF_ARM_APCS_FLOAT
) != 0
2592 || (in_flags
& EF_ARM_VFP_FLOAT
) == 0)
2594 if (in_flags
& EF_ARM_SOFT_FLOAT
)
2595 _bfd_error_handler (_("\
2596 ERROR: %s uses software FP, whereas %s uses hardware FP"),
2597 bfd_archive_filename (ibfd
),
2598 bfd_get_filename (obfd
));
2600 _bfd_error_handler (_("\
2601 ERROR: %s uses hardware FP, whereas %s uses software FP"),
2602 bfd_archive_filename (ibfd
),
2603 bfd_get_filename (obfd
));
2605 flags_compatible
= FALSE
;
2610 /* Interworking mismatch is only a warning. */
2611 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2613 if (in_flags
& EF_ARM_INTERWORK
)
2615 _bfd_error_handler (_("\
2616 Warning: %s supports interworking, whereas %s does not"),
2617 bfd_archive_filename (ibfd
),
2618 bfd_get_filename (obfd
));
2622 _bfd_error_handler (_("\
2623 Warning: %s does not support interworking, whereas %s does"),
2624 bfd_archive_filename (ibfd
),
2625 bfd_get_filename (obfd
));
2630 return flags_compatible
;
2633 /* Display the flags field. */
2636 elf32_arm_print_private_bfd_data (abfd
, ptr
)
2640 FILE * file
= (FILE *) ptr
;
2641 unsigned long flags
;
2643 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
2645 /* Print normal ELF private data. */
2646 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
2648 flags
= elf_elfheader (abfd
)->e_flags
;
2649 /* Ignore init flag - it may not be set, despite the flags field
2650 containing valid data. */
2652 /* xgettext:c-format */
2653 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
2655 switch (EF_ARM_EABI_VERSION (flags
))
2657 case EF_ARM_EABI_UNKNOWN
:
2658 /* The following flag bits are GNU extensions and not part of the
2659 official ARM ELF extended ABI. Hence they are only decoded if
2660 the EABI version is not set. */
2661 if (flags
& EF_ARM_INTERWORK
)
2662 fprintf (file
, _(" [interworking enabled]"));
2664 if (flags
& EF_ARM_APCS_26
)
2665 fprintf (file
, " [APCS-26]");
2667 fprintf (file
, " [APCS-32]");
2669 if (flags
& EF_ARM_VFP_FLOAT
)
2670 fprintf (file
, _(" [VFP float format]"));
2671 else if (flags
& EF_ARM_MAVERICK_FLOAT
)
2672 fprintf (file
, _(" [Maverick float format]"));
2674 fprintf (file
, _(" [FPA float format]"));
2676 if (flags
& EF_ARM_APCS_FLOAT
)
2677 fprintf (file
, _(" [floats passed in float registers]"));
2679 if (flags
& EF_ARM_PIC
)
2680 fprintf (file
, _(" [position independent]"));
2682 if (flags
& EF_ARM_NEW_ABI
)
2683 fprintf (file
, _(" [new ABI]"));
2685 if (flags
& EF_ARM_OLD_ABI
)
2686 fprintf (file
, _(" [old ABI]"));
2688 if (flags
& EF_ARM_SOFT_FLOAT
)
2689 fprintf (file
, _(" [software FP]"));
2691 flags
&= ~(EF_ARM_INTERWORK
| EF_ARM_APCS_26
| EF_ARM_APCS_FLOAT
2692 | EF_ARM_PIC
| EF_ARM_NEW_ABI
| EF_ARM_OLD_ABI
2693 | EF_ARM_SOFT_FLOAT
| EF_ARM_VFP_FLOAT
2694 | EF_ARM_MAVERICK_FLOAT
);
2697 case EF_ARM_EABI_VER1
:
2698 fprintf (file
, _(" [Version1 EABI]"));
2700 if (flags
& EF_ARM_SYMSARESORTED
)
2701 fprintf (file
, _(" [sorted symbol table]"));
2703 fprintf (file
, _(" [unsorted symbol table]"));
2705 flags
&= ~ EF_ARM_SYMSARESORTED
;
2708 case EF_ARM_EABI_VER2
:
2709 fprintf (file
, _(" [Version2 EABI]"));
2711 if (flags
& EF_ARM_SYMSARESORTED
)
2712 fprintf (file
, _(" [sorted symbol table]"));
2714 fprintf (file
, _(" [unsorted symbol table]"));
2716 if (flags
& EF_ARM_DYNSYMSUSESEGIDX
)
2717 fprintf (file
, _(" [dynamic symbols use segment index]"));
2719 if (flags
& EF_ARM_MAPSYMSFIRST
)
2720 fprintf (file
, _(" [mapping symbols precede others]"));
2722 flags
&= ~(EF_ARM_SYMSARESORTED
| EF_ARM_DYNSYMSUSESEGIDX
2723 | EF_ARM_MAPSYMSFIRST
);
2726 case EF_ARM_EABI_VER3
:
2727 fprintf (file
, _(" [Version3 EABI]"));
2729 if (flags
& EF_ARM_BE8
)
2730 fprintf (file
, _(" [BE8]"));
2732 if (flags
& EF_ARM_LE8
)
2733 fprintf (file
, _(" [LE8]"));
2735 flags
&= ~(EF_ARM_LE8
| EF_ARM_BE8
);
2739 fprintf (file
, _(" <EABI version unrecognised>"));
2743 flags
&= ~ EF_ARM_EABIMASK
;
2745 if (flags
& EF_ARM_RELEXEC
)
2746 fprintf (file
, _(" [relocatable executable]"));
2748 if (flags
& EF_ARM_HASENTRY
)
2749 fprintf (file
, _(" [has entry point]"));
2751 flags
&= ~ (EF_ARM_RELEXEC
| EF_ARM_HASENTRY
);
2754 fprintf (file
, _("<Unrecognised flag bits set>"));
2762 elf32_arm_get_symbol_type (elf_sym
, type
)
2763 Elf_Internal_Sym
* elf_sym
;
2766 switch (ELF_ST_TYPE (elf_sym
->st_info
))
2769 return ELF_ST_TYPE (elf_sym
->st_info
);
2772 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2773 This allows us to distinguish between data used by Thumb instructions
2774 and non-data (which is probably code) inside Thumb regions of an
2776 if (type
!= STT_OBJECT
)
2777 return ELF_ST_TYPE (elf_sym
->st_info
);
2788 elf32_arm_gc_mark_hook (sec
, info
, rel
, h
, sym
)
2790 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2791 Elf_Internal_Rela
*rel
;
2792 struct elf_link_hash_entry
*h
;
2793 Elf_Internal_Sym
*sym
;
2797 switch (ELF32_R_TYPE (rel
->r_info
))
2799 case R_ARM_GNU_VTINHERIT
:
2800 case R_ARM_GNU_VTENTRY
:
2804 switch (h
->root
.type
)
2806 case bfd_link_hash_defined
:
2807 case bfd_link_hash_defweak
:
2808 return h
->root
.u
.def
.section
;
2810 case bfd_link_hash_common
:
2811 return h
->root
.u
.c
.p
->section
;
2819 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
2824 /* Update the got entry reference counts for the section being removed. */
2827 elf32_arm_gc_sweep_hook (abfd
, info
, sec
, relocs
)
2828 bfd
*abfd ATTRIBUTE_UNUSED
;
2829 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2830 asection
*sec ATTRIBUTE_UNUSED
;
2831 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
;
2833 Elf_Internal_Shdr
*symtab_hdr
;
2834 struct elf_link_hash_entry
**sym_hashes
;
2835 bfd_signed_vma
*local_got_refcounts
;
2836 const Elf_Internal_Rela
*rel
, *relend
;
2837 unsigned long r_symndx
;
2838 struct elf_link_hash_entry
*h
;
2840 elf_section_data (sec
)->local_dynrel
= NULL
;
2842 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2843 sym_hashes
= elf_sym_hashes (abfd
);
2844 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2846 relend
= relocs
+ sec
->reloc_count
;
2847 for (rel
= relocs
; rel
< relend
; rel
++)
2848 switch (ELF32_R_TYPE (rel
->r_info
))
2851 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2852 if (r_symndx
>= symtab_hdr
->sh_info
)
2854 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2855 if (h
->got
.refcount
> 0)
2856 h
->got
.refcount
-= 1;
2858 else if (local_got_refcounts
!= NULL
)
2860 if (local_got_refcounts
[r_symndx
] > 0)
2861 local_got_refcounts
[r_symndx
] -= 1;
2869 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2870 if (r_symndx
>= symtab_hdr
->sh_info
)
2872 struct elf32_arm_link_hash_entry
*eh
;
2873 struct elf32_arm_relocs_copied
**pp
;
2874 struct elf32_arm_relocs_copied
*p
;
2876 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2878 if (h
->plt
.refcount
> 0)
2879 h
->plt
.refcount
-= 1;
2881 if (ELF32_R_TYPE (rel
->r_info
) == R_ARM_ABS32
2882 || ELF32_R_TYPE (rel
->r_info
) == R_ARM_REL32
)
2884 eh
= (struct elf32_arm_link_hash_entry
*) h
;
2886 for (pp
= &eh
->relocs_copied
; (p
= *pp
) != NULL
;
2888 if (p
->section
== sec
)
2906 /* Look through the relocs for a section during the first phase. */
2909 elf32_arm_check_relocs (abfd
, info
, sec
, relocs
)
2911 struct bfd_link_info
*info
;
2913 const Elf_Internal_Rela
*relocs
;
2915 Elf_Internal_Shdr
*symtab_hdr
;
2916 struct elf_link_hash_entry
**sym_hashes
;
2917 struct elf_link_hash_entry
**sym_hashes_end
;
2918 const Elf_Internal_Rela
*rel
;
2919 const Elf_Internal_Rela
*rel_end
;
2922 bfd_vma
*local_got_offsets
;
2923 struct elf32_arm_link_hash_table
*htab
;
2925 if (info
->relocatable
)
2928 htab
= elf32_arm_hash_table (info
);
2931 dynobj
= elf_hash_table (info
)->dynobj
;
2932 local_got_offsets
= elf_local_got_offsets (abfd
);
2934 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2935 sym_hashes
= elf_sym_hashes (abfd
);
2936 sym_hashes_end
= sym_hashes
2937 + symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
2939 if (!elf_bad_symtab (abfd
))
2940 sym_hashes_end
-= symtab_hdr
->sh_info
;
2942 rel_end
= relocs
+ sec
->reloc_count
;
2943 for (rel
= relocs
; rel
< rel_end
; rel
++)
2945 struct elf_link_hash_entry
*h
;
2946 unsigned long r_symndx
;
2948 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2949 if (r_symndx
< symtab_hdr
->sh_info
)
2952 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2954 switch (ELF32_R_TYPE (rel
->r_info
))
2957 /* This symbol requires a global offset table entry. */
2964 bfd_signed_vma
*local_got_refcounts
;
2966 /* This is a global offset table entry for a local symbol. */
2967 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2968 if (local_got_refcounts
== NULL
)
2972 size
= symtab_hdr
->sh_info
;
2973 size
*= (sizeof (bfd_signed_vma
) + sizeof(char));
2974 local_got_refcounts
= ((bfd_signed_vma
*)
2975 bfd_zalloc (abfd
, size
));
2976 if (local_got_refcounts
== NULL
)
2978 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
2980 local_got_refcounts
[r_symndx
] += 1;
2986 if (htab
->sgot
== NULL
)
2988 if (htab
->root
.dynobj
== NULL
)
2989 htab
->root
.dynobj
= abfd
;
2990 if (!create_got_section (htab
->root
.dynobj
, info
))
3001 /* If this reloc is in a read-only section, we might
3002 need a copy reloc. We can't check reliably at this
3003 stage whether the section is read-only, as input
3004 sections have not yet been mapped to output sections.
3005 Tentatively set the flag for now, and correct in
3006 adjust_dynamic_symbol. */
3008 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
3010 /* We may need a .plt entry if the function this reloc
3011 refers to is in a different object. We can't tell for
3012 sure yet, because something later might force the
3014 if (ELF32_R_TYPE (rel
->r_info
) == R_ARM_PC24
3015 || ELF32_R_TYPE (rel
->r_info
) == R_ARM_PLT32
)
3016 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
3018 /* If we create a PLT entry, this relocation will reference
3019 it, even if it's an ABS32 relocation. */
3020 h
->plt
.refcount
+= 1;
3023 /* If we are creating a shared library, and this is a reloc
3024 against a global symbol, or a non PC relative reloc
3025 against a local symbol, then we need to copy the reloc
3026 into the shared library. However, if we are linking with
3027 -Bsymbolic, we do not need to copy a reloc against a
3028 global symbol which is defined in an object we are
3029 including in the link (i.e., DEF_REGULAR is set). At
3030 this point we have not seen all the input files, so it is
3031 possible that DEF_REGULAR is not set now but will be set
3032 later (it is never cleared). We account for that
3033 possibility below by storing information in the
3034 relocs_copied field of the hash table entry. */
3036 && (sec
->flags
& SEC_ALLOC
) != 0
3037 && ((ELF32_R_TYPE (rel
->r_info
) != R_ARM_PC24
3038 && ELF32_R_TYPE (rel
->r_info
) != R_ARM_PLT32
3039 && ELF32_R_TYPE (rel
->r_info
) != R_ARM_REL32
)
3041 && (! info
->symbolic
3042 || (h
->elf_link_hash_flags
3043 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
3045 struct elf32_arm_relocs_copied
*p
, **head
;
3047 /* When creating a shared object, we must copy these
3048 reloc types into the output file. We create a reloc
3049 section in dynobj and make room for this reloc. */
3054 name
= (bfd_elf_string_from_elf_section
3056 elf_elfheader (abfd
)->e_shstrndx
,
3057 elf_section_data (sec
)->rel_hdr
.sh_name
));
3061 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
3062 && strcmp (bfd_get_section_name (abfd
, sec
),
3065 sreloc
= bfd_get_section_by_name (dynobj
, name
);
3070 sreloc
= bfd_make_section (dynobj
, name
);
3071 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
3072 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3073 if ((sec
->flags
& SEC_ALLOC
) != 0)
3074 flags
|= SEC_ALLOC
| SEC_LOAD
;
3076 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
3077 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
3081 elf_section_data (sec
)->sreloc
= sreloc
;
3084 /* If this is a global symbol, we count the number of
3085 relocations we need for this symbol. */
3088 head
= &((struct elf32_arm_link_hash_entry
*) h
)->relocs_copied
;
3092 /* Track dynamic relocs needed for local syms too.
3093 We really need local syms available to do this
3097 s
= bfd_section_from_r_symndx (abfd
, &htab
->sym_sec
,
3102 head
= ((struct elf32_arm_relocs_copied
**)
3103 &elf_section_data (s
)->local_dynrel
);
3107 if (p
== NULL
|| p
->section
!= sec
)
3109 bfd_size_type amt
= sizeof *p
;
3110 p
= bfd_alloc (htab
->root
.dynobj
, amt
);
3119 if (ELF32_R_TYPE (rel
->r_info
) == R_ARM_ABS32
3120 || ELF32_R_TYPE (rel
->r_info
) == R_ARM_REL32
)
3125 /* This relocation describes the C++ object vtable hierarchy.
3126 Reconstruct it for later use during GC. */
3127 case R_ARM_GNU_VTINHERIT
:
3128 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
3132 /* This relocation describes which C++ vtable entries are actually
3133 used. Record for later use during GC. */
3134 case R_ARM_GNU_VTENTRY
:
3135 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
3144 /* Find the nearest line to a particular section and offset, for error
3145 reporting. This code is a duplicate of the code in elf.c, except
3146 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
3149 elf32_arm_find_nearest_line
3150 (abfd
, section
, symbols
, offset
, filename_ptr
, functionname_ptr
, line_ptr
)
3155 const char **filename_ptr
;
3156 const char **functionname_ptr
;
3157 unsigned int *line_ptr
;
3160 const char *filename
;
3165 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
3166 filename_ptr
, functionname_ptr
,
3168 &elf_tdata (abfd
)->dwarf2_find_line_info
))
3171 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
3172 &found
, filename_ptr
,
3173 functionname_ptr
, line_ptr
,
3174 &elf_tdata (abfd
)->line_info
))
3180 if (symbols
== NULL
)
3187 for (p
= symbols
; *p
!= NULL
; p
++)
3191 q
= (elf_symbol_type
*) *p
;
3193 if (bfd_get_section (&q
->symbol
) != section
)
3196 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
3201 filename
= bfd_asymbol_name (&q
->symbol
);
3206 if (q
->symbol
.section
== section
3207 && q
->symbol
.value
>= low_func
3208 && q
->symbol
.value
<= offset
)
3210 func
= (asymbol
*) q
;
3211 low_func
= q
->symbol
.value
;
3220 *filename_ptr
= filename
;
3221 *functionname_ptr
= bfd_asymbol_name (func
);
3227 /* Adjust a symbol defined by a dynamic object and referenced by a
3228 regular object. The current definition is in some section of the
3229 dynamic object, but we're not including those sections. We have to
3230 change the definition to something the rest of the link can
3234 elf32_arm_adjust_dynamic_symbol (info
, h
)
3235 struct bfd_link_info
* info
;
3236 struct elf_link_hash_entry
* h
;
3240 unsigned int power_of_two
;
3242 dynobj
= elf_hash_table (info
)->dynobj
;
3244 /* Make sure we know what is going on here. */
3245 BFD_ASSERT (dynobj
!= NULL
3246 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
3247 || h
->weakdef
!= NULL
3248 || ((h
->elf_link_hash_flags
3249 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
3250 && (h
->elf_link_hash_flags
3251 & ELF_LINK_HASH_REF_REGULAR
) != 0
3252 && (h
->elf_link_hash_flags
3253 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
3255 /* If this is a function, put it in the procedure linkage table. We
3256 will fill in the contents of the procedure linkage table later,
3257 when we know the address of the .got section. */
3258 if (h
->type
== STT_FUNC
3259 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
3261 if (h
->plt
.refcount
<= 0
3262 || SYMBOL_CALLS_LOCAL (info
, h
)
3263 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
3264 && h
->root
.type
== bfd_link_hash_undefweak
))
3266 /* This case can occur if we saw a PLT32 reloc in an input
3267 file, but the symbol was never referred to by a dynamic
3268 object, or if all references were garbage collected. In
3269 such a case, we don't actually need to build a procedure
3270 linkage table, and we can just do a PC24 reloc instead. */
3271 h
->plt
.offset
= (bfd_vma
) -1;
3272 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
3278 /* It's possible that we incorrectly decided a .plt reloc was
3279 needed for an R_ARM_PC24 reloc to a non-function sym in
3280 check_relocs. We can't decide accurately between function and
3281 non-function syms in check-relocs; Objects loaded later in
3282 the link may change h->type. So fix it now. */
3283 h
->plt
.offset
= (bfd_vma
) -1;
3285 /* If this is a weak symbol, and there is a real definition, the
3286 processor independent code will have arranged for us to see the
3287 real definition first, and we can just use the same value. */
3288 if (h
->weakdef
!= NULL
)
3290 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
3291 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
3292 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
3293 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
3297 /* This is a reference to a symbol defined by a dynamic object which
3298 is not a function. */
3300 /* If we are creating a shared library, we must presume that the
3301 only references to the symbol are via the global offset table.
3302 For such cases we need not do anything here; the relocations will
3303 be handled correctly by relocate_section. */
3307 /* We must allocate the symbol in our .dynbss section, which will
3308 become part of the .bss section of the executable. There will be
3309 an entry for this symbol in the .dynsym section. The dynamic
3310 object will contain position independent code, so all references
3311 from the dynamic object to this symbol will go through the global
3312 offset table. The dynamic linker will use the .dynsym entry to
3313 determine the address it must put in the global offset table, so
3314 both the dynamic object and the regular object will refer to the
3315 same memory location for the variable. */
3316 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
3317 BFD_ASSERT (s
!= NULL
);
3319 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
3320 copy the initial value out of the dynamic object and into the
3321 runtime process image. We need to remember the offset into the
3322 .rel.bss section we are going to use. */
3323 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
3327 srel
= bfd_get_section_by_name (dynobj
, ".rel.bss");
3328 BFD_ASSERT (srel
!= NULL
);
3329 srel
->size
+= sizeof (Elf32_External_Rel
);
3330 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
3333 /* We need to figure out the alignment required for this symbol. I
3334 have no idea how ELF linkers handle this. */
3335 power_of_two
= bfd_log2 (h
->size
);
3336 if (power_of_two
> 3)
3339 /* Apply the required alignment. */
3340 s
->size
= BFD_ALIGN (s
->size
, (bfd_size_type
) (1 << power_of_two
));
3341 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
3343 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
3347 /* Define the symbol as being at this point in the section. */
3348 h
->root
.u
.def
.section
= s
;
3349 h
->root
.u
.def
.value
= s
->size
;
3351 /* Increment the section size to make room for the symbol. */
3357 /* Allocate space in .plt, .got and associated reloc sections for
3361 allocate_dynrelocs (h
, inf
)
3362 struct elf_link_hash_entry
*h
;
3365 struct bfd_link_info
*info
;
3366 struct elf32_arm_link_hash_table
*htab
;
3367 struct elf32_arm_link_hash_entry
*eh
;
3368 struct elf32_arm_relocs_copied
*p
;
3370 if (h
->root
.type
== bfd_link_hash_indirect
)
3373 if (h
->root
.type
== bfd_link_hash_warning
)
3374 /* When warning symbols are created, they **replace** the "real"
3375 entry in the hash table, thus we never get to see the real
3376 symbol in a hash traversal. So look at it now. */
3377 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3379 info
= (struct bfd_link_info
*) inf
;
3380 htab
= elf32_arm_hash_table (info
);
3382 if (htab
->root
.dynamic_sections_created
3383 && h
->plt
.refcount
> 0)
3385 /* Make sure this symbol is output as a dynamic symbol.
3386 Undefined weak syms won't yet be marked as dynamic. */
3387 if (h
->dynindx
== -1
3388 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
3390 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3395 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
3397 asection
*s
= htab
->splt
;
3399 /* If this is the first .plt entry, make room for the special
3402 s
->size
+= PLT_HEADER_SIZE
;
3404 h
->plt
.offset
= s
->size
;
3406 /* If this symbol is not defined in a regular file, and we are
3407 not generating a shared library, then set the symbol to this
3408 location in the .plt. This is required to make function
3409 pointers compare as equal between the normal executable and
3410 the shared library. */
3412 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3414 h
->root
.u
.def
.section
= s
;
3415 h
->root
.u
.def
.value
= h
->plt
.offset
;
3418 /* Make room for this entry. */
3419 s
->size
+= PLT_ENTRY_SIZE
;
3421 /* We also need to make an entry in the .got.plt section, which
3422 will be placed in the .got section by the linker script. */
3423 htab
->sgotplt
->size
+= 4;
3425 /* We also need to make an entry in the .rel.plt section. */
3426 htab
->srelplt
->size
+= sizeof (Elf32_External_Rel
);
3430 h
->plt
.offset
= (bfd_vma
) -1;
3431 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
3436 h
->plt
.offset
= (bfd_vma
) -1;
3437 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
3440 if (h
->got
.refcount
> 0)
3445 /* Make sure this symbol is output as a dynamic symbol.
3446 Undefined weak syms won't yet be marked as dynamic. */
3447 if (h
->dynindx
== -1
3448 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
3450 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3455 h
->got
.offset
= s
->size
;
3457 dyn
= htab
->root
.dynamic_sections_created
;
3458 if ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3459 || h
->root
.type
!= bfd_link_hash_undefweak
)
3461 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
3462 htab
->srelgot
->size
+= sizeof (Elf32_External_Rel
);
3465 h
->got
.offset
= (bfd_vma
) -1;
3467 eh
= (struct elf32_arm_link_hash_entry
*) h
;
3468 if (eh
->relocs_copied
== NULL
)
3471 /* In the shared -Bsymbolic case, discard space allocated for
3472 dynamic pc-relative relocs against symbols which turn out to be
3473 defined in regular objects. For the normal shared case, discard
3474 space for pc-relative relocs that have become local due to symbol
3475 visibility changes. */
3479 /* Discard relocs on undefined weak syms with non-default
3481 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
3482 && h
->root
.type
== bfd_link_hash_undefweak
)
3483 eh
->relocs_copied
= NULL
;
3487 /* For the non-shared case, discard space for relocs against
3488 symbols which turn out to need copy relocs or are not
3491 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
3492 && (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
3493 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3494 || (htab
->root
.dynamic_sections_created
3495 && (h
->root
.type
== bfd_link_hash_undefweak
3496 || h
->root
.type
== bfd_link_hash_undefined
))))
3498 /* Make sure this symbol is output as a dynamic symbol.
3499 Undefined weak syms won't yet be marked as dynamic. */
3500 if (h
->dynindx
== -1
3501 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
3503 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3507 /* If that succeeded, we know we'll be keeping all the
3509 if (h
->dynindx
!= -1)
3513 eh
->relocs_copied
= NULL
;
3518 /* Finally, allocate space. */
3519 for (p
= eh
->relocs_copied
; p
!= NULL
; p
= p
->next
)
3521 asection
*sreloc
= elf_section_data (p
->section
)->sreloc
;
3522 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
3528 /* Set the sizes of the dynamic sections. */
3531 elf32_arm_size_dynamic_sections (output_bfd
, info
)
3532 bfd
* output_bfd ATTRIBUTE_UNUSED
;
3533 struct bfd_link_info
* info
;
3540 struct elf32_arm_link_hash_table
*htab
;
3542 htab
= elf32_arm_hash_table (info
);
3543 dynobj
= elf_hash_table (info
)->dynobj
;
3544 BFD_ASSERT (dynobj
!= NULL
);
3546 if (elf_hash_table (info
)->dynamic_sections_created
)
3548 /* Set the contents of the .interp section to the interpreter. */
3549 if (info
->executable
)
3551 s
= bfd_get_section_by_name (dynobj
, ".interp");
3552 BFD_ASSERT (s
!= NULL
);
3553 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
3554 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
3558 /* Set up .got offsets for local syms, and space for local dynamic
3560 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
3562 bfd_signed_vma
*local_got
;
3563 bfd_signed_vma
*end_local_got
;
3564 char *local_tls_type
;
3565 bfd_size_type locsymcount
;
3566 Elf_Internal_Shdr
*symtab_hdr
;
3569 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
3572 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3574 struct elf32_arm_relocs_copied
*p
;
3576 for (p
= *((struct elf32_arm_relocs_copied
**)
3577 &elf_section_data (s
)->local_dynrel
);
3581 if (!bfd_is_abs_section (p
->section
)
3582 && bfd_is_abs_section (p
->section
->output_section
))
3584 /* Input section has been discarded, either because
3585 it is a copy of a linkonce section or due to
3586 linker script /DISCARD/, so we'll be discarding
3589 else if (p
->count
!= 0)
3591 srel
= elf_section_data (p
->section
)->sreloc
;
3592 srel
->size
+= p
->count
* sizeof (Elf32_External_Rel
);
3593 if ((p
->section
->output_section
->flags
& SEC_READONLY
) != 0)
3594 info
->flags
|= DF_TEXTREL
;
3599 local_got
= elf_local_got_refcounts (ibfd
);
3603 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
3604 locsymcount
= symtab_hdr
->sh_info
;
3605 end_local_got
= local_got
+ locsymcount
;
3607 srel
= htab
->srelgot
;
3608 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
3612 *local_got
= s
->size
;
3615 srel
->size
+= sizeof (Elf32_External_Rel
);
3618 *local_got
= (bfd_vma
) -1;
3622 /* Allocate global sym .plt and .got entries, and space for global
3623 sym dynamic relocs. */
3624 elf_link_hash_traverse (&htab
->root
, allocate_dynrelocs
, (PTR
) info
);
3626 /* The check_relocs and adjust_dynamic_symbol entry points have
3627 determined the sizes of the various dynamic sections. Allocate
3631 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3636 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3639 /* It's OK to base decisions on the section name, because none
3640 of the dynobj section names depend upon the input files. */
3641 name
= bfd_get_section_name (dynobj
, s
);
3645 if (strcmp (name
, ".plt") == 0)
3649 /* Strip this section if we don't need it; see the
3655 /* Remember whether there is a PLT. */
3659 else if (strncmp (name
, ".rel", 4) == 0)
3663 /* If we don't need this section, strip it from the
3664 output file. This is mostly to handle .rel.bss and
3665 .rel.plt. We must create both sections in
3666 create_dynamic_sections, because they must be created
3667 before the linker maps input sections to output
3668 sections. The linker does that before
3669 adjust_dynamic_symbol is called, and it is that
3670 function which decides whether anything needs to go
3671 into these sections. */
3676 /* Remember whether there are any reloc sections other
3678 if (strcmp (name
, ".rel.plt") != 0)
3681 /* We use the reloc_count field as a counter if we need
3682 to copy relocs into the output file. */
3686 else if (strncmp (name
, ".got", 4) != 0)
3688 /* It's not one of our sections, so don't allocate space. */
3694 _bfd_strip_section_from_output (info
, s
);
3698 /* Allocate memory for the section contents. */
3699 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3700 if (s
->contents
== NULL
&& s
->size
!= 0)
3704 if (elf_hash_table (info
)->dynamic_sections_created
)
3706 /* Add some entries to the .dynamic section. We fill in the
3707 values later, in elf32_arm_finish_dynamic_sections, but we
3708 must add the entries now so that we get the correct size for
3709 the .dynamic section. The DT_DEBUG entry is filled in by the
3710 dynamic linker and used by the debugger. */
3711 #define add_dynamic_entry(TAG, VAL) \
3712 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3716 if (!add_dynamic_entry (DT_DEBUG
, 0))
3722 if ( !add_dynamic_entry (DT_PLTGOT
, 0)
3723 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
3724 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
3725 || !add_dynamic_entry (DT_JMPREL
, 0))
3731 if ( !add_dynamic_entry (DT_REL
, 0)
3732 || !add_dynamic_entry (DT_RELSZ
, 0)
3733 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
3737 if ((info
->flags
& DF_TEXTREL
) != 0)
3739 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3741 info
->flags
|= DF_TEXTREL
;
3744 #undef add_synamic_entry
3749 /* Finish up dynamic symbol handling. We set the contents of various
3750 dynamic sections here. */
3753 elf32_arm_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
3755 struct bfd_link_info
* info
;
3756 struct elf_link_hash_entry
* h
;
3757 Elf_Internal_Sym
* sym
;
3761 dynobj
= elf_hash_table (info
)->dynobj
;
3763 if (h
->plt
.offset
!= (bfd_vma
) -1)
3770 Elf_Internal_Rela rel
;
3772 bfd_vma got_displacement
;
3774 /* This symbol has an entry in the procedure linkage table. Set
3777 BFD_ASSERT (h
->dynindx
!= -1);
3779 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3780 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3781 srel
= bfd_get_section_by_name (dynobj
, ".rel.plt");
3782 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
3784 /* Get the index in the procedure linkage table which
3785 corresponds to this symbol. This is the index of this symbol
3786 in all the symbols for which we are making plt entries. The
3787 first entry in the procedure linkage table is reserved. */
3788 plt_index
= (h
->plt
.offset
- PLT_HEADER_SIZE
) / PLT_ENTRY_SIZE
;
3790 /* Get the offset into the .got table of the entry that
3791 corresponds to this function. Each .got entry is 4 bytes.
3792 The first three are reserved. */
3793 got_offset
= (plt_index
+ 3) * 4;
3795 /* Calculate the displacement between the PLT slot and the
3796 entry in the GOT. */
3797 got_displacement
= (sgot
->output_section
->vma
3798 + sgot
->output_offset
3800 - splt
->output_section
->vma
3801 - splt
->output_offset
3805 BFD_ASSERT ((got_displacement
& 0xf0000000) == 0);
3807 /* Fill in the entry in the procedure linkage table. */
3808 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[0] | ((got_displacement
& 0x0ff00000) >> 20),
3809 splt
->contents
+ h
->plt
.offset
+ 0);
3810 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[1] | ((got_displacement
& 0x000ff000) >> 12),
3811 splt
->contents
+ h
->plt
.offset
+ 4);
3812 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[2] | (got_displacement
& 0x00000fff),
3813 splt
->contents
+ h
->plt
.offset
+ 8);
3814 #ifdef FOUR_WORD_PLT
3815 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[3],
3816 splt
->contents
+ h
->plt
.offset
+ 12);
3819 /* Fill in the entry in the global offset table. */
3820 bfd_put_32 (output_bfd
,
3821 (splt
->output_section
->vma
3822 + splt
->output_offset
),
3823 sgot
->contents
+ got_offset
);
3825 /* Fill in the entry in the .rel.plt section. */
3826 rel
.r_offset
= (sgot
->output_section
->vma
3827 + sgot
->output_offset
3829 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_JUMP_SLOT
);
3830 loc
= srel
->contents
+ plt_index
* sizeof (Elf32_External_Rel
);
3831 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3833 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3835 /* Mark the symbol as undefined, rather than as defined in
3836 the .plt section. Leave the value alone. */
3837 sym
->st_shndx
= SHN_UNDEF
;
3838 /* If the symbol is weak, we do need to clear the value.
3839 Otherwise, the PLT entry would provide a definition for
3840 the symbol even if the symbol wasn't defined anywhere,
3841 and so the symbol would never be NULL. */
3842 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR_NONWEAK
)
3848 if (h
->got
.offset
!= (bfd_vma
) -1)
3852 Elf_Internal_Rela rel
;
3855 /* This symbol has an entry in the global offset table. Set it
3857 sgot
= bfd_get_section_by_name (dynobj
, ".got");
3858 srel
= bfd_get_section_by_name (dynobj
, ".rel.got");
3859 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
3861 rel
.r_offset
= (sgot
->output_section
->vma
3862 + sgot
->output_offset
3863 + (h
->got
.offset
&~ (bfd_vma
) 1));
3865 /* If this is a static link, or it is a -Bsymbolic link and the
3866 symbol is defined locally or was forced to be local because
3867 of a version file, we just want to emit a RELATIVE reloc.
3868 The entry in the global offset table will already have been
3869 initialized in the relocate_section function. */
3871 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3873 BFD_ASSERT((h
->got
.offset
& 1) != 0);
3874 rel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
3878 BFD_ASSERT((h
->got
.offset
& 1) == 0);
3879 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
3880 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_GLOB_DAT
);
3883 loc
= srel
->contents
+ srel
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3884 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3887 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
3890 Elf_Internal_Rela rel
;
3893 /* This symbol needs a copy reloc. Set it up. */
3894 BFD_ASSERT (h
->dynindx
!= -1
3895 && (h
->root
.type
== bfd_link_hash_defined
3896 || h
->root
.type
== bfd_link_hash_defweak
));
3898 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
3900 BFD_ASSERT (s
!= NULL
);
3902 rel
.r_offset
= (h
->root
.u
.def
.value
3903 + h
->root
.u
.def
.section
->output_section
->vma
3904 + h
->root
.u
.def
.section
->output_offset
);
3905 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_COPY
);
3906 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3907 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3910 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3911 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3912 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
3913 sym
->st_shndx
= SHN_ABS
;
3918 /* Finish up the dynamic sections. */
3921 elf32_arm_finish_dynamic_sections (output_bfd
, info
)
3923 struct bfd_link_info
* info
;
3929 dynobj
= elf_hash_table (info
)->dynobj
;
3931 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3932 BFD_ASSERT (sgot
!= NULL
);
3933 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3935 if (elf_hash_table (info
)->dynamic_sections_created
)
3938 Elf32_External_Dyn
*dyncon
, *dynconend
;
3940 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3941 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3943 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3944 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
3946 for (; dyncon
< dynconend
; dyncon
++)
3948 Elf_Internal_Dyn dyn
;
3952 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3965 s
= bfd_get_section_by_name (output_bfd
, name
);
3966 BFD_ASSERT (s
!= NULL
);
3967 dyn
.d_un
.d_ptr
= s
->vma
;
3968 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3972 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3973 BFD_ASSERT (s
!= NULL
);
3974 dyn
.d_un
.d_val
= s
->size
;
3975 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3979 /* My reading of the SVR4 ABI indicates that the
3980 procedure linkage table relocs (DT_JMPREL) should be
3981 included in the overall relocs (DT_REL). This is
3982 what Solaris does. However, UnixWare can not handle
3983 that case. Therefore, we override the DT_RELSZ entry
3984 here to make it not include the JMPREL relocs. Since
3985 the linker script arranges for .rel.plt to follow all
3986 other relocation sections, we don't have to worry
3987 about changing the DT_REL entry. */
3988 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3990 dyn
.d_un
.d_val
-= s
->size
;
3991 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3994 /* Set the bottom bit of DT_INIT/FINI if the
3995 corresponding function is Thumb. */
3997 name
= info
->init_function
;
4000 name
= info
->fini_function
;
4002 /* If it wasn't set by elf_bfd_final_link
4003 then there is nothing to adjust. */
4004 if (dyn
.d_un
.d_val
!= 0)
4006 struct elf_link_hash_entry
* eh
;
4008 eh
= elf_link_hash_lookup (elf_hash_table (info
), name
,
4009 FALSE
, FALSE
, TRUE
);
4010 if (eh
!= (struct elf_link_hash_entry
*) NULL
4011 && ELF_ST_TYPE (eh
->type
) == STT_ARM_TFUNC
)
4013 dyn
.d_un
.d_val
|= 1;
4014 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4021 /* Fill in the first entry in the procedure linkage table. */
4024 bfd_vma got_displacement
;
4026 /* Calculate the displacement between the PLT slot and &GOT[0]. */
4027 got_displacement
= (sgot
->output_section
->vma
4028 + sgot
->output_offset
4029 - splt
->output_section
->vma
4030 - splt
->output_offset
4033 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[0], splt
->contents
+ 0);
4034 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[1], splt
->contents
+ 4);
4035 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[2], splt
->contents
+ 8);
4036 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[3], splt
->contents
+ 12);
4037 #ifdef FOUR_WORD_PLT
4038 /* The displacement value goes in the otherwise-unused last word of
4039 the second entry. */
4040 bfd_put_32 (output_bfd
, got_displacement
, splt
->contents
+ 28);
4042 bfd_put_32 (output_bfd
, got_displacement
, splt
->contents
+ 16);
4046 /* UnixWare sets the entsize of .plt to 4, although that doesn't
4047 really seem like the right value. */
4048 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
4051 /* Fill in the first three entries in the global offset table. */
4055 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
4057 bfd_put_32 (output_bfd
,
4058 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
4060 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
4061 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
4064 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
4070 elf32_arm_post_process_headers (abfd
, link_info
)
4072 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
;
4074 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
4075 struct elf32_arm_link_hash_table
*globals
;
4077 i_ehdrp
= elf_elfheader (abfd
);
4079 i_ehdrp
->e_ident
[EI_OSABI
] = ARM_ELF_OS_ABI_VERSION
;
4080 i_ehdrp
->e_ident
[EI_ABIVERSION
] = ARM_ELF_ABI_VERSION
;
4084 globals
= elf32_arm_hash_table (link_info
);
4085 if (globals
->byteswap_code
)
4086 i_ehdrp
->e_flags
|= EF_ARM_BE8
;
4090 static enum elf_reloc_type_class
4091 elf32_arm_reloc_type_class (rela
)
4092 const Elf_Internal_Rela
*rela
;
4094 switch ((int) ELF32_R_TYPE (rela
->r_info
))
4096 case R_ARM_RELATIVE
:
4097 return reloc_class_relative
;
4098 case R_ARM_JUMP_SLOT
:
4099 return reloc_class_plt
;
4101 return reloc_class_copy
;
4103 return reloc_class_normal
;
4107 static bfd_boolean elf32_arm_section_flags
PARAMS ((flagword
*, const Elf_Internal_Shdr
*));
4108 static void elf32_arm_final_write_processing
PARAMS ((bfd
*, bfd_boolean
));
4110 /* Set the right machine number for an Arm ELF file. */
4113 elf32_arm_section_flags (flags
, hdr
)
4115 const Elf_Internal_Shdr
*hdr
;
4117 if (hdr
->sh_type
== SHT_NOTE
)
4118 *flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_CONTENTS
;
4124 elf32_arm_final_write_processing (abfd
, linker
)
4126 bfd_boolean linker ATTRIBUTE_UNUSED
;
4128 bfd_arm_update_notes (abfd
, ARM_NOTE_SECTION
);
4132 /* Called for each symbol. Builds a section map based on mapping symbols.
4133 Does not alter any of the symbols. */
4136 elf32_arm_output_symbol_hook (struct bfd_link_info
*info
,
4138 Elf_Internal_Sym
*elfsym
,
4139 asection
*input_sec
,
4140 struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
4143 elf32_arm_section_map
*map
;
4144 struct elf32_arm_link_hash_table
*globals
;
4146 /* Only do this on final link. */
4147 if (info
->relocatable
)
4150 /* Only build a map if we need to byteswap code. */
4151 globals
= elf32_arm_hash_table (info
);
4152 if (!globals
->byteswap_code
)
4155 /* We only want mapping symbols. */
4163 mapcount
= ++(elf32_arm_section_data (input_sec
)->mapcount
);
4164 map
= elf32_arm_section_data (input_sec
)->map
;
4165 /* TODO: This may be inefficient, but we probably don't usually have many
4166 mapping symbols per section. */
4167 map
= bfd_realloc (map
, mapcount
* sizeof (elf32_arm_section_map
));
4168 elf32_arm_section_data (input_sec
)->map
= map
;
4170 map
[mapcount
- 1].vma
= elfsym
->st_value
;
4171 map
[mapcount
- 1].type
= name
[1];
4176 /* Allocate target specific section data. */
4179 elf32_arm_new_section_hook (bfd
*abfd
, asection
*sec
)
4181 struct _arm_elf_section_data
*sdata
;
4182 bfd_size_type amt
= sizeof (*sdata
);
4184 sdata
= bfd_zalloc (abfd
, amt
);
4187 sec
->used_by_bfd
= sdata
;
4189 return _bfd_elf_new_section_hook (abfd
, sec
);
4193 /* Used to order a list of mapping symbols by address. */
4196 elf32_arm_compare_mapping (const void * a
, const void * b
)
4198 return ((const elf32_arm_section_map
*) a
)->vma
4199 > ((const elf32_arm_section_map
*) b
)->vma
;
4203 /* Do code byteswapping. Return FALSE afterwards so that the section is
4204 written out as normal. */
4207 elf32_arm_write_section (bfd
*output_bfd ATTRIBUTE_UNUSED
, asection
*sec
,
4211 elf32_arm_section_map
*map
;
4218 mapcount
= elf32_arm_section_data (sec
)->mapcount
;
4219 map
= elf32_arm_section_data (sec
)->map
;
4224 qsort (map
, mapcount
, sizeof (elf32_arm_section_map
),
4225 elf32_arm_compare_mapping
);
4227 offset
= sec
->output_section
->vma
+ sec
->output_offset
;
4228 ptr
= map
[0].vma
- offset
;
4229 for (i
= 0; i
< mapcount
; i
++)
4231 if (i
== mapcount
- 1)
4234 end
= map
[i
+ 1].vma
- offset
;
4236 switch (map
[i
].type
)
4239 /* Byte swap code words. */
4240 while (ptr
+ 3 < end
)
4242 tmp
= contents
[ptr
];
4243 contents
[ptr
] = contents
[ptr
+ 3];
4244 contents
[ptr
+ 3] = tmp
;
4245 tmp
= contents
[ptr
+ 1];
4246 contents
[ptr
+ 1] = contents
[ptr
+ 2];
4247 contents
[ptr
+ 2] = tmp
;
4253 /* Byte swap code halfwords. */
4254 while (ptr
+ 1 < end
)
4256 tmp
= contents
[ptr
];
4257 contents
[ptr
] = contents
[ptr
+ 1];
4258 contents
[ptr
+ 1] = tmp
;
4264 /* Leave data alone. */
4273 #define ELF_ARCH bfd_arch_arm
4274 #define ELF_MACHINE_CODE EM_ARM
4275 #ifdef __QNXTARGET__
4276 #define ELF_MAXPAGESIZE 0x1000
4278 #define ELF_MAXPAGESIZE 0x8000
4281 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
4282 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
4283 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
4284 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
4285 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
4286 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
4287 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
4288 #define bfd_elf32_new_section_hook elf32_arm_new_section_hook
4290 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
4291 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
4292 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
4293 #define elf_backend_check_relocs elf32_arm_check_relocs
4294 #define elf_backend_relocate_section elf32_arm_relocate_section
4295 #define elf_backend_write_section elf32_arm_write_section
4296 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
4297 #define elf_backend_create_dynamic_sections elf32_arm_create_dynamic_sections
4298 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
4299 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
4300 #define elf_backend_link_output_symbol_hook elf32_arm_output_symbol_hook
4301 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
4302 #define elf_backend_post_process_headers elf32_arm_post_process_headers
4303 #define elf_backend_reloc_type_class elf32_arm_reloc_type_class
4304 #define elf_backend_object_p elf32_arm_object_p
4305 #define elf_backend_section_flags elf32_arm_section_flags
4306 #define elf_backend_final_write_processing elf32_arm_final_write_processing
4307 #define elf_backend_copy_indirect_symbol elf32_arm_copy_indirect_symbol
4309 #define elf_backend_can_refcount 1
4310 #define elf_backend_can_gc_sections 1
4311 #define elf_backend_plt_readonly 1
4312 #define elf_backend_want_got_plt 1
4313 #define elf_backend_want_plt_sym 0
4315 #define elf_backend_rela_normal 1
4318 #define elf_backend_got_header_size 12
4320 #include "elf32-target.h"