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
934 ret_offset
= (s
->output_offset
936 - (input_section
->output_offset
940 tmp
= bfd_get_32 (input_bfd
, hit_data
941 - input_section
->vma
);
943 bfd_put_32 (output_bfd
,
944 (bfd_vma
) insert_thumb_branch (tmp
, ret_offset
),
945 hit_data
- input_section
->vma
);
950 /* Arm code calling a Thumb function. */
953 elf32_arm_to_thumb_stub (info
, name
, input_bfd
, output_bfd
, input_section
,
954 hit_data
, sym_sec
, offset
, addend
, val
)
955 struct bfd_link_info
* info
;
959 asection
* input_section
;
963 bfd_signed_vma addend
;
966 unsigned long int tmp
;
970 struct elf_link_hash_entry
* myh
;
971 struct elf32_arm_link_hash_table
* globals
;
973 myh
= find_arm_glue (info
, name
, input_bfd
);
977 globals
= elf32_arm_hash_table (info
);
979 BFD_ASSERT (globals
!= NULL
);
980 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
982 my_offset
= myh
->root
.u
.def
.value
;
983 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
984 ARM2THUMB_GLUE_SECTION_NAME
);
985 BFD_ASSERT (s
!= NULL
);
986 BFD_ASSERT (s
->contents
!= NULL
);
987 BFD_ASSERT (s
->output_section
!= NULL
);
989 if ((my_offset
& 0x01) == 0x01)
992 && sym_sec
->owner
!= NULL
993 && !INTERWORK_FLAG (sym_sec
->owner
))
995 (*_bfd_error_handler
)
996 (_("%s(%s): warning: interworking not enabled."),
997 bfd_archive_filename (sym_sec
->owner
), name
);
998 (*_bfd_error_handler
)
999 (_(" first occurrence: %s: arm call to thumb"),
1000 bfd_archive_filename (input_bfd
));
1004 myh
->root
.u
.def
.value
= my_offset
;
1006 bfd_put_32 (output_bfd
, (bfd_vma
) a2t1_ldr_insn
,
1007 s
->contents
+ my_offset
);
1009 bfd_put_32 (output_bfd
, (bfd_vma
) a2t2_bx_r12_insn
,
1010 s
->contents
+ my_offset
+ 4);
1012 /* It's a thumb address. Add the low order bit. */
1013 bfd_put_32 (output_bfd
, val
| a2t3_func_addr_insn
,
1014 s
->contents
+ my_offset
+ 8);
1017 BFD_ASSERT (my_offset
<= globals
->arm_glue_size
);
1019 tmp
= bfd_get_32 (input_bfd
, hit_data
);
1020 tmp
= tmp
& 0xFF000000;
1022 /* Somehow these are both 4 too far, so subtract 8. */
1023 ret_offset
= (s
->output_offset
1025 + s
->output_section
->vma
1026 - (input_section
->output_offset
1027 + input_section
->output_section
->vma
1031 tmp
= tmp
| ((ret_offset
>> 2) & 0x00FFFFFF);
1033 bfd_put_32 (output_bfd
, (bfd_vma
) tmp
, hit_data
- input_section
->vma
);
1038 /* Perform a relocation as part of a final link. */
1040 static bfd_reloc_status_type
1041 elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
1042 input_section
, contents
, rel
, value
,
1043 info
, sym_sec
, sym_name
, sym_flags
, h
)
1044 reloc_howto_type
* howto
;
1047 asection
* input_section
;
1048 bfd_byte
* contents
;
1049 Elf_Internal_Rela
* rel
;
1051 struct bfd_link_info
* info
;
1053 const char * sym_name
;
1055 struct elf_link_hash_entry
* h
;
1057 unsigned long r_type
= howto
->type
;
1058 unsigned long r_symndx
;
1059 bfd_byte
* hit_data
= contents
+ rel
->r_offset
;
1060 bfd
* dynobj
= NULL
;
1061 Elf_Internal_Shdr
* symtab_hdr
;
1062 struct elf_link_hash_entry
** sym_hashes
;
1063 bfd_vma
* local_got_offsets
;
1064 asection
* sgot
= NULL
;
1065 asection
* splt
= NULL
;
1066 asection
* sreloc
= NULL
;
1068 bfd_signed_vma signed_addend
;
1069 struct elf32_arm_link_hash_table
* globals
;
1071 /* If the start address has been set, then set the EF_ARM_HASENTRY
1072 flag. Setting this more than once is redundant, but the cost is
1073 not too high, and it keeps the code simple.
1075 The test is done here, rather than somewhere else, because the
1076 start address is only set just before the final link commences.
1078 Note - if the user deliberately sets a start address of 0, the
1079 flag will not be set. */
1080 if (bfd_get_start_address (output_bfd
) != 0)
1081 elf_elfheader (output_bfd
)->e_flags
|= EF_ARM_HASENTRY
;
1083 globals
= elf32_arm_hash_table (info
);
1085 dynobj
= elf_hash_table (info
)->dynobj
;
1088 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1089 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1091 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1092 sym_hashes
= elf_sym_hashes (input_bfd
);
1093 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1094 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1097 addend
= bfd_get_32 (input_bfd
, hit_data
) & howto
->src_mask
;
1099 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1102 signed_addend
&= ~ howto
->src_mask
;
1103 signed_addend
|= addend
;
1106 signed_addend
= addend
;
1108 addend
= signed_addend
= rel
->r_addend
;
1114 return bfd_reloc_ok
;
1122 /* When generating a shared object, these relocations are copied
1123 into the output file to be resolved at run time. */
1126 && (r_type
!= R_ARM_PC24
1129 && (! info
->symbolic
1130 || (h
->elf_link_hash_flags
1131 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1133 Elf_Internal_Rela outrel
;
1135 bfd_boolean skip
, relocate
;
1141 name
= (bfd_elf_string_from_elf_section
1143 elf_elfheader (input_bfd
)->e_shstrndx
,
1144 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1146 return bfd_reloc_notsupported
;
1148 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
1149 && strcmp (bfd_get_section_name (input_bfd
,
1153 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1154 BFD_ASSERT (sreloc
!= NULL
);
1161 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
1163 if (outrel
.r_offset
== (bfd_vma
) -1)
1165 else if (outrel
.r_offset
== (bfd_vma
) -2)
1166 skip
= TRUE
, relocate
= TRUE
;
1167 outrel
.r_offset
+= (input_section
->output_section
->vma
1168 + input_section
->output_offset
);
1171 memset (&outrel
, 0, sizeof outrel
);
1172 else if (r_type
== R_ARM_PC24
)
1174 BFD_ASSERT (h
!= NULL
&& h
->dynindx
!= -1);
1175 if ((input_section
->flags
& SEC_ALLOC
) == 0)
1177 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_PC24
);
1182 || ((info
->symbolic
|| h
->dynindx
== -1)
1183 && (h
->elf_link_hash_flags
1184 & ELF_LINK_HASH_DEF_REGULAR
) != 0))
1187 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1191 BFD_ASSERT (h
->dynindx
!= -1);
1192 if ((input_section
->flags
& SEC_ALLOC
) == 0)
1194 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_ABS32
);
1198 loc
= sreloc
->contents
;
1199 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
1200 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
1202 /* If this reloc is against an external symbol, we do not want to
1203 fiddle with the addend. Otherwise, we need to include the symbol
1204 value so that it becomes an addend for the dynamic reloc. */
1206 return bfd_reloc_ok
;
1208 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1209 contents
, rel
->r_offset
, value
,
1212 else switch (r_type
)
1215 case R_ARM_XPC25
: /* Arm BLX instruction. */
1217 case R_ARM_PC24
: /* Arm B/BL instruction */
1219 if (r_type
== R_ARM_XPC25
)
1221 /* Check for Arm calling Arm function. */
1222 /* FIXME: Should we translate the instruction into a BL
1223 instruction instead ? */
1224 if (sym_flags
!= STT_ARM_TFUNC
)
1225 (*_bfd_error_handler
) (_("\
1226 %s: Warning: Arm BLX instruction targets Arm function '%s'."),
1227 bfd_archive_filename (input_bfd
),
1228 h
? h
->root
.root
.string
: "(local)");
1233 /* Check for Arm calling Thumb function. */
1234 if (sym_flags
== STT_ARM_TFUNC
)
1236 elf32_arm_to_thumb_stub (info
, sym_name
, input_bfd
, output_bfd
,
1237 input_section
, hit_data
, sym_sec
, rel
->r_offset
,
1238 signed_addend
, value
);
1239 return bfd_reloc_ok
;
1243 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1244 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0)
1246 /* The old way of doing things. Trearing the addend as a
1247 byte sized field and adding in the pipeline offset. */
1248 value
-= (input_section
->output_section
->vma
1249 + input_section
->output_offset
);
1250 value
-= rel
->r_offset
;
1253 if (! globals
->no_pipeline_knowledge
)
1258 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
1260 S is the address of the symbol in the relocation.
1261 P is address of the instruction being relocated.
1262 A is the addend (extracted from the instruction) in bytes.
1264 S is held in 'value'.
1265 P is the base address of the section containing the instruction
1266 plus the offset of the reloc into that section, ie:
1267 (input_section->output_section->vma +
1268 input_section->output_offset +
1270 A is the addend, converted into bytes, ie:
1273 Note: None of these operations have knowledge of the pipeline
1274 size of the processor, thus it is up to the assembler to encode
1275 this information into the addend. */
1276 value
-= (input_section
->output_section
->vma
1277 + input_section
->output_offset
);
1278 value
-= rel
->r_offset
;
1279 value
+= (signed_addend
<< howto
->size
);
1281 /* Previous versions of this code also used to add in the pipeline
1282 offset here. This is wrong because the linker is not supposed
1283 to know about such things, and one day it might change. In order
1284 to support old binaries that need the old behaviour however, so
1285 we attempt to detect which ABI was used to create the reloc. */
1286 if (! globals
->no_pipeline_knowledge
)
1288 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form */
1290 i_ehdrp
= elf_elfheader (input_bfd
);
1292 if (i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1297 signed_addend
= value
;
1298 signed_addend
>>= howto
->rightshift
;
1300 /* It is not an error for an undefined weak reference to be
1301 out of range. Any program that branches to such a symbol
1302 is going to crash anyway, so there is no point worrying
1303 about getting the destination exactly right. */
1304 if (! h
|| h
->root
.type
!= bfd_link_hash_undefweak
)
1306 /* Perform a signed range check. */
1307 if ( signed_addend
> ((bfd_signed_vma
) (howto
->dst_mask
>> 1))
1308 || signed_addend
< - ((bfd_signed_vma
) ((howto
->dst_mask
+ 1) >> 1)))
1309 return bfd_reloc_overflow
;
1313 /* If necessary set the H bit in the BLX instruction. */
1314 if (r_type
== R_ARM_XPC25
&& ((value
& 2) == 2))
1315 value
= (signed_addend
& howto
->dst_mask
)
1316 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
))
1320 value
= (signed_addend
& howto
->dst_mask
)
1321 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1326 if (sym_flags
== STT_ARM_TFUNC
)
1331 value
-= (input_section
->output_section
->vma
1332 + input_section
->output_offset
+ rel
->r_offset
);
1337 bfd_put_32 (input_bfd
, value
, hit_data
);
1338 return bfd_reloc_ok
;
1342 if ((long) value
> 0x7f || (long) value
< -0x80)
1343 return bfd_reloc_overflow
;
1345 bfd_put_8 (input_bfd
, value
, hit_data
);
1346 return bfd_reloc_ok
;
1351 if ((long) value
> 0x7fff || (long) value
< -0x8000)
1352 return bfd_reloc_overflow
;
1354 bfd_put_16 (input_bfd
, value
, hit_data
);
1355 return bfd_reloc_ok
;
1358 /* Support ldr and str instruction for the arm */
1359 /* Also thumb b (unconditional branch). ??? Really? */
1362 if ((long) value
> 0x7ff || (long) value
< -0x800)
1363 return bfd_reloc_overflow
;
1365 value
|= (bfd_get_32 (input_bfd
, hit_data
) & 0xfffff000);
1366 bfd_put_32 (input_bfd
, value
, hit_data
);
1367 return bfd_reloc_ok
;
1369 case R_ARM_THM_ABS5
:
1370 /* Support ldr and str instructions for the thumb. */
1372 /* Need to refetch addend. */
1373 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1374 /* ??? Need to determine shift amount from operand size. */
1375 addend
>>= howto
->rightshift
;
1379 /* ??? Isn't value unsigned? */
1380 if ((long) value
> 0x1f || (long) value
< -0x10)
1381 return bfd_reloc_overflow
;
1383 /* ??? Value needs to be properly shifted into place first. */
1384 value
|= bfd_get_16 (input_bfd
, hit_data
) & 0xf83f;
1385 bfd_put_16 (input_bfd
, value
, hit_data
);
1386 return bfd_reloc_ok
;
1389 case R_ARM_THM_XPC22
:
1391 case R_ARM_THM_PC22
:
1392 /* Thumb BL (branch long instruction). */
1395 bfd_boolean overflow
= FALSE
;
1396 bfd_vma upper_insn
= bfd_get_16 (input_bfd
, hit_data
);
1397 bfd_vma lower_insn
= bfd_get_16 (input_bfd
, hit_data
+ 2);
1398 bfd_signed_vma reloc_signed_max
= ((1 << (howto
->bitsize
- 1)) - 1) >> howto
->rightshift
;
1399 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1401 bfd_signed_vma signed_check
;
1404 /* Need to refetch the addend and squish the two 11 bit pieces
1407 bfd_vma upper
= upper_insn
& 0x7ff;
1408 bfd_vma lower
= lower_insn
& 0x7ff;
1409 upper
= (upper
^ 0x400) - 0x400; /* Sign extend. */
1410 addend
= (upper
<< 12) | (lower
<< 1);
1411 signed_addend
= addend
;
1415 if (r_type
== R_ARM_THM_XPC22
)
1417 /* Check for Thumb to Thumb call. */
1418 /* FIXME: Should we translate the instruction into a BL
1419 instruction instead ? */
1420 if (sym_flags
== STT_ARM_TFUNC
)
1421 (*_bfd_error_handler
) (_("\
1422 %s: Warning: Thumb BLX instruction targets thumb function '%s'."),
1423 bfd_archive_filename (input_bfd
),
1424 h
? h
->root
.root
.string
: "(local)");
1429 /* If it is not a call to Thumb, assume call to Arm.
1430 If it is a call relative to a section name, then it is not a
1431 function call at all, but rather a long jump. */
1432 if (sym_flags
!= STT_ARM_TFUNC
&& sym_flags
!= STT_SECTION
)
1434 if (elf32_thumb_to_arm_stub
1435 (info
, sym_name
, input_bfd
, output_bfd
, input_section
,
1436 hit_data
, sym_sec
, rel
->r_offset
, signed_addend
, value
))
1437 return bfd_reloc_ok
;
1439 return bfd_reloc_dangerous
;
1443 relocation
= value
+ signed_addend
;
1445 relocation
-= (input_section
->output_section
->vma
1446 + input_section
->output_offset
1449 if (! globals
->no_pipeline_knowledge
)
1451 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form. */
1453 i_ehdrp
= elf_elfheader (input_bfd
);
1455 /* Previous versions of this code also used to add in the pipline
1456 offset here. This is wrong because the linker is not supposed
1457 to know about such things, and one day it might change. In order
1458 to support old binaries that need the old behaviour however, so
1459 we attempt to detect which ABI was used to create the reloc. */
1460 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1461 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0
1462 || i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1466 check
= relocation
>> howto
->rightshift
;
1468 /* If this is a signed value, the rightshift just dropped
1469 leading 1 bits (assuming twos complement). */
1470 if ((bfd_signed_vma
) relocation
>= 0)
1471 signed_check
= check
;
1473 signed_check
= check
| ~((bfd_vma
) -1 >> howto
->rightshift
);
1475 /* Assumes two's complement. */
1476 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1480 if (r_type
== R_ARM_THM_XPC22
1481 && ((lower_insn
& 0x1800) == 0x0800))
1482 /* For a BLX instruction, make sure that the relocation is rounded up
1483 to a word boundary. This follows the semantics of the instruction
1484 which specifies that bit 1 of the target address will come from bit
1485 1 of the base address. */
1486 relocation
= (relocation
+ 2) & ~ 3;
1488 /* Put RELOCATION back into the insn. */
1489 upper_insn
= (upper_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 12) & 0x7ff);
1490 lower_insn
= (lower_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 1) & 0x7ff);
1492 /* Put the relocated value back in the object file: */
1493 bfd_put_16 (input_bfd
, upper_insn
, hit_data
);
1494 bfd_put_16 (input_bfd
, lower_insn
, hit_data
+ 2);
1496 return (overflow
? bfd_reloc_overflow
: bfd_reloc_ok
);
1500 case R_ARM_THM_PC11
:
1501 /* Thumb B (branch) instruction). */
1503 bfd_signed_vma relocation
;
1504 bfd_signed_vma reloc_signed_max
= (1 << (howto
->bitsize
- 1)) - 1;
1505 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1506 bfd_signed_vma signed_check
;
1509 /* Need to refetch addend. */
1510 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1511 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1514 signed_addend
&= ~ howto
->src_mask
;
1515 signed_addend
|= addend
;
1518 signed_addend
= addend
;
1519 /* The value in the insn has been right shifted. We need to
1520 undo this, so that we can perform the address calculation
1521 in terms of bytes. */
1522 signed_addend
<<= howto
->rightshift
;
1524 relocation
= value
+ signed_addend
;
1526 relocation
-= (input_section
->output_section
->vma
1527 + input_section
->output_offset
1530 relocation
>>= howto
->rightshift
;
1531 signed_check
= relocation
;
1532 relocation
&= howto
->dst_mask
;
1533 relocation
|= (bfd_get_16 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1535 bfd_put_16 (input_bfd
, relocation
, hit_data
);
1537 /* Assumes two's complement. */
1538 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1539 return bfd_reloc_overflow
;
1541 return bfd_reloc_ok
;
1544 case R_ARM_GNU_VTINHERIT
:
1545 case R_ARM_GNU_VTENTRY
:
1546 return bfd_reloc_ok
;
1549 return bfd_reloc_notsupported
;
1551 case R_ARM_GLOB_DAT
:
1552 return bfd_reloc_notsupported
;
1554 case R_ARM_JUMP_SLOT
:
1555 return bfd_reloc_notsupported
;
1557 case R_ARM_RELATIVE
:
1558 return bfd_reloc_notsupported
;
1561 /* Relocation is relative to the start of the
1562 global offset table. */
1564 BFD_ASSERT (sgot
!= NULL
);
1566 return bfd_reloc_notsupported
;
1568 /* If we are addressing a Thumb function, we need to adjust the
1569 address by one, so that attempts to call the function pointer will
1570 correctly interpret it as Thumb code. */
1571 if (sym_flags
== STT_ARM_TFUNC
)
1574 /* Note that sgot->output_offset is not involved in this
1575 calculation. We always want the start of .got. If we
1576 define _GLOBAL_OFFSET_TABLE in a different way, as is
1577 permitted by the ABI, we might have to change this
1579 value
-= sgot
->output_section
->vma
;
1580 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1581 contents
, rel
->r_offset
, value
,
1585 /* Use global offset table as symbol value. */
1586 BFD_ASSERT (sgot
!= NULL
);
1589 return bfd_reloc_notsupported
;
1591 value
= sgot
->output_section
->vma
;
1592 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1593 contents
, rel
->r_offset
, value
,
1597 /* Relocation is to the entry for this symbol in the
1598 global offset table. */
1600 return bfd_reloc_notsupported
;
1606 off
= h
->got
.offset
;
1607 BFD_ASSERT (off
!= (bfd_vma
) -1);
1609 if (!elf_hash_table (info
)->dynamic_sections_created
||
1610 (info
->shared
&& (info
->symbolic
|| h
->dynindx
== -1)
1611 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1613 /* This is actually a static link, or it is a -Bsymbolic link
1614 and the symbol is defined locally. We must initialize this
1615 entry in the global offset table. Since the offset must
1616 always be a multiple of 4, we use the least significant bit
1617 to record whether we have initialized it already.
1619 When doing a dynamic link, we create a .rel.got relocation
1620 entry to initialize the value. This is done in the
1621 finish_dynamic_symbol routine. */
1626 /* If we are addressing a Thumb function, we need to
1627 adjust the address by one, so that attempts to
1628 call the function pointer will correctly
1629 interpret it as Thumb code. */
1630 if (sym_flags
== STT_ARM_TFUNC
)
1633 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1638 value
= sgot
->output_offset
+ off
;
1644 BFD_ASSERT (local_got_offsets
!= NULL
&&
1645 local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1647 off
= local_got_offsets
[r_symndx
];
1649 /* The offset must always be a multiple of 4. We use the
1650 least significant bit to record whether we have already
1651 generated the necessary reloc. */
1656 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1661 Elf_Internal_Rela outrel
;
1664 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
1665 BFD_ASSERT (srelgot
!= NULL
);
1667 outrel
.r_offset
= (sgot
->output_section
->vma
1668 + sgot
->output_offset
1670 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1671 loc
= srelgot
->contents
;
1672 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rel
);
1673 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
1676 local_got_offsets
[r_symndx
] |= 1;
1679 value
= sgot
->output_offset
+ off
;
1682 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1683 contents
, rel
->r_offset
, value
,
1687 /* Relocation is to the entry for this symbol in the
1688 procedure linkage table. */
1690 /* Resolve a PLT32 reloc against a local symbol directly,
1691 without using the procedure linkage table. */
1693 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1694 contents
, rel
->r_offset
, value
,
1697 if (h
->plt
.offset
== (bfd_vma
) -1)
1698 /* We didn't make a PLT entry for this symbol. This
1699 happens when statically linking PIC code, or when
1700 using -Bsymbolic. */
1701 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1702 contents
, rel
->r_offset
, value
,
1705 BFD_ASSERT(splt
!= NULL
);
1707 return bfd_reloc_notsupported
;
1709 value
= (splt
->output_section
->vma
1710 + splt
->output_offset
1712 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1713 contents
, rel
->r_offset
, value
,
1717 return bfd_reloc_notsupported
;
1719 case R_ARM_AMP_VCALL9
:
1720 return bfd_reloc_notsupported
;
1722 case R_ARM_RSBREL32
:
1723 return bfd_reloc_notsupported
;
1725 case R_ARM_THM_RPC22
:
1726 return bfd_reloc_notsupported
;
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
;
1746 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
1748 arm_add_to_rel (abfd
, address
, howto
, increment
)
1751 reloc_howto_type
* howto
;
1752 bfd_signed_vma increment
;
1754 bfd_signed_vma addend
;
1756 if (howto
->type
== R_ARM_THM_PC22
)
1758 int upper_insn
, lower_insn
;
1761 upper_insn
= bfd_get_16 (abfd
, address
);
1762 lower_insn
= bfd_get_16 (abfd
, address
+ 2);
1763 upper
= upper_insn
& 0x7ff;
1764 lower
= lower_insn
& 0x7ff;
1766 addend
= (upper
<< 12) | (lower
<< 1);
1767 addend
+= increment
;
1770 upper_insn
= (upper_insn
& 0xf800) | ((addend
>> 11) & 0x7ff);
1771 lower_insn
= (lower_insn
& 0xf800) | (addend
& 0x7ff);
1773 bfd_put_16 (abfd
, (bfd_vma
) upper_insn
, address
);
1774 bfd_put_16 (abfd
, (bfd_vma
) lower_insn
, address
+ 2);
1780 contents
= bfd_get_32 (abfd
, address
);
1782 /* Get the (signed) value from the instruction. */
1783 addend
= contents
& howto
->src_mask
;
1784 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1786 bfd_signed_vma mask
;
1789 mask
&= ~ howto
->src_mask
;
1793 /* Add in the increment, (which is a byte value). */
1794 switch (howto
->type
)
1797 addend
+= increment
;
1801 addend
<<= howto
->size
;
1802 addend
+= increment
;
1804 /* Should we check for overflow here ? */
1806 /* Drop any undesired bits. */
1807 addend
>>= howto
->rightshift
;
1811 contents
= (contents
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
1813 bfd_put_32 (abfd
, contents
, address
);
1816 #endif /* USE_REL */
1818 /* Relocate an ARM ELF section. */
1820 elf32_arm_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1821 contents
, relocs
, local_syms
, local_sections
)
1823 struct bfd_link_info
*info
;
1825 asection
*input_section
;
1827 Elf_Internal_Rela
*relocs
;
1828 Elf_Internal_Sym
*local_syms
;
1829 asection
**local_sections
;
1831 Elf_Internal_Shdr
*symtab_hdr
;
1832 struct elf_link_hash_entry
**sym_hashes
;
1833 Elf_Internal_Rela
*rel
;
1834 Elf_Internal_Rela
*relend
;
1838 if (info
->relocateable
)
1842 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1843 sym_hashes
= elf_sym_hashes (input_bfd
);
1846 relend
= relocs
+ input_section
->reloc_count
;
1847 for (; rel
< relend
; rel
++)
1850 reloc_howto_type
* howto
;
1851 unsigned long r_symndx
;
1852 Elf_Internal_Sym
* sym
;
1854 struct elf_link_hash_entry
* h
;
1856 bfd_reloc_status_type r
;
1859 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1860 r_type
= ELF32_R_TYPE (rel
->r_info
);
1862 if ( r_type
== R_ARM_GNU_VTENTRY
1863 || r_type
== R_ARM_GNU_VTINHERIT
)
1866 elf32_arm_info_to_howto (input_bfd
, & bfd_reloc
, rel
);
1867 howto
= bfd_reloc
.howto
;
1870 if (info
->relocateable
)
1872 /* This is a relocateable link. We don't have to change
1873 anything, unless the reloc is against a section symbol,
1874 in which case we have to adjust according to where the
1875 section symbol winds up in the output section. */
1876 if (r_symndx
< symtab_hdr
->sh_info
)
1878 sym
= local_syms
+ r_symndx
;
1879 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1881 sec
= local_sections
[r_symndx
];
1882 arm_add_to_rel (input_bfd
, contents
+ rel
->r_offset
,
1884 (bfd_signed_vma
) (sec
->output_offset
1893 /* This is a final link. */
1898 if (r_symndx
< symtab_hdr
->sh_info
)
1900 sym
= local_syms
+ r_symndx
;
1901 sec
= local_sections
[r_symndx
];
1903 relocation
= (sec
->output_section
->vma
1904 + sec
->output_offset
1906 if ((sec
->flags
& SEC_MERGE
)
1907 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1910 bfd_vma addend
, value
;
1912 if (howto
->rightshift
)
1914 (*_bfd_error_handler
)
1915 (_("%s(%s+0x%lx): %s relocation against SEC_MERGE section"),
1916 bfd_archive_filename (input_bfd
),
1917 bfd_get_section_name (input_bfd
, input_section
),
1918 (long) rel
->r_offset
, howto
->name
);
1922 value
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1924 /* Get the (signed) value from the instruction. */
1925 addend
= value
& howto
->src_mask
;
1926 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1928 bfd_signed_vma mask
;
1931 mask
&= ~ howto
->src_mask
;
1936 _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
)
1938 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
1939 value
= (value
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
1940 bfd_put_32 (input_bfd
, value
, contents
+ rel
->r_offset
);
1943 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, sec
, rel
);
1948 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1950 while ( h
->root
.type
== bfd_link_hash_indirect
1951 || h
->root
.type
== bfd_link_hash_warning
)
1952 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1954 if ( h
->root
.type
== bfd_link_hash_defined
1955 || h
->root
.type
== bfd_link_hash_defweak
)
1957 int relocation_needed
= 1;
1959 sec
= h
->root
.u
.def
.section
;
1961 /* In these cases, we don't need the relocation value.
1962 We check specially because in some obscure cases
1963 sec->output_section will be NULL. */
1968 case R_ARM_THM_PC22
:
1971 (!info
->symbolic
&& h
->dynindx
!= -1)
1972 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1974 && ((input_section
->flags
& SEC_ALLOC
) != 0
1975 /* DWARF will emit R_ARM_ABS32 relocations in its
1976 sections against symbols defined externally
1977 in shared libraries. We can't do anything
1979 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
1980 && (h
->elf_link_hash_flags
1981 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
1983 relocation_needed
= 0;
1987 relocation_needed
= 0;
1991 if (elf_hash_table(info
)->dynamic_sections_created
1993 || (!info
->symbolic
&& h
->dynindx
!= -1)
1994 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1997 relocation_needed
= 0;
2001 if (h
->plt
.offset
!= (bfd_vma
)-1)
2002 relocation_needed
= 0;
2006 if (sec
->output_section
== NULL
)
2008 (*_bfd_error_handler
)
2009 (_("%s: warning: unresolvable relocation %d against symbol `%s' from %s section"),
2010 bfd_archive_filename (input_bfd
),
2012 h
->root
.root
.string
,
2013 bfd_get_section_name (input_bfd
, input_section
));
2014 relocation_needed
= 0;
2018 if (relocation_needed
)
2019 relocation
= h
->root
.u
.def
.value
2020 + sec
->output_section
->vma
2021 + sec
->output_offset
;
2025 else if (h
->root
.type
== bfd_link_hash_undefweak
)
2027 else if (info
->shared
&& !info
->symbolic
2028 && !info
->no_undefined
2029 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
2033 if (!((*info
->callbacks
->undefined_symbol
)
2034 (info
, h
->root
.root
.string
, input_bfd
,
2035 input_section
, rel
->r_offset
,
2036 (!info
->shared
|| info
->no_undefined
2037 || ELF_ST_VISIBILITY (h
->other
)))))
2044 name
= h
->root
.root
.string
;
2047 name
= (bfd_elf_string_from_elf_section
2048 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2049 if (name
== NULL
|| *name
== '\0')
2050 name
= bfd_section_name (input_bfd
, sec
);
2053 r
= elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
2054 input_section
, contents
, rel
,
2055 relocation
, info
, sec
, name
,
2056 (h
? ELF_ST_TYPE (h
->type
) :
2057 ELF_ST_TYPE (sym
->st_info
)), h
);
2059 if (r
!= bfd_reloc_ok
)
2061 const char * msg
= (const char *) 0;
2065 case bfd_reloc_overflow
:
2066 /* If the overflowing reloc was to an undefined symbol,
2067 we have already printed one error message and there
2068 is no point complaining again. */
2070 h
->root
.type
!= bfd_link_hash_undefined
)
2071 && (!((*info
->callbacks
->reloc_overflow
)
2072 (info
, name
, howto
->name
, (bfd_vma
) 0,
2073 input_bfd
, input_section
, rel
->r_offset
))))
2077 case bfd_reloc_undefined
:
2078 if (!((*info
->callbacks
->undefined_symbol
)
2079 (info
, name
, input_bfd
, input_section
,
2080 rel
->r_offset
, TRUE
)))
2084 case bfd_reloc_outofrange
:
2085 msg
= _("internal error: out of range error");
2088 case bfd_reloc_notsupported
:
2089 msg
= _("internal error: unsupported relocation error");
2092 case bfd_reloc_dangerous
:
2093 msg
= _("internal error: dangerous error");
2097 msg
= _("internal error: unknown error");
2101 if (!((*info
->callbacks
->warning
)
2102 (info
, msg
, name
, input_bfd
, input_section
,
2113 /* Set the right machine number. */
2116 elf32_arm_object_p (abfd
)
2119 /* XXX - we ought to examine a .note section here. */
2121 if (elf_elfheader (abfd
)->e_flags
& EF_ARM_MAVERICK_FLOAT
)
2122 bfd_default_set_arch_mach (abfd
, bfd_arch_arm
, bfd_mach_arm_ep9312
);
2127 /* Function to keep ARM specific flags in the ELF header. */
2129 elf32_arm_set_private_flags (abfd
, flags
)
2133 if (elf_flags_init (abfd
)
2134 && elf_elfheader (abfd
)->e_flags
!= flags
)
2136 if (EF_ARM_EABI_VERSION (flags
) == EF_ARM_EABI_UNKNOWN
)
2138 if (flags
& EF_ARM_INTERWORK
)
2139 (*_bfd_error_handler
) (_("\
2140 Warning: Not setting interworking flag of %s since it has already been specified as non-interworking"),
2141 bfd_archive_filename (abfd
));
2143 _bfd_error_handler (_("\
2144 Warning: Clearing the interworking flag of %s due to outside request"),
2145 bfd_archive_filename (abfd
));
2150 elf_elfheader (abfd
)->e_flags
= flags
;
2151 elf_flags_init (abfd
) = TRUE
;
2157 /* Copy backend specific data from one object module to another. */
2160 elf32_arm_copy_private_bfd_data (ibfd
, obfd
)
2167 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2168 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2171 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2172 out_flags
= elf_elfheader (obfd
)->e_flags
;
2174 if (elf_flags_init (obfd
)
2175 && EF_ARM_EABI_VERSION (out_flags
) == EF_ARM_EABI_UNKNOWN
2176 && in_flags
!= out_flags
)
2178 /* Cannot mix APCS26 and APCS32 code. */
2179 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2182 /* Cannot mix float APCS and non-float APCS code. */
2183 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2186 /* If the src and dest have different interworking flags
2187 then turn off the interworking bit. */
2188 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2190 if (out_flags
& EF_ARM_INTERWORK
)
2191 _bfd_error_handler (_("\
2192 Warning: Clearing the interworking flag of %s because non-interworking code in %s has been linked with it"),
2193 bfd_get_filename (obfd
),
2194 bfd_archive_filename (ibfd
));
2196 in_flags
&= ~EF_ARM_INTERWORK
;
2199 /* Likewise for PIC, though don't warn for this case. */
2200 if ((in_flags
& EF_ARM_PIC
) != (out_flags
& EF_ARM_PIC
))
2201 in_flags
&= ~EF_ARM_PIC
;
2204 elf_elfheader (obfd
)->e_flags
= in_flags
;
2205 elf_flags_init (obfd
) = TRUE
;
2210 /* Merge backend specific data from an object file to the output
2211 object file when linking. */
2214 elf32_arm_merge_private_bfd_data (ibfd
, obfd
)
2220 bfd_boolean flags_compatible
= TRUE
;
2221 bfd_boolean null_input_bfd
= TRUE
;
2224 /* Check if we have the same endianess. */
2225 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
2228 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2229 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2232 /* The input BFD must have had its flags initialised. */
2233 /* The following seems bogus to me -- The flags are initialized in
2234 the assembler but I don't think an elf_flags_init field is
2235 written into the object. */
2236 /* BFD_ASSERT (elf_flags_init (ibfd)); */
2238 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2239 out_flags
= elf_elfheader (obfd
)->e_flags
;
2241 if (!elf_flags_init (obfd
))
2243 /* If the input is the default architecture and had the default
2244 flags then do not bother setting the flags for the output
2245 architecture, instead allow future merges to do this. If no
2246 future merges ever set these flags then they will retain their
2247 uninitialised values, which surprise surprise, correspond
2248 to the default values. */
2249 if (bfd_get_arch_info (ibfd
)->the_default
2250 && elf_elfheader (ibfd
)->e_flags
== 0)
2253 elf_flags_init (obfd
) = TRUE
;
2254 elf_elfheader (obfd
)->e_flags
= in_flags
;
2256 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
2257 && bfd_get_arch_info (obfd
)->the_default
)
2258 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
), bfd_get_mach (ibfd
));
2263 /* Identical flags must be compatible. */
2264 if (in_flags
== out_flags
)
2267 /* Check to see if the input BFD actually contains any sections.
2268 If not, its flags may not have been initialised either, but it cannot
2269 actually cause any incompatibility. */
2270 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2272 /* Ignore synthetic glue sections. */
2273 if (strcmp (sec
->name
, ".glue_7")
2274 && strcmp (sec
->name
, ".glue_7t"))
2276 null_input_bfd
= FALSE
;
2283 /* Complain about various flag mismatches. */
2284 if (EF_ARM_EABI_VERSION (in_flags
) != EF_ARM_EABI_VERSION (out_flags
))
2286 _bfd_error_handler (_("\
2287 ERROR: %s is compiled for EABI version %d, whereas %s is compiled for version %d"),
2288 bfd_archive_filename (ibfd
),
2289 (in_flags
& EF_ARM_EABIMASK
) >> 24,
2290 bfd_get_filename (obfd
),
2291 (out_flags
& EF_ARM_EABIMASK
) >> 24);
2295 /* Not sure what needs to be checked for EABI versions >= 1. */
2296 if (EF_ARM_EABI_VERSION (in_flags
) == EF_ARM_EABI_UNKNOWN
)
2298 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2300 _bfd_error_handler (_("\
2301 ERROR: %s is compiled for APCS-%d, whereas target %s uses APCS-%d"),
2302 bfd_archive_filename (ibfd
),
2303 in_flags
& EF_ARM_APCS_26
? 26 : 32,
2304 bfd_get_filename (obfd
),
2305 out_flags
& EF_ARM_APCS_26
? 26 : 32);
2306 flags_compatible
= FALSE
;
2309 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2311 if (in_flags
& EF_ARM_APCS_FLOAT
)
2312 _bfd_error_handler (_("\
2313 ERROR: %s passes floats in float registers, whereas %s passes them in integer registers"),
2314 bfd_archive_filename (ibfd
),
2315 bfd_get_filename (obfd
));
2317 _bfd_error_handler (_("\
2318 ERROR: %s passes floats in integer registers, whereas %s passes them in float registers"),
2319 bfd_archive_filename (ibfd
),
2320 bfd_get_filename (obfd
));
2322 flags_compatible
= FALSE
;
2325 if ((in_flags
& EF_ARM_VFP_FLOAT
) != (out_flags
& EF_ARM_VFP_FLOAT
))
2327 if (in_flags
& EF_ARM_VFP_FLOAT
)
2328 _bfd_error_handler (_("\
2329 ERROR: %s uses VFP instructions, whereas %s does not"),
2330 bfd_archive_filename (ibfd
),
2331 bfd_get_filename (obfd
));
2333 _bfd_error_handler (_("\
2334 ERROR: %s uses FPA instructions, whereas %s does not"),
2335 bfd_archive_filename (ibfd
),
2336 bfd_get_filename (obfd
));
2338 flags_compatible
= FALSE
;
2341 if ((in_flags
& EF_ARM_MAVERICK_FLOAT
) != (out_flags
& EF_ARM_MAVERICK_FLOAT
))
2343 if (in_flags
& EF_ARM_MAVERICK_FLOAT
)
2344 _bfd_error_handler (_("\
2345 ERROR: %s uses Maverick instructions, whereas %s does not"),
2346 bfd_archive_filename (ibfd
),
2347 bfd_get_filename (obfd
));
2349 _bfd_error_handler (_("\
2350 ERROR: %s uses Maverick instructions, whereas %s does not"),
2351 bfd_archive_filename (ibfd
),
2352 bfd_get_filename (obfd
));
2354 flags_compatible
= FALSE
;
2357 #ifdef EF_ARM_SOFT_FLOAT
2358 if ((in_flags
& EF_ARM_SOFT_FLOAT
) != (out_flags
& EF_ARM_SOFT_FLOAT
))
2360 /* We can allow interworking between code that is VFP format
2361 layout, and uses either soft float or integer regs for
2362 passing floating point arguments and results. We already
2363 know that the APCS_FLOAT flags match; similarly for VFP
2365 if ((in_flags
& EF_ARM_APCS_FLOAT
) != 0
2366 || (in_flags
& EF_ARM_VFP_FLOAT
) == 0)
2368 if (in_flags
& EF_ARM_SOFT_FLOAT
)
2369 _bfd_error_handler (_("\
2370 ERROR: %s uses software FP, whereas %s uses hardware FP"),
2371 bfd_archive_filename (ibfd
),
2372 bfd_get_filename (obfd
));
2374 _bfd_error_handler (_("\
2375 ERROR: %s uses hardware FP, whereas %s uses software FP"),
2376 bfd_archive_filename (ibfd
),
2377 bfd_get_filename (obfd
));
2379 flags_compatible
= FALSE
;
2384 /* Interworking mismatch is only a warning. */
2385 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2387 if (in_flags
& EF_ARM_INTERWORK
)
2389 _bfd_error_handler (_("\
2390 Warning: %s supports interworking, whereas %s does not"),
2391 bfd_archive_filename (ibfd
),
2392 bfd_get_filename (obfd
));
2396 _bfd_error_handler (_("\
2397 Warning: %s does not support interworking, whereas %s does"),
2398 bfd_archive_filename (ibfd
),
2399 bfd_get_filename (obfd
));
2404 return flags_compatible
;
2407 /* Display the flags field. */
2410 elf32_arm_print_private_bfd_data (abfd
, ptr
)
2414 FILE * file
= (FILE *) ptr
;
2415 unsigned long flags
;
2417 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
2419 /* Print normal ELF private data. */
2420 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
2422 flags
= elf_elfheader (abfd
)->e_flags
;
2423 /* Ignore init flag - it may not be set, despite the flags field
2424 containing valid data. */
2426 /* xgettext:c-format */
2427 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
2429 switch (EF_ARM_EABI_VERSION (flags
))
2431 case EF_ARM_EABI_UNKNOWN
:
2432 /* The following flag bits are GNU extenstions and not part of the
2433 official ARM ELF extended ABI. Hence they are only decoded if
2434 the EABI version is not set. */
2435 if (flags
& EF_ARM_INTERWORK
)
2436 fprintf (file
, _(" [interworking enabled]"));
2438 if (flags
& EF_ARM_APCS_26
)
2439 fprintf (file
, " [APCS-26]");
2441 fprintf (file
, " [APCS-32]");
2443 if (flags
& EF_ARM_VFP_FLOAT
)
2444 fprintf (file
, _(" [VFP float format]"));
2445 else if (flags
& EF_ARM_MAVERICK_FLOAT
)
2446 fprintf (file
, _(" [Maverick float format]"));
2448 fprintf (file
, _(" [FPA float format]"));
2450 if (flags
& EF_ARM_APCS_FLOAT
)
2451 fprintf (file
, _(" [floats passed in float registers]"));
2453 if (flags
& EF_ARM_PIC
)
2454 fprintf (file
, _(" [position independent]"));
2456 if (flags
& EF_ARM_NEW_ABI
)
2457 fprintf (file
, _(" [new ABI]"));
2459 if (flags
& EF_ARM_OLD_ABI
)
2460 fprintf (file
, _(" [old ABI]"));
2462 if (flags
& EF_ARM_SOFT_FLOAT
)
2463 fprintf (file
, _(" [software FP]"));
2465 flags
&= ~(EF_ARM_INTERWORK
| EF_ARM_APCS_26
| EF_ARM_APCS_FLOAT
2466 | EF_ARM_PIC
| EF_ARM_NEW_ABI
| EF_ARM_OLD_ABI
2467 | EF_ARM_SOFT_FLOAT
| EF_ARM_VFP_FLOAT
2468 | EF_ARM_MAVERICK_FLOAT
);
2471 case EF_ARM_EABI_VER1
:
2472 fprintf (file
, _(" [Version1 EABI]"));
2474 if (flags
& EF_ARM_SYMSARESORTED
)
2475 fprintf (file
, _(" [sorted symbol table]"));
2477 fprintf (file
, _(" [unsorted symbol table]"));
2479 flags
&= ~ EF_ARM_SYMSARESORTED
;
2482 case EF_ARM_EABI_VER2
:
2483 fprintf (file
, _(" [Version2 EABI]"));
2485 if (flags
& EF_ARM_SYMSARESORTED
)
2486 fprintf (file
, _(" [sorted symbol table]"));
2488 fprintf (file
, _(" [unsorted symbol table]"));
2490 if (flags
& EF_ARM_DYNSYMSUSESEGIDX
)
2491 fprintf (file
, _(" [dynamic symbols use segment index]"));
2493 if (flags
& EF_ARM_MAPSYMSFIRST
)
2494 fprintf (file
, _(" [mapping symbols precede others]"));
2496 flags
&= ~(EF_ARM_SYMSARESORTED
| EF_ARM_DYNSYMSUSESEGIDX
2497 | EF_ARM_MAPSYMSFIRST
);
2501 fprintf (file
, _(" <EABI version unrecognised>"));
2505 flags
&= ~ EF_ARM_EABIMASK
;
2507 if (flags
& EF_ARM_RELEXEC
)
2508 fprintf (file
, _(" [relocatable executable]"));
2510 if (flags
& EF_ARM_HASENTRY
)
2511 fprintf (file
, _(" [has entry point]"));
2513 flags
&= ~ (EF_ARM_RELEXEC
| EF_ARM_HASENTRY
);
2516 fprintf (file
, _("<Unrecognised flag bits set>"));
2524 elf32_arm_get_symbol_type (elf_sym
, type
)
2525 Elf_Internal_Sym
* elf_sym
;
2528 switch (ELF_ST_TYPE (elf_sym
->st_info
))
2531 return ELF_ST_TYPE (elf_sym
->st_info
);
2534 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2535 This allows us to distinguish between data used by Thumb instructions
2536 and non-data (which is probably code) inside Thumb regions of an
2538 if (type
!= STT_OBJECT
)
2539 return ELF_ST_TYPE (elf_sym
->st_info
);
2550 elf32_arm_gc_mark_hook (sec
, info
, rel
, h
, sym
)
2552 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2553 Elf_Internal_Rela
*rel
;
2554 struct elf_link_hash_entry
*h
;
2555 Elf_Internal_Sym
*sym
;
2559 switch (ELF32_R_TYPE (rel
->r_info
))
2561 case R_ARM_GNU_VTINHERIT
:
2562 case R_ARM_GNU_VTENTRY
:
2566 switch (h
->root
.type
)
2568 case bfd_link_hash_defined
:
2569 case bfd_link_hash_defweak
:
2570 return h
->root
.u
.def
.section
;
2572 case bfd_link_hash_common
:
2573 return h
->root
.u
.c
.p
->section
;
2581 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
2586 /* Update the got entry reference counts for the section being removed. */
2589 elf32_arm_gc_sweep_hook (abfd
, info
, sec
, relocs
)
2590 bfd
*abfd ATTRIBUTE_UNUSED
;
2591 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2592 asection
*sec ATTRIBUTE_UNUSED
;
2593 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
;
2595 /* We don't support garbage collection of GOT and PLT relocs yet. */
2599 /* Look through the relocs for a section during the first phase. */
2602 elf32_arm_check_relocs (abfd
, info
, sec
, relocs
)
2604 struct bfd_link_info
*info
;
2606 const Elf_Internal_Rela
*relocs
;
2608 Elf_Internal_Shdr
*symtab_hdr
;
2609 struct elf_link_hash_entry
**sym_hashes
;
2610 struct elf_link_hash_entry
**sym_hashes_end
;
2611 const Elf_Internal_Rela
*rel
;
2612 const Elf_Internal_Rela
*rel_end
;
2614 asection
*sgot
, *srelgot
, *sreloc
;
2615 bfd_vma
*local_got_offsets
;
2617 if (info
->relocateable
)
2620 sgot
= srelgot
= sreloc
= NULL
;
2622 dynobj
= elf_hash_table (info
)->dynobj
;
2623 local_got_offsets
= elf_local_got_offsets (abfd
);
2625 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2626 sym_hashes
= elf_sym_hashes (abfd
);
2627 sym_hashes_end
= sym_hashes
2628 + symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
2630 if (!elf_bad_symtab (abfd
))
2631 sym_hashes_end
-= symtab_hdr
->sh_info
;
2633 rel_end
= relocs
+ sec
->reloc_count
;
2634 for (rel
= relocs
; rel
< rel_end
; rel
++)
2636 struct elf_link_hash_entry
*h
;
2637 unsigned long r_symndx
;
2639 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2640 if (r_symndx
< symtab_hdr
->sh_info
)
2643 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2645 /* Some relocs require a global offset table. */
2648 switch (ELF32_R_TYPE (rel
->r_info
))
2653 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
2654 if (! _bfd_elf_create_got_section (dynobj
, info
))
2663 switch (ELF32_R_TYPE (rel
->r_info
))
2666 /* This symbol requires a global offset table entry. */
2669 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2670 BFD_ASSERT (sgot
!= NULL
);
2673 /* Get the got relocation section if necessary. */
2675 && (h
!= NULL
|| info
->shared
))
2677 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
2679 /* If no got relocation section, make one and initialize. */
2680 if (srelgot
== NULL
)
2682 srelgot
= bfd_make_section (dynobj
, ".rel.got");
2684 || ! bfd_set_section_flags (dynobj
, srelgot
,
2689 | SEC_LINKER_CREATED
2691 || ! bfd_set_section_alignment (dynobj
, srelgot
, 2))
2698 if (h
->got
.offset
!= (bfd_vma
) -1)
2699 /* We have already allocated space in the .got. */
2702 h
->got
.offset
= sgot
->_raw_size
;
2704 /* Make sure this symbol is output as a dynamic symbol. */
2705 if (h
->dynindx
== -1)
2706 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2709 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2713 /* This is a global offset table entry for a local
2715 if (local_got_offsets
== NULL
)
2720 size
= symtab_hdr
->sh_info
;
2721 size
*= sizeof (bfd_vma
);
2722 local_got_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
2723 if (local_got_offsets
== NULL
)
2725 elf_local_got_offsets (abfd
) = local_got_offsets
;
2726 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
2727 local_got_offsets
[i
] = (bfd_vma
) -1;
2730 if (local_got_offsets
[r_symndx
] != (bfd_vma
) -1)
2731 /* We have already allocated space in the .got. */
2734 local_got_offsets
[r_symndx
] = sgot
->_raw_size
;
2737 /* If we are generating a shared object, we need to
2738 output a R_ARM_RELATIVE reloc so that the dynamic
2739 linker can adjust this GOT entry. */
2740 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2743 sgot
->_raw_size
+= 4;
2747 /* This symbol requires a procedure linkage table entry. We
2748 actually build the entry in adjust_dynamic_symbol,
2749 because this might be a case of linking PIC code which is
2750 never referenced by a dynamic object, in which case we
2751 don't need to generate a procedure linkage table entry
2754 /* If this is a local symbol, we resolve it directly without
2755 creating a procedure linkage table entry. */
2759 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2765 /* If we are creating a shared library, and this is a reloc
2766 against a global symbol, or a non PC relative reloc
2767 against a local symbol, then we need to copy the reloc
2768 into the shared library. However, if we are linking with
2769 -Bsymbolic, we do not need to copy a reloc against a
2770 global symbol which is defined in an object we are
2771 including in the link (i.e., DEF_REGULAR is set). At
2772 this point we have not seen all the input files, so it is
2773 possible that DEF_REGULAR is not set now but will be set
2774 later (it is never cleared). We account for that
2775 possibility below by storing information in the
2776 pcrel_relocs_copied field of the hash table entry. */
2778 && (ELF32_R_TYPE (rel
->r_info
) != R_ARM_PC24
2780 && (! info
->symbolic
2781 || (h
->elf_link_hash_flags
2782 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
2784 /* When creating a shared object, we must copy these
2785 reloc types into the output file. We create a reloc
2786 section in dynobj and make room for this reloc. */
2791 name
= (bfd_elf_string_from_elf_section
2793 elf_elfheader (abfd
)->e_shstrndx
,
2794 elf_section_data (sec
)->rel_hdr
.sh_name
));
2798 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
2799 && strcmp (bfd_get_section_name (abfd
, sec
),
2802 sreloc
= bfd_get_section_by_name (dynobj
, name
);
2807 sreloc
= bfd_make_section (dynobj
, name
);
2808 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
2809 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
2810 if ((sec
->flags
& SEC_ALLOC
) != 0)
2811 flags
|= SEC_ALLOC
| SEC_LOAD
;
2813 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
2814 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
2817 if (sec
->flags
& SEC_READONLY
)
2818 info
->flags
|= DF_TEXTREL
;
2821 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
2822 /* If we are linking with -Bsymbolic, and this is a
2823 global symbol, we count the number of PC relative
2824 relocations we have entered for this symbol, so that
2825 we can discard them again if the symbol is later
2826 defined by a regular object. Note that this function
2827 is only called if we are using an elf_i386 linker
2828 hash table, which means that h is really a pointer to
2829 an elf_i386_link_hash_entry. */
2830 if (h
!= NULL
&& info
->symbolic
2831 && ELF32_R_TYPE (rel
->r_info
) == R_ARM_PC24
)
2833 struct elf32_arm_link_hash_entry
* eh
;
2834 struct elf32_arm_pcrel_relocs_copied
* p
;
2836 eh
= (struct elf32_arm_link_hash_entry
*) h
;
2838 for (p
= eh
->pcrel_relocs_copied
; p
!= NULL
; p
= p
->next
)
2839 if (p
->section
== sreloc
)
2844 p
= ((struct elf32_arm_pcrel_relocs_copied
*)
2845 bfd_alloc (dynobj
, (bfd_size_type
) sizeof * p
));
2848 p
->next
= eh
->pcrel_relocs_copied
;
2849 eh
->pcrel_relocs_copied
= p
;
2850 p
->section
= sreloc
;
2859 /* This relocation describes the C++ object vtable hierarchy.
2860 Reconstruct it for later use during GC. */
2861 case R_ARM_GNU_VTINHERIT
:
2862 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2866 /* This relocation describes which C++ vtable entries are actually
2867 used. Record for later use during GC. */
2868 case R_ARM_GNU_VTENTRY
:
2869 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
2878 /* Find the nearest line to a particular section and offset, for error
2879 reporting. This code is a duplicate of the code in elf.c, except
2880 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
2883 elf32_arm_find_nearest_line
2884 (abfd
, section
, symbols
, offset
, filename_ptr
, functionname_ptr
, line_ptr
)
2889 const char **filename_ptr
;
2890 const char **functionname_ptr
;
2891 unsigned int *line_ptr
;
2894 const char *filename
;
2899 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
2900 filename_ptr
, functionname_ptr
,
2902 &elf_tdata (abfd
)->dwarf2_find_line_info
))
2905 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2906 &found
, filename_ptr
,
2907 functionname_ptr
, line_ptr
,
2908 &elf_tdata (abfd
)->line_info
))
2914 if (symbols
== NULL
)
2921 for (p
= symbols
; *p
!= NULL
; p
++)
2925 q
= (elf_symbol_type
*) *p
;
2927 if (bfd_get_section (&q
->symbol
) != section
)
2930 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
2935 filename
= bfd_asymbol_name (&q
->symbol
);
2940 if (q
->symbol
.section
== section
2941 && q
->symbol
.value
>= low_func
2942 && q
->symbol
.value
<= offset
)
2944 func
= (asymbol
*) q
;
2945 low_func
= q
->symbol
.value
;
2954 *filename_ptr
= filename
;
2955 *functionname_ptr
= bfd_asymbol_name (func
);
2961 /* Adjust a symbol defined by a dynamic object and referenced by a
2962 regular object. The current definition is in some section of the
2963 dynamic object, but we're not including those sections. We have to
2964 change the definition to something the rest of the link can
2968 elf32_arm_adjust_dynamic_symbol (info
, h
)
2969 struct bfd_link_info
* info
;
2970 struct elf_link_hash_entry
* h
;
2974 unsigned int power_of_two
;
2976 dynobj
= elf_hash_table (info
)->dynobj
;
2978 /* Make sure we know what is going on here. */
2979 BFD_ASSERT (dynobj
!= NULL
2980 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
2981 || h
->weakdef
!= NULL
2982 || ((h
->elf_link_hash_flags
2983 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2984 && (h
->elf_link_hash_flags
2985 & ELF_LINK_HASH_REF_REGULAR
) != 0
2986 && (h
->elf_link_hash_flags
2987 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
2989 /* If this is a function, put it in the procedure linkage table. We
2990 will fill in the contents of the procedure linkage table later,
2991 when we know the address of the .got section. */
2992 if (h
->type
== STT_FUNC
2993 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
2995 /* If we link a program (not a DSO), we'll get rid of unnecessary
2996 PLT entries; we point to the actual symbols -- even for pic
2997 relocs, because a program built with -fpic should have the same
2998 result as one built without -fpic, specifically considering weak
3000 FIXME: m68k and i386 differ here, for unclear reasons. */
3002 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0)
3004 /* This case can occur if we saw a PLT32 reloc in an input
3005 file, but the symbol was not defined by a dynamic object.
3006 In such a case, we don't actually need to build a
3007 procedure linkage table, and we can just do a PC32 reloc
3009 BFD_ASSERT ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0);
3010 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
3014 /* Make sure this symbol is output as a dynamic symbol. */
3015 if (h
->dynindx
== -1)
3017 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
3021 s
= bfd_get_section_by_name (dynobj
, ".plt");
3022 BFD_ASSERT (s
!= NULL
);
3024 /* If this is the first .plt entry, make room for the special
3026 if (s
->_raw_size
== 0)
3027 s
->_raw_size
+= PLT_ENTRY_SIZE
;
3029 /* If this symbol is not defined in a regular file, and we are
3030 not generating a shared library, then set the symbol to this
3031 location in the .plt. This is required to make function
3032 pointers compare as equal between the normal executable and
3033 the shared library. */
3035 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3037 h
->root
.u
.def
.section
= s
;
3038 h
->root
.u
.def
.value
= s
->_raw_size
;
3041 h
->plt
.offset
= s
->_raw_size
;
3043 /* Make room for this entry. */
3044 s
->_raw_size
+= PLT_ENTRY_SIZE
;
3046 /* We also need to make an entry in the .got.plt section, which
3047 will be placed in the .got section by the linker script. */
3048 s
= bfd_get_section_by_name (dynobj
, ".got.plt");
3049 BFD_ASSERT (s
!= NULL
);
3052 /* We also need to make an entry in the .rel.plt section. */
3054 s
= bfd_get_section_by_name (dynobj
, ".rel.plt");
3055 BFD_ASSERT (s
!= NULL
);
3056 s
->_raw_size
+= sizeof (Elf32_External_Rel
);
3061 /* If this is a weak symbol, and there is a real definition, the
3062 processor independent code will have arranged for us to see the
3063 real definition first, and we can just use the same value. */
3064 if (h
->weakdef
!= NULL
)
3066 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
3067 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
3068 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
3069 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
3073 /* This is a reference to a symbol defined by a dynamic object which
3074 is not a function. */
3076 /* If we are creating a shared library, we must presume that the
3077 only references to the symbol are via the global offset table.
3078 For such cases we need not do anything here; the relocations will
3079 be handled correctly by relocate_section. */
3083 /* We must allocate the symbol in our .dynbss section, which will
3084 become part of the .bss section of the executable. There will be
3085 an entry for this symbol in the .dynsym section. The dynamic
3086 object will contain position independent code, so all references
3087 from the dynamic object to this symbol will go through the global
3088 offset table. The dynamic linker will use the .dynsym entry to
3089 determine the address it must put in the global offset table, so
3090 both the dynamic object and the regular object will refer to the
3091 same memory location for the variable. */
3092 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
3093 BFD_ASSERT (s
!= NULL
);
3095 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
3096 copy the initial value out of the dynamic object and into the
3097 runtime process image. We need to remember the offset into the
3098 .rel.bss section we are going to use. */
3099 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
3103 srel
= bfd_get_section_by_name (dynobj
, ".rel.bss");
3104 BFD_ASSERT (srel
!= NULL
);
3105 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
3106 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
3109 /* We need to figure out the alignment required for this symbol. I
3110 have no idea how ELF linkers handle this. */
3111 power_of_two
= bfd_log2 (h
->size
);
3112 if (power_of_two
> 3)
3115 /* Apply the required alignment. */
3116 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
3117 (bfd_size_type
) (1 << power_of_two
));
3118 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
3120 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
3124 /* Define the symbol as being at this point in the section. */
3125 h
->root
.u
.def
.section
= s
;
3126 h
->root
.u
.def
.value
= s
->_raw_size
;
3128 /* Increment the section size to make room for the symbol. */
3129 s
->_raw_size
+= h
->size
;
3134 /* Set the sizes of the dynamic sections. */
3137 elf32_arm_size_dynamic_sections (output_bfd
, info
)
3138 bfd
* output_bfd ATTRIBUTE_UNUSED
;
3139 struct bfd_link_info
* info
;
3146 dynobj
= elf_hash_table (info
)->dynobj
;
3147 BFD_ASSERT (dynobj
!= NULL
);
3149 if (elf_hash_table (info
)->dynamic_sections_created
)
3151 /* Set the contents of the .interp section to the interpreter. */
3154 s
= bfd_get_section_by_name (dynobj
, ".interp");
3155 BFD_ASSERT (s
!= NULL
);
3156 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
3157 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
3162 /* We may have created entries in the .rel.got section.
3163 However, if we are not creating the dynamic sections, we will
3164 not actually use these entries. Reset the size of .rel.got,
3165 which will cause it to get stripped from the output file
3167 s
= bfd_get_section_by_name (dynobj
, ".rel.got");
3172 /* If this is a -Bsymbolic shared link, then we need to discard all
3173 PC relative relocs against symbols defined in a regular object.
3174 We allocated space for them in the check_relocs routine, but we
3175 will not fill them in in the relocate_section routine. */
3176 if (info
->shared
&& info
->symbolic
)
3177 elf32_arm_link_hash_traverse (elf32_arm_hash_table (info
),
3178 elf32_arm_discard_copies
,
3181 /* The check_relocs and adjust_dynamic_symbol entry points have
3182 determined the sizes of the various dynamic sections. Allocate
3186 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3191 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3194 /* It's OK to base decisions on the section name, because none
3195 of the dynobj section names depend upon the input files. */
3196 name
= bfd_get_section_name (dynobj
, s
);
3200 if (strcmp (name
, ".plt") == 0)
3202 if (s
->_raw_size
== 0)
3204 /* Strip this section if we don't need it; see the
3210 /* Remember whether there is a PLT. */
3214 else if (strncmp (name
, ".rel", 4) == 0)
3216 if (s
->_raw_size
== 0)
3218 /* If we don't need this section, strip it from the
3219 output file. This is mostly to handle .rel.bss and
3220 .rel.plt. We must create both sections in
3221 create_dynamic_sections, because they must be created
3222 before the linker maps input sections to output
3223 sections. The linker does that before
3224 adjust_dynamic_symbol is called, and it is that
3225 function which decides whether anything needs to go
3226 into these sections. */
3231 /* Remember whether there are any reloc sections other
3233 if (strcmp (name
, ".rel.plt") != 0)
3236 /* We use the reloc_count field as a counter if we need
3237 to copy relocs into the output file. */
3241 else if (strncmp (name
, ".got", 4) != 0)
3243 /* It's not one of our sections, so don't allocate space. */
3249 _bfd_strip_section_from_output (info
, s
);
3253 /* Allocate memory for the section contents. */
3254 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
3255 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
3259 if (elf_hash_table (info
)->dynamic_sections_created
)
3261 /* Add some entries to the .dynamic section. We fill in the
3262 values later, in elf32_arm_finish_dynamic_sections, but we
3263 must add the entries now so that we get the correct size for
3264 the .dynamic section. The DT_DEBUG entry is filled in by the
3265 dynamic linker and used by the debugger. */
3266 #define add_dynamic_entry(TAG, VAL) \
3267 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
3271 if (!add_dynamic_entry (DT_DEBUG
, 0))
3277 if ( !add_dynamic_entry (DT_PLTGOT
, 0)
3278 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
3279 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
3280 || !add_dynamic_entry (DT_JMPREL
, 0))
3286 if ( !add_dynamic_entry (DT_REL
, 0)
3287 || !add_dynamic_entry (DT_RELSZ
, 0)
3288 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
3292 if ((info
->flags
& DF_TEXTREL
) != 0)
3294 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3296 info
->flags
|= DF_TEXTREL
;
3299 #undef add_synamic_entry
3304 /* This function is called via elf32_arm_link_hash_traverse if we are
3305 creating a shared object with -Bsymbolic. It discards the space
3306 allocated to copy PC relative relocs against symbols which are
3307 defined in regular objects. We allocated space for them in the
3308 check_relocs routine, but we won't fill them in in the
3309 relocate_section routine. */
3312 elf32_arm_discard_copies (h
, ignore
)
3313 struct elf32_arm_link_hash_entry
* h
;
3314 PTR ignore ATTRIBUTE_UNUSED
;
3316 struct elf32_arm_pcrel_relocs_copied
* s
;
3318 if (h
->root
.root
.type
== bfd_link_hash_warning
)
3319 h
= (struct elf32_arm_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3321 /* We only discard relocs for symbols defined in a regular object. */
3322 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3325 for (s
= h
->pcrel_relocs_copied
; s
!= NULL
; s
= s
->next
)
3326 s
->section
->_raw_size
-= s
->count
* sizeof (Elf32_External_Rel
);
3331 /* Finish up dynamic symbol handling. We set the contents of various
3332 dynamic sections here. */
3335 elf32_arm_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
3337 struct bfd_link_info
* info
;
3338 struct elf_link_hash_entry
* h
;
3339 Elf_Internal_Sym
* sym
;
3343 dynobj
= elf_hash_table (info
)->dynobj
;
3345 if (h
->plt
.offset
!= (bfd_vma
) -1)
3352 Elf_Internal_Rela rel
;
3355 /* This symbol has an entry in the procedure linkage table. Set
3358 BFD_ASSERT (h
->dynindx
!= -1);
3360 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3361 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3362 srel
= bfd_get_section_by_name (dynobj
, ".rel.plt");
3363 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
3365 /* Get the index in the procedure linkage table which
3366 corresponds to this symbol. This is the index of this symbol
3367 in all the symbols for which we are making plt entries. The
3368 first entry in the procedure linkage table is reserved. */
3369 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
3371 /* Get the offset into the .got table of the entry that
3372 corresponds to this function. Each .got entry is 4 bytes.
3373 The first three are reserved. */
3374 got_offset
= (plt_index
+ 3) * 4;
3376 /* Fill in the entry in the procedure linkage table. */
3377 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[0],
3378 splt
->contents
+ h
->plt
.offset
+ 0);
3379 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[1],
3380 splt
->contents
+ h
->plt
.offset
+ 4);
3381 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[2],
3382 splt
->contents
+ h
->plt
.offset
+ 8);
3383 bfd_put_32 (output_bfd
,
3384 (sgot
->output_section
->vma
3385 + sgot
->output_offset
3387 - splt
->output_section
->vma
3388 - splt
->output_offset
3389 - h
->plt
.offset
- 12),
3390 splt
->contents
+ h
->plt
.offset
+ 12);
3392 /* Fill in the entry in the global offset table. */
3393 bfd_put_32 (output_bfd
,
3394 (splt
->output_section
->vma
3395 + splt
->output_offset
),
3396 sgot
->contents
+ got_offset
);
3398 /* Fill in the entry in the .rel.plt section. */
3399 rel
.r_offset
= (sgot
->output_section
->vma
3400 + sgot
->output_offset
3402 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_JUMP_SLOT
);
3403 loc
= srel
->contents
+ plt_index
* sizeof (Elf32_External_Rel
);
3404 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3406 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3408 /* Mark the symbol as undefined, rather than as defined in
3409 the .plt section. Leave the value alone. */
3410 sym
->st_shndx
= SHN_UNDEF
;
3411 /* If the symbol is weak, we do need to clear the value.
3412 Otherwise, the PLT entry would provide a definition for
3413 the symbol even if the symbol wasn't defined anywhere,
3414 and so the symbol would never be NULL. */
3415 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR_NONWEAK
)
3421 if (h
->got
.offset
!= (bfd_vma
) -1)
3425 Elf_Internal_Rela rel
;
3428 /* This symbol has an entry in the global offset table. Set it
3430 sgot
= bfd_get_section_by_name (dynobj
, ".got");
3431 srel
= bfd_get_section_by_name (dynobj
, ".rel.got");
3432 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
3434 rel
.r_offset
= (sgot
->output_section
->vma
3435 + sgot
->output_offset
3436 + (h
->got
.offset
&~ (bfd_vma
) 1));
3438 /* If this is a -Bsymbolic link, and the symbol is defined
3439 locally, we just want to emit a RELATIVE reloc. The entry in
3440 the global offset table will already have been initialized in
3441 the relocate_section function. */
3443 && (info
->symbolic
|| h
->dynindx
== -1)
3444 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
3445 rel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
3448 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
3449 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_GLOB_DAT
);
3452 loc
= srel
->contents
+ srel
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3453 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3456 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
3459 Elf_Internal_Rela rel
;
3462 /* This symbol needs a copy reloc. Set it up. */
3463 BFD_ASSERT (h
->dynindx
!= -1
3464 && (h
->root
.type
== bfd_link_hash_defined
3465 || h
->root
.type
== bfd_link_hash_defweak
));
3467 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
3469 BFD_ASSERT (s
!= NULL
);
3471 rel
.r_offset
= (h
->root
.u
.def
.value
3472 + h
->root
.u
.def
.section
->output_section
->vma
3473 + h
->root
.u
.def
.section
->output_offset
);
3474 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_COPY
);
3475 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3476 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3479 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3480 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3481 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
3482 sym
->st_shndx
= SHN_ABS
;
3487 /* Finish up the dynamic sections. */
3490 elf32_arm_finish_dynamic_sections (output_bfd
, info
)
3492 struct bfd_link_info
* info
;
3498 dynobj
= elf_hash_table (info
)->dynobj
;
3500 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3501 BFD_ASSERT (sgot
!= NULL
);
3502 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3504 if (elf_hash_table (info
)->dynamic_sections_created
)
3507 Elf32_External_Dyn
*dyncon
, *dynconend
;
3509 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3510 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3512 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3513 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
3515 for (; dyncon
< dynconend
; dyncon
++)
3517 Elf_Internal_Dyn dyn
;
3521 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3534 s
= bfd_get_section_by_name (output_bfd
, name
);
3535 BFD_ASSERT (s
!= NULL
);
3536 dyn
.d_un
.d_ptr
= s
->vma
;
3537 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3541 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3542 BFD_ASSERT (s
!= NULL
);
3543 if (s
->_cooked_size
!= 0)
3544 dyn
.d_un
.d_val
= s
->_cooked_size
;
3546 dyn
.d_un
.d_val
= s
->_raw_size
;
3547 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3551 /* My reading of the SVR4 ABI indicates that the
3552 procedure linkage table relocs (DT_JMPREL) should be
3553 included in the overall relocs (DT_REL). This is
3554 what Solaris does. However, UnixWare can not handle
3555 that case. Therefore, we override the DT_RELSZ entry
3556 here to make it not include the JMPREL relocs. Since
3557 the linker script arranges for .rel.plt to follow all
3558 other relocation sections, we don't have to worry
3559 about changing the DT_REL entry. */
3560 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3563 if (s
->_cooked_size
!= 0)
3564 dyn
.d_un
.d_val
-= s
->_cooked_size
;
3566 dyn
.d_un
.d_val
-= s
->_raw_size
;
3568 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3571 /* Set the bottom bit of DT_INIT/FINI if the
3572 corresponding function is Thumb. */
3574 name
= info
->init_function
;
3577 name
= info
->fini_function
;
3579 /* If it wasn't set by elf_bfd_final_link
3580 then there is nothing to ajdust. */
3581 if (dyn
.d_un
.d_val
!= 0)
3583 struct elf_link_hash_entry
* eh
;
3585 eh
= elf_link_hash_lookup (elf_hash_table (info
), name
,
3586 FALSE
, FALSE
, TRUE
);
3587 if (eh
!= (struct elf_link_hash_entry
*) NULL
3588 && ELF_ST_TYPE (eh
->type
) == STT_ARM_TFUNC
)
3590 dyn
.d_un
.d_val
|= 1;
3591 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3598 /* Fill in the first entry in the procedure linkage table. */
3599 if (splt
->_raw_size
> 0)
3601 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[0], splt
->contents
+ 0);
3602 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[1], splt
->contents
+ 4);
3603 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[2], splt
->contents
+ 8);
3604 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[3], splt
->contents
+ 12);
3607 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3608 really seem like the right value. */
3609 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
3612 /* Fill in the first three entries in the global offset table. */
3613 if (sgot
->_raw_size
> 0)
3616 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
3618 bfd_put_32 (output_bfd
,
3619 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3621 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
3622 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
3625 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
3631 elf32_arm_post_process_headers (abfd
, link_info
)
3633 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
;
3635 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
3637 i_ehdrp
= elf_elfheader (abfd
);
3639 i_ehdrp
->e_ident
[EI_OSABI
] = ARM_ELF_OS_ABI_VERSION
;
3640 i_ehdrp
->e_ident
[EI_ABIVERSION
] = ARM_ELF_ABI_VERSION
;
3643 static enum elf_reloc_type_class
3644 elf32_arm_reloc_type_class (rela
)
3645 const Elf_Internal_Rela
*rela
;
3647 switch ((int) ELF32_R_TYPE (rela
->r_info
))
3649 case R_ARM_RELATIVE
:
3650 return reloc_class_relative
;
3651 case R_ARM_JUMP_SLOT
:
3652 return reloc_class_plt
;
3654 return reloc_class_copy
;
3656 return reloc_class_normal
;
3660 #define ELF_ARCH bfd_arch_arm
3661 #define ELF_MACHINE_CODE EM_ARM
3662 #define ELF_MAXPAGESIZE 0x8000
3664 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
3665 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
3666 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
3667 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
3668 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
3669 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
3670 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
3672 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
3673 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
3674 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
3675 #define elf_backend_check_relocs elf32_arm_check_relocs
3676 #define elf_backend_relocate_section elf32_arm_relocate_section
3677 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
3678 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
3679 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
3680 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
3681 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
3682 #define elf_backend_post_process_headers elf32_arm_post_process_headers
3683 #define elf_backend_reloc_type_class elf32_arm_reloc_type_class
3684 #define elf_backend_object_p elf32_arm_object_p
3686 #define elf_backend_can_gc_sections 1
3687 #define elf_backend_plt_readonly 1
3688 #define elf_backend_want_got_plt 1
3689 #define elf_backend_want_plt_sym 0
3691 #define elf_backend_rela_normal 1
3694 #define elf_backend_got_header_size 12
3695 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
3697 #include "elf32-target.h"