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));
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 /* The ARM linker needs to keep track of the number of relocs that it
194 decides to copy in check_relocs for each symbol. This is so that
195 it can discard PC relative relocs if it doesn't need them when
196 linking with -Bsymbolic. We store the information in a field
197 extending the regular ELF linker hash table. */
199 /* This structure keeps track of the number of PC relative relocs we
200 have copied for a given symbol. */
201 struct elf32_arm_relocs_copied
204 struct elf32_arm_relocs_copied
* next
;
205 /* A section in dynobj. */
207 /* Number of relocs copied in this section. */
211 /* Arm ELF linker hash entry. */
212 struct elf32_arm_link_hash_entry
214 struct elf_link_hash_entry root
;
216 /* Number of PC relative relocs copied for this symbol. */
217 struct elf32_arm_relocs_copied
* relocs_copied
;
220 /* Traverse an arm ELF linker hash table. */
221 #define elf32_arm_link_hash_traverse(table, func, info) \
222 (elf_link_hash_traverse \
224 (bfd_boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
227 /* Get the ARM elf linker hash table from a link_info structure. */
228 #define elf32_arm_hash_table(info) \
229 ((struct elf32_arm_link_hash_table *) ((info)->hash))
231 /* ARM ELF linker hash table. */
232 struct elf32_arm_link_hash_table
234 /* The main hash table. */
235 struct elf_link_hash_table root
;
237 /* The size in bytes of the section containing the Thumb-to-ARM glue. */
238 bfd_size_type thumb_glue_size
;
240 /* The size in bytes of the section containing the ARM-to-Thumb glue. */
241 bfd_size_type arm_glue_size
;
243 /* An arbitrary input BFD chosen to hold the glue sections. */
244 bfd
* bfd_of_glue_owner
;
246 /* A boolean indicating whether knowledge of the ARM's pipeline
247 length should be applied by the linker. */
248 int no_pipeline_knowledge
;
250 /* Short-cuts to get to dynamic linker sections. */
259 /* Small local sym to section mapping cache. */
260 struct sym_sec_cache sym_sec
;
263 /* Create an entry in an ARM ELF linker hash table. */
265 static struct bfd_hash_entry
*
266 elf32_arm_link_hash_newfunc (entry
, table
, string
)
267 struct bfd_hash_entry
* entry
;
268 struct bfd_hash_table
* table
;
271 struct elf32_arm_link_hash_entry
* ret
=
272 (struct elf32_arm_link_hash_entry
*) entry
;
274 /* Allocate the structure if it has not already been allocated by a
276 if (ret
== (struct elf32_arm_link_hash_entry
*) NULL
)
277 ret
= ((struct elf32_arm_link_hash_entry
*)
278 bfd_hash_allocate (table
,
279 sizeof (struct elf32_arm_link_hash_entry
)));
280 if (ret
== (struct elf32_arm_link_hash_entry
*) NULL
)
281 return (struct bfd_hash_entry
*) ret
;
283 /* Call the allocation method of the superclass. */
284 ret
= ((struct elf32_arm_link_hash_entry
*)
285 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
287 if (ret
!= (struct elf32_arm_link_hash_entry
*) NULL
)
288 ret
->relocs_copied
= NULL
;
290 return (struct bfd_hash_entry
*) ret
;
293 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
294 shortcuts to them in our hash table. */
297 create_got_section (dynobj
, info
)
299 struct bfd_link_info
*info
;
301 struct elf32_arm_link_hash_table
*htab
;
303 if (! _bfd_elf_create_got_section (dynobj
, info
))
306 htab
= elf32_arm_hash_table (info
);
307 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
308 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
309 if (!htab
->sgot
|| !htab
->sgotplt
)
312 htab
->srelgot
= bfd_make_section (dynobj
, ".rel.got");
313 if (htab
->srelgot
== NULL
314 || ! bfd_set_section_flags (dynobj
, htab
->srelgot
,
315 (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
316 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
318 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 2))
323 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
324 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
328 elf32_arm_create_dynamic_sections (dynobj
, info
)
330 struct bfd_link_info
*info
;
332 struct elf32_arm_link_hash_table
*htab
;
334 htab
= elf32_arm_hash_table (info
);
335 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
338 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
341 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
342 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rel.plt");
343 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
345 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rel.bss");
347 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
348 || (!info
->shared
&& !htab
->srelbss
))
354 /* Copy the extra info we tack onto an elf_link_hash_entry. */
357 elf32_arm_copy_indirect_symbol (const struct elf_backend_data
*bed
,
358 struct elf_link_hash_entry
*dir
,
359 struct elf_link_hash_entry
*ind
)
361 struct elf32_arm_link_hash_entry
*edir
, *eind
;
363 edir
= (struct elf32_arm_link_hash_entry
*) dir
;
364 eind
= (struct elf32_arm_link_hash_entry
*) ind
;
366 if (eind
->relocs_copied
!= NULL
)
368 if (edir
->relocs_copied
!= NULL
)
370 struct elf32_arm_relocs_copied
**pp
;
371 struct elf32_arm_relocs_copied
*p
;
373 if (ind
->root
.type
== bfd_link_hash_indirect
)
376 /* Add reloc counts against the weak sym to the strong sym
377 list. Merge any entries against the same section. */
378 for (pp
= &eind
->relocs_copied
; (p
= *pp
) != NULL
; )
380 struct elf32_arm_relocs_copied
*q
;
382 for (q
= edir
->relocs_copied
; q
!= NULL
; q
= q
->next
)
383 if (q
->section
== p
->section
)
385 q
->count
+= p
->count
;
392 *pp
= edir
->relocs_copied
;
395 edir
->relocs_copied
= eind
->relocs_copied
;
396 eind
->relocs_copied
= NULL
;
399 _bfd_elf_link_hash_copy_indirect (bed
, dir
, ind
);
402 /* Create an ARM elf linker hash table. */
404 static struct bfd_link_hash_table
*
405 elf32_arm_link_hash_table_create (abfd
)
408 struct elf32_arm_link_hash_table
*ret
;
409 bfd_size_type amt
= sizeof (struct elf32_arm_link_hash_table
);
411 ret
= (struct elf32_arm_link_hash_table
*) bfd_malloc (amt
);
412 if (ret
== (struct elf32_arm_link_hash_table
*) NULL
)
415 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
416 elf32_arm_link_hash_newfunc
))
429 ret
->thumb_glue_size
= 0;
430 ret
->arm_glue_size
= 0;
431 ret
->bfd_of_glue_owner
= NULL
;
432 ret
->no_pipeline_knowledge
= 0;
433 ret
->sym_sec
.abfd
= NULL
;
435 return &ret
->root
.root
;
438 /* Locate the Thumb encoded calling stub for NAME. */
440 static struct elf_link_hash_entry
*
441 find_thumb_glue (link_info
, name
, input_bfd
)
442 struct bfd_link_info
*link_info
;
447 struct elf_link_hash_entry
*hash
;
448 struct elf32_arm_link_hash_table
*hash_table
;
450 /* We need a pointer to the armelf specific hash table. */
451 hash_table
= elf32_arm_hash_table (link_info
);
453 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
454 + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1);
456 BFD_ASSERT (tmp_name
);
458 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
460 hash
= elf_link_hash_lookup
461 (&(hash_table
)->root
, tmp_name
, FALSE
, FALSE
, TRUE
);
464 /* xgettext:c-format */
465 (*_bfd_error_handler
) (_("%s: unable to find THUMB glue '%s' for `%s'"),
466 bfd_archive_filename (input_bfd
), tmp_name
, name
);
473 /* Locate the ARM encoded calling stub for NAME. */
475 static struct elf_link_hash_entry
*
476 find_arm_glue (link_info
, name
, input_bfd
)
477 struct bfd_link_info
*link_info
;
482 struct elf_link_hash_entry
*myh
;
483 struct elf32_arm_link_hash_table
*hash_table
;
485 /* We need a pointer to the elfarm specific hash table. */
486 hash_table
= elf32_arm_hash_table (link_info
);
488 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
489 + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1);
491 BFD_ASSERT (tmp_name
);
493 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
495 myh
= elf_link_hash_lookup
496 (&(hash_table
)->root
, tmp_name
, FALSE
, FALSE
, TRUE
);
499 /* xgettext:c-format */
500 (*_bfd_error_handler
) (_("%s: unable to find ARM glue '%s' for `%s'"),
501 bfd_archive_filename (input_bfd
), tmp_name
, name
);
515 .word func @ behave as if you saw a ARM_32 reloc. */
517 #define ARM2THUMB_GLUE_SIZE 12
518 static const insn32 a2t1_ldr_insn
= 0xe59fc000;
519 static const insn32 a2t2_bx_r12_insn
= 0xe12fff1c;
520 static const insn32 a2t3_func_addr_insn
= 0x00000001;
522 /* Thumb->ARM: Thumb->(non-interworking aware) ARM
526 __func_from_thumb: __func_from_thumb:
528 nop ldr r6, __func_addr
530 __func_change_to_arm: bx r6
532 __func_back_to_thumb:
538 #define THUMB2ARM_GLUE_SIZE 8
539 static const insn16 t2a1_bx_pc_insn
= 0x4778;
540 static const insn16 t2a2_noop_insn
= 0x46c0;
541 static const insn32 t2a3_b_insn
= 0xea000000;
543 #ifndef ELFARM_NABI_C_INCLUDED
545 bfd_elf32_arm_allocate_interworking_sections (info
)
546 struct bfd_link_info
* info
;
550 struct elf32_arm_link_hash_table
* globals
;
552 globals
= elf32_arm_hash_table (info
);
554 BFD_ASSERT (globals
!= NULL
);
556 if (globals
->arm_glue_size
!= 0)
558 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
560 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
561 ARM2THUMB_GLUE_SECTION_NAME
);
563 BFD_ASSERT (s
!= NULL
);
565 foo
= (bfd_byte
*) bfd_alloc (globals
->bfd_of_glue_owner
,
566 globals
->arm_glue_size
);
568 s
->_raw_size
= s
->_cooked_size
= globals
->arm_glue_size
;
572 if (globals
->thumb_glue_size
!= 0)
574 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
576 s
= bfd_get_section_by_name
577 (globals
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
579 BFD_ASSERT (s
!= NULL
);
581 foo
= (bfd_byte
*) bfd_alloc (globals
->bfd_of_glue_owner
,
582 globals
->thumb_glue_size
);
584 s
->_raw_size
= s
->_cooked_size
= globals
->thumb_glue_size
;
592 record_arm_to_thumb_glue (link_info
, h
)
593 struct bfd_link_info
* link_info
;
594 struct elf_link_hash_entry
* h
;
596 const char * name
= h
->root
.root
.string
;
599 struct elf_link_hash_entry
* myh
;
600 struct bfd_link_hash_entry
* bh
;
601 struct elf32_arm_link_hash_table
* globals
;
604 globals
= elf32_arm_hash_table (link_info
);
606 BFD_ASSERT (globals
!= NULL
);
607 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
609 s
= bfd_get_section_by_name
610 (globals
->bfd_of_glue_owner
, ARM2THUMB_GLUE_SECTION_NAME
);
612 BFD_ASSERT (s
!= NULL
);
614 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
615 + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1);
617 BFD_ASSERT (tmp_name
);
619 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
621 myh
= elf_link_hash_lookup
622 (&(globals
)->root
, tmp_name
, FALSE
, FALSE
, TRUE
);
626 /* We've already seen this guy. */
631 /* The only trick here is using hash_table->arm_glue_size as the value. Even
632 though the section isn't allocated yet, this is where we will be putting
635 val
= globals
->arm_glue_size
+ 1;
636 _bfd_generic_link_add_one_symbol (link_info
, globals
->bfd_of_glue_owner
,
637 tmp_name
, BSF_GLOBAL
, s
, val
,
638 NULL
, TRUE
, FALSE
, &bh
);
642 globals
->arm_glue_size
+= ARM2THUMB_GLUE_SIZE
;
648 record_thumb_to_arm_glue (link_info
, h
)
649 struct bfd_link_info
*link_info
;
650 struct elf_link_hash_entry
*h
;
652 const char *name
= h
->root
.root
.string
;
655 struct elf_link_hash_entry
*myh
;
656 struct bfd_link_hash_entry
*bh
;
657 struct elf32_arm_link_hash_table
*hash_table
;
661 hash_table
= elf32_arm_hash_table (link_info
);
663 BFD_ASSERT (hash_table
!= NULL
);
664 BFD_ASSERT (hash_table
->bfd_of_glue_owner
!= NULL
);
666 s
= bfd_get_section_by_name
667 (hash_table
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
669 BFD_ASSERT (s
!= NULL
);
671 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
672 + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1);
674 BFD_ASSERT (tmp_name
);
676 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
678 myh
= elf_link_hash_lookup
679 (&(hash_table
)->root
, tmp_name
, FALSE
, FALSE
, TRUE
);
683 /* We've already seen this guy. */
689 val
= hash_table
->thumb_glue_size
+ 1;
690 _bfd_generic_link_add_one_symbol (link_info
, hash_table
->bfd_of_glue_owner
,
691 tmp_name
, BSF_GLOBAL
, s
, val
,
692 NULL
, TRUE
, FALSE
, &bh
);
694 /* If we mark it 'Thumb', the disassembler will do a better job. */
695 myh
= (struct elf_link_hash_entry
*) bh
;
696 bind
= ELF_ST_BIND (myh
->type
);
697 myh
->type
= ELF_ST_INFO (bind
, STT_ARM_TFUNC
);
701 #define CHANGE_TO_ARM "__%s_change_to_arm"
702 #define BACK_FROM_ARM "__%s_back_from_arm"
704 /* Allocate another symbol to mark where we switch to Arm mode. */
705 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
706 + strlen (CHANGE_TO_ARM
) + 1);
708 BFD_ASSERT (tmp_name
);
710 sprintf (tmp_name
, CHANGE_TO_ARM
, name
);
713 val
= hash_table
->thumb_glue_size
+ 4,
714 _bfd_generic_link_add_one_symbol (link_info
, hash_table
->bfd_of_glue_owner
,
715 tmp_name
, BSF_LOCAL
, s
, val
,
716 NULL
, TRUE
, FALSE
, &bh
);
720 hash_table
->thumb_glue_size
+= THUMB2ARM_GLUE_SIZE
;
725 /* Add the glue sections to ABFD. This function is called from the
726 linker scripts in ld/emultempl/{armelf}.em. */
729 bfd_elf32_arm_add_glue_sections_to_bfd (abfd
, info
)
731 struct bfd_link_info
*info
;
736 /* If we are only performing a partial
737 link do not bother adding the glue. */
738 if (info
->relocatable
)
741 sec
= bfd_get_section_by_name (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
745 /* Note: we do not include the flag SEC_LINKER_CREATED, as this
746 will prevent elf_link_input_bfd() from processing the contents
748 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_CODE
| SEC_READONLY
;
750 sec
= bfd_make_section (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
753 || !bfd_set_section_flags (abfd
, sec
, flags
)
754 || !bfd_set_section_alignment (abfd
, sec
, 2))
757 /* Set the gc mark to prevent the section from being removed by garbage
758 collection, despite the fact that no relocs refer to this section. */
762 sec
= bfd_get_section_by_name (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
766 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_CODE
| SEC_READONLY
;
768 sec
= bfd_make_section (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
771 || !bfd_set_section_flags (abfd
, sec
, flags
)
772 || !bfd_set_section_alignment (abfd
, sec
, 2))
781 /* Select a BFD to be used to hold the sections used by the glue code.
782 This function is called from the linker scripts in ld/emultempl/
786 bfd_elf32_arm_get_bfd_for_interworking (abfd
, info
)
788 struct bfd_link_info
*info
;
790 struct elf32_arm_link_hash_table
*globals
;
792 /* If we are only performing a partial link
793 do not bother getting a bfd to hold the glue. */
794 if (info
->relocatable
)
797 globals
= elf32_arm_hash_table (info
);
799 BFD_ASSERT (globals
!= NULL
);
801 if (globals
->bfd_of_glue_owner
!= NULL
)
804 /* Save the bfd for later use. */
805 globals
->bfd_of_glue_owner
= abfd
;
811 bfd_elf32_arm_process_before_allocation (abfd
, link_info
, no_pipeline_knowledge
)
813 struct bfd_link_info
*link_info
;
814 int no_pipeline_knowledge
;
816 Elf_Internal_Shdr
*symtab_hdr
;
817 Elf_Internal_Rela
*internal_relocs
= NULL
;
818 Elf_Internal_Rela
*irel
, *irelend
;
819 bfd_byte
*contents
= NULL
;
822 struct elf32_arm_link_hash_table
*globals
;
824 /* If we are only performing a partial link do not bother
825 to construct any glue. */
826 if (link_info
->relocatable
)
829 /* Here we have a bfd that is to be included on the link. We have a hook
830 to do reloc rummaging, before section sizes are nailed down. */
831 globals
= elf32_arm_hash_table (link_info
);
833 BFD_ASSERT (globals
!= NULL
);
834 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
836 globals
->no_pipeline_knowledge
= no_pipeline_knowledge
;
838 /* Rummage around all the relocs and map the glue vectors. */
839 sec
= abfd
->sections
;
844 for (; sec
!= NULL
; sec
= sec
->next
)
846 if (sec
->reloc_count
== 0)
849 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
851 /* Load the relocs. */
853 = _bfd_elf_link_read_relocs (abfd
, sec
, (PTR
) NULL
,
854 (Elf_Internal_Rela
*) NULL
, FALSE
);
856 if (internal_relocs
== NULL
)
859 irelend
= internal_relocs
+ sec
->reloc_count
;
860 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
863 unsigned long r_index
;
865 struct elf_link_hash_entry
*h
;
867 r_type
= ELF32_R_TYPE (irel
->r_info
);
868 r_index
= ELF32_R_SYM (irel
->r_info
);
870 /* These are the only relocation types we care about. */
871 if ( r_type
!= R_ARM_PC24
872 && r_type
!= R_ARM_THM_PC22
)
875 /* Get the section contents if we haven't done so already. */
876 if (contents
== NULL
)
878 /* Get cached copy if it exists. */
879 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
880 contents
= elf_section_data (sec
)->this_hdr
.contents
;
883 /* Go get them off disk. */
884 contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
885 if (contents
== NULL
)
888 if (!bfd_get_section_contents (abfd
, sec
, contents
,
889 (file_ptr
) 0, sec
->_raw_size
))
894 /* If the relocation is not against a symbol it cannot concern us. */
897 /* We don't care about local symbols. */
898 if (r_index
< symtab_hdr
->sh_info
)
901 /* This is an external symbol. */
902 r_index
-= symtab_hdr
->sh_info
;
903 h
= (struct elf_link_hash_entry
*)
904 elf_sym_hashes (abfd
)[r_index
];
906 /* If the relocation is against a static symbol it must be within
907 the current section and so cannot be a cross ARM/Thumb relocation. */
914 /* This one is a call from arm code. We need to look up
915 the target of the call. If it is a thumb target, we
917 if (ELF_ST_TYPE(h
->type
) == STT_ARM_TFUNC
)
918 record_arm_to_thumb_glue (link_info
, h
);
922 /* This one is a call from thumb code. We look
923 up the target of the call. If it is not a thumb
924 target, we insert glue. */
925 if (ELF_ST_TYPE (h
->type
) != STT_ARM_TFUNC
)
926 record_thumb_to_arm_glue (link_info
, h
);
935 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
939 if (internal_relocs
!= NULL
940 && elf_section_data (sec
)->relocs
!= internal_relocs
)
941 free (internal_relocs
);
942 internal_relocs
= NULL
;
949 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
951 if (internal_relocs
!= NULL
952 && elf_section_data (sec
)->relocs
!= internal_relocs
)
953 free (internal_relocs
);
959 /* The thumb form of a long branch is a bit finicky, because the offset
960 encoding is split over two fields, each in it's own instruction. They
961 can occur in any order. So given a thumb form of long branch, and an
962 offset, insert the offset into the thumb branch and return finished
965 It takes two thumb instructions to encode the target address. Each has
966 11 bits to invest. The upper 11 bits are stored in one (identified by
967 H-0.. see below), the lower 11 bits are stored in the other (identified
970 Combine together and shifted left by 1 (it's a half word address) and
974 H-0, upper address-0 = 000
976 H-1, lower address-0 = 800
978 They can be ordered either way, but the arm tools I've seen always put
979 the lower one first. It probably doesn't matter. krk@cygnus.com
981 XXX: Actually the order does matter. The second instruction (H-1)
982 moves the computed address into the PC, so it must be the second one
983 in the sequence. The problem, however is that whilst little endian code
984 stores the instructions in HI then LOW order, big endian code does the
985 reverse. nickc@cygnus.com. */
987 #define LOW_HI_ORDER 0xF800F000
988 #define HI_LOW_ORDER 0xF000F800
991 insert_thumb_branch (br_insn
, rel_off
)
995 unsigned int low_bits
;
996 unsigned int high_bits
;
998 BFD_ASSERT ((rel_off
& 1) != 1);
1000 rel_off
>>= 1; /* Half word aligned address. */
1001 low_bits
= rel_off
& 0x000007FF; /* The bottom 11 bits. */
1002 high_bits
= (rel_off
>> 11) & 0x000007FF; /* The top 11 bits. */
1004 if ((br_insn
& LOW_HI_ORDER
) == LOW_HI_ORDER
)
1005 br_insn
= LOW_HI_ORDER
| (low_bits
<< 16) | high_bits
;
1006 else if ((br_insn
& HI_LOW_ORDER
) == HI_LOW_ORDER
)
1007 br_insn
= HI_LOW_ORDER
| (high_bits
<< 16) | low_bits
;
1009 /* FIXME: abort is probably not the right call. krk@cygnus.com */
1010 abort (); /* error - not a valid branch instruction form. */
1015 /* Thumb code calling an ARM function. */
1018 elf32_thumb_to_arm_stub (info
, name
, input_bfd
, output_bfd
, input_section
,
1019 hit_data
, sym_sec
, offset
, addend
, val
)
1020 struct bfd_link_info
* info
;
1024 asection
* input_section
;
1025 bfd_byte
* hit_data
;
1028 bfd_signed_vma addend
;
1033 unsigned long int tmp
;
1034 long int ret_offset
;
1035 struct elf_link_hash_entry
* myh
;
1036 struct elf32_arm_link_hash_table
* globals
;
1038 myh
= find_thumb_glue (info
, name
, input_bfd
);
1042 globals
= elf32_arm_hash_table (info
);
1044 BFD_ASSERT (globals
!= NULL
);
1045 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
1047 my_offset
= myh
->root
.u
.def
.value
;
1049 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
1050 THUMB2ARM_GLUE_SECTION_NAME
);
1052 BFD_ASSERT (s
!= NULL
);
1053 BFD_ASSERT (s
->contents
!= NULL
);
1054 BFD_ASSERT (s
->output_section
!= NULL
);
1056 if ((my_offset
& 0x01) == 0x01)
1059 && sym_sec
->owner
!= NULL
1060 && !INTERWORK_FLAG (sym_sec
->owner
))
1062 (*_bfd_error_handler
)
1063 (_("%s(%s): warning: interworking not enabled."),
1064 bfd_archive_filename (sym_sec
->owner
), name
);
1065 (*_bfd_error_handler
)
1066 (_(" first occurrence: %s: thumb call to arm"),
1067 bfd_archive_filename (input_bfd
));
1073 myh
->root
.u
.def
.value
= my_offset
;
1075 bfd_put_16 (output_bfd
, (bfd_vma
) t2a1_bx_pc_insn
,
1076 s
->contents
+ my_offset
);
1078 bfd_put_16 (output_bfd
, (bfd_vma
) t2a2_noop_insn
,
1079 s
->contents
+ my_offset
+ 2);
1082 /* Address of destination of the stub. */
1083 ((bfd_signed_vma
) val
)
1085 /* Offset from the start of the current section to the start of the stubs. */
1087 /* Offset of the start of this stub from the start of the stubs. */
1089 /* Address of the start of the current section. */
1090 + s
->output_section
->vma
)
1091 /* The branch instruction is 4 bytes into the stub. */
1093 /* ARM branches work from the pc of the instruction + 8. */
1096 bfd_put_32 (output_bfd
,
1097 (bfd_vma
) t2a3_b_insn
| ((ret_offset
>> 2) & 0x00FFFFFF),
1098 s
->contents
+ my_offset
+ 4);
1101 BFD_ASSERT (my_offset
<= globals
->thumb_glue_size
);
1103 /* Now go back and fix up the original BL insn to point to here. */
1105 /* Address of where the stub is located. */
1106 (s
->output_section
->vma
+ s
->output_offset
+ my_offset
)
1107 /* Address of where the BL is located. */
1108 - (input_section
->output_section
->vma
+ input_section
->output_offset
+ offset
)
1109 /* Addend in the relocation. */
1111 /* Biassing for PC-relative addressing. */
1114 tmp
= bfd_get_32 (input_bfd
, hit_data
1115 - input_section
->vma
);
1117 bfd_put_32 (output_bfd
,
1118 (bfd_vma
) insert_thumb_branch (tmp
, ret_offset
),
1119 hit_data
- input_section
->vma
);
1124 /* Arm code calling a Thumb function. */
1127 elf32_arm_to_thumb_stub (info
, name
, input_bfd
, output_bfd
, input_section
,
1128 hit_data
, sym_sec
, offset
, addend
, val
)
1129 struct bfd_link_info
* info
;
1133 asection
* input_section
;
1134 bfd_byte
* hit_data
;
1137 bfd_signed_vma addend
;
1140 unsigned long int tmp
;
1143 long int ret_offset
;
1144 struct elf_link_hash_entry
* myh
;
1145 struct elf32_arm_link_hash_table
* globals
;
1147 myh
= find_arm_glue (info
, name
, input_bfd
);
1151 globals
= elf32_arm_hash_table (info
);
1153 BFD_ASSERT (globals
!= NULL
);
1154 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
1156 my_offset
= myh
->root
.u
.def
.value
;
1157 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
1158 ARM2THUMB_GLUE_SECTION_NAME
);
1159 BFD_ASSERT (s
!= NULL
);
1160 BFD_ASSERT (s
->contents
!= NULL
);
1161 BFD_ASSERT (s
->output_section
!= NULL
);
1163 if ((my_offset
& 0x01) == 0x01)
1166 && sym_sec
->owner
!= NULL
1167 && !INTERWORK_FLAG (sym_sec
->owner
))
1169 (*_bfd_error_handler
)
1170 (_("%s(%s): warning: interworking not enabled."),
1171 bfd_archive_filename (sym_sec
->owner
), name
);
1172 (*_bfd_error_handler
)
1173 (_(" first occurrence: %s: arm call to thumb"),
1174 bfd_archive_filename (input_bfd
));
1178 myh
->root
.u
.def
.value
= my_offset
;
1180 bfd_put_32 (output_bfd
, (bfd_vma
) a2t1_ldr_insn
,
1181 s
->contents
+ my_offset
);
1183 bfd_put_32 (output_bfd
, (bfd_vma
) a2t2_bx_r12_insn
,
1184 s
->contents
+ my_offset
+ 4);
1186 /* It's a thumb address. Add the low order bit. */
1187 bfd_put_32 (output_bfd
, val
| a2t3_func_addr_insn
,
1188 s
->contents
+ my_offset
+ 8);
1191 BFD_ASSERT (my_offset
<= globals
->arm_glue_size
);
1193 tmp
= bfd_get_32 (input_bfd
, hit_data
);
1194 tmp
= tmp
& 0xFF000000;
1196 /* Somehow these are both 4 too far, so subtract 8. */
1197 ret_offset
= (s
->output_offset
1199 + s
->output_section
->vma
1200 - (input_section
->output_offset
1201 + input_section
->output_section
->vma
1205 tmp
= tmp
| ((ret_offset
>> 2) & 0x00FFFFFF);
1207 bfd_put_32 (output_bfd
, (bfd_vma
) tmp
, hit_data
- input_section
->vma
);
1212 /* Perform a relocation as part of a final link. */
1214 static bfd_reloc_status_type
1215 elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
1216 input_section
, contents
, rel
, value
,
1217 info
, sym_sec
, sym_name
, sym_flags
, h
)
1218 reloc_howto_type
* howto
;
1221 asection
* input_section
;
1222 bfd_byte
* contents
;
1223 Elf_Internal_Rela
* rel
;
1225 struct bfd_link_info
* info
;
1227 const char * sym_name
;
1229 struct elf_link_hash_entry
* h
;
1231 unsigned long r_type
= howto
->type
;
1232 unsigned long r_symndx
;
1233 bfd_byte
* hit_data
= contents
+ rel
->r_offset
;
1234 bfd
* dynobj
= NULL
;
1235 Elf_Internal_Shdr
* symtab_hdr
;
1236 struct elf_link_hash_entry
** sym_hashes
;
1237 bfd_vma
* local_got_offsets
;
1238 asection
* sgot
= NULL
;
1239 asection
* splt
= NULL
;
1240 asection
* sreloc
= NULL
;
1242 bfd_signed_vma signed_addend
;
1243 struct elf32_arm_link_hash_table
* globals
;
1245 /* If the start address has been set, then set the EF_ARM_HASENTRY
1246 flag. Setting this more than once is redundant, but the cost is
1247 not too high, and it keeps the code simple.
1249 The test is done here, rather than somewhere else, because the
1250 start address is only set just before the final link commences.
1252 Note - if the user deliberately sets a start address of 0, the
1253 flag will not be set. */
1254 if (bfd_get_start_address (output_bfd
) != 0)
1255 elf_elfheader (output_bfd
)->e_flags
|= EF_ARM_HASENTRY
;
1257 globals
= elf32_arm_hash_table (info
);
1259 dynobj
= elf_hash_table (info
)->dynobj
;
1262 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1263 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1265 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1266 sym_hashes
= elf_sym_hashes (input_bfd
);
1267 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1268 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1271 addend
= bfd_get_32 (input_bfd
, hit_data
) & howto
->src_mask
;
1273 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1276 signed_addend
&= ~ howto
->src_mask
;
1277 signed_addend
|= addend
;
1280 signed_addend
= addend
;
1282 addend
= signed_addend
= rel
->r_addend
;
1288 return bfd_reloc_ok
;
1297 /* r_symndx will be zero only for relocs against symbols
1298 from removed linkonce sections, or sections discarded by
1301 return bfd_reloc_ok
;
1303 /* Handle relocations which should use the PLT entry. ABS32/REL32
1304 will use the symbol's value, which may point to a PLT entry, but we
1305 don't need to handle that here. If we created a PLT entry, all
1306 branches in this object should go to it. */
1307 if ((r_type
!= R_ARM_ABS32
&& r_type
!= R_ARM_REL32
)
1310 && h
->plt
.offset
!= (bfd_vma
) -1)
1312 /* If we've created a .plt section, and assigned a PLT entry to
1313 this function, it should not be known to bind locally. If
1314 it were, we would have cleared the PLT entry. */
1315 BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info
, h
));
1317 value
= (splt
->output_section
->vma
1318 + splt
->output_offset
1320 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1321 contents
, rel
->r_offset
, value
,
1325 /* When generating a shared object, these relocations are copied
1326 into the output file to be resolved at run time. */
1328 && (input_section
->flags
& SEC_ALLOC
)
1330 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
1331 || h
->root
.type
!= bfd_link_hash_undefweak
)
1332 && r_type
!= R_ARM_PC24
1333 && r_type
!= R_ARM_PLT32
)
1335 Elf_Internal_Rela outrel
;
1337 bfd_boolean skip
, relocate
;
1343 name
= (bfd_elf_string_from_elf_section
1345 elf_elfheader (input_bfd
)->e_shstrndx
,
1346 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1348 return bfd_reloc_notsupported
;
1350 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
1351 && strcmp (bfd_get_section_name (input_bfd
,
1355 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1356 BFD_ASSERT (sreloc
!= NULL
);
1363 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
1365 if (outrel
.r_offset
== (bfd_vma
) -1)
1367 else if (outrel
.r_offset
== (bfd_vma
) -2)
1368 skip
= TRUE
, relocate
= TRUE
;
1369 outrel
.r_offset
+= (input_section
->output_section
->vma
1370 + input_section
->output_offset
);
1373 memset (&outrel
, 0, sizeof outrel
);
1378 || (h
->elf_link_hash_flags
1379 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1380 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1383 /* This symbol is local, or marked to become local. */
1385 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1388 loc
= sreloc
->contents
;
1389 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
1390 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
1392 /* If this reloc is against an external symbol, we do not want to
1393 fiddle with the addend. Otherwise, we need to include the symbol
1394 value so that it becomes an addend for the dynamic reloc. */
1396 return bfd_reloc_ok
;
1398 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1399 contents
, rel
->r_offset
, value
,
1402 else switch (r_type
)
1405 case R_ARM_XPC25
: /* Arm BLX instruction. */
1407 case R_ARM_PC24
: /* Arm B/BL instruction */
1410 if (r_type
== R_ARM_XPC25
)
1412 /* Check for Arm calling Arm function. */
1413 /* FIXME: Should we translate the instruction into a BL
1414 instruction instead ? */
1415 if (sym_flags
!= STT_ARM_TFUNC
)
1416 (*_bfd_error_handler
) (_("\
1417 %s: Warning: Arm BLX instruction targets Arm function '%s'."),
1418 bfd_archive_filename (input_bfd
),
1419 h
? h
->root
.root
.string
: "(local)");
1424 /* Check for Arm calling Thumb function. */
1425 if (sym_flags
== STT_ARM_TFUNC
)
1427 elf32_arm_to_thumb_stub (info
, sym_name
, input_bfd
, output_bfd
,
1428 input_section
, hit_data
, sym_sec
, rel
->r_offset
,
1429 signed_addend
, value
);
1430 return bfd_reloc_ok
;
1434 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1435 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0)
1437 /* The old way of doing things. Trearing the addend as a
1438 byte sized field and adding in the pipeline offset. */
1439 value
-= (input_section
->output_section
->vma
1440 + input_section
->output_offset
);
1441 value
-= rel
->r_offset
;
1444 if (! globals
->no_pipeline_knowledge
)
1449 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
1451 S is the address of the symbol in the relocation.
1452 P is address of the instruction being relocated.
1453 A is the addend (extracted from the instruction) in bytes.
1455 S is held in 'value'.
1456 P is the base address of the section containing the instruction
1457 plus the offset of the reloc into that section, ie:
1458 (input_section->output_section->vma +
1459 input_section->output_offset +
1461 A is the addend, converted into bytes, ie:
1464 Note: None of these operations have knowledge of the pipeline
1465 size of the processor, thus it is up to the assembler to encode
1466 this information into the addend. */
1467 value
-= (input_section
->output_section
->vma
1468 + input_section
->output_offset
);
1469 value
-= rel
->r_offset
;
1470 value
+= (signed_addend
<< howto
->size
);
1472 /* Previous versions of this code also used to add in the pipeline
1473 offset here. This is wrong because the linker is not supposed
1474 to know about such things, and one day it might change. In order
1475 to support old binaries that need the old behaviour however, so
1476 we attempt to detect which ABI was used to create the reloc. */
1477 if (! globals
->no_pipeline_knowledge
)
1479 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form */
1481 i_ehdrp
= elf_elfheader (input_bfd
);
1483 if (i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1488 signed_addend
= value
;
1489 signed_addend
>>= howto
->rightshift
;
1491 /* It is not an error for an undefined weak reference to be
1492 out of range. Any program that branches to such a symbol
1493 is going to crash anyway, so there is no point worrying
1494 about getting the destination exactly right. */
1495 if (! h
|| h
->root
.type
!= bfd_link_hash_undefweak
)
1497 /* Perform a signed range check. */
1498 if ( signed_addend
> ((bfd_signed_vma
) (howto
->dst_mask
>> 1))
1499 || signed_addend
< - ((bfd_signed_vma
) ((howto
->dst_mask
+ 1) >> 1)))
1500 return bfd_reloc_overflow
;
1504 /* If necessary set the H bit in the BLX instruction. */
1505 if (r_type
== R_ARM_XPC25
&& ((value
& 2) == 2))
1506 value
= (signed_addend
& howto
->dst_mask
)
1507 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
))
1511 value
= (signed_addend
& howto
->dst_mask
)
1512 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1517 if (sym_flags
== STT_ARM_TFUNC
)
1522 value
-= (input_section
->output_section
->vma
1523 + input_section
->output_offset
+ rel
->r_offset
);
1528 bfd_put_32 (input_bfd
, value
, hit_data
);
1529 return bfd_reloc_ok
;
1533 if ((long) value
> 0x7f || (long) value
< -0x80)
1534 return bfd_reloc_overflow
;
1536 bfd_put_8 (input_bfd
, value
, hit_data
);
1537 return bfd_reloc_ok
;
1542 if ((long) value
> 0x7fff || (long) value
< -0x8000)
1543 return bfd_reloc_overflow
;
1545 bfd_put_16 (input_bfd
, value
, hit_data
);
1546 return bfd_reloc_ok
;
1549 /* Support ldr and str instruction for the arm */
1550 /* Also thumb b (unconditional branch). ??? Really? */
1553 if ((long) value
> 0x7ff || (long) value
< -0x800)
1554 return bfd_reloc_overflow
;
1556 value
|= (bfd_get_32 (input_bfd
, hit_data
) & 0xfffff000);
1557 bfd_put_32 (input_bfd
, value
, hit_data
);
1558 return bfd_reloc_ok
;
1560 case R_ARM_THM_ABS5
:
1561 /* Support ldr and str instructions for the thumb. */
1563 /* Need to refetch addend. */
1564 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1565 /* ??? Need to determine shift amount from operand size. */
1566 addend
>>= howto
->rightshift
;
1570 /* ??? Isn't value unsigned? */
1571 if ((long) value
> 0x1f || (long) value
< -0x10)
1572 return bfd_reloc_overflow
;
1574 /* ??? Value needs to be properly shifted into place first. */
1575 value
|= bfd_get_16 (input_bfd
, hit_data
) & 0xf83f;
1576 bfd_put_16 (input_bfd
, value
, hit_data
);
1577 return bfd_reloc_ok
;
1580 case R_ARM_THM_XPC22
:
1582 case R_ARM_THM_PC22
:
1583 /* Thumb BL (branch long instruction). */
1586 bfd_boolean overflow
= FALSE
;
1587 bfd_vma upper_insn
= bfd_get_16 (input_bfd
, hit_data
);
1588 bfd_vma lower_insn
= bfd_get_16 (input_bfd
, hit_data
+ 2);
1589 bfd_signed_vma reloc_signed_max
= ((1 << (howto
->bitsize
- 1)) - 1) >> howto
->rightshift
;
1590 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1592 bfd_signed_vma signed_check
;
1595 /* Need to refetch the addend and squish the two 11 bit pieces
1598 bfd_vma upper
= upper_insn
& 0x7ff;
1599 bfd_vma lower
= lower_insn
& 0x7ff;
1600 upper
= (upper
^ 0x400) - 0x400; /* Sign extend. */
1601 addend
= (upper
<< 12) | (lower
<< 1);
1602 signed_addend
= addend
;
1606 if (r_type
== R_ARM_THM_XPC22
)
1608 /* Check for Thumb to Thumb call. */
1609 /* FIXME: Should we translate the instruction into a BL
1610 instruction instead ? */
1611 if (sym_flags
== STT_ARM_TFUNC
)
1612 (*_bfd_error_handler
) (_("\
1613 %s: Warning: Thumb BLX instruction targets thumb function '%s'."),
1614 bfd_archive_filename (input_bfd
),
1615 h
? h
->root
.root
.string
: "(local)");
1620 /* If it is not a call to Thumb, assume call to Arm.
1621 If it is a call relative to a section name, then it is not a
1622 function call at all, but rather a long jump. */
1623 if (sym_flags
!= STT_ARM_TFUNC
&& sym_flags
!= STT_SECTION
)
1625 if (elf32_thumb_to_arm_stub
1626 (info
, sym_name
, input_bfd
, output_bfd
, input_section
,
1627 hit_data
, sym_sec
, rel
->r_offset
, signed_addend
, value
))
1628 return bfd_reloc_ok
;
1630 return bfd_reloc_dangerous
;
1634 relocation
= value
+ signed_addend
;
1636 relocation
-= (input_section
->output_section
->vma
1637 + input_section
->output_offset
1640 if (! globals
->no_pipeline_knowledge
)
1642 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form. */
1644 i_ehdrp
= elf_elfheader (input_bfd
);
1646 /* Previous versions of this code also used to add in the pipline
1647 offset here. This is wrong because the linker is not supposed
1648 to know about such things, and one day it might change. In order
1649 to support old binaries that need the old behaviour however, so
1650 we attempt to detect which ABI was used to create the reloc. */
1651 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1652 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0
1653 || i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1657 check
= relocation
>> howto
->rightshift
;
1659 /* If this is a signed value, the rightshift just dropped
1660 leading 1 bits (assuming twos complement). */
1661 if ((bfd_signed_vma
) relocation
>= 0)
1662 signed_check
= check
;
1664 signed_check
= check
| ~((bfd_vma
) -1 >> howto
->rightshift
);
1666 /* Assumes two's complement. */
1667 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1671 if (r_type
== R_ARM_THM_XPC22
1672 && ((lower_insn
& 0x1800) == 0x0800))
1673 /* For a BLX instruction, make sure that the relocation is rounded up
1674 to a word boundary. This follows the semantics of the instruction
1675 which specifies that bit 1 of the target address will come from bit
1676 1 of the base address. */
1677 relocation
= (relocation
+ 2) & ~ 3;
1679 /* Put RELOCATION back into the insn. */
1680 upper_insn
= (upper_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 12) & 0x7ff);
1681 lower_insn
= (lower_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 1) & 0x7ff);
1683 /* Put the relocated value back in the object file: */
1684 bfd_put_16 (input_bfd
, upper_insn
, hit_data
);
1685 bfd_put_16 (input_bfd
, lower_insn
, hit_data
+ 2);
1687 return (overflow
? bfd_reloc_overflow
: bfd_reloc_ok
);
1691 case R_ARM_THM_PC11
:
1692 /* Thumb B (branch) instruction). */
1694 bfd_signed_vma relocation
;
1695 bfd_signed_vma reloc_signed_max
= (1 << (howto
->bitsize
- 1)) - 1;
1696 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1697 bfd_signed_vma signed_check
;
1700 /* Need to refetch addend. */
1701 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1702 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1705 signed_addend
&= ~ howto
->src_mask
;
1706 signed_addend
|= addend
;
1709 signed_addend
= addend
;
1710 /* The value in the insn has been right shifted. We need to
1711 undo this, so that we can perform the address calculation
1712 in terms of bytes. */
1713 signed_addend
<<= howto
->rightshift
;
1715 relocation
= value
+ signed_addend
;
1717 relocation
-= (input_section
->output_section
->vma
1718 + input_section
->output_offset
1721 relocation
>>= howto
->rightshift
;
1722 signed_check
= relocation
;
1723 relocation
&= howto
->dst_mask
;
1724 relocation
|= (bfd_get_16 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1726 bfd_put_16 (input_bfd
, relocation
, hit_data
);
1728 /* Assumes two's complement. */
1729 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1730 return bfd_reloc_overflow
;
1732 return bfd_reloc_ok
;
1735 case R_ARM_ALU_PCREL7_0
:
1736 case R_ARM_ALU_PCREL15_8
:
1737 case R_ARM_ALU_PCREL23_15
:
1742 insn
= bfd_get_32 (input_bfd
, hit_data
);
1744 /* Extract the addend. */
1745 addend
= (insn
& 0xff) << ((insn
& 0xf00) >> 7);
1746 signed_addend
= addend
;
1748 relocation
= value
+ signed_addend
;
1750 relocation
-= (input_section
->output_section
->vma
1751 + input_section
->output_offset
1753 insn
= (insn
& ~0xfff)
1754 | ((howto
->bitpos
<< 7) & 0xf00)
1755 | ((relocation
>> howto
->bitpos
) & 0xff);
1756 bfd_put_32 (input_bfd
, value
, hit_data
);
1758 return bfd_reloc_ok
;
1760 case R_ARM_GNU_VTINHERIT
:
1761 case R_ARM_GNU_VTENTRY
:
1762 return bfd_reloc_ok
;
1765 return bfd_reloc_notsupported
;
1767 case R_ARM_GLOB_DAT
:
1768 return bfd_reloc_notsupported
;
1770 case R_ARM_JUMP_SLOT
:
1771 return bfd_reloc_notsupported
;
1773 case R_ARM_RELATIVE
:
1774 return bfd_reloc_notsupported
;
1777 /* Relocation is relative to the start of the
1778 global offset table. */
1780 BFD_ASSERT (sgot
!= NULL
);
1782 return bfd_reloc_notsupported
;
1784 /* If we are addressing a Thumb function, we need to adjust the
1785 address by one, so that attempts to call the function pointer will
1786 correctly interpret it as Thumb code. */
1787 if (sym_flags
== STT_ARM_TFUNC
)
1790 /* Note that sgot->output_offset is not involved in this
1791 calculation. We always want the start of .got. If we
1792 define _GLOBAL_OFFSET_TABLE in a different way, as is
1793 permitted by the ABI, we might have to change this
1795 value
-= sgot
->output_section
->vma
;
1796 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1797 contents
, rel
->r_offset
, value
,
1801 /* Use global offset table as symbol value. */
1802 BFD_ASSERT (sgot
!= NULL
);
1805 return bfd_reloc_notsupported
;
1807 value
= sgot
->output_section
->vma
;
1808 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1809 contents
, rel
->r_offset
, value
,
1813 /* Relocation is to the entry for this symbol in the
1814 global offset table. */
1816 return bfd_reloc_notsupported
;
1823 off
= h
->got
.offset
;
1824 BFD_ASSERT (off
!= (bfd_vma
) -1);
1825 dyn
= globals
->root
.dynamic_sections_created
;
1827 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
1829 && SYMBOL_REFERENCES_LOCAL (info
, h
))
1830 || (ELF_ST_VISIBILITY (h
->other
)
1831 && h
->root
.type
== bfd_link_hash_undefweak
))
1833 /* This is actually a static link, or it is a -Bsymbolic link
1834 and the symbol is defined locally. We must initialize this
1835 entry in the global offset table. Since the offset must
1836 always be a multiple of 4, we use the least significant bit
1837 to record whether we have initialized it already.
1839 When doing a dynamic link, we create a .rel.got relocation
1840 entry to initialize the value. This is done in the
1841 finish_dynamic_symbol routine. */
1846 /* If we are addressing a Thumb function, we need to
1847 adjust the address by one, so that attempts to
1848 call the function pointer will correctly
1849 interpret it as Thumb code. */
1850 if (sym_flags
== STT_ARM_TFUNC
)
1853 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1858 value
= sgot
->output_offset
+ off
;
1864 BFD_ASSERT (local_got_offsets
!= NULL
&&
1865 local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1867 off
= local_got_offsets
[r_symndx
];
1869 /* The offset must always be a multiple of 4. We use the
1870 least significant bit to record whether we have already
1871 generated the necessary reloc. */
1876 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1881 Elf_Internal_Rela outrel
;
1884 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
1885 BFD_ASSERT (srelgot
!= NULL
);
1887 outrel
.r_offset
= (sgot
->output_section
->vma
1888 + sgot
->output_offset
1890 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1891 loc
= srelgot
->contents
;
1892 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rel
);
1893 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
1896 local_got_offsets
[r_symndx
] |= 1;
1899 value
= sgot
->output_offset
+ off
;
1902 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1903 contents
, rel
->r_offset
, value
,
1907 return bfd_reloc_notsupported
;
1909 case R_ARM_AMP_VCALL9
:
1910 return bfd_reloc_notsupported
;
1912 case R_ARM_RSBREL32
:
1913 return bfd_reloc_notsupported
;
1915 case R_ARM_THM_RPC22
:
1916 return bfd_reloc_notsupported
;
1919 return bfd_reloc_notsupported
;
1922 return bfd_reloc_notsupported
;
1925 return bfd_reloc_notsupported
;
1928 return bfd_reloc_notsupported
;
1931 return bfd_reloc_notsupported
;
1936 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
1938 arm_add_to_rel (abfd
, address
, howto
, increment
)
1941 reloc_howto_type
* howto
;
1942 bfd_signed_vma increment
;
1944 bfd_signed_vma addend
;
1946 if (howto
->type
== R_ARM_THM_PC22
)
1948 int upper_insn
, lower_insn
;
1951 upper_insn
= bfd_get_16 (abfd
, address
);
1952 lower_insn
= bfd_get_16 (abfd
, address
+ 2);
1953 upper
= upper_insn
& 0x7ff;
1954 lower
= lower_insn
& 0x7ff;
1956 addend
= (upper
<< 12) | (lower
<< 1);
1957 addend
+= increment
;
1960 upper_insn
= (upper_insn
& 0xf800) | ((addend
>> 11) & 0x7ff);
1961 lower_insn
= (lower_insn
& 0xf800) | (addend
& 0x7ff);
1963 bfd_put_16 (abfd
, (bfd_vma
) upper_insn
, address
);
1964 bfd_put_16 (abfd
, (bfd_vma
) lower_insn
, address
+ 2);
1970 contents
= bfd_get_32 (abfd
, address
);
1972 /* Get the (signed) value from the instruction. */
1973 addend
= contents
& howto
->src_mask
;
1974 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1976 bfd_signed_vma mask
;
1979 mask
&= ~ howto
->src_mask
;
1983 /* Add in the increment, (which is a byte value). */
1984 switch (howto
->type
)
1987 addend
+= increment
;
1991 addend
<<= howto
->size
;
1992 addend
+= increment
;
1994 /* Should we check for overflow here ? */
1996 /* Drop any undesired bits. */
1997 addend
>>= howto
->rightshift
;
2001 contents
= (contents
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
2003 bfd_put_32 (abfd
, contents
, address
);
2006 #endif /* USE_REL */
2008 /* Relocate an ARM ELF section. */
2010 elf32_arm_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
2011 contents
, relocs
, local_syms
, local_sections
)
2013 struct bfd_link_info
*info
;
2015 asection
*input_section
;
2017 Elf_Internal_Rela
*relocs
;
2018 Elf_Internal_Sym
*local_syms
;
2019 asection
**local_sections
;
2021 Elf_Internal_Shdr
*symtab_hdr
;
2022 struct elf_link_hash_entry
**sym_hashes
;
2023 Elf_Internal_Rela
*rel
;
2024 Elf_Internal_Rela
*relend
;
2028 if (info
->relocatable
)
2032 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
2033 sym_hashes
= elf_sym_hashes (input_bfd
);
2036 relend
= relocs
+ input_section
->reloc_count
;
2037 for (; rel
< relend
; rel
++)
2040 reloc_howto_type
* howto
;
2041 unsigned long r_symndx
;
2042 Elf_Internal_Sym
* sym
;
2044 struct elf_link_hash_entry
* h
;
2046 bfd_reloc_status_type r
;
2049 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2050 r_type
= ELF32_R_TYPE (rel
->r_info
);
2052 if ( r_type
== R_ARM_GNU_VTENTRY
2053 || r_type
== R_ARM_GNU_VTINHERIT
)
2056 elf32_arm_info_to_howto (input_bfd
, & bfd_reloc
, rel
);
2057 howto
= bfd_reloc
.howto
;
2060 if (info
->relocatable
)
2062 /* This is a relocatable link. We don't have to change
2063 anything, unless the reloc is against a section symbol,
2064 in which case we have to adjust according to where the
2065 section symbol winds up in the output section. */
2066 if (r_symndx
< symtab_hdr
->sh_info
)
2068 sym
= local_syms
+ r_symndx
;
2069 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2071 sec
= local_sections
[r_symndx
];
2072 arm_add_to_rel (input_bfd
, contents
+ rel
->r_offset
,
2074 (bfd_signed_vma
) (sec
->output_offset
2083 /* This is a final link. */
2088 if (r_symndx
< symtab_hdr
->sh_info
)
2090 sym
= local_syms
+ r_symndx
;
2091 sec
= local_sections
[r_symndx
];
2093 relocation
= (sec
->output_section
->vma
2094 + sec
->output_offset
2096 if ((sec
->flags
& SEC_MERGE
)
2097 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2100 bfd_vma addend
, value
;
2102 if (howto
->rightshift
)
2104 (*_bfd_error_handler
)
2105 (_("%s(%s+0x%lx): %s relocation against SEC_MERGE section"),
2106 bfd_archive_filename (input_bfd
),
2107 bfd_get_section_name (input_bfd
, input_section
),
2108 (long) rel
->r_offset
, howto
->name
);
2112 value
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2114 /* Get the (signed) value from the instruction. */
2115 addend
= value
& howto
->src_mask
;
2116 if (addend
& ((howto
->src_mask
+ 1) >> 1))
2118 bfd_signed_vma mask
;
2121 mask
&= ~ howto
->src_mask
;
2126 _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
)
2128 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2129 value
= (value
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
2130 bfd_put_32 (input_bfd
, value
, contents
+ rel
->r_offset
);
2133 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2139 bfd_boolean unresolved_reloc
;
2141 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2142 r_symndx
, symtab_hdr
, sym_hashes
,
2144 unresolved_reloc
, warned
);
2146 if (unresolved_reloc
|| relocation
!= 0)
2148 /* In these cases, we don't need the relocation value.
2149 We check specially because in some obscure cases
2150 sec->output_section will be NULL. */
2155 case R_ARM_THM_PC22
:
2158 (!info
->symbolic
&& h
->dynindx
!= -1)
2159 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2161 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2162 && ((input_section
->flags
& SEC_ALLOC
) != 0
2163 /* DWARF will emit R_ARM_ABS32 relocations in its
2164 sections against symbols defined externally
2165 in shared libraries. We can't do anything
2167 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
2168 && (h
->elf_link_hash_flags
2169 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
2179 if ((WILL_CALL_FINISH_DYNAMIC_SYMBOL
2180 (elf_hash_table (info
)->dynamic_sections_created
,
2183 || (!info
->symbolic
&& h
->dynindx
!= -1)
2184 || (h
->elf_link_hash_flags
2185 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
2190 if (h
->plt
.offset
!= (bfd_vma
)-1)
2195 if (unresolved_reloc
)
2197 (_("%s: warning: unresolvable relocation %d against symbol `%s' from %s section"),
2198 bfd_archive_filename (input_bfd
),
2200 h
->root
.root
.string
,
2201 bfd_get_section_name (input_bfd
, input_section
));
2208 name
= h
->root
.root
.string
;
2211 name
= (bfd_elf_string_from_elf_section
2212 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2213 if (name
== NULL
|| *name
== '\0')
2214 name
= bfd_section_name (input_bfd
, sec
);
2217 r
= elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
2218 input_section
, contents
, rel
,
2219 relocation
, info
, sec
, name
,
2220 (h
? ELF_ST_TYPE (h
->type
) :
2221 ELF_ST_TYPE (sym
->st_info
)), h
);
2223 if (r
!= bfd_reloc_ok
)
2225 const char * msg
= (const char *) 0;
2229 case bfd_reloc_overflow
:
2230 /* If the overflowing reloc was to an undefined symbol,
2231 we have already printed one error message and there
2232 is no point complaining again. */
2234 h
->root
.type
!= bfd_link_hash_undefined
)
2235 && (!((*info
->callbacks
->reloc_overflow
)
2236 (info
, name
, howto
->name
, (bfd_vma
) 0,
2237 input_bfd
, input_section
, rel
->r_offset
))))
2241 case bfd_reloc_undefined
:
2242 if (!((*info
->callbacks
->undefined_symbol
)
2243 (info
, name
, input_bfd
, input_section
,
2244 rel
->r_offset
, TRUE
)))
2248 case bfd_reloc_outofrange
:
2249 msg
= _("internal error: out of range error");
2252 case bfd_reloc_notsupported
:
2253 msg
= _("internal error: unsupported relocation error");
2256 case bfd_reloc_dangerous
:
2257 msg
= _("internal error: dangerous error");
2261 msg
= _("internal error: unknown error");
2265 if (!((*info
->callbacks
->warning
)
2266 (info
, msg
, name
, input_bfd
, input_section
,
2277 /* Set the right machine number. */
2280 elf32_arm_object_p (abfd
)
2285 mach
= bfd_arm_get_mach_from_notes (abfd
, ARM_NOTE_SECTION
);
2287 if (mach
!= bfd_mach_arm_unknown
)
2288 bfd_default_set_arch_mach (abfd
, bfd_arch_arm
, mach
);
2290 else if (elf_elfheader (abfd
)->e_flags
& EF_ARM_MAVERICK_FLOAT
)
2291 bfd_default_set_arch_mach (abfd
, bfd_arch_arm
, bfd_mach_arm_ep9312
);
2294 bfd_default_set_arch_mach (abfd
, bfd_arch_arm
, mach
);
2299 /* Function to keep ARM specific flags in the ELF header. */
2301 elf32_arm_set_private_flags (abfd
, flags
)
2305 if (elf_flags_init (abfd
)
2306 && elf_elfheader (abfd
)->e_flags
!= flags
)
2308 if (EF_ARM_EABI_VERSION (flags
) == EF_ARM_EABI_UNKNOWN
)
2310 if (flags
& EF_ARM_INTERWORK
)
2311 (*_bfd_error_handler
) (_("\
2312 Warning: Not setting interworking flag of %s since it has already been specified as non-interworking"),
2313 bfd_archive_filename (abfd
));
2315 _bfd_error_handler (_("\
2316 Warning: Clearing the interworking flag of %s due to outside request"),
2317 bfd_archive_filename (abfd
));
2322 elf_elfheader (abfd
)->e_flags
= flags
;
2323 elf_flags_init (abfd
) = TRUE
;
2329 /* Copy backend specific data from one object module to another. */
2332 elf32_arm_copy_private_bfd_data (ibfd
, obfd
)
2339 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2340 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2343 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2344 out_flags
= elf_elfheader (obfd
)->e_flags
;
2346 if (elf_flags_init (obfd
)
2347 && EF_ARM_EABI_VERSION (out_flags
) == EF_ARM_EABI_UNKNOWN
2348 && in_flags
!= out_flags
)
2350 /* Cannot mix APCS26 and APCS32 code. */
2351 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2354 /* Cannot mix float APCS and non-float APCS code. */
2355 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2358 /* If the src and dest have different interworking flags
2359 then turn off the interworking bit. */
2360 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2362 if (out_flags
& EF_ARM_INTERWORK
)
2363 _bfd_error_handler (_("\
2364 Warning: Clearing the interworking flag of %s because non-interworking code in %s has been linked with it"),
2365 bfd_get_filename (obfd
),
2366 bfd_archive_filename (ibfd
));
2368 in_flags
&= ~EF_ARM_INTERWORK
;
2371 /* Likewise for PIC, though don't warn for this case. */
2372 if ((in_flags
& EF_ARM_PIC
) != (out_flags
& EF_ARM_PIC
))
2373 in_flags
&= ~EF_ARM_PIC
;
2376 elf_elfheader (obfd
)->e_flags
= in_flags
;
2377 elf_flags_init (obfd
) = TRUE
;
2382 /* Merge backend specific data from an object file to the output
2383 object file when linking. */
2386 elf32_arm_merge_private_bfd_data (ibfd
, obfd
)
2392 bfd_boolean flags_compatible
= TRUE
;
2395 /* Check if we have the same endianess. */
2396 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
2399 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2400 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2403 /* The input BFD must have had its flags initialised. */
2404 /* The following seems bogus to me -- The flags are initialized in
2405 the assembler but I don't think an elf_flags_init field is
2406 written into the object. */
2407 /* BFD_ASSERT (elf_flags_init (ibfd)); */
2409 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2410 out_flags
= elf_elfheader (obfd
)->e_flags
;
2412 if (!elf_flags_init (obfd
))
2414 /* If the input is the default architecture and had the default
2415 flags then do not bother setting the flags for the output
2416 architecture, instead allow future merges to do this. If no
2417 future merges ever set these flags then they will retain their
2418 uninitialised values, which surprise surprise, correspond
2419 to the default values. */
2420 if (bfd_get_arch_info (ibfd
)->the_default
2421 && elf_elfheader (ibfd
)->e_flags
== 0)
2424 elf_flags_init (obfd
) = TRUE
;
2425 elf_elfheader (obfd
)->e_flags
= in_flags
;
2427 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
2428 && bfd_get_arch_info (obfd
)->the_default
)
2429 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
), bfd_get_mach (ibfd
));
2434 /* Determine what should happen if the input ARM architecture
2435 does not match the output ARM architecture. */
2436 if (! bfd_arm_merge_machines (ibfd
, obfd
))
2439 /* Identical flags must be compatible. */
2440 if (in_flags
== out_flags
)
2443 /* Check to see if the input BFD actually contains any sections. If
2444 not, its flags may not have been initialised either, but it
2445 cannot actually cause any incompatibility. Do not short-circuit
2446 dynamic objects; their section list may be emptied by
2447 elf_link_add_object_symbols.
2449 Also check to see if there are no code sections in the input.
2450 In this case there is no need to check for code specific flags.
2451 XXX - do we need to worry about floating-point format compatability
2452 in data sections ? */
2453 if (!(ibfd
->flags
& DYNAMIC
))
2455 bfd_boolean null_input_bfd
= TRUE
;
2456 bfd_boolean only_data_sections
= TRUE
;
2458 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2460 /* Ignore synthetic glue sections. */
2461 if (strcmp (sec
->name
, ".glue_7")
2462 && strcmp (sec
->name
, ".glue_7t"))
2464 if ((bfd_get_section_flags (ibfd
, sec
)
2465 & (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
2466 == (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
2467 only_data_sections
= FALSE
;
2469 null_input_bfd
= FALSE
;
2474 if (null_input_bfd
|| only_data_sections
)
2478 /* Complain about various flag mismatches. */
2479 if (EF_ARM_EABI_VERSION (in_flags
) != EF_ARM_EABI_VERSION (out_flags
))
2481 _bfd_error_handler (_("\
2482 ERROR: %s is compiled for EABI version %d, whereas %s is compiled for version %d"),
2483 bfd_archive_filename (ibfd
),
2484 (in_flags
& EF_ARM_EABIMASK
) >> 24,
2485 bfd_get_filename (obfd
),
2486 (out_flags
& EF_ARM_EABIMASK
) >> 24);
2490 /* Not sure what needs to be checked for EABI versions >= 1. */
2491 if (EF_ARM_EABI_VERSION (in_flags
) == EF_ARM_EABI_UNKNOWN
)
2493 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2495 _bfd_error_handler (_("\
2496 ERROR: %s is compiled for APCS-%d, whereas target %s uses APCS-%d"),
2497 bfd_archive_filename (ibfd
),
2498 in_flags
& EF_ARM_APCS_26
? 26 : 32,
2499 bfd_get_filename (obfd
),
2500 out_flags
& EF_ARM_APCS_26
? 26 : 32);
2501 flags_compatible
= FALSE
;
2504 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2506 if (in_flags
& EF_ARM_APCS_FLOAT
)
2507 _bfd_error_handler (_("\
2508 ERROR: %s passes floats in float registers, whereas %s passes them in integer registers"),
2509 bfd_archive_filename (ibfd
),
2510 bfd_get_filename (obfd
));
2512 _bfd_error_handler (_("\
2513 ERROR: %s passes floats in integer registers, whereas %s passes them in float registers"),
2514 bfd_archive_filename (ibfd
),
2515 bfd_get_filename (obfd
));
2517 flags_compatible
= FALSE
;
2520 if ((in_flags
& EF_ARM_VFP_FLOAT
) != (out_flags
& EF_ARM_VFP_FLOAT
))
2522 if (in_flags
& EF_ARM_VFP_FLOAT
)
2523 _bfd_error_handler (_("\
2524 ERROR: %s uses VFP instructions, whereas %s does not"),
2525 bfd_archive_filename (ibfd
),
2526 bfd_get_filename (obfd
));
2528 _bfd_error_handler (_("\
2529 ERROR: %s uses FPA instructions, whereas %s does not"),
2530 bfd_archive_filename (ibfd
),
2531 bfd_get_filename (obfd
));
2533 flags_compatible
= FALSE
;
2536 if ((in_flags
& EF_ARM_MAVERICK_FLOAT
) != (out_flags
& EF_ARM_MAVERICK_FLOAT
))
2538 if (in_flags
& EF_ARM_MAVERICK_FLOAT
)
2539 _bfd_error_handler (_("\
2540 ERROR: %s uses Maverick instructions, whereas %s does not"),
2541 bfd_archive_filename (ibfd
),
2542 bfd_get_filename (obfd
));
2544 _bfd_error_handler (_("\
2545 ERROR: %s does not use Maverick instructions, whereas %s does"),
2546 bfd_archive_filename (ibfd
),
2547 bfd_get_filename (obfd
));
2549 flags_compatible
= FALSE
;
2552 #ifdef EF_ARM_SOFT_FLOAT
2553 if ((in_flags
& EF_ARM_SOFT_FLOAT
) != (out_flags
& EF_ARM_SOFT_FLOAT
))
2555 /* We can allow interworking between code that is VFP format
2556 layout, and uses either soft float or integer regs for
2557 passing floating point arguments and results. We already
2558 know that the APCS_FLOAT flags match; similarly for VFP
2560 if ((in_flags
& EF_ARM_APCS_FLOAT
) != 0
2561 || (in_flags
& EF_ARM_VFP_FLOAT
) == 0)
2563 if (in_flags
& EF_ARM_SOFT_FLOAT
)
2564 _bfd_error_handler (_("\
2565 ERROR: %s uses software FP, whereas %s uses hardware FP"),
2566 bfd_archive_filename (ibfd
),
2567 bfd_get_filename (obfd
));
2569 _bfd_error_handler (_("\
2570 ERROR: %s uses hardware FP, whereas %s uses software FP"),
2571 bfd_archive_filename (ibfd
),
2572 bfd_get_filename (obfd
));
2574 flags_compatible
= FALSE
;
2579 /* Interworking mismatch is only a warning. */
2580 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2582 if (in_flags
& EF_ARM_INTERWORK
)
2584 _bfd_error_handler (_("\
2585 Warning: %s supports interworking, whereas %s does not"),
2586 bfd_archive_filename (ibfd
),
2587 bfd_get_filename (obfd
));
2591 _bfd_error_handler (_("\
2592 Warning: %s does not support interworking, whereas %s does"),
2593 bfd_archive_filename (ibfd
),
2594 bfd_get_filename (obfd
));
2599 return flags_compatible
;
2602 /* Display the flags field. */
2605 elf32_arm_print_private_bfd_data (abfd
, ptr
)
2609 FILE * file
= (FILE *) ptr
;
2610 unsigned long flags
;
2612 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
2614 /* Print normal ELF private data. */
2615 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
2617 flags
= elf_elfheader (abfd
)->e_flags
;
2618 /* Ignore init flag - it may not be set, despite the flags field
2619 containing valid data. */
2621 /* xgettext:c-format */
2622 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
2624 switch (EF_ARM_EABI_VERSION (flags
))
2626 case EF_ARM_EABI_UNKNOWN
:
2627 /* The following flag bits are GNU extensions and not part of the
2628 official ARM ELF extended ABI. Hence they are only decoded if
2629 the EABI version is not set. */
2630 if (flags
& EF_ARM_INTERWORK
)
2631 fprintf (file
, _(" [interworking enabled]"));
2633 if (flags
& EF_ARM_APCS_26
)
2634 fprintf (file
, " [APCS-26]");
2636 fprintf (file
, " [APCS-32]");
2638 if (flags
& EF_ARM_VFP_FLOAT
)
2639 fprintf (file
, _(" [VFP float format]"));
2640 else if (flags
& EF_ARM_MAVERICK_FLOAT
)
2641 fprintf (file
, _(" [Maverick float format]"));
2643 fprintf (file
, _(" [FPA float format]"));
2645 if (flags
& EF_ARM_APCS_FLOAT
)
2646 fprintf (file
, _(" [floats passed in float registers]"));
2648 if (flags
& EF_ARM_PIC
)
2649 fprintf (file
, _(" [position independent]"));
2651 if (flags
& EF_ARM_NEW_ABI
)
2652 fprintf (file
, _(" [new ABI]"));
2654 if (flags
& EF_ARM_OLD_ABI
)
2655 fprintf (file
, _(" [old ABI]"));
2657 if (flags
& EF_ARM_SOFT_FLOAT
)
2658 fprintf (file
, _(" [software FP]"));
2660 flags
&= ~(EF_ARM_INTERWORK
| EF_ARM_APCS_26
| EF_ARM_APCS_FLOAT
2661 | EF_ARM_PIC
| EF_ARM_NEW_ABI
| EF_ARM_OLD_ABI
2662 | EF_ARM_SOFT_FLOAT
| EF_ARM_VFP_FLOAT
2663 | EF_ARM_MAVERICK_FLOAT
);
2666 case EF_ARM_EABI_VER1
:
2667 fprintf (file
, _(" [Version1 EABI]"));
2669 if (flags
& EF_ARM_SYMSARESORTED
)
2670 fprintf (file
, _(" [sorted symbol table]"));
2672 fprintf (file
, _(" [unsorted symbol table]"));
2674 flags
&= ~ EF_ARM_SYMSARESORTED
;
2677 case EF_ARM_EABI_VER2
:
2678 fprintf (file
, _(" [Version2 EABI]"));
2680 if (flags
& EF_ARM_SYMSARESORTED
)
2681 fprintf (file
, _(" [sorted symbol table]"));
2683 fprintf (file
, _(" [unsorted symbol table]"));
2685 if (flags
& EF_ARM_DYNSYMSUSESEGIDX
)
2686 fprintf (file
, _(" [dynamic symbols use segment index]"));
2688 if (flags
& EF_ARM_MAPSYMSFIRST
)
2689 fprintf (file
, _(" [mapping symbols precede others]"));
2691 flags
&= ~(EF_ARM_SYMSARESORTED
| EF_ARM_DYNSYMSUSESEGIDX
2692 | EF_ARM_MAPSYMSFIRST
);
2695 case EF_ARM_EABI_VER3
:
2696 fprintf (file
, _(" [Version3 EABI]"));
2698 if (flags
& EF_ARM_BE8
)
2699 fprintf (file
, _(" [BE8]"));
2701 if (flags
& EF_ARM_LE8
)
2702 fprintf (file
, _(" [LE8]"));
2704 flags
&= ~(EF_ARM_LE8
| EF_ARM_BE8
);
2708 fprintf (file
, _(" <EABI version unrecognised>"));
2712 flags
&= ~ EF_ARM_EABIMASK
;
2714 if (flags
& EF_ARM_RELEXEC
)
2715 fprintf (file
, _(" [relocatable executable]"));
2717 if (flags
& EF_ARM_HASENTRY
)
2718 fprintf (file
, _(" [has entry point]"));
2720 flags
&= ~ (EF_ARM_RELEXEC
| EF_ARM_HASENTRY
);
2723 fprintf (file
, _("<Unrecognised flag bits set>"));
2731 elf32_arm_get_symbol_type (elf_sym
, type
)
2732 Elf_Internal_Sym
* elf_sym
;
2735 switch (ELF_ST_TYPE (elf_sym
->st_info
))
2738 return ELF_ST_TYPE (elf_sym
->st_info
);
2741 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2742 This allows us to distinguish between data used by Thumb instructions
2743 and non-data (which is probably code) inside Thumb regions of an
2745 if (type
!= STT_OBJECT
)
2746 return ELF_ST_TYPE (elf_sym
->st_info
);
2757 elf32_arm_gc_mark_hook (sec
, info
, rel
, h
, sym
)
2759 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2760 Elf_Internal_Rela
*rel
;
2761 struct elf_link_hash_entry
*h
;
2762 Elf_Internal_Sym
*sym
;
2766 switch (ELF32_R_TYPE (rel
->r_info
))
2768 case R_ARM_GNU_VTINHERIT
:
2769 case R_ARM_GNU_VTENTRY
:
2773 switch (h
->root
.type
)
2775 case bfd_link_hash_defined
:
2776 case bfd_link_hash_defweak
:
2777 return h
->root
.u
.def
.section
;
2779 case bfd_link_hash_common
:
2780 return h
->root
.u
.c
.p
->section
;
2788 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
2793 /* Update the got entry reference counts for the section being removed. */
2796 elf32_arm_gc_sweep_hook (abfd
, info
, sec
, relocs
)
2797 bfd
*abfd ATTRIBUTE_UNUSED
;
2798 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2799 asection
*sec ATTRIBUTE_UNUSED
;
2800 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
;
2802 Elf_Internal_Shdr
*symtab_hdr
;
2803 struct elf_link_hash_entry
**sym_hashes
;
2804 bfd_signed_vma
*local_got_refcounts
;
2805 const Elf_Internal_Rela
*rel
, *relend
;
2806 unsigned long r_symndx
;
2807 struct elf_link_hash_entry
*h
;
2809 elf_section_data (sec
)->local_dynrel
= NULL
;
2811 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2812 sym_hashes
= elf_sym_hashes (abfd
);
2813 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2815 relend
= relocs
+ sec
->reloc_count
;
2816 for (rel
= relocs
; rel
< relend
; rel
++)
2817 switch (ELF32_R_TYPE (rel
->r_info
))
2820 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2821 if (r_symndx
>= symtab_hdr
->sh_info
)
2823 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2824 if (h
->got
.refcount
> 0)
2825 h
->got
.refcount
-= 1;
2827 else if (local_got_refcounts
!= NULL
)
2829 if (local_got_refcounts
[r_symndx
] > 0)
2830 local_got_refcounts
[r_symndx
] -= 1;
2838 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2839 if (r_symndx
>= symtab_hdr
->sh_info
)
2841 struct elf32_arm_link_hash_entry
*eh
;
2842 struct elf32_arm_relocs_copied
**pp
;
2843 struct elf32_arm_relocs_copied
*p
;
2845 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2847 if (h
->plt
.refcount
> 0)
2848 h
->plt
.refcount
-= 1;
2850 if (ELF32_R_TYPE (rel
->r_info
) == R_ARM_ABS32
2851 || ELF32_R_TYPE (rel
->r_info
) == R_ARM_REL32
)
2853 eh
= (struct elf32_arm_link_hash_entry
*) h
;
2855 for (pp
= &eh
->relocs_copied
; (p
= *pp
) != NULL
;
2857 if (p
->section
== sec
)
2875 /* Look through the relocs for a section during the first phase. */
2878 elf32_arm_check_relocs (abfd
, info
, sec
, relocs
)
2880 struct bfd_link_info
*info
;
2882 const Elf_Internal_Rela
*relocs
;
2884 Elf_Internal_Shdr
*symtab_hdr
;
2885 struct elf_link_hash_entry
**sym_hashes
;
2886 struct elf_link_hash_entry
**sym_hashes_end
;
2887 const Elf_Internal_Rela
*rel
;
2888 const Elf_Internal_Rela
*rel_end
;
2891 bfd_vma
*local_got_offsets
;
2892 struct elf32_arm_link_hash_table
*htab
;
2894 if (info
->relocatable
)
2897 htab
= elf32_arm_hash_table (info
);
2900 dynobj
= elf_hash_table (info
)->dynobj
;
2901 local_got_offsets
= elf_local_got_offsets (abfd
);
2903 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2904 sym_hashes
= elf_sym_hashes (abfd
);
2905 sym_hashes_end
= sym_hashes
2906 + symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
2908 if (!elf_bad_symtab (abfd
))
2909 sym_hashes_end
-= symtab_hdr
->sh_info
;
2911 rel_end
= relocs
+ sec
->reloc_count
;
2912 for (rel
= relocs
; rel
< rel_end
; rel
++)
2914 struct elf_link_hash_entry
*h
;
2915 unsigned long r_symndx
;
2917 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2918 if (r_symndx
< symtab_hdr
->sh_info
)
2921 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2923 switch (ELF32_R_TYPE (rel
->r_info
))
2926 /* This symbol requires a global offset table entry. */
2933 bfd_signed_vma
*local_got_refcounts
;
2935 /* This is a global offset table entry for a local symbol. */
2936 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2937 if (local_got_refcounts
== NULL
)
2941 size
= symtab_hdr
->sh_info
;
2942 size
*= (sizeof (bfd_signed_vma
) + sizeof(char));
2943 local_got_refcounts
= ((bfd_signed_vma
*)
2944 bfd_zalloc (abfd
, size
));
2945 if (local_got_refcounts
== NULL
)
2947 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
2949 local_got_refcounts
[r_symndx
] += 1;
2955 if (htab
->sgot
== NULL
)
2957 if (htab
->root
.dynobj
== NULL
)
2958 htab
->root
.dynobj
= abfd
;
2959 if (!create_got_section (htab
->root
.dynobj
, info
))
2970 /* If this reloc is in a read-only section, we might
2971 need a copy reloc. We can't check reliably at this
2972 stage whether the section is read-only, as input
2973 sections have not yet been mapped to output sections.
2974 Tentatively set the flag for now, and correct in
2975 adjust_dynamic_symbol. */
2977 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
2979 /* We may need a .plt entry if the function this reloc
2980 refers to is in a different object. We can't tell for
2981 sure yet, because something later might force the
2983 if (ELF32_R_TYPE (rel
->r_info
) == R_ARM_PC24
2984 || ELF32_R_TYPE (rel
->r_info
) == R_ARM_PLT32
)
2985 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2987 /* If we create a PLT entry, this relocation will reference
2988 it, even if it's an ABS32 relocation. */
2989 h
->plt
.refcount
+= 1;
2992 /* If we are creating a shared library, and this is a reloc
2993 against a global symbol, or a non PC relative reloc
2994 against a local symbol, then we need to copy the reloc
2995 into the shared library. However, if we are linking with
2996 -Bsymbolic, we do not need to copy a reloc against a
2997 global symbol which is defined in an object we are
2998 including in the link (i.e., DEF_REGULAR is set). At
2999 this point we have not seen all the input files, so it is
3000 possible that DEF_REGULAR is not set now but will be set
3001 later (it is never cleared). We account for that
3002 possibility below by storing information in the
3003 relocs_copied field of the hash table entry. */
3005 && (sec
->flags
& SEC_ALLOC
) != 0
3006 && ((ELF32_R_TYPE (rel
->r_info
) != R_ARM_PC24
3007 && ELF32_R_TYPE (rel
->r_info
) != R_ARM_PLT32
)
3009 && (! info
->symbolic
3010 || (h
->elf_link_hash_flags
3011 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
3013 struct elf32_arm_relocs_copied
*p
, **head
;
3015 /* When creating a shared object, we must copy these
3016 reloc types into the output file. We create a reloc
3017 section in dynobj and make room for this reloc. */
3022 name
= (bfd_elf_string_from_elf_section
3024 elf_elfheader (abfd
)->e_shstrndx
,
3025 elf_section_data (sec
)->rel_hdr
.sh_name
));
3029 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
3030 && strcmp (bfd_get_section_name (abfd
, sec
),
3033 sreloc
= bfd_get_section_by_name (dynobj
, name
);
3038 sreloc
= bfd_make_section (dynobj
, name
);
3039 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
3040 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3041 if ((sec
->flags
& SEC_ALLOC
) != 0)
3042 flags
|= SEC_ALLOC
| SEC_LOAD
;
3044 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
3045 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
3049 elf_section_data (sec
)->sreloc
= sreloc
;
3052 /* If this is a global symbol, we count the number of
3053 relocations we need for this symbol. */
3056 head
= &((struct elf32_arm_link_hash_entry
*) h
)->relocs_copied
;
3060 /* Track dynamic relocs needed for local syms too.
3061 We really need local syms available to do this
3065 s
= bfd_section_from_r_symndx (abfd
, &htab
->sym_sec
,
3070 head
= ((struct elf32_arm_relocs_copied
**)
3071 &elf_section_data (s
)->local_dynrel
);
3075 if (p
== NULL
|| p
->section
!= sec
)
3077 bfd_size_type amt
= sizeof *p
;
3078 p
= bfd_alloc (htab
->root
.dynobj
, amt
);
3087 if (ELF32_R_TYPE (rel
->r_info
) == R_ARM_ABS32
3088 || ELF32_R_TYPE (rel
->r_info
) == R_ARM_REL32
)
3093 /* This relocation describes the C++ object vtable hierarchy.
3094 Reconstruct it for later use during GC. */
3095 case R_ARM_GNU_VTINHERIT
:
3096 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
3100 /* This relocation describes which C++ vtable entries are actually
3101 used. Record for later use during GC. */
3102 case R_ARM_GNU_VTENTRY
:
3103 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
3112 /* Find the nearest line to a particular section and offset, for error
3113 reporting. This code is a duplicate of the code in elf.c, except
3114 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
3117 elf32_arm_find_nearest_line
3118 (abfd
, section
, symbols
, offset
, filename_ptr
, functionname_ptr
, line_ptr
)
3123 const char **filename_ptr
;
3124 const char **functionname_ptr
;
3125 unsigned int *line_ptr
;
3128 const char *filename
;
3133 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
3134 filename_ptr
, functionname_ptr
,
3136 &elf_tdata (abfd
)->dwarf2_find_line_info
))
3139 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
3140 &found
, filename_ptr
,
3141 functionname_ptr
, line_ptr
,
3142 &elf_tdata (abfd
)->line_info
))
3148 if (symbols
== NULL
)
3155 for (p
= symbols
; *p
!= NULL
; p
++)
3159 q
= (elf_symbol_type
*) *p
;
3161 if (bfd_get_section (&q
->symbol
) != section
)
3164 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
3169 filename
= bfd_asymbol_name (&q
->symbol
);
3174 if (q
->symbol
.section
== section
3175 && q
->symbol
.value
>= low_func
3176 && q
->symbol
.value
<= offset
)
3178 func
= (asymbol
*) q
;
3179 low_func
= q
->symbol
.value
;
3188 *filename_ptr
= filename
;
3189 *functionname_ptr
= bfd_asymbol_name (func
);
3195 /* Adjust a symbol defined by a dynamic object and referenced by a
3196 regular object. The current definition is in some section of the
3197 dynamic object, but we're not including those sections. We have to
3198 change the definition to something the rest of the link can
3202 elf32_arm_adjust_dynamic_symbol (info
, h
)
3203 struct bfd_link_info
* info
;
3204 struct elf_link_hash_entry
* h
;
3208 unsigned int power_of_two
;
3210 dynobj
= elf_hash_table (info
)->dynobj
;
3212 /* Make sure we know what is going on here. */
3213 BFD_ASSERT (dynobj
!= NULL
3214 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
3215 || h
->weakdef
!= NULL
3216 || ((h
->elf_link_hash_flags
3217 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
3218 && (h
->elf_link_hash_flags
3219 & ELF_LINK_HASH_REF_REGULAR
) != 0
3220 && (h
->elf_link_hash_flags
3221 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
3223 /* If this is a function, put it in the procedure linkage table. We
3224 will fill in the contents of the procedure linkage table later,
3225 when we know the address of the .got section. */
3226 if (h
->type
== STT_FUNC
3227 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
3229 if (h
->plt
.refcount
<= 0
3230 || SYMBOL_CALLS_LOCAL (info
, h
)
3231 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
3232 && h
->root
.type
== bfd_link_hash_undefweak
))
3234 /* This case can occur if we saw a PLT32 reloc in an input
3235 file, but the symbol was never referred to by a dynamic
3236 object, or if all references were garbage collected. In
3237 such a case, we don't actually need to build a procedure
3238 linkage table, and we can just do a PC24 reloc instead. */
3239 h
->plt
.offset
= (bfd_vma
) -1;
3240 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
3246 /* It's possible that we incorrectly decided a .plt reloc was
3247 needed for an R_ARM_PC24 reloc to a non-function sym in
3248 check_relocs. We can't decide accurately between function and
3249 non-function syms in check-relocs; Objects loaded later in
3250 the link may change h->type. So fix it now. */
3251 h
->plt
.offset
= (bfd_vma
) -1;
3253 /* If this is a weak symbol, and there is a real definition, the
3254 processor independent code will have arranged for us to see the
3255 real definition first, and we can just use the same value. */
3256 if (h
->weakdef
!= NULL
)
3258 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
3259 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
3260 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
3261 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
3265 /* This is a reference to a symbol defined by a dynamic object which
3266 is not a function. */
3268 /* If we are creating a shared library, we must presume that the
3269 only references to the symbol are via the global offset table.
3270 For such cases we need not do anything here; the relocations will
3271 be handled correctly by relocate_section. */
3275 /* We must allocate the symbol in our .dynbss section, which will
3276 become part of the .bss section of the executable. There will be
3277 an entry for this symbol in the .dynsym section. The dynamic
3278 object will contain position independent code, so all references
3279 from the dynamic object to this symbol will go through the global
3280 offset table. The dynamic linker will use the .dynsym entry to
3281 determine the address it must put in the global offset table, so
3282 both the dynamic object and the regular object will refer to the
3283 same memory location for the variable. */
3284 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
3285 BFD_ASSERT (s
!= NULL
);
3287 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
3288 copy the initial value out of the dynamic object and into the
3289 runtime process image. We need to remember the offset into the
3290 .rel.bss section we are going to use. */
3291 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
3295 srel
= bfd_get_section_by_name (dynobj
, ".rel.bss");
3296 BFD_ASSERT (srel
!= NULL
);
3297 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
3298 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
3301 /* We need to figure out the alignment required for this symbol. I
3302 have no idea how ELF linkers handle this. */
3303 power_of_two
= bfd_log2 (h
->size
);
3304 if (power_of_two
> 3)
3307 /* Apply the required alignment. */
3308 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
3309 (bfd_size_type
) (1 << power_of_two
));
3310 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
3312 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
3316 /* Define the symbol as being at this point in the section. */
3317 h
->root
.u
.def
.section
= s
;
3318 h
->root
.u
.def
.value
= s
->_raw_size
;
3320 /* Increment the section size to make room for the symbol. */
3321 s
->_raw_size
+= h
->size
;
3326 /* Allocate space in .plt, .got and associated reloc sections for
3330 allocate_dynrelocs (h
, inf
)
3331 struct elf_link_hash_entry
*h
;
3334 struct bfd_link_info
*info
;
3335 struct elf32_arm_link_hash_table
*htab
;
3336 struct elf32_arm_link_hash_entry
*eh
;
3337 struct elf32_arm_relocs_copied
*p
;
3339 if (h
->root
.type
== bfd_link_hash_indirect
)
3342 if (h
->root
.type
== bfd_link_hash_warning
)
3343 /* When warning symbols are created, they **replace** the "real"
3344 entry in the hash table, thus we never get to see the real
3345 symbol in a hash traversal. So look at it now. */
3346 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3348 info
= (struct bfd_link_info
*) inf
;
3349 htab
= elf32_arm_hash_table (info
);
3351 if (htab
->root
.dynamic_sections_created
3352 && h
->plt
.refcount
> 0)
3354 /* Make sure this symbol is output as a dynamic symbol.
3355 Undefined weak syms won't yet be marked as dynamic. */
3356 if (h
->dynindx
== -1
3357 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
3359 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3364 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
3366 asection
*s
= htab
->splt
;
3368 /* If this is the first .plt entry, make room for the special
3370 if (s
->_raw_size
== 0)
3371 s
->_raw_size
+= PLT_HEADER_SIZE
;
3373 h
->plt
.offset
= s
->_raw_size
;
3375 /* If this symbol is not defined in a regular file, and we are
3376 not generating a shared library, then set the symbol to this
3377 location in the .plt. This is required to make function
3378 pointers compare as equal between the normal executable and
3379 the shared library. */
3381 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3383 h
->root
.u
.def
.section
= s
;
3384 h
->root
.u
.def
.value
= h
->plt
.offset
;
3387 /* Make room for this entry. */
3388 s
->_raw_size
+= PLT_ENTRY_SIZE
;
3390 /* We also need to make an entry in the .got.plt section, which
3391 will be placed in the .got section by the linker script. */
3392 htab
->sgotplt
->_raw_size
+= 4;
3394 /* We also need to make an entry in the .rel.plt section. */
3395 htab
->srelplt
->_raw_size
+= sizeof (Elf32_External_Rel
);
3399 h
->plt
.offset
= (bfd_vma
) -1;
3400 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
3405 h
->plt
.offset
= (bfd_vma
) -1;
3406 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
3409 if (h
->got
.refcount
> 0)
3414 /* Make sure this symbol is output as a dynamic symbol.
3415 Undefined weak syms won't yet be marked as dynamic. */
3416 if (h
->dynindx
== -1
3417 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
3419 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3424 h
->got
.offset
= s
->_raw_size
;
3426 dyn
= htab
->root
.dynamic_sections_created
;
3427 if ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3428 || h
->root
.type
!= bfd_link_hash_undefweak
)
3430 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
3431 htab
->srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
3434 h
->got
.offset
= (bfd_vma
) -1;
3436 eh
= (struct elf32_arm_link_hash_entry
*) h
;
3437 if (eh
->relocs_copied
== NULL
)
3440 /* In the shared -Bsymbolic case, discard space allocated for
3441 dynamic pc-relative relocs against symbols which turn out to be
3442 defined in regular objects. For the normal shared case, discard
3443 space for pc-relative relocs that have become local due to symbol
3444 visibility changes. */
3448 /* Discard relocs on undefined weak syms with non-default
3450 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
3451 && h
->root
.type
== bfd_link_hash_undefweak
)
3452 eh
->relocs_copied
= NULL
;
3456 /* For the non-shared case, discard space for relocs against
3457 symbols which turn out to need copy relocs or are not
3460 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
3461 && (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
3462 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3463 || (htab
->root
.dynamic_sections_created
3464 && (h
->root
.type
== bfd_link_hash_undefweak
3465 || h
->root
.type
== bfd_link_hash_undefined
))))
3467 /* Make sure this symbol is output as a dynamic symbol.
3468 Undefined weak syms won't yet be marked as dynamic. */
3469 if (h
->dynindx
== -1
3470 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
3472 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3476 /* If that succeeded, we know we'll be keeping all the
3478 if (h
->dynindx
!= -1)
3482 eh
->relocs_copied
= NULL
;
3487 /* Finally, allocate space. */
3488 for (p
= eh
->relocs_copied
; p
!= NULL
; p
= p
->next
)
3490 asection
*sreloc
= elf_section_data (p
->section
)->sreloc
;
3491 sreloc
->_raw_size
+= p
->count
* sizeof (Elf32_External_Rel
);
3497 /* Set the sizes of the dynamic sections. */
3500 elf32_arm_size_dynamic_sections (output_bfd
, info
)
3501 bfd
* output_bfd ATTRIBUTE_UNUSED
;
3502 struct bfd_link_info
* info
;
3509 struct elf32_arm_link_hash_table
*htab
;
3511 htab
= elf32_arm_hash_table (info
);
3512 dynobj
= elf_hash_table (info
)->dynobj
;
3513 BFD_ASSERT (dynobj
!= NULL
);
3515 if (elf_hash_table (info
)->dynamic_sections_created
)
3517 /* Set the contents of the .interp section to the interpreter. */
3518 if (info
->executable
)
3520 s
= bfd_get_section_by_name (dynobj
, ".interp");
3521 BFD_ASSERT (s
!= NULL
);
3522 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
3523 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
3527 /* Set up .got offsets for local syms, and space for local dynamic
3529 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
3531 bfd_signed_vma
*local_got
;
3532 bfd_signed_vma
*end_local_got
;
3533 char *local_tls_type
;
3534 bfd_size_type locsymcount
;
3535 Elf_Internal_Shdr
*symtab_hdr
;
3538 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
3541 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3543 struct elf32_arm_relocs_copied
*p
;
3545 for (p
= *((struct elf32_arm_relocs_copied
**)
3546 &elf_section_data (s
)->local_dynrel
);
3550 if (!bfd_is_abs_section (p
->section
)
3551 && bfd_is_abs_section (p
->section
->output_section
))
3553 /* Input section has been discarded, either because
3554 it is a copy of a linkonce section or due to
3555 linker script /DISCARD/, so we'll be discarding
3558 else if (p
->count
!= 0)
3560 srel
= elf_section_data (p
->section
)->sreloc
;
3561 srel
->_raw_size
+= p
->count
* sizeof (Elf32_External_Rel
);
3562 if ((p
->section
->output_section
->flags
& SEC_READONLY
) != 0)
3563 info
->flags
|= DF_TEXTREL
;
3568 local_got
= elf_local_got_refcounts (ibfd
);
3572 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
3573 locsymcount
= symtab_hdr
->sh_info
;
3574 end_local_got
= local_got
+ locsymcount
;
3576 srel
= htab
->srelgot
;
3577 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
3581 *local_got
= s
->_raw_size
;
3584 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
3587 *local_got
= (bfd_vma
) -1;
3591 /* Allocate global sym .plt and .got entries, and space for global
3592 sym dynamic relocs. */
3593 elf_link_hash_traverse (&htab
->root
, allocate_dynrelocs
, (PTR
) info
);
3595 /* The check_relocs and adjust_dynamic_symbol entry points have
3596 determined the sizes of the various dynamic sections. Allocate
3600 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3605 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3608 /* It's OK to base decisions on the section name, because none
3609 of the dynobj section names depend upon the input files. */
3610 name
= bfd_get_section_name (dynobj
, s
);
3614 if (strcmp (name
, ".plt") == 0)
3616 if (s
->_raw_size
== 0)
3618 /* Strip this section if we don't need it; see the
3624 /* Remember whether there is a PLT. */
3628 else if (strncmp (name
, ".rel", 4) == 0)
3630 if (s
->_raw_size
== 0)
3632 /* If we don't need this section, strip it from the
3633 output file. This is mostly to handle .rel.bss and
3634 .rel.plt. We must create both sections in
3635 create_dynamic_sections, because they must be created
3636 before the linker maps input sections to output
3637 sections. The linker does that before
3638 adjust_dynamic_symbol is called, and it is that
3639 function which decides whether anything needs to go
3640 into these sections. */
3645 /* Remember whether there are any reloc sections other
3647 if (strcmp (name
, ".rel.plt") != 0)
3650 /* We use the reloc_count field as a counter if we need
3651 to copy relocs into the output file. */
3655 else if (strncmp (name
, ".got", 4) != 0)
3657 /* It's not one of our sections, so don't allocate space. */
3663 _bfd_strip_section_from_output (info
, s
);
3667 /* Allocate memory for the section contents. */
3668 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
3669 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
3673 if (elf_hash_table (info
)->dynamic_sections_created
)
3675 /* Add some entries to the .dynamic section. We fill in the
3676 values later, in elf32_arm_finish_dynamic_sections, but we
3677 must add the entries now so that we get the correct size for
3678 the .dynamic section. The DT_DEBUG entry is filled in by the
3679 dynamic linker and used by the debugger. */
3680 #define add_dynamic_entry(TAG, VAL) \
3681 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3685 if (!add_dynamic_entry (DT_DEBUG
, 0))
3691 if ( !add_dynamic_entry (DT_PLTGOT
, 0)
3692 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
3693 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
3694 || !add_dynamic_entry (DT_JMPREL
, 0))
3700 if ( !add_dynamic_entry (DT_REL
, 0)
3701 || !add_dynamic_entry (DT_RELSZ
, 0)
3702 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
3706 if ((info
->flags
& DF_TEXTREL
) != 0)
3708 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3710 info
->flags
|= DF_TEXTREL
;
3713 #undef add_synamic_entry
3718 /* Finish up dynamic symbol handling. We set the contents of various
3719 dynamic sections here. */
3722 elf32_arm_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
3724 struct bfd_link_info
* info
;
3725 struct elf_link_hash_entry
* h
;
3726 Elf_Internal_Sym
* sym
;
3730 dynobj
= elf_hash_table (info
)->dynobj
;
3732 if (h
->plt
.offset
!= (bfd_vma
) -1)
3739 Elf_Internal_Rela rel
;
3741 bfd_vma got_displacement
;
3743 /* This symbol has an entry in the procedure linkage table. Set
3746 BFD_ASSERT (h
->dynindx
!= -1);
3748 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3749 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3750 srel
= bfd_get_section_by_name (dynobj
, ".rel.plt");
3751 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
3753 /* Get the index in the procedure linkage table which
3754 corresponds to this symbol. This is the index of this symbol
3755 in all the symbols for which we are making plt entries. The
3756 first entry in the procedure linkage table is reserved. */
3757 plt_index
= (h
->plt
.offset
- PLT_HEADER_SIZE
) / PLT_ENTRY_SIZE
;
3759 /* Get the offset into the .got table of the entry that
3760 corresponds to this function. Each .got entry is 4 bytes.
3761 The first three are reserved. */
3762 got_offset
= (plt_index
+ 3) * 4;
3764 /* Calculate the displacement between the PLT slot and the
3765 entry in the GOT. */
3766 got_displacement
= (sgot
->output_section
->vma
3767 + sgot
->output_offset
3769 - splt
->output_section
->vma
3770 - splt
->output_offset
3774 BFD_ASSERT ((got_displacement
& 0xf0000000) == 0);
3776 /* Fill in the entry in the procedure linkage table. */
3777 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[0] | ((got_displacement
& 0x0ff00000) >> 20),
3778 splt
->contents
+ h
->plt
.offset
+ 0);
3779 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[1] | ((got_displacement
& 0x000ff000) >> 12),
3780 splt
->contents
+ h
->plt
.offset
+ 4);
3781 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[2] | (got_displacement
& 0x00000fff),
3782 splt
->contents
+ h
->plt
.offset
+ 8);
3783 #ifdef FOUR_WORD_PLT
3784 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[3],
3785 splt
->contents
+ h
->plt
.offset
+ 12);
3788 /* Fill in the entry in the global offset table. */
3789 bfd_put_32 (output_bfd
,
3790 (splt
->output_section
->vma
3791 + splt
->output_offset
),
3792 sgot
->contents
+ got_offset
);
3794 /* Fill in the entry in the .rel.plt section. */
3795 rel
.r_offset
= (sgot
->output_section
->vma
3796 + sgot
->output_offset
3798 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_JUMP_SLOT
);
3799 loc
= srel
->contents
+ plt_index
* sizeof (Elf32_External_Rel
);
3800 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3802 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3804 /* Mark the symbol as undefined, rather than as defined in
3805 the .plt section. Leave the value alone. */
3806 sym
->st_shndx
= SHN_UNDEF
;
3807 /* If the symbol is weak, we do need to clear the value.
3808 Otherwise, the PLT entry would provide a definition for
3809 the symbol even if the symbol wasn't defined anywhere,
3810 and so the symbol would never be NULL. */
3811 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR_NONWEAK
)
3817 if (h
->got
.offset
!= (bfd_vma
) -1)
3821 Elf_Internal_Rela rel
;
3824 /* This symbol has an entry in the global offset table. Set it
3826 sgot
= bfd_get_section_by_name (dynobj
, ".got");
3827 srel
= bfd_get_section_by_name (dynobj
, ".rel.got");
3828 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
3830 rel
.r_offset
= (sgot
->output_section
->vma
3831 + sgot
->output_offset
3832 + (h
->got
.offset
&~ (bfd_vma
) 1));
3834 /* If this is a static link, or it is a -Bsymbolic link and the
3835 symbol is defined locally or was forced to be local because
3836 of a version file, we just want to emit a RELATIVE reloc.
3837 The entry in the global offset table will already have been
3838 initialized in the relocate_section function. */
3840 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3842 BFD_ASSERT((h
->got
.offset
& 1) != 0);
3843 rel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
3847 BFD_ASSERT((h
->got
.offset
& 1) == 0);
3848 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
3849 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_GLOB_DAT
);
3852 loc
= srel
->contents
+ srel
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3853 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3856 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
3859 Elf_Internal_Rela rel
;
3862 /* This symbol needs a copy reloc. Set it up. */
3863 BFD_ASSERT (h
->dynindx
!= -1
3864 && (h
->root
.type
== bfd_link_hash_defined
3865 || h
->root
.type
== bfd_link_hash_defweak
));
3867 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
3869 BFD_ASSERT (s
!= NULL
);
3871 rel
.r_offset
= (h
->root
.u
.def
.value
3872 + h
->root
.u
.def
.section
->output_section
->vma
3873 + h
->root
.u
.def
.section
->output_offset
);
3874 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_COPY
);
3875 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3876 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3879 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3880 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3881 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
3882 sym
->st_shndx
= SHN_ABS
;
3887 /* Finish up the dynamic sections. */
3890 elf32_arm_finish_dynamic_sections (output_bfd
, info
)
3892 struct bfd_link_info
* info
;
3898 dynobj
= elf_hash_table (info
)->dynobj
;
3900 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3901 BFD_ASSERT (sgot
!= NULL
);
3902 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3904 if (elf_hash_table (info
)->dynamic_sections_created
)
3907 Elf32_External_Dyn
*dyncon
, *dynconend
;
3909 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3910 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3912 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3913 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
3915 for (; dyncon
< dynconend
; dyncon
++)
3917 Elf_Internal_Dyn dyn
;
3921 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3934 s
= bfd_get_section_by_name (output_bfd
, name
);
3935 BFD_ASSERT (s
!= NULL
);
3936 dyn
.d_un
.d_ptr
= s
->vma
;
3937 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3941 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3942 BFD_ASSERT (s
!= NULL
);
3943 if (s
->_cooked_size
!= 0)
3944 dyn
.d_un
.d_val
= s
->_cooked_size
;
3946 dyn
.d_un
.d_val
= s
->_raw_size
;
3947 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3951 /* My reading of the SVR4 ABI indicates that the
3952 procedure linkage table relocs (DT_JMPREL) should be
3953 included in the overall relocs (DT_REL). This is
3954 what Solaris does. However, UnixWare can not handle
3955 that case. Therefore, we override the DT_RELSZ entry
3956 here to make it not include the JMPREL relocs. Since
3957 the linker script arranges for .rel.plt to follow all
3958 other relocation sections, we don't have to worry
3959 about changing the DT_REL entry. */
3960 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3963 if (s
->_cooked_size
!= 0)
3964 dyn
.d_un
.d_val
-= s
->_cooked_size
;
3966 dyn
.d_un
.d_val
-= s
->_raw_size
;
3968 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3971 /* Set the bottom bit of DT_INIT/FINI if the
3972 corresponding function is Thumb. */
3974 name
= info
->init_function
;
3977 name
= info
->fini_function
;
3979 /* If it wasn't set by elf_bfd_final_link
3980 then there is nothing to adjust. */
3981 if (dyn
.d_un
.d_val
!= 0)
3983 struct elf_link_hash_entry
* eh
;
3985 eh
= elf_link_hash_lookup (elf_hash_table (info
), name
,
3986 FALSE
, FALSE
, TRUE
);
3987 if (eh
!= (struct elf_link_hash_entry
*) NULL
3988 && ELF_ST_TYPE (eh
->type
) == STT_ARM_TFUNC
)
3990 dyn
.d_un
.d_val
|= 1;
3991 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3998 /* Fill in the first entry in the procedure linkage table. */
3999 if (splt
->_raw_size
> 0)
4001 bfd_vma got_displacement
;
4003 /* Calculate the displacement between the PLT slot and &GOT[0]. */
4004 got_displacement
= (sgot
->output_section
->vma
4005 + sgot
->output_offset
4006 - splt
->output_section
->vma
4007 - splt
->output_offset
4010 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[0], splt
->contents
+ 0);
4011 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[1], splt
->contents
+ 4);
4012 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[2], splt
->contents
+ 8);
4013 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[3], splt
->contents
+ 12);
4014 #ifdef FOUR_WORD_PLT
4015 /* The displacement value goes in the otherwise-unused last word of
4016 the second entry. */
4017 bfd_put_32 (output_bfd
, got_displacement
, splt
->contents
+ 28);
4019 bfd_put_32 (output_bfd
, got_displacement
, splt
->contents
+ 16);
4023 /* UnixWare sets the entsize of .plt to 4, although that doesn't
4024 really seem like the right value. */
4025 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
4028 /* Fill in the first three entries in the global offset table. */
4029 if (sgot
->_raw_size
> 0)
4032 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
4034 bfd_put_32 (output_bfd
,
4035 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
4037 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
4038 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
4041 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
4047 elf32_arm_post_process_headers (abfd
, link_info
)
4049 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
;
4051 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
4053 i_ehdrp
= elf_elfheader (abfd
);
4055 i_ehdrp
->e_ident
[EI_OSABI
] = ARM_ELF_OS_ABI_VERSION
;
4056 i_ehdrp
->e_ident
[EI_ABIVERSION
] = ARM_ELF_ABI_VERSION
;
4059 static enum elf_reloc_type_class
4060 elf32_arm_reloc_type_class (rela
)
4061 const Elf_Internal_Rela
*rela
;
4063 switch ((int) ELF32_R_TYPE (rela
->r_info
))
4065 case R_ARM_RELATIVE
:
4066 return reloc_class_relative
;
4067 case R_ARM_JUMP_SLOT
:
4068 return reloc_class_plt
;
4070 return reloc_class_copy
;
4072 return reloc_class_normal
;
4076 static bfd_boolean elf32_arm_section_flags
PARAMS ((flagword
*, Elf_Internal_Shdr
*));
4077 static void elf32_arm_final_write_processing
PARAMS ((bfd
*, bfd_boolean
));
4079 /* Set the right machine number for an Arm ELF file. */
4082 elf32_arm_section_flags (flags
, hdr
)
4084 Elf_Internal_Shdr
*hdr
;
4086 if (hdr
->sh_type
== SHT_NOTE
)
4087 *flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_CONTENTS
;
4093 elf32_arm_final_write_processing (abfd
, linker
)
4095 bfd_boolean linker ATTRIBUTE_UNUSED
;
4097 bfd_arm_update_notes (abfd
, ARM_NOTE_SECTION
);
4100 #define ELF_ARCH bfd_arch_arm
4101 #define ELF_MACHINE_CODE EM_ARM
4102 #ifdef __QNXTARGET__
4103 #define ELF_MAXPAGESIZE 0x1000
4105 #define ELF_MAXPAGESIZE 0x8000
4108 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
4109 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
4110 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
4111 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
4112 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
4113 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
4114 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
4116 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
4117 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
4118 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
4119 #define elf_backend_check_relocs elf32_arm_check_relocs
4120 #define elf_backend_relocate_section elf32_arm_relocate_section
4121 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
4122 #define elf_backend_create_dynamic_sections elf32_arm_create_dynamic_sections
4123 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
4124 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
4125 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
4126 #define elf_backend_post_process_headers elf32_arm_post_process_headers
4127 #define elf_backend_reloc_type_class elf32_arm_reloc_type_class
4128 #define elf_backend_object_p elf32_arm_object_p
4129 #define elf_backend_section_flags elf32_arm_section_flags
4130 #define elf_backend_final_write_processing elf32_arm_final_write_processing
4131 #define elf_backend_copy_indirect_symbol elf32_arm_copy_indirect_symbol
4133 #define elf_backend_can_refcount 1
4134 #define elf_backend_can_gc_sections 1
4135 #define elf_backend_plt_readonly 1
4136 #define elf_backend_want_got_plt 1
4137 #define elf_backend_want_plt_sym 0
4139 #define elf_backend_rela_normal 1
4142 #define elf_backend_got_header_size 12
4144 #include "elf32-target.h"