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
*));
52 /* The linker script knows the section names for placement.
53 The entry_names are used to do simple name mangling on the stubs.
54 Given a function name, and its type, the stub can be found. The
55 name can be changed. The only requirement is the %s be present.
58 #define INTERWORK_FLAG( abfd ) (elf_elfheader (abfd)->e_flags & EF_INTERWORK)
60 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
61 #define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
63 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
64 #define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
66 /* The name of the dynamic interpreter. This is put in the .interp
68 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
70 /* The size in bytes of an entry in the procedure linkage table. */
72 #define PLT_ENTRY_SIZE 16
74 /* The first entry in a procedure linkage table looks like
75 this. It is set up so that any shared library function that is
76 called before the relocation has been set up calles the dynamic
79 static const bfd_byte elf32_arm_plt0_entry
[PLT_ENTRY_SIZE
] =
81 0x04, 0xe0, 0x2d, 0xe5, /* str lr, [sp, #-4]! */
82 0x10, 0xe0, 0x9f, 0xe5, /* ldr lr, [pc, #16] */
83 0x0e, 0xe0, 0x8f, 0xe0, /* adr lr, pc, lr */
84 0x08, 0xf0, 0xbe, 0xe5 /* ldr pc, [lr, #-4] */
87 /* Subsequent entries in a procedure linkage table look like
90 static const bfd_byte elf32_arm_plt_entry
[PLT_ENTRY_SIZE
] =
92 0x04, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc, #4] */
93 0x0c, 0xc0, 0x8f, 0xe0, /* add ip, pc, ip */
94 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
95 0x00, 0x00, 0x00, 0x00 /* offset to symbol in got */
99 /* The ARM linker needs to keep track of the number of relocs that it
100 decides to copy in check_relocs for each symbol. This is so that
101 it can discard PC relative relocs if it doesn't need them when
102 linking with -Bsymbolic. We store the information in a field
103 extending the regular ELF linker hash table. */
105 /* This structure keeps track of the number of PC relative relocs we
106 have copied for a given symbol. */
108 struct elf32_arm_pcrel_relocs_copied
111 struct elf32_arm_pcrel_relocs_copied
* next
;
112 /* A section in dynobj. */
114 /* Number of relocs copied in this section. */
118 /* arm ELF linker hash entry. */
120 struct elf32_arm_link_hash_entry
122 struct elf_link_hash_entry root
;
124 /* Number of PC relative relocs copied for this symbol. */
125 struct elf32_arm_pcrel_relocs_copied
* pcrel_relocs_copied
;
128 /* Declare this now that the above structures are defined. */
130 static boolean elf32_arm_discard_copies
131 PARAMS ((struct elf32_arm_link_hash_entry
*, PTR
));
133 /* Traverse an arm ELF linker hash table. */
135 #define elf32_arm_link_hash_traverse(table, func, info) \
136 (elf_link_hash_traverse \
138 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
141 /* Get the ARM elf linker hash table from a link_info structure. */
142 #define elf32_arm_hash_table(info) \
143 ((struct elf32_arm_link_hash_table *) ((info)->hash))
145 /* ARM ELF linker hash table */
146 struct elf32_arm_link_hash_table
148 /* The main hash table. */
149 struct elf_link_hash_table root
;
151 /* The size in bytes of the section containg the Thumb-to-ARM glue. */
152 long int thumb_glue_size
;
154 /* The size in bytes of the section containg the ARM-to-Thumb glue. */
155 long int arm_glue_size
;
157 /* An arbitary input BFD chosen to hold the glue sections. */
158 bfd
* bfd_of_glue_owner
;
162 /* Create an entry in an ARM ELF linker hash table. */
164 static struct bfd_hash_entry
*
165 elf32_arm_link_hash_newfunc (entry
, table
, string
)
166 struct bfd_hash_entry
* entry
;
167 struct bfd_hash_table
* table
;
170 struct elf32_arm_link_hash_entry
* ret
=
171 (struct elf32_arm_link_hash_entry
*) entry
;
173 /* Allocate the structure if it has not already been allocated by a
175 if (ret
== (struct elf32_arm_link_hash_entry
*) NULL
)
176 ret
= ((struct elf32_arm_link_hash_entry
*)
177 bfd_hash_allocate (table
,
178 sizeof (struct elf32_arm_link_hash_entry
)));
179 if (ret
== (struct elf32_arm_link_hash_entry
*) NULL
)
180 return (struct bfd_hash_entry
*) ret
;
182 /* Call the allocation method of the superclass. */
183 ret
= ((struct elf32_arm_link_hash_entry
*)
184 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
186 if (ret
!= (struct elf32_arm_link_hash_entry
*) NULL
)
187 ret
->pcrel_relocs_copied
= NULL
;
189 return (struct bfd_hash_entry
*) ret
;
192 /* Create an ARM elf linker hash table */
194 static struct bfd_link_hash_table
*
195 elf32_arm_link_hash_table_create (abfd
)
198 struct elf32_arm_link_hash_table
*ret
;
200 ret
= ((struct elf32_arm_link_hash_table
*)
201 bfd_alloc (abfd
, sizeof (struct elf32_arm_link_hash_table
)));
202 if (ret
== (struct elf32_arm_link_hash_table
*) NULL
)
205 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
206 elf32_arm_link_hash_newfunc
))
208 bfd_release (abfd
, ret
);
212 ret
->thumb_glue_size
= 0;
213 ret
->arm_glue_size
= 0;
214 ret
->bfd_of_glue_owner
= NULL
;
216 return &ret
->root
.root
;
219 static struct elf_link_hash_entry
*
220 find_thumb_glue (link_info
, name
, input_bfd
)
221 struct bfd_link_info
*link_info
;
226 struct elf_link_hash_entry
*hash
;
227 struct elf32_arm_link_hash_table
*hash_table
;
229 /* We need a pointer to the armelf specific hash table. */
230 hash_table
= elf32_arm_hash_table (link_info
);
234 bfd_malloc (strlen (name
) + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1));
236 BFD_ASSERT (tmp_name
);
238 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
240 hash
= elf_link_hash_lookup
241 (&(hash_table
)->root
, tmp_name
, false, false, true);
244 /* xgettext:c-format */
245 _bfd_error_handler (_ ("%s: unable to find THUMB glue '%s' for `%s'"),
246 bfd_get_filename (input_bfd
), tmp_name
, name
);
253 static struct elf_link_hash_entry
*
254 find_arm_glue (link_info
, name
, input_bfd
)
255 struct bfd_link_info
*link_info
;
260 struct elf_link_hash_entry
*myh
;
261 struct elf32_arm_link_hash_table
*hash_table
;
263 /* We need a pointer to the elfarm specific hash table. */
264 hash_table
= elf32_arm_hash_table (link_info
);
267 bfd_malloc (strlen (name
) + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1));
269 BFD_ASSERT (tmp_name
);
271 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
273 myh
= elf_link_hash_lookup
274 (&(hash_table
)->root
, tmp_name
, false, false, true);
277 /* xgettext:c-format */
278 _bfd_error_handler (_ ("%s: unable to find ARM glue '%s' for `%s'"),
279 bfd_get_filename (input_bfd
), tmp_name
, name
);
294 .word func @ behave as if you saw a ARM_32 reloc
297 #define ARM2THUMB_GLUE_SIZE 12
298 static const insn32 a2t1_ldr_insn
= 0xe59fc000;
299 static const insn32 a2t2_bx_r12_insn
= 0xe12fff1c;
300 static const insn32 a2t3_func_addr_insn
= 0x00000001;
303 Thumb->ARM: Thumb->(non-interworking aware) ARM
307 __func_from_thumb: __func_from_thumb:
309 nop ldr r6, __func_addr
311 __func_change_to_arm: bx r6
313 __func_back_to_thumb:
320 #define THUMB2ARM_GLUE_SIZE 8
321 static const insn16 t2a1_bx_pc_insn
= 0x4778;
322 static const insn16 t2a2_noop_insn
= 0x46c0;
323 static const insn32 t2a3_b_insn
= 0xea000000;
325 static const insn16 t2a1_push_insn
= 0xb540;
326 static const insn16 t2a2_ldr_insn
= 0x4e03;
327 static const insn16 t2a3_mov_insn
= 0x46fe;
328 static const insn16 t2a4_bx_insn
= 0x4730;
329 static const insn32 t2a5_pop_insn
= 0xe8bd4040;
330 static const insn32 t2a6_bx_insn
= 0xe12fff1e;
333 bfd_elf32_arm_allocate_interworking_sections (info
)
334 struct bfd_link_info
* info
;
338 struct elf32_arm_link_hash_table
* globals
;
340 globals
= elf32_arm_hash_table (info
);
342 BFD_ASSERT (globals
!= NULL
);
344 if (globals
->arm_glue_size
!= 0)
346 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
348 s
= bfd_get_section_by_name
349 (globals
->bfd_of_glue_owner
, ARM2THUMB_GLUE_SECTION_NAME
);
351 BFD_ASSERT (s
!= NULL
);
353 foo
= (bfd_byte
*) bfd_alloc
354 (globals
->bfd_of_glue_owner
, globals
->arm_glue_size
);
356 s
->_raw_size
= s
->_cooked_size
= globals
->arm_glue_size
;
360 if (globals
->thumb_glue_size
!= 0)
362 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
364 s
= bfd_get_section_by_name
365 (globals
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
367 BFD_ASSERT (s
!= NULL
);
369 foo
= (bfd_byte
*) bfd_alloc
370 (globals
->bfd_of_glue_owner
, globals
->thumb_glue_size
);
372 s
->_raw_size
= s
->_cooked_size
= globals
->thumb_glue_size
;
380 record_arm_to_thumb_glue (link_info
, h
)
381 struct bfd_link_info
* link_info
;
382 struct elf_link_hash_entry
* h
;
384 const char * name
= h
->root
.root
.string
;
385 register asection
* s
;
387 struct elf_link_hash_entry
* myh
;
388 struct elf32_arm_link_hash_table
* globals
;
390 globals
= elf32_arm_hash_table (link_info
);
392 BFD_ASSERT (globals
!= NULL
);
393 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
395 s
= bfd_get_section_by_name
396 (globals
->bfd_of_glue_owner
, ARM2THUMB_GLUE_SECTION_NAME
);
399 BFD_ASSERT (s
!= NULL
);
402 bfd_malloc (strlen (name
) + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1));
404 BFD_ASSERT (tmp_name
);
406 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
408 myh
= elf_link_hash_lookup
409 (&(globals
)->root
, tmp_name
, false, false, true);
414 return; /* we've already seen this guy */
417 /* The only trick here is using hash_table->arm_glue_size as the value. Even
418 though the section isn't allocated yet, this is where we will be putting
421 _bfd_generic_link_add_one_symbol (link_info
, globals
->bfd_of_glue_owner
, tmp_name
,
423 s
, globals
->arm_glue_size
+ 1,
425 (struct bfd_link_hash_entry
**) &myh
);
429 globals
->arm_glue_size
+= ARM2THUMB_GLUE_SIZE
;
435 record_thumb_to_arm_glue (link_info
, h
)
436 struct bfd_link_info
*link_info
;
437 struct elf_link_hash_entry
*h
;
439 const char *name
= h
->root
.root
.string
;
440 register asection
*s
;
442 struct elf_link_hash_entry
*myh
;
443 struct elf32_arm_link_hash_table
*hash_table
;
446 hash_table
= elf32_arm_hash_table (link_info
);
448 BFD_ASSERT (hash_table
!= NULL
);
449 BFD_ASSERT (hash_table
->bfd_of_glue_owner
!= NULL
);
451 s
= bfd_get_section_by_name
452 (hash_table
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
454 BFD_ASSERT (s
!= NULL
);
456 tmp_name
= (char *) bfd_malloc (strlen (name
) + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1);
458 BFD_ASSERT (tmp_name
);
460 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
462 myh
= elf_link_hash_lookup
463 (&(hash_table
)->root
, tmp_name
, false, false, true);
468 return; /* we've already seen this guy */
471 _bfd_generic_link_add_one_symbol (link_info
, hash_table
->bfd_of_glue_owner
, tmp_name
,
472 BSF_GLOBAL
, s
, hash_table
->thumb_glue_size
+ 1,
474 (struct bfd_link_hash_entry
**) &myh
);
476 /* If we mark it 'thumb', the disassembler will do a better job. */
477 bind
= ELF_ST_BIND (myh
->type
);
478 myh
->type
= ELF_ST_INFO (bind
, STT_ARM_TFUNC
);
482 /* Allocate another symbol to mark where we switch to arm mode. */
484 #define CHANGE_TO_ARM "__%s_change_to_arm"
485 #define BACK_FROM_ARM "__%s_back_from_arm"
487 tmp_name
= (char *) bfd_malloc (strlen (name
) + strlen (CHANGE_TO_ARM
) + 1);
489 BFD_ASSERT (tmp_name
);
491 sprintf (tmp_name
, CHANGE_TO_ARM
, name
);
495 _bfd_generic_link_add_one_symbol (link_info
, hash_table
->bfd_of_glue_owner
, tmp_name
,
496 BSF_LOCAL
, s
, hash_table
->thumb_glue_size
+ 4,
498 (struct bfd_link_hash_entry
**) &myh
);
502 hash_table
->thumb_glue_size
+= THUMB2ARM_GLUE_SIZE
;
507 /* Select a BFD to be used to hold the sections used by the glue code.
508 This function is called from the linker scripts in ld/emultempl/
511 bfd_elf32_arm_get_bfd_for_interworking (abfd
, info
)
513 struct bfd_link_info
*info
;
515 struct elf32_arm_link_hash_table
*globals
;
519 /* If we are only performing a partial link do not bother
520 getting a bfd to hold the glue. */
521 if (info
->relocateable
)
524 globals
= elf32_arm_hash_table (info
);
526 BFD_ASSERT (globals
!= NULL
);
528 if (globals
->bfd_of_glue_owner
!= NULL
)
531 sec
= bfd_get_section_by_name (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
535 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
537 sec
= bfd_make_section (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
540 || !bfd_set_section_flags (abfd
, sec
, flags
)
541 || !bfd_set_section_alignment (abfd
, sec
, 2))
545 sec
= bfd_get_section_by_name (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
549 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
551 sec
= bfd_make_section (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
554 || !bfd_set_section_flags (abfd
, sec
, flags
)
555 || !bfd_set_section_alignment (abfd
, sec
, 2))
559 /* Save the bfd for later use. */
560 globals
->bfd_of_glue_owner
= abfd
;
566 bfd_elf32_arm_process_before_allocation (abfd
, link_info
)
568 struct bfd_link_info
*link_info
;
570 Elf_Internal_Shdr
*symtab_hdr
;
571 Elf_Internal_Rela
*free_relocs
= NULL
;
572 Elf_Internal_Rela
*irel
, *irelend
;
573 bfd_byte
*contents
= NULL
;
574 bfd_byte
*free_contents
= NULL
;
575 Elf32_External_Sym
*extsyms
= NULL
;
576 Elf32_External_Sym
*free_extsyms
= NULL
;
579 struct elf32_arm_link_hash_table
*globals
;
581 /* If we are only performing a partial link do not bother
582 to construct any glue. */
583 if (link_info
->relocateable
)
586 /* Here we have a bfd that is to be included on the link. We have a hook
587 to do reloc rummaging, before section sizes are nailed down. */
589 globals
= elf32_arm_hash_table (link_info
);
591 BFD_ASSERT (globals
!= NULL
);
592 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
594 /* Rummage around all the relocs and map the glue vectors. */
595 sec
= abfd
->sections
;
600 for (; sec
!= NULL
; sec
= sec
->next
)
602 if (sec
->reloc_count
== 0)
605 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
606 /* Load the relocs. */
608 irel
= (_bfd_elf32_link_read_relocs (abfd
, sec
, (PTR
) NULL
,
609 (Elf_Internal_Rela
*) NULL
, false));
611 BFD_ASSERT (irel
!= 0);
613 irelend
= irel
+ sec
->reloc_count
;
614 for (; irel
< irelend
; irel
++)
617 unsigned long r_index
;
620 struct elf_link_hash_entry
*h
;
622 r_type
= ELF32_R_TYPE (irel
->r_info
);
623 r_index
= ELF32_R_SYM (irel
->r_info
);
625 /* These are the only relocation types we care about */
626 if (r_type
!= R_ARM_PC24
627 && r_type
!= R_ARM_THM_PC22
)
630 /* Get the section contents if we haven't done so already. */
631 if (contents
== NULL
)
633 /* Get cached copy if it exists. */
634 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
635 contents
= elf_section_data (sec
)->this_hdr
.contents
;
638 /* Go get them off disk. */
639 contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
640 if (contents
== NULL
)
642 free_contents
= contents
;
644 if (!bfd_get_section_contents (abfd
, sec
, contents
,
645 (file_ptr
) 0, sec
->_raw_size
))
650 /* Read this BFD's symbols if we haven't done so already. */
653 /* Get cached copy if it exists. */
654 if (symtab_hdr
->contents
!= NULL
)
655 extsyms
= (Elf32_External_Sym
*) symtab_hdr
->contents
;
658 /* Go get them off disk. */
659 extsyms
= ((Elf32_External_Sym
*)
660 bfd_malloc (symtab_hdr
->sh_size
));
663 free_extsyms
= extsyms
;
664 if (bfd_seek (abfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
665 || (bfd_read (extsyms
, 1, symtab_hdr
->sh_size
, abfd
)
666 != symtab_hdr
->sh_size
))
671 /* If the relocation is not against a symbol it cannot concern us. */
675 /* We don't care about local symbols */
676 if (r_index
< symtab_hdr
->sh_info
)
679 /* This is an external symbol */
680 r_index
-= symtab_hdr
->sh_info
;
681 h
= (struct elf_link_hash_entry
*)
682 elf_sym_hashes (abfd
)[r_index
];
684 /* If the relocation is against a static symbol it must be within
685 the current section and so cannot be a cross ARM/Thumb relocation. */
692 /* This one is a call from arm code. We need to look up
693 the target of the call. If it is a thumb target, we
696 if (ELF_ST_TYPE(h
->type
) == STT_ARM_TFUNC
)
697 record_arm_to_thumb_glue (link_info
, h
);
701 /* This one is a call from thumb code. We look
702 up the target of the call. If it is not a thumb
703 target, we insert glue. */
705 if (ELF_ST_TYPE (h
->type
) != STT_ARM_TFUNC
)
706 record_thumb_to_arm_glue (link_info
, h
);
717 if (free_relocs
!= NULL
)
719 if (free_contents
!= NULL
)
720 free (free_contents
);
721 if (free_extsyms
!= NULL
)
727 /* The thumb form of a long branch is a bit finicky, because the offset
728 encoding is split over two fields, each in it's own instruction. They
729 can occur in any order. So given a thumb form of long branch, and an
730 offset, insert the offset into the thumb branch and return finished
733 It takes two thumb instructions to encode the target address. Each has
734 11 bits to invest. The upper 11 bits are stored in one (identifed by
735 H-0.. see below), the lower 11 bits are stored in the other (identified
738 Combine together and shifted left by 1 (it's a half word address) and
742 H-0, upper address-0 = 000
744 H-1, lower address-0 = 800
746 They can be ordered either way, but the arm tools I've seen always put
747 the lower one first. It probably doesn't matter. krk@cygnus.com
749 XXX: Actually the order does matter. The second instruction (H-1)
750 moves the computed address into the PC, so it must be the second one
751 in the sequence. The problem, however is that whilst little endian code
752 stores the instructions in HI then LOW order, big endian code does the
753 reverse. nickc@cygnus.com */
755 #define LOW_HI_ORDER 0xF800F000
756 #define HI_LOW_ORDER 0xF000F800
759 insert_thumb_branch (br_insn
, rel_off
)
763 unsigned int low_bits
;
764 unsigned int high_bits
;
767 BFD_ASSERT ((rel_off
& 1) != 1);
769 rel_off
>>= 1; /* half word aligned address */
770 low_bits
= rel_off
& 0x000007FF; /* the bottom 11 bits */
771 high_bits
= (rel_off
>> 11) & 0x000007FF; /* the top 11 bits */
773 if ((br_insn
& LOW_HI_ORDER
) == LOW_HI_ORDER
)
774 br_insn
= LOW_HI_ORDER
| (low_bits
<< 16) | high_bits
;
775 else if ((br_insn
& HI_LOW_ORDER
) == HI_LOW_ORDER
)
776 br_insn
= HI_LOW_ORDER
| (high_bits
<< 16) | low_bits
;
778 abort (); /* error - not a valid branch instruction form */
780 /* FIXME: abort is probably not the right call. krk@cygnus.com */
785 /* Thumb code calling an ARM function */
787 elf32_thumb_to_arm_stub (info
, name
, input_bfd
, output_bfd
, input_section
,
788 hit_data
, sym_sec
, offset
, addend
, val
)
789 struct bfd_link_info
*info
;
793 asection
*input_section
;
802 unsigned long int tmp
;
804 struct elf_link_hash_entry
*myh
;
805 struct elf32_arm_link_hash_table
*globals
;
807 myh
= find_thumb_glue (info
, name
, input_bfd
);
811 globals
= elf32_arm_hash_table (info
);
813 BFD_ASSERT (globals
!= NULL
);
814 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
816 my_offset
= myh
->root
.u
.def
.value
;
818 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
819 THUMB2ARM_GLUE_SECTION_NAME
);
821 BFD_ASSERT (s
!= NULL
);
822 BFD_ASSERT (s
->contents
!= NULL
);
823 BFD_ASSERT (s
->output_section
!= NULL
);
825 if ((my_offset
& 0x01) == 0x01)
828 && sym_sec
->owner
!= NULL
829 && !INTERWORK_FLAG (sym_sec
->owner
))
832 (_ ("%s(%s): warning: interworking not enabled."),
833 bfd_get_filename (sym_sec
->owner
), name
);
835 (_ (" first occurrence: %s: thumb call to arm"),
836 bfd_get_filename (input_bfd
));
842 myh
->root
.u
.def
.value
= my_offset
;
844 bfd_put_16 (output_bfd
, t2a1_bx_pc_insn
,
845 s
->contents
+ my_offset
);
847 bfd_put_16 (output_bfd
, t2a2_noop_insn
,
848 s
->contents
+ my_offset
+ 2);
851 ((bfd_signed_vma
) val
) /* Address of destination of the stub */
853 (s
->output_offset
/* Offset from the start of the current section to the start of the stubs. */
854 + my_offset
/* Offset of the start of this stub from the start of the stubs. */
855 + s
->output_section
->vma
) /* Address of the start of the current section. */
856 + 4 /* The branch instruction is 4 bytes into the stub. */
857 + 8); /* ARM branches work from the pc of the instruction + 8. */
859 bfd_put_32 (output_bfd
,
860 t2a3_b_insn
| ((ret_offset
>> 2) & 0x00FFFFFF),
861 s
->contents
+ my_offset
+ 4);
864 BFD_ASSERT (my_offset
<= globals
->thumb_glue_size
);
866 /* Now go back and fix up the original BL insn to point
871 - (input_section
->output_offset
875 tmp
= bfd_get_32 (input_bfd
, hit_data
876 - input_section
->vma
);
878 bfd_put_32 (output_bfd
,
879 insert_thumb_branch (tmp
, ret_offset
),
880 hit_data
- input_section
->vma
);
885 /* Arm code calling a Thumb function */
887 elf32_arm_to_thumb_stub (info
, name
, input_bfd
, output_bfd
, input_section
,
888 hit_data
, sym_sec
, offset
, addend
, val
)
890 struct bfd_link_info
*info
;
894 asection
*input_section
;
901 unsigned long int tmp
;
905 struct elf_link_hash_entry
*myh
;
906 struct elf32_arm_link_hash_table
*globals
;
908 myh
= find_arm_glue (info
, name
, input_bfd
);
912 globals
= elf32_arm_hash_table (info
);
914 BFD_ASSERT (globals
!= NULL
);
915 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
917 my_offset
= myh
->root
.u
.def
.value
;
918 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
919 ARM2THUMB_GLUE_SECTION_NAME
);
920 BFD_ASSERT (s
!= NULL
);
921 BFD_ASSERT (s
->contents
!= NULL
);
922 BFD_ASSERT (s
->output_section
!= NULL
);
924 if ((my_offset
& 0x01) == 0x01)
927 && sym_sec
->owner
!= NULL
928 && !INTERWORK_FLAG (sym_sec
->owner
))
931 (_ ("%s(%s): warning: interworking not enabled."),
932 bfd_get_filename (sym_sec
->owner
), name
);
934 (_ (" first occurrence: %s: arm call to thumb"),
935 bfd_get_filename (input_bfd
));
938 myh
->root
.u
.def
.value
= my_offset
;
940 bfd_put_32 (output_bfd
, a2t1_ldr_insn
,
941 s
->contents
+ my_offset
);
943 bfd_put_32 (output_bfd
, a2t2_bx_r12_insn
,
944 s
->contents
+ my_offset
+ 4);
946 /* It's a thumb address. Add the low order bit. */
947 bfd_put_32 (output_bfd
, val
| a2t3_func_addr_insn
,
948 s
->contents
+ my_offset
+ 8);
951 BFD_ASSERT (my_offset
<= globals
->arm_glue_size
);
953 tmp
= bfd_get_32 (input_bfd
, hit_data
);
954 tmp
= tmp
& 0xFF000000;
956 /* Somehow these are both 4 too far, so subtract 8. */
957 ret_offset
= s
->output_offset
959 + s
->output_section
->vma
960 - (input_section
->output_offset
961 + input_section
->output_section
->vma
965 tmp
= tmp
| ((ret_offset
>> 2) & 0x00FFFFFF);
967 bfd_put_32 (output_bfd
, tmp
, hit_data
968 - input_section
->vma
);
974 /* Perform a relocation as part of a final link. */
975 static bfd_reloc_status_type
976 elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
977 input_section
, contents
, rel
, value
,
978 info
, sym_sec
, sym_name
, sym_flags
, h
)
979 reloc_howto_type
* howto
;
982 asection
* input_section
;
984 Elf_Internal_Rela
* rel
;
986 struct bfd_link_info
* info
;
988 const char * sym_name
;
989 unsigned char sym_flags
;
990 struct elf_link_hash_entry
* h
;
992 unsigned long r_type
= howto
->type
;
993 unsigned long r_symndx
;
994 bfd_byte
* hit_data
= contents
+ rel
->r_offset
;
996 Elf_Internal_Shdr
* symtab_hdr
;
997 struct elf_link_hash_entry
** sym_hashes
;
998 bfd_vma
* local_got_offsets
;
999 asection
* sgot
= NULL
;
1000 asection
* splt
= NULL
;
1001 asection
* sreloc
= NULL
;
1004 dynobj
= elf_hash_table (info
)->dynobj
;
1007 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1008 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1010 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1011 sym_hashes
= elf_sym_hashes (input_bfd
);
1012 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1013 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1016 addend
= (bfd_get_32 (input_bfd
, hit_data
) & howto
->src_mask
);
1018 addend
= rel
->r_addend
;
1024 return bfd_reloc_ok
;
1029 /* When generating a shared object, these relocations are copied
1030 into the output file to be resolved at run time. */
1033 && (r_type
!= R_ARM_PC24
1036 && (! info
->symbolic
1037 || (h
->elf_link_hash_flags
1038 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1040 Elf_Internal_Rel outrel
;
1041 boolean skip
, relocate
;
1047 name
= (bfd_elf_string_from_elf_section
1049 elf_elfheader (input_bfd
)->e_shstrndx
,
1050 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1052 return bfd_reloc_notsupported
;
1054 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
1055 && strcmp (bfd_get_section_name (input_bfd
,
1059 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1060 BFD_ASSERT (sreloc
!= NULL
);
1065 if (elf_section_data (input_section
)->stab_info
== NULL
)
1066 outrel
.r_offset
= rel
->r_offset
;
1071 off
= (_bfd_stab_section_offset
1072 (output_bfd
, &elf_hash_table (info
)->stab_info
,
1074 & elf_section_data (input_section
)->stab_info
,
1076 if (off
== (bfd_vma
) -1)
1078 outrel
.r_offset
= off
;
1081 outrel
.r_offset
+= (input_section
->output_section
->vma
1082 + input_section
->output_offset
);
1086 memset (&outrel
, 0, sizeof outrel
);
1089 else if (r_type
== R_ARM_PC24
)
1091 BFD_ASSERT (h
!= NULL
&& h
->dynindx
!= -1);
1092 if ((input_section
->flags
& SEC_ALLOC
) != 0)
1096 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_PC24
);
1101 || ((info
->symbolic
|| h
->dynindx
== -1)
1102 && (h
->elf_link_hash_flags
1103 & ELF_LINK_HASH_DEF_REGULAR
) != 0))
1106 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1110 BFD_ASSERT (h
->dynindx
!= -1);
1111 if ((input_section
->flags
& SEC_ALLOC
) != 0)
1115 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_ABS32
);
1119 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1120 (((Elf32_External_Rel
*)
1122 + sreloc
->reloc_count
));
1123 ++sreloc
->reloc_count
;
1125 /* If this reloc is against an external symbol, we do not want to
1126 fiddle with the addend. Otherwise, we need to include the symbol
1127 value so that it becomes an addend for the dynamic reloc. */
1129 return bfd_reloc_ok
;
1131 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1132 contents
, rel
->r_offset
, value
,
1135 else switch (r_type
)
1138 /* Arm B/BL instruction */
1140 /* Check for arm calling thumb function. */
1141 if (sym_flags
== STT_ARM_TFUNC
)
1143 elf32_arm_to_thumb_stub (info
, sym_name
, input_bfd
, output_bfd
,
1144 input_section
, hit_data
, sym_sec
, rel
->r_offset
, addend
, value
);
1145 return bfd_reloc_ok
;
1148 value
= value
+ addend
;
1149 value
-= (input_section
->output_section
->vma
1150 + input_section
->output_offset
+ 8);
1151 value
-= rel
->r_offset
;
1152 value
= value
>> howto
->rightshift
;
1155 value
|= (bfd_get_32 (input_bfd
, hit_data
) & 0xff000000);
1160 if (sym_flags
== STT_ARM_TFUNC
)
1165 value
-= (input_section
->output_section
->vma
1166 + input_section
->output_offset
);
1171 bfd_put_32 (input_bfd
, value
, hit_data
);
1172 return bfd_reloc_ok
;
1176 if ((long) value
> 0x7f || (long) value
< -0x80)
1177 return bfd_reloc_overflow
;
1179 bfd_put_8 (input_bfd
, value
, hit_data
);
1180 return bfd_reloc_ok
;
1185 if ((long) value
> 0x7fff || (long) value
< -0x8000)
1186 return bfd_reloc_overflow
;
1188 bfd_put_16 (input_bfd
, value
, hit_data
);
1189 return bfd_reloc_ok
;
1192 /* Support ldr and str instruction for the arm */
1193 /* Also thumb b (unconditional branch). ??? Really? */
1196 if ((long) value
> 0x7ff || (long) value
< -0x800)
1197 return bfd_reloc_overflow
;
1199 value
|= (bfd_get_32 (input_bfd
, hit_data
) & 0xfffff000);
1200 bfd_put_32 (input_bfd
, value
, hit_data
);
1201 return bfd_reloc_ok
;
1203 case R_ARM_THM_ABS5
:
1204 /* Support ldr and str instructions for the thumb. */
1206 /* Need to refetch addend. */
1207 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1208 /* ??? Need to determine shift amount from operand size. */
1209 addend
>>= howto
->rightshift
;
1213 /* ??? Isn't value unsigned? */
1214 if ((long) value
> 0x1f || (long) value
< -0x10)
1215 return bfd_reloc_overflow
;
1217 /* ??? Value needs to be properly shifted into place first. */
1218 value
|= bfd_get_16 (input_bfd
, hit_data
) & 0xf83f;
1219 bfd_put_16 (input_bfd
, value
, hit_data
);
1220 return bfd_reloc_ok
;
1222 case R_ARM_THM_PC22
:
1223 /* Thumb BL (branch long instruction). */
1226 boolean overflow
= false;
1227 bfd_vma upper_insn
= bfd_get_16 (input_bfd
, hit_data
);
1228 bfd_vma lower_insn
= bfd_get_16 (input_bfd
, hit_data
+ 2);
1229 bfd_vma src_mask
= 0x007FFFFE;
1230 bfd_signed_vma reloc_signed_max
= (1 << (howto
->bitsize
- 1)) - 1;
1231 bfd_signed_vma reloc_signed_min
= ~reloc_signed_max
;
1233 bfd_signed_vma signed_check
;
1235 bfd_signed_vma signed_add
;
1238 /* Need to refetch the addend and squish the two 11 bit pieces
1241 bfd_vma upper
= bfd_get_16 (input_bfd
, hit_data
) & 0x7ff;
1242 bfd_vma lower
= bfd_get_16 (input_bfd
, hit_data
+ 2) & 0x7ff;
1243 upper
= (upper
^ 0x400) - 0x400; /* sign extend */
1244 addend
= (upper
<< 12) | (lower
<< 1);
1248 /* If it's not a call to thumb, assume call to arm */
1249 if (sym_flags
!= STT_ARM_TFUNC
)
1251 if (elf32_thumb_to_arm_stub
1252 (info
, sym_name
, input_bfd
, output_bfd
, input_section
,
1253 hit_data
, sym_sec
, rel
->r_offset
, addend
, value
))
1254 return bfd_reloc_ok
;
1256 return bfd_reloc_dangerous
;
1259 /* +4: pc is offset by 4 */
1260 relocation
= value
+ addend
+ 4;
1261 relocation
-= (input_section
->output_section
->vma
1262 + input_section
->output_offset
);
1263 relocation
-= rel
->r_offset
;
1265 check
= relocation
>> howto
->rightshift
;
1267 /* If this is a signed value, the rightshift just dropped
1268 leading 1 bits (assuming twos complement). */
1269 if ((bfd_signed_vma
) relocation
>= 0)
1270 signed_check
= check
;
1272 signed_check
= check
| ~((bfd_vma
) -1 >> howto
->rightshift
);
1274 add
= ((upper_insn
& 0x7ff) << 12) | ((lower_insn
& 0x7ff) << 1);
1276 signed_add
= (add
^ 0x400000) - 0x400000;
1278 /* Add the value from the object file. */
1279 signed_check
+= signed_add
;
1280 relocation
+= signed_add
;
1282 /* Assumes two's complement. */
1283 if (signed_check
> reloc_signed_max
1284 || signed_check
< reloc_signed_min
)
1287 /* Put RELOCATION back into the insn. */
1288 upper_insn
= (upper_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 12) & 0x7ff);
1289 lower_insn
= (lower_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 1) & 0x7ff);
1291 /* Put the relocated value back in the object file: */
1292 bfd_put_16 (input_bfd
, upper_insn
, hit_data
);
1293 bfd_put_16 (input_bfd
, lower_insn
, hit_data
+ 2);
1295 return (overflow
? bfd_reloc_overflow
: bfd_reloc_ok
);
1299 case R_ARM_GNU_VTINHERIT
:
1300 case R_ARM_GNU_VTENTRY
:
1301 return bfd_reloc_ok
;
1304 return bfd_reloc_notsupported
;
1306 case R_ARM_GLOB_DAT
:
1307 return bfd_reloc_notsupported
;
1309 case R_ARM_JUMP_SLOT
:
1310 return bfd_reloc_notsupported
;
1312 case R_ARM_RELATIVE
:
1313 return bfd_reloc_notsupported
;
1316 /* Relocation is relative to the start of the
1317 global offset table. */
1319 BFD_ASSERT (sgot
!= NULL
);
1321 return bfd_reloc_notsupported
;
1323 /* Note that sgot->output_offset is not involved in this
1324 calculation. We always want the start of .got. If we
1325 define _GLOBAL_OFFSET_TABLE in a different way, as is
1326 permitted by the ABI, we might have to change this
1329 value
-= sgot
->output_section
->vma
;
1330 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1331 contents
, rel
->r_offset
, value
,
1335 /* Use global offset table as symbol value. */
1337 BFD_ASSERT (sgot
!= NULL
);
1340 return bfd_reloc_notsupported
;
1342 value
= sgot
->output_section
->vma
;
1343 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1344 contents
, rel
->r_offset
, value
,
1348 /* Relocation is to the entry for this symbol in the
1349 global offset table. */
1351 return bfd_reloc_notsupported
;
1357 off
= h
->got
.offset
;
1358 BFD_ASSERT (off
!= (bfd_vma
) -1);
1360 if (!elf_hash_table (info
)->dynamic_sections_created
||
1361 (info
->shared
&& (info
->symbolic
|| h
->dynindx
== -1)
1362 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1364 /* This is actually a static link, or it is a -Bsymbolic link
1365 and the symbol is defined locally. We must initialize this
1366 entry in the global offset table. Since the offset must
1367 always be a multiple of 4, we use the least significant bit
1368 to record whether we have initialized it already.
1370 When doing a dynamic link, we create a .rel.got relocation
1371 entry to initialize the value. This is done in the
1372 finish_dynamic_symbol routine. */
1378 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1383 value
= sgot
->output_offset
+ off
;
1389 BFD_ASSERT (local_got_offsets
!= NULL
&&
1390 local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1392 off
= local_got_offsets
[r_symndx
];
1394 /* The offset must always be a multiple of 4. We use the
1395 least significant bit to record whether we have already
1396 generated the necessary reloc. */
1401 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1406 Elf_Internal_Rel outrel
;
1408 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
1409 BFD_ASSERT (srelgot
!= NULL
);
1411 outrel
.r_offset
= (sgot
->output_section
->vma
1412 + sgot
->output_offset
1414 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1415 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1416 (((Elf32_External_Rel
*)
1418 + srelgot
->reloc_count
));
1419 ++srelgot
->reloc_count
;
1422 local_got_offsets
[r_symndx
] |= 1;
1425 value
= sgot
->output_offset
+ off
;
1428 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1429 contents
, rel
->r_offset
, value
,
1433 /* Relocation is to the entry for this symbol in the
1434 procedure linkage table. */
1436 /* Resolve a PLT32 reloc against a local symbol directly,
1437 without using the procedure linkage table. */
1439 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1440 contents
, rel
->r_offset
, value
,
1443 if (h
->plt
.offset
== (bfd_vma
) -1)
1444 /* We didn't make a PLT entry for this symbol. This
1445 happens when statically linking PIC code, or when
1446 using -Bsymbolic. */
1447 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1448 contents
, rel
->r_offset
, value
,
1451 BFD_ASSERT(splt
!= NULL
);
1453 return bfd_reloc_notsupported
;
1455 value
= (splt
->output_section
->vma
1456 + splt
->output_offset
1458 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1459 contents
, rel
->r_offset
, value
,
1463 return bfd_reloc_notsupported
;
1465 case R_ARM_AMP_VCALL9
:
1466 return bfd_reloc_notsupported
;
1468 case R_ARM_RSBREL32
:
1469 return bfd_reloc_notsupported
;
1471 case R_ARM_THM_RPC22
:
1472 return bfd_reloc_notsupported
;
1475 return bfd_reloc_notsupported
;
1478 return bfd_reloc_notsupported
;
1481 return bfd_reloc_notsupported
;
1484 return bfd_reloc_notsupported
;
1487 return bfd_reloc_notsupported
;
1492 /* Relocate an ARM ELF section. */
1494 elf32_arm_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1495 contents
, relocs
, local_syms
, local_sections
)
1497 struct bfd_link_info
* info
;
1499 asection
* input_section
;
1500 bfd_byte
* contents
;
1501 Elf_Internal_Rela
* relocs
;
1502 Elf_Internal_Sym
* local_syms
;
1503 asection
** local_sections
;
1505 Elf_Internal_Shdr
* symtab_hdr
;
1506 struct elf_link_hash_entry
** sym_hashes
;
1507 Elf_Internal_Rela
* rel
;
1508 Elf_Internal_Rela
* relend
;
1511 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1512 sym_hashes
= elf_sym_hashes (input_bfd
);
1515 relend
= relocs
+ input_section
->reloc_count
;
1516 for (; rel
< relend
; rel
++)
1519 reloc_howto_type
* howto
;
1520 unsigned long r_symndx
;
1521 Elf_Internal_Sym
* sym
;
1523 struct elf_link_hash_entry
* h
;
1525 bfd_reloc_status_type r
;
1527 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1528 r_type
= ELF32_R_TYPE (rel
->r_info
);
1530 if (r_type
== R_ARM_GNU_VTENTRY
1531 || r_type
== R_ARM_GNU_VTINHERIT
)
1534 /* ScottB: range check r_type here. */
1536 howto
= elf32_arm_howto_table
+ r_type
;
1538 if (info
->relocateable
)
1540 /* This is a relocateable link. We don't have to change
1541 anything, unless the reloc is against a section symbol,
1542 in which case we have to adjust according to where the
1543 section symbol winds up in the output section. */
1544 if (r_symndx
< symtab_hdr
->sh_info
)
1546 sym
= local_syms
+ r_symndx
;
1547 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1549 sec
= local_sections
[r_symndx
];
1553 val
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1554 val
+= (sec
->output_offset
+ sym
->st_value
);
1555 bfd_put_32 (input_bfd
, val
, contents
+ rel
->r_offset
);
1558 rel
->r_addend
+= (sec
->output_offset
+ sym
->st_value
)
1559 >> howto
->rightshift
;
1567 /* This is a final link. */
1571 if (r_symndx
< symtab_hdr
->sh_info
)
1573 sym
= local_syms
+ r_symndx
;
1574 sec
= local_sections
[r_symndx
];
1575 relocation
= (sec
->output_section
->vma
1576 + sec
->output_offset
1581 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1582 while (h
->root
.type
== bfd_link_hash_indirect
1583 || h
->root
.type
== bfd_link_hash_warning
)
1584 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1585 if (h
->root
.type
== bfd_link_hash_defined
1586 || h
->root
.type
== bfd_link_hash_defweak
)
1588 int relocation_needed
= 1;
1590 sec
= h
->root
.u
.def
.section
;
1592 /* In these cases, we don't need the relocation value.
1593 We check specially because in some obscure cases
1594 sec->output_section will be NULL. */
1601 (!info
->symbolic
&& h
->dynindx
!= -1)
1602 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1604 && ((input_section
->flags
& SEC_ALLOC
) != 0)
1606 relocation_needed
= 0;
1610 relocation_needed
= 0;
1614 if (elf_hash_table(info
)->dynamic_sections_created
1616 || (!info
->symbolic
&& h
->dynindx
!= -1)
1617 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1620 relocation_needed
= 0;
1624 if (h
->plt
.offset
!= (bfd_vma
)-1)
1625 relocation_needed
= 0;
1629 if (sec
->output_section
== NULL
)
1631 (*_bfd_error_handler
)
1632 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1633 bfd_get_filename (input_bfd
), h
->root
.root
.string
,
1634 bfd_get_section_name (input_bfd
, input_section
));
1635 relocation_needed
= 0;
1639 if (relocation_needed
)
1640 relocation
= h
->root
.u
.def
.value
1641 + sec
->output_section
->vma
1642 + sec
->output_offset
;
1646 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1650 if (!((*info
->callbacks
->undefined_symbol
)
1651 (info
, h
->root
.root
.string
, input_bfd
,
1652 input_section
, rel
->r_offset
)))
1659 name
= h
->root
.root
.string
;
1662 name
= (bfd_elf_string_from_elf_section
1663 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
1664 if (name
== NULL
|| *name
== '\0')
1665 name
= bfd_section_name (input_bfd
, sec
);
1668 r
= elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
1669 input_section
, contents
, rel
,
1670 relocation
, info
, sec
, name
,
1671 (h
? ELF_ST_TYPE (h
->type
) :
1672 ELF_ST_TYPE (sym
->st_info
)), h
);
1674 if (r
!= bfd_reloc_ok
)
1676 const char * msg
= (const char *) 0;
1680 case bfd_reloc_overflow
:
1681 if (!((*info
->callbacks
->reloc_overflow
)
1682 (info
, name
, howto
->name
, (bfd_vma
) 0,
1683 input_bfd
, input_section
, rel
->r_offset
)))
1687 case bfd_reloc_undefined
:
1688 if (!((*info
->callbacks
->undefined_symbol
)
1689 (info
, name
, input_bfd
, input_section
,
1694 case bfd_reloc_outofrange
:
1695 msg
= _ ("internal error: out of range error");
1698 case bfd_reloc_notsupported
:
1699 msg
= _ ("internal error: unsupported relocation error");
1702 case bfd_reloc_dangerous
:
1703 msg
= _ ("internal error: dangerous error");
1707 msg
= _ ("internal error: unknown error");
1711 if (!((*info
->callbacks
->warning
)
1712 (info
, msg
, name
, input_bfd
, input_section
,
1723 /* Function to keep ARM specific flags in the ELF header. */
1725 elf32_arm_set_private_flags (abfd
, flags
)
1729 if (elf_flags_init (abfd
)
1730 && elf_elfheader (abfd
)->e_flags
!= flags
)
1732 if (flags
& EF_INTERWORK
)
1733 _bfd_error_handler (_ ("\
1734 Warning: Not setting interwork flag of %s since it has already been specified as non-interworking"),
1735 bfd_get_filename (abfd
));
1737 _bfd_error_handler (_ ("\
1738 Warning: Clearing the interwork flag of %s due to outside request"),
1739 bfd_get_filename (abfd
));
1743 elf_elfheader (abfd
)->e_flags
= flags
;
1744 elf_flags_init (abfd
) = true;
1750 /* Copy backend specific data from one object module to another */
1752 elf32_arm_copy_private_bfd_data (ibfd
, obfd
)
1759 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1760 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1763 in_flags
= elf_elfheader (ibfd
)->e_flags
;
1764 out_flags
= elf_elfheader (obfd
)->e_flags
;
1766 if (elf_flags_init (obfd
) && in_flags
!= out_flags
)
1768 /* Cannot mix PIC and non-PIC code. */
1769 if ((in_flags
& EF_PIC
) != (out_flags
& EF_PIC
))
1772 /* Cannot mix APCS26 and APCS32 code. */
1773 if ((in_flags
& EF_APCS_26
) != (out_flags
& EF_APCS_26
))
1776 /* Cannot mix float APCS and non-float APCS code. */
1777 if ((in_flags
& EF_APCS_FLOAT
) != (out_flags
& EF_APCS_FLOAT
))
1780 /* If the src and dest have different interworking flags
1781 then turn off the interworking bit. */
1782 if ((in_flags
& EF_INTERWORK
) != (out_flags
& EF_INTERWORK
))
1784 if (out_flags
& EF_INTERWORK
)
1785 _bfd_error_handler (_ ("\
1786 Warning: Clearing the interwork flag in %s because non-interworking code in %s has been linked with it"),
1787 bfd_get_filename (obfd
), bfd_get_filename (ibfd
));
1789 in_flags
&= ~EF_INTERWORK
;
1793 elf_elfheader (obfd
)->e_flags
= in_flags
;
1794 elf_flags_init (obfd
) = true;
1799 /* Merge backend specific data from an object file to the output
1800 object file when linking. */
1802 elf32_arm_merge_private_bfd_data (ibfd
, obfd
)
1809 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1810 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1813 /* Check if we have the same endianess */
1814 if ( ibfd
->xvec
->byteorder
!= obfd
->xvec
->byteorder
1815 && obfd
->xvec
->byteorder
!= BFD_ENDIAN_UNKNOWN
1816 && ibfd
->xvec
->byteorder
!= BFD_ENDIAN_UNKNOWN
)
1818 (*_bfd_error_handler
)
1819 (_("%s: compiled for a %s endian system and target is %s endian"),
1820 bfd_get_filename (ibfd
),
1821 bfd_big_endian (ibfd
) ? "big" : "little",
1822 bfd_big_endian (obfd
) ? "big" : "little");
1824 bfd_set_error (bfd_error_wrong_format
);
1828 /* The input BFD must have had its flags initialised. */
1829 /* The following seems bogus to me -- The flags are initialized in
1830 the assembler but I don't think an elf_flags_init field is
1831 written into the object */
1832 /* BFD_ASSERT (elf_flags_init (ibfd)); */
1834 in_flags
= elf_elfheader (ibfd
)->e_flags
;
1835 out_flags
= elf_elfheader (obfd
)->e_flags
;
1837 if (!elf_flags_init (obfd
))
1839 /* If the input is the default architecture then do not
1840 bother setting the flags for the output architecture,
1841 instead allow future merges to do this. If no future
1842 merges ever set these flags then they will retain their
1843 unitialised values, which surprise surprise, correspond
1844 to the default values. */
1845 if (bfd_get_arch_info (ibfd
)->the_default
)
1848 elf_flags_init (obfd
) = true;
1849 elf_elfheader (obfd
)->e_flags
= in_flags
;
1851 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
1852 && bfd_get_arch_info (obfd
)->the_default
)
1853 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
), bfd_get_mach (ibfd
));
1858 /* Check flag compatibility. */
1859 if (in_flags
== out_flags
)
1862 /* Complain about various flag mismatches. */
1864 if ((in_flags
& EF_APCS_26
) != (out_flags
& EF_APCS_26
))
1865 _bfd_error_handler (_ ("\
1866 Error: %s compiled for APCS-%d, whereas %s is compiled for APCS-%d"),
1867 bfd_get_filename (ibfd
),
1868 in_flags
& EF_APCS_26
? 26 : 32,
1869 bfd_get_filename (obfd
),
1870 out_flags
& EF_APCS_26
? 26 : 32);
1872 if ((in_flags
& EF_APCS_FLOAT
) != (out_flags
& EF_APCS_FLOAT
))
1873 _bfd_error_handler (_ ("\
1874 Error: %s passes floats in %s registers, whereas %s passes them in %s registers"),
1875 bfd_get_filename (ibfd
),
1876 in_flags
& EF_APCS_FLOAT
? _ ("float") : _ ("integer"),
1877 bfd_get_filename (obfd
),
1878 out_flags
& EF_APCS_26
? _ ("float") : _ ("integer"));
1880 if ((in_flags
& EF_PIC
) != (out_flags
& EF_PIC
))
1881 _bfd_error_handler (_ ("\
1882 Error: %s is compiled as position %s code, whereas %s is not"),
1883 bfd_get_filename (ibfd
),
1884 in_flags
& EF_PIC
? _ ("independent") : _ ("dependent"),
1885 bfd_get_filename (obfd
));
1887 /* Interworking mismatch is only a warning. */
1888 if ((in_flags
& EF_INTERWORK
) != (out_flags
& EF_INTERWORK
))
1890 _bfd_error_handler (_ ("\
1891 Warning: %s %s interworking, whereas %s %s"),
1892 bfd_get_filename (ibfd
),
1893 in_flags
& EF_INTERWORK
? _ ("supports") : _ ("does not support"),
1894 bfd_get_filename (obfd
),
1895 out_flags
& EF_INTERWORK
? _ ("does not") : _ ("does"));
1902 /* Display the flags field */
1904 elf32_arm_print_private_bfd_data (abfd
, ptr
)
1908 FILE *file
= (FILE *) ptr
;
1910 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
1912 /* Print normal ELF private data. */
1913 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
1915 /* Ignore init flag - it may not be set, despite the flags field containing valid data. */
1917 /* xgettext:c-format */
1918 fprintf (file
, _ ("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
1920 if (elf_elfheader (abfd
)->e_flags
& EF_INTERWORK
)
1921 fprintf (file
, _ (" [interworking enabled]"));
1923 fprintf (file
, _ (" [interworking not enabled]"));
1925 if (elf_elfheader (abfd
)->e_flags
& EF_APCS_26
)
1926 fprintf (file
, _ (" [APCS-26]"));
1928 fprintf (file
, _ (" [APCS-32]"));
1930 if (elf_elfheader (abfd
)->e_flags
& EF_APCS_FLOAT
)
1931 fprintf (file
, _ (" [floats passed in float registers]"));
1933 fprintf (file
, _ (" [floats passed in integer registers]"));
1935 if (elf_elfheader (abfd
)->e_flags
& EF_PIC
)
1936 fprintf (file
, _ (" [position independent]"));
1938 fprintf (file
, _ (" [absolute position]"));
1946 elf32_arm_get_symbol_type (elf_sym
, type
)
1947 Elf_Internal_Sym
* elf_sym
;
1950 if (ELF_ST_TYPE (elf_sym
->st_info
) == STT_ARM_TFUNC
)
1951 return ELF_ST_TYPE (elf_sym
->st_info
);
1957 elf32_arm_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
1959 struct bfd_link_info
*info
;
1960 Elf_Internal_Rela
*rel
;
1961 struct elf_link_hash_entry
*h
;
1962 Elf_Internal_Sym
*sym
;
1966 switch (ELF32_R_TYPE (rel
->r_info
))
1968 case R_ARM_GNU_VTINHERIT
:
1969 case R_ARM_GNU_VTENTRY
:
1973 switch (h
->root
.type
)
1975 case bfd_link_hash_defined
:
1976 case bfd_link_hash_defweak
:
1977 return h
->root
.u
.def
.section
;
1979 case bfd_link_hash_common
:
1980 return h
->root
.u
.c
.p
->section
;
1986 if (!(elf_bad_symtab (abfd
)
1987 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
1988 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
1989 && sym
->st_shndx
!= SHN_COMMON
))
1991 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
1997 /* Update the got entry reference counts for the section being removed. */
2000 elf32_arm_gc_sweep_hook (abfd
, info
, sec
, relocs
)
2002 struct bfd_link_info
*info
;
2004 const Elf_Internal_Rela
*relocs
;
2006 /* We don't support garbage collection of GOT and PLT relocs yet. */
2010 /* Look through the relocs for a section during the first phase. */
2013 elf32_arm_check_relocs (abfd
, info
, sec
, relocs
)
2015 struct bfd_link_info
* info
;
2017 const Elf_Internal_Rela
* relocs
;
2019 Elf_Internal_Shdr
* symtab_hdr
;
2020 struct elf_link_hash_entry
** sym_hashes
;
2021 struct elf_link_hash_entry
** sym_hashes_end
;
2022 const Elf_Internal_Rela
* rel
;
2023 const Elf_Internal_Rela
* rel_end
;
2025 asection
* sgot
, *srelgot
, *sreloc
;
2026 bfd_vma
* local_got_offsets
;
2028 if (info
->relocateable
)
2031 sgot
= srelgot
= sreloc
= NULL
;
2033 dynobj
= elf_hash_table (info
)->dynobj
;
2034 local_got_offsets
= elf_local_got_offsets (abfd
);
2036 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2037 sym_hashes
= elf_sym_hashes (abfd
);
2038 sym_hashes_end
= sym_hashes
+ symtab_hdr
->sh_size
/sizeof(Elf32_External_Sym
);
2039 if (!elf_bad_symtab (abfd
))
2040 sym_hashes_end
-= symtab_hdr
->sh_info
;
2042 rel_end
= relocs
+ sec
->reloc_count
;
2043 for (rel
= relocs
; rel
< rel_end
; rel
++)
2045 struct elf_link_hash_entry
*h
;
2046 unsigned long r_symndx
;
2048 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2049 if (r_symndx
< symtab_hdr
->sh_info
)
2052 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2054 /* Some relocs require a global offset table. */
2057 switch (ELF32_R_TYPE (rel
->r_info
))
2062 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
2063 if (! _bfd_elf_create_got_section (dynobj
, info
))
2072 switch (ELF32_R_TYPE (rel
->r_info
))
2075 /* This symbol requires a global offset table entry. */
2078 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2079 BFD_ASSERT (sgot
!= NULL
);
2082 /* Get the got relocation section if necessary. */
2084 && (h
!= NULL
|| info
->shared
))
2086 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
2088 /* If no got relocation section, make one and initialize. */
2089 if (srelgot
== NULL
)
2091 srelgot
= bfd_make_section (dynobj
, ".rel.got");
2093 || ! bfd_set_section_flags (dynobj
, srelgot
,
2098 | SEC_LINKER_CREATED
2100 || ! bfd_set_section_alignment (dynobj
, srelgot
, 2))
2107 if (h
->got
.offset
!= (bfd_vma
) -1)
2108 /* We have already allocated space in the .got. */
2111 h
->got
.offset
= sgot
->_raw_size
;
2113 /* Make sure this symbol is output as a dynamic symbol. */
2114 if (h
->dynindx
== -1)
2115 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2118 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2122 /* This is a global offset table entry for a local
2124 if (local_got_offsets
== NULL
)
2127 register unsigned int i
;
2129 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
2130 local_got_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
2131 if (local_got_offsets
== NULL
)
2133 elf_local_got_offsets (abfd
) = local_got_offsets
;
2134 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
2135 local_got_offsets
[i
] = (bfd_vma
) -1;
2138 if (local_got_offsets
[r_symndx
] != (bfd_vma
) -1)
2139 /* We have already allocated space in the .got. */
2142 local_got_offsets
[r_symndx
] = sgot
->_raw_size
;
2145 /* If we are generating a shared object, we need to
2146 output a R_ARM_RELATIVE reloc so that the dynamic
2147 linker can adjust this GOT entry. */
2148 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2151 sgot
->_raw_size
+= 4;
2155 /* This symbol requires a procedure linkage table entry. We
2156 actually build the entry in adjust_dynamic_symbol,
2157 because this might be a case of linking PIC code which is
2158 never referenced by a dynamic object, in which case we
2159 don't need to generate a procedure linkage table entry
2162 /* If this is a local symbol, we resolve it directly without
2163 creating a procedure linkage table entry. */
2167 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2173 /* If we are creating a shared library, and this is a reloc
2174 against a global symbol, or a non PC relative reloc
2175 against a local symbol, then we need to copy the reloc
2176 into the shared library. However, if we are linking with
2177 -Bsymbolic, we do not need to copy a reloc against a
2178 global symbol which is defined in an object we are
2179 including in the link (i.e., DEF_REGULAR is set). At
2180 this point we have not seen all the input files, so it is
2181 possible that DEF_REGULAR is not set now but will be set
2182 later (it is never cleared). We account for that
2183 possibility below by storing information in the
2184 pcrel_relocs_copied field of the hash table entry. */
2186 && (ELF32_R_TYPE (rel
->r_info
) != R_ARM_PC24
2188 && (! info
->symbolic
2189 || (h
->elf_link_hash_flags
2190 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
2192 /* When creating a shared object, we must copy these
2193 reloc types into the output file. We create a reloc
2194 section in dynobj and make room for this reloc. */
2199 name
= (bfd_elf_string_from_elf_section
2201 elf_elfheader (abfd
)->e_shstrndx
,
2202 elf_section_data (sec
)->rel_hdr
.sh_name
));
2206 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
2207 && strcmp (bfd_get_section_name (abfd
, sec
),
2210 sreloc
= bfd_get_section_by_name (dynobj
, name
);
2215 sreloc
= bfd_make_section (dynobj
, name
);
2216 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
2217 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
2218 if ((sec
->flags
& SEC_ALLOC
) != 0)
2219 flags
|= SEC_ALLOC
| SEC_LOAD
;
2221 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
2222 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
2227 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
2228 /* If we are linking with -Bsymbolic, and this is a
2229 global symbol, we count the number of PC relative
2230 relocations we have entered for this symbol, so that
2231 we can discard them again if the symbol is later
2232 defined by a regular object. Note that this function
2233 is only called if we are using an elf_i386 linker
2234 hash table, which means that h is really a pointer to
2235 an elf_i386_link_hash_entry. */
2236 if (h
!= NULL
&& info
->symbolic
2237 && ELF32_R_TYPE (rel
->r_info
) == R_ARM_PC24
)
2239 struct elf32_arm_link_hash_entry
* eh
;
2240 struct elf32_arm_pcrel_relocs_copied
* p
;
2242 eh
= (struct elf32_arm_link_hash_entry
*) h
;
2244 for (p
= eh
->pcrel_relocs_copied
; p
!= NULL
; p
= p
->next
)
2245 if (p
->section
== sreloc
)
2250 p
= ((struct elf32_arm_pcrel_relocs_copied
*)
2251 bfd_alloc (dynobj
, sizeof * p
));
2255 p
->next
= eh
->pcrel_relocs_copied
;
2256 eh
->pcrel_relocs_copied
= p
;
2257 p
->section
= sreloc
;
2266 /* This relocation describes the C++ object vtable hierarchy.
2267 Reconstruct it for later use during GC. */
2268 case R_ARM_GNU_VTINHERIT
:
2269 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2273 /* This relocation describes which C++ vtable entries are actually
2274 used. Record for later use during GC. */
2275 case R_ARM_GNU_VTENTRY
:
2276 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2286 /* Find the nearest line to a particular section and offset, for error
2287 reporting. This code is a duplicate of the code in elf.c, except
2288 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
2291 elf32_arm_find_nearest_line
2292 (abfd
, section
, symbols
, offset
, filename_ptr
, functionname_ptr
, line_ptr
)
2297 CONST
char ** filename_ptr
;
2298 CONST
char ** functionname_ptr
;
2299 unsigned int * line_ptr
;
2302 const char * filename
;
2307 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
2308 filename_ptr
, functionname_ptr
,
2312 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2313 &found
, filename_ptr
,
2314 functionname_ptr
, line_ptr
,
2315 &elf_tdata (abfd
)->line_info
))
2321 if (symbols
== NULL
)
2328 for (p
= symbols
; *p
!= NULL
; p
++)
2332 q
= (elf_symbol_type
*) *p
;
2334 if (bfd_get_section (&q
->symbol
) != section
)
2337 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
2342 filename
= bfd_asymbol_name (&q
->symbol
);
2347 if (q
->symbol
.section
== section
2348 && q
->symbol
.value
>= low_func
2349 && q
->symbol
.value
<= offset
)
2351 func
= (asymbol
*) q
;
2352 low_func
= q
->symbol
.value
;
2361 *filename_ptr
= filename
;
2362 *functionname_ptr
= bfd_asymbol_name (func
);
2368 /* Adjust a symbol defined by a dynamic object and referenced by a
2369 regular object. The current definition is in some section of the
2370 dynamic object, but we're not including those sections. We have to
2371 change the definition to something the rest of the link can
2375 elf32_arm_adjust_dynamic_symbol (info
, h
)
2376 struct bfd_link_info
* info
;
2377 struct elf_link_hash_entry
* h
;
2381 unsigned int power_of_two
;
2383 dynobj
= elf_hash_table (info
)->dynobj
;
2385 /* Make sure we know what is going on here. */
2386 BFD_ASSERT (dynobj
!= NULL
2387 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
2388 || h
->weakdef
!= NULL
2389 || ((h
->elf_link_hash_flags
2390 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2391 && (h
->elf_link_hash_flags
2392 & ELF_LINK_HASH_REF_REGULAR
) != 0
2393 && (h
->elf_link_hash_flags
2394 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
2396 /* If this is a function, put it in the procedure linkage table. We
2397 will fill in the contents of the procedure linkage table later,
2398 when we know the address of the .got section. */
2399 if (h
->type
== STT_FUNC
2400 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
2403 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
2404 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0)
2406 /* This case can occur if we saw a PLT32 reloc in an input
2407 file, but the symbol was never referred to by a dynamic
2408 object. In such a case, we don't actually need to build
2409 a procedure linkage table, and we can just do a PC32
2411 BFD_ASSERT ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0);
2415 /* Make sure this symbol is output as a dynamic symbol. */
2416 if (h
->dynindx
== -1)
2418 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2422 s
= bfd_get_section_by_name (dynobj
, ".plt");
2423 BFD_ASSERT (s
!= NULL
);
2425 /* If this is the first .plt entry, make room for the special
2427 if (s
->_raw_size
== 0)
2428 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2430 /* If this symbol is not defined in a regular file, and we are
2431 not generating a shared library, then set the symbol to this
2432 location in the .plt. This is required to make function
2433 pointers compare as equal between the normal executable and
2434 the shared library. */
2436 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2438 h
->root
.u
.def
.section
= s
;
2439 h
->root
.u
.def
.value
= s
->_raw_size
;
2442 h
->plt
.offset
= s
->_raw_size
;
2444 /* Make room for this entry. */
2445 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2447 /* We also need to make an entry in the .got.plt section, which
2448 will be placed in the .got section by the linker script. */
2450 s
= bfd_get_section_by_name (dynobj
, ".got.plt");
2451 BFD_ASSERT (s
!= NULL
);
2454 /* We also need to make an entry in the .rel.plt section. */
2456 s
= bfd_get_section_by_name (dynobj
, ".rel.plt");
2457 BFD_ASSERT (s
!= NULL
);
2458 s
->_raw_size
+= sizeof (Elf32_External_Rel
);
2463 /* If this is a weak symbol, and there is a real definition, the
2464 processor independent code will have arranged for us to see the
2465 real definition first, and we can just use the same value. */
2466 if (h
->weakdef
!= NULL
)
2468 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
2469 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
2470 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
2471 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
2475 /* This is a reference to a symbol defined by a dynamic object which
2476 is not a function. */
2478 /* If we are creating a shared library, we must presume that the
2479 only references to the symbol are via the global offset table.
2480 For such cases we need not do anything here; the relocations will
2481 be handled correctly by relocate_section. */
2485 /* We must allocate the symbol in our .dynbss section, which will
2486 become part of the .bss section of the executable. There will be
2487 an entry for this symbol in the .dynsym section. The dynamic
2488 object will contain position independent code, so all references
2489 from the dynamic object to this symbol will go through the global
2490 offset table. The dynamic linker will use the .dynsym entry to
2491 determine the address it must put in the global offset table, so
2492 both the dynamic object and the regular object will refer to the
2493 same memory location for the variable. */
2495 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
2496 BFD_ASSERT (s
!= NULL
);
2498 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
2499 copy the initial value out of the dynamic object and into the
2500 runtime process image. We need to remember the offset into the
2501 .rel.bss section we are going to use. */
2502 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2506 srel
= bfd_get_section_by_name (dynobj
, ".rel.bss");
2507 BFD_ASSERT (srel
!= NULL
);
2508 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
2509 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
2512 /* We need to figure out the alignment required for this symbol. I
2513 have no idea how ELF linkers handle this. */
2514 power_of_two
= bfd_log2 (h
->size
);
2515 if (power_of_two
> 3)
2518 /* Apply the required alignment. */
2519 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
2520 (bfd_size_type
) (1 << power_of_two
));
2521 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
2523 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
2527 /* Define the symbol as being at this point in the section. */
2528 h
->root
.u
.def
.section
= s
;
2529 h
->root
.u
.def
.value
= s
->_raw_size
;
2531 /* Increment the section size to make room for the symbol. */
2532 s
->_raw_size
+= h
->size
;
2537 /* Set the sizes of the dynamic sections. */
2540 elf32_arm_size_dynamic_sections (output_bfd
, info
)
2542 struct bfd_link_info
* info
;
2550 dynobj
= elf_hash_table (info
)->dynobj
;
2551 BFD_ASSERT (dynobj
!= NULL
);
2553 if (elf_hash_table (info
)->dynamic_sections_created
)
2555 /* Set the contents of the .interp section to the interpreter. */
2558 s
= bfd_get_section_by_name (dynobj
, ".interp");
2559 BFD_ASSERT (s
!= NULL
);
2560 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2561 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2566 /* We may have created entries in the .rel.got section.
2567 However, if we are not creating the dynamic sections, we will
2568 not actually use these entries. Reset the size of .rel.got,
2569 which will cause it to get stripped from the output file
2571 s
= bfd_get_section_by_name (dynobj
, ".rel.got");
2576 /* If this is a -Bsymbolic shared link, then we need to discard all
2577 PC relative relocs against symbols defined in a regular object.
2578 We allocated space for them in the check_relocs routine, but we
2579 will not fill them in in the relocate_section routine. */
2580 if (info
->shared
&& info
->symbolic
)
2581 elf32_arm_link_hash_traverse (elf32_arm_hash_table (info
),
2582 elf32_arm_discard_copies
,
2585 /* The check_relocs and adjust_dynamic_symbol entry points have
2586 determined the sizes of the various dynamic sections. Allocate
2591 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2596 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2599 /* It's OK to base decisions on the section name, because none
2600 of the dynobj section names depend upon the input files. */
2601 name
= bfd_get_section_name (dynobj
, s
);
2605 if (strcmp (name
, ".plt") == 0)
2607 if (s
->_raw_size
== 0)
2609 /* Strip this section if we don't need it; see the
2615 /* Remember whether there is a PLT. */
2619 else if (strncmp (name
, ".rel", 4) == 0)
2621 if (s
->_raw_size
== 0)
2623 /* If we don't need this section, strip it from the
2624 output file. This is mostly to handle .rel.bss and
2625 .rel.plt. We must create both sections in
2626 create_dynamic_sections, because they must be created
2627 before the linker maps input sections to output
2628 sections. The linker does that before
2629 adjust_dynamic_symbol is called, and it is that
2630 function which decides whether anything needs to go
2631 into these sections. */
2638 /* Remember whether there are any reloc sections other
2640 if (strcmp (name
, ".rel.plt") != 0)
2642 const char *outname
;
2646 /* If this relocation section applies to a read only
2647 section, then we probably need a DT_TEXTREL
2648 entry. The entries in the .rel.plt section
2649 really apply to the .got section, which we
2650 created ourselves and so know is not readonly. */
2651 outname
= bfd_get_section_name (output_bfd
,
2653 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
2655 && (target
->flags
& SEC_READONLY
) != 0
2656 && (target
->flags
& SEC_ALLOC
) != 0)
2660 /* We use the reloc_count field as a counter if we need
2661 to copy relocs into the output file. */
2665 else if (strncmp (name
, ".got", 4) != 0)
2667 /* It's not one of our sections, so don't allocate space. */
2675 for (spp
= &s
->output_section
->owner
->sections
;
2676 *spp
!= s
->output_section
;
2677 spp
= &(*spp
)->next
)
2679 *spp
= s
->output_section
->next
;
2680 --s
->output_section
->owner
->section_count
;
2685 /* Allocate memory for the section contents. */
2686 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
2687 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
2691 if (elf_hash_table (info
)->dynamic_sections_created
)
2693 /* Add some entries to the .dynamic section. We fill in the
2694 values later, in elf32_arm_finish_dynamic_sections, but we
2695 must add the entries now so that we get the correct size for
2696 the .dynamic section. The DT_DEBUG entry is filled in by the
2697 dynamic linker and used by the debugger. */
2700 if (! bfd_elf32_add_dynamic_entry (info
, DT_DEBUG
, 0))
2706 if (! bfd_elf32_add_dynamic_entry (info
, DT_PLTGOT
, 0)
2707 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
2708 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTREL
, DT_REL
)
2709 || ! bfd_elf32_add_dynamic_entry (info
, DT_JMPREL
, 0))
2715 if (! bfd_elf32_add_dynamic_entry (info
, DT_REL
, 0)
2716 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELSZ
, 0)
2717 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELENT
,
2718 sizeof (Elf32_External_Rel
)))
2724 if (! bfd_elf32_add_dynamic_entry (info
, DT_TEXTREL
, 0))
2732 /* This function is called via elf32_arm_link_hash_traverse if we are
2733 creating a shared object with -Bsymbolic. It discards the space
2734 allocated to copy PC relative relocs against symbols which are
2735 defined in regular objects. We allocated space for them in the
2736 check_relocs routine, but we won't fill them in in the
2737 relocate_section routine. */
2740 elf32_arm_discard_copies (h
, ignore
)
2741 struct elf32_arm_link_hash_entry
* h
;
2744 struct elf32_arm_pcrel_relocs_copied
* s
;
2746 /* We only discard relocs for symbols defined in a regular object. */
2747 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2750 for (s
= h
->pcrel_relocs_copied
; s
!= NULL
; s
= s
->next
)
2751 s
->section
->_raw_size
-= s
->count
* sizeof (Elf32_External_Rel
);
2756 /* Finish up dynamic symbol handling. We set the contents of various
2757 dynamic sections here. */
2760 elf32_arm_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
2762 struct bfd_link_info
* info
;
2763 struct elf_link_hash_entry
* h
;
2764 Elf_Internal_Sym
* sym
;
2768 dynobj
= elf_hash_table (info
)->dynobj
;
2770 if (h
->plt
.offset
!= (bfd_vma
) -1)
2777 Elf_Internal_Rel rel
;
2779 /* This symbol has an entry in the procedure linkage table. Set
2782 BFD_ASSERT (h
->dynindx
!= -1);
2784 splt
= bfd_get_section_by_name (dynobj
, ".plt");
2785 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
2786 srel
= bfd_get_section_by_name (dynobj
, ".rel.plt");
2787 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
2789 /* Get the index in the procedure linkage table which
2790 corresponds to this symbol. This is the index of this symbol
2791 in all the symbols for which we are making plt entries. The
2792 first entry in the procedure linkage table is reserved. */
2793 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
2795 /* Get the offset into the .got table of the entry that
2796 corresponds to this function. Each .got entry is 4 bytes.
2797 The first three are reserved. */
2798 got_offset
= (plt_index
+ 3) * 4;
2800 /* Fill in the entry in the procedure linkage table. */
2801 memcpy (splt
->contents
+ h
->plt
.offset
,
2802 elf32_arm_plt_entry
,
2804 bfd_put_32 (output_bfd
,
2805 (sgot
->output_section
->vma
2806 + sgot
->output_offset
2808 - splt
->output_section
->vma
2809 - splt
->output_offset
2810 - h
->plt
.offset
- 12),
2811 splt
->contents
+ h
->plt
.offset
+ 12);
2813 /* Fill in the entry in the global offset table. */
2814 bfd_put_32 (output_bfd
,
2815 (splt
->output_section
->vma
2816 + splt
->output_offset
),
2817 sgot
->contents
+ got_offset
);
2819 /* Fill in the entry in the .rel.plt section. */
2820 rel
.r_offset
= (sgot
->output_section
->vma
2821 + sgot
->output_offset
2823 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_JUMP_SLOT
);
2824 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
2825 ((Elf32_External_Rel
*) srel
->contents
2828 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2830 /* Mark the symbol as undefined, rather than as defined in
2831 the .plt section. Leave the value alone. */
2832 sym
->st_shndx
= SHN_UNDEF
;
2836 if (h
->got
.offset
!= (bfd_vma
) -1)
2840 Elf_Internal_Rel rel
;
2842 /* This symbol has an entry in the global offset table. Set it
2845 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2846 srel
= bfd_get_section_by_name (dynobj
, ".rel.got");
2847 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
2849 rel
.r_offset
= (sgot
->output_section
->vma
2850 + sgot
->output_offset
2851 + (h
->got
.offset
&~ 1));
2853 /* If this is a -Bsymbolic link, and the symbol is defined
2854 locally, we just want to emit a RELATIVE reloc. The entry in
2855 the global offset table will already have been initialized in
2856 the relocate_section function. */
2858 && (info
->symbolic
|| h
->dynindx
== -1)
2859 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
2860 rel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
2863 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
2864 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_GLOB_DAT
);
2867 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
2868 ((Elf32_External_Rel
*) srel
->contents
2869 + srel
->reloc_count
));
2870 ++srel
->reloc_count
;
2873 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
2876 Elf_Internal_Rel rel
;
2878 /* This symbol needs a copy reloc. Set it up. */
2880 BFD_ASSERT (h
->dynindx
!= -1
2881 && (h
->root
.type
== bfd_link_hash_defined
2882 || h
->root
.type
== bfd_link_hash_defweak
));
2884 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
2886 BFD_ASSERT (s
!= NULL
);
2888 rel
.r_offset
= (h
->root
.u
.def
.value
2889 + h
->root
.u
.def
.section
->output_section
->vma
2890 + h
->root
.u
.def
.section
->output_offset
);
2891 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_COPY
);
2892 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
2893 ((Elf32_External_Rel
*) s
->contents
2898 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2899 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2900 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2901 sym
->st_shndx
= SHN_ABS
;
2906 /* Finish up the dynamic sections. */
2909 elf32_arm_finish_dynamic_sections (output_bfd
, info
)
2911 struct bfd_link_info
* info
;
2917 dynobj
= elf_hash_table (info
)->dynobj
;
2919 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
2920 BFD_ASSERT (sgot
!= NULL
);
2921 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2923 if (elf_hash_table (info
)->dynamic_sections_created
)
2926 Elf32_External_Dyn
*dyncon
, *dynconend
;
2928 splt
= bfd_get_section_by_name (dynobj
, ".plt");
2929 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
2931 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2932 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
2933 for (; dyncon
< dynconend
; dyncon
++)
2935 Elf_Internal_Dyn dyn
;
2939 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2952 s
= bfd_get_section_by_name (output_bfd
, name
);
2953 BFD_ASSERT (s
!= NULL
);
2954 dyn
.d_un
.d_ptr
= s
->vma
;
2955 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2959 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
2960 BFD_ASSERT (s
!= NULL
);
2961 if (s
->_cooked_size
!= 0)
2962 dyn
.d_un
.d_val
= s
->_cooked_size
;
2964 dyn
.d_un
.d_val
= s
->_raw_size
;
2965 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2969 /* My reading of the SVR4 ABI indicates that the
2970 procedure linkage table relocs (DT_JMPREL) should be
2971 included in the overall relocs (DT_REL). This is
2972 what Solaris does. However, UnixWare can not handle
2973 that case. Therefore, we override the DT_RELSZ entry
2974 here to make it not include the JMPREL relocs. Since
2975 the linker script arranges for .rel.plt to follow all
2976 other relocation sections, we don't have to worry
2977 about changing the DT_REL entry. */
2978 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
2981 if (s
->_cooked_size
!= 0)
2982 dyn
.d_un
.d_val
-= s
->_cooked_size
;
2984 dyn
.d_un
.d_val
-= s
->_raw_size
;
2986 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2991 /* Fill in the first entry in the procedure linkage table. */
2992 if (splt
->_raw_size
> 0)
2993 memcpy (splt
->contents
, elf32_arm_plt0_entry
, PLT_ENTRY_SIZE
);
2995 /* UnixWare sets the entsize of .plt to 4, although that doesn't
2996 really seem like the right value. */
2997 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
3000 /* Fill in the first three entries in the global offset table. */
3001 if (sgot
->_raw_size
> 0)
3004 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
3006 bfd_put_32 (output_bfd
,
3007 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3009 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
3010 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
3013 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
3018 #define ELF_ARCH bfd_arch_arm
3019 #define ELF_MACHINE_CODE EM_ARM
3020 #define ELF_MAXPAGE_SIZE 0x8000
3023 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
3024 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
3025 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
3026 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
3027 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
3028 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
3029 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
3031 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
3032 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
3033 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
3034 #define elf_backend_check_relocs elf32_arm_check_relocs
3035 #define elf_backend_relocate_section elf32_arm_relocate_section
3036 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
3037 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
3038 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
3039 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
3040 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
3042 #define elf_backend_can_gc_sections 1
3043 #define elf_backend_plt_readonly 1
3044 #define elf_backend_want_got_plt 1
3045 #define elf_backend_want_plt_sym 0
3047 #include "elf32-target.h"