1 /* 32-bit ELF support for ARM
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
24 typedef unsigned long int insn32
;
25 typedef unsigned short int insn16
;
27 static bfd_boolean elf32_arm_set_private_flags
28 PARAMS ((bfd
*, flagword
));
29 static bfd_boolean elf32_arm_copy_private_bfd_data
30 PARAMS ((bfd
*, bfd
*));
31 static bfd_boolean elf32_arm_merge_private_bfd_data
32 PARAMS ((bfd
*, bfd
*));
33 static bfd_boolean elf32_arm_print_private_bfd_data
34 PARAMS ((bfd
*, PTR
));
35 static int elf32_arm_get_symbol_type
36 PARAMS (( Elf_Internal_Sym
*, int));
37 static struct bfd_link_hash_table
*elf32_arm_link_hash_table_create
39 static bfd_reloc_status_type elf32_arm_final_link_relocate
40 PARAMS ((reloc_howto_type
*, bfd
*, bfd
*, asection
*, bfd_byte
*,
41 Elf_Internal_Rela
*, bfd_vma
, struct bfd_link_info
*, asection
*,
42 const char *, int, struct elf_link_hash_entry
*));
43 static insn32 insert_thumb_branch
44 PARAMS ((insn32
, int));
45 static struct elf_link_hash_entry
*find_thumb_glue
46 PARAMS ((struct bfd_link_info
*, const char *, bfd
*));
47 static struct elf_link_hash_entry
*find_arm_glue
48 PARAMS ((struct bfd_link_info
*, const char *, bfd
*));
49 static void elf32_arm_post_process_headers
50 PARAMS ((bfd
*, struct bfd_link_info
*));
51 static int elf32_arm_to_thumb_stub
52 PARAMS ((struct bfd_link_info
*, const char *, bfd
*, bfd
*, asection
*,
53 bfd_byte
*, asection
*, bfd_vma
, bfd_signed_vma
, bfd_vma
));
54 static int elf32_thumb_to_arm_stub
55 PARAMS ((struct bfd_link_info
*, const char *, bfd
*, bfd
*, asection
*,
56 bfd_byte
*, asection
*, bfd_vma
, bfd_signed_vma
, bfd_vma
));
57 static bfd_boolean elf32_arm_relocate_section
58 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
59 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
60 static asection
* elf32_arm_gc_mark_hook
61 PARAMS ((asection
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
62 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
63 static bfd_boolean elf32_arm_gc_sweep_hook
64 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
65 const Elf_Internal_Rela
*));
66 static bfd_boolean elf32_arm_check_relocs
67 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
68 const Elf_Internal_Rela
*));
69 static bfd_boolean elf32_arm_find_nearest_line
70 PARAMS ((bfd
*, asection
*, asymbol
**, bfd_vma
, const char **,
71 const char **, unsigned int *));
72 static bfd_boolean elf32_arm_adjust_dynamic_symbol
73 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
74 static bfd_boolean elf32_arm_size_dynamic_sections
75 PARAMS ((bfd
*, struct bfd_link_info
*));
76 static bfd_boolean elf32_arm_finish_dynamic_symbol
77 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
79 static bfd_boolean elf32_arm_finish_dynamic_sections
80 PARAMS ((bfd
*, struct bfd_link_info
*));
81 static struct bfd_hash_entry
* elf32_arm_link_hash_newfunc
82 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
84 static void arm_add_to_rel
85 PARAMS ((bfd
*, bfd_byte
*, reloc_howto_type
*, bfd_signed_vma
));
87 static enum elf_reloc_type_class elf32_arm_reloc_type_class
88 PARAMS ((const Elf_Internal_Rela
*));
89 static bfd_boolean elf32_arm_object_p
92 #ifndef ELFARM_NABI_C_INCLUDED
93 static void record_arm_to_thumb_glue
94 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
95 static void record_thumb_to_arm_glue
96 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
97 bfd_boolean bfd_elf32_arm_allocate_interworking_sections
98 PARAMS ((struct bfd_link_info
*));
99 bfd_boolean bfd_elf32_arm_get_bfd_for_interworking
100 PARAMS ((bfd
*, struct bfd_link_info
*));
101 bfd_boolean bfd_elf32_arm_process_before_allocation
102 PARAMS ((bfd
*, struct bfd_link_info
*, int));
106 #define INTERWORK_FLAG(abfd) (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK)
108 /* The linker script knows the section names for placement.
109 The entry_names are used to do simple name mangling on the stubs.
110 Given a function name, and its type, the stub can be found. The
111 name can be changed. The only requirement is the %s be present. */
112 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
113 #define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
115 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
116 #define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
118 /* The name of the dynamic interpreter. This is put in the .interp
120 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
122 /* The size in bytes of an entry in the procedure linkage table. */
123 #define PLT_ENTRY_SIZE 16
125 /* The first entry in a procedure linkage table looks like
126 this. It is set up so that any shared library function that is
127 called before the relocation has been set up calls the dynamic
129 static const bfd_vma elf32_arm_plt0_entry
[PLT_ENTRY_SIZE
/ 4] =
131 0xe52de004, /* str lr, [sp, #-4]! */
132 0xe59fe010, /* ldr lr, [pc, #16] */
133 0xe08fe00e, /* add lr, pc, lr */
134 0xe5bef008 /* ldr pc, [lr, #8]! */
137 /* Subsequent entries in a procedure linkage table look like
139 static const bfd_vma elf32_arm_plt_entry
[PLT_ENTRY_SIZE
/ 4] =
141 0xe59fc004, /* ldr ip, [pc, #4] */
142 0xe08fc00c, /* add ip, pc, ip */
143 0xe59cf000, /* ldr pc, [ip] */
144 0x00000000 /* offset to symbol in got */
147 /* The ARM linker needs to keep track of the number of relocs that it
148 decides to copy in check_relocs for each symbol. This is so that
149 it can discard PC relative relocs if it doesn't need them when
150 linking with -Bsymbolic. We store the information in a field
151 extending the regular ELF linker hash table. */
153 /* This structure keeps track of the number of PC relative relocs we
154 have copied for a given symbol. */
155 struct elf32_arm_pcrel_relocs_copied
158 struct elf32_arm_pcrel_relocs_copied
* next
;
159 /* A section in dynobj. */
161 /* Number of relocs copied in this section. */
165 /* Arm ELF linker hash entry. */
166 struct elf32_arm_link_hash_entry
168 struct elf_link_hash_entry root
;
170 /* Number of PC relative relocs copied for this symbol. */
171 struct elf32_arm_pcrel_relocs_copied
* pcrel_relocs_copied
;
174 /* Declare this now that the above structures are defined. */
175 static bfd_boolean elf32_arm_discard_copies
176 PARAMS ((struct elf32_arm_link_hash_entry
*, PTR
));
178 /* Traverse an arm ELF linker hash table. */
179 #define elf32_arm_link_hash_traverse(table, func, info) \
180 (elf_link_hash_traverse \
182 (bfd_boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
185 /* Get the ARM elf linker hash table from a link_info structure. */
186 #define elf32_arm_hash_table(info) \
187 ((struct elf32_arm_link_hash_table *) ((info)->hash))
189 /* ARM ELF linker hash table. */
190 struct elf32_arm_link_hash_table
192 /* The main hash table. */
193 struct elf_link_hash_table root
;
195 /* The size in bytes of the section containg the Thumb-to-ARM glue. */
196 bfd_size_type thumb_glue_size
;
198 /* The size in bytes of the section containg the ARM-to-Thumb glue. */
199 bfd_size_type arm_glue_size
;
201 /* An arbitary input BFD chosen to hold the glue sections. */
202 bfd
* bfd_of_glue_owner
;
204 /* A boolean indicating whether knowledge of the ARM's pipeline
205 length should be applied by the linker. */
206 int no_pipeline_knowledge
;
209 /* Create an entry in an ARM ELF linker hash table. */
211 static struct bfd_hash_entry
*
212 elf32_arm_link_hash_newfunc (entry
, table
, string
)
213 struct bfd_hash_entry
* entry
;
214 struct bfd_hash_table
* table
;
217 struct elf32_arm_link_hash_entry
* ret
=
218 (struct elf32_arm_link_hash_entry
*) entry
;
220 /* Allocate the structure if it has not already been allocated by a
222 if (ret
== (struct elf32_arm_link_hash_entry
*) NULL
)
223 ret
= ((struct elf32_arm_link_hash_entry
*)
224 bfd_hash_allocate (table
,
225 sizeof (struct elf32_arm_link_hash_entry
)));
226 if (ret
== (struct elf32_arm_link_hash_entry
*) NULL
)
227 return (struct bfd_hash_entry
*) ret
;
229 /* Call the allocation method of the superclass. */
230 ret
= ((struct elf32_arm_link_hash_entry
*)
231 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
233 if (ret
!= (struct elf32_arm_link_hash_entry
*) NULL
)
234 ret
->pcrel_relocs_copied
= NULL
;
236 return (struct bfd_hash_entry
*) ret
;
239 /* Create an ARM elf linker hash table. */
241 static struct bfd_link_hash_table
*
242 elf32_arm_link_hash_table_create (abfd
)
245 struct elf32_arm_link_hash_table
*ret
;
246 bfd_size_type amt
= sizeof (struct elf32_arm_link_hash_table
);
248 ret
= (struct elf32_arm_link_hash_table
*) bfd_malloc (amt
);
249 if (ret
== (struct elf32_arm_link_hash_table
*) NULL
)
252 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
253 elf32_arm_link_hash_newfunc
))
259 ret
->thumb_glue_size
= 0;
260 ret
->arm_glue_size
= 0;
261 ret
->bfd_of_glue_owner
= NULL
;
262 ret
->no_pipeline_knowledge
= 0;
264 return &ret
->root
.root
;
267 /* Locate the Thumb encoded calling stub for NAME. */
269 static struct elf_link_hash_entry
*
270 find_thumb_glue (link_info
, name
, input_bfd
)
271 struct bfd_link_info
*link_info
;
276 struct elf_link_hash_entry
*hash
;
277 struct elf32_arm_link_hash_table
*hash_table
;
279 /* We need a pointer to the armelf specific hash table. */
280 hash_table
= elf32_arm_hash_table (link_info
);
282 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
283 + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1);
285 BFD_ASSERT (tmp_name
);
287 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
289 hash
= elf_link_hash_lookup
290 (&(hash_table
)->root
, tmp_name
, FALSE
, FALSE
, TRUE
);
293 /* xgettext:c-format */
294 (*_bfd_error_handler
) (_("%s: unable to find THUMB glue '%s' for `%s'"),
295 bfd_archive_filename (input_bfd
), tmp_name
, name
);
302 /* Locate the ARM encoded calling stub for NAME. */
304 static struct elf_link_hash_entry
*
305 find_arm_glue (link_info
, name
, input_bfd
)
306 struct bfd_link_info
*link_info
;
311 struct elf_link_hash_entry
*myh
;
312 struct elf32_arm_link_hash_table
*hash_table
;
314 /* We need a pointer to the elfarm specific hash table. */
315 hash_table
= elf32_arm_hash_table (link_info
);
317 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
318 + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1);
320 BFD_ASSERT (tmp_name
);
322 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
324 myh
= elf_link_hash_lookup
325 (&(hash_table
)->root
, tmp_name
, FALSE
, FALSE
, TRUE
);
328 /* xgettext:c-format */
329 (*_bfd_error_handler
) (_("%s: unable to find ARM glue '%s' for `%s'"),
330 bfd_archive_filename (input_bfd
), tmp_name
, name
);
344 .word func @ behave as if you saw a ARM_32 reloc. */
346 #define ARM2THUMB_GLUE_SIZE 12
347 static const insn32 a2t1_ldr_insn
= 0xe59fc000;
348 static const insn32 a2t2_bx_r12_insn
= 0xe12fff1c;
349 static const insn32 a2t3_func_addr_insn
= 0x00000001;
351 /* Thumb->ARM: Thumb->(non-interworking aware) ARM
355 __func_from_thumb: __func_from_thumb:
357 nop ldr r6, __func_addr
359 __func_change_to_arm: bx r6
361 __func_back_to_thumb:
367 #define THUMB2ARM_GLUE_SIZE 8
368 static const insn16 t2a1_bx_pc_insn
= 0x4778;
369 static const insn16 t2a2_noop_insn
= 0x46c0;
370 static const insn32 t2a3_b_insn
= 0xea000000;
372 #ifndef ELFARM_NABI_C_INCLUDED
374 bfd_elf32_arm_allocate_interworking_sections (info
)
375 struct bfd_link_info
* info
;
379 struct elf32_arm_link_hash_table
* globals
;
381 globals
= elf32_arm_hash_table (info
);
383 BFD_ASSERT (globals
!= NULL
);
385 if (globals
->arm_glue_size
!= 0)
387 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
389 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
390 ARM2THUMB_GLUE_SECTION_NAME
);
392 BFD_ASSERT (s
!= NULL
);
394 foo
= (bfd_byte
*) bfd_alloc (globals
->bfd_of_glue_owner
,
395 globals
->arm_glue_size
);
397 s
->_raw_size
= s
->_cooked_size
= globals
->arm_glue_size
;
401 if (globals
->thumb_glue_size
!= 0)
403 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
405 s
= bfd_get_section_by_name
406 (globals
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
408 BFD_ASSERT (s
!= NULL
);
410 foo
= (bfd_byte
*) bfd_alloc (globals
->bfd_of_glue_owner
,
411 globals
->thumb_glue_size
);
413 s
->_raw_size
= s
->_cooked_size
= globals
->thumb_glue_size
;
421 record_arm_to_thumb_glue (link_info
, h
)
422 struct bfd_link_info
* link_info
;
423 struct elf_link_hash_entry
* h
;
425 const char * name
= h
->root
.root
.string
;
428 struct elf_link_hash_entry
* myh
;
429 struct bfd_link_hash_entry
* bh
;
430 struct elf32_arm_link_hash_table
* globals
;
433 globals
= elf32_arm_hash_table (link_info
);
435 BFD_ASSERT (globals
!= NULL
);
436 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
438 s
= bfd_get_section_by_name
439 (globals
->bfd_of_glue_owner
, ARM2THUMB_GLUE_SECTION_NAME
);
441 BFD_ASSERT (s
!= NULL
);
443 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
444 + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1);
446 BFD_ASSERT (tmp_name
);
448 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
450 myh
= elf_link_hash_lookup
451 (&(globals
)->root
, tmp_name
, FALSE
, FALSE
, TRUE
);
455 /* We've already seen this guy. */
460 /* The only trick here is using hash_table->arm_glue_size as the value. Even
461 though the section isn't allocated yet, this is where we will be putting
464 val
= globals
->arm_glue_size
+ 1;
465 _bfd_generic_link_add_one_symbol (link_info
, globals
->bfd_of_glue_owner
,
466 tmp_name
, BSF_GLOBAL
, s
, val
,
467 NULL
, TRUE
, FALSE
, &bh
);
471 globals
->arm_glue_size
+= ARM2THUMB_GLUE_SIZE
;
477 record_thumb_to_arm_glue (link_info
, h
)
478 struct bfd_link_info
*link_info
;
479 struct elf_link_hash_entry
*h
;
481 const char *name
= h
->root
.root
.string
;
484 struct elf_link_hash_entry
*myh
;
485 struct bfd_link_hash_entry
*bh
;
486 struct elf32_arm_link_hash_table
*hash_table
;
490 hash_table
= elf32_arm_hash_table (link_info
);
492 BFD_ASSERT (hash_table
!= NULL
);
493 BFD_ASSERT (hash_table
->bfd_of_glue_owner
!= NULL
);
495 s
= bfd_get_section_by_name
496 (hash_table
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
498 BFD_ASSERT (s
!= NULL
);
500 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
501 + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1);
503 BFD_ASSERT (tmp_name
);
505 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
507 myh
= elf_link_hash_lookup
508 (&(hash_table
)->root
, tmp_name
, FALSE
, FALSE
, TRUE
);
512 /* We've already seen this guy. */
518 val
= hash_table
->thumb_glue_size
+ 1;
519 _bfd_generic_link_add_one_symbol (link_info
, hash_table
->bfd_of_glue_owner
,
520 tmp_name
, BSF_GLOBAL
, s
, val
,
521 NULL
, TRUE
, FALSE
, &bh
);
523 /* If we mark it 'Thumb', the disassembler will do a better job. */
524 myh
= (struct elf_link_hash_entry
*) bh
;
525 bind
= ELF_ST_BIND (myh
->type
);
526 myh
->type
= ELF_ST_INFO (bind
, STT_ARM_TFUNC
);
530 #define CHANGE_TO_ARM "__%s_change_to_arm"
531 #define BACK_FROM_ARM "__%s_back_from_arm"
533 /* Allocate another symbol to mark where we switch to Arm mode. */
534 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
535 + strlen (CHANGE_TO_ARM
) + 1);
537 BFD_ASSERT (tmp_name
);
539 sprintf (tmp_name
, CHANGE_TO_ARM
, name
);
542 val
= hash_table
->thumb_glue_size
+ 4,
543 _bfd_generic_link_add_one_symbol (link_info
, hash_table
->bfd_of_glue_owner
,
544 tmp_name
, BSF_LOCAL
, s
, val
,
545 NULL
, TRUE
, FALSE
, &bh
);
549 hash_table
->thumb_glue_size
+= THUMB2ARM_GLUE_SIZE
;
554 /* Add the glue sections to ABFD. This function is called from the
555 linker scripts in ld/emultempl/{armelf}.em. */
558 bfd_elf32_arm_add_glue_sections_to_bfd (abfd
, info
)
560 struct bfd_link_info
*info
;
565 /* If we are only performing a partial
566 link do not bother adding the glue. */
567 if (info
->relocateable
)
570 sec
= bfd_get_section_by_name (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
574 /* Note: we do not include the flag SEC_LINKER_CREATED, as this
575 will prevent elf_link_input_bfd() from processing the contents
577 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_CODE
| SEC_READONLY
;
579 sec
= bfd_make_section (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
582 || !bfd_set_section_flags (abfd
, sec
, flags
)
583 || !bfd_set_section_alignment (abfd
, sec
, 2))
586 /* Set the gc mark to prevent the section from being removed by garbage
587 collection, despite the fact that no relocs refer to this section. */
591 sec
= bfd_get_section_by_name (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
595 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_CODE
| SEC_READONLY
;
597 sec
= bfd_make_section (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
600 || !bfd_set_section_flags (abfd
, sec
, flags
)
601 || !bfd_set_section_alignment (abfd
, sec
, 2))
610 /* Select a BFD to be used to hold the sections used by the glue code.
611 This function is called from the linker scripts in ld/emultempl/
615 bfd_elf32_arm_get_bfd_for_interworking (abfd
, info
)
617 struct bfd_link_info
*info
;
619 struct elf32_arm_link_hash_table
*globals
;
621 /* If we are only performing a partial link
622 do not bother getting a bfd to hold the glue. */
623 if (info
->relocateable
)
626 globals
= elf32_arm_hash_table (info
);
628 BFD_ASSERT (globals
!= NULL
);
630 if (globals
->bfd_of_glue_owner
!= NULL
)
633 /* Save the bfd for later use. */
634 globals
->bfd_of_glue_owner
= abfd
;
640 bfd_elf32_arm_process_before_allocation (abfd
, link_info
, no_pipeline_knowledge
)
642 struct bfd_link_info
*link_info
;
643 int no_pipeline_knowledge
;
645 Elf_Internal_Shdr
*symtab_hdr
;
646 Elf_Internal_Rela
*internal_relocs
= NULL
;
647 Elf_Internal_Rela
*irel
, *irelend
;
648 bfd_byte
*contents
= NULL
;
651 struct elf32_arm_link_hash_table
*globals
;
653 /* If we are only performing a partial link do not bother
654 to construct any glue. */
655 if (link_info
->relocateable
)
658 /* Here we have a bfd that is to be included on the link. We have a hook
659 to do reloc rummaging, before section sizes are nailed down. */
660 globals
= elf32_arm_hash_table (link_info
);
662 BFD_ASSERT (globals
!= NULL
);
663 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
665 globals
->no_pipeline_knowledge
= no_pipeline_knowledge
;
667 /* Rummage around all the relocs and map the glue vectors. */
668 sec
= abfd
->sections
;
673 for (; sec
!= NULL
; sec
= sec
->next
)
675 if (sec
->reloc_count
== 0)
678 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
680 /* Load the relocs. */
682 = _bfd_elf32_link_read_relocs (abfd
, sec
, (PTR
) NULL
,
683 (Elf_Internal_Rela
*) NULL
, FALSE
);
685 if (internal_relocs
== NULL
)
688 irelend
= internal_relocs
+ sec
->reloc_count
;
689 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
692 unsigned long r_index
;
694 struct elf_link_hash_entry
*h
;
696 r_type
= ELF32_R_TYPE (irel
->r_info
);
697 r_index
= ELF32_R_SYM (irel
->r_info
);
699 /* These are the only relocation types we care about. */
700 if ( r_type
!= R_ARM_PC24
701 && r_type
!= R_ARM_THM_PC22
)
704 /* Get the section contents if we haven't done so already. */
705 if (contents
== NULL
)
707 /* Get cached copy if it exists. */
708 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
709 contents
= elf_section_data (sec
)->this_hdr
.contents
;
712 /* Go get them off disk. */
713 contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
714 if (contents
== NULL
)
717 if (!bfd_get_section_contents (abfd
, sec
, contents
,
718 (file_ptr
) 0, sec
->_raw_size
))
723 /* If the relocation is not against a symbol it cannot concern us. */
726 /* We don't care about local symbols. */
727 if (r_index
< symtab_hdr
->sh_info
)
730 /* This is an external symbol. */
731 r_index
-= symtab_hdr
->sh_info
;
732 h
= (struct elf_link_hash_entry
*)
733 elf_sym_hashes (abfd
)[r_index
];
735 /* If the relocation is against a static symbol it must be within
736 the current section and so cannot be a cross ARM/Thumb relocation. */
743 /* This one is a call from arm code. We need to look up
744 the target of the call. If it is a thumb target, we
746 if (ELF_ST_TYPE(h
->type
) == STT_ARM_TFUNC
)
747 record_arm_to_thumb_glue (link_info
, h
);
751 /* This one is a call from thumb code. We look
752 up the target of the call. If it is not a thumb
753 target, we insert glue. */
754 if (ELF_ST_TYPE (h
->type
) != STT_ARM_TFUNC
)
755 record_thumb_to_arm_glue (link_info
, h
);
764 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
768 if (internal_relocs
!= NULL
769 && elf_section_data (sec
)->relocs
!= internal_relocs
)
770 free (internal_relocs
);
771 internal_relocs
= NULL
;
778 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
780 if (internal_relocs
!= NULL
781 && elf_section_data (sec
)->relocs
!= internal_relocs
)
782 free (internal_relocs
);
788 /* The thumb form of a long branch is a bit finicky, because the offset
789 encoding is split over two fields, each in it's own instruction. They
790 can occur in any order. So given a thumb form of long branch, and an
791 offset, insert the offset into the thumb branch and return finished
794 It takes two thumb instructions to encode the target address. Each has
795 11 bits to invest. The upper 11 bits are stored in one (identifed by
796 H-0.. see below), the lower 11 bits are stored in the other (identified
799 Combine together and shifted left by 1 (it's a half word address) and
803 H-0, upper address-0 = 000
805 H-1, lower address-0 = 800
807 They can be ordered either way, but the arm tools I've seen always put
808 the lower one first. It probably doesn't matter. krk@cygnus.com
810 XXX: Actually the order does matter. The second instruction (H-1)
811 moves the computed address into the PC, so it must be the second one
812 in the sequence. The problem, however is that whilst little endian code
813 stores the instructions in HI then LOW order, big endian code does the
814 reverse. nickc@cygnus.com. */
816 #define LOW_HI_ORDER 0xF800F000
817 #define HI_LOW_ORDER 0xF000F800
820 insert_thumb_branch (br_insn
, rel_off
)
824 unsigned int low_bits
;
825 unsigned int high_bits
;
827 BFD_ASSERT ((rel_off
& 1) != 1);
829 rel_off
>>= 1; /* Half word aligned address. */
830 low_bits
= rel_off
& 0x000007FF; /* The bottom 11 bits. */
831 high_bits
= (rel_off
>> 11) & 0x000007FF; /* The top 11 bits. */
833 if ((br_insn
& LOW_HI_ORDER
) == LOW_HI_ORDER
)
834 br_insn
= LOW_HI_ORDER
| (low_bits
<< 16) | high_bits
;
835 else if ((br_insn
& HI_LOW_ORDER
) == HI_LOW_ORDER
)
836 br_insn
= HI_LOW_ORDER
| (high_bits
<< 16) | low_bits
;
838 /* FIXME: abort is probably not the right call. krk@cygnus.com */
839 abort (); /* error - not a valid branch instruction form. */
844 /* Thumb code calling an ARM function. */
847 elf32_thumb_to_arm_stub (info
, name
, input_bfd
, output_bfd
, input_section
,
848 hit_data
, sym_sec
, offset
, addend
, val
)
849 struct bfd_link_info
* info
;
853 asection
* input_section
;
857 bfd_signed_vma addend
;
862 unsigned long int tmp
;
864 struct elf_link_hash_entry
* myh
;
865 struct elf32_arm_link_hash_table
* globals
;
867 myh
= find_thumb_glue (info
, name
, input_bfd
);
871 globals
= elf32_arm_hash_table (info
);
873 BFD_ASSERT (globals
!= NULL
);
874 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
876 my_offset
= myh
->root
.u
.def
.value
;
878 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
879 THUMB2ARM_GLUE_SECTION_NAME
);
881 BFD_ASSERT (s
!= NULL
);
882 BFD_ASSERT (s
->contents
!= NULL
);
883 BFD_ASSERT (s
->output_section
!= NULL
);
885 if ((my_offset
& 0x01) == 0x01)
888 && sym_sec
->owner
!= NULL
889 && !INTERWORK_FLAG (sym_sec
->owner
))
891 (*_bfd_error_handler
)
892 (_("%s(%s): warning: interworking not enabled."),
893 bfd_archive_filename (sym_sec
->owner
), name
);
894 (*_bfd_error_handler
)
895 (_(" first occurrence: %s: thumb call to arm"),
896 bfd_archive_filename (input_bfd
));
902 myh
->root
.u
.def
.value
= my_offset
;
904 bfd_put_16 (output_bfd
, (bfd_vma
) t2a1_bx_pc_insn
,
905 s
->contents
+ my_offset
);
907 bfd_put_16 (output_bfd
, (bfd_vma
) t2a2_noop_insn
,
908 s
->contents
+ my_offset
+ 2);
911 /* Address of destination of the stub. */
912 ((bfd_signed_vma
) val
)
914 /* Offset from the start of the current section to the start of the stubs. */
916 /* Offset of the start of this stub from the start of the stubs. */
918 /* Address of the start of the current section. */
919 + s
->output_section
->vma
)
920 /* The branch instruction is 4 bytes into the stub. */
922 /* ARM branches work from the pc of the instruction + 8. */
925 bfd_put_32 (output_bfd
,
926 (bfd_vma
) t2a3_b_insn
| ((ret_offset
>> 2) & 0x00FFFFFF),
927 s
->contents
+ my_offset
+ 4);
930 BFD_ASSERT (my_offset
<= globals
->thumb_glue_size
);
932 /* Now go back and fix up the original BL insn to point to here. */
934 /* Address of where the stub is located. */
935 (s
->output_section
->vma
+ s
->output_offset
+ my_offset
)
936 /* Address of where the BL is located. */
937 - (input_section
->output_section
->vma
+ input_section
->output_offset
+ offset
)
938 /* Addend in the relocation. */
940 /* Biassing for PC-relative addressing. */
943 tmp
= bfd_get_32 (input_bfd
, hit_data
944 - input_section
->vma
);
946 bfd_put_32 (output_bfd
,
947 (bfd_vma
) insert_thumb_branch (tmp
, ret_offset
),
948 hit_data
- input_section
->vma
);
953 /* Arm code calling a Thumb function. */
956 elf32_arm_to_thumb_stub (info
, name
, input_bfd
, output_bfd
, input_section
,
957 hit_data
, sym_sec
, offset
, addend
, val
)
958 struct bfd_link_info
* info
;
962 asection
* input_section
;
966 bfd_signed_vma addend
;
969 unsigned long int tmp
;
973 struct elf_link_hash_entry
* myh
;
974 struct elf32_arm_link_hash_table
* globals
;
976 myh
= find_arm_glue (info
, name
, input_bfd
);
980 globals
= elf32_arm_hash_table (info
);
982 BFD_ASSERT (globals
!= NULL
);
983 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
985 my_offset
= myh
->root
.u
.def
.value
;
986 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
987 ARM2THUMB_GLUE_SECTION_NAME
);
988 BFD_ASSERT (s
!= NULL
);
989 BFD_ASSERT (s
->contents
!= NULL
);
990 BFD_ASSERT (s
->output_section
!= NULL
);
992 if ((my_offset
& 0x01) == 0x01)
995 && sym_sec
->owner
!= NULL
996 && !INTERWORK_FLAG (sym_sec
->owner
))
998 (*_bfd_error_handler
)
999 (_("%s(%s): warning: interworking not enabled."),
1000 bfd_archive_filename (sym_sec
->owner
), name
);
1001 (*_bfd_error_handler
)
1002 (_(" first occurrence: %s: arm call to thumb"),
1003 bfd_archive_filename (input_bfd
));
1007 myh
->root
.u
.def
.value
= my_offset
;
1009 bfd_put_32 (output_bfd
, (bfd_vma
) a2t1_ldr_insn
,
1010 s
->contents
+ my_offset
);
1012 bfd_put_32 (output_bfd
, (bfd_vma
) a2t2_bx_r12_insn
,
1013 s
->contents
+ my_offset
+ 4);
1015 /* It's a thumb address. Add the low order bit. */
1016 bfd_put_32 (output_bfd
, val
| a2t3_func_addr_insn
,
1017 s
->contents
+ my_offset
+ 8);
1020 BFD_ASSERT (my_offset
<= globals
->arm_glue_size
);
1022 tmp
= bfd_get_32 (input_bfd
, hit_data
);
1023 tmp
= tmp
& 0xFF000000;
1025 /* Somehow these are both 4 too far, so subtract 8. */
1026 ret_offset
= (s
->output_offset
1028 + s
->output_section
->vma
1029 - (input_section
->output_offset
1030 + input_section
->output_section
->vma
1034 tmp
= tmp
| ((ret_offset
>> 2) & 0x00FFFFFF);
1036 bfd_put_32 (output_bfd
, (bfd_vma
) tmp
, hit_data
- input_section
->vma
);
1041 /* Perform a relocation as part of a final link. */
1043 static bfd_reloc_status_type
1044 elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
1045 input_section
, contents
, rel
, value
,
1046 info
, sym_sec
, sym_name
, sym_flags
, h
)
1047 reloc_howto_type
* howto
;
1050 asection
* input_section
;
1051 bfd_byte
* contents
;
1052 Elf_Internal_Rela
* rel
;
1054 struct bfd_link_info
* info
;
1056 const char * sym_name
;
1058 struct elf_link_hash_entry
* h
;
1060 unsigned long r_type
= howto
->type
;
1061 unsigned long r_symndx
;
1062 bfd_byte
* hit_data
= contents
+ rel
->r_offset
;
1063 bfd
* dynobj
= NULL
;
1064 Elf_Internal_Shdr
* symtab_hdr
;
1065 struct elf_link_hash_entry
** sym_hashes
;
1066 bfd_vma
* local_got_offsets
;
1067 asection
* sgot
= NULL
;
1068 asection
* splt
= NULL
;
1069 asection
* sreloc
= NULL
;
1071 bfd_signed_vma signed_addend
;
1072 struct elf32_arm_link_hash_table
* globals
;
1074 /* If the start address has been set, then set the EF_ARM_HASENTRY
1075 flag. Setting this more than once is redundant, but the cost is
1076 not too high, and it keeps the code simple.
1078 The test is done here, rather than somewhere else, because the
1079 start address is only set just before the final link commences.
1081 Note - if the user deliberately sets a start address of 0, the
1082 flag will not be set. */
1083 if (bfd_get_start_address (output_bfd
) != 0)
1084 elf_elfheader (output_bfd
)->e_flags
|= EF_ARM_HASENTRY
;
1086 globals
= elf32_arm_hash_table (info
);
1088 dynobj
= elf_hash_table (info
)->dynobj
;
1091 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1092 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1094 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1095 sym_hashes
= elf_sym_hashes (input_bfd
);
1096 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1097 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1100 addend
= bfd_get_32 (input_bfd
, hit_data
) & howto
->src_mask
;
1102 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1105 signed_addend
&= ~ howto
->src_mask
;
1106 signed_addend
|= addend
;
1109 signed_addend
= addend
;
1111 addend
= signed_addend
= rel
->r_addend
;
1117 return bfd_reloc_ok
;
1125 /* When generating a shared object, these relocations are copied
1126 into the output file to be resolved at run time. */
1129 && (r_type
!= R_ARM_PC24
1132 && (! info
->symbolic
1133 || (h
->elf_link_hash_flags
1134 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1136 Elf_Internal_Rela outrel
;
1138 bfd_boolean skip
, relocate
;
1144 name
= (bfd_elf_string_from_elf_section
1146 elf_elfheader (input_bfd
)->e_shstrndx
,
1147 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1149 return bfd_reloc_notsupported
;
1151 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
1152 && strcmp (bfd_get_section_name (input_bfd
,
1156 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1157 BFD_ASSERT (sreloc
!= NULL
);
1164 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
1166 if (outrel
.r_offset
== (bfd_vma
) -1)
1168 else if (outrel
.r_offset
== (bfd_vma
) -2)
1169 skip
= TRUE
, relocate
= TRUE
;
1170 outrel
.r_offset
+= (input_section
->output_section
->vma
1171 + input_section
->output_offset
);
1174 memset (&outrel
, 0, sizeof outrel
);
1175 else if (r_type
== R_ARM_PC24
)
1177 BFD_ASSERT (h
!= NULL
&& h
->dynindx
!= -1);
1178 if ((input_section
->flags
& SEC_ALLOC
) == 0)
1180 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_PC24
);
1185 || ((info
->symbolic
|| h
->dynindx
== -1)
1186 && (h
->elf_link_hash_flags
1187 & ELF_LINK_HASH_DEF_REGULAR
) != 0))
1190 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1194 BFD_ASSERT (h
->dynindx
!= -1);
1195 if ((input_section
->flags
& SEC_ALLOC
) == 0)
1197 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_ABS32
);
1201 loc
= sreloc
->contents
;
1202 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
1203 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
1205 /* If this reloc is against an external symbol, we do not want to
1206 fiddle with the addend. Otherwise, we need to include the symbol
1207 value so that it becomes an addend for the dynamic reloc. */
1209 return bfd_reloc_ok
;
1211 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1212 contents
, rel
->r_offset
, value
,
1215 else switch (r_type
)
1218 case R_ARM_XPC25
: /* Arm BLX instruction. */
1220 case R_ARM_PC24
: /* Arm B/BL instruction */
1222 if (r_type
== R_ARM_XPC25
)
1224 /* Check for Arm calling Arm function. */
1225 /* FIXME: Should we translate the instruction into a BL
1226 instruction instead ? */
1227 if (sym_flags
!= STT_ARM_TFUNC
)
1228 (*_bfd_error_handler
) (_("\
1229 %s: Warning: Arm BLX instruction targets Arm function '%s'."),
1230 bfd_archive_filename (input_bfd
),
1231 h
? h
->root
.root
.string
: "(local)");
1236 /* Check for Arm calling Thumb function. */
1237 if (sym_flags
== STT_ARM_TFUNC
)
1239 elf32_arm_to_thumb_stub (info
, sym_name
, input_bfd
, output_bfd
,
1240 input_section
, hit_data
, sym_sec
, rel
->r_offset
,
1241 signed_addend
, value
);
1242 return bfd_reloc_ok
;
1246 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1247 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0)
1249 /* The old way of doing things. Trearing the addend as a
1250 byte sized field and adding in the pipeline offset. */
1251 value
-= (input_section
->output_section
->vma
1252 + input_section
->output_offset
);
1253 value
-= rel
->r_offset
;
1256 if (! globals
->no_pipeline_knowledge
)
1261 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
1263 S is the address of the symbol in the relocation.
1264 P is address of the instruction being relocated.
1265 A is the addend (extracted from the instruction) in bytes.
1267 S is held in 'value'.
1268 P is the base address of the section containing the instruction
1269 plus the offset of the reloc into that section, ie:
1270 (input_section->output_section->vma +
1271 input_section->output_offset +
1273 A is the addend, converted into bytes, ie:
1276 Note: None of these operations have knowledge of the pipeline
1277 size of the processor, thus it is up to the assembler to encode
1278 this information into the addend. */
1279 value
-= (input_section
->output_section
->vma
1280 + input_section
->output_offset
);
1281 value
-= rel
->r_offset
;
1282 value
+= (signed_addend
<< howto
->size
);
1284 /* Previous versions of this code also used to add in the pipeline
1285 offset here. This is wrong because the linker is not supposed
1286 to know about such things, and one day it might change. In order
1287 to support old binaries that need the old behaviour however, so
1288 we attempt to detect which ABI was used to create the reloc. */
1289 if (! globals
->no_pipeline_knowledge
)
1291 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form */
1293 i_ehdrp
= elf_elfheader (input_bfd
);
1295 if (i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1300 signed_addend
= value
;
1301 signed_addend
>>= howto
->rightshift
;
1303 /* It is not an error for an undefined weak reference to be
1304 out of range. Any program that branches to such a symbol
1305 is going to crash anyway, so there is no point worrying
1306 about getting the destination exactly right. */
1307 if (! h
|| h
->root
.type
!= bfd_link_hash_undefweak
)
1309 /* Perform a signed range check. */
1310 if ( signed_addend
> ((bfd_signed_vma
) (howto
->dst_mask
>> 1))
1311 || signed_addend
< - ((bfd_signed_vma
) ((howto
->dst_mask
+ 1) >> 1)))
1312 return bfd_reloc_overflow
;
1316 /* If necessary set the H bit in the BLX instruction. */
1317 if (r_type
== R_ARM_XPC25
&& ((value
& 2) == 2))
1318 value
= (signed_addend
& howto
->dst_mask
)
1319 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
))
1323 value
= (signed_addend
& howto
->dst_mask
)
1324 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1329 if (sym_flags
== STT_ARM_TFUNC
)
1334 value
-= (input_section
->output_section
->vma
1335 + input_section
->output_offset
+ rel
->r_offset
);
1340 bfd_put_32 (input_bfd
, value
, hit_data
);
1341 return bfd_reloc_ok
;
1345 if ((long) value
> 0x7f || (long) value
< -0x80)
1346 return bfd_reloc_overflow
;
1348 bfd_put_8 (input_bfd
, value
, hit_data
);
1349 return bfd_reloc_ok
;
1354 if ((long) value
> 0x7fff || (long) value
< -0x8000)
1355 return bfd_reloc_overflow
;
1357 bfd_put_16 (input_bfd
, value
, hit_data
);
1358 return bfd_reloc_ok
;
1361 /* Support ldr and str instruction for the arm */
1362 /* Also thumb b (unconditional branch). ??? Really? */
1365 if ((long) value
> 0x7ff || (long) value
< -0x800)
1366 return bfd_reloc_overflow
;
1368 value
|= (bfd_get_32 (input_bfd
, hit_data
) & 0xfffff000);
1369 bfd_put_32 (input_bfd
, value
, hit_data
);
1370 return bfd_reloc_ok
;
1372 case R_ARM_THM_ABS5
:
1373 /* Support ldr and str instructions for the thumb. */
1375 /* Need to refetch addend. */
1376 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1377 /* ??? Need to determine shift amount from operand size. */
1378 addend
>>= howto
->rightshift
;
1382 /* ??? Isn't value unsigned? */
1383 if ((long) value
> 0x1f || (long) value
< -0x10)
1384 return bfd_reloc_overflow
;
1386 /* ??? Value needs to be properly shifted into place first. */
1387 value
|= bfd_get_16 (input_bfd
, hit_data
) & 0xf83f;
1388 bfd_put_16 (input_bfd
, value
, hit_data
);
1389 return bfd_reloc_ok
;
1392 case R_ARM_THM_XPC22
:
1394 case R_ARM_THM_PC22
:
1395 /* Thumb BL (branch long instruction). */
1398 bfd_boolean overflow
= FALSE
;
1399 bfd_vma upper_insn
= bfd_get_16 (input_bfd
, hit_data
);
1400 bfd_vma lower_insn
= bfd_get_16 (input_bfd
, hit_data
+ 2);
1401 bfd_signed_vma reloc_signed_max
= ((1 << (howto
->bitsize
- 1)) - 1) >> howto
->rightshift
;
1402 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1404 bfd_signed_vma signed_check
;
1407 /* Need to refetch the addend and squish the two 11 bit pieces
1410 bfd_vma upper
= upper_insn
& 0x7ff;
1411 bfd_vma lower
= lower_insn
& 0x7ff;
1412 upper
= (upper
^ 0x400) - 0x400; /* Sign extend. */
1413 addend
= (upper
<< 12) | (lower
<< 1);
1414 signed_addend
= addend
;
1418 if (r_type
== R_ARM_THM_XPC22
)
1420 /* Check for Thumb to Thumb call. */
1421 /* FIXME: Should we translate the instruction into a BL
1422 instruction instead ? */
1423 if (sym_flags
== STT_ARM_TFUNC
)
1424 (*_bfd_error_handler
) (_("\
1425 %s: Warning: Thumb BLX instruction targets thumb function '%s'."),
1426 bfd_archive_filename (input_bfd
),
1427 h
? h
->root
.root
.string
: "(local)");
1432 /* If it is not a call to Thumb, assume call to Arm.
1433 If it is a call relative to a section name, then it is not a
1434 function call at all, but rather a long jump. */
1435 if (sym_flags
!= STT_ARM_TFUNC
&& sym_flags
!= STT_SECTION
)
1437 if (elf32_thumb_to_arm_stub
1438 (info
, sym_name
, input_bfd
, output_bfd
, input_section
,
1439 hit_data
, sym_sec
, rel
->r_offset
, signed_addend
, value
))
1440 return bfd_reloc_ok
;
1442 return bfd_reloc_dangerous
;
1446 relocation
= value
+ signed_addend
;
1448 relocation
-= (input_section
->output_section
->vma
1449 + input_section
->output_offset
1452 if (! globals
->no_pipeline_knowledge
)
1454 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form. */
1456 i_ehdrp
= elf_elfheader (input_bfd
);
1458 /* Previous versions of this code also used to add in the pipline
1459 offset here. This is wrong because the linker is not supposed
1460 to know about such things, and one day it might change. In order
1461 to support old binaries that need the old behaviour however, so
1462 we attempt to detect which ABI was used to create the reloc. */
1463 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1464 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0
1465 || i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1469 check
= relocation
>> howto
->rightshift
;
1471 /* If this is a signed value, the rightshift just dropped
1472 leading 1 bits (assuming twos complement). */
1473 if ((bfd_signed_vma
) relocation
>= 0)
1474 signed_check
= check
;
1476 signed_check
= check
| ~((bfd_vma
) -1 >> howto
->rightshift
);
1478 /* Assumes two's complement. */
1479 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1483 if (r_type
== R_ARM_THM_XPC22
1484 && ((lower_insn
& 0x1800) == 0x0800))
1485 /* For a BLX instruction, make sure that the relocation is rounded up
1486 to a word boundary. This follows the semantics of the instruction
1487 which specifies that bit 1 of the target address will come from bit
1488 1 of the base address. */
1489 relocation
= (relocation
+ 2) & ~ 3;
1491 /* Put RELOCATION back into the insn. */
1492 upper_insn
= (upper_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 12) & 0x7ff);
1493 lower_insn
= (lower_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 1) & 0x7ff);
1495 /* Put the relocated value back in the object file: */
1496 bfd_put_16 (input_bfd
, upper_insn
, hit_data
);
1497 bfd_put_16 (input_bfd
, lower_insn
, hit_data
+ 2);
1499 return (overflow
? bfd_reloc_overflow
: bfd_reloc_ok
);
1503 case R_ARM_THM_PC11
:
1504 /* Thumb B (branch) instruction). */
1506 bfd_signed_vma relocation
;
1507 bfd_signed_vma reloc_signed_max
= (1 << (howto
->bitsize
- 1)) - 1;
1508 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1509 bfd_signed_vma signed_check
;
1512 /* Need to refetch addend. */
1513 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1514 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1517 signed_addend
&= ~ howto
->src_mask
;
1518 signed_addend
|= addend
;
1521 signed_addend
= addend
;
1522 /* The value in the insn has been right shifted. We need to
1523 undo this, so that we can perform the address calculation
1524 in terms of bytes. */
1525 signed_addend
<<= howto
->rightshift
;
1527 relocation
= value
+ signed_addend
;
1529 relocation
-= (input_section
->output_section
->vma
1530 + input_section
->output_offset
1533 relocation
>>= howto
->rightshift
;
1534 signed_check
= relocation
;
1535 relocation
&= howto
->dst_mask
;
1536 relocation
|= (bfd_get_16 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1538 bfd_put_16 (input_bfd
, relocation
, hit_data
);
1540 /* Assumes two's complement. */
1541 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1542 return bfd_reloc_overflow
;
1544 return bfd_reloc_ok
;
1547 case R_ARM_GNU_VTINHERIT
:
1548 case R_ARM_GNU_VTENTRY
:
1549 return bfd_reloc_ok
;
1552 return bfd_reloc_notsupported
;
1554 case R_ARM_GLOB_DAT
:
1555 return bfd_reloc_notsupported
;
1557 case R_ARM_JUMP_SLOT
:
1558 return bfd_reloc_notsupported
;
1560 case R_ARM_RELATIVE
:
1561 return bfd_reloc_notsupported
;
1564 /* Relocation is relative to the start of the
1565 global offset table. */
1567 BFD_ASSERT (sgot
!= NULL
);
1569 return bfd_reloc_notsupported
;
1571 /* If we are addressing a Thumb function, we need to adjust the
1572 address by one, so that attempts to call the function pointer will
1573 correctly interpret it as Thumb code. */
1574 if (sym_flags
== STT_ARM_TFUNC
)
1577 /* Note that sgot->output_offset is not involved in this
1578 calculation. We always want the start of .got. If we
1579 define _GLOBAL_OFFSET_TABLE in a different way, as is
1580 permitted by the ABI, we might have to change this
1582 value
-= sgot
->output_section
->vma
;
1583 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1584 contents
, rel
->r_offset
, value
,
1588 /* Use global offset table as symbol value. */
1589 BFD_ASSERT (sgot
!= NULL
);
1592 return bfd_reloc_notsupported
;
1594 value
= sgot
->output_section
->vma
;
1595 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1596 contents
, rel
->r_offset
, value
,
1600 /* Relocation is to the entry for this symbol in the
1601 global offset table. */
1603 return bfd_reloc_notsupported
;
1609 off
= h
->got
.offset
;
1610 BFD_ASSERT (off
!= (bfd_vma
) -1);
1612 if (!elf_hash_table (info
)->dynamic_sections_created
||
1613 (info
->shared
&& (info
->symbolic
|| h
->dynindx
== -1)
1614 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1616 /* This is actually a static link, or it is a -Bsymbolic link
1617 and the symbol is defined locally. We must initialize this
1618 entry in the global offset table. Since the offset must
1619 always be a multiple of 4, we use the least significant bit
1620 to record whether we have initialized it already.
1622 When doing a dynamic link, we create a .rel.got relocation
1623 entry to initialize the value. This is done in the
1624 finish_dynamic_symbol routine. */
1629 /* If we are addressing a Thumb function, we need to
1630 adjust the address by one, so that attempts to
1631 call the function pointer will correctly
1632 interpret it as Thumb code. */
1633 if (sym_flags
== STT_ARM_TFUNC
)
1636 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1641 value
= sgot
->output_offset
+ off
;
1647 BFD_ASSERT (local_got_offsets
!= NULL
&&
1648 local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1650 off
= local_got_offsets
[r_symndx
];
1652 /* The offset must always be a multiple of 4. We use the
1653 least significant bit to record whether we have already
1654 generated the necessary reloc. */
1659 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1664 Elf_Internal_Rela outrel
;
1667 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
1668 BFD_ASSERT (srelgot
!= NULL
);
1670 outrel
.r_offset
= (sgot
->output_section
->vma
1671 + sgot
->output_offset
1673 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1674 loc
= srelgot
->contents
;
1675 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rel
);
1676 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
1679 local_got_offsets
[r_symndx
] |= 1;
1682 value
= sgot
->output_offset
+ off
;
1685 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1686 contents
, rel
->r_offset
, value
,
1690 /* Relocation is to the entry for this symbol in the
1691 procedure linkage table. */
1693 /* Resolve a PLT32 reloc against a local symbol directly,
1694 without using the procedure linkage table. */
1696 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1697 contents
, rel
->r_offset
, value
,
1700 if (h
->plt
.offset
== (bfd_vma
) -1)
1701 /* We didn't make a PLT entry for this symbol. This
1702 happens when statically linking PIC code, or when
1703 using -Bsymbolic. */
1704 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1705 contents
, rel
->r_offset
, value
,
1708 BFD_ASSERT(splt
!= NULL
);
1710 return bfd_reloc_notsupported
;
1712 value
= (splt
->output_section
->vma
1713 + splt
->output_offset
1715 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1716 contents
, rel
->r_offset
, value
,
1720 return bfd_reloc_notsupported
;
1722 case R_ARM_AMP_VCALL9
:
1723 return bfd_reloc_notsupported
;
1725 case R_ARM_RSBREL32
:
1726 return bfd_reloc_notsupported
;
1728 case R_ARM_THM_RPC22
:
1729 return bfd_reloc_notsupported
;
1732 return bfd_reloc_notsupported
;
1735 return bfd_reloc_notsupported
;
1738 return bfd_reloc_notsupported
;
1741 return bfd_reloc_notsupported
;
1744 return bfd_reloc_notsupported
;
1749 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
1751 arm_add_to_rel (abfd
, address
, howto
, increment
)
1754 reloc_howto_type
* howto
;
1755 bfd_signed_vma increment
;
1757 bfd_signed_vma addend
;
1759 if (howto
->type
== R_ARM_THM_PC22
)
1761 int upper_insn
, lower_insn
;
1764 upper_insn
= bfd_get_16 (abfd
, address
);
1765 lower_insn
= bfd_get_16 (abfd
, address
+ 2);
1766 upper
= upper_insn
& 0x7ff;
1767 lower
= lower_insn
& 0x7ff;
1769 addend
= (upper
<< 12) | (lower
<< 1);
1770 addend
+= increment
;
1773 upper_insn
= (upper_insn
& 0xf800) | ((addend
>> 11) & 0x7ff);
1774 lower_insn
= (lower_insn
& 0xf800) | (addend
& 0x7ff);
1776 bfd_put_16 (abfd
, (bfd_vma
) upper_insn
, address
);
1777 bfd_put_16 (abfd
, (bfd_vma
) lower_insn
, address
+ 2);
1783 contents
= bfd_get_32 (abfd
, address
);
1785 /* Get the (signed) value from the instruction. */
1786 addend
= contents
& howto
->src_mask
;
1787 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1789 bfd_signed_vma mask
;
1792 mask
&= ~ howto
->src_mask
;
1796 /* Add in the increment, (which is a byte value). */
1797 switch (howto
->type
)
1800 addend
+= increment
;
1804 addend
<<= howto
->size
;
1805 addend
+= increment
;
1807 /* Should we check for overflow here ? */
1809 /* Drop any undesired bits. */
1810 addend
>>= howto
->rightshift
;
1814 contents
= (contents
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
1816 bfd_put_32 (abfd
, contents
, address
);
1819 #endif /* USE_REL */
1821 /* Relocate an ARM ELF section. */
1823 elf32_arm_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1824 contents
, relocs
, local_syms
, local_sections
)
1826 struct bfd_link_info
*info
;
1828 asection
*input_section
;
1830 Elf_Internal_Rela
*relocs
;
1831 Elf_Internal_Sym
*local_syms
;
1832 asection
**local_sections
;
1834 Elf_Internal_Shdr
*symtab_hdr
;
1835 struct elf_link_hash_entry
**sym_hashes
;
1836 Elf_Internal_Rela
*rel
;
1837 Elf_Internal_Rela
*relend
;
1841 if (info
->relocateable
)
1845 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1846 sym_hashes
= elf_sym_hashes (input_bfd
);
1849 relend
= relocs
+ input_section
->reloc_count
;
1850 for (; rel
< relend
; rel
++)
1853 reloc_howto_type
* howto
;
1854 unsigned long r_symndx
;
1855 Elf_Internal_Sym
* sym
;
1857 struct elf_link_hash_entry
* h
;
1859 bfd_reloc_status_type r
;
1862 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1863 r_type
= ELF32_R_TYPE (rel
->r_info
);
1865 if ( r_type
== R_ARM_GNU_VTENTRY
1866 || r_type
== R_ARM_GNU_VTINHERIT
)
1869 elf32_arm_info_to_howto (input_bfd
, & bfd_reloc
, rel
);
1870 howto
= bfd_reloc
.howto
;
1873 if (info
->relocateable
)
1875 /* This is a relocateable link. We don't have to change
1876 anything, unless the reloc is against a section symbol,
1877 in which case we have to adjust according to where the
1878 section symbol winds up in the output section. */
1879 if (r_symndx
< symtab_hdr
->sh_info
)
1881 sym
= local_syms
+ r_symndx
;
1882 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1884 sec
= local_sections
[r_symndx
];
1885 arm_add_to_rel (input_bfd
, contents
+ rel
->r_offset
,
1887 (bfd_signed_vma
) (sec
->output_offset
1896 /* This is a final link. */
1901 if (r_symndx
< symtab_hdr
->sh_info
)
1903 sym
= local_syms
+ r_symndx
;
1904 sec
= local_sections
[r_symndx
];
1906 relocation
= (sec
->output_section
->vma
1907 + sec
->output_offset
1909 if ((sec
->flags
& SEC_MERGE
)
1910 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1913 bfd_vma addend
, value
;
1915 if (howto
->rightshift
)
1917 (*_bfd_error_handler
)
1918 (_("%s(%s+0x%lx): %s relocation against SEC_MERGE section"),
1919 bfd_archive_filename (input_bfd
),
1920 bfd_get_section_name (input_bfd
, input_section
),
1921 (long) rel
->r_offset
, howto
->name
);
1925 value
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1927 /* Get the (signed) value from the instruction. */
1928 addend
= value
& howto
->src_mask
;
1929 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1931 bfd_signed_vma mask
;
1934 mask
&= ~ howto
->src_mask
;
1939 _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
)
1941 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
1942 value
= (value
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
1943 bfd_put_32 (input_bfd
, value
, contents
+ rel
->r_offset
);
1946 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, sec
, rel
);
1951 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1953 while ( h
->root
.type
== bfd_link_hash_indirect
1954 || h
->root
.type
== bfd_link_hash_warning
)
1955 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1957 if ( h
->root
.type
== bfd_link_hash_defined
1958 || h
->root
.type
== bfd_link_hash_defweak
)
1960 int relocation_needed
= 1;
1962 sec
= h
->root
.u
.def
.section
;
1964 /* In these cases, we don't need the relocation value.
1965 We check specially because in some obscure cases
1966 sec->output_section will be NULL. */
1971 case R_ARM_THM_PC22
:
1974 (!info
->symbolic
&& h
->dynindx
!= -1)
1975 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1977 && ((input_section
->flags
& SEC_ALLOC
) != 0
1978 /* DWARF will emit R_ARM_ABS32 relocations in its
1979 sections against symbols defined externally
1980 in shared libraries. We can't do anything
1982 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
1983 && (h
->elf_link_hash_flags
1984 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
1986 relocation_needed
= 0;
1990 relocation_needed
= 0;
1994 if (elf_hash_table(info
)->dynamic_sections_created
1996 || (!info
->symbolic
&& h
->dynindx
!= -1)
1997 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2000 relocation_needed
= 0;
2004 if (h
->plt
.offset
!= (bfd_vma
)-1)
2005 relocation_needed
= 0;
2009 if (sec
->output_section
== NULL
)
2011 (*_bfd_error_handler
)
2012 (_("%s: warning: unresolvable relocation %d against symbol `%s' from %s section"),
2013 bfd_archive_filename (input_bfd
),
2015 h
->root
.root
.string
,
2016 bfd_get_section_name (input_bfd
, input_section
));
2017 relocation_needed
= 0;
2021 if (relocation_needed
)
2022 relocation
= h
->root
.u
.def
.value
2023 + sec
->output_section
->vma
2024 + sec
->output_offset
;
2028 else if (h
->root
.type
== bfd_link_hash_undefweak
)
2030 else if (info
->shared
&& !info
->symbolic
2031 && !info
->no_undefined
2032 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
2036 if (!((*info
->callbacks
->undefined_symbol
)
2037 (info
, h
->root
.root
.string
, input_bfd
,
2038 input_section
, rel
->r_offset
,
2039 (!info
->shared
|| info
->no_undefined
2040 || ELF_ST_VISIBILITY (h
->other
)))))
2047 name
= h
->root
.root
.string
;
2050 name
= (bfd_elf_string_from_elf_section
2051 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2052 if (name
== NULL
|| *name
== '\0')
2053 name
= bfd_section_name (input_bfd
, sec
);
2056 r
= elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
2057 input_section
, contents
, rel
,
2058 relocation
, info
, sec
, name
,
2059 (h
? ELF_ST_TYPE (h
->type
) :
2060 ELF_ST_TYPE (sym
->st_info
)), h
);
2062 if (r
!= bfd_reloc_ok
)
2064 const char * msg
= (const char *) 0;
2068 case bfd_reloc_overflow
:
2069 /* If the overflowing reloc was to an undefined symbol,
2070 we have already printed one error message and there
2071 is no point complaining again. */
2073 h
->root
.type
!= bfd_link_hash_undefined
)
2074 && (!((*info
->callbacks
->reloc_overflow
)
2075 (info
, name
, howto
->name
, (bfd_vma
) 0,
2076 input_bfd
, input_section
, rel
->r_offset
))))
2080 case bfd_reloc_undefined
:
2081 if (!((*info
->callbacks
->undefined_symbol
)
2082 (info
, name
, input_bfd
, input_section
,
2083 rel
->r_offset
, TRUE
)))
2087 case bfd_reloc_outofrange
:
2088 msg
= _("internal error: out of range error");
2091 case bfd_reloc_notsupported
:
2092 msg
= _("internal error: unsupported relocation error");
2095 case bfd_reloc_dangerous
:
2096 msg
= _("internal error: dangerous error");
2100 msg
= _("internal error: unknown error");
2104 if (!((*info
->callbacks
->warning
)
2105 (info
, msg
, name
, input_bfd
, input_section
,
2116 /* Set the right machine number. */
2119 elf32_arm_object_p (abfd
)
2122 asection
* arm_arch_section
;
2124 arm_arch_section
= bfd_get_section_by_name (abfd
, ARM_NOTE_SECTION
);
2126 if (arm_arch_section
)
2129 unsigned long arm_mach
;
2131 if (! bfd_get_section_contents (abfd
, arm_arch_section
, buffer
,
2132 (file_ptr
) 0, sizeof buffer
))
2133 (*_bfd_error_handler
)
2134 (_("%s: warning: unable to retrieve %s section from %s"),
2135 ARM_NOTE_SECTION
, bfd_get_filename (abfd
));
2138 /* We have to extract the value this way to allow for a
2139 host whose endian-ness is different from the target. */
2140 arm_mach
= bfd_get_32 (abfd
, buffer
);
2141 bfd_default_set_arch_mach (abfd
, bfd_arch_arm
, arm_mach
);
2143 if (bfd_get_arch (abfd
) == bfd_arch_arm
)
2146 /* If the set failed for some reason, do not leave the architecture
2147 type as 0 (unknown), but issue a warning message and force it to
2148 be set to bfd_arch_arm. */
2149 (*_bfd_error_handler
)
2150 (_("%s: warning: unrecognized ARM machine number: %x"),
2151 bfd_get_filename (abfd
), arm_mach
);
2156 if (elf_elfheader (abfd
)->e_flags
& EF_ARM_MAVERICK_FLOAT
)
2157 bfd_default_set_arch_mach (abfd
, bfd_arch_arm
, bfd_mach_arm_ep9312
);
2163 /* Function to keep ARM specific flags in the ELF header. */
2165 elf32_arm_set_private_flags (abfd
, flags
)
2169 if (elf_flags_init (abfd
)
2170 && elf_elfheader (abfd
)->e_flags
!= flags
)
2172 if (EF_ARM_EABI_VERSION (flags
) == EF_ARM_EABI_UNKNOWN
)
2174 if (flags
& EF_ARM_INTERWORK
)
2175 (*_bfd_error_handler
) (_("\
2176 Warning: Not setting interworking flag of %s since it has already been specified as non-interworking"),
2177 bfd_archive_filename (abfd
));
2179 _bfd_error_handler (_("\
2180 Warning: Clearing the interworking flag of %s due to outside request"),
2181 bfd_archive_filename (abfd
));
2186 elf_elfheader (abfd
)->e_flags
= flags
;
2187 elf_flags_init (abfd
) = TRUE
;
2193 /* Copy backend specific data from one object module to another. */
2196 elf32_arm_copy_private_bfd_data (ibfd
, obfd
)
2203 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2204 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2207 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2208 out_flags
= elf_elfheader (obfd
)->e_flags
;
2210 if (elf_flags_init (obfd
)
2211 && EF_ARM_EABI_VERSION (out_flags
) == EF_ARM_EABI_UNKNOWN
2212 && in_flags
!= out_flags
)
2214 /* Cannot mix APCS26 and APCS32 code. */
2215 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2218 /* Cannot mix float APCS and non-float APCS code. */
2219 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2222 /* If the src and dest have different interworking flags
2223 then turn off the interworking bit. */
2224 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2226 if (out_flags
& EF_ARM_INTERWORK
)
2227 _bfd_error_handler (_("\
2228 Warning: Clearing the interworking flag of %s because non-interworking code in %s has been linked with it"),
2229 bfd_get_filename (obfd
),
2230 bfd_archive_filename (ibfd
));
2232 in_flags
&= ~EF_ARM_INTERWORK
;
2235 /* Likewise for PIC, though don't warn for this case. */
2236 if ((in_flags
& EF_ARM_PIC
) != (out_flags
& EF_ARM_PIC
))
2237 in_flags
&= ~EF_ARM_PIC
;
2240 elf_elfheader (obfd
)->e_flags
= in_flags
;
2241 elf_flags_init (obfd
) = TRUE
;
2246 /* Merge backend specific data from an object file to the output
2247 object file when linking. */
2250 elf32_arm_merge_private_bfd_data (ibfd
, obfd
)
2256 bfd_boolean flags_compatible
= TRUE
;
2257 bfd_boolean null_input_bfd
= TRUE
;
2260 /* Check if we have the same endianess. */
2261 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
2264 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2265 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2268 /* The input BFD must have had its flags initialised. */
2269 /* The following seems bogus to me -- The flags are initialized in
2270 the assembler but I don't think an elf_flags_init field is
2271 written into the object. */
2272 /* BFD_ASSERT (elf_flags_init (ibfd)); */
2274 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2275 out_flags
= elf_elfheader (obfd
)->e_flags
;
2277 if (!elf_flags_init (obfd
))
2279 /* If the input is the default architecture and had the default
2280 flags then do not bother setting the flags for the output
2281 architecture, instead allow future merges to do this. If no
2282 future merges ever set these flags then they will retain their
2283 uninitialised values, which surprise surprise, correspond
2284 to the default values. */
2285 if (bfd_get_arch_info (ibfd
)->the_default
2286 && elf_elfheader (ibfd
)->e_flags
== 0)
2289 elf_flags_init (obfd
) = TRUE
;
2290 elf_elfheader (obfd
)->e_flags
= in_flags
;
2292 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
2293 && bfd_get_arch_info (obfd
)->the_default
)
2294 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
), bfd_get_mach (ibfd
));
2299 if (bfd_get_mach (obfd
) && bfd_get_mach (obfd
) != bfd_get_mach (ibfd
))
2301 /* For now, allow an output file type of 'xscale' if the
2302 input file type is 'iWMMXt'. This means that we will
2303 not have to build an entire iWMMXt enabled set of libraries
2304 just to test a iWMMXt enabled binary. Change the output
2305 type to iWMMXt though. Similarly allow 'xscale' binaries
2306 to be linked into a 'iWMMXt' output binary. */
2307 if ( bfd_get_mach (obfd
) == bfd_mach_arm_XScale
2308 && bfd_get_mach (ibfd
) == bfd_mach_arm_iWMMXt
)
2309 bfd_set_arch_mach (obfd
, bfd_get_arch (obfd
), bfd_mach_arm_iWMMXt
);
2310 else if ( bfd_get_mach (ibfd
) != bfd_mach_arm_XScale
2311 || bfd_get_mach (obfd
) != bfd_mach_arm_iWMMXt
)
2313 bfd_set_error (bfd_error_wrong_format
);
2318 /* Identical flags must be compatible. */
2319 if (in_flags
== out_flags
)
2322 /* Check to see if the input BFD actually contains any sections.
2323 If not, its flags may not have been initialised either, but it cannot
2324 actually cause any incompatibility. */
2325 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2327 /* Ignore synthetic glue sections. */
2328 if (strcmp (sec
->name
, ".glue_7")
2329 && strcmp (sec
->name
, ".glue_7t"))
2331 null_input_bfd
= FALSE
;
2338 /* Complain about various flag mismatches. */
2339 if (EF_ARM_EABI_VERSION (in_flags
) != EF_ARM_EABI_VERSION (out_flags
))
2341 _bfd_error_handler (_("\
2342 ERROR: %s is compiled for EABI version %d, whereas %s is compiled for version %d"),
2343 bfd_archive_filename (ibfd
),
2344 (in_flags
& EF_ARM_EABIMASK
) >> 24,
2345 bfd_get_filename (obfd
),
2346 (out_flags
& EF_ARM_EABIMASK
) >> 24);
2350 /* Not sure what needs to be checked for EABI versions >= 1. */
2351 if (EF_ARM_EABI_VERSION (in_flags
) == EF_ARM_EABI_UNKNOWN
)
2353 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2355 _bfd_error_handler (_("\
2356 ERROR: %s is compiled for APCS-%d, whereas target %s uses APCS-%d"),
2357 bfd_archive_filename (ibfd
),
2358 in_flags
& EF_ARM_APCS_26
? 26 : 32,
2359 bfd_get_filename (obfd
),
2360 out_flags
& EF_ARM_APCS_26
? 26 : 32);
2361 flags_compatible
= FALSE
;
2364 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2366 if (in_flags
& EF_ARM_APCS_FLOAT
)
2367 _bfd_error_handler (_("\
2368 ERROR: %s passes floats in float registers, whereas %s passes them in integer registers"),
2369 bfd_archive_filename (ibfd
),
2370 bfd_get_filename (obfd
));
2372 _bfd_error_handler (_("\
2373 ERROR: %s passes floats in integer registers, whereas %s passes them in float registers"),
2374 bfd_archive_filename (ibfd
),
2375 bfd_get_filename (obfd
));
2377 flags_compatible
= FALSE
;
2380 if ((in_flags
& EF_ARM_VFP_FLOAT
) != (out_flags
& EF_ARM_VFP_FLOAT
))
2382 if (in_flags
& EF_ARM_VFP_FLOAT
)
2383 _bfd_error_handler (_("\
2384 ERROR: %s uses VFP instructions, whereas %s does not"),
2385 bfd_archive_filename (ibfd
),
2386 bfd_get_filename (obfd
));
2388 _bfd_error_handler (_("\
2389 ERROR: %s uses FPA instructions, whereas %s does not"),
2390 bfd_archive_filename (ibfd
),
2391 bfd_get_filename (obfd
));
2393 flags_compatible
= FALSE
;
2396 if ((in_flags
& EF_ARM_MAVERICK_FLOAT
) != (out_flags
& EF_ARM_MAVERICK_FLOAT
))
2398 if (in_flags
& EF_ARM_MAVERICK_FLOAT
)
2399 _bfd_error_handler (_("\
2400 ERROR: %s uses Maverick instructions, whereas %s does not"),
2401 bfd_archive_filename (ibfd
),
2402 bfd_get_filename (obfd
));
2404 _bfd_error_handler (_("\
2405 ERROR: %s uses Maverick instructions, whereas %s does not"),
2406 bfd_archive_filename (ibfd
),
2407 bfd_get_filename (obfd
));
2409 flags_compatible
= FALSE
;
2412 #ifdef EF_ARM_SOFT_FLOAT
2413 if ((in_flags
& EF_ARM_SOFT_FLOAT
) != (out_flags
& EF_ARM_SOFT_FLOAT
))
2415 /* We can allow interworking between code that is VFP format
2416 layout, and uses either soft float or integer regs for
2417 passing floating point arguments and results. We already
2418 know that the APCS_FLOAT flags match; similarly for VFP
2420 if ((in_flags
& EF_ARM_APCS_FLOAT
) != 0
2421 || (in_flags
& EF_ARM_VFP_FLOAT
) == 0)
2423 if (in_flags
& EF_ARM_SOFT_FLOAT
)
2424 _bfd_error_handler (_("\
2425 ERROR: %s uses software FP, whereas %s uses hardware FP"),
2426 bfd_archive_filename (ibfd
),
2427 bfd_get_filename (obfd
));
2429 _bfd_error_handler (_("\
2430 ERROR: %s uses hardware FP, whereas %s uses software FP"),
2431 bfd_archive_filename (ibfd
),
2432 bfd_get_filename (obfd
));
2434 flags_compatible
= FALSE
;
2439 /* Interworking mismatch is only a warning. */
2440 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2442 if (in_flags
& EF_ARM_INTERWORK
)
2444 _bfd_error_handler (_("\
2445 Warning: %s supports interworking, whereas %s does not"),
2446 bfd_archive_filename (ibfd
),
2447 bfd_get_filename (obfd
));
2451 _bfd_error_handler (_("\
2452 Warning: %s does not support interworking, whereas %s does"),
2453 bfd_archive_filename (ibfd
),
2454 bfd_get_filename (obfd
));
2459 return flags_compatible
;
2462 /* Display the flags field. */
2465 elf32_arm_print_private_bfd_data (abfd
, ptr
)
2469 FILE * file
= (FILE *) ptr
;
2470 unsigned long flags
;
2472 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
2474 /* Print normal ELF private data. */
2475 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
2477 flags
= elf_elfheader (abfd
)->e_flags
;
2478 /* Ignore init flag - it may not be set, despite the flags field
2479 containing valid data. */
2481 /* xgettext:c-format */
2482 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
2484 switch (EF_ARM_EABI_VERSION (flags
))
2486 case EF_ARM_EABI_UNKNOWN
:
2487 /* The following flag bits are GNU extenstions and not part of the
2488 official ARM ELF extended ABI. Hence they are only decoded if
2489 the EABI version is not set. */
2490 if (flags
& EF_ARM_INTERWORK
)
2491 fprintf (file
, _(" [interworking enabled]"));
2493 if (flags
& EF_ARM_APCS_26
)
2494 fprintf (file
, " [APCS-26]");
2496 fprintf (file
, " [APCS-32]");
2498 if (flags
& EF_ARM_VFP_FLOAT
)
2499 fprintf (file
, _(" [VFP float format]"));
2500 else if (flags
& EF_ARM_MAVERICK_FLOAT
)
2501 fprintf (file
, _(" [Maverick float format]"));
2503 fprintf (file
, _(" [FPA float format]"));
2505 if (flags
& EF_ARM_APCS_FLOAT
)
2506 fprintf (file
, _(" [floats passed in float registers]"));
2508 if (flags
& EF_ARM_PIC
)
2509 fprintf (file
, _(" [position independent]"));
2511 if (flags
& EF_ARM_NEW_ABI
)
2512 fprintf (file
, _(" [new ABI]"));
2514 if (flags
& EF_ARM_OLD_ABI
)
2515 fprintf (file
, _(" [old ABI]"));
2517 if (flags
& EF_ARM_SOFT_FLOAT
)
2518 fprintf (file
, _(" [software FP]"));
2520 flags
&= ~(EF_ARM_INTERWORK
| EF_ARM_APCS_26
| EF_ARM_APCS_FLOAT
2521 | EF_ARM_PIC
| EF_ARM_NEW_ABI
| EF_ARM_OLD_ABI
2522 | EF_ARM_SOFT_FLOAT
| EF_ARM_VFP_FLOAT
2523 | EF_ARM_MAVERICK_FLOAT
);
2526 case EF_ARM_EABI_VER1
:
2527 fprintf (file
, _(" [Version1 EABI]"));
2529 if (flags
& EF_ARM_SYMSARESORTED
)
2530 fprintf (file
, _(" [sorted symbol table]"));
2532 fprintf (file
, _(" [unsorted symbol table]"));
2534 flags
&= ~ EF_ARM_SYMSARESORTED
;
2537 case EF_ARM_EABI_VER2
:
2538 fprintf (file
, _(" [Version2 EABI]"));
2540 if (flags
& EF_ARM_SYMSARESORTED
)
2541 fprintf (file
, _(" [sorted symbol table]"));
2543 fprintf (file
, _(" [unsorted symbol table]"));
2545 if (flags
& EF_ARM_DYNSYMSUSESEGIDX
)
2546 fprintf (file
, _(" [dynamic symbols use segment index]"));
2548 if (flags
& EF_ARM_MAPSYMSFIRST
)
2549 fprintf (file
, _(" [mapping symbols precede others]"));
2551 flags
&= ~(EF_ARM_SYMSARESORTED
| EF_ARM_DYNSYMSUSESEGIDX
2552 | EF_ARM_MAPSYMSFIRST
);
2556 fprintf (file
, _(" <EABI version unrecognised>"));
2560 flags
&= ~ EF_ARM_EABIMASK
;
2562 if (flags
& EF_ARM_RELEXEC
)
2563 fprintf (file
, _(" [relocatable executable]"));
2565 if (flags
& EF_ARM_HASENTRY
)
2566 fprintf (file
, _(" [has entry point]"));
2568 flags
&= ~ (EF_ARM_RELEXEC
| EF_ARM_HASENTRY
);
2571 fprintf (file
, _("<Unrecognised flag bits set>"));
2579 elf32_arm_get_symbol_type (elf_sym
, type
)
2580 Elf_Internal_Sym
* elf_sym
;
2583 switch (ELF_ST_TYPE (elf_sym
->st_info
))
2586 return ELF_ST_TYPE (elf_sym
->st_info
);
2589 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2590 This allows us to distinguish between data used by Thumb instructions
2591 and non-data (which is probably code) inside Thumb regions of an
2593 if (type
!= STT_OBJECT
)
2594 return ELF_ST_TYPE (elf_sym
->st_info
);
2605 elf32_arm_gc_mark_hook (sec
, info
, rel
, h
, sym
)
2607 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2608 Elf_Internal_Rela
*rel
;
2609 struct elf_link_hash_entry
*h
;
2610 Elf_Internal_Sym
*sym
;
2614 switch (ELF32_R_TYPE (rel
->r_info
))
2616 case R_ARM_GNU_VTINHERIT
:
2617 case R_ARM_GNU_VTENTRY
:
2621 switch (h
->root
.type
)
2623 case bfd_link_hash_defined
:
2624 case bfd_link_hash_defweak
:
2625 return h
->root
.u
.def
.section
;
2627 case bfd_link_hash_common
:
2628 return h
->root
.u
.c
.p
->section
;
2636 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
2641 /* Update the got entry reference counts for the section being removed. */
2644 elf32_arm_gc_sweep_hook (abfd
, info
, sec
, relocs
)
2645 bfd
*abfd ATTRIBUTE_UNUSED
;
2646 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2647 asection
*sec ATTRIBUTE_UNUSED
;
2648 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
;
2650 /* We don't support garbage collection of GOT and PLT relocs yet. */
2654 /* Look through the relocs for a section during the first phase. */
2657 elf32_arm_check_relocs (abfd
, info
, sec
, relocs
)
2659 struct bfd_link_info
*info
;
2661 const Elf_Internal_Rela
*relocs
;
2663 Elf_Internal_Shdr
*symtab_hdr
;
2664 struct elf_link_hash_entry
**sym_hashes
;
2665 struct elf_link_hash_entry
**sym_hashes_end
;
2666 const Elf_Internal_Rela
*rel
;
2667 const Elf_Internal_Rela
*rel_end
;
2669 asection
*sgot
, *srelgot
, *sreloc
;
2670 bfd_vma
*local_got_offsets
;
2672 if (info
->relocateable
)
2675 sgot
= srelgot
= sreloc
= NULL
;
2677 dynobj
= elf_hash_table (info
)->dynobj
;
2678 local_got_offsets
= elf_local_got_offsets (abfd
);
2680 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2681 sym_hashes
= elf_sym_hashes (abfd
);
2682 sym_hashes_end
= sym_hashes
2683 + symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
2685 if (!elf_bad_symtab (abfd
))
2686 sym_hashes_end
-= symtab_hdr
->sh_info
;
2688 rel_end
= relocs
+ sec
->reloc_count
;
2689 for (rel
= relocs
; rel
< rel_end
; rel
++)
2691 struct elf_link_hash_entry
*h
;
2692 unsigned long r_symndx
;
2694 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2695 if (r_symndx
< symtab_hdr
->sh_info
)
2698 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2700 /* Some relocs require a global offset table. */
2703 switch (ELF32_R_TYPE (rel
->r_info
))
2708 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
2709 if (! _bfd_elf_create_got_section (dynobj
, info
))
2718 switch (ELF32_R_TYPE (rel
->r_info
))
2721 /* This symbol requires a global offset table entry. */
2724 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2725 BFD_ASSERT (sgot
!= NULL
);
2728 /* Get the got relocation section if necessary. */
2730 && (h
!= NULL
|| info
->shared
))
2732 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
2734 /* If no got relocation section, make one and initialize. */
2735 if (srelgot
== NULL
)
2737 srelgot
= bfd_make_section (dynobj
, ".rel.got");
2739 || ! bfd_set_section_flags (dynobj
, srelgot
,
2744 | SEC_LINKER_CREATED
2746 || ! bfd_set_section_alignment (dynobj
, srelgot
, 2))
2753 if (h
->got
.offset
!= (bfd_vma
) -1)
2754 /* We have already allocated space in the .got. */
2757 h
->got
.offset
= sgot
->_raw_size
;
2759 /* Make sure this symbol is output as a dynamic symbol. */
2760 if (h
->dynindx
== -1)
2761 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2764 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2768 /* This is a global offset table entry for a local
2770 if (local_got_offsets
== NULL
)
2775 size
= symtab_hdr
->sh_info
;
2776 size
*= sizeof (bfd_vma
);
2777 local_got_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
2778 if (local_got_offsets
== NULL
)
2780 elf_local_got_offsets (abfd
) = local_got_offsets
;
2781 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
2782 local_got_offsets
[i
] = (bfd_vma
) -1;
2785 if (local_got_offsets
[r_symndx
] != (bfd_vma
) -1)
2786 /* We have already allocated space in the .got. */
2789 local_got_offsets
[r_symndx
] = sgot
->_raw_size
;
2792 /* If we are generating a shared object, we need to
2793 output a R_ARM_RELATIVE reloc so that the dynamic
2794 linker can adjust this GOT entry. */
2795 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2798 sgot
->_raw_size
+= 4;
2802 /* This symbol requires a procedure linkage table entry. We
2803 actually build the entry in adjust_dynamic_symbol,
2804 because this might be a case of linking PIC code which is
2805 never referenced by a dynamic object, in which case we
2806 don't need to generate a procedure linkage table entry
2809 /* If this is a local symbol, we resolve it directly without
2810 creating a procedure linkage table entry. */
2814 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2820 /* If we are creating a shared library, and this is a reloc
2821 against a global symbol, or a non PC relative reloc
2822 against a local symbol, then we need to copy the reloc
2823 into the shared library. However, if we are linking with
2824 -Bsymbolic, we do not need to copy a reloc against a
2825 global symbol which is defined in an object we are
2826 including in the link (i.e., DEF_REGULAR is set). At
2827 this point we have not seen all the input files, so it is
2828 possible that DEF_REGULAR is not set now but will be set
2829 later (it is never cleared). We account for that
2830 possibility below by storing information in the
2831 pcrel_relocs_copied field of the hash table entry. */
2833 && (ELF32_R_TYPE (rel
->r_info
) != R_ARM_PC24
2835 && (! info
->symbolic
2836 || (h
->elf_link_hash_flags
2837 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
2839 /* When creating a shared object, we must copy these
2840 reloc types into the output file. We create a reloc
2841 section in dynobj and make room for this reloc. */
2846 name
= (bfd_elf_string_from_elf_section
2848 elf_elfheader (abfd
)->e_shstrndx
,
2849 elf_section_data (sec
)->rel_hdr
.sh_name
));
2853 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
2854 && strcmp (bfd_get_section_name (abfd
, sec
),
2857 sreloc
= bfd_get_section_by_name (dynobj
, name
);
2862 sreloc
= bfd_make_section (dynobj
, name
);
2863 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
2864 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
2865 if ((sec
->flags
& SEC_ALLOC
) != 0)
2866 flags
|= SEC_ALLOC
| SEC_LOAD
;
2868 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
2869 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
2872 if (sec
->flags
& SEC_READONLY
)
2873 info
->flags
|= DF_TEXTREL
;
2876 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
2877 /* If we are linking with -Bsymbolic, and this is a
2878 global symbol, we count the number of PC relative
2879 relocations we have entered for this symbol, so that
2880 we can discard them again if the symbol is later
2881 defined by a regular object. Note that this function
2882 is only called if we are using an elf_i386 linker
2883 hash table, which means that h is really a pointer to
2884 an elf_i386_link_hash_entry. */
2885 if (h
!= NULL
&& info
->symbolic
2886 && ELF32_R_TYPE (rel
->r_info
) == R_ARM_PC24
)
2888 struct elf32_arm_link_hash_entry
* eh
;
2889 struct elf32_arm_pcrel_relocs_copied
* p
;
2891 eh
= (struct elf32_arm_link_hash_entry
*) h
;
2893 for (p
= eh
->pcrel_relocs_copied
; p
!= NULL
; p
= p
->next
)
2894 if (p
->section
== sreloc
)
2899 p
= ((struct elf32_arm_pcrel_relocs_copied
*)
2900 bfd_alloc (dynobj
, (bfd_size_type
) sizeof * p
));
2903 p
->next
= eh
->pcrel_relocs_copied
;
2904 eh
->pcrel_relocs_copied
= p
;
2905 p
->section
= sreloc
;
2914 /* This relocation describes the C++ object vtable hierarchy.
2915 Reconstruct it for later use during GC. */
2916 case R_ARM_GNU_VTINHERIT
:
2917 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2921 /* This relocation describes which C++ vtable entries are actually
2922 used. Record for later use during GC. */
2923 case R_ARM_GNU_VTENTRY
:
2924 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
2933 /* Find the nearest line to a particular section and offset, for error
2934 reporting. This code is a duplicate of the code in elf.c, except
2935 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
2938 elf32_arm_find_nearest_line
2939 (abfd
, section
, symbols
, offset
, filename_ptr
, functionname_ptr
, line_ptr
)
2944 const char **filename_ptr
;
2945 const char **functionname_ptr
;
2946 unsigned int *line_ptr
;
2949 const char *filename
;
2954 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
2955 filename_ptr
, functionname_ptr
,
2957 &elf_tdata (abfd
)->dwarf2_find_line_info
))
2960 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2961 &found
, filename_ptr
,
2962 functionname_ptr
, line_ptr
,
2963 &elf_tdata (abfd
)->line_info
))
2969 if (symbols
== NULL
)
2976 for (p
= symbols
; *p
!= NULL
; p
++)
2980 q
= (elf_symbol_type
*) *p
;
2982 if (bfd_get_section (&q
->symbol
) != section
)
2985 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
2990 filename
= bfd_asymbol_name (&q
->symbol
);
2995 if (q
->symbol
.section
== section
2996 && q
->symbol
.value
>= low_func
2997 && q
->symbol
.value
<= offset
)
2999 func
= (asymbol
*) q
;
3000 low_func
= q
->symbol
.value
;
3009 *filename_ptr
= filename
;
3010 *functionname_ptr
= bfd_asymbol_name (func
);
3016 /* Adjust a symbol defined by a dynamic object and referenced by a
3017 regular object. The current definition is in some section of the
3018 dynamic object, but we're not including those sections. We have to
3019 change the definition to something the rest of the link can
3023 elf32_arm_adjust_dynamic_symbol (info
, h
)
3024 struct bfd_link_info
* info
;
3025 struct elf_link_hash_entry
* h
;
3029 unsigned int power_of_two
;
3031 dynobj
= elf_hash_table (info
)->dynobj
;
3033 /* Make sure we know what is going on here. */
3034 BFD_ASSERT (dynobj
!= NULL
3035 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
3036 || h
->weakdef
!= NULL
3037 || ((h
->elf_link_hash_flags
3038 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
3039 && (h
->elf_link_hash_flags
3040 & ELF_LINK_HASH_REF_REGULAR
) != 0
3041 && (h
->elf_link_hash_flags
3042 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
3044 /* If this is a function, put it in the procedure linkage table. We
3045 will fill in the contents of the procedure linkage table later,
3046 when we know the address of the .got section. */
3047 if (h
->type
== STT_FUNC
3048 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
3050 /* If we link a program (not a DSO), we'll get rid of unnecessary
3051 PLT entries; we point to the actual symbols -- even for pic
3052 relocs, because a program built with -fpic should have the same
3053 result as one built without -fpic, specifically considering weak
3055 FIXME: m68k and i386 differ here, for unclear reasons. */
3057 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0)
3059 /* This case can occur if we saw a PLT32 reloc in an input
3060 file, but the symbol was not defined by a dynamic object.
3061 In such a case, we don't actually need to build a
3062 procedure linkage table, and we can just do a PC32 reloc
3064 BFD_ASSERT ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0);
3065 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
3069 /* Make sure this symbol is output as a dynamic symbol. */
3070 if (h
->dynindx
== -1)
3072 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
3076 s
= bfd_get_section_by_name (dynobj
, ".plt");
3077 BFD_ASSERT (s
!= NULL
);
3079 /* If this is the first .plt entry, make room for the special
3081 if (s
->_raw_size
== 0)
3082 s
->_raw_size
+= PLT_ENTRY_SIZE
;
3084 /* If this symbol is not defined in a regular file, and we are
3085 not generating a shared library, then set the symbol to this
3086 location in the .plt. This is required to make function
3087 pointers compare as equal between the normal executable and
3088 the shared library. */
3090 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3092 h
->root
.u
.def
.section
= s
;
3093 h
->root
.u
.def
.value
= s
->_raw_size
;
3096 h
->plt
.offset
= s
->_raw_size
;
3098 /* Make room for this entry. */
3099 s
->_raw_size
+= PLT_ENTRY_SIZE
;
3101 /* We also need to make an entry in the .got.plt section, which
3102 will be placed in the .got section by the linker script. */
3103 s
= bfd_get_section_by_name (dynobj
, ".got.plt");
3104 BFD_ASSERT (s
!= NULL
);
3107 /* We also need to make an entry in the .rel.plt section. */
3109 s
= bfd_get_section_by_name (dynobj
, ".rel.plt");
3110 BFD_ASSERT (s
!= NULL
);
3111 s
->_raw_size
+= sizeof (Elf32_External_Rel
);
3116 /* If this is a weak symbol, and there is a real definition, the
3117 processor independent code will have arranged for us to see the
3118 real definition first, and we can just use the same value. */
3119 if (h
->weakdef
!= NULL
)
3121 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
3122 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
3123 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
3124 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
3128 /* This is a reference to a symbol defined by a dynamic object which
3129 is not a function. */
3131 /* If we are creating a shared library, we must presume that the
3132 only references to the symbol are via the global offset table.
3133 For such cases we need not do anything here; the relocations will
3134 be handled correctly by relocate_section. */
3138 /* We must allocate the symbol in our .dynbss section, which will
3139 become part of the .bss section of the executable. There will be
3140 an entry for this symbol in the .dynsym section. The dynamic
3141 object will contain position independent code, so all references
3142 from the dynamic object to this symbol will go through the global
3143 offset table. The dynamic linker will use the .dynsym entry to
3144 determine the address it must put in the global offset table, so
3145 both the dynamic object and the regular object will refer to the
3146 same memory location for the variable. */
3147 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
3148 BFD_ASSERT (s
!= NULL
);
3150 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
3151 copy the initial value out of the dynamic object and into the
3152 runtime process image. We need to remember the offset into the
3153 .rel.bss section we are going to use. */
3154 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
3158 srel
= bfd_get_section_by_name (dynobj
, ".rel.bss");
3159 BFD_ASSERT (srel
!= NULL
);
3160 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
3161 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
3164 /* We need to figure out the alignment required for this symbol. I
3165 have no idea how ELF linkers handle this. */
3166 power_of_two
= bfd_log2 (h
->size
);
3167 if (power_of_two
> 3)
3170 /* Apply the required alignment. */
3171 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
3172 (bfd_size_type
) (1 << power_of_two
));
3173 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
3175 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
3179 /* Define the symbol as being at this point in the section. */
3180 h
->root
.u
.def
.section
= s
;
3181 h
->root
.u
.def
.value
= s
->_raw_size
;
3183 /* Increment the section size to make room for the symbol. */
3184 s
->_raw_size
+= h
->size
;
3189 /* Set the sizes of the dynamic sections. */
3192 elf32_arm_size_dynamic_sections (output_bfd
, info
)
3193 bfd
* output_bfd ATTRIBUTE_UNUSED
;
3194 struct bfd_link_info
* info
;
3201 dynobj
= elf_hash_table (info
)->dynobj
;
3202 BFD_ASSERT (dynobj
!= NULL
);
3204 if (elf_hash_table (info
)->dynamic_sections_created
)
3206 /* Set the contents of the .interp section to the interpreter. */
3209 s
= bfd_get_section_by_name (dynobj
, ".interp");
3210 BFD_ASSERT (s
!= NULL
);
3211 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
3212 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
3217 /* We may have created entries in the .rel.got section.
3218 However, if we are not creating the dynamic sections, we will
3219 not actually use these entries. Reset the size of .rel.got,
3220 which will cause it to get stripped from the output file
3222 s
= bfd_get_section_by_name (dynobj
, ".rel.got");
3227 /* If this is a -Bsymbolic shared link, then we need to discard all
3228 PC relative relocs against symbols defined in a regular object.
3229 We allocated space for them in the check_relocs routine, but we
3230 will not fill them in in the relocate_section routine. */
3231 if (info
->shared
&& info
->symbolic
)
3232 elf32_arm_link_hash_traverse (elf32_arm_hash_table (info
),
3233 elf32_arm_discard_copies
,
3236 /* The check_relocs and adjust_dynamic_symbol entry points have
3237 determined the sizes of the various dynamic sections. Allocate
3241 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3246 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3249 /* It's OK to base decisions on the section name, because none
3250 of the dynobj section names depend upon the input files. */
3251 name
= bfd_get_section_name (dynobj
, s
);
3255 if (strcmp (name
, ".plt") == 0)
3257 if (s
->_raw_size
== 0)
3259 /* Strip this section if we don't need it; see the
3265 /* Remember whether there is a PLT. */
3269 else if (strncmp (name
, ".rel", 4) == 0)
3271 if (s
->_raw_size
== 0)
3273 /* If we don't need this section, strip it from the
3274 output file. This is mostly to handle .rel.bss and
3275 .rel.plt. We must create both sections in
3276 create_dynamic_sections, because they must be created
3277 before the linker maps input sections to output
3278 sections. The linker does that before
3279 adjust_dynamic_symbol is called, and it is that
3280 function which decides whether anything needs to go
3281 into these sections. */
3286 /* Remember whether there are any reloc sections other
3288 if (strcmp (name
, ".rel.plt") != 0)
3291 /* We use the reloc_count field as a counter if we need
3292 to copy relocs into the output file. */
3296 else if (strncmp (name
, ".got", 4) != 0)
3298 /* It's not one of our sections, so don't allocate space. */
3304 _bfd_strip_section_from_output (info
, s
);
3308 /* Allocate memory for the section contents. */
3309 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
3310 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
3314 if (elf_hash_table (info
)->dynamic_sections_created
)
3316 /* Add some entries to the .dynamic section. We fill in the
3317 values later, in elf32_arm_finish_dynamic_sections, but we
3318 must add the entries now so that we get the correct size for
3319 the .dynamic section. The DT_DEBUG entry is filled in by the
3320 dynamic linker and used by the debugger. */
3321 #define add_dynamic_entry(TAG, VAL) \
3322 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
3326 if (!add_dynamic_entry (DT_DEBUG
, 0))
3332 if ( !add_dynamic_entry (DT_PLTGOT
, 0)
3333 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
3334 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
3335 || !add_dynamic_entry (DT_JMPREL
, 0))
3341 if ( !add_dynamic_entry (DT_REL
, 0)
3342 || !add_dynamic_entry (DT_RELSZ
, 0)
3343 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
3347 if ((info
->flags
& DF_TEXTREL
) != 0)
3349 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3351 info
->flags
|= DF_TEXTREL
;
3354 #undef add_synamic_entry
3359 /* This function is called via elf32_arm_link_hash_traverse if we are
3360 creating a shared object with -Bsymbolic. It discards the space
3361 allocated to copy PC relative relocs against symbols which are
3362 defined in regular objects. We allocated space for them in the
3363 check_relocs routine, but we won't fill them in in the
3364 relocate_section routine. */
3367 elf32_arm_discard_copies (h
, ignore
)
3368 struct elf32_arm_link_hash_entry
* h
;
3369 PTR ignore ATTRIBUTE_UNUSED
;
3371 struct elf32_arm_pcrel_relocs_copied
* s
;
3373 if (h
->root
.root
.type
== bfd_link_hash_warning
)
3374 h
= (struct elf32_arm_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3376 /* We only discard relocs for symbols defined in a regular object. */
3377 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3380 for (s
= h
->pcrel_relocs_copied
; s
!= NULL
; s
= s
->next
)
3381 s
->section
->_raw_size
-= s
->count
* sizeof (Elf32_External_Rel
);
3386 /* Finish up dynamic symbol handling. We set the contents of various
3387 dynamic sections here. */
3390 elf32_arm_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
3392 struct bfd_link_info
* info
;
3393 struct elf_link_hash_entry
* h
;
3394 Elf_Internal_Sym
* sym
;
3398 dynobj
= elf_hash_table (info
)->dynobj
;
3400 if (h
->plt
.offset
!= (bfd_vma
) -1)
3407 Elf_Internal_Rela rel
;
3410 /* This symbol has an entry in the procedure linkage table. Set
3413 BFD_ASSERT (h
->dynindx
!= -1);
3415 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3416 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3417 srel
= bfd_get_section_by_name (dynobj
, ".rel.plt");
3418 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
3420 /* Get the index in the procedure linkage table which
3421 corresponds to this symbol. This is the index of this symbol
3422 in all the symbols for which we are making plt entries. The
3423 first entry in the procedure linkage table is reserved. */
3424 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
3426 /* Get the offset into the .got table of the entry that
3427 corresponds to this function. Each .got entry is 4 bytes.
3428 The first three are reserved. */
3429 got_offset
= (plt_index
+ 3) * 4;
3431 /* Fill in the entry in the procedure linkage table. */
3432 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[0],
3433 splt
->contents
+ h
->plt
.offset
+ 0);
3434 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[1],
3435 splt
->contents
+ h
->plt
.offset
+ 4);
3436 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[2],
3437 splt
->contents
+ h
->plt
.offset
+ 8);
3438 bfd_put_32 (output_bfd
,
3439 (sgot
->output_section
->vma
3440 + sgot
->output_offset
3442 - splt
->output_section
->vma
3443 - splt
->output_offset
3444 - h
->plt
.offset
- 12),
3445 splt
->contents
+ h
->plt
.offset
+ 12);
3447 /* Fill in the entry in the global offset table. */
3448 bfd_put_32 (output_bfd
,
3449 (splt
->output_section
->vma
3450 + splt
->output_offset
),
3451 sgot
->contents
+ got_offset
);
3453 /* Fill in the entry in the .rel.plt section. */
3454 rel
.r_offset
= (sgot
->output_section
->vma
3455 + sgot
->output_offset
3457 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_JUMP_SLOT
);
3458 loc
= srel
->contents
+ plt_index
* sizeof (Elf32_External_Rel
);
3459 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3461 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3463 /* Mark the symbol as undefined, rather than as defined in
3464 the .plt section. Leave the value alone. */
3465 sym
->st_shndx
= SHN_UNDEF
;
3466 /* If the symbol is weak, we do need to clear the value.
3467 Otherwise, the PLT entry would provide a definition for
3468 the symbol even if the symbol wasn't defined anywhere,
3469 and so the symbol would never be NULL. */
3470 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR_NONWEAK
)
3476 if (h
->got
.offset
!= (bfd_vma
) -1)
3480 Elf_Internal_Rela rel
;
3483 /* This symbol has an entry in the global offset table. Set it
3485 sgot
= bfd_get_section_by_name (dynobj
, ".got");
3486 srel
= bfd_get_section_by_name (dynobj
, ".rel.got");
3487 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
3489 rel
.r_offset
= (sgot
->output_section
->vma
3490 + sgot
->output_offset
3491 + (h
->got
.offset
&~ (bfd_vma
) 1));
3493 /* If this is a -Bsymbolic link, and the symbol is defined
3494 locally, we just want to emit a RELATIVE reloc. The entry in
3495 the global offset table will already have been initialized in
3496 the relocate_section function. */
3498 && (info
->symbolic
|| h
->dynindx
== -1)
3499 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
3500 rel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
3503 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
3504 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_GLOB_DAT
);
3507 loc
= srel
->contents
+ srel
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3508 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3511 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
3514 Elf_Internal_Rela rel
;
3517 /* This symbol needs a copy reloc. Set it up. */
3518 BFD_ASSERT (h
->dynindx
!= -1
3519 && (h
->root
.type
== bfd_link_hash_defined
3520 || h
->root
.type
== bfd_link_hash_defweak
));
3522 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
3524 BFD_ASSERT (s
!= NULL
);
3526 rel
.r_offset
= (h
->root
.u
.def
.value
3527 + h
->root
.u
.def
.section
->output_section
->vma
3528 + h
->root
.u
.def
.section
->output_offset
);
3529 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_COPY
);
3530 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3531 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3534 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3535 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3536 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
3537 sym
->st_shndx
= SHN_ABS
;
3542 /* Finish up the dynamic sections. */
3545 elf32_arm_finish_dynamic_sections (output_bfd
, info
)
3547 struct bfd_link_info
* info
;
3553 dynobj
= elf_hash_table (info
)->dynobj
;
3555 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3556 BFD_ASSERT (sgot
!= NULL
);
3557 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3559 if (elf_hash_table (info
)->dynamic_sections_created
)
3562 Elf32_External_Dyn
*dyncon
, *dynconend
;
3564 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3565 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3567 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3568 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
3570 for (; dyncon
< dynconend
; dyncon
++)
3572 Elf_Internal_Dyn dyn
;
3576 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3589 s
= bfd_get_section_by_name (output_bfd
, name
);
3590 BFD_ASSERT (s
!= NULL
);
3591 dyn
.d_un
.d_ptr
= s
->vma
;
3592 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3596 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3597 BFD_ASSERT (s
!= NULL
);
3598 if (s
->_cooked_size
!= 0)
3599 dyn
.d_un
.d_val
= s
->_cooked_size
;
3601 dyn
.d_un
.d_val
= s
->_raw_size
;
3602 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3606 /* My reading of the SVR4 ABI indicates that the
3607 procedure linkage table relocs (DT_JMPREL) should be
3608 included in the overall relocs (DT_REL). This is
3609 what Solaris does. However, UnixWare can not handle
3610 that case. Therefore, we override the DT_RELSZ entry
3611 here to make it not include the JMPREL relocs. Since
3612 the linker script arranges for .rel.plt to follow all
3613 other relocation sections, we don't have to worry
3614 about changing the DT_REL entry. */
3615 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3618 if (s
->_cooked_size
!= 0)
3619 dyn
.d_un
.d_val
-= s
->_cooked_size
;
3621 dyn
.d_un
.d_val
-= s
->_raw_size
;
3623 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3626 /* Set the bottom bit of DT_INIT/FINI if the
3627 corresponding function is Thumb. */
3629 name
= info
->init_function
;
3632 name
= info
->fini_function
;
3634 /* If it wasn't set by elf_bfd_final_link
3635 then there is nothing to ajdust. */
3636 if (dyn
.d_un
.d_val
!= 0)
3638 struct elf_link_hash_entry
* eh
;
3640 eh
= elf_link_hash_lookup (elf_hash_table (info
), name
,
3641 FALSE
, FALSE
, TRUE
);
3642 if (eh
!= (struct elf_link_hash_entry
*) NULL
3643 && ELF_ST_TYPE (eh
->type
) == STT_ARM_TFUNC
)
3645 dyn
.d_un
.d_val
|= 1;
3646 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3653 /* Fill in the first entry in the procedure linkage table. */
3654 if (splt
->_raw_size
> 0)
3656 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[0], splt
->contents
+ 0);
3657 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[1], splt
->contents
+ 4);
3658 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[2], splt
->contents
+ 8);
3659 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[3], splt
->contents
+ 12);
3662 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3663 really seem like the right value. */
3664 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
3667 /* Fill in the first three entries in the global offset table. */
3668 if (sgot
->_raw_size
> 0)
3671 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
3673 bfd_put_32 (output_bfd
,
3674 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3676 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
3677 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
3680 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
3686 elf32_arm_post_process_headers (abfd
, link_info
)
3688 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
;
3690 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
3692 i_ehdrp
= elf_elfheader (abfd
);
3694 i_ehdrp
->e_ident
[EI_OSABI
] = ARM_ELF_OS_ABI_VERSION
;
3695 i_ehdrp
->e_ident
[EI_ABIVERSION
] = ARM_ELF_ABI_VERSION
;
3698 static enum elf_reloc_type_class
3699 elf32_arm_reloc_type_class (rela
)
3700 const Elf_Internal_Rela
*rela
;
3702 switch ((int) ELF32_R_TYPE (rela
->r_info
))
3704 case R_ARM_RELATIVE
:
3705 return reloc_class_relative
;
3706 case R_ARM_JUMP_SLOT
:
3707 return reloc_class_plt
;
3709 return reloc_class_copy
;
3711 return reloc_class_normal
;
3715 static bfd_boolean elf32_arm_section_flags
PARAMS ((flagword
*, Elf_Internal_Shdr
*));
3716 static void elf32_arm_final_write_processing
PARAMS ((bfd
*, bfd_boolean
));
3718 /* Set the right machine number for an Arm ELF file. */
3721 elf32_arm_section_flags (flags
, hdr
)
3723 Elf_Internal_Shdr
*hdr
;
3725 if (hdr
->sh_type
== SHT_NOTE
)
3726 *flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_CONTENTS
;
3732 elf32_arm_final_write_processing (abfd
, linker
)
3734 bfd_boolean linker ATTRIBUTE_UNUSED
;
3736 asection
* arm_arch_section
;
3738 unsigned long arm_mach
;
3740 /* Look for a .note.arm.ident section. If one is present check
3741 the machine number encoded in it, and set it to the current
3742 machine number if it is different. This allows XScale and
3743 iWMMXt binaries to be merged and the resulting output to be set
3744 to iWMMXt, even if the first input file had an XScale .note. */
3746 arm_arch_section
= bfd_get_section_by_name (abfd
, ARM_NOTE_SECTION
);
3748 if (arm_arch_section
== NULL
)
3751 if (! bfd_get_section_contents (abfd
, arm_arch_section
, buffer
,
3752 (file_ptr
) 0, sizeof buffer
))
3753 /* If the ident section does not exist then just skip this check. */
3756 /* We have to extract the value this way to allow for a
3757 host whose endian-ness is different from the target. */
3758 arm_mach
= bfd_get_32 (abfd
, buffer
);
3760 if (arm_mach
== bfd_get_mach (abfd
))
3763 bfd_put_32 (abfd
, bfd_get_mach (abfd
), buffer
);
3765 if (! bfd_set_section_contents (abfd
, arm_arch_section
, buffer
,
3766 (file_ptr
) 0, sizeof buffer
))
3767 (*_bfd_error_handler
)
3768 (_("warning: unable to update contents of %s section in %s"),
3769 ARM_NOTE_SECTION
, bfd_get_filename (abfd
));
3774 #define ELF_ARCH bfd_arch_arm
3775 #define ELF_MACHINE_CODE EM_ARM
3776 #define ELF_MAXPAGESIZE 0x8000
3778 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
3779 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
3780 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
3781 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
3782 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
3783 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
3784 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
3786 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
3787 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
3788 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
3789 #define elf_backend_check_relocs elf32_arm_check_relocs
3790 #define elf_backend_relocate_section elf32_arm_relocate_section
3791 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
3792 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
3793 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
3794 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
3795 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
3796 #define elf_backend_post_process_headers elf32_arm_post_process_headers
3797 #define elf_backend_reloc_type_class elf32_arm_reloc_type_class
3798 #define elf_backend_object_p elf32_arm_object_p
3799 #define elf_backend_section_flags elf32_arm_section_flags
3800 #define elf_backend_final_write_processing elf32_arm_final_write_processing
3802 #define elf_backend_can_gc_sections 1
3803 #define elf_backend_plt_readonly 1
3804 #define elf_backend_want_got_plt 1
3805 #define elf_backend_want_plt_sym 0
3807 #define elf_backend_rela_normal 1
3810 #define elf_backend_got_header_size 12
3811 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
3813 #include "elf32-target.h"