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
;
629 struct elf_link_hash_entry
*h
;
631 r_type
= ELF32_R_TYPE (irel
->r_info
);
632 r_index
= ELF32_R_SYM (irel
->r_info
);
634 /* These are the only relocation types we care about */
635 if ( r_type
!= R_ARM_PC24
636 && r_type
!= R_ARM_THM_PC22
)
639 /* Get the section contents if we haven't done so already. */
640 if (contents
== NULL
)
642 /* Get cached copy if it exists. */
643 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
644 contents
= elf_section_data (sec
)->this_hdr
.contents
;
647 /* Go get them off disk. */
648 contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
649 if (contents
== NULL
)
651 free_contents
= contents
;
653 if (!bfd_get_section_contents (abfd
, sec
, contents
,
654 (file_ptr
) 0, sec
->_raw_size
))
659 /* Read this BFD's symbols if we haven't done so already. */
662 /* Get cached copy if it exists. */
663 if (symtab_hdr
->contents
!= NULL
)
664 extsyms
= (Elf32_External_Sym
*) symtab_hdr
->contents
;
667 /* Go get them off disk. */
668 extsyms
= ((Elf32_External_Sym
*)
669 bfd_malloc (symtab_hdr
->sh_size
));
672 free_extsyms
= extsyms
;
673 if (bfd_seek (abfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
674 || (bfd_read (extsyms
, 1, symtab_hdr
->sh_size
, abfd
)
675 != symtab_hdr
->sh_size
))
680 /* If the relocation is not against a symbol it cannot concern us. */
684 /* We don't care about local symbols */
685 if (r_index
< symtab_hdr
->sh_info
)
688 /* This is an external symbol */
689 r_index
-= symtab_hdr
->sh_info
;
690 h
= (struct elf_link_hash_entry
*)
691 elf_sym_hashes (abfd
)[r_index
];
693 /* If the relocation is against a static symbol it must be within
694 the current section and so cannot be a cross ARM/Thumb relocation. */
701 /* This one is a call from arm code. We need to look up
702 the target of the call. If it is a thumb target, we
705 if (ELF_ST_TYPE(h
->type
) == STT_ARM_TFUNC
)
706 record_arm_to_thumb_glue (link_info
, h
);
710 /* This one is a call from thumb code. We look
711 up the target of the call. If it is not a thumb
712 target, we insert glue. */
714 if (ELF_ST_TYPE (h
->type
) != STT_ARM_TFUNC
)
715 record_thumb_to_arm_glue (link_info
, h
);
726 if (free_relocs
!= NULL
)
728 if (free_contents
!= NULL
)
729 free (free_contents
);
730 if (free_extsyms
!= NULL
)
736 /* The thumb form of a long branch is a bit finicky, because the offset
737 encoding is split over two fields, each in it's own instruction. They
738 can occur in any order. So given a thumb form of long branch, and an
739 offset, insert the offset into the thumb branch and return finished
742 It takes two thumb instructions to encode the target address. Each has
743 11 bits to invest. The upper 11 bits are stored in one (identifed by
744 H-0.. see below), the lower 11 bits are stored in the other (identified
747 Combine together and shifted left by 1 (it's a half word address) and
751 H-0, upper address-0 = 000
753 H-1, lower address-0 = 800
755 They can be ordered either way, but the arm tools I've seen always put
756 the lower one first. It probably doesn't matter. krk@cygnus.com
758 XXX: Actually the order does matter. The second instruction (H-1)
759 moves the computed address into the PC, so it must be the second one
760 in the sequence. The problem, however is that whilst little endian code
761 stores the instructions in HI then LOW order, big endian code does the
762 reverse. nickc@cygnus.com */
764 #define LOW_HI_ORDER 0xF800F000
765 #define HI_LOW_ORDER 0xF000F800
768 insert_thumb_branch (br_insn
, rel_off
)
772 unsigned int low_bits
;
773 unsigned int high_bits
;
776 BFD_ASSERT ((rel_off
& 1) != 1);
778 rel_off
>>= 1; /* half word aligned address */
779 low_bits
= rel_off
& 0x000007FF; /* the bottom 11 bits */
780 high_bits
= (rel_off
>> 11) & 0x000007FF; /* the top 11 bits */
782 if ((br_insn
& LOW_HI_ORDER
) == LOW_HI_ORDER
)
783 br_insn
= LOW_HI_ORDER
| (low_bits
<< 16) | high_bits
;
784 else if ((br_insn
& HI_LOW_ORDER
) == HI_LOW_ORDER
)
785 br_insn
= HI_LOW_ORDER
| (high_bits
<< 16) | low_bits
;
787 abort (); /* error - not a valid branch instruction form */
789 /* FIXME: abort is probably not the right call. krk@cygnus.com */
794 /* Thumb code calling an ARM function */
796 elf32_thumb_to_arm_stub (info
, name
, input_bfd
, output_bfd
, input_section
,
797 hit_data
, sym_sec
, offset
, addend
, val
)
798 struct bfd_link_info
*info
;
802 asection
*input_section
;
811 unsigned long int tmp
;
813 struct elf_link_hash_entry
*myh
;
814 struct elf32_arm_link_hash_table
*globals
;
816 myh
= find_thumb_glue (info
, name
, input_bfd
);
820 globals
= elf32_arm_hash_table (info
);
822 BFD_ASSERT (globals
!= NULL
);
823 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
825 my_offset
= myh
->root
.u
.def
.value
;
827 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
828 THUMB2ARM_GLUE_SECTION_NAME
);
830 BFD_ASSERT (s
!= NULL
);
831 BFD_ASSERT (s
->contents
!= NULL
);
832 BFD_ASSERT (s
->output_section
!= NULL
);
834 if ((my_offset
& 0x01) == 0x01)
837 && sym_sec
->owner
!= NULL
838 && !INTERWORK_FLAG (sym_sec
->owner
))
841 (_ ("%s(%s): warning: interworking not enabled."),
842 bfd_get_filename (sym_sec
->owner
), name
);
844 (_ (" first occurrence: %s: thumb call to arm"),
845 bfd_get_filename (input_bfd
));
851 myh
->root
.u
.def
.value
= my_offset
;
853 bfd_put_16 (output_bfd
, t2a1_bx_pc_insn
,
854 s
->contents
+ my_offset
);
856 bfd_put_16 (output_bfd
, t2a2_noop_insn
,
857 s
->contents
+ my_offset
+ 2);
860 ((bfd_signed_vma
) val
) /* Address of destination of the stub */
862 (s
->output_offset
/* Offset from the start of the current section to the start of the stubs. */
863 + my_offset
/* Offset of the start of this stub from the start of the stubs. */
864 + s
->output_section
->vma
) /* Address of the start of the current section. */
865 + 4 /* The branch instruction is 4 bytes into the stub. */
866 + 8); /* ARM branches work from the pc of the instruction + 8. */
868 bfd_put_32 (output_bfd
,
869 t2a3_b_insn
| ((ret_offset
>> 2) & 0x00FFFFFF),
870 s
->contents
+ my_offset
+ 4);
873 BFD_ASSERT (my_offset
<= globals
->thumb_glue_size
);
875 /* Now go back and fix up the original BL insn to point
880 - (input_section
->output_offset
884 tmp
= bfd_get_32 (input_bfd
, hit_data
885 - input_section
->vma
);
887 bfd_put_32 (output_bfd
,
888 insert_thumb_branch (tmp
, ret_offset
),
889 hit_data
- input_section
->vma
);
894 /* Arm code calling a Thumb function */
896 elf32_arm_to_thumb_stub (info
, name
, input_bfd
, output_bfd
, input_section
,
897 hit_data
, sym_sec
, offset
, addend
, val
)
899 struct bfd_link_info
*info
;
903 asection
*input_section
;
910 unsigned long int tmp
;
914 struct elf_link_hash_entry
*myh
;
915 struct elf32_arm_link_hash_table
*globals
;
917 myh
= find_arm_glue (info
, name
, input_bfd
);
921 globals
= elf32_arm_hash_table (info
);
923 BFD_ASSERT (globals
!= NULL
);
924 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
926 my_offset
= myh
->root
.u
.def
.value
;
927 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
928 ARM2THUMB_GLUE_SECTION_NAME
);
929 BFD_ASSERT (s
!= NULL
);
930 BFD_ASSERT (s
->contents
!= NULL
);
931 BFD_ASSERT (s
->output_section
!= NULL
);
933 if ((my_offset
& 0x01) == 0x01)
936 && sym_sec
->owner
!= NULL
937 && !INTERWORK_FLAG (sym_sec
->owner
))
940 (_ ("%s(%s): warning: interworking not enabled."),
941 bfd_get_filename (sym_sec
->owner
), name
);
943 (_ (" first occurrence: %s: arm call to thumb"),
944 bfd_get_filename (input_bfd
));
947 myh
->root
.u
.def
.value
= my_offset
;
949 bfd_put_32 (output_bfd
, a2t1_ldr_insn
,
950 s
->contents
+ my_offset
);
952 bfd_put_32 (output_bfd
, a2t2_bx_r12_insn
,
953 s
->contents
+ my_offset
+ 4);
955 /* It's a thumb address. Add the low order bit. */
956 bfd_put_32 (output_bfd
, val
| a2t3_func_addr_insn
,
957 s
->contents
+ my_offset
+ 8);
960 BFD_ASSERT (my_offset
<= globals
->arm_glue_size
);
962 tmp
= bfd_get_32 (input_bfd
, hit_data
);
963 tmp
= tmp
& 0xFF000000;
965 /* Somehow these are both 4 too far, so subtract 8. */
966 ret_offset
= s
->output_offset
968 + s
->output_section
->vma
969 - (input_section
->output_offset
970 + input_section
->output_section
->vma
974 tmp
= tmp
| ((ret_offset
>> 2) & 0x00FFFFFF);
976 bfd_put_32 (output_bfd
, tmp
, hit_data
977 - input_section
->vma
);
983 /* Perform a relocation as part of a final link. */
984 static bfd_reloc_status_type
985 elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
986 input_section
, contents
, rel
, value
,
987 info
, sym_sec
, sym_name
, sym_flags
, h
)
988 reloc_howto_type
* howto
;
991 asection
* input_section
;
993 Elf_Internal_Rela
* rel
;
995 struct bfd_link_info
* info
;
997 const char * sym_name
;
998 unsigned char sym_flags
;
999 struct elf_link_hash_entry
* h
;
1001 unsigned long r_type
= howto
->type
;
1002 unsigned long r_symndx
;
1003 bfd_byte
* hit_data
= contents
+ rel
->r_offset
;
1004 bfd
* dynobj
= NULL
;
1005 Elf_Internal_Shdr
* symtab_hdr
;
1006 struct elf_link_hash_entry
** sym_hashes
;
1007 bfd_vma
* local_got_offsets
;
1008 asection
* sgot
= NULL
;
1009 asection
* splt
= NULL
;
1010 asection
* sreloc
= NULL
;
1012 bfd_signed_vma signed_addend
;
1013 struct elf32_arm_link_hash_table
* globals
;
1015 globals
= elf32_arm_hash_table (info
);
1017 dynobj
= elf_hash_table (info
)->dynobj
;
1020 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1021 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1023 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1024 sym_hashes
= elf_sym_hashes (input_bfd
);
1025 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1026 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1029 addend
= bfd_get_32 (input_bfd
, hit_data
) & howto
->src_mask
;
1031 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1034 signed_addend
&= ~ howto
->src_mask
;
1035 signed_addend
|= addend
;
1038 signed_addend
= addend
;
1040 addend
= signed_addend
= rel
->r_addend
;
1046 return bfd_reloc_ok
;
1051 /* When generating a shared object, these relocations are copied
1052 into the output file to be resolved at run time. */
1055 && (r_type
!= R_ARM_PC24
1058 && (! info
->symbolic
1059 || (h
->elf_link_hash_flags
1060 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1062 Elf_Internal_Rel outrel
;
1063 boolean skip
, relocate
;
1069 name
= (bfd_elf_string_from_elf_section
1071 elf_elfheader (input_bfd
)->e_shstrndx
,
1072 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1074 return bfd_reloc_notsupported
;
1076 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
1077 && strcmp (bfd_get_section_name (input_bfd
,
1081 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1082 BFD_ASSERT (sreloc
!= NULL
);
1087 if (elf_section_data (input_section
)->stab_info
== NULL
)
1088 outrel
.r_offset
= rel
->r_offset
;
1093 off
= (_bfd_stab_section_offset
1094 (output_bfd
, &elf_hash_table (info
)->stab_info
,
1096 & elf_section_data (input_section
)->stab_info
,
1098 if (off
== (bfd_vma
) -1)
1100 outrel
.r_offset
= off
;
1103 outrel
.r_offset
+= (input_section
->output_section
->vma
1104 + input_section
->output_offset
);
1108 memset (&outrel
, 0, sizeof outrel
);
1111 else if (r_type
== R_ARM_PC24
)
1113 BFD_ASSERT (h
!= NULL
&& h
->dynindx
!= -1);
1114 if ((input_section
->flags
& SEC_ALLOC
) != 0)
1118 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_PC24
);
1123 || ((info
->symbolic
|| h
->dynindx
== -1)
1124 && (h
->elf_link_hash_flags
1125 & ELF_LINK_HASH_DEF_REGULAR
) != 0))
1128 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1132 BFD_ASSERT (h
->dynindx
!= -1);
1133 if ((input_section
->flags
& SEC_ALLOC
) != 0)
1137 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_ABS32
);
1141 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1142 (((Elf32_External_Rel
*)
1144 + sreloc
->reloc_count
));
1145 ++sreloc
->reloc_count
;
1147 /* If this reloc is against an external symbol, we do not want to
1148 fiddle with the addend. Otherwise, we need to include the symbol
1149 value so that it becomes an addend for the dynamic reloc. */
1151 return bfd_reloc_ok
;
1154 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1155 contents
, rel
->r_offset
, value
,
1158 else switch (r_type
)
1161 /* Arm B/BL instruction */
1163 /* Check for arm calling thumb function. */
1164 if (sym_flags
== STT_ARM_TFUNC
)
1166 elf32_arm_to_thumb_stub (info
, sym_name
, input_bfd
, output_bfd
,
1167 input_section
, hit_data
, sym_sec
, rel
->r_offset
, addend
, value
);
1168 return bfd_reloc_ok
;
1171 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1172 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0)
1174 /* The old way of doing things. Trearing the addend as a
1175 byte sized field and adding in the pipeline offset. */
1177 value
-= (input_section
->output_section
->vma
1178 + input_section
->output_offset
);
1179 value
-= rel
->r_offset
;
1182 if (! globals
->no_pipeline_knowledge
)
1187 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
1189 S is the address of the symbol in the relocation.
1190 P is address of the instruction being relocated.
1191 A is the addend (extracted from the instruction) in bytes.
1193 S is held in 'value'.
1194 P is the base address of the section containing the instruction
1195 plus the offset of the reloc into that section, ie:
1196 (input_section->output_section->vma +
1197 input_section->output_offset +
1199 A is the addend, converted into bytes, ie:
1202 Note: None of these operations have knowledge of the pipeline
1203 size of the processor, thus it is up to the assembler to encode
1204 this information into the addend. */
1206 value
-= (input_section
->output_section
->vma
1207 + input_section
->output_offset
);
1208 value
-= rel
->r_offset
;
1209 value
+= (signed_addend
<< howto
->size
);
1211 /* Previous versions of this code also used to add in the pipeline
1212 offset here. This is wrong because the linker is not supposed
1213 to know about such things, and one day it might change. In order
1214 to support old binaries that need the old behaviour however, so
1215 we attempt to detect which ABI was used to create the reloc. */
1216 if (! globals
->no_pipeline_knowledge
)
1218 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form */
1220 i_ehdrp
= elf_elfheader (input_bfd
);
1222 if (i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1227 value
>>= howto
->rightshift
;
1228 value
&= howto
->dst_mask
;
1229 value
|= (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1234 if (sym_flags
== STT_ARM_TFUNC
)
1239 value
-= (input_section
->output_section
->vma
1240 + input_section
->output_offset
);
1245 bfd_put_32 (input_bfd
, value
, hit_data
);
1246 return bfd_reloc_ok
;
1250 if ((long) value
> 0x7f || (long) value
< -0x80)
1251 return bfd_reloc_overflow
;
1253 bfd_put_8 (input_bfd
, value
, hit_data
);
1254 return bfd_reloc_ok
;
1259 if ((long) value
> 0x7fff || (long) value
< -0x8000)
1260 return bfd_reloc_overflow
;
1262 bfd_put_16 (input_bfd
, value
, hit_data
);
1263 return bfd_reloc_ok
;
1266 /* Support ldr and str instruction for the arm */
1267 /* Also thumb b (unconditional branch). ??? Really? */
1270 if ((long) value
> 0x7ff || (long) value
< -0x800)
1271 return bfd_reloc_overflow
;
1273 value
|= (bfd_get_32 (input_bfd
, hit_data
) & 0xfffff000);
1274 bfd_put_32 (input_bfd
, value
, hit_data
);
1275 return bfd_reloc_ok
;
1277 case R_ARM_THM_ABS5
:
1278 /* Support ldr and str instructions for the thumb. */
1280 /* Need to refetch addend. */
1281 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1282 /* ??? Need to determine shift amount from operand size. */
1283 addend
>>= howto
->rightshift
;
1287 /* ??? Isn't value unsigned? */
1288 if ((long) value
> 0x1f || (long) value
< -0x10)
1289 return bfd_reloc_overflow
;
1291 /* ??? Value needs to be properly shifted into place first. */
1292 value
|= bfd_get_16 (input_bfd
, hit_data
) & 0xf83f;
1293 bfd_put_16 (input_bfd
, value
, hit_data
);
1294 return bfd_reloc_ok
;
1296 case R_ARM_THM_PC22
:
1297 /* Thumb BL (branch long instruction). */
1300 boolean overflow
= false;
1301 bfd_vma upper_insn
= bfd_get_16 (input_bfd
, hit_data
);
1302 bfd_vma lower_insn
= bfd_get_16 (input_bfd
, hit_data
+ 2);
1303 bfd_signed_vma reloc_signed_max
= (1 << (howto
->bitsize
- 1)) - 1;
1304 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1306 bfd_signed_vma signed_check
;
1309 /* Need to refetch the addend and squish the two 11 bit pieces
1312 bfd_vma upper
= upper_insn
& 0x7ff;
1313 bfd_vma lower
= lower_insn
& 0x7ff;
1314 upper
= (upper
^ 0x400) - 0x400; /* sign extend */
1315 addend
= (upper
<< 12) | (lower
<< 1);
1316 signed_addend
= addend
;
1320 /* If it's not a call to thumb, assume call to arm */
1321 if (sym_flags
!= STT_ARM_TFUNC
)
1323 if (elf32_thumb_to_arm_stub
1324 (info
, sym_name
, input_bfd
, output_bfd
, input_section
,
1325 hit_data
, sym_sec
, rel
->r_offset
, addend
, value
))
1326 return bfd_reloc_ok
;
1328 return bfd_reloc_dangerous
;
1331 relocation
= value
+ signed_addend
;
1333 relocation
-= (input_section
->output_section
->vma
1334 + input_section
->output_offset
1337 if (! globals
->no_pipeline_knowledge
)
1339 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form */
1341 i_ehdrp
= elf_elfheader (input_bfd
);
1343 /* Previous versions of this code also used to add in the pipline
1344 offset here. This is wrong because the linker is not supposed
1345 to know about such things, and one day it might change. In order
1346 to support old binaries that need the old behaviour however, so
1347 we attempt to detect which ABI was used to create the reloc. */
1348 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1349 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0
1350 || i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1354 check
= relocation
>> howto
->rightshift
;
1356 /* If this is a signed value, the rightshift just dropped
1357 leading 1 bits (assuming twos complement). */
1358 if ((bfd_signed_vma
) relocation
>= 0)
1359 signed_check
= check
;
1361 signed_check
= check
| ~((bfd_vma
) -1 >> howto
->rightshift
);
1363 /* Assumes two's complement. */
1364 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1367 /* Put RELOCATION back into the insn. */
1368 upper_insn
= (upper_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 12) & 0x7ff);
1369 lower_insn
= (lower_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 1) & 0x7ff);
1371 /* Put the relocated value back in the object file: */
1372 bfd_put_16 (input_bfd
, upper_insn
, hit_data
);
1373 bfd_put_16 (input_bfd
, lower_insn
, hit_data
+ 2);
1375 return (overflow
? bfd_reloc_overflow
: bfd_reloc_ok
);
1379 case R_ARM_GNU_VTINHERIT
:
1380 case R_ARM_GNU_VTENTRY
:
1381 return bfd_reloc_ok
;
1384 return bfd_reloc_notsupported
;
1386 case R_ARM_GLOB_DAT
:
1387 return bfd_reloc_notsupported
;
1389 case R_ARM_JUMP_SLOT
:
1390 return bfd_reloc_notsupported
;
1392 case R_ARM_RELATIVE
:
1393 return bfd_reloc_notsupported
;
1396 /* Relocation is relative to the start of the
1397 global offset table. */
1399 BFD_ASSERT (sgot
!= NULL
);
1401 return bfd_reloc_notsupported
;
1403 /* Note that sgot->output_offset is not involved in this
1404 calculation. We always want the start of .got. If we
1405 define _GLOBAL_OFFSET_TABLE in a different way, as is
1406 permitted by the ABI, we might have to change this
1409 value
-= sgot
->output_section
->vma
;
1410 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1411 contents
, rel
->r_offset
, value
,
1415 /* Use global offset table as symbol value. */
1417 BFD_ASSERT (sgot
!= NULL
);
1420 return bfd_reloc_notsupported
;
1422 value
= sgot
->output_section
->vma
;
1423 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1424 contents
, rel
->r_offset
, value
,
1428 /* Relocation is to the entry for this symbol in the
1429 global offset table. */
1431 return bfd_reloc_notsupported
;
1437 off
= h
->got
.offset
;
1438 BFD_ASSERT (off
!= (bfd_vma
) -1);
1440 if (!elf_hash_table (info
)->dynamic_sections_created
||
1441 (info
->shared
&& (info
->symbolic
|| h
->dynindx
== -1)
1442 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1444 /* This is actually a static link, or it is a -Bsymbolic link
1445 and the symbol is defined locally. We must initialize this
1446 entry in the global offset table. Since the offset must
1447 always be a multiple of 4, we use the least significant bit
1448 to record whether we have initialized it already.
1450 When doing a dynamic link, we create a .rel.got relocation
1451 entry to initialize the value. This is done in the
1452 finish_dynamic_symbol routine. */
1458 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1463 value
= sgot
->output_offset
+ off
;
1469 BFD_ASSERT (local_got_offsets
!= NULL
&&
1470 local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1472 off
= local_got_offsets
[r_symndx
];
1474 /* The offset must always be a multiple of 4. We use the
1475 least significant bit to record whether we have already
1476 generated the necessary reloc. */
1481 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1486 Elf_Internal_Rel outrel
;
1488 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
1489 BFD_ASSERT (srelgot
!= NULL
);
1491 outrel
.r_offset
= (sgot
->output_section
->vma
1492 + sgot
->output_offset
1494 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1495 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1496 (((Elf32_External_Rel
*)
1498 + srelgot
->reloc_count
));
1499 ++srelgot
->reloc_count
;
1502 local_got_offsets
[r_symndx
] |= 1;
1505 value
= sgot
->output_offset
+ off
;
1508 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1509 contents
, rel
->r_offset
, value
,
1513 /* Relocation is to the entry for this symbol in the
1514 procedure linkage table. */
1516 /* Resolve a PLT32 reloc against a local symbol directly,
1517 without using the procedure linkage table. */
1519 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1520 contents
, rel
->r_offset
, value
,
1523 if (h
->plt
.offset
== (bfd_vma
) -1)
1524 /* We didn't make a PLT entry for this symbol. This
1525 happens when statically linking PIC code, or when
1526 using -Bsymbolic. */
1527 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1528 contents
, rel
->r_offset
, value
,
1531 BFD_ASSERT(splt
!= NULL
);
1533 return bfd_reloc_notsupported
;
1535 value
= (splt
->output_section
->vma
1536 + splt
->output_offset
1538 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1539 contents
, rel
->r_offset
, value
,
1543 return bfd_reloc_notsupported
;
1545 case R_ARM_AMP_VCALL9
:
1546 return bfd_reloc_notsupported
;
1548 case R_ARM_RSBREL32
:
1549 return bfd_reloc_notsupported
;
1551 case R_ARM_THM_RPC22
:
1552 return bfd_reloc_notsupported
;
1555 return bfd_reloc_notsupported
;
1558 return bfd_reloc_notsupported
;
1561 return bfd_reloc_notsupported
;
1564 return bfd_reloc_notsupported
;
1567 return bfd_reloc_notsupported
;
1572 /* Relocate an ARM ELF section. */
1574 elf32_arm_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1575 contents
, relocs
, local_syms
, local_sections
)
1577 struct bfd_link_info
* info
;
1579 asection
* input_section
;
1580 bfd_byte
* contents
;
1581 Elf_Internal_Rela
* relocs
;
1582 Elf_Internal_Sym
* local_syms
;
1583 asection
** local_sections
;
1585 Elf_Internal_Shdr
* symtab_hdr
;
1586 struct elf_link_hash_entry
** sym_hashes
;
1587 Elf_Internal_Rela
* rel
;
1588 Elf_Internal_Rela
* relend
;
1591 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1592 sym_hashes
= elf_sym_hashes (input_bfd
);
1595 relend
= relocs
+ input_section
->reloc_count
;
1596 for (; rel
< relend
; rel
++)
1599 reloc_howto_type
* howto
;
1600 unsigned long r_symndx
;
1601 Elf_Internal_Sym
* sym
;
1603 struct elf_link_hash_entry
* h
;
1605 bfd_reloc_status_type r
;
1608 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1609 r_type
= ELF32_R_TYPE (rel
->r_info
);
1611 if ( r_type
== R_ARM_GNU_VTENTRY
1612 || r_type
== R_ARM_GNU_VTINHERIT
)
1615 elf32_arm_info_to_howto (input_bfd
, & bfd_reloc
, rel
);
1616 howto
= bfd_reloc
.howto
;
1618 if (info
->relocateable
)
1620 /* This is a relocateable link. We don't have to change
1621 anything, unless the reloc is against a section symbol,
1622 in which case we have to adjust according to where the
1623 section symbol winds up in the output section. */
1624 if (r_symndx
< symtab_hdr
->sh_info
)
1626 sym
= local_syms
+ r_symndx
;
1627 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1629 sec
= local_sections
[r_symndx
];
1635 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1636 val
= insn
+ ((sec
->output_offset
+ sym
->st_value
)
1637 >> howto
->rightshift
);
1638 val
&= howto
->dst_mask
;
1639 val
|= insn
& ~(howto
->dst_mask
);
1641 bfd_put_32 (input_bfd
, val
, contents
+ rel
->r_offset
);
1644 rel
->r_addend
+= (sec
->output_offset
+ sym
->st_value
)
1645 >> howto
->rightshift
;
1653 /* This is a final link. */
1657 if (r_symndx
< symtab_hdr
->sh_info
)
1659 sym
= local_syms
+ r_symndx
;
1660 sec
= local_sections
[r_symndx
];
1661 relocation
= (sec
->output_section
->vma
1662 + sec
->output_offset
1667 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1668 while (h
->root
.type
== bfd_link_hash_indirect
1669 || h
->root
.type
== bfd_link_hash_warning
)
1670 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1671 if (h
->root
.type
== bfd_link_hash_defined
1672 || h
->root
.type
== bfd_link_hash_defweak
)
1674 int relocation_needed
= 1;
1676 sec
= h
->root
.u
.def
.section
;
1678 /* In these cases, we don't need the relocation value.
1679 We check specially because in some obscure cases
1680 sec->output_section will be NULL. */
1687 (!info
->symbolic
&& h
->dynindx
!= -1)
1688 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1690 && ((input_section
->flags
& SEC_ALLOC
) != 0)
1692 relocation_needed
= 0;
1696 relocation_needed
= 0;
1700 if (elf_hash_table(info
)->dynamic_sections_created
1702 || (!info
->symbolic
&& h
->dynindx
!= -1)
1703 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1706 relocation_needed
= 0;
1710 if (h
->plt
.offset
!= (bfd_vma
)-1)
1711 relocation_needed
= 0;
1715 if (sec
->output_section
== NULL
)
1717 (*_bfd_error_handler
)
1718 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1719 bfd_get_filename (input_bfd
), h
->root
.root
.string
,
1720 bfd_get_section_name (input_bfd
, input_section
));
1721 relocation_needed
= 0;
1725 if (relocation_needed
)
1726 relocation
= h
->root
.u
.def
.value
1727 + sec
->output_section
->vma
1728 + sec
->output_offset
;
1732 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1734 else if (info
->shared
&& !info
->symbolic
&& !info
->no_undefined
)
1738 if (!((*info
->callbacks
->undefined_symbol
)
1739 (info
, h
->root
.root
.string
, input_bfd
,
1740 input_section
, rel
->r_offset
)))
1747 name
= h
->root
.root
.string
;
1750 name
= (bfd_elf_string_from_elf_section
1751 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
1752 if (name
== NULL
|| *name
== '\0')
1753 name
= bfd_section_name (input_bfd
, sec
);
1756 r
= elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
1757 input_section
, contents
, rel
,
1758 relocation
, info
, sec
, name
,
1759 (h
? ELF_ST_TYPE (h
->type
) :
1760 ELF_ST_TYPE (sym
->st_info
)), h
);
1762 if (r
!= bfd_reloc_ok
)
1764 const char * msg
= (const char *) 0;
1768 case bfd_reloc_overflow
:
1769 if (!((*info
->callbacks
->reloc_overflow
)
1770 (info
, name
, howto
->name
, (bfd_vma
) 0,
1771 input_bfd
, input_section
, rel
->r_offset
)))
1775 case bfd_reloc_undefined
:
1776 if (!((*info
->callbacks
->undefined_symbol
)
1777 (info
, name
, input_bfd
, input_section
,
1782 case bfd_reloc_outofrange
:
1783 msg
= _ ("internal error: out of range error");
1786 case bfd_reloc_notsupported
:
1787 msg
= _ ("internal error: unsupported relocation error");
1790 case bfd_reloc_dangerous
:
1791 msg
= _ ("internal error: dangerous error");
1795 msg
= _ ("internal error: unknown error");
1799 if (!((*info
->callbacks
->warning
)
1800 (info
, msg
, name
, input_bfd
, input_section
,
1811 /* Function to keep ARM specific flags in the ELF header. */
1813 elf32_arm_set_private_flags (abfd
, flags
)
1817 if (elf_flags_init (abfd
)
1818 && elf_elfheader (abfd
)->e_flags
!= flags
)
1820 if (flags
& EF_INTERWORK
)
1821 _bfd_error_handler (_ ("\
1822 Warning: Not setting interwork flag of %s since it has already been specified as non-interworking"),
1823 bfd_get_filename (abfd
));
1825 _bfd_error_handler (_ ("\
1826 Warning: Clearing the interwork flag of %s due to outside request"),
1827 bfd_get_filename (abfd
));
1831 elf_elfheader (abfd
)->e_flags
= flags
;
1832 elf_flags_init (abfd
) = true;
1838 /* Copy backend specific data from one object module to another */
1840 elf32_arm_copy_private_bfd_data (ibfd
, obfd
)
1847 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1848 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1851 in_flags
= elf_elfheader (ibfd
)->e_flags
;
1852 out_flags
= elf_elfheader (obfd
)->e_flags
;
1854 if (elf_flags_init (obfd
) && in_flags
!= out_flags
)
1856 /* Cannot mix PIC and non-PIC code. */
1857 if ((in_flags
& EF_PIC
) != (out_flags
& EF_PIC
))
1860 /* Cannot mix APCS26 and APCS32 code. */
1861 if ((in_flags
& EF_APCS_26
) != (out_flags
& EF_APCS_26
))
1864 /* Cannot mix float APCS and non-float APCS code. */
1865 if ((in_flags
& EF_APCS_FLOAT
) != (out_flags
& EF_APCS_FLOAT
))
1868 /* If the src and dest have different interworking flags
1869 then turn off the interworking bit. */
1870 if ((in_flags
& EF_INTERWORK
) != (out_flags
& EF_INTERWORK
))
1872 if (out_flags
& EF_INTERWORK
)
1873 _bfd_error_handler (_ ("\
1874 Warning: Clearing the interwork flag in %s because non-interworking code in %s has been linked with it"),
1875 bfd_get_filename (obfd
), bfd_get_filename (ibfd
));
1877 in_flags
&= ~EF_INTERWORK
;
1881 elf_elfheader (obfd
)->e_flags
= in_flags
;
1882 elf_flags_init (obfd
) = true;
1887 /* Merge backend specific data from an object file to the output
1888 object file when linking. */
1890 elf32_arm_merge_private_bfd_data (ibfd
, obfd
)
1897 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1898 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1901 /* Check if we have the same endianess */
1902 if ( ibfd
->xvec
->byteorder
!= obfd
->xvec
->byteorder
1903 && obfd
->xvec
->byteorder
!= BFD_ENDIAN_UNKNOWN
1904 && ibfd
->xvec
->byteorder
!= BFD_ENDIAN_UNKNOWN
)
1906 (*_bfd_error_handler
)
1907 (_("%s: compiled for a %s endian system and target is %s endian"),
1908 bfd_get_filename (ibfd
),
1909 bfd_big_endian (ibfd
) ? "big" : "little",
1910 bfd_big_endian (obfd
) ? "big" : "little");
1912 bfd_set_error (bfd_error_wrong_format
);
1916 /* The input BFD must have had its flags initialised. */
1917 /* The following seems bogus to me -- The flags are initialized in
1918 the assembler but I don't think an elf_flags_init field is
1919 written into the object */
1920 /* BFD_ASSERT (elf_flags_init (ibfd)); */
1922 in_flags
= elf_elfheader (ibfd
)->e_flags
;
1923 out_flags
= elf_elfheader (obfd
)->e_flags
;
1925 if (!elf_flags_init (obfd
))
1927 /* If the input is the default architecture then do not
1928 bother setting the flags for the output architecture,
1929 instead allow future merges to do this. If no future
1930 merges ever set these flags then they will retain their
1931 unitialised values, which surprise surprise, correspond
1932 to the default values. */
1933 if (bfd_get_arch_info (ibfd
)->the_default
)
1936 elf_flags_init (obfd
) = true;
1937 elf_elfheader (obfd
)->e_flags
= in_flags
;
1939 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
1940 && bfd_get_arch_info (obfd
)->the_default
)
1941 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
), bfd_get_mach (ibfd
));
1946 /* Check flag compatibility. */
1947 if (in_flags
== out_flags
)
1950 /* Complain about various flag mismatches. */
1952 if ((in_flags
& EF_APCS_26
) != (out_flags
& EF_APCS_26
))
1953 _bfd_error_handler (_ ("\
1954 Error: %s compiled for APCS-%d, whereas %s is compiled for APCS-%d"),
1955 bfd_get_filename (ibfd
),
1956 in_flags
& EF_APCS_26
? 26 : 32,
1957 bfd_get_filename (obfd
),
1958 out_flags
& EF_APCS_26
? 26 : 32);
1960 if ((in_flags
& EF_APCS_FLOAT
) != (out_flags
& EF_APCS_FLOAT
))
1961 _bfd_error_handler (_ ("\
1962 Error: %s passes floats in %s registers, whereas %s passes them in %s registers"),
1963 bfd_get_filename (ibfd
),
1964 in_flags
& EF_APCS_FLOAT
? _ ("float") : _ ("integer"),
1965 bfd_get_filename (obfd
),
1966 out_flags
& EF_APCS_26
? _ ("float") : _ ("integer"));
1968 if ((in_flags
& EF_PIC
) != (out_flags
& EF_PIC
))
1969 _bfd_error_handler (_ ("\
1970 Error: %s is compiled as position %s code, whereas %s is not"),
1971 bfd_get_filename (ibfd
),
1972 in_flags
& EF_PIC
? _ ("independent") : _ ("dependent"),
1973 bfd_get_filename (obfd
));
1975 /* Interworking mismatch is only a warning. */
1976 if ((in_flags
& EF_INTERWORK
) != (out_flags
& EF_INTERWORK
))
1978 _bfd_error_handler (_ ("\
1979 Warning: %s %s interworking, whereas %s %s"),
1980 bfd_get_filename (ibfd
),
1981 in_flags
& EF_INTERWORK
? _ ("supports") : _ ("does not support"),
1982 bfd_get_filename (obfd
),
1983 out_flags
& EF_INTERWORK
? _ ("does not") : _ ("does"));
1990 /* Display the flags field */
1992 elf32_arm_print_private_bfd_data (abfd
, ptr
)
1996 FILE *file
= (FILE *) ptr
;
1998 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
2000 /* Print normal ELF private data. */
2001 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
2003 /* Ignore init flag - it may not be set, despite the flags field containing valid data. */
2005 /* xgettext:c-format */
2006 fprintf (file
, _ ("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
2008 if (elf_elfheader (abfd
)->e_flags
& EF_INTERWORK
)
2009 fprintf (file
, _ (" [interworking enabled]"));
2011 fprintf (file
, _ (" [interworking not enabled]"));
2013 if (elf_elfheader (abfd
)->e_flags
& EF_APCS_26
)
2014 fprintf (file
, _ (" [APCS-26]"));
2016 fprintf (file
, _ (" [APCS-32]"));
2018 if (elf_elfheader (abfd
)->e_flags
& EF_APCS_FLOAT
)
2019 fprintf (file
, _ (" [floats passed in float registers]"));
2021 fprintf (file
, _ (" [floats passed in integer registers]"));
2023 if (elf_elfheader (abfd
)->e_flags
& EF_PIC
)
2024 fprintf (file
, _ (" [position independent]"));
2026 fprintf (file
, _ (" [absolute position]"));
2034 elf32_arm_get_symbol_type (elf_sym
, type
)
2035 Elf_Internal_Sym
* elf_sym
;
2038 if (ELF_ST_TYPE (elf_sym
->st_info
) == STT_ARM_TFUNC
)
2039 return ELF_ST_TYPE (elf_sym
->st_info
);
2045 elf32_arm_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
2047 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2048 Elf_Internal_Rela
*rel
;
2049 struct elf_link_hash_entry
*h
;
2050 Elf_Internal_Sym
*sym
;
2054 switch (ELF32_R_TYPE (rel
->r_info
))
2056 case R_ARM_GNU_VTINHERIT
:
2057 case R_ARM_GNU_VTENTRY
:
2061 switch (h
->root
.type
)
2063 case bfd_link_hash_defined
:
2064 case bfd_link_hash_defweak
:
2065 return h
->root
.u
.def
.section
;
2067 case bfd_link_hash_common
:
2068 return h
->root
.u
.c
.p
->section
;
2077 if (!(elf_bad_symtab (abfd
)
2078 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
2079 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
2080 && sym
->st_shndx
!= SHN_COMMON
))
2082 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
2088 /* Update the got entry reference counts for the section being removed. */
2091 elf32_arm_gc_sweep_hook (abfd
, info
, sec
, relocs
)
2092 bfd
*abfd ATTRIBUTE_UNUSED
;
2093 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2094 asection
*sec ATTRIBUTE_UNUSED
;
2095 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
;
2097 /* We don't support garbage collection of GOT and PLT relocs yet. */
2101 /* Look through the relocs for a section during the first phase. */
2104 elf32_arm_check_relocs (abfd
, info
, sec
, relocs
)
2106 struct bfd_link_info
* info
;
2108 const Elf_Internal_Rela
* relocs
;
2110 Elf_Internal_Shdr
* symtab_hdr
;
2111 struct elf_link_hash_entry
** sym_hashes
;
2112 struct elf_link_hash_entry
** sym_hashes_end
;
2113 const Elf_Internal_Rela
* rel
;
2114 const Elf_Internal_Rela
* rel_end
;
2116 asection
* sgot
, *srelgot
, *sreloc
;
2117 bfd_vma
* local_got_offsets
;
2119 if (info
->relocateable
)
2122 sgot
= srelgot
= sreloc
= NULL
;
2124 dynobj
= elf_hash_table (info
)->dynobj
;
2125 local_got_offsets
= elf_local_got_offsets (abfd
);
2127 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2128 sym_hashes
= elf_sym_hashes (abfd
);
2129 sym_hashes_end
= sym_hashes
+ symtab_hdr
->sh_size
/sizeof(Elf32_External_Sym
);
2130 if (!elf_bad_symtab (abfd
))
2131 sym_hashes_end
-= symtab_hdr
->sh_info
;
2133 rel_end
= relocs
+ sec
->reloc_count
;
2134 for (rel
= relocs
; rel
< rel_end
; rel
++)
2136 struct elf_link_hash_entry
*h
;
2137 unsigned long r_symndx
;
2139 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2140 if (r_symndx
< symtab_hdr
->sh_info
)
2143 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2145 /* Some relocs require a global offset table. */
2148 switch (ELF32_R_TYPE (rel
->r_info
))
2153 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
2154 if (! _bfd_elf_create_got_section (dynobj
, info
))
2163 switch (ELF32_R_TYPE (rel
->r_info
))
2166 /* This symbol requires a global offset table entry. */
2169 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2170 BFD_ASSERT (sgot
!= NULL
);
2173 /* Get the got relocation section if necessary. */
2175 && (h
!= NULL
|| info
->shared
))
2177 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
2179 /* If no got relocation section, make one and initialize. */
2180 if (srelgot
== NULL
)
2182 srelgot
= bfd_make_section (dynobj
, ".rel.got");
2184 || ! bfd_set_section_flags (dynobj
, srelgot
,
2189 | SEC_LINKER_CREATED
2191 || ! bfd_set_section_alignment (dynobj
, srelgot
, 2))
2198 if (h
->got
.offset
!= (bfd_vma
) -1)
2199 /* We have already allocated space in the .got. */
2202 h
->got
.offset
= sgot
->_raw_size
;
2204 /* Make sure this symbol is output as a dynamic symbol. */
2205 if (h
->dynindx
== -1)
2206 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2209 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2213 /* This is a global offset table entry for a local
2215 if (local_got_offsets
== NULL
)
2218 register unsigned int i
;
2220 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
2221 local_got_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
2222 if (local_got_offsets
== NULL
)
2224 elf_local_got_offsets (abfd
) = local_got_offsets
;
2225 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
2226 local_got_offsets
[i
] = (bfd_vma
) -1;
2229 if (local_got_offsets
[r_symndx
] != (bfd_vma
) -1)
2230 /* We have already allocated space in the .got. */
2233 local_got_offsets
[r_symndx
] = sgot
->_raw_size
;
2236 /* If we are generating a shared object, we need to
2237 output a R_ARM_RELATIVE reloc so that the dynamic
2238 linker can adjust this GOT entry. */
2239 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2242 sgot
->_raw_size
+= 4;
2246 /* This symbol requires a procedure linkage table entry. We
2247 actually build the entry in adjust_dynamic_symbol,
2248 because this might be a case of linking PIC code which is
2249 never referenced by a dynamic object, in which case we
2250 don't need to generate a procedure linkage table entry
2253 /* If this is a local symbol, we resolve it directly without
2254 creating a procedure linkage table entry. */
2258 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2264 /* If we are creating a shared library, and this is a reloc
2265 against a global symbol, or a non PC relative reloc
2266 against a local symbol, then we need to copy the reloc
2267 into the shared library. However, if we are linking with
2268 -Bsymbolic, we do not need to copy a reloc against a
2269 global symbol which is defined in an object we are
2270 including in the link (i.e., DEF_REGULAR is set). At
2271 this point we have not seen all the input files, so it is
2272 possible that DEF_REGULAR is not set now but will be set
2273 later (it is never cleared). We account for that
2274 possibility below by storing information in the
2275 pcrel_relocs_copied field of the hash table entry. */
2277 && (ELF32_R_TYPE (rel
->r_info
) != R_ARM_PC24
2279 && (! info
->symbolic
2280 || (h
->elf_link_hash_flags
2281 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
2283 /* When creating a shared object, we must copy these
2284 reloc types into the output file. We create a reloc
2285 section in dynobj and make room for this reloc. */
2290 name
= (bfd_elf_string_from_elf_section
2292 elf_elfheader (abfd
)->e_shstrndx
,
2293 elf_section_data (sec
)->rel_hdr
.sh_name
));
2297 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
2298 && strcmp (bfd_get_section_name (abfd
, sec
),
2301 sreloc
= bfd_get_section_by_name (dynobj
, name
);
2306 sreloc
= bfd_make_section (dynobj
, name
);
2307 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
2308 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
2309 if ((sec
->flags
& SEC_ALLOC
) != 0)
2310 flags
|= SEC_ALLOC
| SEC_LOAD
;
2312 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
2313 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
2318 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
2319 /* If we are linking with -Bsymbolic, and this is a
2320 global symbol, we count the number of PC relative
2321 relocations we have entered for this symbol, so that
2322 we can discard them again if the symbol is later
2323 defined by a regular object. Note that this function
2324 is only called if we are using an elf_i386 linker
2325 hash table, which means that h is really a pointer to
2326 an elf_i386_link_hash_entry. */
2327 if (h
!= NULL
&& info
->symbolic
2328 && ELF32_R_TYPE (rel
->r_info
) == R_ARM_PC24
)
2330 struct elf32_arm_link_hash_entry
* eh
;
2331 struct elf32_arm_pcrel_relocs_copied
* p
;
2333 eh
= (struct elf32_arm_link_hash_entry
*) h
;
2335 for (p
= eh
->pcrel_relocs_copied
; p
!= NULL
; p
= p
->next
)
2336 if (p
->section
== sreloc
)
2341 p
= ((struct elf32_arm_pcrel_relocs_copied
*)
2342 bfd_alloc (dynobj
, sizeof * p
));
2346 p
->next
= eh
->pcrel_relocs_copied
;
2347 eh
->pcrel_relocs_copied
= p
;
2348 p
->section
= sreloc
;
2357 /* This relocation describes the C++ object vtable hierarchy.
2358 Reconstruct it for later use during GC. */
2359 case R_ARM_GNU_VTINHERIT
:
2360 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2364 /* This relocation describes which C++ vtable entries are actually
2365 used. Record for later use during GC. */
2366 case R_ARM_GNU_VTENTRY
:
2367 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
2377 /* Find the nearest line to a particular section and offset, for error
2378 reporting. This code is a duplicate of the code in elf.c, except
2379 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
2382 elf32_arm_find_nearest_line
2383 (abfd
, section
, symbols
, offset
, filename_ptr
, functionname_ptr
, line_ptr
)
2388 CONST
char ** filename_ptr
;
2389 CONST
char ** functionname_ptr
;
2390 unsigned int * line_ptr
;
2393 const char * filename
;
2398 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
2399 filename_ptr
, functionname_ptr
,
2403 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2404 &found
, filename_ptr
,
2405 functionname_ptr
, line_ptr
,
2406 &elf_tdata (abfd
)->line_info
))
2412 if (symbols
== NULL
)
2419 for (p
= symbols
; *p
!= NULL
; p
++)
2423 q
= (elf_symbol_type
*) *p
;
2425 if (bfd_get_section (&q
->symbol
) != section
)
2428 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
2433 filename
= bfd_asymbol_name (&q
->symbol
);
2438 if (q
->symbol
.section
== section
2439 && q
->symbol
.value
>= low_func
2440 && q
->symbol
.value
<= offset
)
2442 func
= (asymbol
*) q
;
2443 low_func
= q
->symbol
.value
;
2452 *filename_ptr
= filename
;
2453 *functionname_ptr
= bfd_asymbol_name (func
);
2459 /* Adjust a symbol defined by a dynamic object and referenced by a
2460 regular object. The current definition is in some section of the
2461 dynamic object, but we're not including those sections. We have to
2462 change the definition to something the rest of the link can
2466 elf32_arm_adjust_dynamic_symbol (info
, h
)
2467 struct bfd_link_info
* info
;
2468 struct elf_link_hash_entry
* h
;
2472 unsigned int power_of_two
;
2474 dynobj
= elf_hash_table (info
)->dynobj
;
2476 /* Make sure we know what is going on here. */
2477 BFD_ASSERT (dynobj
!= NULL
2478 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
2479 || h
->weakdef
!= NULL
2480 || ((h
->elf_link_hash_flags
2481 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2482 && (h
->elf_link_hash_flags
2483 & ELF_LINK_HASH_REF_REGULAR
) != 0
2484 && (h
->elf_link_hash_flags
2485 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
2487 /* If this is a function, put it in the procedure linkage table. We
2488 will fill in the contents of the procedure linkage table later,
2489 when we know the address of the .got section. */
2490 if (h
->type
== STT_FUNC
2491 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
2494 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
2495 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0)
2497 /* This case can occur if we saw a PLT32 reloc in an input
2498 file, but the symbol was never referred to by a dynamic
2499 object. In such a case, we don't actually need to build
2500 a procedure linkage table, and we can just do a PC32
2502 BFD_ASSERT ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0);
2506 /* Make sure this symbol is output as a dynamic symbol. */
2507 if (h
->dynindx
== -1)
2509 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2513 s
= bfd_get_section_by_name (dynobj
, ".plt");
2514 BFD_ASSERT (s
!= NULL
);
2516 /* If this is the first .plt entry, make room for the special
2518 if (s
->_raw_size
== 0)
2519 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2521 /* If this symbol is not defined in a regular file, and we are
2522 not generating a shared library, then set the symbol to this
2523 location in the .plt. This is required to make function
2524 pointers compare as equal between the normal executable and
2525 the shared library. */
2527 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2529 h
->root
.u
.def
.section
= s
;
2530 h
->root
.u
.def
.value
= s
->_raw_size
;
2533 h
->plt
.offset
= s
->_raw_size
;
2535 /* Make room for this entry. */
2536 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2538 /* We also need to make an entry in the .got.plt section, which
2539 will be placed in the .got section by the linker script. */
2541 s
= bfd_get_section_by_name (dynobj
, ".got.plt");
2542 BFD_ASSERT (s
!= NULL
);
2545 /* We also need to make an entry in the .rel.plt section. */
2547 s
= bfd_get_section_by_name (dynobj
, ".rel.plt");
2548 BFD_ASSERT (s
!= NULL
);
2549 s
->_raw_size
+= sizeof (Elf32_External_Rel
);
2554 /* If this is a weak symbol, and there is a real definition, the
2555 processor independent code will have arranged for us to see the
2556 real definition first, and we can just use the same value. */
2557 if (h
->weakdef
!= NULL
)
2559 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
2560 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
2561 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
2562 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
2566 /* This is a reference to a symbol defined by a dynamic object which
2567 is not a function. */
2569 /* If we are creating a shared library, we must presume that the
2570 only references to the symbol are via the global offset table.
2571 For such cases we need not do anything here; the relocations will
2572 be handled correctly by relocate_section. */
2576 /* We must allocate the symbol in our .dynbss section, which will
2577 become part of the .bss section of the executable. There will be
2578 an entry for this symbol in the .dynsym section. The dynamic
2579 object will contain position independent code, so all references
2580 from the dynamic object to this symbol will go through the global
2581 offset table. The dynamic linker will use the .dynsym entry to
2582 determine the address it must put in the global offset table, so
2583 both the dynamic object and the regular object will refer to the
2584 same memory location for the variable. */
2586 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
2587 BFD_ASSERT (s
!= NULL
);
2589 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
2590 copy the initial value out of the dynamic object and into the
2591 runtime process image. We need to remember the offset into the
2592 .rel.bss section we are going to use. */
2593 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2597 srel
= bfd_get_section_by_name (dynobj
, ".rel.bss");
2598 BFD_ASSERT (srel
!= NULL
);
2599 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
2600 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
2603 /* We need to figure out the alignment required for this symbol. I
2604 have no idea how ELF linkers handle this. */
2605 power_of_two
= bfd_log2 (h
->size
);
2606 if (power_of_two
> 3)
2609 /* Apply the required alignment. */
2610 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
2611 (bfd_size_type
) (1 << power_of_two
));
2612 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
2614 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
2618 /* Define the symbol as being at this point in the section. */
2619 h
->root
.u
.def
.section
= s
;
2620 h
->root
.u
.def
.value
= s
->_raw_size
;
2622 /* Increment the section size to make room for the symbol. */
2623 s
->_raw_size
+= h
->size
;
2628 /* Set the sizes of the dynamic sections. */
2631 elf32_arm_size_dynamic_sections (output_bfd
, info
)
2633 struct bfd_link_info
* info
;
2641 dynobj
= elf_hash_table (info
)->dynobj
;
2642 BFD_ASSERT (dynobj
!= NULL
);
2644 if (elf_hash_table (info
)->dynamic_sections_created
)
2646 /* Set the contents of the .interp section to the interpreter. */
2649 s
= bfd_get_section_by_name (dynobj
, ".interp");
2650 BFD_ASSERT (s
!= NULL
);
2651 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2652 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2657 /* We may have created entries in the .rel.got section.
2658 However, if we are not creating the dynamic sections, we will
2659 not actually use these entries. Reset the size of .rel.got,
2660 which will cause it to get stripped from the output file
2662 s
= bfd_get_section_by_name (dynobj
, ".rel.got");
2667 /* If this is a -Bsymbolic shared link, then we need to discard all
2668 PC relative relocs against symbols defined in a regular object.
2669 We allocated space for them in the check_relocs routine, but we
2670 will not fill them in in the relocate_section routine. */
2671 if (info
->shared
&& info
->symbolic
)
2672 elf32_arm_link_hash_traverse (elf32_arm_hash_table (info
),
2673 elf32_arm_discard_copies
,
2676 /* The check_relocs and adjust_dynamic_symbol entry points have
2677 determined the sizes of the various dynamic sections. Allocate
2682 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2687 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2690 /* It's OK to base decisions on the section name, because none
2691 of the dynobj section names depend upon the input files. */
2692 name
= bfd_get_section_name (dynobj
, s
);
2696 if (strcmp (name
, ".plt") == 0)
2698 if (s
->_raw_size
== 0)
2700 /* Strip this section if we don't need it; see the
2706 /* Remember whether there is a PLT. */
2710 else if (strncmp (name
, ".rel", 4) == 0)
2712 if (s
->_raw_size
== 0)
2714 /* If we don't need this section, strip it from the
2715 output file. This is mostly to handle .rel.bss and
2716 .rel.plt. We must create both sections in
2717 create_dynamic_sections, because they must be created
2718 before the linker maps input sections to output
2719 sections. The linker does that before
2720 adjust_dynamic_symbol is called, and it is that
2721 function which decides whether anything needs to go
2722 into these sections. */
2729 /* Remember whether there are any reloc sections other
2731 if (strcmp (name
, ".rel.plt") != 0)
2733 const char *outname
;
2737 /* If this relocation section applies to a read only
2738 section, then we probably need a DT_TEXTREL
2739 entry. The entries in the .rel.plt section
2740 really apply to the .got section, which we
2741 created ourselves and so know is not readonly. */
2742 outname
= bfd_get_section_name (output_bfd
,
2744 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
2746 && (target
->flags
& SEC_READONLY
) != 0
2747 && (target
->flags
& SEC_ALLOC
) != 0)
2751 /* We use the reloc_count field as a counter if we need
2752 to copy relocs into the output file. */
2756 else if (strncmp (name
, ".got", 4) != 0)
2758 /* It's not one of our sections, so don't allocate space. */
2766 for (spp
= &s
->output_section
->owner
->sections
;
2767 *spp
!= s
->output_section
;
2768 spp
= &(*spp
)->next
)
2770 *spp
= s
->output_section
->next
;
2771 --s
->output_section
->owner
->section_count
;
2776 /* Allocate memory for the section contents. */
2777 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
2778 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
2782 if (elf_hash_table (info
)->dynamic_sections_created
)
2784 /* Add some entries to the .dynamic section. We fill in the
2785 values later, in elf32_arm_finish_dynamic_sections, but we
2786 must add the entries now so that we get the correct size for
2787 the .dynamic section. The DT_DEBUG entry is filled in by the
2788 dynamic linker and used by the debugger. */
2791 if (! bfd_elf32_add_dynamic_entry (info
, DT_DEBUG
, 0))
2797 if (! bfd_elf32_add_dynamic_entry (info
, DT_PLTGOT
, 0)
2798 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
2799 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTREL
, DT_REL
)
2800 || ! bfd_elf32_add_dynamic_entry (info
, DT_JMPREL
, 0))
2806 if (! bfd_elf32_add_dynamic_entry (info
, DT_REL
, 0)
2807 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELSZ
, 0)
2808 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELENT
,
2809 sizeof (Elf32_External_Rel
)))
2815 if (! bfd_elf32_add_dynamic_entry (info
, DT_TEXTREL
, 0))
2823 /* This function is called via elf32_arm_link_hash_traverse if we are
2824 creating a shared object with -Bsymbolic. It discards the space
2825 allocated to copy PC relative relocs against symbols which are
2826 defined in regular objects. We allocated space for them in the
2827 check_relocs routine, but we won't fill them in in the
2828 relocate_section routine. */
2831 elf32_arm_discard_copies (h
, ignore
)
2832 struct elf32_arm_link_hash_entry
* h
;
2833 PTR ignore ATTRIBUTE_UNUSED
;
2835 struct elf32_arm_pcrel_relocs_copied
* s
;
2837 /* We only discard relocs for symbols defined in a regular object. */
2838 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2841 for (s
= h
->pcrel_relocs_copied
; s
!= NULL
; s
= s
->next
)
2842 s
->section
->_raw_size
-= s
->count
* sizeof (Elf32_External_Rel
);
2847 /* Finish up dynamic symbol handling. We set the contents of various
2848 dynamic sections here. */
2851 elf32_arm_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
2853 struct bfd_link_info
* info
;
2854 struct elf_link_hash_entry
* h
;
2855 Elf_Internal_Sym
* sym
;
2859 dynobj
= elf_hash_table (info
)->dynobj
;
2861 if (h
->plt
.offset
!= (bfd_vma
) -1)
2868 Elf_Internal_Rel rel
;
2870 /* This symbol has an entry in the procedure linkage table. Set
2873 BFD_ASSERT (h
->dynindx
!= -1);
2875 splt
= bfd_get_section_by_name (dynobj
, ".plt");
2876 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
2877 srel
= bfd_get_section_by_name (dynobj
, ".rel.plt");
2878 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
2880 /* Get the index in the procedure linkage table which
2881 corresponds to this symbol. This is the index of this symbol
2882 in all the symbols for which we are making plt entries. The
2883 first entry in the procedure linkage table is reserved. */
2884 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
2886 /* Get the offset into the .got table of the entry that
2887 corresponds to this function. Each .got entry is 4 bytes.
2888 The first three are reserved. */
2889 got_offset
= (plt_index
+ 3) * 4;
2891 /* Fill in the entry in the procedure linkage table. */
2892 memcpy (splt
->contents
+ h
->plt
.offset
,
2893 elf32_arm_plt_entry
,
2895 bfd_put_32 (output_bfd
,
2896 (sgot
->output_section
->vma
2897 + sgot
->output_offset
2899 - splt
->output_section
->vma
2900 - splt
->output_offset
2901 - h
->plt
.offset
- 12),
2902 splt
->contents
+ h
->plt
.offset
+ 12);
2904 /* Fill in the entry in the global offset table. */
2905 bfd_put_32 (output_bfd
,
2906 (splt
->output_section
->vma
2907 + splt
->output_offset
),
2908 sgot
->contents
+ got_offset
);
2910 /* Fill in the entry in the .rel.plt section. */
2911 rel
.r_offset
= (sgot
->output_section
->vma
2912 + sgot
->output_offset
2914 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_JUMP_SLOT
);
2915 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
2916 ((Elf32_External_Rel
*) srel
->contents
2919 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2921 /* Mark the symbol as undefined, rather than as defined in
2922 the .plt section. Leave the value alone. */
2923 sym
->st_shndx
= SHN_UNDEF
;
2927 if (h
->got
.offset
!= (bfd_vma
) -1)
2931 Elf_Internal_Rel rel
;
2933 /* This symbol has an entry in the global offset table. Set it
2936 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2937 srel
= bfd_get_section_by_name (dynobj
, ".rel.got");
2938 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
2940 rel
.r_offset
= (sgot
->output_section
->vma
2941 + sgot
->output_offset
2942 + (h
->got
.offset
&~ 1));
2944 /* If this is a -Bsymbolic link, and the symbol is defined
2945 locally, we just want to emit a RELATIVE reloc. The entry in
2946 the global offset table will already have been initialized in
2947 the relocate_section function. */
2949 && (info
->symbolic
|| h
->dynindx
== -1)
2950 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
2951 rel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
2954 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
2955 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_GLOB_DAT
);
2958 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
2959 ((Elf32_External_Rel
*) srel
->contents
2960 + srel
->reloc_count
));
2961 ++srel
->reloc_count
;
2964 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
2967 Elf_Internal_Rel rel
;
2969 /* This symbol needs a copy reloc. Set it up. */
2971 BFD_ASSERT (h
->dynindx
!= -1
2972 && (h
->root
.type
== bfd_link_hash_defined
2973 || h
->root
.type
== bfd_link_hash_defweak
));
2975 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
2977 BFD_ASSERT (s
!= NULL
);
2979 rel
.r_offset
= (h
->root
.u
.def
.value
2980 + h
->root
.u
.def
.section
->output_section
->vma
2981 + h
->root
.u
.def
.section
->output_offset
);
2982 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_COPY
);
2983 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
2984 ((Elf32_External_Rel
*) s
->contents
2989 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2990 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2991 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2992 sym
->st_shndx
= SHN_ABS
;
2997 /* Finish up the dynamic sections. */
3000 elf32_arm_finish_dynamic_sections (output_bfd
, info
)
3002 struct bfd_link_info
* info
;
3008 dynobj
= elf_hash_table (info
)->dynobj
;
3010 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3011 BFD_ASSERT (sgot
!= NULL
);
3012 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3014 if (elf_hash_table (info
)->dynamic_sections_created
)
3017 Elf32_External_Dyn
*dyncon
, *dynconend
;
3019 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3020 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3022 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3023 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
3024 for (; dyncon
< dynconend
; dyncon
++)
3026 Elf_Internal_Dyn dyn
;
3030 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3043 s
= bfd_get_section_by_name (output_bfd
, name
);
3044 BFD_ASSERT (s
!= NULL
);
3045 dyn
.d_un
.d_ptr
= s
->vma
;
3046 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3050 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3051 BFD_ASSERT (s
!= NULL
);
3052 if (s
->_cooked_size
!= 0)
3053 dyn
.d_un
.d_val
= s
->_cooked_size
;
3055 dyn
.d_un
.d_val
= s
->_raw_size
;
3056 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3060 /* My reading of the SVR4 ABI indicates that the
3061 procedure linkage table relocs (DT_JMPREL) should be
3062 included in the overall relocs (DT_REL). This is
3063 what Solaris does. However, UnixWare can not handle
3064 that case. Therefore, we override the DT_RELSZ entry
3065 here to make it not include the JMPREL relocs. Since
3066 the linker script arranges for .rel.plt to follow all
3067 other relocation sections, we don't have to worry
3068 about changing the DT_REL entry. */
3069 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3072 if (s
->_cooked_size
!= 0)
3073 dyn
.d_un
.d_val
-= s
->_cooked_size
;
3075 dyn
.d_un
.d_val
-= s
->_raw_size
;
3077 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3082 /* Fill in the first entry in the procedure linkage table. */
3083 if (splt
->_raw_size
> 0)
3084 memcpy (splt
->contents
, elf32_arm_plt0_entry
, PLT_ENTRY_SIZE
);
3086 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3087 really seem like the right value. */
3088 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
3091 /* Fill in the first three entries in the global offset table. */
3092 if (sgot
->_raw_size
> 0)
3095 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
3097 bfd_put_32 (output_bfd
,
3098 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3100 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
3101 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
3104 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
3110 elf32_arm_post_process_headers (abfd
, link_info
)
3112 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
;
3114 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form */
3116 i_ehdrp
= elf_elfheader (abfd
);
3118 i_ehdrp
->e_ident
[EI_OSABI
] = ARM_ELF_OS_ABI_VERSION
;
3119 i_ehdrp
->e_ident
[EI_ABIVERSION
] = ARM_ELF_ABI_VERSION
;
3123 #define ELF_ARCH bfd_arch_arm
3124 #define ELF_MACHINE_CODE EM_ARM
3125 #define ELF_MAXPAGESIZE 0x8000
3128 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
3129 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
3130 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
3131 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
3132 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
3133 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
3134 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
3136 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
3137 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
3138 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
3139 #define elf_backend_check_relocs elf32_arm_check_relocs
3140 #define elf_backend_relocate_section elf32_arm_relocate_section
3141 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
3142 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
3143 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
3144 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
3145 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
3146 #define elf_backend_post_process_headers elf32_arm_post_process_headers
3148 #define elf_backend_can_gc_sections 1
3149 #define elf_backend_plt_readonly 1
3150 #define elf_backend_want_got_plt 1
3151 #define elf_backend_want_plt_sym 0
3153 #define elf_backend_got_header_size 12
3154 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
3156 #include "elf32-target.h"