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 *));
54 /* The linker script knows the section names for placement.
55 The entry_names are used to do simple name mangling on the stubs.
56 Given a function name, and its type, the stub can be found. The
57 name can be changed. The only requirement is the %s be present.
60 #define INTERWORK_FLAG( abfd ) (elf_elfheader (abfd)->e_flags & EF_INTERWORK)
62 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
63 #define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
65 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
66 #define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
68 /* The name of the dynamic interpreter. This is put in the .interp
70 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
72 /* The size in bytes of an entry in the procedure linkage table. */
74 #define PLT_ENTRY_SIZE 16
76 /* The first entry in a procedure linkage table looks like
77 this. It is set up so that any shared library function that is
78 called before the relocation has been set up calles the dynamic
81 static const bfd_byte elf32_arm_plt0_entry [PLT_ENTRY_SIZE] =
83 0x04, 0xe0, 0x2d, 0xe5, /* str lr, [sp, #-4]! */
84 0x10, 0xe0, 0x9f, 0xe5, /* ldr lr, [pc, #16] */
85 0x0e, 0xe0, 0x8f, 0xe0, /* adr lr, pc, lr */
86 0x08, 0xf0, 0xbe, 0xe5 /* ldr pc, [lr, #-4] */
89 /* Subsequent entries in a procedure linkage table look like
92 static const bfd_byte elf32_arm_plt_entry [PLT_ENTRY_SIZE] =
94 0x04, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc, #4] */
95 0x0c, 0xc0, 0x8f, 0xe0, /* add ip, pc, ip */
96 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
97 0x00, 0x00, 0x00, 0x00 /* offset to symbol in got */
101 /* The ARM linker needs to keep track of the number of relocs that it
102 decides to copy in check_relocs for each symbol. This is so that
103 it can discard PC relative relocs if it doesn't need them when
104 linking with -Bsymbolic. We store the information in a field
105 extending the regular ELF linker hash table. */
107 /* This structure keeps track of the number of PC relative relocs we
108 have copied for a given symbol. */
110 struct elf32_arm_pcrel_relocs_copied
113 struct elf32_arm_pcrel_relocs_copied * next;
114 /* A section in dynobj. */
116 /* Number of relocs copied in this section. */
120 /* Arm ELF linker hash entry. */
122 struct elf32_arm_link_hash_entry
124 struct elf_link_hash_entry root;
126 /* Number of PC relative relocs copied for this symbol. */
127 struct elf32_arm_pcrel_relocs_copied * pcrel_relocs_copied;
130 /* Declare this now that the above structures are defined. */
132 static boolean elf32_arm_discard_copies
133 PARAMS ((struct elf32_arm_link_hash_entry *, PTR));
135 /* Traverse an arm ELF linker hash table. */
137 #define elf32_arm_link_hash_traverse(table, func, info) \
138 (elf_link_hash_traverse \
140 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
143 /* Get the ARM elf linker hash table from a link_info structure. */
144 #define elf32_arm_hash_table(info) \
145 ((struct elf32_arm_link_hash_table *) ((info)->hash))
147 /* ARM ELF linker hash table */
148 struct elf32_arm_link_hash_table
150 /* The main hash table. */
151 struct elf_link_hash_table root;
153 /* The size in bytes of the section containg the Thumb-to-ARM glue. */
154 long int thumb_glue_size;
156 /* The size in bytes of the section containg the ARM-to-Thumb glue. */
157 long int arm_glue_size;
159 /* An arbitary input BFD chosen to hold the glue sections. */
160 bfd * bfd_of_glue_owner;
162 /* A boolean indicating whether knowledge of the ARM's pipeline
163 length should be applied by the linker. */
164 int no_pipeline_knowledge;
168 /* Create an entry in an ARM ELF linker hash table. */
170 static struct bfd_hash_entry *
171 elf32_arm_link_hash_newfunc (entry, table, string)
172 struct bfd_hash_entry * entry;
173 struct bfd_hash_table * table;
176 struct elf32_arm_link_hash_entry * ret =
177 (struct elf32_arm_link_hash_entry *) entry;
179 /* Allocate the structure if it has not already been allocated by a
181 if (ret == (struct elf32_arm_link_hash_entry *) NULL)
182 ret = ((struct elf32_arm_link_hash_entry *)
183 bfd_hash_allocate (table,
184 sizeof (struct elf32_arm_link_hash_entry)));
185 if (ret == (struct elf32_arm_link_hash_entry *) NULL)
186 return (struct bfd_hash_entry *) ret;
188 /* Call the allocation method of the superclass. */
189 ret = ((struct elf32_arm_link_hash_entry *)
190 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
192 if (ret != (struct elf32_arm_link_hash_entry *) NULL)
193 ret->pcrel_relocs_copied = NULL;
195 return (struct bfd_hash_entry *) ret;
198 /* Create an ARM elf linker hash table */
200 static struct bfd_link_hash_table *
201 elf32_arm_link_hash_table_create (abfd)
204 struct elf32_arm_link_hash_table *ret;
206 ret = ((struct elf32_arm_link_hash_table *)
207 bfd_alloc (abfd, sizeof (struct elf32_arm_link_hash_table)));
208 if (ret == (struct elf32_arm_link_hash_table *) NULL)
211 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
212 elf32_arm_link_hash_newfunc))
214 bfd_release (abfd, ret);
218 ret->thumb_glue_size = 0;
219 ret->arm_glue_size = 0;
220 ret->bfd_of_glue_owner = NULL;
221 ret->no_pipeline_knowledge = 0;
223 return &ret->root.root;
226 static struct elf_link_hash_entry *
227 find_thumb_glue (link_info, name, input_bfd)
228 struct bfd_link_info *link_info;
233 struct elf_link_hash_entry *hash;
234 struct elf32_arm_link_hash_table *hash_table;
236 /* We need a pointer to the armelf specific hash table. */
237 hash_table = elf32_arm_hash_table (link_info);
241 bfd_malloc (strlen (name) + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1));
243 BFD_ASSERT (tmp_name);
245 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
247 hash = elf_link_hash_lookup
248 (&(hash_table)->root, tmp_name, false, false, true);
251 /* xgettext:c-format */
252 _bfd_error_handler (_ ("%s: unable to find THUMB glue '%s' for `%s'"),
253 bfd_get_filename (input_bfd), tmp_name, name);
260 static struct elf_link_hash_entry *
261 find_arm_glue (link_info, name, input_bfd)
262 struct bfd_link_info *link_info;
267 struct elf_link_hash_entry *myh;
268 struct elf32_arm_link_hash_table *hash_table;
270 /* We need a pointer to the elfarm specific hash table. */
271 hash_table = elf32_arm_hash_table (link_info);
274 bfd_malloc (strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1));
276 BFD_ASSERT (tmp_name);
278 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
280 myh = elf_link_hash_lookup
281 (&(hash_table)->root, tmp_name, false, false, true);
284 /* xgettext:c-format */
285 _bfd_error_handler (_ ("%s: unable to find ARM glue '%s' for `%s'"),
286 bfd_get_filename (input_bfd), tmp_name, name);
301 .word func @ behave as if you saw a ARM_32 reloc
304 #define ARM2THUMB_GLUE_SIZE 12
305 static const insn32 a2t1_ldr_insn = 0xe59fc000;
306 static const insn32 a2t2_bx_r12_insn = 0xe12fff1c;
307 static const insn32 a2t3_func_addr_insn = 0x00000001;
310 Thumb->ARM: Thumb->(non-interworking aware) ARM
314 __func_from_thumb: __func_from_thumb:
316 nop ldr r6, __func_addr
318 __func_change_to_arm: bx r6
320 __func_back_to_thumb:
327 #define THUMB2ARM_GLUE_SIZE 8
328 static const insn16 t2a1_bx_pc_insn = 0x4778;
329 static const insn16 t2a2_noop_insn = 0x46c0;
330 static const insn32 t2a3_b_insn = 0xea000000;
332 static const insn16 t2a1_push_insn = 0xb540;
333 static const insn16 t2a2_ldr_insn = 0x4e03;
334 static const insn16 t2a3_mov_insn = 0x46fe;
335 static const insn16 t2a4_bx_insn = 0x4730;
336 static const insn32 t2a5_pop_insn = 0xe8bd4040;
337 static const insn32 t2a6_bx_insn = 0xe12fff1e;
340 bfd_elf32_arm_allocate_interworking_sections (info)
341 struct bfd_link_info * info;
345 struct elf32_arm_link_hash_table * globals;
347 globals = elf32_arm_hash_table (info);
349 BFD_ASSERT (globals != NULL);
351 if (globals->arm_glue_size != 0)
353 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
355 s = bfd_get_section_by_name
356 (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
358 BFD_ASSERT (s != NULL);
360 foo = (bfd_byte *) bfd_alloc
361 (globals->bfd_of_glue_owner, globals->arm_glue_size);
363 s->_raw_size = s->_cooked_size = globals->arm_glue_size;
367 if (globals->thumb_glue_size != 0)
369 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
371 s = bfd_get_section_by_name
372 (globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
374 BFD_ASSERT (s != NULL);
376 foo = (bfd_byte *) bfd_alloc
377 (globals->bfd_of_glue_owner, globals->thumb_glue_size);
379 s->_raw_size = s->_cooked_size = globals->thumb_glue_size;
387 record_arm_to_thumb_glue (link_info, h)
388 struct bfd_link_info * link_info;
389 struct elf_link_hash_entry * h;
391 const char * name = h->root.root.string;
392 register asection * s;
394 struct elf_link_hash_entry * myh;
395 struct elf32_arm_link_hash_table * globals;
397 globals = elf32_arm_hash_table (link_info);
399 BFD_ASSERT (globals != NULL);
400 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
402 s = bfd_get_section_by_name
403 (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
406 BFD_ASSERT (s != NULL);
409 bfd_malloc (strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1));
411 BFD_ASSERT (tmp_name);
413 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
415 myh = elf_link_hash_lookup
416 (&(globals)->root, tmp_name, false, false, true);
421 return; /* we've already seen this guy */
424 /* The only trick here is using hash_table->arm_glue_size as the value. Even
425 though the section isn't allocated yet, this is where we will be putting
428 _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner, tmp_name,
430 s, globals->arm_glue_size + 1,
432 (struct bfd_link_hash_entry **) &myh);
436 globals->arm_glue_size += ARM2THUMB_GLUE_SIZE;
442 record_thumb_to_arm_glue (link_info, h)
443 struct bfd_link_info *link_info;
444 struct elf_link_hash_entry *h;
446 const char *name = h->root.root.string;
447 register asection *s;
449 struct elf_link_hash_entry *myh;
450 struct elf32_arm_link_hash_table *hash_table;
453 hash_table = elf32_arm_hash_table (link_info);
455 BFD_ASSERT (hash_table != NULL);
456 BFD_ASSERT (hash_table->bfd_of_glue_owner != NULL);
458 s = bfd_get_section_by_name
459 (hash_table->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
461 BFD_ASSERT (s != NULL);
463 tmp_name = (char *) bfd_malloc (strlen (name) + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
465 BFD_ASSERT (tmp_name);
467 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
469 myh = elf_link_hash_lookup
470 (&(hash_table)->root, tmp_name, false, false, true);
475 return; /* we've already seen this guy */
478 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner, tmp_name,
479 BSF_GLOBAL, s, hash_table->thumb_glue_size + 1,
481 (struct bfd_link_hash_entry **) &myh);
483 /* If we mark it 'thumb', the disassembler will do a better job. */
484 bind = ELF_ST_BIND (myh->type);
485 myh->type = ELF_ST_INFO (bind, STT_ARM_TFUNC);
489 /* Allocate another symbol to mark where we switch to arm mode. */
491 #define CHANGE_TO_ARM "__%s_change_to_arm"
492 #define BACK_FROM_ARM "__%s_back_from_arm"
494 tmp_name = (char *) bfd_malloc (strlen (name) + strlen (CHANGE_TO_ARM) + 1);
496 BFD_ASSERT (tmp_name);
498 sprintf (tmp_name, CHANGE_TO_ARM, name);
502 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner, tmp_name,
503 BSF_LOCAL, s, hash_table->thumb_glue_size + 4,
505 (struct bfd_link_hash_entry **) &myh);
509 hash_table->thumb_glue_size += THUMB2ARM_GLUE_SIZE;
514 /* Select a BFD to be used to hold the sections used by the glue code.
515 This function is called from the linker scripts in ld/emultempl/
518 bfd_elf32_arm_get_bfd_for_interworking (abfd, info)
520 struct bfd_link_info *info;
522 struct elf32_arm_link_hash_table *globals;
526 /* If we are only performing a partial link do not bother
527 getting a bfd to hold the glue. */
528 if (info->relocateable)
531 globals = elf32_arm_hash_table (info);
533 BFD_ASSERT (globals != NULL);
535 if (globals->bfd_of_glue_owner != NULL)
538 sec = bfd_get_section_by_name (abfd, ARM2THUMB_GLUE_SECTION_NAME);
542 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
544 sec = bfd_make_section (abfd, ARM2THUMB_GLUE_SECTION_NAME);
547 || !bfd_set_section_flags (abfd, sec, flags)
548 || !bfd_set_section_alignment (abfd, sec, 2))
552 sec = bfd_get_section_by_name (abfd, THUMB2ARM_GLUE_SECTION_NAME);
556 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
558 sec = bfd_make_section (abfd, THUMB2ARM_GLUE_SECTION_NAME);
561 || !bfd_set_section_flags (abfd, sec, flags)
562 || !bfd_set_section_alignment (abfd, sec, 2))
566 /* Save the bfd for later use. */
567 globals->bfd_of_glue_owner = abfd;
573 bfd_elf32_arm_process_before_allocation (abfd, link_info, no_pipeline_knowledge)
575 struct bfd_link_info *link_info;
576 int no_pipeline_knowledge;
578 Elf_Internal_Shdr *symtab_hdr;
579 Elf_Internal_Rela *free_relocs = NULL;
580 Elf_Internal_Rela *irel, *irelend;
581 bfd_byte *contents = NULL;
582 bfd_byte *free_contents = NULL;
583 Elf32_External_Sym *extsyms = NULL;
584 Elf32_External_Sym *free_extsyms = NULL;
587 struct elf32_arm_link_hash_table *globals;
589 /* If we are only performing a partial link do not bother
590 to construct any glue. */
591 if (link_info->relocateable)
594 /* Here we have a bfd that is to be included on the link. We have a hook
595 to do reloc rummaging, before section sizes are nailed down. */
597 globals = elf32_arm_hash_table (link_info);
599 BFD_ASSERT (globals != NULL);
600 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
602 globals->no_pipeline_knowledge = no_pipeline_knowledge;
604 /* Rummage around all the relocs and map the glue vectors. */
605 sec = abfd->sections;
610 for (; sec != NULL; sec = sec->next)
612 if (sec->reloc_count == 0)
615 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
616 /* Load the relocs. */
618 irel = (_bfd_elf32_link_read_relocs (abfd, sec, (PTR) NULL,
619 (Elf_Internal_Rela *) NULL, false));
621 BFD_ASSERT (irel != 0);
623 irelend = irel + sec->reloc_count;
624 for (; irel < irelend; irel++)
627 unsigned long r_index;
630 struct elf_link_hash_entry *h;
632 r_type = ELF32_R_TYPE (irel->r_info);
633 r_index = ELF32_R_SYM (irel->r_info);
635 /* These are the only relocation types we care about */
636 if ( r_type != R_ARM_PC24
637 && r_type != R_ARM_THM_PC22)
640 /* Get the section contents if we haven't done so already. */
641 if (contents == NULL)
643 /* Get cached copy if it exists. */
644 if (elf_section_data (sec)->this_hdr.contents != NULL)
645 contents = elf_section_data (sec)->this_hdr.contents;
648 /* Go get them off disk. */
649 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
650 if (contents == NULL)
652 free_contents = contents;
654 if (!bfd_get_section_contents (abfd, sec, contents,
655 (file_ptr) 0, sec->_raw_size))
660 /* Read this BFD's symbols if we haven't done so already. */
663 /* Get cached copy if it exists. */
664 if (symtab_hdr->contents != NULL)
665 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
668 /* Go get them off disk. */
669 extsyms = ((Elf32_External_Sym *)
670 bfd_malloc (symtab_hdr->sh_size));
673 free_extsyms = extsyms;
674 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
675 || (bfd_read (extsyms, 1, symtab_hdr->sh_size, abfd)
676 != symtab_hdr->sh_size))
681 /* If the relocation is not against a symbol it cannot concern us. */
685 /* We don't care about local symbols */
686 if (r_index < symtab_hdr->sh_info)
689 /* This is an external symbol */
690 r_index -= symtab_hdr->sh_info;
691 h = (struct elf_link_hash_entry *)
692 elf_sym_hashes (abfd)[r_index];
694 /* If the relocation is against a static symbol it must be within
695 the current section and so cannot be a cross ARM/Thumb relocation. */
702 /* This one is a call from arm code. We need to look up
703 the target of the call. If it is a thumb target, we
706 if (ELF_ST_TYPE(h->type) == STT_ARM_TFUNC)
707 record_arm_to_thumb_glue (link_info, h);
711 /* This one is a call from thumb code. We look
712 up the target of the call. If it is not a thumb
713 target, we insert glue. */
715 if (ELF_ST_TYPE (h->type) != STT_ARM_TFUNC)
716 record_thumb_to_arm_glue (link_info, h);
727 if (free_relocs != NULL)
729 if (free_contents != NULL)
730 free (free_contents);
731 if (free_extsyms != NULL)
737 /* The thumb form of a long branch is a bit finicky, because the offset
738 encoding is split over two fields, each in it's own instruction. They
739 can occur in any order. So given a thumb form of long branch, and an
740 offset, insert the offset into the thumb branch and return finished
743 It takes two thumb instructions to encode the target address. Each has
744 11 bits to invest. The upper 11 bits are stored in one (identifed by
745 H-0.. see below), the lower 11 bits are stored in the other (identified
748 Combine together and shifted left by 1 (it's a half word address) and
752 H-0, upper address-0 = 000
754 H-1, lower address-0 = 800
756 They can be ordered either way, but the arm tools I've seen always put
757 the lower one first. It probably doesn't matter. krk@cygnus.com
759 XXX: Actually the order does matter. The second instruction (H-1)
760 moves the computed address into the PC, so it must be the second one
761 in the sequence. The problem, however is that whilst little endian code
762 stores the instructions in HI then LOW order, big endian code does the
763 reverse. nickc@cygnus.com */
765 #define LOW_HI_ORDER 0xF800F000
766 #define HI_LOW_ORDER 0xF000F800
769 insert_thumb_branch (br_insn, rel_off)
773 unsigned int low_bits;
774 unsigned int high_bits;
777 BFD_ASSERT ((rel_off & 1) != 1);
779 rel_off >>= 1; /* half word aligned address */
780 low_bits = rel_off & 0x000007FF; /* the bottom 11 bits */
781 high_bits = (rel_off >> 11) & 0x000007FF; /* the top 11 bits */
783 if ((br_insn & LOW_HI_ORDER) == LOW_HI_ORDER)
784 br_insn = LOW_HI_ORDER | (low_bits << 16) | high_bits;
785 else if ((br_insn & HI_LOW_ORDER) == HI_LOW_ORDER)
786 br_insn = HI_LOW_ORDER | (high_bits << 16) | low_bits;
788 abort (); /* error - not a valid branch instruction form */
790 /* FIXME: abort is probably not the right call. krk@cygnus.com */
795 /* Thumb code calling an ARM function */
797 elf32_thumb_to_arm_stub (info, name, input_bfd, output_bfd, input_section,
798 hit_data, sym_sec, offset, addend, val)
799 struct bfd_link_info *info;
803 asection *input_section;
812 unsigned long int tmp;
814 struct elf_link_hash_entry *myh;
815 struct elf32_arm_link_hash_table *globals;
817 myh = find_thumb_glue (info, name, input_bfd);
821 globals = elf32_arm_hash_table (info);
823 BFD_ASSERT (globals != NULL);
824 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
826 my_offset = myh->root.u.def.value;
828 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
829 THUMB2ARM_GLUE_SECTION_NAME);
831 BFD_ASSERT (s != NULL);
832 BFD_ASSERT (s->contents != NULL);
833 BFD_ASSERT (s->output_section != NULL);
835 if ((my_offset & 0x01) == 0x01)
838 && sym_sec->owner != NULL
839 && !INTERWORK_FLAG (sym_sec->owner))
842 (_ ("%s(%s): warning: interworking not enabled."),
843 bfd_get_filename (sym_sec->owner), name);
845 (_ (" first occurrence: %s: thumb call to arm"),
846 bfd_get_filename (input_bfd));
852 myh->root.u.def.value = my_offset;
854 bfd_put_16 (output_bfd, t2a1_bx_pc_insn,
855 s->contents + my_offset);
857 bfd_put_16 (output_bfd, t2a2_noop_insn,
858 s->contents + my_offset + 2);
861 ((bfd_signed_vma) val) /* Address of destination of the stub */
863 (s->output_offset /* Offset from the start of the current section to the start of the stubs. */
864 + my_offset /* Offset of the start of this stub from the start of the stubs. */
865 + s->output_section->vma) /* Address of the start of the current section. */
866 + 4 /* The branch instruction is 4 bytes into the stub. */
867 + 8); /* ARM branches work from the pc of the instruction + 8. */
869 bfd_put_32 (output_bfd,
870 t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
871 s->contents + my_offset + 4);
874 BFD_ASSERT (my_offset <= globals->thumb_glue_size);
876 /* Now go back and fix up the original BL insn to point
881 - (input_section->output_offset
885 tmp = bfd_get_32 (input_bfd, hit_data
886 - input_section->vma);
888 bfd_put_32 (output_bfd,
889 insert_thumb_branch (tmp, ret_offset),
890 hit_data - input_section->vma);
895 /* Arm code calling a Thumb function */
897 elf32_arm_to_thumb_stub (info, name, input_bfd, output_bfd, input_section,
898 hit_data, sym_sec, offset, addend, val)
900 struct bfd_link_info *info;
904 asection *input_section;
911 unsigned long int tmp;
915 struct elf_link_hash_entry *myh;
916 struct elf32_arm_link_hash_table *globals;
918 myh = find_arm_glue (info, name, input_bfd);
922 globals = elf32_arm_hash_table (info);
924 BFD_ASSERT (globals != NULL);
925 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
927 my_offset = myh->root.u.def.value;
928 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
929 ARM2THUMB_GLUE_SECTION_NAME);
930 BFD_ASSERT (s != NULL);
931 BFD_ASSERT (s->contents != NULL);
932 BFD_ASSERT (s->output_section != NULL);
934 if ((my_offset & 0x01) == 0x01)
937 && sym_sec->owner != NULL
938 && !INTERWORK_FLAG (sym_sec->owner))
941 (_ ("%s(%s): warning: interworking not enabled."),
942 bfd_get_filename (sym_sec->owner), name);
944 (_ (" first occurrence: %s: arm call to thumb"),
945 bfd_get_filename (input_bfd));
948 myh->root.u.def.value = my_offset;
950 bfd_put_32 (output_bfd, a2t1_ldr_insn,
951 s->contents + my_offset);
953 bfd_put_32 (output_bfd, a2t2_bx_r12_insn,
954 s->contents + my_offset + 4);
956 /* It's a thumb address. Add the low order bit. */
957 bfd_put_32 (output_bfd, val | a2t3_func_addr_insn,
958 s->contents + my_offset + 8);
961 BFD_ASSERT (my_offset <= globals->arm_glue_size);
963 tmp = bfd_get_32 (input_bfd, hit_data);
964 tmp = tmp & 0xFF000000;
966 /* Somehow these are both 4 too far, so subtract 8. */
967 ret_offset = s->output_offset
969 + s->output_section->vma
970 - (input_section->output_offset
971 + input_section->output_section->vma
975 tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
977 bfd_put_32 (output_bfd, tmp, hit_data
978 - input_section->vma);
984 /* Perform a relocation as part of a final link. */
985 static bfd_reloc_status_type
986 elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
987 input_section, contents, rel, value,
988 info, sym_sec, sym_name, sym_flags, h)
989 reloc_howto_type * howto;
992 asection * input_section;
994 Elf_Internal_Rela * rel;
996 struct bfd_link_info * info;
998 const char * sym_name;
999 unsigned char sym_flags;
1000 struct elf_link_hash_entry * h;
1002 unsigned long r_type = howto->type;
1003 unsigned long r_symndx;
1004 bfd_byte * hit_data = contents + rel->r_offset;
1005 bfd * dynobj = NULL;
1006 Elf_Internal_Shdr * symtab_hdr;
1007 struct elf_link_hash_entry ** sym_hashes;
1008 bfd_vma * local_got_offsets;
1009 asection * sgot = NULL;
1010 asection * splt = NULL;
1011 asection * sreloc = NULL;
1013 bfd_signed_vma signed_addend;
1014 struct elf32_arm_link_hash_table * globals;
1016 globals = elf32_arm_hash_table (info);
1018 dynobj = elf_hash_table (info)->dynobj;
1021 sgot = bfd_get_section_by_name (dynobj, ".got");
1022 splt = bfd_get_section_by_name (dynobj, ".plt");
1024 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1025 sym_hashes = elf_sym_hashes (input_bfd);
1026 local_got_offsets = elf_local_got_offsets (input_bfd);
1027 r_symndx = ELF32_R_SYM (rel->r_info);
1030 addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask;
1032 if (addend & ((howto->src_mask + 1) >> 1))
1035 signed_addend &= ~ howto->src_mask;
1036 signed_addend |= addend;
1039 signed_addend = addend;
1041 addend = signed_addend = rel->r_addend;
1047 return bfd_reloc_ok;
1052 /* When generating a shared object, these relocations are copied
1053 into the output file to be resolved at run time. */
1056 && (r_type != R_ARM_PC24
1059 && (! info->symbolic
1060 || (h->elf_link_hash_flags
1061 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1063 Elf_Internal_Rel outrel;
1064 boolean skip, relocate;
1070 name = (bfd_elf_string_from_elf_section
1072 elf_elfheader (input_bfd)->e_shstrndx,
1073 elf_section_data (input_section)->rel_hdr.sh_name));
1075 return bfd_reloc_notsupported;
1077 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
1078 && strcmp (bfd_get_section_name (input_bfd,
1082 sreloc = bfd_get_section_by_name (dynobj, name);
1083 BFD_ASSERT (sreloc != NULL);
1088 if (elf_section_data (input_section)->stab_info == NULL)
1089 outrel.r_offset = rel->r_offset;
1094 off = (_bfd_stab_section_offset
1095 (output_bfd, &elf_hash_table (info)->stab_info,
1097 & elf_section_data (input_section)->stab_info,
1099 if (off == (bfd_vma) -1)
1101 outrel.r_offset = off;
1104 outrel.r_offset += (input_section->output_section->vma
1105 + input_section->output_offset);
1109 memset (&outrel, 0, sizeof outrel);
1112 else if (r_type == R_ARM_PC24)
1114 BFD_ASSERT (h != NULL && h->dynindx != -1);
1115 if ((input_section->flags & SEC_ALLOC) != 0)
1119 outrel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_PC24);
1124 || ((info->symbolic || h->dynindx == -1)
1125 && (h->elf_link_hash_flags
1126 & ELF_LINK_HASH_DEF_REGULAR) != 0))
1129 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
1133 BFD_ASSERT (h->dynindx != -1);
1134 if ((input_section->flags & SEC_ALLOC) != 0)
1138 outrel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_ABS32);
1142 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1143 (((Elf32_External_Rel *)
1145 + sreloc->reloc_count));
1146 ++sreloc->reloc_count;
1148 /* If this reloc is against an external symbol, we do not want to
1149 fiddle with the addend. Otherwise, we need to include the symbol
1150 value so that it becomes an addend for the dynamic reloc. */
1152 return bfd_reloc_ok;
1155 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1156 contents, rel->r_offset, value,
1159 else switch (r_type)
1162 /* Arm B/BL instruction */
1164 /* Check for arm calling thumb function. */
1165 if (sym_flags == STT_ARM_TFUNC)
1167 elf32_arm_to_thumb_stub (info, sym_name, input_bfd, output_bfd,
1168 input_section, hit_data, sym_sec, rel->r_offset, addend, value);
1169 return bfd_reloc_ok;
1172 if ( strcmp (bfd_get_target (input_bfd), "elf32-littlearm-oabi") == 0
1173 || strcmp (bfd_get_target (input_bfd), "elf32-bigarm-oabi") == 0)
1175 /* The old way of doing things. Trearing the addend as a
1176 byte sized field and adding in the pipeline offset. */
1178 value -= (input_section->output_section->vma
1179 + input_section->output_offset);
1180 value -= rel->r_offset;
1183 if (! globals->no_pipeline_knowledge)
1188 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
1190 S is the address of the symbol in the relocation.
1191 P is address of the instruction being relocated.
1192 A is the addend (extracted from the instruction) in bytes.
1194 S is held in 'value'.
1195 P is the base address of the section containing the instruction
1196 plus the offset of the reloc into that section, ie:
1197 (input_section->output_section->vma +
1198 input_section->output_offset +
1200 A is the addend, converted into bytes, ie:
1203 Note: None of these operations have knowledge of the pipeline
1204 size of the processor, thus it is up to the assembler to encode
1205 this information into the addend. */
1207 value -= (input_section->output_section->vma
1208 + input_section->output_offset);
1209 value -= rel->r_offset;
1210 value += (signed_addend << howto->size);
1212 /* Previous versions of this code also used to add in the pipeline
1213 offset here. This is wrong because the linker is not supposed
1214 to know about such things, and one day it might change. In order
1215 to support old binaries that need the old behaviour however, so
1216 we attempt to detect which ABI was used to create the reloc. */
1217 if (! globals->no_pipeline_knowledge)
1219 Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form */
1221 i_ehdrp = elf_elfheader (input_bfd);
1223 if (i_ehdrp->e_ident[EI_OSABI] == 0)
1228 value >>= howto->rightshift;
1229 value &= howto->dst_mask;
1230 value |= (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
1235 if (sym_flags == STT_ARM_TFUNC)
1240 value -= (input_section->output_section->vma
1241 + input_section->output_offset);
1246 bfd_put_32 (input_bfd, value, hit_data);
1247 return bfd_reloc_ok;
1251 if ((long) value > 0x7f || (long) value < -0x80)
1252 return bfd_reloc_overflow;
1254 bfd_put_8 (input_bfd, value, hit_data);
1255 return bfd_reloc_ok;
1260 if ((long) value > 0x7fff || (long) value < -0x8000)
1261 return bfd_reloc_overflow;
1263 bfd_put_16 (input_bfd, value, hit_data);
1264 return bfd_reloc_ok;
1267 /* Support ldr and str instruction for the arm */
1268 /* Also thumb b (unconditional branch). ??? Really? */
1271 if ((long) value > 0x7ff || (long) value < -0x800)
1272 return bfd_reloc_overflow;
1274 value |= (bfd_get_32 (input_bfd, hit_data) & 0xfffff000);
1275 bfd_put_32 (input_bfd, value, hit_data);
1276 return bfd_reloc_ok;
1278 case R_ARM_THM_ABS5:
1279 /* Support ldr and str instructions for the thumb. */
1281 /* Need to refetch addend. */
1282 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
1283 /* ??? Need to determine shift amount from operand size. */
1284 addend >>= howto->rightshift;
1288 /* ??? Isn't value unsigned? */
1289 if ((long) value > 0x1f || (long) value < -0x10)
1290 return bfd_reloc_overflow;
1292 /* ??? Value needs to be properly shifted into place first. */
1293 value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
1294 bfd_put_16 (input_bfd, value, hit_data);
1295 return bfd_reloc_ok;
1297 case R_ARM_THM_PC22:
1298 /* Thumb BL (branch long instruction). */
1301 boolean overflow = false;
1302 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
1303 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
1304 bfd_vma src_mask = 0x007FFFFE;
1305 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
1306 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
1308 bfd_signed_vma signed_check;
1311 /* Need to refetch the addend and squish the two 11 bit pieces
1314 bfd_vma upper = upper_insn & 0x7ff;
1315 bfd_vma lower = lower_insn & 0x7ff;
1316 upper = (upper ^ 0x400) - 0x400; /* sign extend */
1317 addend = (upper << 12) | (lower << 1);
1318 signed_addend = addend;
1322 /* If it's not a call to thumb, assume call to arm */
1323 if (sym_flags != STT_ARM_TFUNC)
1325 if (elf32_thumb_to_arm_stub
1326 (info, sym_name, input_bfd, output_bfd, input_section,
1327 hit_data, sym_sec, rel->r_offset, addend, value))
1328 return bfd_reloc_ok;
1330 return bfd_reloc_dangerous;
1333 relocation = value + signed_addend;
1335 relocation -= (input_section->output_section->vma
1336 + input_section->output_offset
1339 if (! globals->no_pipeline_knowledge)
1341 Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form */
1343 i_ehdrp = elf_elfheader (input_bfd);
1345 /* Previous versions of this code also used to add in the pipline
1346 offset here. This is wrong because the linker is not supposed
1347 to know about such things, and one day it might change. In order
1348 to support old binaries that need the old behaviour however, so
1349 we attempt to detect which ABI was used to create the reloc. */
1350 if ( strcmp (bfd_get_target (input_bfd), "elf32-littlearm-oabi") == 0
1351 || strcmp (bfd_get_target (input_bfd), "elf32-bigarm-oabi") == 0
1352 || i_ehdrp->e_ident[EI_OSABI] == 0)
1356 check = relocation >> howto->rightshift;
1358 /* If this is a signed value, the rightshift just dropped
1359 leading 1 bits (assuming twos complement). */
1360 if ((bfd_signed_vma) relocation >= 0)
1361 signed_check = check;
1363 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
1365 /* Assumes two's complement. */
1366 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
1369 /* Put RELOCATION back into the insn. */
1370 upper_insn = (upper_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 12) & 0x7ff);
1371 lower_insn = (lower_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 1) & 0x7ff);
1373 /* Put the relocated value back in the object file: */
1374 bfd_put_16 (input_bfd, upper_insn, hit_data);
1375 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
1377 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
1381 case R_ARM_GNU_VTINHERIT:
1382 case R_ARM_GNU_VTENTRY:
1383 return bfd_reloc_ok;
1386 return bfd_reloc_notsupported;
1388 case R_ARM_GLOB_DAT:
1389 return bfd_reloc_notsupported;
1391 case R_ARM_JUMP_SLOT:
1392 return bfd_reloc_notsupported;
1394 case R_ARM_RELATIVE:
1395 return bfd_reloc_notsupported;
1398 /* Relocation is relative to the start of the
1399 global offset table. */
1401 BFD_ASSERT (sgot != NULL);
1403 return bfd_reloc_notsupported;
1405 /* Note that sgot->output_offset is not involved in this
1406 calculation. We always want the start of .got. If we
1407 define _GLOBAL_OFFSET_TABLE in a different way, as is
1408 permitted by the ABI, we might have to change this
1411 value -= sgot->output_section->vma;
1412 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1413 contents, rel->r_offset, value,
1417 /* Use global offset table as symbol value. */
1419 BFD_ASSERT (sgot != NULL);
1422 return bfd_reloc_notsupported;
1424 value = sgot->output_section->vma;
1425 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1426 contents, rel->r_offset, value,
1430 /* Relocation is to the entry for this symbol in the
1431 global offset table. */
1433 return bfd_reloc_notsupported;
1439 off = h->got.offset;
1440 BFD_ASSERT (off != (bfd_vma) -1);
1442 if (!elf_hash_table (info)->dynamic_sections_created ||
1443 (info->shared && (info->symbolic || h->dynindx == -1)
1444 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1446 /* This is actually a static link, or it is a -Bsymbolic link
1447 and the symbol is defined locally. We must initialize this
1448 entry in the global offset table. Since the offset must
1449 always be a multiple of 4, we use the least significant bit
1450 to record whether we have initialized it already.
1452 When doing a dynamic link, we create a .rel.got relocation
1453 entry to initialize the value. This is done in the
1454 finish_dynamic_symbol routine. */
1460 bfd_put_32 (output_bfd, value, sgot->contents + off);
1465 value = sgot->output_offset + off;
1471 BFD_ASSERT (local_got_offsets != NULL &&
1472 local_got_offsets[r_symndx] != (bfd_vma) -1);
1474 off = local_got_offsets[r_symndx];
1476 /* The offset must always be a multiple of 4. We use the
1477 least significant bit to record whether we have already
1478 generated the necessary reloc. */
1483 bfd_put_32 (output_bfd, value, sgot->contents + off);
1488 Elf_Internal_Rel outrel;
1490 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
1491 BFD_ASSERT (srelgot != NULL);
1493 outrel.r_offset = (sgot->output_section->vma
1494 + sgot->output_offset
1496 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
1497 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1498 (((Elf32_External_Rel *)
1500 + srelgot->reloc_count));
1501 ++srelgot->reloc_count;
1504 local_got_offsets[r_symndx] |= 1;
1507 value = sgot->output_offset + off;
1510 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1511 contents, rel->r_offset, value,
1515 /* Relocation is to the entry for this symbol in the
1516 procedure linkage table. */
1518 /* Resolve a PLT32 reloc against a local symbol directly,
1519 without using the procedure linkage table. */
1521 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1522 contents, rel->r_offset, value,
1525 if (h->plt.offset == (bfd_vma) -1)
1526 /* We didn't make a PLT entry for this symbol. This
1527 happens when statically linking PIC code, or when
1528 using -Bsymbolic. */
1529 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1530 contents, rel->r_offset, value,
1533 BFD_ASSERT(splt != NULL);
1535 return bfd_reloc_notsupported;
1537 value = (splt->output_section->vma
1538 + splt->output_offset
1540 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1541 contents, rel->r_offset, value,
1545 return bfd_reloc_notsupported;
1547 case R_ARM_AMP_VCALL9:
1548 return bfd_reloc_notsupported;
1550 case R_ARM_RSBREL32:
1551 return bfd_reloc_notsupported;
1553 case R_ARM_THM_RPC22:
1554 return bfd_reloc_notsupported;
1557 return bfd_reloc_notsupported;
1560 return bfd_reloc_notsupported;
1563 return bfd_reloc_notsupported;
1566 return bfd_reloc_notsupported;
1569 return bfd_reloc_notsupported;
1574 /* Relocate an ARM ELF section. */
1576 elf32_arm_relocate_section (output_bfd, info, input_bfd, input_section,
1577 contents, relocs, local_syms, local_sections)
1579 struct bfd_link_info * info;
1581 asection * input_section;
1582 bfd_byte * contents;
1583 Elf_Internal_Rela * relocs;
1584 Elf_Internal_Sym * local_syms;
1585 asection ** local_sections;
1587 Elf_Internal_Shdr * symtab_hdr;
1588 struct elf_link_hash_entry ** sym_hashes;
1589 Elf_Internal_Rela * rel;
1590 Elf_Internal_Rela * relend;
1593 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1594 sym_hashes = elf_sym_hashes (input_bfd);
1597 relend = relocs + input_section->reloc_count;
1598 for (; rel < relend; rel++)
1601 reloc_howto_type * howto;
1602 unsigned long r_symndx;
1603 Elf_Internal_Sym * sym;
1605 struct elf_link_hash_entry * h;
1607 bfd_reloc_status_type r;
1610 r_symndx = ELF32_R_SYM (rel->r_info);
1611 r_type = ELF32_R_TYPE (rel->r_info);
1613 if ( r_type == R_ARM_GNU_VTENTRY
1614 || r_type == R_ARM_GNU_VTINHERIT)
1617 elf32_arm_info_to_howto (input_bfd, & bfd_reloc, rel);
1618 howto = bfd_reloc.howto;
1620 if (info->relocateable)
1622 /* This is a relocateable link. We don't have to change
1623 anything, unless the reloc is against a section symbol,
1624 in which case we have to adjust according to where the
1625 section symbol winds up in the output section. */
1626 if (r_symndx < symtab_hdr->sh_info)
1628 sym = local_syms + r_symndx;
1629 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1631 sec = local_sections[r_symndx];
1637 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
1638 val = insn + ((sec->output_offset + sym->st_value)
1639 >> howto->rightshift);
1640 val &= howto->dst_mask;
1641 val |= insn & ~(howto->dst_mask);
1643 bfd_put_32 (input_bfd, val, contents + rel->r_offset);
1646 rel->r_addend += (sec->output_offset + sym->st_value)
1647 >> howto->rightshift;
1655 /* This is a final link. */
1659 if (r_symndx < symtab_hdr->sh_info)
1661 sym = local_syms + r_symndx;
1662 sec = local_sections[r_symndx];
1663 relocation = (sec->output_section->vma
1664 + sec->output_offset
1669 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1670 while (h->root.type == bfd_link_hash_indirect
1671 || h->root.type == bfd_link_hash_warning)
1672 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1673 if (h->root.type == bfd_link_hash_defined
1674 || h->root.type == bfd_link_hash_defweak)
1676 int relocation_needed = 1;
1678 sec = h->root.u.def.section;
1680 /* In these cases, we don't need the relocation value.
1681 We check specially because in some obscure cases
1682 sec->output_section will be NULL. */
1689 (!info->symbolic && h->dynindx != -1)
1690 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
1692 && ((input_section->flags & SEC_ALLOC) != 0)
1694 relocation_needed = 0;
1698 relocation_needed = 0;
1702 if (elf_hash_table(info)->dynamic_sections_created
1704 || (!info->symbolic && h->dynindx != -1)
1705 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
1708 relocation_needed = 0;
1712 if (h->plt.offset != (bfd_vma)-1)
1713 relocation_needed = 0;
1717 if (sec->output_section == NULL)
1719 (*_bfd_error_handler)
1720 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1721 bfd_get_filename (input_bfd), h->root.root.string,
1722 bfd_get_section_name (input_bfd, input_section));
1723 relocation_needed = 0;
1727 if (relocation_needed)
1728 relocation = h->root.u.def.value
1729 + sec->output_section->vma
1730 + sec->output_offset;
1734 else if (h->root.type == bfd_link_hash_undefweak)
1736 else if (info->shared && !info->symbolic && !info->no_undefined)
1740 if (!((*info->callbacks->undefined_symbol)
1741 (info, h->root.root.string, input_bfd,
1742 input_section, rel->r_offset)))
1749 name = h->root.root.string;
1752 name = (bfd_elf_string_from_elf_section
1753 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1754 if (name == NULL || *name == '\0')
1755 name = bfd_section_name (input_bfd, sec);
1758 r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
1759 input_section, contents, rel,
1760 relocation, info, sec, name,
1761 (h ? ELF_ST_TYPE (h->type) :
1762 ELF_ST_TYPE (sym->st_info)), h);
1764 if (r != bfd_reloc_ok)
1766 const char * msg = (const char *) 0;
1770 case bfd_reloc_overflow:
1771 if (!((*info->callbacks->reloc_overflow)
1772 (info, name, howto->name, (bfd_vma) 0,
1773 input_bfd, input_section, rel->r_offset)))
1777 case bfd_reloc_undefined:
1778 if (!((*info->callbacks->undefined_symbol)
1779 (info, name, input_bfd, input_section,
1784 case bfd_reloc_outofrange:
1785 msg = _ ("internal error: out of range error");
1788 case bfd_reloc_notsupported:
1789 msg = _ ("internal error: unsupported relocation error");
1792 case bfd_reloc_dangerous:
1793 msg = _ ("internal error: dangerous error");
1797 msg = _ ("internal error: unknown error");
1801 if (!((*info->callbacks->warning)
1802 (info, msg, name, input_bfd, input_section,
1813 /* Function to keep ARM specific flags in the ELF header. */
1815 elf32_arm_set_private_flags (abfd, flags)
1819 if (elf_flags_init (abfd)
1820 && elf_elfheader (abfd)->e_flags != flags)
1822 if (flags & EF_INTERWORK)
1823 _bfd_error_handler (_ ("\
1824 Warning: Not setting interwork flag of %s since it has already been specified as non-interworking"),
1825 bfd_get_filename (abfd));
1827 _bfd_error_handler (_ ("\
1828 Warning: Clearing the interwork flag of %s due to outside request"),
1829 bfd_get_filename (abfd));
1833 elf_elfheader (abfd)->e_flags = flags;
1834 elf_flags_init (abfd) = true;
1840 /* Copy backend specific data from one object module to another */
1842 elf32_arm_copy_private_bfd_data (ibfd, obfd)
1849 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1850 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1853 in_flags = elf_elfheader (ibfd)->e_flags;
1854 out_flags = elf_elfheader (obfd)->e_flags;
1856 if (elf_flags_init (obfd) && in_flags != out_flags)
1858 /* Cannot mix PIC and non-PIC code. */
1859 if ((in_flags & EF_PIC) != (out_flags & EF_PIC))
1862 /* Cannot mix APCS26 and APCS32 code. */
1863 if ((in_flags & EF_APCS_26) != (out_flags & EF_APCS_26))
1866 /* Cannot mix float APCS and non-float APCS code. */
1867 if ((in_flags & EF_APCS_FLOAT) != (out_flags & EF_APCS_FLOAT))
1870 /* If the src and dest have different interworking flags
1871 then turn off the interworking bit. */
1872 if ((in_flags & EF_INTERWORK) != (out_flags & EF_INTERWORK))
1874 if (out_flags & EF_INTERWORK)
1875 _bfd_error_handler (_ ("\
1876 Warning: Clearing the interwork flag in %s because non-interworking code in %s has been linked with it"),
1877 bfd_get_filename (obfd), bfd_get_filename (ibfd));
1879 in_flags &= ~EF_INTERWORK;
1883 elf_elfheader (obfd)->e_flags = in_flags;
1884 elf_flags_init (obfd) = true;
1889 /* Merge backend specific data from an object file to the output
1890 object file when linking. */
1892 elf32_arm_merge_private_bfd_data (ibfd, obfd)
1899 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1900 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1903 /* Check if we have the same endianess */
1904 if ( ibfd->xvec->byteorder != obfd->xvec->byteorder
1905 && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
1906 && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
1908 (*_bfd_error_handler)
1909 (_("%s: compiled for a %s endian system and target is %s endian"),
1910 bfd_get_filename (ibfd),
1911 bfd_big_endian (ibfd) ? "big" : "little",
1912 bfd_big_endian (obfd) ? "big" : "little");
1914 bfd_set_error (bfd_error_wrong_format);
1918 /* The input BFD must have had its flags initialised. */
1919 /* The following seems bogus to me -- The flags are initialized in
1920 the assembler but I don't think an elf_flags_init field is
1921 written into the object */
1922 /* BFD_ASSERT (elf_flags_init (ibfd)); */
1924 in_flags = elf_elfheader (ibfd)->e_flags;
1925 out_flags = elf_elfheader (obfd)->e_flags;
1927 if (!elf_flags_init (obfd))
1929 /* If the input is the default architecture then do not
1930 bother setting the flags for the output architecture,
1931 instead allow future merges to do this. If no future
1932 merges ever set these flags then they will retain their
1933 unitialised values, which surprise surprise, correspond
1934 to the default values. */
1935 if (bfd_get_arch_info (ibfd)->the_default)
1938 elf_flags_init (obfd) = true;
1939 elf_elfheader (obfd)->e_flags = in_flags;
1941 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
1942 && bfd_get_arch_info (obfd)->the_default)
1943 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
1948 /* Check flag compatibility. */
1949 if (in_flags == out_flags)
1952 /* Complain about various flag mismatches. */
1954 if ((in_flags & EF_APCS_26) != (out_flags & EF_APCS_26))
1955 _bfd_error_handler (_ ("\
1956 Error: %s compiled for APCS-%d, whereas %s is compiled for APCS-%d"),
1957 bfd_get_filename (ibfd),
1958 in_flags & EF_APCS_26 ? 26 : 32,
1959 bfd_get_filename (obfd),
1960 out_flags & EF_APCS_26 ? 26 : 32);
1962 if ((in_flags & EF_APCS_FLOAT) != (out_flags & EF_APCS_FLOAT))
1963 _bfd_error_handler (_ ("\
1964 Error: %s passes floats in %s registers, whereas %s passes them in %s registers"),
1965 bfd_get_filename (ibfd),
1966 in_flags & EF_APCS_FLOAT ? _ ("float") : _ ("integer"),
1967 bfd_get_filename (obfd),
1968 out_flags & EF_APCS_26 ? _ ("float") : _ ("integer"));
1970 if ((in_flags & EF_PIC) != (out_flags & EF_PIC))
1971 _bfd_error_handler (_ ("\
1972 Error: %s is compiled as position %s code, whereas %s is not"),
1973 bfd_get_filename (ibfd),
1974 in_flags & EF_PIC ? _ ("independent") : _ ("dependent"),
1975 bfd_get_filename (obfd));
1977 /* Interworking mismatch is only a warning. */
1978 if ((in_flags & EF_INTERWORK) != (out_flags & EF_INTERWORK))
1980 _bfd_error_handler (_ ("\
1981 Warning: %s %s interworking, whereas %s %s"),
1982 bfd_get_filename (ibfd),
1983 in_flags & EF_INTERWORK ? _ ("supports") : _ ("does not support"),
1984 bfd_get_filename (obfd),
1985 out_flags & EF_INTERWORK ? _ ("does not") : _ ("does"));
1992 /* Display the flags field */
1994 elf32_arm_print_private_bfd_data (abfd, ptr)
1998 FILE *file = (FILE *) ptr;
2000 BFD_ASSERT (abfd != NULL && ptr != NULL);
2002 /* Print normal ELF private data. */
2003 _bfd_elf_print_private_bfd_data (abfd, ptr);
2005 /* Ignore init flag - it may not be set, despite the flags field containing valid data. */
2007 /* xgettext:c-format */
2008 fprintf (file, _ ("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
2010 if (elf_elfheader (abfd)->e_flags & EF_INTERWORK)
2011 fprintf (file, _ (" [interworking enabled]"));
2013 fprintf (file, _ (" [interworking not enabled]"));
2015 if (elf_elfheader (abfd)->e_flags & EF_APCS_26)
2016 fprintf (file, _ (" [APCS-26]"));
2018 fprintf (file, _ (" [APCS-32]"));
2020 if (elf_elfheader (abfd)->e_flags & EF_APCS_FLOAT)
2021 fprintf (file, _ (" [floats passed in float registers]"));
2023 fprintf (file, _ (" [floats passed in integer registers]"));
2025 if (elf_elfheader (abfd)->e_flags & EF_PIC)
2026 fprintf (file, _ (" [position independent]"));
2028 fprintf (file, _ (" [absolute position]"));
2036 elf32_arm_get_symbol_type (elf_sym, type)
2037 Elf_Internal_Sym * elf_sym;
2040 if (ELF_ST_TYPE (elf_sym->st_info) == STT_ARM_TFUNC)
2041 return ELF_ST_TYPE (elf_sym->st_info);
2047 elf32_arm_gc_mark_hook (abfd, info, rel, h, sym)
2049 struct bfd_link_info *info;
2050 Elf_Internal_Rela *rel;
2051 struct elf_link_hash_entry *h;
2052 Elf_Internal_Sym *sym;
2056 switch (ELF32_R_TYPE (rel->r_info))
2058 case R_ARM_GNU_VTINHERIT:
2059 case R_ARM_GNU_VTENTRY:
2063 switch (h->root.type)
2065 case bfd_link_hash_defined:
2066 case bfd_link_hash_defweak:
2067 return h->root.u.def.section;
2069 case bfd_link_hash_common:
2070 return h->root.u.c.p->section;
2076 if (!(elf_bad_symtab (abfd)
2077 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
2078 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
2079 && sym->st_shndx != SHN_COMMON))
2081 return bfd_section_from_elf_index (abfd, sym->st_shndx);
2087 /* Update the got entry reference counts for the section being removed. */
2090 elf32_arm_gc_sweep_hook (abfd, info, sec, relocs)
2092 struct bfd_link_info *info;
2094 const Elf_Internal_Rela *relocs;
2096 /* We don't support garbage collection of GOT and PLT relocs yet. */
2100 /* Look through the relocs for a section during the first phase. */
2103 elf32_arm_check_relocs (abfd, info, sec, relocs)
2105 struct bfd_link_info * info;
2107 const Elf_Internal_Rela * relocs;
2109 Elf_Internal_Shdr * symtab_hdr;
2110 struct elf_link_hash_entry ** sym_hashes;
2111 struct elf_link_hash_entry ** sym_hashes_end;
2112 const Elf_Internal_Rela * rel;
2113 const Elf_Internal_Rela * rel_end;
2115 asection * sgot, *srelgot, *sreloc;
2116 bfd_vma * local_got_offsets;
2118 if (info->relocateable)
2121 sgot = srelgot = sreloc = NULL;
2123 dynobj = elf_hash_table (info)->dynobj;
2124 local_got_offsets = elf_local_got_offsets (abfd);
2126 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2127 sym_hashes = elf_sym_hashes (abfd);
2128 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);
2129 if (!elf_bad_symtab (abfd))
2130 sym_hashes_end -= symtab_hdr->sh_info;
2132 rel_end = relocs + sec->reloc_count;
2133 for (rel = relocs; rel < rel_end; rel++)
2135 struct elf_link_hash_entry *h;
2136 unsigned long r_symndx;
2138 r_symndx = ELF32_R_SYM (rel->r_info);
2139 if (r_symndx < symtab_hdr->sh_info)
2142 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2144 /* Some relocs require a global offset table. */
2147 switch (ELF32_R_TYPE (rel->r_info))
2152 elf_hash_table (info)->dynobj = dynobj = abfd;
2153 if (! _bfd_elf_create_got_section (dynobj, info))
2162 switch (ELF32_R_TYPE (rel->r_info))
2165 /* This symbol requires a global offset table entry. */
2168 sgot = bfd_get_section_by_name (dynobj, ".got");
2169 BFD_ASSERT (sgot != NULL);
2172 /* Get the got relocation section if necessary. */
2174 && (h != NULL || info->shared))
2176 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
2178 /* If no got relocation section, make one and initialize. */
2179 if (srelgot == NULL)
2181 srelgot = bfd_make_section (dynobj, ".rel.got");
2183 || ! bfd_set_section_flags (dynobj, srelgot,
2188 | SEC_LINKER_CREATED
2190 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
2197 if (h->got.offset != (bfd_vma) -1)
2198 /* We have already allocated space in the .got. */
2201 h->got.offset = sgot->_raw_size;
2203 /* Make sure this symbol is output as a dynamic symbol. */
2204 if (h->dynindx == -1)
2205 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2208 srelgot->_raw_size += sizeof (Elf32_External_Rel);
2212 /* This is a global offset table entry for a local
2214 if (local_got_offsets == NULL)
2217 register unsigned int i;
2219 size = symtab_hdr->sh_info * sizeof (bfd_vma);
2220 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
2221 if (local_got_offsets == NULL)
2223 elf_local_got_offsets (abfd) = local_got_offsets;
2224 for (i = 0; i < symtab_hdr->sh_info; i++)
2225 local_got_offsets[i] = (bfd_vma) -1;
2228 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
2229 /* We have already allocated space in the .got. */
2232 local_got_offsets[r_symndx] = sgot->_raw_size;
2235 /* If we are generating a shared object, we need to
2236 output a R_ARM_RELATIVE reloc so that the dynamic
2237 linker can adjust this GOT entry. */
2238 srelgot->_raw_size += sizeof (Elf32_External_Rel);
2241 sgot->_raw_size += 4;
2245 /* This symbol requires a procedure linkage table entry. We
2246 actually build the entry in adjust_dynamic_symbol,
2247 because this might be a case of linking PIC code which is
2248 never referenced by a dynamic object, in which case we
2249 don't need to generate a procedure linkage table entry
2252 /* If this is a local symbol, we resolve it directly without
2253 creating a procedure linkage table entry. */
2257 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2263 /* If we are creating a shared library, and this is a reloc
2264 against a global symbol, or a non PC relative reloc
2265 against a local symbol, then we need to copy the reloc
2266 into the shared library. However, if we are linking with
2267 -Bsymbolic, we do not need to copy a reloc against a
2268 global symbol which is defined in an object we are
2269 including in the link (i.e., DEF_REGULAR is set). At
2270 this point we have not seen all the input files, so it is
2271 possible that DEF_REGULAR is not set now but will be set
2272 later (it is never cleared). We account for that
2273 possibility below by storing information in the
2274 pcrel_relocs_copied field of the hash table entry. */
2276 && (ELF32_R_TYPE (rel->r_info) != R_ARM_PC24
2278 && (! info->symbolic
2279 || (h->elf_link_hash_flags
2280 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2282 /* When creating a shared object, we must copy these
2283 reloc types into the output file. We create a reloc
2284 section in dynobj and make room for this reloc. */
2289 name = (bfd_elf_string_from_elf_section
2291 elf_elfheader (abfd)->e_shstrndx,
2292 elf_section_data (sec)->rel_hdr.sh_name));
2296 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
2297 && strcmp (bfd_get_section_name (abfd, sec),
2300 sreloc = bfd_get_section_by_name (dynobj, name);
2305 sreloc = bfd_make_section (dynobj, name);
2306 flags = (SEC_HAS_CONTENTS | SEC_READONLY
2307 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2308 if ((sec->flags & SEC_ALLOC) != 0)
2309 flags |= SEC_ALLOC | SEC_LOAD;
2311 || ! bfd_set_section_flags (dynobj, sreloc, flags)
2312 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
2317 sreloc->_raw_size += sizeof (Elf32_External_Rel);
2318 /* If we are linking with -Bsymbolic, and this is a
2319 global symbol, we count the number of PC relative
2320 relocations we have entered for this symbol, so that
2321 we can discard them again if the symbol is later
2322 defined by a regular object. Note that this function
2323 is only called if we are using an elf_i386 linker
2324 hash table, which means that h is really a pointer to
2325 an elf_i386_link_hash_entry. */
2326 if (h != NULL && info->symbolic
2327 && ELF32_R_TYPE (rel->r_info) == R_ARM_PC24)
2329 struct elf32_arm_link_hash_entry * eh;
2330 struct elf32_arm_pcrel_relocs_copied * p;
2332 eh = (struct elf32_arm_link_hash_entry *) h;
2334 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
2335 if (p->section == sreloc)
2340 p = ((struct elf32_arm_pcrel_relocs_copied *)
2341 bfd_alloc (dynobj, sizeof * p));
2345 p->next = eh->pcrel_relocs_copied;
2346 eh->pcrel_relocs_copied = p;
2347 p->section = sreloc;
2356 /* This relocation describes the C++ object vtable hierarchy.
2357 Reconstruct it for later use during GC. */
2358 case R_ARM_GNU_VTINHERIT:
2359 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2363 /* This relocation describes which C++ vtable entries are actually
2364 used. Record for later use during GC. */
2365 case R_ARM_GNU_VTENTRY:
2366 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2376 /* Find the nearest line to a particular section and offset, for error
2377 reporting. This code is a duplicate of the code in elf.c, except
2378 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
2381 elf32_arm_find_nearest_line
2382 (abfd, section, symbols, offset, filename_ptr, functionname_ptr, line_ptr)
2387 CONST char ** filename_ptr;
2388 CONST char ** functionname_ptr;
2389 unsigned int * line_ptr;
2392 const char * filename;
2397 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
2398 filename_ptr, functionname_ptr,
2402 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
2403 &found, filename_ptr,
2404 functionname_ptr, line_ptr,
2405 &elf_tdata (abfd)->line_info))
2411 if (symbols == NULL)
2418 for (p = symbols; *p != NULL; p++)
2422 q = (elf_symbol_type *) *p;
2424 if (bfd_get_section (&q->symbol) != section)
2427 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
2432 filename = bfd_asymbol_name (&q->symbol);
2437 if (q->symbol.section == section
2438 && q->symbol.value >= low_func
2439 && q->symbol.value <= offset)
2441 func = (asymbol *) q;
2442 low_func = q->symbol.value;
2451 *filename_ptr = filename;
2452 *functionname_ptr = bfd_asymbol_name (func);
2458 /* Adjust a symbol defined by a dynamic object and referenced by a
2459 regular object. The current definition is in some section of the
2460 dynamic object, but we're not including those sections. We have to
2461 change the definition to something the rest of the link can
2465 elf32_arm_adjust_dynamic_symbol (info, h)
2466 struct bfd_link_info * info;
2467 struct elf_link_hash_entry * h;
2471 unsigned int power_of_two;
2473 dynobj = elf_hash_table (info)->dynobj;
2475 /* Make sure we know what is going on here. */
2476 BFD_ASSERT (dynobj != NULL
2477 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
2478 || h->weakdef != NULL
2479 || ((h->elf_link_hash_flags
2480 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2481 && (h->elf_link_hash_flags
2482 & ELF_LINK_HASH_REF_REGULAR) != 0
2483 && (h->elf_link_hash_flags
2484 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
2486 /* If this is a function, put it in the procedure linkage table. We
2487 will fill in the contents of the procedure linkage table later,
2488 when we know the address of the .got section. */
2489 if (h->type == STT_FUNC
2490 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2493 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
2494 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
2496 /* This case can occur if we saw a PLT32 reloc in an input
2497 file, but the symbol was never referred to by a dynamic
2498 object. In such a case, we don't actually need to build
2499 a procedure linkage table, and we can just do a PC32
2501 BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
2505 /* Make sure this symbol is output as a dynamic symbol. */
2506 if (h->dynindx == -1)
2508 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2512 s = bfd_get_section_by_name (dynobj, ".plt");
2513 BFD_ASSERT (s != NULL);
2515 /* If this is the first .plt entry, make room for the special
2517 if (s->_raw_size == 0)
2518 s->_raw_size += PLT_ENTRY_SIZE;
2520 /* If this symbol is not defined in a regular file, and we are
2521 not generating a shared library, then set the symbol to this
2522 location in the .plt. This is required to make function
2523 pointers compare as equal between the normal executable and
2524 the shared library. */
2526 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2528 h->root.u.def.section = s;
2529 h->root.u.def.value = s->_raw_size;
2532 h->plt.offset = s->_raw_size;
2534 /* Make room for this entry. */
2535 s->_raw_size += PLT_ENTRY_SIZE;
2537 /* We also need to make an entry in the .got.plt section, which
2538 will be placed in the .got section by the linker script. */
2540 s = bfd_get_section_by_name (dynobj, ".got.plt");
2541 BFD_ASSERT (s != NULL);
2544 /* We also need to make an entry in the .rel.plt section. */
2546 s = bfd_get_section_by_name (dynobj, ".rel.plt");
2547 BFD_ASSERT (s != NULL);
2548 s->_raw_size += sizeof (Elf32_External_Rel);
2553 /* If this is a weak symbol, and there is a real definition, the
2554 processor independent code will have arranged for us to see the
2555 real definition first, and we can just use the same value. */
2556 if (h->weakdef != NULL)
2558 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2559 || h->weakdef->root.type == bfd_link_hash_defweak);
2560 h->root.u.def.section = h->weakdef->root.u.def.section;
2561 h->root.u.def.value = h->weakdef->root.u.def.value;
2565 /* This is a reference to a symbol defined by a dynamic object which
2566 is not a function. */
2568 /* If we are creating a shared library, we must presume that the
2569 only references to the symbol are via the global offset table.
2570 For such cases we need not do anything here; the relocations will
2571 be handled correctly by relocate_section. */
2575 /* We must allocate the symbol in our .dynbss section, which will
2576 become part of the .bss section of the executable. There will be
2577 an entry for this symbol in the .dynsym section. The dynamic
2578 object will contain position independent code, so all references
2579 from the dynamic object to this symbol will go through the global
2580 offset table. The dynamic linker will use the .dynsym entry to
2581 determine the address it must put in the global offset table, so
2582 both the dynamic object and the regular object will refer to the
2583 same memory location for the variable. */
2585 s = bfd_get_section_by_name (dynobj, ".dynbss");
2586 BFD_ASSERT (s != NULL);
2588 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
2589 copy the initial value out of the dynamic object and into the
2590 runtime process image. We need to remember the offset into the
2591 .rel.bss section we are going to use. */
2592 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2596 srel = bfd_get_section_by_name (dynobj, ".rel.bss");
2597 BFD_ASSERT (srel != NULL);
2598 srel->_raw_size += sizeof (Elf32_External_Rel);
2599 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
2602 /* We need to figure out the alignment required for this symbol. I
2603 have no idea how ELF linkers handle this. */
2604 power_of_two = bfd_log2 (h->size);
2605 if (power_of_two > 3)
2608 /* Apply the required alignment. */
2609 s->_raw_size = BFD_ALIGN (s->_raw_size,
2610 (bfd_size_type) (1 << power_of_two));
2611 if (power_of_two > bfd_get_section_alignment (dynobj, s))
2613 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
2617 /* Define the symbol as being at this point in the section. */
2618 h->root.u.def.section = s;
2619 h->root.u.def.value = s->_raw_size;
2621 /* Increment the section size to make room for the symbol. */
2622 s->_raw_size += h->size;
2627 /* Set the sizes of the dynamic sections. */
2630 elf32_arm_size_dynamic_sections (output_bfd, info)
2632 struct bfd_link_info * info;
2640 dynobj = elf_hash_table (info)->dynobj;
2641 BFD_ASSERT (dynobj != NULL);
2643 if (elf_hash_table (info)->dynamic_sections_created)
2645 /* Set the contents of the .interp section to the interpreter. */
2648 s = bfd_get_section_by_name (dynobj, ".interp");
2649 BFD_ASSERT (s != NULL);
2650 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
2651 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2656 /* We may have created entries in the .rel.got section.
2657 However, if we are not creating the dynamic sections, we will
2658 not actually use these entries. Reset the size of .rel.got,
2659 which will cause it to get stripped from the output file
2661 s = bfd_get_section_by_name (dynobj, ".rel.got");
2666 /* If this is a -Bsymbolic shared link, then we need to discard all
2667 PC relative relocs against symbols defined in a regular object.
2668 We allocated space for them in the check_relocs routine, but we
2669 will not fill them in in the relocate_section routine. */
2670 if (info->shared && info->symbolic)
2671 elf32_arm_link_hash_traverse (elf32_arm_hash_table (info),
2672 elf32_arm_discard_copies,
2675 /* The check_relocs and adjust_dynamic_symbol entry points have
2676 determined the sizes of the various dynamic sections. Allocate
2681 for (s = dynobj->sections; s != NULL; s = s->next)
2686 if ((s->flags & SEC_LINKER_CREATED) == 0)
2689 /* It's OK to base decisions on the section name, because none
2690 of the dynobj section names depend upon the input files. */
2691 name = bfd_get_section_name (dynobj, s);
2695 if (strcmp (name, ".plt") == 0)
2697 if (s->_raw_size == 0)
2699 /* Strip this section if we don't need it; see the
2705 /* Remember whether there is a PLT. */
2709 else if (strncmp (name, ".rel", 4) == 0)
2711 if (s->_raw_size == 0)
2713 /* If we don't need this section, strip it from the
2714 output file. This is mostly to handle .rel.bss and
2715 .rel.plt. We must create both sections in
2716 create_dynamic_sections, because they must be created
2717 before the linker maps input sections to output
2718 sections. The linker does that before
2719 adjust_dynamic_symbol is called, and it is that
2720 function which decides whether anything needs to go
2721 into these sections. */
2728 /* Remember whether there are any reloc sections other
2730 if (strcmp (name, ".rel.plt") != 0)
2732 const char *outname;
2736 /* If this relocation section applies to a read only
2737 section, then we probably need a DT_TEXTREL
2738 entry. The entries in the .rel.plt section
2739 really apply to the .got section, which we
2740 created ourselves and so know is not readonly. */
2741 outname = bfd_get_section_name (output_bfd,
2743 target = bfd_get_section_by_name (output_bfd, outname + 4);
2745 && (target->flags & SEC_READONLY) != 0
2746 && (target->flags & SEC_ALLOC) != 0)
2750 /* We use the reloc_count field as a counter if we need
2751 to copy relocs into the output file. */
2755 else if (strncmp (name, ".got", 4) != 0)
2757 /* It's not one of our sections, so don't allocate space. */
2765 for (spp = &s->output_section->owner->sections;
2766 *spp != s->output_section;
2767 spp = &(*spp)->next)
2769 *spp = s->output_section->next;
2770 --s->output_section->owner->section_count;
2775 /* Allocate memory for the section contents. */
2776 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
2777 if (s->contents == NULL && s->_raw_size != 0)
2781 if (elf_hash_table (info)->dynamic_sections_created)
2783 /* Add some entries to the .dynamic section. We fill in the
2784 values later, in elf32_arm_finish_dynamic_sections, but we
2785 must add the entries now so that we get the correct size for
2786 the .dynamic section. The DT_DEBUG entry is filled in by the
2787 dynamic linker and used by the debugger. */
2790 if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
2796 if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
2797 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
2798 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_REL)
2799 || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
2805 if (! bfd_elf32_add_dynamic_entry (info, DT_REL, 0)
2806 || ! bfd_elf32_add_dynamic_entry (info, DT_RELSZ, 0)
2807 || ! bfd_elf32_add_dynamic_entry (info, DT_RELENT,
2808 sizeof (Elf32_External_Rel)))
2814 if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
2822 /* This function is called via elf32_arm_link_hash_traverse if we are
2823 creating a shared object with -Bsymbolic. It discards the space
2824 allocated to copy PC relative relocs against symbols which are
2825 defined in regular objects. We allocated space for them in the
2826 check_relocs routine, but we won't fill them in in the
2827 relocate_section routine. */
2830 elf32_arm_discard_copies (h, ignore)
2831 struct elf32_arm_link_hash_entry * h;
2834 struct elf32_arm_pcrel_relocs_copied * s;
2836 /* We only discard relocs for symbols defined in a regular object. */
2837 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2840 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
2841 s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
2846 /* Finish up dynamic symbol handling. We set the contents of various
2847 dynamic sections here. */
2850 elf32_arm_finish_dynamic_symbol (output_bfd, info, h, sym)
2852 struct bfd_link_info * info;
2853 struct elf_link_hash_entry * h;
2854 Elf_Internal_Sym * sym;
2858 dynobj = elf_hash_table (info)->dynobj;
2860 if (h->plt.offset != (bfd_vma) -1)
2867 Elf_Internal_Rel rel;
2869 /* This symbol has an entry in the procedure linkage table. Set
2872 BFD_ASSERT (h->dynindx != -1);
2874 splt = bfd_get_section_by_name (dynobj, ".plt");
2875 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
2876 srel = bfd_get_section_by_name (dynobj, ".rel.plt");
2877 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
2879 /* Get the index in the procedure linkage table which
2880 corresponds to this symbol. This is the index of this symbol
2881 in all the symbols for which we are making plt entries. The
2882 first entry in the procedure linkage table is reserved. */
2883 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2885 /* Get the offset into the .got table of the entry that
2886 corresponds to this function. Each .got entry is 4 bytes.
2887 The first three are reserved. */
2888 got_offset = (plt_index + 3) * 4;
2890 /* Fill in the entry in the procedure linkage table. */
2891 memcpy (splt->contents + h->plt.offset,
2892 elf32_arm_plt_entry,
2894 bfd_put_32 (output_bfd,
2895 (sgot->output_section->vma
2896 + sgot->output_offset
2898 - splt->output_section->vma
2899 - splt->output_offset
2900 - h->plt.offset - 12),
2901 splt->contents + h->plt.offset + 12);
2903 /* Fill in the entry in the global offset table. */
2904 bfd_put_32 (output_bfd,
2905 (splt->output_section->vma
2906 + splt->output_offset),
2907 sgot->contents + got_offset);
2909 /* Fill in the entry in the .rel.plt section. */
2910 rel.r_offset = (sgot->output_section->vma
2911 + sgot->output_offset
2913 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
2914 bfd_elf32_swap_reloc_out (output_bfd, &rel,
2915 ((Elf32_External_Rel *) srel->contents
2918 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2920 /* Mark the symbol as undefined, rather than as defined in
2921 the .plt section. Leave the value alone. */
2922 sym->st_shndx = SHN_UNDEF;
2926 if (h->got.offset != (bfd_vma) -1)
2930 Elf_Internal_Rel rel;
2932 /* This symbol has an entry in the global offset table. Set it
2935 sgot = bfd_get_section_by_name (dynobj, ".got");
2936 srel = bfd_get_section_by_name (dynobj, ".rel.got");
2937 BFD_ASSERT (sgot != NULL && srel != NULL);
2939 rel.r_offset = (sgot->output_section->vma
2940 + sgot->output_offset
2941 + (h->got.offset &~ 1));
2943 /* If this is a -Bsymbolic link, and the symbol is defined
2944 locally, we just want to emit a RELATIVE reloc. The entry in
2945 the global offset table will already have been initialized in
2946 the relocate_section function. */
2948 && (info->symbolic || h->dynindx == -1)
2949 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
2950 rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
2953 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
2954 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
2957 bfd_elf32_swap_reloc_out (output_bfd, &rel,
2958 ((Elf32_External_Rel *) srel->contents
2959 + srel->reloc_count));
2960 ++srel->reloc_count;
2963 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
2966 Elf_Internal_Rel rel;
2968 /* This symbol needs a copy reloc. Set it up. */
2970 BFD_ASSERT (h->dynindx != -1
2971 && (h->root.type == bfd_link_hash_defined
2972 || h->root.type == bfd_link_hash_defweak));
2974 s = bfd_get_section_by_name (h->root.u.def.section->owner,
2976 BFD_ASSERT (s != NULL);
2978 rel.r_offset = (h->root.u.def.value
2979 + h->root.u.def.section->output_section->vma
2980 + h->root.u.def.section->output_offset);
2981 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
2982 bfd_elf32_swap_reloc_out (output_bfd, &rel,
2983 ((Elf32_External_Rel *) s->contents
2988 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2989 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2990 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2991 sym->st_shndx = SHN_ABS;
2996 /* Finish up the dynamic sections. */
2999 elf32_arm_finish_dynamic_sections (output_bfd, info)
3001 struct bfd_link_info * info;
3007 dynobj = elf_hash_table (info)->dynobj;
3009 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3010 BFD_ASSERT (sgot != NULL);
3011 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3013 if (elf_hash_table (info)->dynamic_sections_created)
3016 Elf32_External_Dyn *dyncon, *dynconend;
3018 splt = bfd_get_section_by_name (dynobj, ".plt");
3019 BFD_ASSERT (splt != NULL && sdyn != NULL);
3021 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3022 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3023 for (; dyncon < dynconend; dyncon++)
3025 Elf_Internal_Dyn dyn;
3029 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3042 s = bfd_get_section_by_name (output_bfd, name);
3043 BFD_ASSERT (s != NULL);
3044 dyn.d_un.d_ptr = s->vma;
3045 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3049 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3050 BFD_ASSERT (s != NULL);
3051 if (s->_cooked_size != 0)
3052 dyn.d_un.d_val = s->_cooked_size;
3054 dyn.d_un.d_val = s->_raw_size;
3055 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3059 /* My reading of the SVR4 ABI indicates that the
3060 procedure linkage table relocs (DT_JMPREL) should be
3061 included in the overall relocs (DT_REL). This is
3062 what Solaris does. However, UnixWare can not handle
3063 that case. Therefore, we override the DT_RELSZ entry
3064 here to make it not include the JMPREL relocs. Since
3065 the linker script arranges for .rel.plt to follow all
3066 other relocation sections, we don't have to worry
3067 about changing the DT_REL entry. */
3068 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3071 if (s->_cooked_size != 0)
3072 dyn.d_un.d_val -= s->_cooked_size;
3074 dyn.d_un.d_val -= s->_raw_size;
3076 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3081 /* Fill in the first entry in the procedure linkage table. */
3082 if (splt->_raw_size > 0)
3083 memcpy (splt->contents, elf32_arm_plt0_entry, PLT_ENTRY_SIZE);
3085 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3086 really seem like the right value. */
3087 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
3090 /* Fill in the first three entries in the global offset table. */
3091 if (sgot->_raw_size > 0)
3094 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
3096 bfd_put_32 (output_bfd,
3097 sdyn->output_section->vma + sdyn->output_offset,
3099 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
3100 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3103 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
3109 elf32_arm_post_process_headers (abfd, link_info)
3111 struct bfd_link_info * link_info;
3113 Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form */
3115 i_ehdrp = elf_elfheader (abfd);
3117 i_ehdrp->e_ident[EI_OSABI] = ARM_ELF_OS_ABI_VERSION;
3118 i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
3122 #define ELF_ARCH bfd_arch_arm
3123 #define ELF_MACHINE_CODE EM_ARM
3124 #define ELF_MAXPAGESIZE 0x8000
3127 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
3128 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
3129 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
3130 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
3131 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
3132 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
3133 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
3135 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
3136 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
3137 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
3138 #define elf_backend_check_relocs elf32_arm_check_relocs
3139 #define elf_backend_relocate_section elf32_arm_relocate_section
3140 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
3141 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
3142 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
3143 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
3144 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
3145 #define elf_backend_post_process_headers elf32_arm_post_process_headers
3147 #define elf_backend_can_gc_sections 1
3148 #define elf_backend_plt_readonly 1
3149 #define elf_backend_want_got_plt 1
3150 #define elf_backend_want_plt_sym 0
3152 #include "elf32-target.h"