1 /* 32-bit ELF support for ARM
2 Copyright 1998, 1999 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. */
21 typedef unsigned long int insn32
;
22 typedef unsigned short int insn16
;
24 static boolean elf32_arm_set_private_flags
25 PARAMS ((bfd
*, flagword
));
26 static boolean elf32_arm_copy_private_bfd_data
27 PARAMS ((bfd
*, bfd
*));
28 static boolean elf32_arm_merge_private_bfd_data
29 PARAMS ((bfd
*, bfd
*));
30 static boolean elf32_arm_print_private_bfd_data
31 PARAMS ((bfd
*, PTR
));
32 static int elf32_arm_get_symbol_type
33 PARAMS (( Elf_Internal_Sym
*, int));
34 static struct bfd_link_hash_table
*elf32_arm_link_hash_table_create
36 static bfd_reloc_status_type elf32_arm_final_link_relocate
37 PARAMS ((reloc_howto_type
*, bfd
*, bfd
*, asection
*, bfd_byte
*,
38 Elf_Internal_Rela
*, bfd_vma
, struct bfd_link_info
*, asection
*,
39 const char *, unsigned char, struct elf_link_hash_entry
*));
41 static insn32 insert_thumb_branch
42 PARAMS ((insn32
, int));
43 static struct elf_link_hash_entry
*find_thumb_glue
44 PARAMS ((struct bfd_link_info
*, CONST
char *, bfd
*));
45 static struct elf_link_hash_entry
*find_arm_glue
46 PARAMS ((struct bfd_link_info
*, CONST
char *, bfd
*));
47 static void record_arm_to_thumb_glue
48 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
49 static void record_thumb_to_arm_glue
50 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
51 static void elf32_arm_post_process_headers
52 PARAMS ((bfd
*, struct bfd_link_info
*));
53 static int elf32_arm_to_thumb_stub
54 PARAMS ((struct bfd_link_info
*, const char *, bfd
*, bfd
*, asection
*,
55 bfd_byte
*, asection
*, bfd_vma
, bfd_signed_vma
, bfd_vma
));
56 static int elf32_thumb_to_arm_stub
57 PARAMS ((struct bfd_link_info
*, const char *, bfd
*, bfd
*, asection
*,
58 bfd_byte
*, asection
*, bfd_vma
, bfd_signed_vma
, bfd_vma
));
60 /* The linker script knows the section names for placement.
61 The entry_names are used to do simple name mangling on the stubs.
62 Given a function name, and its type, the stub can be found. The
63 name can be changed. The only requirement is the %s be present.
66 #define INTERWORK_FLAG( abfd ) (elf_elfheader (abfd)->e_flags & EF_INTERWORK)
68 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
69 #define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
71 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
72 #define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
74 /* The name of the dynamic interpreter. This is put in the .interp
76 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
78 /* The size in bytes of an entry in the procedure linkage table. */
80 #define PLT_ENTRY_SIZE 16
82 /* The first entry in a procedure linkage table looks like
83 this. It is set up so that any shared library function that is
84 called before the relocation has been set up calls the dynamic
87 static const bfd_byte elf32_arm_plt0_entry
[PLT_ENTRY_SIZE
] =
89 0x04, 0xe0, 0x2d, 0xe5, /* str lr, [sp, #-4]! */
90 0x10, 0xe0, 0x9f, 0xe5, /* ldr lr, [pc, #16] */
91 0x0e, 0xe0, 0x8f, 0xe0, /* adr lr, pc, lr */
92 0x08, 0xf0, 0xbe, 0xe5 /* ldr pc, [lr, #8]! */
95 /* Subsequent entries in a procedure linkage table look like
98 static const bfd_byte elf32_arm_plt_entry
[PLT_ENTRY_SIZE
] =
100 0x04, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc, #4] */
101 0x0c, 0xc0, 0x8f, 0xe0, /* add ip, pc, ip */
102 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
103 0x00, 0x00, 0x00, 0x00 /* offset to symbol in got */
107 /* The ARM linker needs to keep track of the number of relocs that it
108 decides to copy in check_relocs for each symbol. This is so that
109 it can discard PC relative relocs if it doesn't need them when
110 linking with -Bsymbolic. We store the information in a field
111 extending the regular ELF linker hash table. */
113 /* This structure keeps track of the number of PC relative relocs we
114 have copied for a given symbol. */
116 struct elf32_arm_pcrel_relocs_copied
119 struct elf32_arm_pcrel_relocs_copied
* next
;
120 /* A section in dynobj. */
122 /* Number of relocs copied in this section. */
126 /* Arm ELF linker hash entry. */
128 struct elf32_arm_link_hash_entry
130 struct elf_link_hash_entry root
;
132 /* Number of PC relative relocs copied for this symbol. */
133 struct elf32_arm_pcrel_relocs_copied
* pcrel_relocs_copied
;
136 /* Declare this now that the above structures are defined. */
138 static boolean elf32_arm_discard_copies
139 PARAMS ((struct elf32_arm_link_hash_entry
*, PTR
));
141 /* Traverse an arm ELF linker hash table. */
143 #define elf32_arm_link_hash_traverse(table, func, info) \
144 (elf_link_hash_traverse \
146 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
149 /* Get the ARM elf linker hash table from a link_info structure. */
150 #define elf32_arm_hash_table(info) \
151 ((struct elf32_arm_link_hash_table *) ((info)->hash))
153 /* ARM ELF linker hash table */
154 struct elf32_arm_link_hash_table
156 /* The main hash table. */
157 struct elf_link_hash_table root
;
159 /* The size in bytes of the section containg the Thumb-to-ARM glue. */
160 long int thumb_glue_size
;
162 /* The size in bytes of the section containg the ARM-to-Thumb glue. */
163 long int arm_glue_size
;
165 /* An arbitary input BFD chosen to hold the glue sections. */
166 bfd
* bfd_of_glue_owner
;
168 /* A boolean indicating whether knowledge of the ARM's pipeline
169 length should be applied by the linker. */
170 int no_pipeline_knowledge
;
174 /* Create an entry in an ARM ELF linker hash table. */
176 static struct bfd_hash_entry
*
177 elf32_arm_link_hash_newfunc (entry
, table
, string
)
178 struct bfd_hash_entry
* entry
;
179 struct bfd_hash_table
* table
;
182 struct elf32_arm_link_hash_entry
* ret
=
183 (struct elf32_arm_link_hash_entry
*) entry
;
185 /* Allocate the structure if it has not already been allocated by a
187 if (ret
== (struct elf32_arm_link_hash_entry
*) NULL
)
188 ret
= ((struct elf32_arm_link_hash_entry
*)
189 bfd_hash_allocate (table
,
190 sizeof (struct elf32_arm_link_hash_entry
)));
191 if (ret
== (struct elf32_arm_link_hash_entry
*) NULL
)
192 return (struct bfd_hash_entry
*) ret
;
194 /* Call the allocation method of the superclass. */
195 ret
= ((struct elf32_arm_link_hash_entry
*)
196 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
198 if (ret
!= (struct elf32_arm_link_hash_entry
*) NULL
)
199 ret
->pcrel_relocs_copied
= NULL
;
201 return (struct bfd_hash_entry
*) ret
;
204 /* Create an ARM elf linker hash table */
206 static struct bfd_link_hash_table
*
207 elf32_arm_link_hash_table_create (abfd
)
210 struct elf32_arm_link_hash_table
*ret
;
212 ret
= ((struct elf32_arm_link_hash_table
*)
213 bfd_alloc (abfd
, sizeof (struct elf32_arm_link_hash_table
)));
214 if (ret
== (struct elf32_arm_link_hash_table
*) NULL
)
217 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
218 elf32_arm_link_hash_newfunc
))
220 bfd_release (abfd
, ret
);
224 ret
->thumb_glue_size
= 0;
225 ret
->arm_glue_size
= 0;
226 ret
->bfd_of_glue_owner
= NULL
;
227 ret
->no_pipeline_knowledge
= 0;
229 return &ret
->root
.root
;
232 static struct elf_link_hash_entry
*
233 find_thumb_glue (link_info
, name
, input_bfd
)
234 struct bfd_link_info
*link_info
;
239 struct elf_link_hash_entry
*hash
;
240 struct elf32_arm_link_hash_table
*hash_table
;
242 /* We need a pointer to the armelf specific hash table. */
243 hash_table
= elf32_arm_hash_table (link_info
);
247 bfd_malloc (strlen (name
) + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1));
249 BFD_ASSERT (tmp_name
);
251 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
253 hash
= elf_link_hash_lookup
254 (&(hash_table
)->root
, tmp_name
, false, false, true);
257 /* xgettext:c-format */
258 _bfd_error_handler (_ ("%s: unable to find THUMB glue '%s' for `%s'"),
259 bfd_get_filename (input_bfd
), tmp_name
, name
);
266 static struct elf_link_hash_entry
*
267 find_arm_glue (link_info
, name
, input_bfd
)
268 struct bfd_link_info
*link_info
;
273 struct elf_link_hash_entry
*myh
;
274 struct elf32_arm_link_hash_table
*hash_table
;
276 /* We need a pointer to the elfarm specific hash table. */
277 hash_table
= elf32_arm_hash_table (link_info
);
280 bfd_malloc (strlen (name
) + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1));
282 BFD_ASSERT (tmp_name
);
284 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
286 myh
= elf_link_hash_lookup
287 (&(hash_table
)->root
, tmp_name
, false, false, true);
290 /* xgettext:c-format */
291 _bfd_error_handler (_ ("%s: unable to find ARM glue '%s' for `%s'"),
292 bfd_get_filename (input_bfd
), tmp_name
, name
);
307 .word func @ behave as if you saw a ARM_32 reloc
310 #define ARM2THUMB_GLUE_SIZE 12
311 static const insn32 a2t1_ldr_insn
= 0xe59fc000;
312 static const insn32 a2t2_bx_r12_insn
= 0xe12fff1c;
313 static const insn32 a2t3_func_addr_insn
= 0x00000001;
316 Thumb->ARM: Thumb->(non-interworking aware) ARM
320 __func_from_thumb: __func_from_thumb:
322 nop ldr r6, __func_addr
324 __func_change_to_arm: bx r6
326 __func_back_to_thumb:
333 #define THUMB2ARM_GLUE_SIZE 8
334 static const insn16 t2a1_bx_pc_insn
= 0x4778;
335 static const insn16 t2a2_noop_insn
= 0x46c0;
336 static const insn32 t2a3_b_insn
= 0xea000000;
338 static const insn16 t2a1_push_insn
= 0xb540;
339 static const insn16 t2a2_ldr_insn
= 0x4e03;
340 static const insn16 t2a3_mov_insn
= 0x46fe;
341 static const insn16 t2a4_bx_insn
= 0x4730;
342 static const insn32 t2a5_pop_insn
= 0xe8bd4040;
343 static const insn32 t2a6_bx_insn
= 0xe12fff1e;
346 bfd_elf32_arm_allocate_interworking_sections (info
)
347 struct bfd_link_info
* info
;
351 struct elf32_arm_link_hash_table
* globals
;
353 globals
= elf32_arm_hash_table (info
);
355 BFD_ASSERT (globals
!= NULL
);
357 if (globals
->arm_glue_size
!= 0)
359 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
361 s
= bfd_get_section_by_name
362 (globals
->bfd_of_glue_owner
, ARM2THUMB_GLUE_SECTION_NAME
);
364 BFD_ASSERT (s
!= NULL
);
366 foo
= (bfd_byte
*) bfd_alloc
367 (globals
->bfd_of_glue_owner
, globals
->arm_glue_size
);
369 s
->_raw_size
= s
->_cooked_size
= globals
->arm_glue_size
;
373 if (globals
->thumb_glue_size
!= 0)
375 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
377 s
= bfd_get_section_by_name
378 (globals
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
380 BFD_ASSERT (s
!= NULL
);
382 foo
= (bfd_byte
*) bfd_alloc
383 (globals
->bfd_of_glue_owner
, globals
->thumb_glue_size
);
385 s
->_raw_size
= s
->_cooked_size
= globals
->thumb_glue_size
;
393 record_arm_to_thumb_glue (link_info
, h
)
394 struct bfd_link_info
* link_info
;
395 struct elf_link_hash_entry
* h
;
397 const char * name
= h
->root
.root
.string
;
398 register asection
* s
;
400 struct elf_link_hash_entry
* myh
;
401 struct elf32_arm_link_hash_table
* globals
;
403 globals
= elf32_arm_hash_table (link_info
);
405 BFD_ASSERT (globals
!= NULL
);
406 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
408 s
= bfd_get_section_by_name
409 (globals
->bfd_of_glue_owner
, ARM2THUMB_GLUE_SECTION_NAME
);
412 BFD_ASSERT (s
!= NULL
);
415 bfd_malloc (strlen (name
) + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1));
417 BFD_ASSERT (tmp_name
);
419 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
421 myh
= elf_link_hash_lookup
422 (&(globals
)->root
, tmp_name
, false, false, true);
427 return; /* we've already seen this guy */
430 /* The only trick here is using hash_table->arm_glue_size as the value. Even
431 though the section isn't allocated yet, this is where we will be putting
434 _bfd_generic_link_add_one_symbol (link_info
, globals
->bfd_of_glue_owner
, tmp_name
,
436 s
, globals
->arm_glue_size
+ 1,
438 (struct bfd_link_hash_entry
**) &myh
);
442 globals
->arm_glue_size
+= ARM2THUMB_GLUE_SIZE
;
448 record_thumb_to_arm_glue (link_info
, h
)
449 struct bfd_link_info
*link_info
;
450 struct elf_link_hash_entry
*h
;
452 const char *name
= h
->root
.root
.string
;
453 register asection
*s
;
455 struct elf_link_hash_entry
*myh
;
456 struct elf32_arm_link_hash_table
*hash_table
;
459 hash_table
= elf32_arm_hash_table (link_info
);
461 BFD_ASSERT (hash_table
!= NULL
);
462 BFD_ASSERT (hash_table
->bfd_of_glue_owner
!= NULL
);
464 s
= bfd_get_section_by_name
465 (hash_table
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
467 BFD_ASSERT (s
!= NULL
);
469 tmp_name
= (char *) bfd_malloc (strlen (name
) + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1);
471 BFD_ASSERT (tmp_name
);
473 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
475 myh
= elf_link_hash_lookup
476 (&(hash_table
)->root
, tmp_name
, false, false, true);
481 return; /* we've already seen this guy */
484 _bfd_generic_link_add_one_symbol (link_info
, hash_table
->bfd_of_glue_owner
, tmp_name
,
485 BSF_GLOBAL
, s
, hash_table
->thumb_glue_size
+ 1,
487 (struct bfd_link_hash_entry
**) &myh
);
489 /* If we mark it 'thumb', the disassembler will do a better job. */
490 bind
= ELF_ST_BIND (myh
->type
);
491 myh
->type
= ELF_ST_INFO (bind
, STT_ARM_TFUNC
);
495 /* Allocate another symbol to mark where we switch to arm mode. */
497 #define CHANGE_TO_ARM "__%s_change_to_arm"
498 #define BACK_FROM_ARM "__%s_back_from_arm"
500 tmp_name
= (char *) bfd_malloc (strlen (name
) + strlen (CHANGE_TO_ARM
) + 1);
502 BFD_ASSERT (tmp_name
);
504 sprintf (tmp_name
, CHANGE_TO_ARM
, name
);
508 _bfd_generic_link_add_one_symbol (link_info
, hash_table
->bfd_of_glue_owner
, tmp_name
,
509 BSF_LOCAL
, s
, hash_table
->thumb_glue_size
+ 4,
511 (struct bfd_link_hash_entry
**) &myh
);
515 hash_table
->thumb_glue_size
+= THUMB2ARM_GLUE_SIZE
;
520 /* Select a BFD to be used to hold the sections used by the glue code.
521 This function is called from the linker scripts in ld/emultempl/
524 bfd_elf32_arm_get_bfd_for_interworking (abfd
, info
)
526 struct bfd_link_info
*info
;
528 struct elf32_arm_link_hash_table
*globals
;
532 /* If we are only performing a partial link do not bother
533 getting a bfd to hold the glue. */
534 if (info
->relocateable
)
537 globals
= elf32_arm_hash_table (info
);
539 BFD_ASSERT (globals
!= NULL
);
541 if (globals
->bfd_of_glue_owner
!= NULL
)
544 sec
= bfd_get_section_by_name (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
548 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
;
550 sec
= bfd_make_section (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
553 || !bfd_set_section_flags (abfd
, sec
, flags
)
554 || !bfd_set_section_alignment (abfd
, sec
, 2))
558 sec
= bfd_get_section_by_name (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
562 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
;
564 sec
= bfd_make_section (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
567 || !bfd_set_section_flags (abfd
, sec
, flags
)
568 || !bfd_set_section_alignment (abfd
, sec
, 2))
572 /* Save the bfd for later use. */
573 globals
->bfd_of_glue_owner
= abfd
;
579 bfd_elf32_arm_process_before_allocation (abfd
, link_info
, no_pipeline_knowledge
)
581 struct bfd_link_info
*link_info
;
582 int no_pipeline_knowledge
;
584 Elf_Internal_Shdr
*symtab_hdr
;
585 Elf_Internal_Rela
*free_relocs
= NULL
;
586 Elf_Internal_Rela
*irel
, *irelend
;
587 bfd_byte
*contents
= NULL
;
588 bfd_byte
*free_contents
= NULL
;
589 Elf32_External_Sym
*extsyms
= NULL
;
590 Elf32_External_Sym
*free_extsyms
= NULL
;
593 struct elf32_arm_link_hash_table
*globals
;
595 /* If we are only performing a partial link do not bother
596 to construct any glue. */
597 if (link_info
->relocateable
)
600 /* Here we have a bfd that is to be included on the link. We have a hook
601 to do reloc rummaging, before section sizes are nailed down. */
603 globals
= elf32_arm_hash_table (link_info
);
605 BFD_ASSERT (globals
!= NULL
);
606 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
608 globals
->no_pipeline_knowledge
= no_pipeline_knowledge
;
610 /* Rummage around all the relocs and map the glue vectors. */
611 sec
= abfd
->sections
;
616 for (; sec
!= NULL
; sec
= sec
->next
)
618 if (sec
->reloc_count
== 0)
621 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
622 /* Load the relocs. */
624 irel
= (_bfd_elf32_link_read_relocs (abfd
, sec
, (PTR
) NULL
,
625 (Elf_Internal_Rela
*) NULL
, false));
627 BFD_ASSERT (irel
!= 0);
629 irelend
= irel
+ sec
->reloc_count
;
630 for (; irel
< irelend
; irel
++)
633 unsigned long r_index
;
635 struct elf_link_hash_entry
*h
;
637 r_type
= ELF32_R_TYPE (irel
->r_info
);
638 r_index
= ELF32_R_SYM (irel
->r_info
);
640 /* These are the only relocation types we care about */
641 if ( r_type
!= R_ARM_PC24
642 && r_type
!= R_ARM_THM_PC22
)
645 /* Get the section contents if we haven't done so already. */
646 if (contents
== NULL
)
648 /* Get cached copy if it exists. */
649 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
650 contents
= elf_section_data (sec
)->this_hdr
.contents
;
653 /* Go get them off disk. */
654 contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
655 if (contents
== NULL
)
657 free_contents
= contents
;
659 if (!bfd_get_section_contents (abfd
, sec
, contents
,
660 (file_ptr
) 0, sec
->_raw_size
))
665 /* Read this BFD's symbols if we haven't done so already. */
668 /* Get cached copy if it exists. */
669 if (symtab_hdr
->contents
!= NULL
)
670 extsyms
= (Elf32_External_Sym
*) symtab_hdr
->contents
;
673 /* Go get them off disk. */
674 extsyms
= ((Elf32_External_Sym
*)
675 bfd_malloc (symtab_hdr
->sh_size
));
678 free_extsyms
= extsyms
;
679 if (bfd_seek (abfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
680 || (bfd_read (extsyms
, 1, symtab_hdr
->sh_size
, abfd
)
681 != symtab_hdr
->sh_size
))
686 /* If the relocation is not against a symbol it cannot concern us. */
690 /* We don't care about local symbols */
691 if (r_index
< symtab_hdr
->sh_info
)
694 /* This is an external symbol */
695 r_index
-= symtab_hdr
->sh_info
;
696 h
= (struct elf_link_hash_entry
*)
697 elf_sym_hashes (abfd
)[r_index
];
699 /* If the relocation is against a static symbol it must be within
700 the current section and so cannot be a cross ARM/Thumb relocation. */
707 /* This one is a call from arm code. We need to look up
708 the target of the call. If it is a thumb target, we
711 if (ELF_ST_TYPE(h
->type
) == STT_ARM_TFUNC
)
712 record_arm_to_thumb_glue (link_info
, h
);
716 /* This one is a call from thumb code. We look
717 up the target of the call. If it is not a thumb
718 target, we insert glue. */
720 if (ELF_ST_TYPE (h
->type
) != STT_ARM_TFUNC
)
721 record_thumb_to_arm_glue (link_info
, h
);
732 if (free_relocs
!= NULL
)
734 if (free_contents
!= NULL
)
735 free (free_contents
);
736 if (free_extsyms
!= NULL
)
742 /* The thumb form of a long branch is a bit finicky, because the offset
743 encoding is split over two fields, each in it's own instruction. They
744 can occur in any order. So given a thumb form of long branch, and an
745 offset, insert the offset into the thumb branch and return finished
748 It takes two thumb instructions to encode the target address. Each has
749 11 bits to invest. The upper 11 bits are stored in one (identifed by
750 H-0.. see below), the lower 11 bits are stored in the other (identified
753 Combine together and shifted left by 1 (it's a half word address) and
757 H-0, upper address-0 = 000
759 H-1, lower address-0 = 800
761 They can be ordered either way, but the arm tools I've seen always put
762 the lower one first. It probably doesn't matter. krk@cygnus.com
764 XXX: Actually the order does matter. The second instruction (H-1)
765 moves the computed address into the PC, so it must be the second one
766 in the sequence. The problem, however is that whilst little endian code
767 stores the instructions in HI then LOW order, big endian code does the
768 reverse. nickc@cygnus.com */
770 #define LOW_HI_ORDER 0xF800F000
771 #define HI_LOW_ORDER 0xF000F800
774 insert_thumb_branch (br_insn
, rel_off
)
778 unsigned int low_bits
;
779 unsigned int high_bits
;
782 BFD_ASSERT ((rel_off
& 1) != 1);
784 rel_off
>>= 1; /* half word aligned address */
785 low_bits
= rel_off
& 0x000007FF; /* the bottom 11 bits */
786 high_bits
= (rel_off
>> 11) & 0x000007FF; /* the top 11 bits */
788 if ((br_insn
& LOW_HI_ORDER
) == LOW_HI_ORDER
)
789 br_insn
= LOW_HI_ORDER
| (low_bits
<< 16) | high_bits
;
790 else if ((br_insn
& HI_LOW_ORDER
) == HI_LOW_ORDER
)
791 br_insn
= HI_LOW_ORDER
| (high_bits
<< 16) | low_bits
;
793 abort (); /* error - not a valid branch instruction form */
795 /* FIXME: abort is probably not the right call. krk@cygnus.com */
800 /* Thumb code calling an ARM function */
802 elf32_thumb_to_arm_stub (info
, name
, input_bfd
, output_bfd
, input_section
,
803 hit_data
, sym_sec
, offset
, addend
, val
)
804 struct bfd_link_info
* info
;
808 asection
* input_section
;
812 bfd_signed_vma addend
;
817 unsigned long int tmp
;
819 struct elf_link_hash_entry
* myh
;
820 struct elf32_arm_link_hash_table
* globals
;
822 myh
= find_thumb_glue (info
, name
, input_bfd
);
826 globals
= elf32_arm_hash_table (info
);
828 BFD_ASSERT (globals
!= NULL
);
829 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
831 my_offset
= myh
->root
.u
.def
.value
;
833 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
834 THUMB2ARM_GLUE_SECTION_NAME
);
836 BFD_ASSERT (s
!= NULL
);
837 BFD_ASSERT (s
->contents
!= NULL
);
838 BFD_ASSERT (s
->output_section
!= NULL
);
840 if ((my_offset
& 0x01) == 0x01)
843 && sym_sec
->owner
!= NULL
844 && !INTERWORK_FLAG (sym_sec
->owner
))
847 (_ ("%s(%s): warning: interworking not enabled."),
848 bfd_get_filename (sym_sec
->owner
), name
);
850 (_ (" first occurrence: %s: thumb call to arm"),
851 bfd_get_filename (input_bfd
));
857 myh
->root
.u
.def
.value
= my_offset
;
859 bfd_put_16 (output_bfd
, t2a1_bx_pc_insn
,
860 s
->contents
+ my_offset
);
862 bfd_put_16 (output_bfd
, t2a2_noop_insn
,
863 s
->contents
+ my_offset
+ 2);
866 ((bfd_signed_vma
) val
) /* Address of destination of the stub */
868 (s
->output_offset
/* Offset from the start of the current section to the start of the stubs. */
869 + my_offset
/* Offset of the start of this stub from the start of the stubs. */
870 + s
->output_section
->vma
) /* Address of the start of the current section. */
871 + 4 /* The branch instruction is 4 bytes into the stub. */
872 + 8); /* ARM branches work from the pc of the instruction + 8. */
874 bfd_put_32 (output_bfd
,
875 t2a3_b_insn
| ((ret_offset
>> 2) & 0x00FFFFFF),
876 s
->contents
+ my_offset
+ 4);
879 BFD_ASSERT (my_offset
<= globals
->thumb_glue_size
);
881 /* Now go back and fix up the original BL insn to point
886 - (input_section
->output_offset
890 tmp
= bfd_get_32 (input_bfd
, hit_data
891 - input_section
->vma
);
893 bfd_put_32 (output_bfd
,
894 insert_thumb_branch (tmp
, ret_offset
),
895 hit_data
- input_section
->vma
);
900 /* Arm code calling a Thumb function */
902 elf32_arm_to_thumb_stub (info
, name
, input_bfd
, output_bfd
, input_section
,
903 hit_data
, sym_sec
, offset
, addend
, val
)
904 struct bfd_link_info
* info
;
908 asection
* input_section
;
912 bfd_signed_vma addend
;
915 unsigned long int tmp
;
919 struct elf_link_hash_entry
* myh
;
920 struct elf32_arm_link_hash_table
* globals
;
922 myh
= find_arm_glue (info
, name
, input_bfd
);
926 globals
= elf32_arm_hash_table (info
);
928 BFD_ASSERT (globals
!= NULL
);
929 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
931 my_offset
= myh
->root
.u
.def
.value
;
932 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
933 ARM2THUMB_GLUE_SECTION_NAME
);
934 BFD_ASSERT (s
!= NULL
);
935 BFD_ASSERT (s
->contents
!= NULL
);
936 BFD_ASSERT (s
->output_section
!= NULL
);
938 if ((my_offset
& 0x01) == 0x01)
941 && sym_sec
->owner
!= NULL
942 && !INTERWORK_FLAG (sym_sec
->owner
))
945 (_ ("%s(%s): warning: interworking not enabled."),
946 bfd_get_filename (sym_sec
->owner
), name
);
948 (_ (" first occurrence: %s: arm call to thumb"),
949 bfd_get_filename (input_bfd
));
952 myh
->root
.u
.def
.value
= my_offset
;
954 bfd_put_32 (output_bfd
, a2t1_ldr_insn
,
955 s
->contents
+ my_offset
);
957 bfd_put_32 (output_bfd
, a2t2_bx_r12_insn
,
958 s
->contents
+ my_offset
+ 4);
960 /* It's a thumb address. Add the low order bit. */
961 bfd_put_32 (output_bfd
, val
| a2t3_func_addr_insn
,
962 s
->contents
+ my_offset
+ 8);
965 BFD_ASSERT (my_offset
<= globals
->arm_glue_size
);
967 tmp
= bfd_get_32 (input_bfd
, hit_data
);
968 tmp
= tmp
& 0xFF000000;
970 /* Somehow these are both 4 too far, so subtract 8. */
971 ret_offset
= s
->output_offset
973 + s
->output_section
->vma
974 - (input_section
->output_offset
975 + input_section
->output_section
->vma
979 tmp
= tmp
| ((ret_offset
>> 2) & 0x00FFFFFF);
981 bfd_put_32 (output_bfd
, tmp
, hit_data
982 - input_section
->vma
);
987 /* Perform a relocation as part of a final link. */
988 static bfd_reloc_status_type
989 elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
990 input_section
, contents
, rel
, value
,
991 info
, sym_sec
, sym_name
, sym_flags
, h
)
992 reloc_howto_type
* howto
;
995 asection
* input_section
;
997 Elf_Internal_Rela
* rel
;
999 struct bfd_link_info
* info
;
1001 const char * sym_name
;
1002 unsigned char sym_flags
;
1003 struct elf_link_hash_entry
* h
;
1005 unsigned long r_type
= howto
->type
;
1006 unsigned long r_symndx
;
1007 bfd_byte
* hit_data
= contents
+ rel
->r_offset
;
1008 bfd
* dynobj
= NULL
;
1009 Elf_Internal_Shdr
* symtab_hdr
;
1010 struct elf_link_hash_entry
** sym_hashes
;
1011 bfd_vma
* local_got_offsets
;
1012 asection
* sgot
= NULL
;
1013 asection
* splt
= NULL
;
1014 asection
* sreloc
= NULL
;
1016 bfd_signed_vma signed_addend
;
1017 struct elf32_arm_link_hash_table
* globals
;
1019 globals
= elf32_arm_hash_table (info
);
1021 dynobj
= elf_hash_table (info
)->dynobj
;
1024 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1025 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1027 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1028 sym_hashes
= elf_sym_hashes (input_bfd
);
1029 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1030 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1033 addend
= bfd_get_32 (input_bfd
, hit_data
) & howto
->src_mask
;
1035 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1038 signed_addend
&= ~ howto
->src_mask
;
1039 signed_addend
|= addend
;
1042 signed_addend
= addend
;
1044 addend
= signed_addend
= rel
->r_addend
;
1050 return bfd_reloc_ok
;
1055 /* When generating a shared object, these relocations are copied
1056 into the output file to be resolved at run time. */
1059 && (r_type
!= R_ARM_PC24
1062 && (! info
->symbolic
1063 || (h
->elf_link_hash_flags
1064 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1066 Elf_Internal_Rel outrel
;
1067 boolean skip
, relocate
;
1073 name
= (bfd_elf_string_from_elf_section
1075 elf_elfheader (input_bfd
)->e_shstrndx
,
1076 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1078 return bfd_reloc_notsupported
;
1080 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
1081 && strcmp (bfd_get_section_name (input_bfd
,
1085 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1086 BFD_ASSERT (sreloc
!= NULL
);
1091 if (elf_section_data (input_section
)->stab_info
== NULL
)
1092 outrel
.r_offset
= rel
->r_offset
;
1097 off
= (_bfd_stab_section_offset
1098 (output_bfd
, &elf_hash_table (info
)->stab_info
,
1100 & elf_section_data (input_section
)->stab_info
,
1102 if (off
== (bfd_vma
) -1)
1104 outrel
.r_offset
= off
;
1107 outrel
.r_offset
+= (input_section
->output_section
->vma
1108 + input_section
->output_offset
);
1112 memset (&outrel
, 0, sizeof outrel
);
1115 else if (r_type
== R_ARM_PC24
)
1117 BFD_ASSERT (h
!= NULL
&& h
->dynindx
!= -1);
1118 if ((input_section
->flags
& SEC_ALLOC
) != 0)
1122 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_PC24
);
1127 || ((info
->symbolic
|| h
->dynindx
== -1)
1128 && (h
->elf_link_hash_flags
1129 & ELF_LINK_HASH_DEF_REGULAR
) != 0))
1132 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1136 BFD_ASSERT (h
->dynindx
!= -1);
1137 if ((input_section
->flags
& SEC_ALLOC
) != 0)
1141 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_ABS32
);
1145 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1146 (((Elf32_External_Rel
*)
1148 + sreloc
->reloc_count
));
1149 ++sreloc
->reloc_count
;
1151 /* If this reloc is against an external symbol, we do not want to
1152 fiddle with the addend. Otherwise, we need to include the symbol
1153 value so that it becomes an addend for the dynamic reloc. */
1155 return bfd_reloc_ok
;
1158 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1159 contents
, rel
->r_offset
, value
,
1162 else switch (r_type
)
1165 /* Arm B/BL instruction */
1167 /* Check for arm calling thumb function. */
1168 if (sym_flags
== STT_ARM_TFUNC
)
1170 elf32_arm_to_thumb_stub (info
, sym_name
, input_bfd
, output_bfd
,
1171 input_section
, hit_data
, sym_sec
, rel
->r_offset
,
1172 signed_addend
, value
);
1173 return bfd_reloc_ok
;
1176 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1177 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0)
1179 /* The old way of doing things. Trearing the addend as a
1180 byte sized field and adding in the pipeline offset. */
1182 value
-= (input_section
->output_section
->vma
1183 + input_section
->output_offset
);
1184 value
-= rel
->r_offset
;
1187 if (! globals
->no_pipeline_knowledge
)
1192 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
1194 S is the address of the symbol in the relocation.
1195 P is address of the instruction being relocated.
1196 A is the addend (extracted from the instruction) in bytes.
1198 S is held in 'value'.
1199 P is the base address of the section containing the instruction
1200 plus the offset of the reloc into that section, ie:
1201 (input_section->output_section->vma +
1202 input_section->output_offset +
1204 A is the addend, converted into bytes, ie:
1207 Note: None of these operations have knowledge of the pipeline
1208 size of the processor, thus it is up to the assembler to encode
1209 this information into the addend. */
1211 value
-= (input_section
->output_section
->vma
1212 + input_section
->output_offset
);
1213 value
-= rel
->r_offset
;
1214 value
+= (signed_addend
<< howto
->size
);
1216 /* Previous versions of this code also used to add in the pipeline
1217 offset here. This is wrong because the linker is not supposed
1218 to know about such things, and one day it might change. In order
1219 to support old binaries that need the old behaviour however, so
1220 we attempt to detect which ABI was used to create the reloc. */
1221 if (! globals
->no_pipeline_knowledge
)
1223 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form */
1225 i_ehdrp
= elf_elfheader (input_bfd
);
1227 if (i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1232 /* It is not an error for an undefined weak reference to be
1233 out of range. Any program that branches to such a symbol
1234 is going to crash anyway, so there is no point worrying
1235 about getting the destination exactly right. */
1236 if (! h
|| h
->root
.type
!= bfd_link_hash_undefweak
)
1238 /* Perform a signed range check. */
1239 signed_addend
= value
;
1240 signed_addend
>>= howto
->rightshift
;
1241 if (signed_addend
> ((bfd_signed_vma
)(howto
->dst_mask
>> 1))
1242 || signed_addend
< - ((bfd_signed_vma
) ((howto
->dst_mask
+ 1) >> 1)))
1243 return bfd_reloc_overflow
;
1246 value
= (signed_addend
& howto
->dst_mask
)
1247 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1252 if (sym_flags
== STT_ARM_TFUNC
)
1257 value
-= (input_section
->output_section
->vma
1258 + input_section
->output_offset
);
1263 bfd_put_32 (input_bfd
, value
, hit_data
);
1264 return bfd_reloc_ok
;
1268 if ((long) value
> 0x7f || (long) value
< -0x80)
1269 return bfd_reloc_overflow
;
1271 bfd_put_8 (input_bfd
, value
, hit_data
);
1272 return bfd_reloc_ok
;
1277 if ((long) value
> 0x7fff || (long) value
< -0x8000)
1278 return bfd_reloc_overflow
;
1280 bfd_put_16 (input_bfd
, value
, hit_data
);
1281 return bfd_reloc_ok
;
1284 /* Support ldr and str instruction for the arm */
1285 /* Also thumb b (unconditional branch). ??? Really? */
1288 if ((long) value
> 0x7ff || (long) value
< -0x800)
1289 return bfd_reloc_overflow
;
1291 value
|= (bfd_get_32 (input_bfd
, hit_data
) & 0xfffff000);
1292 bfd_put_32 (input_bfd
, value
, hit_data
);
1293 return bfd_reloc_ok
;
1295 case R_ARM_THM_ABS5
:
1296 /* Support ldr and str instructions for the thumb. */
1298 /* Need to refetch addend. */
1299 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1300 /* ??? Need to determine shift amount from operand size. */
1301 addend
>>= howto
->rightshift
;
1305 /* ??? Isn't value unsigned? */
1306 if ((long) value
> 0x1f || (long) value
< -0x10)
1307 return bfd_reloc_overflow
;
1309 /* ??? Value needs to be properly shifted into place first. */
1310 value
|= bfd_get_16 (input_bfd
, hit_data
) & 0xf83f;
1311 bfd_put_16 (input_bfd
, value
, hit_data
);
1312 return bfd_reloc_ok
;
1314 case R_ARM_THM_PC22
:
1315 /* Thumb BL (branch long instruction). */
1318 boolean overflow
= false;
1319 bfd_vma upper_insn
= bfd_get_16 (input_bfd
, hit_data
);
1320 bfd_vma lower_insn
= bfd_get_16 (input_bfd
, hit_data
+ 2);
1321 bfd_signed_vma reloc_signed_max
= (1 << (howto
->bitsize
- 1)) - 1;
1322 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1324 bfd_signed_vma signed_check
;
1327 /* Need to refetch the addend and squish the two 11 bit pieces
1330 bfd_vma upper
= upper_insn
& 0x7ff;
1331 bfd_vma lower
= lower_insn
& 0x7ff;
1332 upper
= (upper
^ 0x400) - 0x400; /* sign extend */
1333 addend
= (upper
<< 12) | (lower
<< 1);
1334 signed_addend
= addend
;
1338 /* If it is not a call to thumb, assume call to arm.
1339 If it is a call relative to a section name, then it is not a
1340 function call at all, but rather a long jump. */
1341 if (sym_flags
!= STT_ARM_TFUNC
&& sym_flags
!= STT_SECTION
)
1343 if (elf32_thumb_to_arm_stub
1344 (info
, sym_name
, input_bfd
, output_bfd
, input_section
,
1345 hit_data
, sym_sec
, rel
->r_offset
, signed_addend
, value
))
1346 return bfd_reloc_ok
;
1348 return bfd_reloc_dangerous
;
1351 relocation
= value
+ signed_addend
;
1353 relocation
-= (input_section
->output_section
->vma
1354 + input_section
->output_offset
1357 if (! globals
->no_pipeline_knowledge
)
1359 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form */
1361 i_ehdrp
= elf_elfheader (input_bfd
);
1363 /* Previous versions of this code also used to add in the pipline
1364 offset here. This is wrong because the linker is not supposed
1365 to know about such things, and one day it might change. In order
1366 to support old binaries that need the old behaviour however, so
1367 we attempt to detect which ABI was used to create the reloc. */
1368 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1369 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0
1370 || i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1374 check
= relocation
>> howto
->rightshift
;
1376 /* If this is a signed value, the rightshift just dropped
1377 leading 1 bits (assuming twos complement). */
1378 if ((bfd_signed_vma
) relocation
>= 0)
1379 signed_check
= check
;
1381 signed_check
= check
| ~((bfd_vma
) -1 >> howto
->rightshift
);
1383 /* Assumes two's complement. */
1384 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1387 /* Put RELOCATION back into the insn. */
1388 upper_insn
= (upper_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 12) & 0x7ff);
1389 lower_insn
= (lower_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 1) & 0x7ff);
1391 /* Put the relocated value back in the object file: */
1392 bfd_put_16 (input_bfd
, upper_insn
, hit_data
);
1393 bfd_put_16 (input_bfd
, lower_insn
, hit_data
+ 2);
1395 return (overflow
? bfd_reloc_overflow
: bfd_reloc_ok
);
1399 case R_ARM_GNU_VTINHERIT
:
1400 case R_ARM_GNU_VTENTRY
:
1401 return bfd_reloc_ok
;
1404 return bfd_reloc_notsupported
;
1406 case R_ARM_GLOB_DAT
:
1407 return bfd_reloc_notsupported
;
1409 case R_ARM_JUMP_SLOT
:
1410 return bfd_reloc_notsupported
;
1412 case R_ARM_RELATIVE
:
1413 return bfd_reloc_notsupported
;
1416 /* Relocation is relative to the start of the
1417 global offset table. */
1419 BFD_ASSERT (sgot
!= NULL
);
1421 return bfd_reloc_notsupported
;
1423 /* Note that sgot->output_offset is not involved in this
1424 calculation. We always want the start of .got. If we
1425 define _GLOBAL_OFFSET_TABLE in a different way, as is
1426 permitted by the ABI, we might have to change this
1429 value
-= sgot
->output_section
->vma
;
1430 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1431 contents
, rel
->r_offset
, value
,
1435 /* Use global offset table as symbol value. */
1437 BFD_ASSERT (sgot
!= NULL
);
1440 return bfd_reloc_notsupported
;
1442 value
= sgot
->output_section
->vma
;
1443 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1444 contents
, rel
->r_offset
, value
,
1448 /* Relocation is to the entry for this symbol in the
1449 global offset table. */
1451 return bfd_reloc_notsupported
;
1457 off
= h
->got
.offset
;
1458 BFD_ASSERT (off
!= (bfd_vma
) -1);
1460 if (!elf_hash_table (info
)->dynamic_sections_created
||
1461 (info
->shared
&& (info
->symbolic
|| h
->dynindx
== -1)
1462 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1464 /* This is actually a static link, or it is a -Bsymbolic link
1465 and the symbol is defined locally. We must initialize this
1466 entry in the global offset table. Since the offset must
1467 always be a multiple of 4, we use the least significant bit
1468 to record whether we have initialized it already.
1470 When doing a dynamic link, we create a .rel.got relocation
1471 entry to initialize the value. This is done in the
1472 finish_dynamic_symbol routine. */
1478 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1483 value
= sgot
->output_offset
+ off
;
1489 BFD_ASSERT (local_got_offsets
!= NULL
&&
1490 local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1492 off
= local_got_offsets
[r_symndx
];
1494 /* The offset must always be a multiple of 4. We use the
1495 least significant bit to record whether we have already
1496 generated the necessary reloc. */
1501 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1506 Elf_Internal_Rel outrel
;
1508 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
1509 BFD_ASSERT (srelgot
!= NULL
);
1511 outrel
.r_offset
= (sgot
->output_section
->vma
1512 + sgot
->output_offset
1514 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1515 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1516 (((Elf32_External_Rel
*)
1518 + srelgot
->reloc_count
));
1519 ++srelgot
->reloc_count
;
1522 local_got_offsets
[r_symndx
] |= 1;
1525 value
= sgot
->output_offset
+ off
;
1528 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1529 contents
, rel
->r_offset
, value
,
1533 /* Relocation is to the entry for this symbol in the
1534 procedure linkage table. */
1536 /* Resolve a PLT32 reloc against a local symbol directly,
1537 without using the procedure linkage table. */
1539 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1540 contents
, rel
->r_offset
, value
,
1543 if (h
->plt
.offset
== (bfd_vma
) -1)
1544 /* We didn't make a PLT entry for this symbol. This
1545 happens when statically linking PIC code, or when
1546 using -Bsymbolic. */
1547 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1548 contents
, rel
->r_offset
, value
,
1551 BFD_ASSERT(splt
!= NULL
);
1553 return bfd_reloc_notsupported
;
1555 value
= (splt
->output_section
->vma
1556 + splt
->output_offset
1558 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1559 contents
, rel
->r_offset
, value
,
1563 return bfd_reloc_notsupported
;
1565 case R_ARM_AMP_VCALL9
:
1566 return bfd_reloc_notsupported
;
1568 case R_ARM_RSBREL32
:
1569 return bfd_reloc_notsupported
;
1571 case R_ARM_THM_RPC22
:
1572 return bfd_reloc_notsupported
;
1575 return bfd_reloc_notsupported
;
1578 return bfd_reloc_notsupported
;
1581 return bfd_reloc_notsupported
;
1584 return bfd_reloc_notsupported
;
1587 return bfd_reloc_notsupported
;
1592 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
1594 arm_add_to_rel (abfd
, address
, howto
, increment
)
1597 reloc_howto_type
* howto
;
1598 bfd_signed_vma increment
;
1601 bfd_signed_vma addend
;
1603 contents
= bfd_get_32 (abfd
, address
);
1605 /* Get the (signed) value from the instruction. */
1606 addend
= contents
& howto
->src_mask
;
1607 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1609 bfd_signed_vma mask
;
1612 mask
&= ~ howto
->src_mask
;
1616 /* Add in the increment, (which is a byte value). */
1617 switch (howto
->type
)
1619 case R_ARM_THM_PC22
:
1621 addend
+= increment
;
1625 addend
<<= howto
->size
;
1626 addend
+= increment
;
1628 /* Should we check for overflow here ? */
1630 /* Drop any undesired bits. */
1631 addend
>>= howto
->rightshift
;
1635 contents
= (contents
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
1637 bfd_put_32 (abfd
, contents
, address
);
1639 #endif /* USE_REL */
1641 /* Relocate an ARM ELF section. */
1643 elf32_arm_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1644 contents
, relocs
, local_syms
, local_sections
)
1646 struct bfd_link_info
* info
;
1648 asection
* input_section
;
1649 bfd_byte
* contents
;
1650 Elf_Internal_Rela
* relocs
;
1651 Elf_Internal_Sym
* local_syms
;
1652 asection
** local_sections
;
1654 Elf_Internal_Shdr
* symtab_hdr
;
1655 struct elf_link_hash_entry
** sym_hashes
;
1656 Elf_Internal_Rela
* rel
;
1657 Elf_Internal_Rela
* relend
;
1660 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1661 sym_hashes
= elf_sym_hashes (input_bfd
);
1664 relend
= relocs
+ input_section
->reloc_count
;
1665 for (; rel
< relend
; rel
++)
1668 reloc_howto_type
* howto
;
1669 unsigned long r_symndx
;
1670 Elf_Internal_Sym
* sym
;
1672 struct elf_link_hash_entry
* h
;
1674 bfd_reloc_status_type r
;
1677 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1678 r_type
= ELF32_R_TYPE (rel
->r_info
);
1680 if ( r_type
== R_ARM_GNU_VTENTRY
1681 || r_type
== R_ARM_GNU_VTINHERIT
)
1684 elf32_arm_info_to_howto (input_bfd
, & bfd_reloc
, rel
);
1685 howto
= bfd_reloc
.howto
;
1687 if (info
->relocateable
)
1689 /* This is a relocateable link. We don't have to change
1690 anything, unless the reloc is against a section symbol,
1691 in which case we have to adjust according to where the
1692 section symbol winds up in the output section. */
1693 if (r_symndx
< symtab_hdr
->sh_info
)
1695 sym
= local_syms
+ r_symndx
;
1696 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1698 sec
= local_sections
[r_symndx
];
1700 arm_add_to_rel (input_bfd
, contents
+ rel
->r_offset
,
1701 howto
, sec
->output_offset
+ sym
->st_value
);
1703 rel
->r_addend
+= (sec
->output_offset
+ sym
->st_value
)
1704 >> howto
->rightshift
;
1712 /* This is a final link. */
1716 if (r_symndx
< symtab_hdr
->sh_info
)
1718 sym
= local_syms
+ r_symndx
;
1719 sec
= local_sections
[r_symndx
];
1720 relocation
= (sec
->output_section
->vma
1721 + sec
->output_offset
1726 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1727 while (h
->root
.type
== bfd_link_hash_indirect
1728 || h
->root
.type
== bfd_link_hash_warning
)
1729 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1730 if (h
->root
.type
== bfd_link_hash_defined
1731 || h
->root
.type
== bfd_link_hash_defweak
)
1733 int relocation_needed
= 1;
1735 sec
= h
->root
.u
.def
.section
;
1737 /* In these cases, we don't need the relocation value.
1738 We check specially because in some obscure cases
1739 sec->output_section will be NULL. */
1746 (!info
->symbolic
&& h
->dynindx
!= -1)
1747 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1749 && ((input_section
->flags
& SEC_ALLOC
) != 0)
1751 relocation_needed
= 0;
1755 relocation_needed
= 0;
1759 if (elf_hash_table(info
)->dynamic_sections_created
1761 || (!info
->symbolic
&& h
->dynindx
!= -1)
1762 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1765 relocation_needed
= 0;
1769 if (h
->plt
.offset
!= (bfd_vma
)-1)
1770 relocation_needed
= 0;
1774 if (sec
->output_section
== NULL
)
1776 (*_bfd_error_handler
)
1777 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1778 bfd_get_filename (input_bfd
), h
->root
.root
.string
,
1779 bfd_get_section_name (input_bfd
, input_section
));
1780 relocation_needed
= 0;
1784 if (relocation_needed
)
1785 relocation
= h
->root
.u
.def
.value
1786 + sec
->output_section
->vma
1787 + sec
->output_offset
;
1791 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1793 else if (info
->shared
&& !info
->symbolic
&& !info
->no_undefined
)
1797 if (!((*info
->callbacks
->undefined_symbol
)
1798 (info
, h
->root
.root
.string
, input_bfd
,
1799 input_section
, rel
->r_offset
)))
1806 name
= h
->root
.root
.string
;
1809 name
= (bfd_elf_string_from_elf_section
1810 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
1811 if (name
== NULL
|| *name
== '\0')
1812 name
= bfd_section_name (input_bfd
, sec
);
1815 r
= elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
1816 input_section
, contents
, rel
,
1817 relocation
, info
, sec
, name
,
1818 (h
? ELF_ST_TYPE (h
->type
) :
1819 ELF_ST_TYPE (sym
->st_info
)), h
);
1821 if (r
!= bfd_reloc_ok
)
1823 const char * msg
= (const char *) 0;
1827 case bfd_reloc_overflow
:
1828 if (!((*info
->callbacks
->reloc_overflow
)
1829 (info
, name
, howto
->name
, (bfd_vma
) 0,
1830 input_bfd
, input_section
, rel
->r_offset
)))
1834 case bfd_reloc_undefined
:
1835 if (!((*info
->callbacks
->undefined_symbol
)
1836 (info
, name
, input_bfd
, input_section
,
1841 case bfd_reloc_outofrange
:
1842 msg
= _ ("internal error: out of range error");
1845 case bfd_reloc_notsupported
:
1846 msg
= _ ("internal error: unsupported relocation error");
1849 case bfd_reloc_dangerous
:
1850 msg
= _ ("internal error: dangerous error");
1854 msg
= _ ("internal error: unknown error");
1858 if (!((*info
->callbacks
->warning
)
1859 (info
, msg
, name
, input_bfd
, input_section
,
1870 /* Function to keep ARM specific flags in the ELF header. */
1872 elf32_arm_set_private_flags (abfd
, flags
)
1876 if (elf_flags_init (abfd
)
1877 && elf_elfheader (abfd
)->e_flags
!= flags
)
1879 if (flags
& EF_INTERWORK
)
1880 _bfd_error_handler (_ ("\
1881 Warning: Not setting interwork flag of %s since it has already been specified as non-interworking"),
1882 bfd_get_filename (abfd
));
1884 _bfd_error_handler (_ ("\
1885 Warning: Clearing the interwork flag of %s due to outside request"),
1886 bfd_get_filename (abfd
));
1890 elf_elfheader (abfd
)->e_flags
= flags
;
1891 elf_flags_init (abfd
) = true;
1897 /* Copy backend specific data from one object module to another */
1899 elf32_arm_copy_private_bfd_data (ibfd
, obfd
)
1906 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1907 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1910 in_flags
= elf_elfheader (ibfd
)->e_flags
;
1911 out_flags
= elf_elfheader (obfd
)->e_flags
;
1913 if (elf_flags_init (obfd
) && in_flags
!= out_flags
)
1915 /* Cannot mix PIC and non-PIC code. */
1916 if ((in_flags
& EF_PIC
) != (out_flags
& EF_PIC
))
1919 /* Cannot mix APCS26 and APCS32 code. */
1920 if ((in_flags
& EF_APCS_26
) != (out_flags
& EF_APCS_26
))
1923 /* Cannot mix float APCS and non-float APCS code. */
1924 if ((in_flags
& EF_APCS_FLOAT
) != (out_flags
& EF_APCS_FLOAT
))
1927 /* If the src and dest have different interworking flags
1928 then turn off the interworking bit. */
1929 if ((in_flags
& EF_INTERWORK
) != (out_flags
& EF_INTERWORK
))
1931 if (out_flags
& EF_INTERWORK
)
1932 _bfd_error_handler (_ ("\
1933 Warning: Clearing the interwork flag in %s because non-interworking code in %s has been linked with it"),
1934 bfd_get_filename (obfd
), bfd_get_filename (ibfd
));
1936 in_flags
&= ~EF_INTERWORK
;
1940 elf_elfheader (obfd
)->e_flags
= in_flags
;
1941 elf_flags_init (obfd
) = true;
1946 /* Merge backend specific data from an object file to the output
1947 object file when linking. */
1949 elf32_arm_merge_private_bfd_data (ibfd
, obfd
)
1956 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1957 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1960 /* Check if we have the same endianess */
1961 if ( ibfd
->xvec
->byteorder
!= obfd
->xvec
->byteorder
1962 && obfd
->xvec
->byteorder
!= BFD_ENDIAN_UNKNOWN
1963 && ibfd
->xvec
->byteorder
!= BFD_ENDIAN_UNKNOWN
)
1965 (*_bfd_error_handler
)
1966 (_("%s: compiled for a %s endian system and target is %s endian"),
1967 bfd_get_filename (ibfd
),
1968 bfd_big_endian (ibfd
) ? "big" : "little",
1969 bfd_big_endian (obfd
) ? "big" : "little");
1971 bfd_set_error (bfd_error_wrong_format
);
1975 /* The input BFD must have had its flags initialised. */
1976 /* The following seems bogus to me -- The flags are initialized in
1977 the assembler but I don't think an elf_flags_init field is
1978 written into the object */
1979 /* BFD_ASSERT (elf_flags_init (ibfd)); */
1981 in_flags
= elf_elfheader (ibfd
)->e_flags
;
1982 out_flags
= elf_elfheader (obfd
)->e_flags
;
1984 if (!elf_flags_init (obfd
))
1986 /* If the input is the default architecture then do not
1987 bother setting the flags for the output architecture,
1988 instead allow future merges to do this. If no future
1989 merges ever set these flags then they will retain their
1990 unitialised values, which surprise surprise, correspond
1991 to the default values. */
1992 if (bfd_get_arch_info (ibfd
)->the_default
)
1995 elf_flags_init (obfd
) = true;
1996 elf_elfheader (obfd
)->e_flags
= in_flags
;
1998 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
1999 && bfd_get_arch_info (obfd
)->the_default
)
2000 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
), bfd_get_mach (ibfd
));
2005 /* Check flag compatibility. */
2006 if (in_flags
== out_flags
)
2009 /* Complain about various flag mismatches. */
2011 if ((in_flags
& EF_APCS_26
) != (out_flags
& EF_APCS_26
))
2012 _bfd_error_handler (_ ("\
2013 Error: %s compiled for APCS-%d, whereas %s is compiled for APCS-%d"),
2014 bfd_get_filename (ibfd
),
2015 in_flags
& EF_APCS_26
? 26 : 32,
2016 bfd_get_filename (obfd
),
2017 out_flags
& EF_APCS_26
? 26 : 32);
2019 if ((in_flags
& EF_APCS_FLOAT
) != (out_flags
& EF_APCS_FLOAT
))
2020 _bfd_error_handler (_ ("\
2021 Error: %s passes floats in %s registers, whereas %s passes them in %s registers"),
2022 bfd_get_filename (ibfd
),
2023 in_flags
& EF_APCS_FLOAT
? _ ("float") : _ ("integer"),
2024 bfd_get_filename (obfd
),
2025 out_flags
& EF_APCS_26
? _ ("float") : _ ("integer"));
2027 if ((in_flags
& EF_PIC
) != (out_flags
& EF_PIC
))
2028 _bfd_error_handler (_ ("\
2029 Error: %s is compiled as position %s code, whereas %s is not"),
2030 bfd_get_filename (ibfd
),
2031 in_flags
& EF_PIC
? _ ("independent") : _ ("dependent"),
2032 bfd_get_filename (obfd
));
2034 /* Interworking mismatch is only a warning. */
2035 if ((in_flags
& EF_INTERWORK
) != (out_flags
& EF_INTERWORK
))
2037 _bfd_error_handler (_ ("\
2038 Warning: %s %s interworking, whereas %s %s"),
2039 bfd_get_filename (ibfd
),
2040 in_flags
& EF_INTERWORK
? _ ("supports") : _ ("does not support"),
2041 bfd_get_filename (obfd
),
2042 out_flags
& EF_INTERWORK
? _ ("does not") : _ ("does"));
2049 /* Display the flags field */
2051 elf32_arm_print_private_bfd_data (abfd
, ptr
)
2055 FILE *file
= (FILE *) ptr
;
2057 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
2059 /* Print normal ELF private data. */
2060 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
2062 /* Ignore init flag - it may not be set, despite the flags field containing valid data. */
2064 /* xgettext:c-format */
2065 fprintf (file
, _ ("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
2067 if (elf_elfheader (abfd
)->e_flags
& EF_INTERWORK
)
2068 fprintf (file
, _ (" [interworking enabled]"));
2070 fprintf (file
, _ (" [interworking not enabled]"));
2072 if (elf_elfheader (abfd
)->e_flags
& EF_APCS_26
)
2073 fprintf (file
, _ (" [APCS-26]"));
2075 fprintf (file
, _ (" [APCS-32]"));
2077 if (elf_elfheader (abfd
)->e_flags
& EF_APCS_FLOAT
)
2078 fprintf (file
, _ (" [floats passed in float registers]"));
2080 fprintf (file
, _ (" [floats passed in integer registers]"));
2082 if (elf_elfheader (abfd
)->e_flags
& EF_PIC
)
2083 fprintf (file
, _ (" [position independent]"));
2085 fprintf (file
, _ (" [absolute position]"));
2093 elf32_arm_get_symbol_type (elf_sym
, type
)
2094 Elf_Internal_Sym
* elf_sym
;
2097 if (ELF_ST_TYPE (elf_sym
->st_info
) == STT_ARM_TFUNC
)
2098 return ELF_ST_TYPE (elf_sym
->st_info
);
2104 elf32_arm_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
2106 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2107 Elf_Internal_Rela
*rel
;
2108 struct elf_link_hash_entry
*h
;
2109 Elf_Internal_Sym
*sym
;
2113 switch (ELF32_R_TYPE (rel
->r_info
))
2115 case R_ARM_GNU_VTINHERIT
:
2116 case R_ARM_GNU_VTENTRY
:
2120 switch (h
->root
.type
)
2122 case bfd_link_hash_defined
:
2123 case bfd_link_hash_defweak
:
2124 return h
->root
.u
.def
.section
;
2126 case bfd_link_hash_common
:
2127 return h
->root
.u
.c
.p
->section
;
2136 if (!(elf_bad_symtab (abfd
)
2137 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
2138 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
2139 && sym
->st_shndx
!= SHN_COMMON
))
2141 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
2147 /* Update the got entry reference counts for the section being removed. */
2150 elf32_arm_gc_sweep_hook (abfd
, info
, sec
, relocs
)
2151 bfd
*abfd ATTRIBUTE_UNUSED
;
2152 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2153 asection
*sec ATTRIBUTE_UNUSED
;
2154 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
;
2156 /* We don't support garbage collection of GOT and PLT relocs yet. */
2160 /* Look through the relocs for a section during the first phase. */
2163 elf32_arm_check_relocs (abfd
, info
, sec
, relocs
)
2165 struct bfd_link_info
* info
;
2167 const Elf_Internal_Rela
* relocs
;
2169 Elf_Internal_Shdr
* symtab_hdr
;
2170 struct elf_link_hash_entry
** sym_hashes
;
2171 struct elf_link_hash_entry
** sym_hashes_end
;
2172 const Elf_Internal_Rela
* rel
;
2173 const Elf_Internal_Rela
* rel_end
;
2175 asection
* sgot
, *srelgot
, *sreloc
;
2176 bfd_vma
* local_got_offsets
;
2178 if (info
->relocateable
)
2181 sgot
= srelgot
= sreloc
= NULL
;
2183 dynobj
= elf_hash_table (info
)->dynobj
;
2184 local_got_offsets
= elf_local_got_offsets (abfd
);
2186 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2187 sym_hashes
= elf_sym_hashes (abfd
);
2188 sym_hashes_end
= sym_hashes
+ symtab_hdr
->sh_size
/sizeof(Elf32_External_Sym
);
2189 if (!elf_bad_symtab (abfd
))
2190 sym_hashes_end
-= symtab_hdr
->sh_info
;
2192 rel_end
= relocs
+ sec
->reloc_count
;
2193 for (rel
= relocs
; rel
< rel_end
; rel
++)
2195 struct elf_link_hash_entry
*h
;
2196 unsigned long r_symndx
;
2198 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2199 if (r_symndx
< symtab_hdr
->sh_info
)
2202 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2204 /* Some relocs require a global offset table. */
2207 switch (ELF32_R_TYPE (rel
->r_info
))
2212 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
2213 if (! _bfd_elf_create_got_section (dynobj
, info
))
2222 switch (ELF32_R_TYPE (rel
->r_info
))
2225 /* This symbol requires a global offset table entry. */
2228 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2229 BFD_ASSERT (sgot
!= NULL
);
2232 /* Get the got relocation section if necessary. */
2234 && (h
!= NULL
|| info
->shared
))
2236 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
2238 /* If no got relocation section, make one and initialize. */
2239 if (srelgot
== NULL
)
2241 srelgot
= bfd_make_section (dynobj
, ".rel.got");
2243 || ! bfd_set_section_flags (dynobj
, srelgot
,
2248 | SEC_LINKER_CREATED
2250 || ! bfd_set_section_alignment (dynobj
, srelgot
, 2))
2257 if (h
->got
.offset
!= (bfd_vma
) -1)
2258 /* We have already allocated space in the .got. */
2261 h
->got
.offset
= sgot
->_raw_size
;
2263 /* Make sure this symbol is output as a dynamic symbol. */
2264 if (h
->dynindx
== -1)
2265 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2268 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2272 /* This is a global offset table entry for a local
2274 if (local_got_offsets
== NULL
)
2277 register unsigned int i
;
2279 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
2280 local_got_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
2281 if (local_got_offsets
== NULL
)
2283 elf_local_got_offsets (abfd
) = local_got_offsets
;
2284 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
2285 local_got_offsets
[i
] = (bfd_vma
) -1;
2288 if (local_got_offsets
[r_symndx
] != (bfd_vma
) -1)
2289 /* We have already allocated space in the .got. */
2292 local_got_offsets
[r_symndx
] = sgot
->_raw_size
;
2295 /* If we are generating a shared object, we need to
2296 output a R_ARM_RELATIVE reloc so that the dynamic
2297 linker can adjust this GOT entry. */
2298 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2301 sgot
->_raw_size
+= 4;
2305 /* This symbol requires a procedure linkage table entry. We
2306 actually build the entry in adjust_dynamic_symbol,
2307 because this might be a case of linking PIC code which is
2308 never referenced by a dynamic object, in which case we
2309 don't need to generate a procedure linkage table entry
2312 /* If this is a local symbol, we resolve it directly without
2313 creating a procedure linkage table entry. */
2317 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2323 /* If we are creating a shared library, and this is a reloc
2324 against a global symbol, or a non PC relative reloc
2325 against a local symbol, then we need to copy the reloc
2326 into the shared library. However, if we are linking with
2327 -Bsymbolic, we do not need to copy a reloc against a
2328 global symbol which is defined in an object we are
2329 including in the link (i.e., DEF_REGULAR is set). At
2330 this point we have not seen all the input files, so it is
2331 possible that DEF_REGULAR is not set now but will be set
2332 later (it is never cleared). We account for that
2333 possibility below by storing information in the
2334 pcrel_relocs_copied field of the hash table entry. */
2336 && (ELF32_R_TYPE (rel
->r_info
) != R_ARM_PC24
2338 && (! info
->symbolic
2339 || (h
->elf_link_hash_flags
2340 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
2342 /* When creating a shared object, we must copy these
2343 reloc types into the output file. We create a reloc
2344 section in dynobj and make room for this reloc. */
2349 name
= (bfd_elf_string_from_elf_section
2351 elf_elfheader (abfd
)->e_shstrndx
,
2352 elf_section_data (sec
)->rel_hdr
.sh_name
));
2356 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
2357 && strcmp (bfd_get_section_name (abfd
, sec
),
2360 sreloc
= bfd_get_section_by_name (dynobj
, name
);
2365 sreloc
= bfd_make_section (dynobj
, name
);
2366 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
2367 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
2368 if ((sec
->flags
& SEC_ALLOC
) != 0)
2369 flags
|= SEC_ALLOC
| SEC_LOAD
;
2371 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
2372 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
2377 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
2378 /* If we are linking with -Bsymbolic, and this is a
2379 global symbol, we count the number of PC relative
2380 relocations we have entered for this symbol, so that
2381 we can discard them again if the symbol is later
2382 defined by a regular object. Note that this function
2383 is only called if we are using an elf_i386 linker
2384 hash table, which means that h is really a pointer to
2385 an elf_i386_link_hash_entry. */
2386 if (h
!= NULL
&& info
->symbolic
2387 && ELF32_R_TYPE (rel
->r_info
) == R_ARM_PC24
)
2389 struct elf32_arm_link_hash_entry
* eh
;
2390 struct elf32_arm_pcrel_relocs_copied
* p
;
2392 eh
= (struct elf32_arm_link_hash_entry
*) h
;
2394 for (p
= eh
->pcrel_relocs_copied
; p
!= NULL
; p
= p
->next
)
2395 if (p
->section
== sreloc
)
2400 p
= ((struct elf32_arm_pcrel_relocs_copied
*)
2401 bfd_alloc (dynobj
, sizeof * p
));
2405 p
->next
= eh
->pcrel_relocs_copied
;
2406 eh
->pcrel_relocs_copied
= p
;
2407 p
->section
= sreloc
;
2416 /* This relocation describes the C++ object vtable hierarchy.
2417 Reconstruct it for later use during GC. */
2418 case R_ARM_GNU_VTINHERIT
:
2419 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2423 /* This relocation describes which C++ vtable entries are actually
2424 used. Record for later use during GC. */
2425 case R_ARM_GNU_VTENTRY
:
2426 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
2436 /* Find the nearest line to a particular section and offset, for error
2437 reporting. This code is a duplicate of the code in elf.c, except
2438 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
2441 elf32_arm_find_nearest_line
2442 (abfd
, section
, symbols
, offset
, filename_ptr
, functionname_ptr
, line_ptr
)
2447 CONST
char ** filename_ptr
;
2448 CONST
char ** functionname_ptr
;
2449 unsigned int * line_ptr
;
2452 const char * filename
;
2457 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
2458 filename_ptr
, functionname_ptr
,
2462 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2463 &found
, filename_ptr
,
2464 functionname_ptr
, line_ptr
,
2465 &elf_tdata (abfd
)->line_info
))
2471 if (symbols
== NULL
)
2478 for (p
= symbols
; *p
!= NULL
; p
++)
2482 q
= (elf_symbol_type
*) *p
;
2484 if (bfd_get_section (&q
->symbol
) != section
)
2487 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
2492 filename
= bfd_asymbol_name (&q
->symbol
);
2497 if (q
->symbol
.section
== section
2498 && q
->symbol
.value
>= low_func
2499 && q
->symbol
.value
<= offset
)
2501 func
= (asymbol
*) q
;
2502 low_func
= q
->symbol
.value
;
2511 *filename_ptr
= filename
;
2512 *functionname_ptr
= bfd_asymbol_name (func
);
2518 /* Adjust a symbol defined by a dynamic object and referenced by a
2519 regular object. The current definition is in some section of the
2520 dynamic object, but we're not including those sections. We have to
2521 change the definition to something the rest of the link can
2525 elf32_arm_adjust_dynamic_symbol (info
, h
)
2526 struct bfd_link_info
* info
;
2527 struct elf_link_hash_entry
* h
;
2531 unsigned int power_of_two
;
2533 dynobj
= elf_hash_table (info
)->dynobj
;
2535 /* Make sure we know what is going on here. */
2536 BFD_ASSERT (dynobj
!= NULL
2537 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
2538 || h
->weakdef
!= NULL
2539 || ((h
->elf_link_hash_flags
2540 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2541 && (h
->elf_link_hash_flags
2542 & ELF_LINK_HASH_REF_REGULAR
) != 0
2543 && (h
->elf_link_hash_flags
2544 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
2546 /* If this is a function, put it in the procedure linkage table. We
2547 will fill in the contents of the procedure linkage table later,
2548 when we know the address of the .got section. */
2549 if (h
->type
== STT_FUNC
2550 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
2553 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
2554 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0)
2556 /* This case can occur if we saw a PLT32 reloc in an input
2557 file, but the symbol was never referred to by a dynamic
2558 object. In such a case, we don't actually need to build
2559 a procedure linkage table, and we can just do a PC32
2561 BFD_ASSERT ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0);
2565 /* Make sure this symbol is output as a dynamic symbol. */
2566 if (h
->dynindx
== -1)
2568 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2572 s
= bfd_get_section_by_name (dynobj
, ".plt");
2573 BFD_ASSERT (s
!= NULL
);
2575 /* If this is the first .plt entry, make room for the special
2577 if (s
->_raw_size
== 0)
2578 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2580 /* If this symbol is not defined in a regular file, and we are
2581 not generating a shared library, then set the symbol to this
2582 location in the .plt. This is required to make function
2583 pointers compare as equal between the normal executable and
2584 the shared library. */
2586 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2588 h
->root
.u
.def
.section
= s
;
2589 h
->root
.u
.def
.value
= s
->_raw_size
;
2592 h
->plt
.offset
= s
->_raw_size
;
2594 /* Make room for this entry. */
2595 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2597 /* We also need to make an entry in the .got.plt section, which
2598 will be placed in the .got section by the linker script. */
2600 s
= bfd_get_section_by_name (dynobj
, ".got.plt");
2601 BFD_ASSERT (s
!= NULL
);
2604 /* We also need to make an entry in the .rel.plt section. */
2606 s
= bfd_get_section_by_name (dynobj
, ".rel.plt");
2607 BFD_ASSERT (s
!= NULL
);
2608 s
->_raw_size
+= sizeof (Elf32_External_Rel
);
2613 /* If this is a weak symbol, and there is a real definition, the
2614 processor independent code will have arranged for us to see the
2615 real definition first, and we can just use the same value. */
2616 if (h
->weakdef
!= NULL
)
2618 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
2619 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
2620 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
2621 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
2625 /* This is a reference to a symbol defined by a dynamic object which
2626 is not a function. */
2628 /* If we are creating a shared library, we must presume that the
2629 only references to the symbol are via the global offset table.
2630 For such cases we need not do anything here; the relocations will
2631 be handled correctly by relocate_section. */
2635 /* We must allocate the symbol in our .dynbss section, which will
2636 become part of the .bss section of the executable. There will be
2637 an entry for this symbol in the .dynsym section. The dynamic
2638 object will contain position independent code, so all references
2639 from the dynamic object to this symbol will go through the global
2640 offset table. The dynamic linker will use the .dynsym entry to
2641 determine the address it must put in the global offset table, so
2642 both the dynamic object and the regular object will refer to the
2643 same memory location for the variable. */
2645 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
2646 BFD_ASSERT (s
!= NULL
);
2648 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
2649 copy the initial value out of the dynamic object and into the
2650 runtime process image. We need to remember the offset into the
2651 .rel.bss section we are going to use. */
2652 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2656 srel
= bfd_get_section_by_name (dynobj
, ".rel.bss");
2657 BFD_ASSERT (srel
!= NULL
);
2658 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
2659 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
2662 /* We need to figure out the alignment required for this symbol. I
2663 have no idea how ELF linkers handle this. */
2664 power_of_two
= bfd_log2 (h
->size
);
2665 if (power_of_two
> 3)
2668 /* Apply the required alignment. */
2669 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
2670 (bfd_size_type
) (1 << power_of_two
));
2671 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
2673 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
2677 /* Define the symbol as being at this point in the section. */
2678 h
->root
.u
.def
.section
= s
;
2679 h
->root
.u
.def
.value
= s
->_raw_size
;
2681 /* Increment the section size to make room for the symbol. */
2682 s
->_raw_size
+= h
->size
;
2687 /* Set the sizes of the dynamic sections. */
2690 elf32_arm_size_dynamic_sections (output_bfd
, info
)
2692 struct bfd_link_info
* info
;
2700 dynobj
= elf_hash_table (info
)->dynobj
;
2701 BFD_ASSERT (dynobj
!= NULL
);
2703 if (elf_hash_table (info
)->dynamic_sections_created
)
2705 /* Set the contents of the .interp section to the interpreter. */
2708 s
= bfd_get_section_by_name (dynobj
, ".interp");
2709 BFD_ASSERT (s
!= NULL
);
2710 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2711 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2716 /* We may have created entries in the .rel.got section.
2717 However, if we are not creating the dynamic sections, we will
2718 not actually use these entries. Reset the size of .rel.got,
2719 which will cause it to get stripped from the output file
2721 s
= bfd_get_section_by_name (dynobj
, ".rel.got");
2726 /* If this is a -Bsymbolic shared link, then we need to discard all
2727 PC relative relocs against symbols defined in a regular object.
2728 We allocated space for them in the check_relocs routine, but we
2729 will not fill them in in the relocate_section routine. */
2730 if (info
->shared
&& info
->symbolic
)
2731 elf32_arm_link_hash_traverse (elf32_arm_hash_table (info
),
2732 elf32_arm_discard_copies
,
2735 /* The check_relocs and adjust_dynamic_symbol entry points have
2736 determined the sizes of the various dynamic sections. Allocate
2741 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2746 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2749 /* It's OK to base decisions on the section name, because none
2750 of the dynobj section names depend upon the input files. */
2751 name
= bfd_get_section_name (dynobj
, s
);
2755 if (strcmp (name
, ".plt") == 0)
2757 if (s
->_raw_size
== 0)
2759 /* Strip this section if we don't need it; see the
2765 /* Remember whether there is a PLT. */
2769 else if (strncmp (name
, ".rel", 4) == 0)
2771 if (s
->_raw_size
== 0)
2773 /* If we don't need this section, strip it from the
2774 output file. This is mostly to handle .rel.bss and
2775 .rel.plt. We must create both sections in
2776 create_dynamic_sections, because they must be created
2777 before the linker maps input sections to output
2778 sections. The linker does that before
2779 adjust_dynamic_symbol is called, and it is that
2780 function which decides whether anything needs to go
2781 into these sections. */
2788 /* Remember whether there are any reloc sections other
2790 if (strcmp (name
, ".rel.plt") != 0)
2792 const char *outname
;
2796 /* If this relocation section applies to a read only
2797 section, then we probably need a DT_TEXTREL
2798 entry. The entries in the .rel.plt section
2799 really apply to the .got section, which we
2800 created ourselves and so know is not readonly. */
2801 outname
= bfd_get_section_name (output_bfd
,
2803 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
2805 && (target
->flags
& SEC_READONLY
) != 0
2806 && (target
->flags
& SEC_ALLOC
) != 0)
2810 /* We use the reloc_count field as a counter if we need
2811 to copy relocs into the output file. */
2815 else if (strncmp (name
, ".got", 4) != 0)
2817 /* It's not one of our sections, so don't allocate space. */
2825 for (spp
= &s
->output_section
->owner
->sections
;
2826 *spp
!= s
->output_section
;
2827 spp
= &(*spp
)->next
)
2829 *spp
= s
->output_section
->next
;
2830 --s
->output_section
->owner
->section_count
;
2835 /* Allocate memory for the section contents. */
2836 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
2837 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
2841 if (elf_hash_table (info
)->dynamic_sections_created
)
2843 /* Add some entries to the .dynamic section. We fill in the
2844 values later, in elf32_arm_finish_dynamic_sections, but we
2845 must add the entries now so that we get the correct size for
2846 the .dynamic section. The DT_DEBUG entry is filled in by the
2847 dynamic linker and used by the debugger. */
2850 if (! bfd_elf32_add_dynamic_entry (info
, DT_DEBUG
, 0))
2856 if (! bfd_elf32_add_dynamic_entry (info
, DT_PLTGOT
, 0)
2857 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
2858 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTREL
, DT_REL
)
2859 || ! bfd_elf32_add_dynamic_entry (info
, DT_JMPREL
, 0))
2865 if (! bfd_elf32_add_dynamic_entry (info
, DT_REL
, 0)
2866 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELSZ
, 0)
2867 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELENT
,
2868 sizeof (Elf32_External_Rel
)))
2874 if (! bfd_elf32_add_dynamic_entry (info
, DT_TEXTREL
, 0))
2882 /* This function is called via elf32_arm_link_hash_traverse if we are
2883 creating a shared object with -Bsymbolic. It discards the space
2884 allocated to copy PC relative relocs against symbols which are
2885 defined in regular objects. We allocated space for them in the
2886 check_relocs routine, but we won't fill them in in the
2887 relocate_section routine. */
2890 elf32_arm_discard_copies (h
, ignore
)
2891 struct elf32_arm_link_hash_entry
* h
;
2892 PTR ignore ATTRIBUTE_UNUSED
;
2894 struct elf32_arm_pcrel_relocs_copied
* s
;
2896 /* We only discard relocs for symbols defined in a regular object. */
2897 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2900 for (s
= h
->pcrel_relocs_copied
; s
!= NULL
; s
= s
->next
)
2901 s
->section
->_raw_size
-= s
->count
* sizeof (Elf32_External_Rel
);
2906 /* Finish up dynamic symbol handling. We set the contents of various
2907 dynamic sections here. */
2910 elf32_arm_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
2912 struct bfd_link_info
* info
;
2913 struct elf_link_hash_entry
* h
;
2914 Elf_Internal_Sym
* sym
;
2918 dynobj
= elf_hash_table (info
)->dynobj
;
2920 if (h
->plt
.offset
!= (bfd_vma
) -1)
2927 Elf_Internal_Rel rel
;
2929 /* This symbol has an entry in the procedure linkage table. Set
2932 BFD_ASSERT (h
->dynindx
!= -1);
2934 splt
= bfd_get_section_by_name (dynobj
, ".plt");
2935 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
2936 srel
= bfd_get_section_by_name (dynobj
, ".rel.plt");
2937 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
2939 /* Get the index in the procedure linkage table which
2940 corresponds to this symbol. This is the index of this symbol
2941 in all the symbols for which we are making plt entries. The
2942 first entry in the procedure linkage table is reserved. */
2943 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
2945 /* Get the offset into the .got table of the entry that
2946 corresponds to this function. Each .got entry is 4 bytes.
2947 The first three are reserved. */
2948 got_offset
= (plt_index
+ 3) * 4;
2950 /* Fill in the entry in the procedure linkage table. */
2951 memcpy (splt
->contents
+ h
->plt
.offset
,
2952 elf32_arm_plt_entry
,
2954 bfd_put_32 (output_bfd
,
2955 (sgot
->output_section
->vma
2956 + sgot
->output_offset
2958 - splt
->output_section
->vma
2959 - splt
->output_offset
2960 - h
->plt
.offset
- 12),
2961 splt
->contents
+ h
->plt
.offset
+ 12);
2963 /* Fill in the entry in the global offset table. */
2964 bfd_put_32 (output_bfd
,
2965 (splt
->output_section
->vma
2966 + splt
->output_offset
),
2967 sgot
->contents
+ got_offset
);
2969 /* Fill in the entry in the .rel.plt section. */
2970 rel
.r_offset
= (sgot
->output_section
->vma
2971 + sgot
->output_offset
2973 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_JUMP_SLOT
);
2974 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
2975 ((Elf32_External_Rel
*) srel
->contents
2978 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2980 /* Mark the symbol as undefined, rather than as defined in
2981 the .plt section. Leave the value alone. */
2982 sym
->st_shndx
= SHN_UNDEF
;
2986 if (h
->got
.offset
!= (bfd_vma
) -1)
2990 Elf_Internal_Rel rel
;
2992 /* This symbol has an entry in the global offset table. Set it
2995 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2996 srel
= bfd_get_section_by_name (dynobj
, ".rel.got");
2997 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
2999 rel
.r_offset
= (sgot
->output_section
->vma
3000 + sgot
->output_offset
3001 + (h
->got
.offset
&~ 1));
3003 /* If this is a -Bsymbolic link, and the symbol is defined
3004 locally, we just want to emit a RELATIVE reloc. The entry in
3005 the global offset table will already have been initialized in
3006 the relocate_section function. */
3008 && (info
->symbolic
|| h
->dynindx
== -1)
3009 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
3010 rel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
3013 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
3014 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_GLOB_DAT
);
3017 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3018 ((Elf32_External_Rel
*) srel
->contents
3019 + srel
->reloc_count
));
3020 ++srel
->reloc_count
;
3023 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
3026 Elf_Internal_Rel rel
;
3028 /* This symbol needs a copy reloc. Set it up. */
3030 BFD_ASSERT (h
->dynindx
!= -1
3031 && (h
->root
.type
== bfd_link_hash_defined
3032 || h
->root
.type
== bfd_link_hash_defweak
));
3034 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
3036 BFD_ASSERT (s
!= NULL
);
3038 rel
.r_offset
= (h
->root
.u
.def
.value
3039 + h
->root
.u
.def
.section
->output_section
->vma
3040 + h
->root
.u
.def
.section
->output_offset
);
3041 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_COPY
);
3042 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3043 ((Elf32_External_Rel
*) s
->contents
3048 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3049 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3050 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
3051 sym
->st_shndx
= SHN_ABS
;
3056 /* Finish up the dynamic sections. */
3059 elf32_arm_finish_dynamic_sections (output_bfd
, info
)
3061 struct bfd_link_info
* info
;
3067 dynobj
= elf_hash_table (info
)->dynobj
;
3069 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3070 BFD_ASSERT (sgot
!= NULL
);
3071 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3073 if (elf_hash_table (info
)->dynamic_sections_created
)
3076 Elf32_External_Dyn
*dyncon
, *dynconend
;
3078 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3079 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3081 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3082 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
3083 for (; dyncon
< dynconend
; dyncon
++)
3085 Elf_Internal_Dyn dyn
;
3089 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3102 s
= bfd_get_section_by_name (output_bfd
, name
);
3103 BFD_ASSERT (s
!= NULL
);
3104 dyn
.d_un
.d_ptr
= s
->vma
;
3105 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3109 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3110 BFD_ASSERT (s
!= NULL
);
3111 if (s
->_cooked_size
!= 0)
3112 dyn
.d_un
.d_val
= s
->_cooked_size
;
3114 dyn
.d_un
.d_val
= s
->_raw_size
;
3115 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3119 /* My reading of the SVR4 ABI indicates that the
3120 procedure linkage table relocs (DT_JMPREL) should be
3121 included in the overall relocs (DT_REL). This is
3122 what Solaris does. However, UnixWare can not handle
3123 that case. Therefore, we override the DT_RELSZ entry
3124 here to make it not include the JMPREL relocs. Since
3125 the linker script arranges for .rel.plt to follow all
3126 other relocation sections, we don't have to worry
3127 about changing the DT_REL entry. */
3128 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3131 if (s
->_cooked_size
!= 0)
3132 dyn
.d_un
.d_val
-= s
->_cooked_size
;
3134 dyn
.d_un
.d_val
-= s
->_raw_size
;
3136 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3141 /* Fill in the first entry in the procedure linkage table. */
3142 if (splt
->_raw_size
> 0)
3143 memcpy (splt
->contents
, elf32_arm_plt0_entry
, PLT_ENTRY_SIZE
);
3145 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3146 really seem like the right value. */
3147 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
3150 /* Fill in the first three entries in the global offset table. */
3151 if (sgot
->_raw_size
> 0)
3154 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
3156 bfd_put_32 (output_bfd
,
3157 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3159 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
3160 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
3163 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
3169 elf32_arm_post_process_headers (abfd
, link_info
)
3171 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
;
3173 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form */
3175 i_ehdrp
= elf_elfheader (abfd
);
3177 i_ehdrp
->e_ident
[EI_OSABI
] = ARM_ELF_OS_ABI_VERSION
;
3178 i_ehdrp
->e_ident
[EI_ABIVERSION
] = ARM_ELF_ABI_VERSION
;
3182 #define ELF_ARCH bfd_arch_arm
3183 #define ELF_MACHINE_CODE EM_ARM
3184 #define ELF_MAXPAGESIZE 0x8000
3187 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
3188 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
3189 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
3190 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
3191 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
3192 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
3193 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
3195 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
3196 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
3197 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
3198 #define elf_backend_check_relocs elf32_arm_check_relocs
3199 #define elf_backend_relocate_section elf32_arm_relocate_section
3200 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
3201 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
3202 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
3203 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
3204 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
3205 #define elf_backend_post_process_headers elf32_arm_post_process_headers
3207 #define elf_backend_can_gc_sections 1
3208 #define elf_backend_plt_readonly 1
3209 #define elf_backend_want_got_plt 1
3210 #define elf_backend_want_plt_sym 0
3212 #define elf_backend_got_header_size 12
3213 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
3215 #include "elf32-target.h"