1 /* 32-bit ELF support for ARM
2 Copyright 1998, 1999, 2000, 2001, 2002 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
*));
90 #ifndef ELFARM_NABI_C_INCLUDED
91 static void record_arm_to_thumb_glue
92 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
93 static void record_thumb_to_arm_glue
94 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
95 bfd_boolean bfd_elf32_arm_allocate_interworking_sections
96 PARAMS ((struct bfd_link_info
*));
97 bfd_boolean bfd_elf32_arm_get_bfd_for_interworking
98 PARAMS ((bfd
*, struct bfd_link_info
*));
99 bfd_boolean bfd_elf32_arm_process_before_allocation
100 PARAMS ((bfd
*, struct bfd_link_info
*, int));
104 #define INTERWORK_FLAG(abfd) (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK)
106 /* The linker script knows the section names for placement.
107 The entry_names are used to do simple name mangling on the stubs.
108 Given a function name, and its type, the stub can be found. The
109 name can be changed. The only requirement is the %s be present. */
110 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
111 #define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
113 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
114 #define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
116 /* The name of the dynamic interpreter. This is put in the .interp
118 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
120 /* The size in bytes of an entry in the procedure linkage table. */
121 #define PLT_ENTRY_SIZE 16
123 /* The first entry in a procedure linkage table looks like
124 this. It is set up so that any shared library function that is
125 called before the relocation has been set up calls the dynamic
127 static const bfd_vma elf32_arm_plt0_entry
[PLT_ENTRY_SIZE
/ 4] =
129 0xe52de004, /* str lr, [sp, #-4]! */
130 0xe59fe010, /* ldr lr, [pc, #16] */
131 0xe08fe00e, /* add lr, pc, lr */
132 0xe5bef008 /* ldr pc, [lr, #8]! */
135 /* Subsequent entries in a procedure linkage table look like
137 static const bfd_vma elf32_arm_plt_entry
[PLT_ENTRY_SIZE
/ 4] =
139 0xe59fc004, /* ldr ip, [pc, #4] */
140 0xe08fc00c, /* add ip, pc, ip */
141 0xe59cf000, /* ldr pc, [ip] */
142 0x00000000 /* offset to symbol in got */
145 /* The ARM linker needs to keep track of the number of relocs that it
146 decides to copy in check_relocs for each symbol. This is so that
147 it can discard PC relative relocs if it doesn't need them when
148 linking with -Bsymbolic. We store the information in a field
149 extending the regular ELF linker hash table. */
151 /* This structure keeps track of the number of PC relative relocs we
152 have copied for a given symbol. */
153 struct elf32_arm_pcrel_relocs_copied
156 struct elf32_arm_pcrel_relocs_copied
* next
;
157 /* A section in dynobj. */
159 /* Number of relocs copied in this section. */
163 /* Arm ELF linker hash entry. */
164 struct elf32_arm_link_hash_entry
166 struct elf_link_hash_entry root
;
168 /* Number of PC relative relocs copied for this symbol. */
169 struct elf32_arm_pcrel_relocs_copied
* pcrel_relocs_copied
;
172 /* Declare this now that the above structures are defined. */
173 static bfd_boolean elf32_arm_discard_copies
174 PARAMS ((struct elf32_arm_link_hash_entry
*, PTR
));
176 /* Traverse an arm ELF linker hash table. */
177 #define elf32_arm_link_hash_traverse(table, func, info) \
178 (elf_link_hash_traverse \
180 (bfd_boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
183 /* Get the ARM elf linker hash table from a link_info structure. */
184 #define elf32_arm_hash_table(info) \
185 ((struct elf32_arm_link_hash_table *) ((info)->hash))
187 /* ARM ELF linker hash table. */
188 struct elf32_arm_link_hash_table
190 /* The main hash table. */
191 struct elf_link_hash_table root
;
193 /* The size in bytes of the section containg the Thumb-to-ARM glue. */
194 bfd_size_type thumb_glue_size
;
196 /* The size in bytes of the section containg the ARM-to-Thumb glue. */
197 bfd_size_type arm_glue_size
;
199 /* An arbitary input BFD chosen to hold the glue sections. */
200 bfd
* bfd_of_glue_owner
;
202 /* A boolean indicating whether knowledge of the ARM's pipeline
203 length should be applied by the linker. */
204 int no_pipeline_knowledge
;
207 /* Create an entry in an ARM ELF linker hash table. */
209 static struct bfd_hash_entry
*
210 elf32_arm_link_hash_newfunc (entry
, table
, string
)
211 struct bfd_hash_entry
* entry
;
212 struct bfd_hash_table
* table
;
215 struct elf32_arm_link_hash_entry
* ret
=
216 (struct elf32_arm_link_hash_entry
*) entry
;
218 /* Allocate the structure if it has not already been allocated by a
220 if (ret
== (struct elf32_arm_link_hash_entry
*) NULL
)
221 ret
= ((struct elf32_arm_link_hash_entry
*)
222 bfd_hash_allocate (table
,
223 sizeof (struct elf32_arm_link_hash_entry
)));
224 if (ret
== (struct elf32_arm_link_hash_entry
*) NULL
)
225 return (struct bfd_hash_entry
*) ret
;
227 /* Call the allocation method of the superclass. */
228 ret
= ((struct elf32_arm_link_hash_entry
*)
229 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
231 if (ret
!= (struct elf32_arm_link_hash_entry
*) NULL
)
232 ret
->pcrel_relocs_copied
= NULL
;
234 return (struct bfd_hash_entry
*) ret
;
237 /* Create an ARM elf linker hash table. */
239 static struct bfd_link_hash_table
*
240 elf32_arm_link_hash_table_create (abfd
)
243 struct elf32_arm_link_hash_table
*ret
;
244 bfd_size_type amt
= sizeof (struct elf32_arm_link_hash_table
);
246 ret
= (struct elf32_arm_link_hash_table
*) bfd_malloc (amt
);
247 if (ret
== (struct elf32_arm_link_hash_table
*) NULL
)
250 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
251 elf32_arm_link_hash_newfunc
))
257 ret
->thumb_glue_size
= 0;
258 ret
->arm_glue_size
= 0;
259 ret
->bfd_of_glue_owner
= NULL
;
260 ret
->no_pipeline_knowledge
= 0;
262 return &ret
->root
.root
;
265 /* Locate the Thumb encoded calling stub for NAME. */
267 static struct elf_link_hash_entry
*
268 find_thumb_glue (link_info
, name
, input_bfd
)
269 struct bfd_link_info
*link_info
;
274 struct elf_link_hash_entry
*hash
;
275 struct elf32_arm_link_hash_table
*hash_table
;
277 /* We need a pointer to the armelf specific hash table. */
278 hash_table
= elf32_arm_hash_table (link_info
);
280 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
281 + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1);
283 BFD_ASSERT (tmp_name
);
285 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
287 hash
= elf_link_hash_lookup
288 (&(hash_table
)->root
, tmp_name
, FALSE
, FALSE
, TRUE
);
291 /* xgettext:c-format */
292 (*_bfd_error_handler
) (_("%s: unable to find THUMB glue '%s' for `%s'"),
293 bfd_archive_filename (input_bfd
), tmp_name
, name
);
300 /* Locate the ARM encoded calling stub for NAME. */
302 static struct elf_link_hash_entry
*
303 find_arm_glue (link_info
, name
, input_bfd
)
304 struct bfd_link_info
*link_info
;
309 struct elf_link_hash_entry
*myh
;
310 struct elf32_arm_link_hash_table
*hash_table
;
312 /* We need a pointer to the elfarm specific hash table. */
313 hash_table
= elf32_arm_hash_table (link_info
);
315 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
316 + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1);
318 BFD_ASSERT (tmp_name
);
320 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
322 myh
= elf_link_hash_lookup
323 (&(hash_table
)->root
, tmp_name
, FALSE
, FALSE
, TRUE
);
326 /* xgettext:c-format */
327 (*_bfd_error_handler
) (_("%s: unable to find ARM glue '%s' for `%s'"),
328 bfd_archive_filename (input_bfd
), tmp_name
, name
);
342 .word func @ behave as if you saw a ARM_32 reloc. */
344 #define ARM2THUMB_GLUE_SIZE 12
345 static const insn32 a2t1_ldr_insn
= 0xe59fc000;
346 static const insn32 a2t2_bx_r12_insn
= 0xe12fff1c;
347 static const insn32 a2t3_func_addr_insn
= 0x00000001;
349 /* Thumb->ARM: Thumb->(non-interworking aware) ARM
353 __func_from_thumb: __func_from_thumb:
355 nop ldr r6, __func_addr
357 __func_change_to_arm: bx r6
359 __func_back_to_thumb:
365 #define THUMB2ARM_GLUE_SIZE 8
366 static const insn16 t2a1_bx_pc_insn
= 0x4778;
367 static const insn16 t2a2_noop_insn
= 0x46c0;
368 static const insn32 t2a3_b_insn
= 0xea000000;
370 #ifndef ELFARM_NABI_C_INCLUDED
372 bfd_elf32_arm_allocate_interworking_sections (info
)
373 struct bfd_link_info
* info
;
377 struct elf32_arm_link_hash_table
* globals
;
379 globals
= elf32_arm_hash_table (info
);
381 BFD_ASSERT (globals
!= NULL
);
383 if (globals
->arm_glue_size
!= 0)
385 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
387 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
388 ARM2THUMB_GLUE_SECTION_NAME
);
390 BFD_ASSERT (s
!= NULL
);
392 foo
= (bfd_byte
*) bfd_alloc (globals
->bfd_of_glue_owner
,
393 globals
->arm_glue_size
);
395 s
->_raw_size
= s
->_cooked_size
= globals
->arm_glue_size
;
399 if (globals
->thumb_glue_size
!= 0)
401 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
403 s
= bfd_get_section_by_name
404 (globals
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
406 BFD_ASSERT (s
!= NULL
);
408 foo
= (bfd_byte
*) bfd_alloc (globals
->bfd_of_glue_owner
,
409 globals
->thumb_glue_size
);
411 s
->_raw_size
= s
->_cooked_size
= globals
->thumb_glue_size
;
419 record_arm_to_thumb_glue (link_info
, h
)
420 struct bfd_link_info
* link_info
;
421 struct elf_link_hash_entry
* h
;
423 const char * name
= h
->root
.root
.string
;
426 struct elf_link_hash_entry
* myh
;
427 struct bfd_link_hash_entry
* bh
;
428 struct elf32_arm_link_hash_table
* globals
;
431 globals
= elf32_arm_hash_table (link_info
);
433 BFD_ASSERT (globals
!= NULL
);
434 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
436 s
= bfd_get_section_by_name
437 (globals
->bfd_of_glue_owner
, ARM2THUMB_GLUE_SECTION_NAME
);
439 BFD_ASSERT (s
!= NULL
);
441 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
442 + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1);
444 BFD_ASSERT (tmp_name
);
446 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
448 myh
= elf_link_hash_lookup
449 (&(globals
)->root
, tmp_name
, FALSE
, FALSE
, TRUE
);
453 /* We've already seen this guy. */
458 /* The only trick here is using hash_table->arm_glue_size as the value. Even
459 though the section isn't allocated yet, this is where we will be putting
462 val
= globals
->arm_glue_size
+ 1;
463 _bfd_generic_link_add_one_symbol (link_info
, globals
->bfd_of_glue_owner
,
464 tmp_name
, BSF_GLOBAL
, s
, val
,
465 NULL
, TRUE
, FALSE
, &bh
);
469 globals
->arm_glue_size
+= ARM2THUMB_GLUE_SIZE
;
475 record_thumb_to_arm_glue (link_info
, h
)
476 struct bfd_link_info
*link_info
;
477 struct elf_link_hash_entry
*h
;
479 const char *name
= h
->root
.root
.string
;
482 struct elf_link_hash_entry
*myh
;
483 struct bfd_link_hash_entry
*bh
;
484 struct elf32_arm_link_hash_table
*hash_table
;
488 hash_table
= elf32_arm_hash_table (link_info
);
490 BFD_ASSERT (hash_table
!= NULL
);
491 BFD_ASSERT (hash_table
->bfd_of_glue_owner
!= NULL
);
493 s
= bfd_get_section_by_name
494 (hash_table
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
496 BFD_ASSERT (s
!= NULL
);
498 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
499 + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1);
501 BFD_ASSERT (tmp_name
);
503 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
505 myh
= elf_link_hash_lookup
506 (&(hash_table
)->root
, tmp_name
, FALSE
, FALSE
, TRUE
);
510 /* We've already seen this guy. */
516 val
= hash_table
->thumb_glue_size
+ 1;
517 _bfd_generic_link_add_one_symbol (link_info
, hash_table
->bfd_of_glue_owner
,
518 tmp_name
, BSF_GLOBAL
, s
, val
,
519 NULL
, TRUE
, FALSE
, &bh
);
521 /* If we mark it 'Thumb', the disassembler will do a better job. */
522 myh
= (struct elf_link_hash_entry
*) bh
;
523 bind
= ELF_ST_BIND (myh
->type
);
524 myh
->type
= ELF_ST_INFO (bind
, STT_ARM_TFUNC
);
528 #define CHANGE_TO_ARM "__%s_change_to_arm"
529 #define BACK_FROM_ARM "__%s_back_from_arm"
531 /* Allocate another symbol to mark where we switch to Arm mode. */
532 tmp_name
= (char *) bfd_malloc ((bfd_size_type
) strlen (name
)
533 + strlen (CHANGE_TO_ARM
) + 1);
535 BFD_ASSERT (tmp_name
);
537 sprintf (tmp_name
, CHANGE_TO_ARM
, name
);
540 val
= hash_table
->thumb_glue_size
+ 4,
541 _bfd_generic_link_add_one_symbol (link_info
, hash_table
->bfd_of_glue_owner
,
542 tmp_name
, BSF_LOCAL
, s
, val
,
543 NULL
, TRUE
, FALSE
, &bh
);
547 hash_table
->thumb_glue_size
+= THUMB2ARM_GLUE_SIZE
;
552 /* Add the glue sections to ABFD. This function is called from the
553 linker scripts in ld/emultempl/{armelf}.em. */
556 bfd_elf32_arm_add_glue_sections_to_bfd (abfd
, info
)
558 struct bfd_link_info
*info
;
563 /* If we are only performing a partial
564 link do not bother adding the glue. */
565 if (info
->relocateable
)
568 sec
= bfd_get_section_by_name (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
572 /* Note: we do not include the flag SEC_LINKER_CREATED, as this
573 will prevent elf_link_input_bfd() from processing the contents
575 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_CODE
| SEC_READONLY
;
577 sec
= bfd_make_section (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
580 || !bfd_set_section_flags (abfd
, sec
, flags
)
581 || !bfd_set_section_alignment (abfd
, sec
, 2))
584 /* Set the gc mark to prevent the section from being removed by garbage
585 collection, despite the fact that no relocs refer to this section. */
589 sec
= bfd_get_section_by_name (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
593 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_CODE
| SEC_READONLY
;
595 sec
= bfd_make_section (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
598 || !bfd_set_section_flags (abfd
, sec
, flags
)
599 || !bfd_set_section_alignment (abfd
, sec
, 2))
608 /* Select a BFD to be used to hold the sections used by the glue code.
609 This function is called from the linker scripts in ld/emultempl/
613 bfd_elf32_arm_get_bfd_for_interworking (abfd
, info
)
615 struct bfd_link_info
*info
;
617 struct elf32_arm_link_hash_table
*globals
;
619 /* If we are only performing a partial link
620 do not bother getting a bfd to hold the glue. */
621 if (info
->relocateable
)
624 globals
= elf32_arm_hash_table (info
);
626 BFD_ASSERT (globals
!= NULL
);
628 if (globals
->bfd_of_glue_owner
!= NULL
)
631 /* Save the bfd for later use. */
632 globals
->bfd_of_glue_owner
= abfd
;
638 bfd_elf32_arm_process_before_allocation (abfd
, link_info
, no_pipeline_knowledge
)
640 struct bfd_link_info
*link_info
;
641 int no_pipeline_knowledge
;
643 Elf_Internal_Shdr
*symtab_hdr
;
644 Elf_Internal_Rela
*internal_relocs
= NULL
;
645 Elf_Internal_Rela
*irel
, *irelend
;
646 bfd_byte
*contents
= NULL
;
649 struct elf32_arm_link_hash_table
*globals
;
651 /* If we are only performing a partial link do not bother
652 to construct any glue. */
653 if (link_info
->relocateable
)
656 /* Here we have a bfd that is to be included on the link. We have a hook
657 to do reloc rummaging, before section sizes are nailed down. */
658 globals
= elf32_arm_hash_table (link_info
);
660 BFD_ASSERT (globals
!= NULL
);
661 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
663 globals
->no_pipeline_knowledge
= no_pipeline_knowledge
;
665 /* Rummage around all the relocs and map the glue vectors. */
666 sec
= abfd
->sections
;
671 for (; sec
!= NULL
; sec
= sec
->next
)
673 if (sec
->reloc_count
== 0)
676 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
678 /* Load the relocs. */
680 = _bfd_elf32_link_read_relocs (abfd
, sec
, (PTR
) NULL
,
681 (Elf_Internal_Rela
*) NULL
, FALSE
);
683 if (internal_relocs
== NULL
)
686 irelend
= internal_relocs
+ sec
->reloc_count
;
687 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
690 unsigned long r_index
;
692 struct elf_link_hash_entry
*h
;
694 r_type
= ELF32_R_TYPE (irel
->r_info
);
695 r_index
= ELF32_R_SYM (irel
->r_info
);
697 /* These are the only relocation types we care about. */
698 if ( r_type
!= R_ARM_PC24
699 && r_type
!= R_ARM_THM_PC22
)
702 /* Get the section contents if we haven't done so already. */
703 if (contents
== NULL
)
705 /* Get cached copy if it exists. */
706 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
707 contents
= elf_section_data (sec
)->this_hdr
.contents
;
710 /* Go get them off disk. */
711 contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
712 if (contents
== NULL
)
715 if (!bfd_get_section_contents (abfd
, sec
, contents
,
716 (file_ptr
) 0, sec
->_raw_size
))
721 /* If the relocation is not against a symbol it cannot concern us. */
724 /* We don't care about local symbols. */
725 if (r_index
< symtab_hdr
->sh_info
)
728 /* This is an external symbol. */
729 r_index
-= symtab_hdr
->sh_info
;
730 h
= (struct elf_link_hash_entry
*)
731 elf_sym_hashes (abfd
)[r_index
];
733 /* If the relocation is against a static symbol it must be within
734 the current section and so cannot be a cross ARM/Thumb relocation. */
741 /* This one is a call from arm code. We need to look up
742 the target of the call. If it is a thumb target, we
744 if (ELF_ST_TYPE(h
->type
) == STT_ARM_TFUNC
)
745 record_arm_to_thumb_glue (link_info
, h
);
749 /* This one is a call from thumb code. We look
750 up the target of the call. If it is not a thumb
751 target, we insert glue. */
752 if (ELF_ST_TYPE (h
->type
) != STT_ARM_TFUNC
)
753 record_thumb_to_arm_glue (link_info
, h
);
762 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
766 if (internal_relocs
!= NULL
767 && elf_section_data (sec
)->relocs
!= internal_relocs
)
768 free (internal_relocs
);
769 internal_relocs
= NULL
;
776 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
778 if (internal_relocs
!= NULL
779 && elf_section_data (sec
)->relocs
!= internal_relocs
)
780 free (internal_relocs
);
786 /* The thumb form of a long branch is a bit finicky, because the offset
787 encoding is split over two fields, each in it's own instruction. They
788 can occur in any order. So given a thumb form of long branch, and an
789 offset, insert the offset into the thumb branch and return finished
792 It takes two thumb instructions to encode the target address. Each has
793 11 bits to invest. The upper 11 bits are stored in one (identifed by
794 H-0.. see below), the lower 11 bits are stored in the other (identified
797 Combine together and shifted left by 1 (it's a half word address) and
801 H-0, upper address-0 = 000
803 H-1, lower address-0 = 800
805 They can be ordered either way, but the arm tools I've seen always put
806 the lower one first. It probably doesn't matter. krk@cygnus.com
808 XXX: Actually the order does matter. The second instruction (H-1)
809 moves the computed address into the PC, so it must be the second one
810 in the sequence. The problem, however is that whilst little endian code
811 stores the instructions in HI then LOW order, big endian code does the
812 reverse. nickc@cygnus.com. */
814 #define LOW_HI_ORDER 0xF800F000
815 #define HI_LOW_ORDER 0xF000F800
818 insert_thumb_branch (br_insn
, rel_off
)
822 unsigned int low_bits
;
823 unsigned int high_bits
;
825 BFD_ASSERT ((rel_off
& 1) != 1);
827 rel_off
>>= 1; /* Half word aligned address. */
828 low_bits
= rel_off
& 0x000007FF; /* The bottom 11 bits. */
829 high_bits
= (rel_off
>> 11) & 0x000007FF; /* The top 11 bits. */
831 if ((br_insn
& LOW_HI_ORDER
) == LOW_HI_ORDER
)
832 br_insn
= LOW_HI_ORDER
| (low_bits
<< 16) | high_bits
;
833 else if ((br_insn
& HI_LOW_ORDER
) == HI_LOW_ORDER
)
834 br_insn
= HI_LOW_ORDER
| (high_bits
<< 16) | low_bits
;
836 /* FIXME: abort is probably not the right call. krk@cygnus.com */
837 abort (); /* error - not a valid branch instruction form. */
842 /* Thumb code calling an ARM function. */
845 elf32_thumb_to_arm_stub (info
, name
, input_bfd
, output_bfd
, input_section
,
846 hit_data
, sym_sec
, offset
, addend
, val
)
847 struct bfd_link_info
* info
;
851 asection
* input_section
;
855 bfd_signed_vma addend
;
860 unsigned long int tmp
;
862 struct elf_link_hash_entry
* myh
;
863 struct elf32_arm_link_hash_table
* globals
;
865 myh
= find_thumb_glue (info
, name
, input_bfd
);
869 globals
= elf32_arm_hash_table (info
);
871 BFD_ASSERT (globals
!= NULL
);
872 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
874 my_offset
= myh
->root
.u
.def
.value
;
876 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
877 THUMB2ARM_GLUE_SECTION_NAME
);
879 BFD_ASSERT (s
!= NULL
);
880 BFD_ASSERT (s
->contents
!= NULL
);
881 BFD_ASSERT (s
->output_section
!= NULL
);
883 if ((my_offset
& 0x01) == 0x01)
886 && sym_sec
->owner
!= NULL
887 && !INTERWORK_FLAG (sym_sec
->owner
))
889 (*_bfd_error_handler
)
890 (_("%s(%s): warning: interworking not enabled."),
891 bfd_archive_filename (sym_sec
->owner
), name
);
892 (*_bfd_error_handler
)
893 (_(" first occurrence: %s: thumb call to arm"),
894 bfd_archive_filename (input_bfd
));
900 myh
->root
.u
.def
.value
= my_offset
;
902 bfd_put_16 (output_bfd
, (bfd_vma
) t2a1_bx_pc_insn
,
903 s
->contents
+ my_offset
);
905 bfd_put_16 (output_bfd
, (bfd_vma
) t2a2_noop_insn
,
906 s
->contents
+ my_offset
+ 2);
909 /* Address of destination of the stub. */
910 ((bfd_signed_vma
) val
)
912 /* Offset from the start of the current section to the start of the stubs. */
914 /* Offset of the start of this stub from the start of the stubs. */
916 /* Address of the start of the current section. */
917 + s
->output_section
->vma
)
918 /* The branch instruction is 4 bytes into the stub. */
920 /* ARM branches work from the pc of the instruction + 8. */
923 bfd_put_32 (output_bfd
,
924 (bfd_vma
) t2a3_b_insn
| ((ret_offset
>> 2) & 0x00FFFFFF),
925 s
->contents
+ my_offset
+ 4);
928 BFD_ASSERT (my_offset
<= globals
->thumb_glue_size
);
930 /* Now go back and fix up the original BL insn to point
932 ret_offset
= (s
->output_offset
934 - (input_section
->output_offset
938 tmp
= bfd_get_32 (input_bfd
, hit_data
939 - input_section
->vma
);
941 bfd_put_32 (output_bfd
,
942 (bfd_vma
) insert_thumb_branch (tmp
, ret_offset
),
943 hit_data
- input_section
->vma
);
948 /* Arm code calling a Thumb function. */
951 elf32_arm_to_thumb_stub (info
, name
, input_bfd
, output_bfd
, input_section
,
952 hit_data
, sym_sec
, offset
, addend
, val
)
953 struct bfd_link_info
* info
;
957 asection
* input_section
;
961 bfd_signed_vma addend
;
964 unsigned long int tmp
;
968 struct elf_link_hash_entry
* myh
;
969 struct elf32_arm_link_hash_table
* globals
;
971 myh
= find_arm_glue (info
, name
, input_bfd
);
975 globals
= elf32_arm_hash_table (info
);
977 BFD_ASSERT (globals
!= NULL
);
978 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
980 my_offset
= myh
->root
.u
.def
.value
;
981 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
982 ARM2THUMB_GLUE_SECTION_NAME
);
983 BFD_ASSERT (s
!= NULL
);
984 BFD_ASSERT (s
->contents
!= NULL
);
985 BFD_ASSERT (s
->output_section
!= NULL
);
987 if ((my_offset
& 0x01) == 0x01)
990 && sym_sec
->owner
!= NULL
991 && !INTERWORK_FLAG (sym_sec
->owner
))
993 (*_bfd_error_handler
)
994 (_("%s(%s): warning: interworking not enabled."),
995 bfd_archive_filename (sym_sec
->owner
), name
);
996 (*_bfd_error_handler
)
997 (_(" first occurrence: %s: arm call to thumb"),
998 bfd_archive_filename (input_bfd
));
1002 myh
->root
.u
.def
.value
= my_offset
;
1004 bfd_put_32 (output_bfd
, (bfd_vma
) a2t1_ldr_insn
,
1005 s
->contents
+ my_offset
);
1007 bfd_put_32 (output_bfd
, (bfd_vma
) a2t2_bx_r12_insn
,
1008 s
->contents
+ my_offset
+ 4);
1010 /* It's a thumb address. Add the low order bit. */
1011 bfd_put_32 (output_bfd
, val
| a2t3_func_addr_insn
,
1012 s
->contents
+ my_offset
+ 8);
1015 BFD_ASSERT (my_offset
<= globals
->arm_glue_size
);
1017 tmp
= bfd_get_32 (input_bfd
, hit_data
);
1018 tmp
= tmp
& 0xFF000000;
1020 /* Somehow these are both 4 too far, so subtract 8. */
1021 ret_offset
= (s
->output_offset
1023 + s
->output_section
->vma
1024 - (input_section
->output_offset
1025 + input_section
->output_section
->vma
1029 tmp
= tmp
| ((ret_offset
>> 2) & 0x00FFFFFF);
1031 bfd_put_32 (output_bfd
, (bfd_vma
) tmp
, hit_data
- input_section
->vma
);
1036 /* Perform a relocation as part of a final link. */
1038 static bfd_reloc_status_type
1039 elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
1040 input_section
, contents
, rel
, value
,
1041 info
, sym_sec
, sym_name
, sym_flags
, h
)
1042 reloc_howto_type
* howto
;
1045 asection
* input_section
;
1046 bfd_byte
* contents
;
1047 Elf_Internal_Rela
* rel
;
1049 struct bfd_link_info
* info
;
1051 const char * sym_name
;
1053 struct elf_link_hash_entry
* h
;
1055 unsigned long r_type
= howto
->type
;
1056 unsigned long r_symndx
;
1057 bfd_byte
* hit_data
= contents
+ rel
->r_offset
;
1058 bfd
* dynobj
= NULL
;
1059 Elf_Internal_Shdr
* symtab_hdr
;
1060 struct elf_link_hash_entry
** sym_hashes
;
1061 bfd_vma
* local_got_offsets
;
1062 asection
* sgot
= NULL
;
1063 asection
* splt
= NULL
;
1064 asection
* sreloc
= NULL
;
1066 bfd_signed_vma signed_addend
;
1067 struct elf32_arm_link_hash_table
* globals
;
1069 /* If the start address has been set, then set the EF_ARM_HASENTRY
1070 flag. Setting this more than once is redundant, but the cost is
1071 not too high, and it keeps the code simple.
1073 The test is done here, rather than somewhere else, because the
1074 start address is only set just before the final link commences.
1076 Note - if the user deliberately sets a start address of 0, the
1077 flag will not be set. */
1078 if (bfd_get_start_address (output_bfd
) != 0)
1079 elf_elfheader (output_bfd
)->e_flags
|= EF_ARM_HASENTRY
;
1081 globals
= elf32_arm_hash_table (info
);
1083 dynobj
= elf_hash_table (info
)->dynobj
;
1086 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1087 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1089 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1090 sym_hashes
= elf_sym_hashes (input_bfd
);
1091 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1092 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1095 addend
= bfd_get_32 (input_bfd
, hit_data
) & howto
->src_mask
;
1097 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1100 signed_addend
&= ~ howto
->src_mask
;
1101 signed_addend
|= addend
;
1104 signed_addend
= addend
;
1106 addend
= signed_addend
= rel
->r_addend
;
1112 return bfd_reloc_ok
;
1120 /* When generating a shared object, these relocations are copied
1121 into the output file to be resolved at run time. */
1124 && (r_type
!= R_ARM_PC24
1127 && (! info
->symbolic
1128 || (h
->elf_link_hash_flags
1129 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1131 Elf_Internal_Rela outrel
;
1133 bfd_boolean skip
, relocate
;
1139 name
= (bfd_elf_string_from_elf_section
1141 elf_elfheader (input_bfd
)->e_shstrndx
,
1142 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1144 return bfd_reloc_notsupported
;
1146 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
1147 && strcmp (bfd_get_section_name (input_bfd
,
1151 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1152 BFD_ASSERT (sreloc
!= NULL
);
1159 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
1161 if (outrel
.r_offset
== (bfd_vma
) -1)
1163 else if (outrel
.r_offset
== (bfd_vma
) -2)
1164 skip
= TRUE
, relocate
= TRUE
;
1165 outrel
.r_offset
+= (input_section
->output_section
->vma
1166 + input_section
->output_offset
);
1169 memset (&outrel
, 0, sizeof outrel
);
1170 else if (r_type
== R_ARM_PC24
)
1172 BFD_ASSERT (h
!= NULL
&& h
->dynindx
!= -1);
1173 if ((input_section
->flags
& SEC_ALLOC
) == 0)
1175 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_PC24
);
1180 || ((info
->symbolic
|| h
->dynindx
== -1)
1181 && (h
->elf_link_hash_flags
1182 & ELF_LINK_HASH_DEF_REGULAR
) != 0))
1185 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1189 BFD_ASSERT (h
->dynindx
!= -1);
1190 if ((input_section
->flags
& SEC_ALLOC
) == 0)
1192 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_ABS32
);
1196 loc
= sreloc
->contents
;
1197 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rel
);
1198 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
1200 /* If this reloc is against an external symbol, we do not want to
1201 fiddle with the addend. Otherwise, we need to include the symbol
1202 value so that it becomes an addend for the dynamic reloc. */
1204 return bfd_reloc_ok
;
1206 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1207 contents
, rel
->r_offset
, value
,
1210 else switch (r_type
)
1213 case R_ARM_XPC25
: /* Arm BLX instruction. */
1215 case R_ARM_PC24
: /* Arm B/BL instruction */
1217 if (r_type
== R_ARM_XPC25
)
1219 /* Check for Arm calling Arm function. */
1220 /* FIXME: Should we translate the instruction into a BL
1221 instruction instead ? */
1222 if (sym_flags
!= STT_ARM_TFUNC
)
1223 (*_bfd_error_handler
) (_("\
1224 %s: Warning: Arm BLX instruction targets Arm function '%s'."),
1225 bfd_archive_filename (input_bfd
),
1226 h
? h
->root
.root
.string
: "(local)");
1231 /* Check for Arm calling Thumb function. */
1232 if (sym_flags
== STT_ARM_TFUNC
)
1234 elf32_arm_to_thumb_stub (info
, sym_name
, input_bfd
, output_bfd
,
1235 input_section
, hit_data
, sym_sec
, rel
->r_offset
,
1236 signed_addend
, value
);
1237 return bfd_reloc_ok
;
1241 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1242 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0)
1244 /* The old way of doing things. Trearing the addend as a
1245 byte sized field and adding in the pipeline offset. */
1246 value
-= (input_section
->output_section
->vma
1247 + input_section
->output_offset
);
1248 value
-= rel
->r_offset
;
1251 if (! globals
->no_pipeline_knowledge
)
1256 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
1258 S is the address of the symbol in the relocation.
1259 P is address of the instruction being relocated.
1260 A is the addend (extracted from the instruction) in bytes.
1262 S is held in 'value'.
1263 P is the base address of the section containing the instruction
1264 plus the offset of the reloc into that section, ie:
1265 (input_section->output_section->vma +
1266 input_section->output_offset +
1268 A is the addend, converted into bytes, ie:
1271 Note: None of these operations have knowledge of the pipeline
1272 size of the processor, thus it is up to the assembler to encode
1273 this information into the addend. */
1274 value
-= (input_section
->output_section
->vma
1275 + input_section
->output_offset
);
1276 value
-= rel
->r_offset
;
1277 value
+= (signed_addend
<< howto
->size
);
1279 /* Previous versions of this code also used to add in the pipeline
1280 offset here. This is wrong because the linker is not supposed
1281 to know about such things, and one day it might change. In order
1282 to support old binaries that need the old behaviour however, so
1283 we attempt to detect which ABI was used to create the reloc. */
1284 if (! globals
->no_pipeline_knowledge
)
1286 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form */
1288 i_ehdrp
= elf_elfheader (input_bfd
);
1290 if (i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1295 signed_addend
= value
;
1296 signed_addend
>>= howto
->rightshift
;
1298 /* It is not an error for an undefined weak reference to be
1299 out of range. Any program that branches to such a symbol
1300 is going to crash anyway, so there is no point worrying
1301 about getting the destination exactly right. */
1302 if (! h
|| h
->root
.type
!= bfd_link_hash_undefweak
)
1304 /* Perform a signed range check. */
1305 if ( signed_addend
> ((bfd_signed_vma
) (howto
->dst_mask
>> 1))
1306 || signed_addend
< - ((bfd_signed_vma
) ((howto
->dst_mask
+ 1) >> 1)))
1307 return bfd_reloc_overflow
;
1311 /* If necessary set the H bit in the BLX instruction. */
1312 if (r_type
== R_ARM_XPC25
&& ((value
& 2) == 2))
1313 value
= (signed_addend
& howto
->dst_mask
)
1314 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
))
1318 value
= (signed_addend
& howto
->dst_mask
)
1319 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1324 if (sym_flags
== STT_ARM_TFUNC
)
1329 value
-= (input_section
->output_section
->vma
1330 + input_section
->output_offset
+ rel
->r_offset
);
1335 bfd_put_32 (input_bfd
, value
, hit_data
);
1336 return bfd_reloc_ok
;
1340 if ((long) value
> 0x7f || (long) value
< -0x80)
1341 return bfd_reloc_overflow
;
1343 bfd_put_8 (input_bfd
, value
, hit_data
);
1344 return bfd_reloc_ok
;
1349 if ((long) value
> 0x7fff || (long) value
< -0x8000)
1350 return bfd_reloc_overflow
;
1352 bfd_put_16 (input_bfd
, value
, hit_data
);
1353 return bfd_reloc_ok
;
1356 /* Support ldr and str instruction for the arm */
1357 /* Also thumb b (unconditional branch). ??? Really? */
1360 if ((long) value
> 0x7ff || (long) value
< -0x800)
1361 return bfd_reloc_overflow
;
1363 value
|= (bfd_get_32 (input_bfd
, hit_data
) & 0xfffff000);
1364 bfd_put_32 (input_bfd
, value
, hit_data
);
1365 return bfd_reloc_ok
;
1367 case R_ARM_THM_ABS5
:
1368 /* Support ldr and str instructions for the thumb. */
1370 /* Need to refetch addend. */
1371 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1372 /* ??? Need to determine shift amount from operand size. */
1373 addend
>>= howto
->rightshift
;
1377 /* ??? Isn't value unsigned? */
1378 if ((long) value
> 0x1f || (long) value
< -0x10)
1379 return bfd_reloc_overflow
;
1381 /* ??? Value needs to be properly shifted into place first. */
1382 value
|= bfd_get_16 (input_bfd
, hit_data
) & 0xf83f;
1383 bfd_put_16 (input_bfd
, value
, hit_data
);
1384 return bfd_reloc_ok
;
1387 case R_ARM_THM_XPC22
:
1389 case R_ARM_THM_PC22
:
1390 /* Thumb BL (branch long instruction). */
1393 bfd_boolean overflow
= FALSE
;
1394 bfd_vma upper_insn
= bfd_get_16 (input_bfd
, hit_data
);
1395 bfd_vma lower_insn
= bfd_get_16 (input_bfd
, hit_data
+ 2);
1396 bfd_signed_vma reloc_signed_max
= ((1 << (howto
->bitsize
- 1)) - 1) >> howto
->rightshift
;
1397 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1399 bfd_signed_vma signed_check
;
1402 /* Need to refetch the addend and squish the two 11 bit pieces
1405 bfd_vma upper
= upper_insn
& 0x7ff;
1406 bfd_vma lower
= lower_insn
& 0x7ff;
1407 upper
= (upper
^ 0x400) - 0x400; /* Sign extend. */
1408 addend
= (upper
<< 12) | (lower
<< 1);
1409 signed_addend
= addend
;
1413 if (r_type
== R_ARM_THM_XPC22
)
1415 /* Check for Thumb to Thumb call. */
1416 /* FIXME: Should we translate the instruction into a BL
1417 instruction instead ? */
1418 if (sym_flags
== STT_ARM_TFUNC
)
1419 (*_bfd_error_handler
) (_("\
1420 %s: Warning: Thumb BLX instruction targets thumb function '%s'."),
1421 bfd_archive_filename (input_bfd
),
1422 h
? h
->root
.root
.string
: "(local)");
1427 /* If it is not a call to Thumb, assume call to Arm.
1428 If it is a call relative to a section name, then it is not a
1429 function call at all, but rather a long jump. */
1430 if (sym_flags
!= STT_ARM_TFUNC
&& sym_flags
!= STT_SECTION
)
1432 if (elf32_thumb_to_arm_stub
1433 (info
, sym_name
, input_bfd
, output_bfd
, input_section
,
1434 hit_data
, sym_sec
, rel
->r_offset
, signed_addend
, value
))
1435 return bfd_reloc_ok
;
1437 return bfd_reloc_dangerous
;
1441 relocation
= value
+ signed_addend
;
1443 relocation
-= (input_section
->output_section
->vma
1444 + input_section
->output_offset
1447 if (! globals
->no_pipeline_knowledge
)
1449 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form. */
1451 i_ehdrp
= elf_elfheader (input_bfd
);
1453 /* Previous versions of this code also used to add in the pipline
1454 offset here. This is wrong because the linker is not supposed
1455 to know about such things, and one day it might change. In order
1456 to support old binaries that need the old behaviour however, so
1457 we attempt to detect which ABI was used to create the reloc. */
1458 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1459 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0
1460 || i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1464 check
= relocation
>> howto
->rightshift
;
1466 /* If this is a signed value, the rightshift just dropped
1467 leading 1 bits (assuming twos complement). */
1468 if ((bfd_signed_vma
) relocation
>= 0)
1469 signed_check
= check
;
1471 signed_check
= check
| ~((bfd_vma
) -1 >> howto
->rightshift
);
1473 /* Assumes two's complement. */
1474 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1478 if (r_type
== R_ARM_THM_XPC22
1479 && ((lower_insn
& 0x1800) == 0x0800))
1480 /* For a BLX instruction, make sure that the relocation is rounded up
1481 to a word boundary. This follows the semantics of the instruction
1482 which specifies that bit 1 of the target address will come from bit
1483 1 of the base address. */
1484 relocation
= (relocation
+ 2) & ~ 3;
1486 /* Put RELOCATION back into the insn. */
1487 upper_insn
= (upper_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 12) & 0x7ff);
1488 lower_insn
= (lower_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 1) & 0x7ff);
1490 /* Put the relocated value back in the object file: */
1491 bfd_put_16 (input_bfd
, upper_insn
, hit_data
);
1492 bfd_put_16 (input_bfd
, lower_insn
, hit_data
+ 2);
1494 return (overflow
? bfd_reloc_overflow
: bfd_reloc_ok
);
1498 case R_ARM_THM_PC11
:
1499 /* Thumb B (branch) instruction). */
1501 bfd_signed_vma relocation
;
1502 bfd_signed_vma reloc_signed_max
= (1 << (howto
->bitsize
- 1)) - 1;
1503 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1504 bfd_signed_vma signed_check
;
1507 /* Need to refetch addend. */
1508 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1509 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1512 signed_addend
&= ~ howto
->src_mask
;
1513 signed_addend
|= addend
;
1516 signed_addend
= addend
;
1517 /* The value in the insn has been right shifted. We need to
1518 undo this, so that we can perform the address calculation
1519 in terms of bytes. */
1520 signed_addend
<<= howto
->rightshift
;
1522 relocation
= value
+ signed_addend
;
1524 relocation
-= (input_section
->output_section
->vma
1525 + input_section
->output_offset
1528 relocation
>>= howto
->rightshift
;
1529 signed_check
= relocation
;
1530 relocation
&= howto
->dst_mask
;
1531 relocation
|= (bfd_get_16 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1533 bfd_put_16 (input_bfd
, relocation
, hit_data
);
1535 /* Assumes two's complement. */
1536 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1537 return bfd_reloc_overflow
;
1539 return bfd_reloc_ok
;
1542 case R_ARM_GNU_VTINHERIT
:
1543 case R_ARM_GNU_VTENTRY
:
1544 return bfd_reloc_ok
;
1547 return bfd_reloc_notsupported
;
1549 case R_ARM_GLOB_DAT
:
1550 return bfd_reloc_notsupported
;
1552 case R_ARM_JUMP_SLOT
:
1553 return bfd_reloc_notsupported
;
1555 case R_ARM_RELATIVE
:
1556 return bfd_reloc_notsupported
;
1559 /* Relocation is relative to the start of the
1560 global offset table. */
1562 BFD_ASSERT (sgot
!= NULL
);
1564 return bfd_reloc_notsupported
;
1566 /* If we are addressing a Thumb function, we need to adjust the
1567 address by one, so that attempts to call the function pointer will
1568 correctly interpret it as Thumb code. */
1569 if (sym_flags
== STT_ARM_TFUNC
)
1572 /* Note that sgot->output_offset is not involved in this
1573 calculation. We always want the start of .got. If we
1574 define _GLOBAL_OFFSET_TABLE in a different way, as is
1575 permitted by the ABI, we might have to change this
1577 value
-= sgot
->output_section
->vma
;
1578 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1579 contents
, rel
->r_offset
, value
,
1583 /* Use global offset table as symbol value. */
1584 BFD_ASSERT (sgot
!= NULL
);
1587 return bfd_reloc_notsupported
;
1589 value
= sgot
->output_section
->vma
;
1590 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1591 contents
, rel
->r_offset
, value
,
1595 /* Relocation is to the entry for this symbol in the
1596 global offset table. */
1598 return bfd_reloc_notsupported
;
1604 off
= h
->got
.offset
;
1605 BFD_ASSERT (off
!= (bfd_vma
) -1);
1607 if (!elf_hash_table (info
)->dynamic_sections_created
||
1608 (info
->shared
&& (info
->symbolic
|| h
->dynindx
== -1)
1609 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1611 /* This is actually a static link, or it is a -Bsymbolic link
1612 and the symbol is defined locally. We must initialize this
1613 entry in the global offset table. Since the offset must
1614 always be a multiple of 4, we use the least significant bit
1615 to record whether we have initialized it already.
1617 When doing a dynamic link, we create a .rel.got relocation
1618 entry to initialize the value. This is done in the
1619 finish_dynamic_symbol routine. */
1624 /* If we are addressing a Thumb function, we need to
1625 adjust the address by one, so that attempts to
1626 call the function pointer will correctly
1627 interpret it as Thumb code. */
1628 if (sym_flags
== STT_ARM_TFUNC
)
1631 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1636 value
= sgot
->output_offset
+ off
;
1642 BFD_ASSERT (local_got_offsets
!= NULL
&&
1643 local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1645 off
= local_got_offsets
[r_symndx
];
1647 /* The offset must always be a multiple of 4. We use the
1648 least significant bit to record whether we have already
1649 generated the necessary reloc. */
1654 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1659 Elf_Internal_Rela outrel
;
1662 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
1663 BFD_ASSERT (srelgot
!= NULL
);
1665 outrel
.r_offset
= (sgot
->output_section
->vma
1666 + sgot
->output_offset
1668 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1669 loc
= srelgot
->contents
;
1670 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rel
);
1671 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
, loc
);
1674 local_got_offsets
[r_symndx
] |= 1;
1677 value
= sgot
->output_offset
+ off
;
1680 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1681 contents
, rel
->r_offset
, value
,
1685 /* Relocation is to the entry for this symbol in the
1686 procedure linkage table. */
1688 /* Resolve a PLT32 reloc against a local symbol directly,
1689 without using the procedure linkage table. */
1691 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1692 contents
, rel
->r_offset
, value
,
1695 if (h
->plt
.offset
== (bfd_vma
) -1)
1696 /* We didn't make a PLT entry for this symbol. This
1697 happens when statically linking PIC code, or when
1698 using -Bsymbolic. */
1699 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1700 contents
, rel
->r_offset
, value
,
1703 BFD_ASSERT(splt
!= NULL
);
1705 return bfd_reloc_notsupported
;
1707 value
= (splt
->output_section
->vma
1708 + splt
->output_offset
1710 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1711 contents
, rel
->r_offset
, value
,
1715 return bfd_reloc_notsupported
;
1717 case R_ARM_AMP_VCALL9
:
1718 return bfd_reloc_notsupported
;
1720 case R_ARM_RSBREL32
:
1721 return bfd_reloc_notsupported
;
1723 case R_ARM_THM_RPC22
:
1724 return bfd_reloc_notsupported
;
1727 return bfd_reloc_notsupported
;
1730 return bfd_reloc_notsupported
;
1733 return bfd_reloc_notsupported
;
1736 return bfd_reloc_notsupported
;
1739 return bfd_reloc_notsupported
;
1744 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
1746 arm_add_to_rel (abfd
, address
, howto
, increment
)
1749 reloc_howto_type
* howto
;
1750 bfd_signed_vma increment
;
1752 bfd_signed_vma addend
;
1754 if (howto
->type
== R_ARM_THM_PC22
)
1756 int upper_insn
, lower_insn
;
1759 upper_insn
= bfd_get_16 (abfd
, address
);
1760 lower_insn
= bfd_get_16 (abfd
, address
+ 2);
1761 upper
= upper_insn
& 0x7ff;
1762 lower
= lower_insn
& 0x7ff;
1764 addend
= (upper
<< 12) | (lower
<< 1);
1765 addend
+= increment
;
1768 upper_insn
= (upper_insn
& 0xf800) | ((addend
>> 11) & 0x7ff);
1769 lower_insn
= (lower_insn
& 0xf800) | (addend
& 0x7ff);
1771 bfd_put_16 (abfd
, (bfd_vma
) upper_insn
, address
);
1772 bfd_put_16 (abfd
, (bfd_vma
) lower_insn
, address
+ 2);
1778 contents
= bfd_get_32 (abfd
, address
);
1780 /* Get the (signed) value from the instruction. */
1781 addend
= contents
& howto
->src_mask
;
1782 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1784 bfd_signed_vma mask
;
1787 mask
&= ~ howto
->src_mask
;
1791 /* Add in the increment, (which is a byte value). */
1792 switch (howto
->type
)
1795 addend
+= increment
;
1799 addend
<<= howto
->size
;
1800 addend
+= increment
;
1802 /* Should we check for overflow here ? */
1804 /* Drop any undesired bits. */
1805 addend
>>= howto
->rightshift
;
1809 contents
= (contents
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
1811 bfd_put_32 (abfd
, contents
, address
);
1814 #endif /* USE_REL */
1816 /* Relocate an ARM ELF section. */
1818 elf32_arm_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1819 contents
, relocs
, local_syms
, local_sections
)
1821 struct bfd_link_info
*info
;
1823 asection
*input_section
;
1825 Elf_Internal_Rela
*relocs
;
1826 Elf_Internal_Sym
*local_syms
;
1827 asection
**local_sections
;
1829 Elf_Internal_Shdr
*symtab_hdr
;
1830 struct elf_link_hash_entry
**sym_hashes
;
1831 Elf_Internal_Rela
*rel
;
1832 Elf_Internal_Rela
*relend
;
1836 if (info
->relocateable
)
1840 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1841 sym_hashes
= elf_sym_hashes (input_bfd
);
1844 relend
= relocs
+ input_section
->reloc_count
;
1845 for (; rel
< relend
; rel
++)
1848 reloc_howto_type
* howto
;
1849 unsigned long r_symndx
;
1850 Elf_Internal_Sym
* sym
;
1852 struct elf_link_hash_entry
* h
;
1854 bfd_reloc_status_type r
;
1857 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1858 r_type
= ELF32_R_TYPE (rel
->r_info
);
1860 if ( r_type
== R_ARM_GNU_VTENTRY
1861 || r_type
== R_ARM_GNU_VTINHERIT
)
1864 elf32_arm_info_to_howto (input_bfd
, & bfd_reloc
, rel
);
1865 howto
= bfd_reloc
.howto
;
1868 if (info
->relocateable
)
1870 /* This is a relocateable link. We don't have to change
1871 anything, unless the reloc is against a section symbol,
1872 in which case we have to adjust according to where the
1873 section symbol winds up in the output section. */
1874 if (r_symndx
< symtab_hdr
->sh_info
)
1876 sym
= local_syms
+ r_symndx
;
1877 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1879 sec
= local_sections
[r_symndx
];
1880 arm_add_to_rel (input_bfd
, contents
+ rel
->r_offset
,
1882 (bfd_signed_vma
) (sec
->output_offset
1891 /* This is a final link. */
1896 if (r_symndx
< symtab_hdr
->sh_info
)
1898 sym
= local_syms
+ r_symndx
;
1899 sec
= local_sections
[r_symndx
];
1901 relocation
= (sec
->output_section
->vma
1902 + sec
->output_offset
1904 if ((sec
->flags
& SEC_MERGE
)
1905 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1908 bfd_vma addend
, value
;
1910 if (howto
->rightshift
)
1912 (*_bfd_error_handler
)
1913 (_("%s(%s+0x%lx): %s relocation against SEC_MERGE section"),
1914 bfd_archive_filename (input_bfd
),
1915 bfd_get_section_name (input_bfd
, input_section
),
1916 (long) rel
->r_offset
, howto
->name
);
1920 value
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1922 /* Get the (signed) value from the instruction. */
1923 addend
= value
& howto
->src_mask
;
1924 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1926 bfd_signed_vma mask
;
1929 mask
&= ~ howto
->src_mask
;
1934 _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
)
1936 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
1937 value
= (value
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
1938 bfd_put_32 (input_bfd
, value
, contents
+ rel
->r_offset
);
1941 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, sec
, rel
);
1946 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1948 while ( h
->root
.type
== bfd_link_hash_indirect
1949 || h
->root
.type
== bfd_link_hash_warning
)
1950 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1952 if ( h
->root
.type
== bfd_link_hash_defined
1953 || h
->root
.type
== bfd_link_hash_defweak
)
1955 int relocation_needed
= 1;
1957 sec
= h
->root
.u
.def
.section
;
1959 /* In these cases, we don't need the relocation value.
1960 We check specially because in some obscure cases
1961 sec->output_section will be NULL. */
1966 case R_ARM_THM_PC22
:
1969 (!info
->symbolic
&& h
->dynindx
!= -1)
1970 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1972 && ((input_section
->flags
& SEC_ALLOC
) != 0
1973 /* DWARF will emit R_ARM_ABS32 relocations in its
1974 sections against symbols defined externally
1975 in shared libraries. We can't do anything
1977 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
1978 && (h
->elf_link_hash_flags
1979 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
1981 relocation_needed
= 0;
1985 relocation_needed
= 0;
1989 if (elf_hash_table(info
)->dynamic_sections_created
1991 || (!info
->symbolic
&& h
->dynindx
!= -1)
1992 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1995 relocation_needed
= 0;
1999 if (h
->plt
.offset
!= (bfd_vma
)-1)
2000 relocation_needed
= 0;
2004 if (sec
->output_section
== NULL
)
2006 (*_bfd_error_handler
)
2007 (_("%s: warning: unresolvable relocation %d against symbol `%s' from %s section"),
2008 bfd_archive_filename (input_bfd
),
2010 h
->root
.root
.string
,
2011 bfd_get_section_name (input_bfd
, input_section
));
2012 relocation_needed
= 0;
2016 if (relocation_needed
)
2017 relocation
= h
->root
.u
.def
.value
2018 + sec
->output_section
->vma
2019 + sec
->output_offset
;
2023 else if (h
->root
.type
== bfd_link_hash_undefweak
)
2025 else if (info
->shared
&& !info
->symbolic
2026 && !info
->no_undefined
2027 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
2031 if (!((*info
->callbacks
->undefined_symbol
)
2032 (info
, h
->root
.root
.string
, input_bfd
,
2033 input_section
, rel
->r_offset
,
2034 (!info
->shared
|| info
->no_undefined
2035 || ELF_ST_VISIBILITY (h
->other
)))))
2042 name
= h
->root
.root
.string
;
2045 name
= (bfd_elf_string_from_elf_section
2046 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2047 if (name
== NULL
|| *name
== '\0')
2048 name
= bfd_section_name (input_bfd
, sec
);
2051 r
= elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
2052 input_section
, contents
, rel
,
2053 relocation
, info
, sec
, name
,
2054 (h
? ELF_ST_TYPE (h
->type
) :
2055 ELF_ST_TYPE (sym
->st_info
)), h
);
2057 if (r
!= bfd_reloc_ok
)
2059 const char * msg
= (const char *) 0;
2063 case bfd_reloc_overflow
:
2064 /* If the overflowing reloc was to an undefined symbol,
2065 we have already printed one error message and there
2066 is no point complaining again. */
2068 h
->root
.type
!= bfd_link_hash_undefined
)
2069 && (!((*info
->callbacks
->reloc_overflow
)
2070 (info
, name
, howto
->name
, (bfd_vma
) 0,
2071 input_bfd
, input_section
, rel
->r_offset
))))
2075 case bfd_reloc_undefined
:
2076 if (!((*info
->callbacks
->undefined_symbol
)
2077 (info
, name
, input_bfd
, input_section
,
2078 rel
->r_offset
, TRUE
)))
2082 case bfd_reloc_outofrange
:
2083 msg
= _("internal error: out of range error");
2086 case bfd_reloc_notsupported
:
2087 msg
= _("internal error: unsupported relocation error");
2090 case bfd_reloc_dangerous
:
2091 msg
= _("internal error: dangerous error");
2095 msg
= _("internal error: unknown error");
2099 if (!((*info
->callbacks
->warning
)
2100 (info
, msg
, name
, input_bfd
, input_section
,
2111 /* Function to keep ARM specific flags in the ELF header. */
2113 elf32_arm_set_private_flags (abfd
, flags
)
2117 if (elf_flags_init (abfd
)
2118 && elf_elfheader (abfd
)->e_flags
!= flags
)
2120 if (EF_ARM_EABI_VERSION (flags
) == EF_ARM_EABI_UNKNOWN
)
2122 if (flags
& EF_ARM_INTERWORK
)
2123 (*_bfd_error_handler
) (_("\
2124 Warning: Not setting interworking flag of %s since it has already been specified as non-interworking"),
2125 bfd_archive_filename (abfd
));
2127 _bfd_error_handler (_("\
2128 Warning: Clearing the interworking flag of %s due to outside request"),
2129 bfd_archive_filename (abfd
));
2134 elf_elfheader (abfd
)->e_flags
= flags
;
2135 elf_flags_init (abfd
) = TRUE
;
2141 /* Copy backend specific data from one object module to another. */
2144 elf32_arm_copy_private_bfd_data (ibfd
, obfd
)
2151 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2152 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2155 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2156 out_flags
= elf_elfheader (obfd
)->e_flags
;
2158 if (elf_flags_init (obfd
)
2159 && EF_ARM_EABI_VERSION (out_flags
) == EF_ARM_EABI_UNKNOWN
2160 && in_flags
!= out_flags
)
2162 /* Cannot mix APCS26 and APCS32 code. */
2163 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2166 /* Cannot mix float APCS and non-float APCS code. */
2167 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2170 /* If the src and dest have different interworking flags
2171 then turn off the interworking bit. */
2172 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2174 if (out_flags
& EF_ARM_INTERWORK
)
2175 _bfd_error_handler (_("\
2176 Warning: Clearing the interworking flag of %s because non-interworking code in %s has been linked with it"),
2177 bfd_get_filename (obfd
),
2178 bfd_archive_filename (ibfd
));
2180 in_flags
&= ~EF_ARM_INTERWORK
;
2183 /* Likewise for PIC, though don't warn for this case. */
2184 if ((in_flags
& EF_ARM_PIC
) != (out_flags
& EF_ARM_PIC
))
2185 in_flags
&= ~EF_ARM_PIC
;
2188 elf_elfheader (obfd
)->e_flags
= in_flags
;
2189 elf_flags_init (obfd
) = TRUE
;
2194 /* Merge backend specific data from an object file to the output
2195 object file when linking. */
2198 elf32_arm_merge_private_bfd_data (ibfd
, obfd
)
2204 bfd_boolean flags_compatible
= TRUE
;
2205 bfd_boolean null_input_bfd
= TRUE
;
2208 /* Check if we have the same endianess. */
2209 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
2212 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2213 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2216 /* The input BFD must have had its flags initialised. */
2217 /* The following seems bogus to me -- The flags are initialized in
2218 the assembler but I don't think an elf_flags_init field is
2219 written into the object. */
2220 /* BFD_ASSERT (elf_flags_init (ibfd)); */
2222 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2223 out_flags
= elf_elfheader (obfd
)->e_flags
;
2225 if (!elf_flags_init (obfd
))
2227 /* If the input is the default architecture and had the default
2228 flags then do not bother setting the flags for the output
2229 architecture, instead allow future merges to do this. If no
2230 future merges ever set these flags then they will retain their
2231 uninitialised values, which surprise surprise, correspond
2232 to the default values. */
2233 if (bfd_get_arch_info (ibfd
)->the_default
2234 && elf_elfheader (ibfd
)->e_flags
== 0)
2237 elf_flags_init (obfd
) = TRUE
;
2238 elf_elfheader (obfd
)->e_flags
= in_flags
;
2240 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
2241 && bfd_get_arch_info (obfd
)->the_default
)
2242 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
), bfd_get_mach (ibfd
));
2247 /* Identical flags must be compatible. */
2248 if (in_flags
== out_flags
)
2251 /* Check to see if the input BFD actually contains any sections.
2252 If not, its flags may not have been initialised either, but it cannot
2253 actually cause any incompatibility. */
2254 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2256 /* Ignore synthetic glue sections. */
2257 if (strcmp (sec
->name
, ".glue_7")
2258 && strcmp (sec
->name
, ".glue_7t"))
2260 null_input_bfd
= FALSE
;
2267 /* Complain about various flag mismatches. */
2268 if (EF_ARM_EABI_VERSION (in_flags
) != EF_ARM_EABI_VERSION (out_flags
))
2270 _bfd_error_handler (_("\
2271 ERROR: %s is compiled for EABI version %d, whereas %s is compiled for version %d"),
2272 bfd_archive_filename (ibfd
),
2273 (in_flags
& EF_ARM_EABIMASK
) >> 24,
2274 bfd_get_filename (obfd
),
2275 (out_flags
& EF_ARM_EABIMASK
) >> 24);
2279 /* Not sure what needs to be checked for EABI versions >= 1. */
2280 if (EF_ARM_EABI_VERSION (in_flags
) == EF_ARM_EABI_UNKNOWN
)
2282 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2284 _bfd_error_handler (_("\
2285 ERROR: %s is compiled for APCS-%d, whereas target %s uses APCS-%d"),
2286 bfd_archive_filename (ibfd
),
2287 in_flags
& EF_ARM_APCS_26
? 26 : 32,
2288 bfd_get_filename (obfd
),
2289 out_flags
& EF_ARM_APCS_26
? 26 : 32);
2290 flags_compatible
= FALSE
;
2293 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2295 if (in_flags
& EF_ARM_APCS_FLOAT
)
2296 _bfd_error_handler (_("\
2297 ERROR: %s passes floats in float registers, whereas %s passes them in integer registers"),
2298 bfd_archive_filename (ibfd
),
2299 bfd_get_filename (obfd
));
2301 _bfd_error_handler (_("\
2302 ERROR: %s passes floats in integer registers, whereas %s passes them in float registers"),
2303 bfd_archive_filename (ibfd
),
2304 bfd_get_filename (obfd
));
2306 flags_compatible
= FALSE
;
2309 if ((in_flags
& EF_ARM_VFP_FLOAT
) != (out_flags
& EF_ARM_VFP_FLOAT
))
2311 if (in_flags
& EF_ARM_VFP_FLOAT
)
2312 _bfd_error_handler (_("\
2313 ERROR: %s uses VFP instructions, whereas %s does not"),
2314 bfd_archive_filename (ibfd
),
2315 bfd_get_filename (obfd
));
2317 _bfd_error_handler (_("\
2318 ERROR: %s uses FPA instructions, whereas %s does not"),
2319 bfd_archive_filename (ibfd
),
2320 bfd_get_filename (obfd
));
2322 flags_compatible
= FALSE
;
2325 if ((in_flags
& EF_ARM_MAVERICK_FLOAT
) != (out_flags
& EF_ARM_MAVERICK_FLOAT
))
2327 if (in_flags
& EF_ARM_MAVERICK_FLOAT
)
2328 _bfd_error_handler (_("\
2329 ERROR: %s uses Maverick instructions, whereas %s does not"),
2330 bfd_archive_filename (ibfd
),
2331 bfd_get_filename (obfd
));
2333 _bfd_error_handler (_("\
2334 ERROR: %s uses Maverick instructions, whereas %s does not"),
2335 bfd_archive_filename (ibfd
),
2336 bfd_get_filename (obfd
));
2338 flags_compatible
= FALSE
;
2341 #ifdef EF_ARM_SOFT_FLOAT
2342 if ((in_flags
& EF_ARM_SOFT_FLOAT
) != (out_flags
& EF_ARM_SOFT_FLOAT
))
2344 /* We can allow interworking between code that is VFP format
2345 layout, and uses either soft float or integer regs for
2346 passing floating point arguments and results. We already
2347 know that the APCS_FLOAT flags match; similarly for VFP
2349 if ((in_flags
& EF_ARM_APCS_FLOAT
) != 0
2350 || (in_flags
& EF_ARM_VFP_FLOAT
) == 0)
2352 if (in_flags
& EF_ARM_SOFT_FLOAT
)
2353 _bfd_error_handler (_("\
2354 ERROR: %s uses software FP, whereas %s uses hardware FP"),
2355 bfd_archive_filename (ibfd
),
2356 bfd_get_filename (obfd
));
2358 _bfd_error_handler (_("\
2359 ERROR: %s uses hardware FP, whereas %s uses software FP"),
2360 bfd_archive_filename (ibfd
),
2361 bfd_get_filename (obfd
));
2363 flags_compatible
= FALSE
;
2368 /* Interworking mismatch is only a warning. */
2369 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2371 if (in_flags
& EF_ARM_INTERWORK
)
2373 _bfd_error_handler (_("\
2374 Warning: %s supports interworking, whereas %s does not"),
2375 bfd_archive_filename (ibfd
),
2376 bfd_get_filename (obfd
));
2380 _bfd_error_handler (_("\
2381 Warning: %s does not support interworking, whereas %s does"),
2382 bfd_archive_filename (ibfd
),
2383 bfd_get_filename (obfd
));
2388 return flags_compatible
;
2391 /* Display the flags field. */
2394 elf32_arm_print_private_bfd_data (abfd
, ptr
)
2398 FILE * file
= (FILE *) ptr
;
2399 unsigned long flags
;
2401 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
2403 /* Print normal ELF private data. */
2404 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
2406 flags
= elf_elfheader (abfd
)->e_flags
;
2407 /* Ignore init flag - it may not be set, despite the flags field
2408 containing valid data. */
2410 /* xgettext:c-format */
2411 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
2413 switch (EF_ARM_EABI_VERSION (flags
))
2415 case EF_ARM_EABI_UNKNOWN
:
2416 /* The following flag bits are GNU extenstions and not part of the
2417 official ARM ELF extended ABI. Hence they are only decoded if
2418 the EABI version is not set. */
2419 if (flags
& EF_ARM_INTERWORK
)
2420 fprintf (file
, _(" [interworking enabled]"));
2422 if (flags
& EF_ARM_APCS_26
)
2423 fprintf (file
, " [APCS-26]");
2425 fprintf (file
, " [APCS-32]");
2427 if (flags
& EF_ARM_VFP_FLOAT
)
2428 fprintf (file
, _(" [VFP float format]"));
2429 else if (flags
& EF_ARM_MAVERICK_FLOAT
)
2430 fprintf (file
, _(" [Maverick float format]"));
2432 fprintf (file
, _(" [FPA float format]"));
2434 if (flags
& EF_ARM_APCS_FLOAT
)
2435 fprintf (file
, _(" [floats passed in float registers]"));
2437 if (flags
& EF_ARM_PIC
)
2438 fprintf (file
, _(" [position independent]"));
2440 if (flags
& EF_ARM_NEW_ABI
)
2441 fprintf (file
, _(" [new ABI]"));
2443 if (flags
& EF_ARM_OLD_ABI
)
2444 fprintf (file
, _(" [old ABI]"));
2446 if (flags
& EF_ARM_SOFT_FLOAT
)
2447 fprintf (file
, _(" [software FP]"));
2449 flags
&= ~(EF_ARM_INTERWORK
| EF_ARM_APCS_26
| EF_ARM_APCS_FLOAT
2450 | EF_ARM_PIC
| EF_ARM_NEW_ABI
| EF_ARM_OLD_ABI
2451 | EF_ARM_SOFT_FLOAT
| EF_ARM_VFP_FLOAT
2452 | EF_ARM_MAVERICK_FLOAT
);
2455 case EF_ARM_EABI_VER1
:
2456 fprintf (file
, _(" [Version1 EABI]"));
2458 if (flags
& EF_ARM_SYMSARESORTED
)
2459 fprintf (file
, _(" [sorted symbol table]"));
2461 fprintf (file
, _(" [unsorted symbol table]"));
2463 flags
&= ~ EF_ARM_SYMSARESORTED
;
2466 case EF_ARM_EABI_VER2
:
2467 fprintf (file
, _(" [Version2 EABI]"));
2469 if (flags
& EF_ARM_SYMSARESORTED
)
2470 fprintf (file
, _(" [sorted symbol table]"));
2472 fprintf (file
, _(" [unsorted symbol table]"));
2474 if (flags
& EF_ARM_DYNSYMSUSESEGIDX
)
2475 fprintf (file
, _(" [dynamic symbols use segment index]"));
2477 if (flags
& EF_ARM_MAPSYMSFIRST
)
2478 fprintf (file
, _(" [mapping symbols precede others]"));
2480 flags
&= ~(EF_ARM_SYMSARESORTED
| EF_ARM_DYNSYMSUSESEGIDX
2481 | EF_ARM_MAPSYMSFIRST
);
2485 fprintf (file
, _(" <EABI version unrecognised>"));
2489 flags
&= ~ EF_ARM_EABIMASK
;
2491 if (flags
& EF_ARM_RELEXEC
)
2492 fprintf (file
, _(" [relocatable executable]"));
2494 if (flags
& EF_ARM_HASENTRY
)
2495 fprintf (file
, _(" [has entry point]"));
2497 flags
&= ~ (EF_ARM_RELEXEC
| EF_ARM_HASENTRY
);
2500 fprintf (file
, _("<Unrecognised flag bits set>"));
2508 elf32_arm_get_symbol_type (elf_sym
, type
)
2509 Elf_Internal_Sym
* elf_sym
;
2512 switch (ELF_ST_TYPE (elf_sym
->st_info
))
2515 return ELF_ST_TYPE (elf_sym
->st_info
);
2518 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2519 This allows us to distinguish between data used by Thumb instructions
2520 and non-data (which is probably code) inside Thumb regions of an
2522 if (type
!= STT_OBJECT
)
2523 return ELF_ST_TYPE (elf_sym
->st_info
);
2534 elf32_arm_gc_mark_hook (sec
, info
, rel
, h
, sym
)
2536 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2537 Elf_Internal_Rela
*rel
;
2538 struct elf_link_hash_entry
*h
;
2539 Elf_Internal_Sym
*sym
;
2543 switch (ELF32_R_TYPE (rel
->r_info
))
2545 case R_ARM_GNU_VTINHERIT
:
2546 case R_ARM_GNU_VTENTRY
:
2550 switch (h
->root
.type
)
2552 case bfd_link_hash_defined
:
2553 case bfd_link_hash_defweak
:
2554 return h
->root
.u
.def
.section
;
2556 case bfd_link_hash_common
:
2557 return h
->root
.u
.c
.p
->section
;
2565 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
2570 /* Update the got entry reference counts for the section being removed. */
2573 elf32_arm_gc_sweep_hook (abfd
, info
, sec
, relocs
)
2574 bfd
*abfd ATTRIBUTE_UNUSED
;
2575 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2576 asection
*sec ATTRIBUTE_UNUSED
;
2577 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
;
2579 /* We don't support garbage collection of GOT and PLT relocs yet. */
2583 /* Look through the relocs for a section during the first phase. */
2586 elf32_arm_check_relocs (abfd
, info
, sec
, relocs
)
2588 struct bfd_link_info
*info
;
2590 const Elf_Internal_Rela
*relocs
;
2592 Elf_Internal_Shdr
*symtab_hdr
;
2593 struct elf_link_hash_entry
**sym_hashes
;
2594 struct elf_link_hash_entry
**sym_hashes_end
;
2595 const Elf_Internal_Rela
*rel
;
2596 const Elf_Internal_Rela
*rel_end
;
2598 asection
*sgot
, *srelgot
, *sreloc
;
2599 bfd_vma
*local_got_offsets
;
2601 if (info
->relocateable
)
2604 sgot
= srelgot
= sreloc
= NULL
;
2606 dynobj
= elf_hash_table (info
)->dynobj
;
2607 local_got_offsets
= elf_local_got_offsets (abfd
);
2609 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2610 sym_hashes
= elf_sym_hashes (abfd
);
2611 sym_hashes_end
= sym_hashes
2612 + symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
2614 if (!elf_bad_symtab (abfd
))
2615 sym_hashes_end
-= symtab_hdr
->sh_info
;
2617 rel_end
= relocs
+ sec
->reloc_count
;
2618 for (rel
= relocs
; rel
< rel_end
; rel
++)
2620 struct elf_link_hash_entry
*h
;
2621 unsigned long r_symndx
;
2623 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2624 if (r_symndx
< symtab_hdr
->sh_info
)
2627 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2629 /* Some relocs require a global offset table. */
2632 switch (ELF32_R_TYPE (rel
->r_info
))
2637 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
2638 if (! _bfd_elf_create_got_section (dynobj
, info
))
2647 switch (ELF32_R_TYPE (rel
->r_info
))
2650 /* This symbol requires a global offset table entry. */
2653 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2654 BFD_ASSERT (sgot
!= NULL
);
2657 /* Get the got relocation section if necessary. */
2659 && (h
!= NULL
|| info
->shared
))
2661 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
2663 /* If no got relocation section, make one and initialize. */
2664 if (srelgot
== NULL
)
2666 srelgot
= bfd_make_section (dynobj
, ".rel.got");
2668 || ! bfd_set_section_flags (dynobj
, srelgot
,
2673 | SEC_LINKER_CREATED
2675 || ! bfd_set_section_alignment (dynobj
, srelgot
, 2))
2682 if (h
->got
.offset
!= (bfd_vma
) -1)
2683 /* We have already allocated space in the .got. */
2686 h
->got
.offset
= sgot
->_raw_size
;
2688 /* Make sure this symbol is output as a dynamic symbol. */
2689 if (h
->dynindx
== -1)
2690 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2693 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2697 /* This is a global offset table entry for a local
2699 if (local_got_offsets
== NULL
)
2704 size
= symtab_hdr
->sh_info
;
2705 size
*= sizeof (bfd_vma
);
2706 local_got_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
2707 if (local_got_offsets
== NULL
)
2709 elf_local_got_offsets (abfd
) = local_got_offsets
;
2710 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
2711 local_got_offsets
[i
] = (bfd_vma
) -1;
2714 if (local_got_offsets
[r_symndx
] != (bfd_vma
) -1)
2715 /* We have already allocated space in the .got. */
2718 local_got_offsets
[r_symndx
] = sgot
->_raw_size
;
2721 /* If we are generating a shared object, we need to
2722 output a R_ARM_RELATIVE reloc so that the dynamic
2723 linker can adjust this GOT entry. */
2724 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2727 sgot
->_raw_size
+= 4;
2731 /* This symbol requires a procedure linkage table entry. We
2732 actually build the entry in adjust_dynamic_symbol,
2733 because this might be a case of linking PIC code which is
2734 never referenced by a dynamic object, in which case we
2735 don't need to generate a procedure linkage table entry
2738 /* If this is a local symbol, we resolve it directly without
2739 creating a procedure linkage table entry. */
2743 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2749 /* If we are creating a shared library, and this is a reloc
2750 against a global symbol, or a non PC relative reloc
2751 against a local symbol, then we need to copy the reloc
2752 into the shared library. However, if we are linking with
2753 -Bsymbolic, we do not need to copy a reloc against a
2754 global symbol which is defined in an object we are
2755 including in the link (i.e., DEF_REGULAR is set). At
2756 this point we have not seen all the input files, so it is
2757 possible that DEF_REGULAR is not set now but will be set
2758 later (it is never cleared). We account for that
2759 possibility below by storing information in the
2760 pcrel_relocs_copied field of the hash table entry. */
2762 && (ELF32_R_TYPE (rel
->r_info
) != R_ARM_PC24
2764 && (! info
->symbolic
2765 || (h
->elf_link_hash_flags
2766 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
2768 /* When creating a shared object, we must copy these
2769 reloc types into the output file. We create a reloc
2770 section in dynobj and make room for this reloc. */
2775 name
= (bfd_elf_string_from_elf_section
2777 elf_elfheader (abfd
)->e_shstrndx
,
2778 elf_section_data (sec
)->rel_hdr
.sh_name
));
2782 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
2783 && strcmp (bfd_get_section_name (abfd
, sec
),
2786 sreloc
= bfd_get_section_by_name (dynobj
, name
);
2791 sreloc
= bfd_make_section (dynobj
, name
);
2792 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
2793 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
2794 if ((sec
->flags
& SEC_ALLOC
) != 0)
2795 flags
|= SEC_ALLOC
| SEC_LOAD
;
2797 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
2798 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
2801 if (sec
->flags
& SEC_READONLY
)
2802 info
->flags
|= DF_TEXTREL
;
2805 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
2806 /* If we are linking with -Bsymbolic, and this is a
2807 global symbol, we count the number of PC relative
2808 relocations we have entered for this symbol, so that
2809 we can discard them again if the symbol is later
2810 defined by a regular object. Note that this function
2811 is only called if we are using an elf_i386 linker
2812 hash table, which means that h is really a pointer to
2813 an elf_i386_link_hash_entry. */
2814 if (h
!= NULL
&& info
->symbolic
2815 && ELF32_R_TYPE (rel
->r_info
) == R_ARM_PC24
)
2817 struct elf32_arm_link_hash_entry
* eh
;
2818 struct elf32_arm_pcrel_relocs_copied
* p
;
2820 eh
= (struct elf32_arm_link_hash_entry
*) h
;
2822 for (p
= eh
->pcrel_relocs_copied
; p
!= NULL
; p
= p
->next
)
2823 if (p
->section
== sreloc
)
2828 p
= ((struct elf32_arm_pcrel_relocs_copied
*)
2829 bfd_alloc (dynobj
, (bfd_size_type
) sizeof * p
));
2832 p
->next
= eh
->pcrel_relocs_copied
;
2833 eh
->pcrel_relocs_copied
= p
;
2834 p
->section
= sreloc
;
2843 /* This relocation describes the C++ object vtable hierarchy.
2844 Reconstruct it for later use during GC. */
2845 case R_ARM_GNU_VTINHERIT
:
2846 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2850 /* This relocation describes which C++ vtable entries are actually
2851 used. Record for later use during GC. */
2852 case R_ARM_GNU_VTENTRY
:
2853 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
2862 /* Find the nearest line to a particular section and offset, for error
2863 reporting. This code is a duplicate of the code in elf.c, except
2864 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
2867 elf32_arm_find_nearest_line
2868 (abfd
, section
, symbols
, offset
, filename_ptr
, functionname_ptr
, line_ptr
)
2873 const char **filename_ptr
;
2874 const char **functionname_ptr
;
2875 unsigned int *line_ptr
;
2878 const char *filename
;
2883 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
2884 filename_ptr
, functionname_ptr
,
2886 &elf_tdata (abfd
)->dwarf2_find_line_info
))
2889 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2890 &found
, filename_ptr
,
2891 functionname_ptr
, line_ptr
,
2892 &elf_tdata (abfd
)->line_info
))
2898 if (symbols
== NULL
)
2905 for (p
= symbols
; *p
!= NULL
; p
++)
2909 q
= (elf_symbol_type
*) *p
;
2911 if (bfd_get_section (&q
->symbol
) != section
)
2914 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
2919 filename
= bfd_asymbol_name (&q
->symbol
);
2924 if (q
->symbol
.section
== section
2925 && q
->symbol
.value
>= low_func
2926 && q
->symbol
.value
<= offset
)
2928 func
= (asymbol
*) q
;
2929 low_func
= q
->symbol
.value
;
2938 *filename_ptr
= filename
;
2939 *functionname_ptr
= bfd_asymbol_name (func
);
2945 /* Adjust a symbol defined by a dynamic object and referenced by a
2946 regular object. The current definition is in some section of the
2947 dynamic object, but we're not including those sections. We have to
2948 change the definition to something the rest of the link can
2952 elf32_arm_adjust_dynamic_symbol (info
, h
)
2953 struct bfd_link_info
* info
;
2954 struct elf_link_hash_entry
* h
;
2958 unsigned int power_of_two
;
2960 dynobj
= elf_hash_table (info
)->dynobj
;
2962 /* Make sure we know what is going on here. */
2963 BFD_ASSERT (dynobj
!= NULL
2964 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
2965 || h
->weakdef
!= NULL
2966 || ((h
->elf_link_hash_flags
2967 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2968 && (h
->elf_link_hash_flags
2969 & ELF_LINK_HASH_REF_REGULAR
) != 0
2970 && (h
->elf_link_hash_flags
2971 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
2973 /* If this is a function, put it in the procedure linkage table. We
2974 will fill in the contents of the procedure linkage table later,
2975 when we know the address of the .got section. */
2976 if (h
->type
== STT_FUNC
2977 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
2979 /* If we link a program (not a DSO), we'll get rid of unnecessary
2980 PLT entries; we point to the actual symbols -- even for pic
2981 relocs, because a program built with -fpic should have the same
2982 result as one built without -fpic, specifically considering weak
2984 FIXME: m68k and i386 differ here, for unclear reasons. */
2986 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0)
2988 /* This case can occur if we saw a PLT32 reloc in an input
2989 file, but the symbol was not defined by a dynamic object.
2990 In such a case, we don't actually need to build a
2991 procedure linkage table, and we can just do a PC32 reloc
2993 BFD_ASSERT ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0);
2994 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
2998 /* Make sure this symbol is output as a dynamic symbol. */
2999 if (h
->dynindx
== -1)
3001 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
3005 s
= bfd_get_section_by_name (dynobj
, ".plt");
3006 BFD_ASSERT (s
!= NULL
);
3008 /* If this is the first .plt entry, make room for the special
3010 if (s
->_raw_size
== 0)
3011 s
->_raw_size
+= PLT_ENTRY_SIZE
;
3013 /* If this symbol is not defined in a regular file, and we are
3014 not generating a shared library, then set the symbol to this
3015 location in the .plt. This is required to make function
3016 pointers compare as equal between the normal executable and
3017 the shared library. */
3019 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3021 h
->root
.u
.def
.section
= s
;
3022 h
->root
.u
.def
.value
= s
->_raw_size
;
3025 h
->plt
.offset
= s
->_raw_size
;
3027 /* Make room for this entry. */
3028 s
->_raw_size
+= PLT_ENTRY_SIZE
;
3030 /* We also need to make an entry in the .got.plt section, which
3031 will be placed in the .got section by the linker script. */
3032 s
= bfd_get_section_by_name (dynobj
, ".got.plt");
3033 BFD_ASSERT (s
!= NULL
);
3036 /* We also need to make an entry in the .rel.plt section. */
3038 s
= bfd_get_section_by_name (dynobj
, ".rel.plt");
3039 BFD_ASSERT (s
!= NULL
);
3040 s
->_raw_size
+= sizeof (Elf32_External_Rel
);
3045 /* If this is a weak symbol, and there is a real definition, the
3046 processor independent code will have arranged for us to see the
3047 real definition first, and we can just use the same value. */
3048 if (h
->weakdef
!= NULL
)
3050 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
3051 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
3052 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
3053 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
3057 /* This is a reference to a symbol defined by a dynamic object which
3058 is not a function. */
3060 /* If we are creating a shared library, we must presume that the
3061 only references to the symbol are via the global offset table.
3062 For such cases we need not do anything here; the relocations will
3063 be handled correctly by relocate_section. */
3067 /* We must allocate the symbol in our .dynbss section, which will
3068 become part of the .bss section of the executable. There will be
3069 an entry for this symbol in the .dynsym section. The dynamic
3070 object will contain position independent code, so all references
3071 from the dynamic object to this symbol will go through the global
3072 offset table. The dynamic linker will use the .dynsym entry to
3073 determine the address it must put in the global offset table, so
3074 both the dynamic object and the regular object will refer to the
3075 same memory location for the variable. */
3076 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
3077 BFD_ASSERT (s
!= NULL
);
3079 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
3080 copy the initial value out of the dynamic object and into the
3081 runtime process image. We need to remember the offset into the
3082 .rel.bss section we are going to use. */
3083 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
3087 srel
= bfd_get_section_by_name (dynobj
, ".rel.bss");
3088 BFD_ASSERT (srel
!= NULL
);
3089 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
3090 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
3093 /* We need to figure out the alignment required for this symbol. I
3094 have no idea how ELF linkers handle this. */
3095 power_of_two
= bfd_log2 (h
->size
);
3096 if (power_of_two
> 3)
3099 /* Apply the required alignment. */
3100 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
3101 (bfd_size_type
) (1 << power_of_two
));
3102 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
3104 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
3108 /* Define the symbol as being at this point in the section. */
3109 h
->root
.u
.def
.section
= s
;
3110 h
->root
.u
.def
.value
= s
->_raw_size
;
3112 /* Increment the section size to make room for the symbol. */
3113 s
->_raw_size
+= h
->size
;
3118 /* Set the sizes of the dynamic sections. */
3121 elf32_arm_size_dynamic_sections (output_bfd
, info
)
3122 bfd
* output_bfd ATTRIBUTE_UNUSED
;
3123 struct bfd_link_info
* info
;
3130 dynobj
= elf_hash_table (info
)->dynobj
;
3131 BFD_ASSERT (dynobj
!= NULL
);
3133 if (elf_hash_table (info
)->dynamic_sections_created
)
3135 /* Set the contents of the .interp section to the interpreter. */
3138 s
= bfd_get_section_by_name (dynobj
, ".interp");
3139 BFD_ASSERT (s
!= NULL
);
3140 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
3141 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
3146 /* We may have created entries in the .rel.got section.
3147 However, if we are not creating the dynamic sections, we will
3148 not actually use these entries. Reset the size of .rel.got,
3149 which will cause it to get stripped from the output file
3151 s
= bfd_get_section_by_name (dynobj
, ".rel.got");
3156 /* If this is a -Bsymbolic shared link, then we need to discard all
3157 PC relative relocs against symbols defined in a regular object.
3158 We allocated space for them in the check_relocs routine, but we
3159 will not fill them in in the relocate_section routine. */
3160 if (info
->shared
&& info
->symbolic
)
3161 elf32_arm_link_hash_traverse (elf32_arm_hash_table (info
),
3162 elf32_arm_discard_copies
,
3165 /* The check_relocs and adjust_dynamic_symbol entry points have
3166 determined the sizes of the various dynamic sections. Allocate
3170 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3175 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3178 /* It's OK to base decisions on the section name, because none
3179 of the dynobj section names depend upon the input files. */
3180 name
= bfd_get_section_name (dynobj
, s
);
3184 if (strcmp (name
, ".plt") == 0)
3186 if (s
->_raw_size
== 0)
3188 /* Strip this section if we don't need it; see the
3194 /* Remember whether there is a PLT. */
3198 else if (strncmp (name
, ".rel", 4) == 0)
3200 if (s
->_raw_size
== 0)
3202 /* If we don't need this section, strip it from the
3203 output file. This is mostly to handle .rel.bss and
3204 .rel.plt. We must create both sections in
3205 create_dynamic_sections, because they must be created
3206 before the linker maps input sections to output
3207 sections. The linker does that before
3208 adjust_dynamic_symbol is called, and it is that
3209 function which decides whether anything needs to go
3210 into these sections. */
3215 /* Remember whether there are any reloc sections other
3217 if (strcmp (name
, ".rel.plt") != 0)
3220 /* We use the reloc_count field as a counter if we need
3221 to copy relocs into the output file. */
3225 else if (strncmp (name
, ".got", 4) != 0)
3227 /* It's not one of our sections, so don't allocate space. */
3233 _bfd_strip_section_from_output (info
, s
);
3237 /* Allocate memory for the section contents. */
3238 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
3239 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
3243 if (elf_hash_table (info
)->dynamic_sections_created
)
3245 /* Add some entries to the .dynamic section. We fill in the
3246 values later, in elf32_arm_finish_dynamic_sections, but we
3247 must add the entries now so that we get the correct size for
3248 the .dynamic section. The DT_DEBUG entry is filled in by the
3249 dynamic linker and used by the debugger. */
3250 #define add_dynamic_entry(TAG, VAL) \
3251 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
3255 if (!add_dynamic_entry (DT_DEBUG
, 0))
3261 if ( !add_dynamic_entry (DT_PLTGOT
, 0)
3262 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
3263 || !add_dynamic_entry (DT_PLTREL
, DT_REL
)
3264 || !add_dynamic_entry (DT_JMPREL
, 0))
3270 if ( !add_dynamic_entry (DT_REL
, 0)
3271 || !add_dynamic_entry (DT_RELSZ
, 0)
3272 || !add_dynamic_entry (DT_RELENT
, sizeof (Elf32_External_Rel
)))
3276 if ((info
->flags
& DF_TEXTREL
) != 0)
3278 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3280 info
->flags
|= DF_TEXTREL
;
3283 #undef add_synamic_entry
3288 /* This function is called via elf32_arm_link_hash_traverse if we are
3289 creating a shared object with -Bsymbolic. It discards the space
3290 allocated to copy PC relative relocs against symbols which are
3291 defined in regular objects. We allocated space for them in the
3292 check_relocs routine, but we won't fill them in in the
3293 relocate_section routine. */
3296 elf32_arm_discard_copies (h
, ignore
)
3297 struct elf32_arm_link_hash_entry
* h
;
3298 PTR ignore ATTRIBUTE_UNUSED
;
3300 struct elf32_arm_pcrel_relocs_copied
* s
;
3302 if (h
->root
.root
.type
== bfd_link_hash_warning
)
3303 h
= (struct elf32_arm_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3305 /* We only discard relocs for symbols defined in a regular object. */
3306 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3309 for (s
= h
->pcrel_relocs_copied
; s
!= NULL
; s
= s
->next
)
3310 s
->section
->_raw_size
-= s
->count
* sizeof (Elf32_External_Rel
);
3315 /* Finish up dynamic symbol handling. We set the contents of various
3316 dynamic sections here. */
3319 elf32_arm_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
3321 struct bfd_link_info
* info
;
3322 struct elf_link_hash_entry
* h
;
3323 Elf_Internal_Sym
* sym
;
3327 dynobj
= elf_hash_table (info
)->dynobj
;
3329 if (h
->plt
.offset
!= (bfd_vma
) -1)
3336 Elf_Internal_Rela rel
;
3339 /* This symbol has an entry in the procedure linkage table. Set
3342 BFD_ASSERT (h
->dynindx
!= -1);
3344 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3345 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3346 srel
= bfd_get_section_by_name (dynobj
, ".rel.plt");
3347 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
3349 /* Get the index in the procedure linkage table which
3350 corresponds to this symbol. This is the index of this symbol
3351 in all the symbols for which we are making plt entries. The
3352 first entry in the procedure linkage table is reserved. */
3353 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
3355 /* Get the offset into the .got table of the entry that
3356 corresponds to this function. Each .got entry is 4 bytes.
3357 The first three are reserved. */
3358 got_offset
= (plt_index
+ 3) * 4;
3360 /* Fill in the entry in the procedure linkage table. */
3361 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[0],
3362 splt
->contents
+ h
->plt
.offset
+ 0);
3363 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[1],
3364 splt
->contents
+ h
->plt
.offset
+ 4);
3365 bfd_put_32 (output_bfd
, elf32_arm_plt_entry
[2],
3366 splt
->contents
+ h
->plt
.offset
+ 8);
3367 bfd_put_32 (output_bfd
,
3368 (sgot
->output_section
->vma
3369 + sgot
->output_offset
3371 - splt
->output_section
->vma
3372 - splt
->output_offset
3373 - h
->plt
.offset
- 12),
3374 splt
->contents
+ h
->plt
.offset
+ 12);
3376 /* Fill in the entry in the global offset table. */
3377 bfd_put_32 (output_bfd
,
3378 (splt
->output_section
->vma
3379 + splt
->output_offset
),
3380 sgot
->contents
+ got_offset
);
3382 /* Fill in the entry in the .rel.plt section. */
3383 rel
.r_offset
= (sgot
->output_section
->vma
3384 + sgot
->output_offset
3386 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_JUMP_SLOT
);
3387 loc
= srel
->contents
+ plt_index
* sizeof (Elf32_External_Rel
);
3388 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3390 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3392 /* Mark the symbol as undefined, rather than as defined in
3393 the .plt section. Leave the value alone. */
3394 sym
->st_shndx
= SHN_UNDEF
;
3395 /* If the symbol is weak, we do need to clear the value.
3396 Otherwise, the PLT entry would provide a definition for
3397 the symbol even if the symbol wasn't defined anywhere,
3398 and so the symbol would never be NULL. */
3399 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR_NONWEAK
)
3405 if (h
->got
.offset
!= (bfd_vma
) -1)
3409 Elf_Internal_Rela rel
;
3412 /* This symbol has an entry in the global offset table. Set it
3414 sgot
= bfd_get_section_by_name (dynobj
, ".got");
3415 srel
= bfd_get_section_by_name (dynobj
, ".rel.got");
3416 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
3418 rel
.r_offset
= (sgot
->output_section
->vma
3419 + sgot
->output_offset
3420 + (h
->got
.offset
&~ (bfd_vma
) 1));
3422 /* If this is a -Bsymbolic link, and the symbol is defined
3423 locally, we just want to emit a RELATIVE reloc. The entry in
3424 the global offset table will already have been initialized in
3425 the relocate_section function. */
3427 && (info
->symbolic
|| h
->dynindx
== -1)
3428 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
3429 rel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
3432 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
3433 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_GLOB_DAT
);
3436 loc
= srel
->contents
+ srel
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3437 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3440 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
3443 Elf_Internal_Rela rel
;
3446 /* This symbol needs a copy reloc. Set it up. */
3447 BFD_ASSERT (h
->dynindx
!= -1
3448 && (h
->root
.type
== bfd_link_hash_defined
3449 || h
->root
.type
== bfd_link_hash_defweak
));
3451 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
3453 BFD_ASSERT (s
!= NULL
);
3455 rel
.r_offset
= (h
->root
.u
.def
.value
3456 + h
->root
.u
.def
.section
->output_section
->vma
3457 + h
->root
.u
.def
.section
->output_offset
);
3458 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_COPY
);
3459 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rel
);
3460 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
3463 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3464 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3465 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
3466 sym
->st_shndx
= SHN_ABS
;
3471 /* Finish up the dynamic sections. */
3474 elf32_arm_finish_dynamic_sections (output_bfd
, info
)
3476 struct bfd_link_info
* info
;
3482 dynobj
= elf_hash_table (info
)->dynobj
;
3484 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3485 BFD_ASSERT (sgot
!= NULL
);
3486 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3488 if (elf_hash_table (info
)->dynamic_sections_created
)
3491 Elf32_External_Dyn
*dyncon
, *dynconend
;
3493 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3494 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3496 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3497 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
3499 for (; dyncon
< dynconend
; dyncon
++)
3501 Elf_Internal_Dyn dyn
;
3505 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3518 s
= bfd_get_section_by_name (output_bfd
, name
);
3519 BFD_ASSERT (s
!= NULL
);
3520 dyn
.d_un
.d_ptr
= s
->vma
;
3521 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3525 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3526 BFD_ASSERT (s
!= NULL
);
3527 if (s
->_cooked_size
!= 0)
3528 dyn
.d_un
.d_val
= s
->_cooked_size
;
3530 dyn
.d_un
.d_val
= s
->_raw_size
;
3531 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3535 /* My reading of the SVR4 ABI indicates that the
3536 procedure linkage table relocs (DT_JMPREL) should be
3537 included in the overall relocs (DT_REL). This is
3538 what Solaris does. However, UnixWare can not handle
3539 that case. Therefore, we override the DT_RELSZ entry
3540 here to make it not include the JMPREL relocs. Since
3541 the linker script arranges for .rel.plt to follow all
3542 other relocation sections, we don't have to worry
3543 about changing the DT_REL entry. */
3544 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3547 if (s
->_cooked_size
!= 0)
3548 dyn
.d_un
.d_val
-= s
->_cooked_size
;
3550 dyn
.d_un
.d_val
-= s
->_raw_size
;
3552 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3555 /* Set the bottom bit of DT_INIT/FINI if the
3556 corresponding function is Thumb. */
3558 name
= info
->init_function
;
3561 name
= info
->fini_function
;
3563 /* If it wasn't set by elf_bfd_final_link
3564 then there is nothing to ajdust. */
3565 if (dyn
.d_un
.d_val
!= 0)
3567 struct elf_link_hash_entry
* eh
;
3569 eh
= elf_link_hash_lookup (elf_hash_table (info
), name
,
3570 FALSE
, FALSE
, TRUE
);
3571 if (eh
!= (struct elf_link_hash_entry
*) NULL
3572 && ELF_ST_TYPE (eh
->type
) == STT_ARM_TFUNC
)
3574 dyn
.d_un
.d_val
|= 1;
3575 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3582 /* Fill in the first entry in the procedure linkage table. */
3583 if (splt
->_raw_size
> 0)
3585 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[0], splt
->contents
+ 0);
3586 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[1], splt
->contents
+ 4);
3587 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[2], splt
->contents
+ 8);
3588 bfd_put_32 (output_bfd
, elf32_arm_plt0_entry
[3], splt
->contents
+ 12);
3591 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3592 really seem like the right value. */
3593 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
3596 /* Fill in the first three entries in the global offset table. */
3597 if (sgot
->_raw_size
> 0)
3600 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
3602 bfd_put_32 (output_bfd
,
3603 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3605 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
3606 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
3609 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
3615 elf32_arm_post_process_headers (abfd
, link_info
)
3617 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
;
3619 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
3621 i_ehdrp
= elf_elfheader (abfd
);
3623 i_ehdrp
->e_ident
[EI_OSABI
] = ARM_ELF_OS_ABI_VERSION
;
3624 i_ehdrp
->e_ident
[EI_ABIVERSION
] = ARM_ELF_ABI_VERSION
;
3627 static enum elf_reloc_type_class
3628 elf32_arm_reloc_type_class (rela
)
3629 const Elf_Internal_Rela
*rela
;
3631 switch ((int) ELF32_R_TYPE (rela
->r_info
))
3633 case R_ARM_RELATIVE
:
3634 return reloc_class_relative
;
3635 case R_ARM_JUMP_SLOT
:
3636 return reloc_class_plt
;
3638 return reloc_class_copy
;
3640 return reloc_class_normal
;
3645 #define ELF_ARCH bfd_arch_arm
3646 #define ELF_MACHINE_CODE EM_ARM
3647 #define ELF_MAXPAGESIZE 0x8000
3649 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
3650 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
3651 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
3652 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
3653 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
3654 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
3655 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
3657 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
3658 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
3659 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
3660 #define elf_backend_check_relocs elf32_arm_check_relocs
3661 #define elf_backend_relocate_section elf32_arm_relocate_section
3662 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
3663 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
3664 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
3665 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
3666 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
3667 #define elf_backend_post_process_headers elf32_arm_post_process_headers
3668 #define elf_backend_reloc_type_class elf32_arm_reloc_type_class
3670 #define elf_backend_can_gc_sections 1
3671 #define elf_backend_plt_readonly 1
3672 #define elf_backend_want_got_plt 1
3673 #define elf_backend_want_plt_sym 0
3675 #define elf_backend_rela_normal 1
3678 #define elf_backend_got_header_size 12
3679 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
3681 #include "elf32-target.h"