1 /* 32-bit ELF support for ARM
2 Copyright 1998, 1999, 2000, 2001 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. */
20 typedef unsigned long int insn32
;
21 typedef unsigned short int insn16
;
23 static boolean elf32_arm_set_private_flags
24 PARAMS ((bfd
*, flagword
));
25 static boolean elf32_arm_copy_private_bfd_data
26 PARAMS ((bfd
*, bfd
*));
27 static boolean elf32_arm_merge_private_bfd_data
28 PARAMS ((bfd
*, bfd
*));
29 static boolean elf32_arm_print_private_bfd_data
30 PARAMS ((bfd
*, PTR
));
31 static int elf32_arm_get_symbol_type
32 PARAMS (( Elf_Internal_Sym
*, int));
33 static struct bfd_link_hash_table
*elf32_arm_link_hash_table_create
35 static bfd_reloc_status_type elf32_arm_final_link_relocate
36 PARAMS ((reloc_howto_type
*, bfd
*, bfd
*, asection
*, bfd_byte
*,
37 Elf_Internal_Rela
*, bfd_vma
, struct bfd_link_info
*, asection
*,
38 const char *, unsigned char, struct elf_link_hash_entry
*));
39 static insn32 insert_thumb_branch
40 PARAMS ((insn32
, int));
41 static struct elf_link_hash_entry
*find_thumb_glue
42 PARAMS ((struct bfd_link_info
*, CONST
char *, bfd
*));
43 static struct elf_link_hash_entry
*find_arm_glue
44 PARAMS ((struct bfd_link_info
*, CONST
char *, bfd
*));
45 static void record_arm_to_thumb_glue
46 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
47 static void record_thumb_to_arm_glue
48 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
49 static void elf32_arm_post_process_headers
50 PARAMS ((bfd
*, struct bfd_link_info
*));
51 static int elf32_arm_to_thumb_stub
52 PARAMS ((struct bfd_link_info
*, const char *, bfd
*, bfd
*, asection
*,
53 bfd_byte
*, asection
*, bfd_vma
, bfd_signed_vma
, bfd_vma
));
54 static int elf32_thumb_to_arm_stub
55 PARAMS ((struct bfd_link_info
*, const char *, bfd
*, bfd
*, asection
*,
56 bfd_byte
*, asection
*, bfd_vma
, bfd_signed_vma
, bfd_vma
));
58 #define INTERWORK_FLAG(abfd) (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK)
60 /* The linker script knows the section names for placement.
61 The entry_names are used to do simple name mangling on the stubs.
62 Given a function name, and its type, the stub can be found. The
63 name can be changed. The only requirement is the %s be present. */
64 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
65 #define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
67 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
68 #define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
70 /* The name of the dynamic interpreter. This is put in the .interp
72 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
74 /* The size in bytes of an entry in the procedure linkage table. */
75 #define PLT_ENTRY_SIZE 16
77 /* The first entry in a procedure linkage table looks like
78 this. It is set up so that any shared library function that is
79 called before the relocation has been set up calls 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, #8]! */
89 /* Subsequent entries in a procedure linkage table look like
91 static const bfd_byte elf32_arm_plt_entry
[PLT_ENTRY_SIZE
] =
93 0x04, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc, #4] */
94 0x0c, 0xc0, 0x8f, 0xe0, /* add ip, pc, ip */
95 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
96 0x00, 0x00, 0x00, 0x00 /* offset to symbol in got */
99 /* The ARM linker needs to keep track of the number of relocs that it
100 decides to copy in check_relocs for each symbol. This is so that
101 it can discard PC relative relocs if it doesn't need them when
102 linking with -Bsymbolic. We store the information in a field
103 extending the regular ELF linker hash table. */
105 /* This structure keeps track of the number of PC relative relocs we
106 have copied for a given symbol. */
107 struct elf32_arm_pcrel_relocs_copied
110 struct elf32_arm_pcrel_relocs_copied
* next
;
111 /* A section in dynobj. */
113 /* Number of relocs copied in this section. */
117 /* Arm ELF linker hash entry. */
118 struct elf32_arm_link_hash_entry
120 struct elf_link_hash_entry root
;
122 /* Number of PC relative relocs copied for this symbol. */
123 struct elf32_arm_pcrel_relocs_copied
* pcrel_relocs_copied
;
126 /* Declare this now that the above structures are defined. */
127 static boolean elf32_arm_discard_copies
128 PARAMS ((struct elf32_arm_link_hash_entry
*, PTR
));
130 /* Traverse an arm ELF linker hash table. */
131 #define elf32_arm_link_hash_traverse(table, func, info) \
132 (elf_link_hash_traverse \
134 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
137 /* Get the ARM elf linker hash table from a link_info structure. */
138 #define elf32_arm_hash_table(info) \
139 ((struct elf32_arm_link_hash_table *) ((info)->hash))
141 /* ARM ELF linker hash table. */
142 struct elf32_arm_link_hash_table
144 /* The main hash table. */
145 struct elf_link_hash_table root
;
147 /* The size in bytes of the section containg the Thumb-to-ARM glue. */
148 long int thumb_glue_size
;
150 /* The size in bytes of the section containg the ARM-to-Thumb glue. */
151 long int arm_glue_size
;
153 /* An arbitary input BFD chosen to hold the glue sections. */
154 bfd
* bfd_of_glue_owner
;
156 /* A boolean indicating whether knowledge of the ARM's pipeline
157 length should be applied by the linker. */
158 int no_pipeline_knowledge
;
161 /* Create an entry in an ARM ELF linker hash table. */
163 static struct bfd_hash_entry
*
164 elf32_arm_link_hash_newfunc (entry
, table
, string
)
165 struct bfd_hash_entry
* entry
;
166 struct bfd_hash_table
* table
;
169 struct elf32_arm_link_hash_entry
* ret
=
170 (struct elf32_arm_link_hash_entry
*) entry
;
172 /* Allocate the structure if it has not already been allocated by a
174 if (ret
== (struct elf32_arm_link_hash_entry
*) NULL
)
175 ret
= ((struct elf32_arm_link_hash_entry
*)
176 bfd_hash_allocate (table
,
177 sizeof (struct elf32_arm_link_hash_entry
)));
178 if (ret
== (struct elf32_arm_link_hash_entry
*) NULL
)
179 return (struct bfd_hash_entry
*) ret
;
181 /* Call the allocation method of the superclass. */
182 ret
= ((struct elf32_arm_link_hash_entry
*)
183 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
185 if (ret
!= (struct elf32_arm_link_hash_entry
*) NULL
)
186 ret
->pcrel_relocs_copied
= NULL
;
188 return (struct bfd_hash_entry
*) ret
;
191 /* Create an ARM elf linker hash table. */
193 static struct bfd_link_hash_table
*
194 elf32_arm_link_hash_table_create (abfd
)
197 struct elf32_arm_link_hash_table
*ret
;
199 ret
= ((struct elf32_arm_link_hash_table
*)
200 bfd_alloc (abfd
, sizeof (struct elf32_arm_link_hash_table
)));
201 if (ret
== (struct elf32_arm_link_hash_table
*) NULL
)
204 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
205 elf32_arm_link_hash_newfunc
))
207 bfd_release (abfd
, ret
);
211 ret
->thumb_glue_size
= 0;
212 ret
->arm_glue_size
= 0;
213 ret
->bfd_of_glue_owner
= NULL
;
214 ret
->no_pipeline_knowledge
= 0;
216 return &ret
->root
.root
;
219 /* Locate the Thumb encoded calling stub for NAME. */
221 static struct elf_link_hash_entry
*
222 find_thumb_glue (link_info
, name
, input_bfd
)
223 struct bfd_link_info
*link_info
;
228 struct elf_link_hash_entry
*hash
;
229 struct elf32_arm_link_hash_table
*hash_table
;
231 /* We need a pointer to the armelf specific hash table. */
232 hash_table
= elf32_arm_hash_table (link_info
);
235 bfd_malloc (strlen (name
) + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1));
237 BFD_ASSERT (tmp_name
);
239 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
241 hash
= elf_link_hash_lookup
242 (&(hash_table
)->root
, tmp_name
, false, false, true);
245 /* xgettext:c-format */
246 _bfd_error_handler (_("%s: unable to find THUMB glue '%s' for `%s'"),
247 bfd_get_filename (input_bfd
), tmp_name
, name
);
254 /* Locate the ARM encoded calling stub for NAME. */
256 static struct elf_link_hash_entry
*
257 find_arm_glue (link_info
, name
, input_bfd
)
258 struct bfd_link_info
*link_info
;
263 struct elf_link_hash_entry
*myh
;
264 struct elf32_arm_link_hash_table
*hash_table
;
266 /* We need a pointer to the elfarm specific hash table. */
267 hash_table
= elf32_arm_hash_table (link_info
);
270 bfd_malloc (strlen (name
) + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1));
272 BFD_ASSERT (tmp_name
);
274 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
276 myh
= elf_link_hash_lookup
277 (&(hash_table
)->root
, tmp_name
, false, false, true);
280 /* xgettext:c-format */
281 _bfd_error_handler (_("%s: unable to find ARM glue '%s' for `%s'"),
282 bfd_get_filename (input_bfd
), tmp_name
, name
);
296 .word func @ behave as if you saw a ARM_32 reloc. */
298 #define ARM2THUMB_GLUE_SIZE 12
299 static const insn32 a2t1_ldr_insn
= 0xe59fc000;
300 static const insn32 a2t2_bx_r12_insn
= 0xe12fff1c;
301 static const insn32 a2t3_func_addr_insn
= 0x00000001;
303 /* Thumb->ARM: Thumb->(non-interworking aware) ARM
307 __func_from_thumb: __func_from_thumb:
309 nop ldr r6, __func_addr
311 __func_change_to_arm: bx r6
313 __func_back_to_thumb:
319 #define THUMB2ARM_GLUE_SIZE 8
320 static const insn16 t2a1_bx_pc_insn
= 0x4778;
321 static const insn16 t2a2_noop_insn
= 0x46c0;
322 static const insn32 t2a3_b_insn
= 0xea000000;
324 static const insn16 t2a1_push_insn
= 0xb540;
325 static const insn16 t2a2_ldr_insn
= 0x4e03;
326 static const insn16 t2a3_mov_insn
= 0x46fe;
327 static const insn16 t2a4_bx_insn
= 0x4730;
328 static const insn32 t2a5_pop_insn
= 0xe8bd4040;
329 static const insn32 t2a6_bx_insn
= 0xe12fff1e;
332 bfd_elf32_arm_allocate_interworking_sections (info
)
333 struct bfd_link_info
* info
;
337 struct elf32_arm_link_hash_table
* globals
;
339 globals
= elf32_arm_hash_table (info
);
341 BFD_ASSERT (globals
!= NULL
);
343 if (globals
->arm_glue_size
!= 0)
345 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
347 s
= bfd_get_section_by_name
348 (globals
->bfd_of_glue_owner
, ARM2THUMB_GLUE_SECTION_NAME
);
350 BFD_ASSERT (s
!= NULL
);
352 foo
= (bfd_byte
*) bfd_alloc
353 (globals
->bfd_of_glue_owner
, globals
->arm_glue_size
);
355 s
->_raw_size
= s
->_cooked_size
= globals
->arm_glue_size
;
359 if (globals
->thumb_glue_size
!= 0)
361 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
363 s
= bfd_get_section_by_name
364 (globals
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
366 BFD_ASSERT (s
!= NULL
);
368 foo
= (bfd_byte
*) bfd_alloc
369 (globals
->bfd_of_glue_owner
, globals
->thumb_glue_size
);
371 s
->_raw_size
= s
->_cooked_size
= globals
->thumb_glue_size
;
379 record_arm_to_thumb_glue (link_info
, h
)
380 struct bfd_link_info
* link_info
;
381 struct elf_link_hash_entry
* h
;
383 const char * name
= h
->root
.root
.string
;
384 register asection
* s
;
386 struct elf_link_hash_entry
* myh
;
387 struct elf32_arm_link_hash_table
* globals
;
389 globals
= elf32_arm_hash_table (link_info
);
391 BFD_ASSERT (globals
!= NULL
);
392 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
394 s
= bfd_get_section_by_name
395 (globals
->bfd_of_glue_owner
, ARM2THUMB_GLUE_SECTION_NAME
);
397 BFD_ASSERT (s
!= NULL
);
400 bfd_malloc (strlen (name
) + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1));
402 BFD_ASSERT (tmp_name
);
404 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
406 myh
= elf_link_hash_lookup
407 (&(globals
)->root
, tmp_name
, false, false, true);
411 /* We've already seen this guy. */
416 /* The only trick here is using hash_table->arm_glue_size as the value. Even
417 though the section isn't allocated yet, this is where we will be putting
419 _bfd_generic_link_add_one_symbol (link_info
, globals
->bfd_of_glue_owner
, tmp_name
,
421 s
, globals
->arm_glue_size
+ 1,
423 (struct bfd_link_hash_entry
**) &myh
);
427 globals
->arm_glue_size
+= ARM2THUMB_GLUE_SIZE
;
433 record_thumb_to_arm_glue (link_info
, h
)
434 struct bfd_link_info
*link_info
;
435 struct elf_link_hash_entry
*h
;
437 const char *name
= h
->root
.root
.string
;
438 register asection
*s
;
440 struct elf_link_hash_entry
*myh
;
441 struct elf32_arm_link_hash_table
*hash_table
;
444 hash_table
= elf32_arm_hash_table (link_info
);
446 BFD_ASSERT (hash_table
!= NULL
);
447 BFD_ASSERT (hash_table
->bfd_of_glue_owner
!= NULL
);
449 s
= bfd_get_section_by_name
450 (hash_table
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
452 BFD_ASSERT (s
!= NULL
);
454 tmp_name
= (char *) bfd_malloc (strlen (name
) + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1);
456 BFD_ASSERT (tmp_name
);
458 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
460 myh
= elf_link_hash_lookup
461 (&(hash_table
)->root
, tmp_name
, false, false, true);
465 /* We've already seen this guy. */
470 _bfd_generic_link_add_one_symbol (link_info
, hash_table
->bfd_of_glue_owner
, tmp_name
,
471 BSF_GLOBAL
, s
, hash_table
->thumb_glue_size
+ 1,
473 (struct bfd_link_hash_entry
**) &myh
);
475 /* If we mark it 'Thumb', the disassembler will do a better job. */
476 bind
= ELF_ST_BIND (myh
->type
);
477 myh
->type
= ELF_ST_INFO (bind
, STT_ARM_TFUNC
);
481 #define CHANGE_TO_ARM "__%s_change_to_arm"
482 #define BACK_FROM_ARM "__%s_back_from_arm"
484 /* Allocate another symbol to mark where we switch to Arm mode. */
485 tmp_name
= (char *) bfd_malloc (strlen (name
) + strlen (CHANGE_TO_ARM
) + 1);
487 BFD_ASSERT (tmp_name
);
489 sprintf (tmp_name
, CHANGE_TO_ARM
, name
);
493 _bfd_generic_link_add_one_symbol (link_info
, hash_table
->bfd_of_glue_owner
, tmp_name
,
494 BSF_LOCAL
, s
, hash_table
->thumb_glue_size
+ 4,
496 (struct bfd_link_hash_entry
**) &myh
);
500 hash_table
->thumb_glue_size
+= THUMB2ARM_GLUE_SIZE
;
505 /* Select a BFD to be used to hold the sections used by the glue code.
506 This function is called from the linker scripts in ld/emultempl/
510 bfd_elf32_arm_get_bfd_for_interworking (abfd
, info
)
512 struct bfd_link_info
*info
;
514 struct elf32_arm_link_hash_table
*globals
;
518 /* If we are only performing a partial link do not bother
519 getting a bfd to hold the glue. */
520 if (info
->relocateable
)
523 globals
= elf32_arm_hash_table (info
);
525 BFD_ASSERT (globals
!= NULL
);
527 if (globals
->bfd_of_glue_owner
!= NULL
)
530 sec
= bfd_get_section_by_name (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
534 /* Note: we do not include the flag SEC_LINKER_CREATED, as this
535 will prevent elf_link_input_bfd() from processing the contents
537 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_CODE
| SEC_READONLY
;
539 sec
= bfd_make_section (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
542 || !bfd_set_section_flags (abfd
, sec
, flags
)
543 || !bfd_set_section_alignment (abfd
, sec
, 2))
546 /* Set the gc mark to prevent the section from being removed by garbage
547 collection, despite the fact that no relocs refer to this section. */
551 sec
= bfd_get_section_by_name (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
555 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_CODE
| SEC_READONLY
;
557 sec
= bfd_make_section (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
560 || !bfd_set_section_flags (abfd
, sec
, flags
)
561 || !bfd_set_section_alignment (abfd
, sec
, 2))
567 /* Save the bfd for later use. */
568 globals
->bfd_of_glue_owner
= abfd
;
574 bfd_elf32_arm_process_before_allocation (abfd
, link_info
, no_pipeline_knowledge
)
576 struct bfd_link_info
*link_info
;
577 int no_pipeline_knowledge
;
579 Elf_Internal_Shdr
*symtab_hdr
;
580 Elf_Internal_Rela
*free_relocs
= NULL
;
581 Elf_Internal_Rela
*irel
, *irelend
;
582 bfd_byte
*contents
= NULL
;
583 bfd_byte
*free_contents
= NULL
;
584 Elf32_External_Sym
*extsyms
= NULL
;
585 Elf32_External_Sym
*free_extsyms
= NULL
;
588 struct elf32_arm_link_hash_table
*globals
;
590 /* If we are only performing a partial link do not bother
591 to construct any glue. */
592 if (link_info
->relocateable
)
595 /* Here we have a bfd that is to be included on the link. We have a hook
596 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
;
617 /* 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
)
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
));
674 free_extsyms
= extsyms
;
676 if (bfd_seek (abfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
677 || (bfd_read (extsyms
, 1, symtab_hdr
->sh_size
, abfd
)
678 != symtab_hdr
->sh_size
))
683 /* If the relocation is not against a symbol it cannot concern us. */
686 /* We don't care about local symbols. */
687 if (r_index
< symtab_hdr
->sh_info
)
690 /* This is an external symbol. */
691 r_index
-= symtab_hdr
->sh_info
;
692 h
= (struct elf_link_hash_entry
*)
693 elf_sym_hashes (abfd
)[r_index
];
695 /* If the relocation is against a static symbol it must be within
696 the current section and so cannot be a cross ARM/Thumb relocation. */
703 /* This one is a call from arm code. We need to look up
704 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. */
714 if (ELF_ST_TYPE (h
->type
) != STT_ARM_TFUNC
)
715 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
;
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 /* FIXME: abort is probably not the right call. krk@cygnus.com */
788 abort (); /* error - not a valid branch instruction form. */
793 /* 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
;
806 bfd_signed_vma addend
;
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 /* Address of destination of the stub. */
861 ((bfd_signed_vma
) val
)
863 /* Offset from the start of the current section to the start of the stubs. */
865 /* Offset of the start of this stub from the start of the stubs. */
867 /* Address of the start of the current section. */
868 + s
->output_section
->vma
)
869 /* The branch instruction is 4 bytes into the stub. */
871 /* ARM branches work from the pc of the instruction + 8. */
874 bfd_put_32 (output_bfd
,
875 t2a3_b_insn
| ((ret_offset
>> 2) & 0x00FFFFFF),
876 s
->contents
+ my_offset
+ 4);
879 BFD_ASSERT (my_offset
<= globals
->thumb_glue_size
);
881 /* Now go back and fix up the original BL insn to point
886 - (input_section
->output_offset
890 tmp
= bfd_get_32 (input_bfd
, hit_data
891 - input_section
->vma
);
893 bfd_put_32 (output_bfd
,
894 insert_thumb_branch (tmp
, ret_offset
),
895 hit_data
- input_section
->vma
);
900 /* Arm code calling a Thumb function. */
903 elf32_arm_to_thumb_stub (info
, name
, input_bfd
, output_bfd
, input_section
,
904 hit_data
, sym_sec
, offset
, addend
, val
)
905 struct bfd_link_info
* info
;
909 asection
* input_section
;
913 bfd_signed_vma addend
;
916 unsigned long int tmp
;
920 struct elf_link_hash_entry
* myh
;
921 struct elf32_arm_link_hash_table
* globals
;
923 myh
= find_arm_glue (info
, name
, input_bfd
);
927 globals
= elf32_arm_hash_table (info
);
929 BFD_ASSERT (globals
!= NULL
);
930 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
932 my_offset
= myh
->root
.u
.def
.value
;
933 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
934 ARM2THUMB_GLUE_SECTION_NAME
);
935 BFD_ASSERT (s
!= NULL
);
936 BFD_ASSERT (s
->contents
!= NULL
);
937 BFD_ASSERT (s
->output_section
!= NULL
);
939 if ((my_offset
& 0x01) == 0x01)
942 && sym_sec
->owner
!= NULL
943 && !INTERWORK_FLAG (sym_sec
->owner
))
946 (_("%s(%s): warning: interworking not enabled."),
947 bfd_get_filename (sym_sec
->owner
), name
);
949 (_(" first occurrence: %s: arm call to thumb"),
950 bfd_get_filename (input_bfd
));
954 myh
->root
.u
.def
.value
= my_offset
;
956 bfd_put_32 (output_bfd
, a2t1_ldr_insn
,
957 s
->contents
+ my_offset
);
959 bfd_put_32 (output_bfd
, a2t2_bx_r12_insn
,
960 s
->contents
+ my_offset
+ 4);
962 /* It's a thumb address. Add the low order bit. */
963 bfd_put_32 (output_bfd
, val
| a2t3_func_addr_insn
,
964 s
->contents
+ my_offset
+ 8);
967 BFD_ASSERT (my_offset
<= globals
->arm_glue_size
);
969 tmp
= bfd_get_32 (input_bfd
, hit_data
);
970 tmp
= tmp
& 0xFF000000;
972 /* Somehow these are both 4 too far, so subtract 8. */
973 ret_offset
= s
->output_offset
975 + s
->output_section
->vma
976 - (input_section
->output_offset
977 + input_section
->output_section
->vma
981 tmp
= tmp
| ((ret_offset
>> 2) & 0x00FFFFFF);
983 bfd_put_32 (output_bfd
, tmp
, hit_data
984 - input_section
->vma
);
989 /* Perform a relocation as part of a final link. */
991 static bfd_reloc_status_type
992 elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
993 input_section
, contents
, rel
, value
,
994 info
, sym_sec
, sym_name
, sym_flags
, h
)
995 reloc_howto_type
* howto
;
998 asection
* input_section
;
1000 Elf_Internal_Rela
* rel
;
1002 struct bfd_link_info
* info
;
1004 const char * sym_name
;
1005 unsigned char sym_flags
;
1006 struct elf_link_hash_entry
* h
;
1008 unsigned long r_type
= howto
->type
;
1009 unsigned long r_symndx
;
1010 bfd_byte
* hit_data
= contents
+ rel
->r_offset
;
1011 bfd
* dynobj
= NULL
;
1012 Elf_Internal_Shdr
* symtab_hdr
;
1013 struct elf_link_hash_entry
** sym_hashes
;
1014 bfd_vma
* local_got_offsets
;
1015 asection
* sgot
= NULL
;
1016 asection
* splt
= NULL
;
1017 asection
* sreloc
= NULL
;
1019 bfd_signed_vma signed_addend
;
1020 struct elf32_arm_link_hash_table
* globals
;
1022 globals
= elf32_arm_hash_table (info
);
1024 dynobj
= elf_hash_table (info
)->dynobj
;
1027 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1028 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1030 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1031 sym_hashes
= elf_sym_hashes (input_bfd
);
1032 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1033 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1036 addend
= bfd_get_32 (input_bfd
, hit_data
) & howto
->src_mask
;
1038 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1041 signed_addend
&= ~ howto
->src_mask
;
1042 signed_addend
|= addend
;
1045 signed_addend
= addend
;
1047 addend
= signed_addend
= rel
->r_addend
;
1053 return bfd_reloc_ok
;
1061 /* When generating a shared object, these relocations are copied
1062 into the output file to be resolved at run time. */
1064 && (r_type
!= R_ARM_PC24
1067 && (! info
->symbolic
1068 || (h
->elf_link_hash_flags
1069 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1071 Elf_Internal_Rel outrel
;
1072 boolean skip
, relocate
;
1078 name
= (bfd_elf_string_from_elf_section
1080 elf_elfheader (input_bfd
)->e_shstrndx
,
1081 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1083 return bfd_reloc_notsupported
;
1085 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
1086 && strcmp (bfd_get_section_name (input_bfd
,
1090 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1091 BFD_ASSERT (sreloc
!= NULL
);
1096 if (elf_section_data (input_section
)->stab_info
== NULL
)
1097 outrel
.r_offset
= rel
->r_offset
;
1102 off
= (_bfd_stab_section_offset
1103 (output_bfd
, &elf_hash_table (info
)->stab_info
,
1105 & elf_section_data (input_section
)->stab_info
,
1107 if (off
== (bfd_vma
) -1)
1109 outrel
.r_offset
= off
;
1112 outrel
.r_offset
+= (input_section
->output_section
->vma
1113 + input_section
->output_offset
);
1117 memset (&outrel
, 0, sizeof outrel
);
1120 else if (r_type
== R_ARM_PC24
)
1122 BFD_ASSERT (h
!= NULL
&& h
->dynindx
!= -1);
1123 if ((input_section
->flags
& SEC_ALLOC
) != 0)
1127 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_PC24
);
1132 || ((info
->symbolic
|| h
->dynindx
== -1)
1133 && (h
->elf_link_hash_flags
1134 & ELF_LINK_HASH_DEF_REGULAR
) != 0))
1137 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1141 BFD_ASSERT (h
->dynindx
!= -1);
1142 if ((input_section
->flags
& SEC_ALLOC
) != 0)
1146 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_ABS32
);
1150 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1151 (((Elf32_External_Rel
*)
1153 + sreloc
->reloc_count
));
1154 ++sreloc
->reloc_count
;
1156 /* If this reloc is against an external symbol, we do not want to
1157 fiddle with the addend. Otherwise, we need to include the symbol
1158 value so that it becomes an addend for the dynamic reloc. */
1160 return bfd_reloc_ok
;
1162 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1163 contents
, rel
->r_offset
, value
,
1166 else switch (r_type
)
1169 case R_ARM_XPC25
: /* Arm BLX instruction. */
1171 case R_ARM_PC24
: /* Arm B/BL instruction */
1173 if (r_type
== R_ARM_XPC25
)
1175 /* Check for Arm calling Arm function. */
1176 /* FIXME: Should we translate the instruction into a BL
1177 instruction instead ? */
1178 if (sym_flags
!= STT_ARM_TFUNC
)
1179 _bfd_error_handler (_("\
1180 %s: Warning: Arm BLX instruction targets Arm function '%s'."),
1181 bfd_get_filename (input_bfd
),
1182 h
? h
->root
.root
.string
: "(local)");
1187 /* Check for Arm calling Thumb function. */
1188 if (sym_flags
== STT_ARM_TFUNC
)
1190 elf32_arm_to_thumb_stub (info
, sym_name
, input_bfd
, output_bfd
,
1191 input_section
, hit_data
, sym_sec
, rel
->r_offset
,
1192 signed_addend
, value
);
1193 return bfd_reloc_ok
;
1197 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1198 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0)
1200 /* The old way of doing things. Trearing the addend as a
1201 byte sized field and adding in the pipeline offset. */
1202 value
-= (input_section
->output_section
->vma
1203 + input_section
->output_offset
);
1204 value
-= rel
->r_offset
;
1207 if (! globals
->no_pipeline_knowledge
)
1212 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
1214 S is the address of the symbol in the relocation.
1215 P is address of the instruction being relocated.
1216 A is the addend (extracted from the instruction) in bytes.
1218 S is held in 'value'.
1219 P is the base address of the section containing the instruction
1220 plus the offset of the reloc into that section, ie:
1221 (input_section->output_section->vma +
1222 input_section->output_offset +
1224 A is the addend, converted into bytes, ie:
1227 Note: None of these operations have knowledge of the pipeline
1228 size of the processor, thus it is up to the assembler to encode
1229 this information into the addend. */
1230 value
-= (input_section
->output_section
->vma
1231 + input_section
->output_offset
);
1232 value
-= rel
->r_offset
;
1233 value
+= (signed_addend
<< howto
->size
);
1235 /* Previous versions of this code also used to add in the pipeline
1236 offset here. This is wrong because the linker is not supposed
1237 to know about such things, and one day it might change. In order
1238 to support old binaries that need the old behaviour however, so
1239 we attempt to detect which ABI was used to create the reloc. */
1240 if (! globals
->no_pipeline_knowledge
)
1242 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form */
1244 i_ehdrp
= elf_elfheader (input_bfd
);
1246 if (i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1251 signed_addend
= value
;
1252 signed_addend
>>= howto
->rightshift
;
1254 /* It is not an error for an undefined weak reference to be
1255 out of range. Any program that branches to such a symbol
1256 is going to crash anyway, so there is no point worrying
1257 about getting the destination exactly right. */
1258 if (! h
|| h
->root
.type
!= bfd_link_hash_undefweak
)
1260 /* Perform a signed range check. */
1261 if ( signed_addend
> ((bfd_signed_vma
) (howto
->dst_mask
>> 1))
1262 || signed_addend
< - ((bfd_signed_vma
) ((howto
->dst_mask
+ 1) >> 1)))
1263 return bfd_reloc_overflow
;
1267 /* If necessary set the H bit in the BLX instruction. */
1268 if (r_type
== R_ARM_XPC25
&& ((value
& 2) == 2))
1269 value
= (signed_addend
& howto
->dst_mask
)
1270 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
))
1274 value
= (signed_addend
& howto
->dst_mask
)
1275 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1280 if (sym_flags
== STT_ARM_TFUNC
)
1285 value
-= (input_section
->output_section
->vma
1286 + input_section
->output_offset
);
1291 bfd_put_32 (input_bfd
, value
, hit_data
);
1292 return bfd_reloc_ok
;
1296 if ((long) value
> 0x7f || (long) value
< -0x80)
1297 return bfd_reloc_overflow
;
1299 bfd_put_8 (input_bfd
, value
, hit_data
);
1300 return bfd_reloc_ok
;
1305 if ((long) value
> 0x7fff || (long) value
< -0x8000)
1306 return bfd_reloc_overflow
;
1308 bfd_put_16 (input_bfd
, value
, hit_data
);
1309 return bfd_reloc_ok
;
1312 /* Support ldr and str instruction for the arm */
1313 /* Also thumb b (unconditional branch). ??? Really? */
1316 if ((long) value
> 0x7ff || (long) value
< -0x800)
1317 return bfd_reloc_overflow
;
1319 value
|= (bfd_get_32 (input_bfd
, hit_data
) & 0xfffff000);
1320 bfd_put_32 (input_bfd
, value
, hit_data
);
1321 return bfd_reloc_ok
;
1323 case R_ARM_THM_ABS5
:
1324 /* Support ldr and str instructions for the thumb. */
1326 /* Need to refetch addend. */
1327 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1328 /* ??? Need to determine shift amount from operand size. */
1329 addend
>>= howto
->rightshift
;
1333 /* ??? Isn't value unsigned? */
1334 if ((long) value
> 0x1f || (long) value
< -0x10)
1335 return bfd_reloc_overflow
;
1337 /* ??? Value needs to be properly shifted into place first. */
1338 value
|= bfd_get_16 (input_bfd
, hit_data
) & 0xf83f;
1339 bfd_put_16 (input_bfd
, value
, hit_data
);
1340 return bfd_reloc_ok
;
1343 case R_ARM_THM_XPC22
:
1345 case R_ARM_THM_PC22
:
1346 /* Thumb BL (branch long instruction). */
1349 boolean overflow
= false;
1350 bfd_vma upper_insn
= bfd_get_16 (input_bfd
, hit_data
);
1351 bfd_vma lower_insn
= bfd_get_16 (input_bfd
, hit_data
+ 2);
1352 bfd_signed_vma reloc_signed_max
= (1 << (howto
->bitsize
- 1)) - 1;
1353 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1355 bfd_signed_vma signed_check
;
1358 /* Need to refetch the addend and squish the two 11 bit pieces
1361 bfd_vma upper
= upper_insn
& 0x7ff;
1362 bfd_vma lower
= lower_insn
& 0x7ff;
1363 upper
= (upper
^ 0x400) - 0x400; /* Sign extend. */
1364 addend
= (upper
<< 12) | (lower
<< 1);
1365 signed_addend
= addend
;
1369 if (r_type
== R_ARM_THM_XPC22
)
1371 /* Check for Thumb to Thumb call. */
1372 /* FIXME: Should we translate the instruction into a BL
1373 instruction instead ? */
1374 if (sym_flags
== STT_ARM_TFUNC
)
1375 _bfd_error_handler (_("\
1376 %s: Warning: Thumb BLX instruction targets thumb function '%s'."),
1377 bfd_get_filename (input_bfd
),
1378 h
? h
->root
.root
.string
: "(local)");
1383 /* If it is not a call to Thumb, assume call to Arm.
1384 If it is a call relative to a section name, then it is not a
1385 function call at all, but rather a long jump. */
1386 if (sym_flags
!= STT_ARM_TFUNC
&& sym_flags
!= STT_SECTION
)
1388 if (elf32_thumb_to_arm_stub
1389 (info
, sym_name
, input_bfd
, output_bfd
, input_section
,
1390 hit_data
, sym_sec
, rel
->r_offset
, signed_addend
, value
))
1391 return bfd_reloc_ok
;
1393 return bfd_reloc_dangerous
;
1397 relocation
= value
+ signed_addend
;
1399 relocation
-= (input_section
->output_section
->vma
1400 + input_section
->output_offset
1403 if (! globals
->no_pipeline_knowledge
)
1405 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form. */
1407 i_ehdrp
= elf_elfheader (input_bfd
);
1409 /* Previous versions of this code also used to add in the pipline
1410 offset here. This is wrong because the linker is not supposed
1411 to know about such things, and one day it might change. In order
1412 to support old binaries that need the old behaviour however, so
1413 we attempt to detect which ABI was used to create the reloc. */
1414 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1415 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0
1416 || i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1420 check
= relocation
>> howto
->rightshift
;
1422 /* If this is a signed value, the rightshift just dropped
1423 leading 1 bits (assuming twos complement). */
1424 if ((bfd_signed_vma
) relocation
>= 0)
1425 signed_check
= check
;
1427 signed_check
= check
| ~((bfd_vma
) -1 >> howto
->rightshift
);
1429 /* Assumes two's complement. */
1430 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1433 /* Put RELOCATION back into the insn. */
1434 upper_insn
= (upper_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 12) & 0x7ff);
1435 lower_insn
= (lower_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 1) & 0x7ff);
1438 if (r_type
== R_ARM_THM_XPC22
1439 && ((lower_insn
& 0x1800) == 0x0800))
1440 /* Remove bit zero of the adjusted offset. Bit zero can only be
1441 set if the upper insn is at a half-word boundary, since the
1442 destination address, an ARM instruction, must always be on a
1443 word boundary. The semantics of the BLX (1) instruction, however,
1444 are that bit zero in the offset must always be zero, and the
1445 corresponding bit one in the target address will be set from bit
1446 one of the source address. */
1449 /* Put the relocated value back in the object file: */
1450 bfd_put_16 (input_bfd
, upper_insn
, hit_data
);
1451 bfd_put_16 (input_bfd
, lower_insn
, hit_data
+ 2);
1453 return (overflow
? bfd_reloc_overflow
: bfd_reloc_ok
);
1457 case R_ARM_GNU_VTINHERIT
:
1458 case R_ARM_GNU_VTENTRY
:
1459 return bfd_reloc_ok
;
1462 return bfd_reloc_notsupported
;
1464 case R_ARM_GLOB_DAT
:
1465 return bfd_reloc_notsupported
;
1467 case R_ARM_JUMP_SLOT
:
1468 return bfd_reloc_notsupported
;
1470 case R_ARM_RELATIVE
:
1471 return bfd_reloc_notsupported
;
1474 /* Relocation is relative to the start of the
1475 global offset table. */
1477 BFD_ASSERT (sgot
!= NULL
);
1479 return bfd_reloc_notsupported
;
1481 /* Note that sgot->output_offset is not involved in this
1482 calculation. We always want the start of .got. If we
1483 define _GLOBAL_OFFSET_TABLE in a different way, as is
1484 permitted by the ABI, we might have to change this
1486 value
-= sgot
->output_section
->vma
;
1487 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1488 contents
, rel
->r_offset
, value
,
1492 /* Use global offset table as symbol value. */
1493 BFD_ASSERT (sgot
!= NULL
);
1496 return bfd_reloc_notsupported
;
1498 value
= sgot
->output_section
->vma
;
1499 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1500 contents
, rel
->r_offset
, value
,
1504 /* Relocation is to the entry for this symbol in the
1505 global offset table. */
1507 return bfd_reloc_notsupported
;
1513 off
= h
->got
.offset
;
1514 BFD_ASSERT (off
!= (bfd_vma
) -1);
1516 if (!elf_hash_table (info
)->dynamic_sections_created
||
1517 (info
->shared
&& (info
->symbolic
|| h
->dynindx
== -1)
1518 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1520 /* This is actually a static link, or it is a -Bsymbolic link
1521 and the symbol is defined locally. We must initialize this
1522 entry in the global offset table. Since the offset must
1523 always be a multiple of 4, we use the least significant bit
1524 to record whether we have initialized it already.
1526 When doing a dynamic link, we create a .rel.got relocation
1527 entry to initialize the value. This is done in the
1528 finish_dynamic_symbol routine. */
1533 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1538 value
= sgot
->output_offset
+ off
;
1544 BFD_ASSERT (local_got_offsets
!= NULL
&&
1545 local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1547 off
= local_got_offsets
[r_symndx
];
1549 /* The offset must always be a multiple of 4. We use the
1550 least significant bit to record whether we have already
1551 generated the necessary reloc. */
1556 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1561 Elf_Internal_Rel outrel
;
1563 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
1564 BFD_ASSERT (srelgot
!= NULL
);
1566 outrel
.r_offset
= (sgot
->output_section
->vma
1567 + sgot
->output_offset
1569 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1570 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1571 (((Elf32_External_Rel
*)
1573 + srelgot
->reloc_count
));
1574 ++srelgot
->reloc_count
;
1577 local_got_offsets
[r_symndx
] |= 1;
1580 value
= sgot
->output_offset
+ off
;
1583 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1584 contents
, rel
->r_offset
, value
,
1588 /* Relocation is to the entry for this symbol in the
1589 procedure linkage table. */
1591 /* Resolve a PLT32 reloc against a local symbol directly,
1592 without using the procedure linkage table. */
1594 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1595 contents
, rel
->r_offset
, value
,
1598 if (h
->plt
.offset
== (bfd_vma
) -1)
1599 /* We didn't make a PLT entry for this symbol. This
1600 happens when statically linking PIC code, or when
1601 using -Bsymbolic. */
1602 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1603 contents
, rel
->r_offset
, value
,
1606 BFD_ASSERT(splt
!= NULL
);
1608 return bfd_reloc_notsupported
;
1610 value
= (splt
->output_section
->vma
1611 + splt
->output_offset
1613 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1614 contents
, rel
->r_offset
, value
,
1618 return bfd_reloc_notsupported
;
1620 case R_ARM_AMP_VCALL9
:
1621 return bfd_reloc_notsupported
;
1623 case R_ARM_RSBREL32
:
1624 return bfd_reloc_notsupported
;
1626 case R_ARM_THM_RPC22
:
1627 return bfd_reloc_notsupported
;
1630 return bfd_reloc_notsupported
;
1633 return bfd_reloc_notsupported
;
1636 return bfd_reloc_notsupported
;
1639 return bfd_reloc_notsupported
;
1642 return bfd_reloc_notsupported
;
1647 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
1649 arm_add_to_rel (abfd
, address
, howto
, increment
)
1652 reloc_howto_type
* howto
;
1653 bfd_signed_vma increment
;
1655 bfd_signed_vma addend
;
1657 if (howto
->type
== R_ARM_THM_PC22
)
1659 int upper_insn
, lower_insn
;
1662 upper_insn
= bfd_get_16 (abfd
, address
);
1663 lower_insn
= bfd_get_16 (abfd
, address
+ 2);
1664 upper
= upper_insn
& 0x7ff;
1665 lower
= lower_insn
& 0x7ff;
1667 addend
= (upper
<< 12) | (lower
<< 1);
1668 addend
+= increment
;
1671 upper_insn
= (upper_insn
& 0xf800) | ((addend
>> 11) & 0x7ff);
1672 lower_insn
= (lower_insn
& 0xf800) | (addend
& 0x7ff);
1674 bfd_put_16 (abfd
, upper_insn
, address
);
1675 bfd_put_16 (abfd
, lower_insn
, address
+ 2);
1681 contents
= bfd_get_32 (abfd
, address
);
1683 /* Get the (signed) value from the instruction. */
1684 addend
= contents
& howto
->src_mask
;
1685 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1687 bfd_signed_vma mask
;
1690 mask
&= ~ howto
->src_mask
;
1694 /* Add in the increment, (which is a byte value). */
1695 switch (howto
->type
)
1698 addend
+= increment
;
1702 addend
<<= howto
->size
;
1703 addend
+= increment
;
1705 /* Should we check for overflow here ? */
1707 /* Drop any undesired bits. */
1708 addend
>>= howto
->rightshift
;
1712 contents
= (contents
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
1714 bfd_put_32 (abfd
, contents
, address
);
1717 #endif /* USE_REL */
1719 /* Relocate an ARM ELF section. */
1721 elf32_arm_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1722 contents
, relocs
, local_syms
, local_sections
)
1724 struct bfd_link_info
* info
;
1726 asection
* input_section
;
1727 bfd_byte
* contents
;
1728 Elf_Internal_Rela
* relocs
;
1729 Elf_Internal_Sym
* local_syms
;
1730 asection
** local_sections
;
1732 Elf_Internal_Shdr
* symtab_hdr
;
1733 struct elf_link_hash_entry
** sym_hashes
;
1734 Elf_Internal_Rela
* rel
;
1735 Elf_Internal_Rela
* relend
;
1738 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1739 sym_hashes
= elf_sym_hashes (input_bfd
);
1742 relend
= relocs
+ input_section
->reloc_count
;
1743 for (; rel
< relend
; rel
++)
1746 reloc_howto_type
* howto
;
1747 unsigned long r_symndx
;
1748 Elf_Internal_Sym
* sym
;
1750 struct elf_link_hash_entry
* h
;
1752 bfd_reloc_status_type r
;
1755 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1756 r_type
= ELF32_R_TYPE (rel
->r_info
);
1758 if ( r_type
== R_ARM_GNU_VTENTRY
1759 || r_type
== R_ARM_GNU_VTINHERIT
)
1762 elf32_arm_info_to_howto (input_bfd
, & bfd_reloc
, rel
);
1763 howto
= bfd_reloc
.howto
;
1765 if (info
->relocateable
)
1767 /* This is a relocateable link. We don't have to change
1768 anything, unless the reloc is against a section symbol,
1769 in which case we have to adjust according to where the
1770 section symbol winds up in the output section. */
1771 if (r_symndx
< symtab_hdr
->sh_info
)
1773 sym
= local_syms
+ r_symndx
;
1774 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1776 sec
= local_sections
[r_symndx
];
1778 arm_add_to_rel (input_bfd
, contents
+ rel
->r_offset
,
1779 howto
, sec
->output_offset
+ sym
->st_value
);
1781 rel
->r_addend
+= (sec
->output_offset
+ sym
->st_value
)
1782 >> howto
->rightshift
;
1790 /* This is a final link. */
1795 if (r_symndx
< symtab_hdr
->sh_info
)
1797 sym
= local_syms
+ r_symndx
;
1798 sec
= local_sections
[r_symndx
];
1799 relocation
= (sec
->output_section
->vma
1800 + sec
->output_offset
1805 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1807 while ( h
->root
.type
== bfd_link_hash_indirect
1808 || h
->root
.type
== bfd_link_hash_warning
)
1809 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1811 if ( h
->root
.type
== bfd_link_hash_defined
1812 || h
->root
.type
== bfd_link_hash_defweak
)
1814 int relocation_needed
= 1;
1816 sec
= h
->root
.u
.def
.section
;
1818 /* In these cases, we don't need the relocation value.
1819 We check specially because in some obscure cases
1820 sec->output_section will be NULL. */
1827 (!info
->symbolic
&& h
->dynindx
!= -1)
1828 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1830 && ((input_section
->flags
& SEC_ALLOC
) != 0
1831 /* DWARF will emit R_ARM_ABS32 relocations in its
1832 sections against symbols defined externally
1833 in shared libraries. We can't do anything
1835 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
1836 && (h
->elf_link_hash_flags
1837 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
1839 relocation_needed
= 0;
1843 relocation_needed
= 0;
1847 if (elf_hash_table(info
)->dynamic_sections_created
1849 || (!info
->symbolic
&& h
->dynindx
!= -1)
1850 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1853 relocation_needed
= 0;
1857 if (h
->plt
.offset
!= (bfd_vma
)-1)
1858 relocation_needed
= 0;
1862 if (sec
->output_section
== NULL
)
1864 (*_bfd_error_handler
)
1865 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1866 bfd_get_filename (input_bfd
), h
->root
.root
.string
,
1867 bfd_get_section_name (input_bfd
, input_section
));
1868 relocation_needed
= 0;
1872 if (relocation_needed
)
1873 relocation
= h
->root
.u
.def
.value
1874 + sec
->output_section
->vma
1875 + sec
->output_offset
;
1879 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1881 else if (info
->shared
&& !info
->symbolic
1882 && !info
->no_undefined
1883 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1887 if (!((*info
->callbacks
->undefined_symbol
)
1888 (info
, h
->root
.root
.string
, input_bfd
,
1889 input_section
, rel
->r_offset
,
1890 (!info
->shared
|| info
->no_undefined
1891 || ELF_ST_VISIBILITY (h
->other
)))))
1898 name
= h
->root
.root
.string
;
1901 name
= (bfd_elf_string_from_elf_section
1902 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
1903 if (name
== NULL
|| *name
== '\0')
1904 name
= bfd_section_name (input_bfd
, sec
);
1907 r
= elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
1908 input_section
, contents
, rel
,
1909 relocation
, info
, sec
, name
,
1910 (h
? ELF_ST_TYPE (h
->type
) :
1911 ELF_ST_TYPE (sym
->st_info
)), h
);
1913 if (r
!= bfd_reloc_ok
)
1915 const char * msg
= (const char *) 0;
1919 case bfd_reloc_overflow
:
1920 /* If the overflowing reloc was to an undefined symbol,
1921 we have already printed one error message and there
1922 is no point complaining again. */
1924 h
->root
.type
!= bfd_link_hash_undefined
)
1925 && (!((*info
->callbacks
->reloc_overflow
)
1926 (info
, name
, howto
->name
, (bfd_vma
) 0,
1927 input_bfd
, input_section
, rel
->r_offset
))))
1931 case bfd_reloc_undefined
:
1932 if (!((*info
->callbacks
->undefined_symbol
)
1933 (info
, name
, input_bfd
, input_section
,
1934 rel
->r_offset
, true)))
1938 case bfd_reloc_outofrange
:
1939 msg
= _("internal error: out of range error");
1942 case bfd_reloc_notsupported
:
1943 msg
= _("internal error: unsupported relocation error");
1946 case bfd_reloc_dangerous
:
1947 msg
= _("internal error: dangerous error");
1951 msg
= _("internal error: unknown error");
1955 if (!((*info
->callbacks
->warning
)
1956 (info
, msg
, name
, input_bfd
, input_section
,
1967 /* Function to keep ARM specific flags in the ELF header. */
1969 elf32_arm_set_private_flags (abfd
, flags
)
1973 if (elf_flags_init (abfd
)
1974 && elf_elfheader (abfd
)->e_flags
!= flags
)
1976 if (EF_ARM_EABI_VERSION (flags
) == EF_ARM_EABI_UNKNOWN
)
1978 if (flags
& EF_ARM_INTERWORK
)
1979 _bfd_error_handler (_("\
1980 Warning: Not setting interwork flag of %s since it has already been specified as non-interworking"),
1981 bfd_get_filename (abfd
));
1983 _bfd_error_handler (_("\
1984 Warning: Clearing the interwork flag of %s due to outside request"),
1985 bfd_get_filename (abfd
));
1990 elf_elfheader (abfd
)->e_flags
= flags
;
1991 elf_flags_init (abfd
) = true;
1997 /* Copy backend specific data from one object module to another. */
2000 elf32_arm_copy_private_bfd_data (ibfd
, obfd
)
2007 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2008 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2011 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2012 out_flags
= elf_elfheader (obfd
)->e_flags
;
2014 if (elf_flags_init (obfd
)
2015 && EF_ARM_EABI_VERSION (out_flags
) == EF_ARM_EABI_UNKNOWN
2016 && in_flags
!= out_flags
)
2018 /* Cannot mix APCS26 and APCS32 code. */
2019 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2022 /* Cannot mix float APCS and non-float APCS code. */
2023 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2026 /* If the src and dest have different interworking flags
2027 then turn off the interworking bit. */
2028 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2030 if (out_flags
& EF_ARM_INTERWORK
)
2031 _bfd_error_handler (_("\
2032 Warning: Clearing the interwork flag in %s because non-interworking code in %s has been linked with it"),
2033 bfd_get_filename (obfd
), bfd_get_filename (ibfd
));
2035 in_flags
&= ~EF_ARM_INTERWORK
;
2038 /* Likewise for PIC, though don't warn for this case. */
2039 if ((in_flags
& EF_ARM_PIC
) != (out_flags
& EF_ARM_PIC
))
2040 in_flags
&= ~EF_ARM_PIC
;
2043 elf_elfheader (obfd
)->e_flags
= in_flags
;
2044 elf_flags_init (obfd
) = true;
2049 /* Merge backend specific data from an object file to the output
2050 object file when linking. */
2053 elf32_arm_merge_private_bfd_data (ibfd
, obfd
)
2059 boolean flags_compatible
= true;
2060 boolean null_input_bfd
= true;
2063 /* Check if we have the same endianess. */
2064 if (_bfd_generic_verify_endian_match (ibfd
, obfd
) == false)
2067 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2068 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2071 /* The input BFD must have had its flags initialised. */
2072 /* The following seems bogus to me -- The flags are initialized in
2073 the assembler but I don't think an elf_flags_init field is
2074 written into the object. */
2075 /* BFD_ASSERT (elf_flags_init (ibfd)); */
2077 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2078 out_flags
= elf_elfheader (obfd
)->e_flags
;
2080 if (!elf_flags_init (obfd
))
2082 /* If the input is the default architecture and had the default
2083 flags then do not bother setting the flags for the output
2084 architecture, instead allow future merges to do this. If no
2085 future merges ever set these flags then they will retain their
2086 uninitialised values, which surprise surprise, correspond
2087 to the default values. */
2088 if (bfd_get_arch_info (ibfd
)->the_default
2089 && elf_elfheader (ibfd
)->e_flags
== 0)
2092 elf_flags_init (obfd
) = true;
2093 elf_elfheader (obfd
)->e_flags
= in_flags
;
2095 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
2096 && bfd_get_arch_info (obfd
)->the_default
)
2097 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
), bfd_get_mach (ibfd
));
2102 /* Identical flags must be compatible. */
2103 if (in_flags
== out_flags
)
2106 /* Check to see if the input BFD actually contains any sections.
2107 If not, its flags may not have been initialised either, but it cannot
2108 actually cause any incompatibility. */
2109 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2111 /* Ignore synthetic glue sections. */
2112 if (strcmp (sec
->name
, ".glue_7")
2113 && strcmp (sec
->name
, ".glue_7t"))
2115 null_input_bfd
= false;
2122 /* Complain about various flag mismatches. */
2123 if (EF_ARM_EABI_VERSION (in_flags
) != EF_ARM_EABI_VERSION (out_flags
))
2125 _bfd_error_handler (_("\
2126 Error: %s compiled for EABI version %d, whereas %s is compiled for version %d"),
2127 bfd_get_filename (ibfd
),
2128 (in_flags
& EF_ARM_EABIMASK
) >> 24,
2129 bfd_get_filename (obfd
),
2130 (out_flags
& EF_ARM_EABIMASK
) >> 24);
2134 /* Not sure what needs to be checked for EABI versions >= 1. */
2135 if (EF_ARM_EABI_VERSION (in_flags
) == EF_ARM_EABI_UNKNOWN
)
2137 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2139 _bfd_error_handler (_("\
2140 Error: %s compiled for APCS-%d, whereas %s is compiled for APCS-%d"),
2141 bfd_get_filename (ibfd
),
2142 in_flags
& EF_ARM_APCS_26
? 26 : 32,
2143 bfd_get_filename (obfd
),
2144 out_flags
& EF_ARM_APCS_26
? 26 : 32);
2145 flags_compatible
= false;
2148 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2150 _bfd_error_handler (_("\
2151 Error: %s passes floats in %s registers, whereas %s passes them in %s registers"),
2152 bfd_get_filename (ibfd
),
2153 in_flags
& EF_ARM_APCS_FLOAT
? _("float") : _("integer"),
2154 bfd_get_filename (obfd
),
2155 out_flags
& EF_ARM_APCS_26
? _("float") : _("integer"));
2156 flags_compatible
= false;
2159 #ifdef EF_ARM_SOFT_FLOAT
2160 if ((in_flags
& EF_ARM_SOFT_FLOAT
) != (out_flags
& EF_ARM_SOFT_FLOAT
))
2162 _bfd_error_handler (_ ("\
2163 Error: %s uses %s floating point, whereas %s uses %s floating point"),
2164 bfd_get_filename (ibfd
),
2165 in_flags
& EF_ARM_SOFT_FLOAT
? _("soft") : _("hard"),
2166 bfd_get_filename (obfd
),
2167 out_flags
& EF_ARM_SOFT_FLOAT
? _("soft") : _("hard"));
2168 flags_compatible
= false;
2172 /* Interworking mismatch is only a warning. */
2173 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2174 _bfd_error_handler (_("\
2175 Warning: %s %s interworking, whereas %s %s"),
2176 bfd_get_filename (ibfd
),
2177 in_flags
& EF_ARM_INTERWORK
? _("supports") : _("does not support"),
2178 bfd_get_filename (obfd
),
2179 out_flags
& EF_ARM_INTERWORK
? _("does") : _("does not"));
2182 return flags_compatible
;
2185 /* Display the flags field. */
2188 elf32_arm_print_private_bfd_data (abfd
, ptr
)
2192 FILE * file
= (FILE *) ptr
;
2193 unsigned long flags
;
2195 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
2197 /* Print normal ELF private data. */
2198 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
2200 flags
= elf_elfheader (abfd
)->e_flags
;
2201 /* Ignore init flag - it may not be set, despite the flags field
2202 containing valid data. */
2204 /* xgettext:c-format */
2205 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
2207 switch (EF_ARM_EABI_VERSION (flags
))
2209 case EF_ARM_EABI_UNKNOWN
:
2210 /* The following flag bits are GNU extenstions and not part of the
2211 official ARM ELF extended ABI. Hence they are only decoded if
2212 the EABI version is not set. */
2213 if (flags
& EF_ARM_INTERWORK
)
2214 fprintf (file
, _(" [interworking enabled]"));
2216 if (flags
& EF_ARM_APCS_26
)
2217 fprintf (file
, _(" [APCS-26]"));
2219 fprintf (file
, _(" [APCS-32]"));
2221 if (flags
& EF_ARM_APCS_FLOAT
)
2222 fprintf (file
, _(" [floats passed in float registers]"));
2224 if (flags
& EF_ARM_PIC
)
2225 fprintf (file
, _(" [position independent]"));
2227 if (flags
& EF_ARM_NEW_ABI
)
2228 fprintf (file
, _(" [new ABI]"));
2230 if (flags
& EF_ARM_OLD_ABI
)
2231 fprintf (file
, _(" [old ABI]"));
2233 if (flags
& EF_ARM_SOFT_FLOAT
)
2234 fprintf (file
, _(" [software FP]"));
2236 flags
&= ~(EF_ARM_INTERWORK
| EF_ARM_APCS_26
| EF_ARM_APCS_FLOAT
| EF_ARM_PIC
2237 | EF_ARM_NEW_ABI
| EF_ARM_OLD_ABI
| EF_ARM_SOFT_FLOAT
);
2240 case EF_ARM_EABI_VER1
:
2241 fprintf (file
, _(" [Version1 EABI]"));
2243 if (flags
& EF_ARM_SYMSARESORTED
)
2244 fprintf (file
, _(" [sorted symbol table]"));
2246 fprintf (file
, _(" [unsorted symbol table]"));
2248 flags
&= ~ EF_ARM_SYMSARESORTED
;
2251 case EF_ARM_EABI_VER2
:
2252 fprintf (file
, _(" [Version2 EABI]"));
2254 if (flags
& EF_ARM_SYMSARESORTED
)
2255 fprintf (file
, _(" [sorted symbol table]"));
2257 fprintf (file
, _(" [unsorted symbol table]"));
2259 if (flags
& EF_ARM_DYNSYMSUSESEGIDX
)
2260 fprintf (file
, _(" [dynamic symbols use segment index]"));
2262 if (flags
& EF_ARM_MAPSYMSFIRST
)
2263 fprintf (file
, _(" [mapping symbols precede others]"));
2265 flags
&= ~(EF_ARM_SYMSARESORTED
| EF_ARM_DYNSYMSUSESEGIDX
2266 | EF_ARM_MAPSYMSFIRST
);
2270 fprintf (file
, _(" <EABI version unrecognised>"));
2274 flags
&= ~ EF_ARM_EABIMASK
;
2276 if (flags
& EF_ARM_RELEXEC
)
2277 fprintf (file
, _(" [relocatable executable]"));
2279 if (flags
& EF_ARM_HASENTRY
)
2280 fprintf (file
, _(" [has entry point]"));
2282 flags
&= ~ (EF_ARM_RELEXEC
| EF_ARM_HASENTRY
);
2285 fprintf (file
, _("<Unrecognised flag bits set>"));
2293 elf32_arm_get_symbol_type (elf_sym
, type
)
2294 Elf_Internal_Sym
* elf_sym
;
2297 switch (ELF_ST_TYPE (elf_sym
->st_info
))
2300 return ELF_ST_TYPE (elf_sym
->st_info
);
2303 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2304 This allows us to distinguish between data used by Thumb instructions
2305 and non-data (which is probably code) inside Thumb regions of an
2307 if (type
!= STT_OBJECT
)
2308 return ELF_ST_TYPE (elf_sym
->st_info
);
2319 elf32_arm_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
2321 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2322 Elf_Internal_Rela
*rel
;
2323 struct elf_link_hash_entry
*h
;
2324 Elf_Internal_Sym
*sym
;
2328 switch (ELF32_R_TYPE (rel
->r_info
))
2330 case R_ARM_GNU_VTINHERIT
:
2331 case R_ARM_GNU_VTENTRY
:
2335 switch (h
->root
.type
)
2337 case bfd_link_hash_defined
:
2338 case bfd_link_hash_defweak
:
2339 return h
->root
.u
.def
.section
;
2341 case bfd_link_hash_common
:
2342 return h
->root
.u
.c
.p
->section
;
2351 if (!(elf_bad_symtab (abfd
)
2352 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
2353 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
2354 && sym
->st_shndx
!= SHN_COMMON
))
2356 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
2362 /* Update the got entry reference counts for the section being removed. */
2365 elf32_arm_gc_sweep_hook (abfd
, info
, sec
, relocs
)
2366 bfd
*abfd ATTRIBUTE_UNUSED
;
2367 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2368 asection
*sec ATTRIBUTE_UNUSED
;
2369 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
;
2371 /* We don't support garbage collection of GOT and PLT relocs yet. */
2375 /* Look through the relocs for a section during the first phase. */
2378 elf32_arm_check_relocs (abfd
, info
, sec
, relocs
)
2380 struct bfd_link_info
* info
;
2382 const Elf_Internal_Rela
* relocs
;
2384 Elf_Internal_Shdr
* symtab_hdr
;
2385 struct elf_link_hash_entry
** sym_hashes
;
2386 struct elf_link_hash_entry
** sym_hashes_end
;
2387 const Elf_Internal_Rela
* rel
;
2388 const Elf_Internal_Rela
* rel_end
;
2390 asection
* sgot
, *srelgot
, *sreloc
;
2391 bfd_vma
* local_got_offsets
;
2393 if (info
->relocateable
)
2396 sgot
= srelgot
= sreloc
= NULL
;
2398 dynobj
= elf_hash_table (info
)->dynobj
;
2399 local_got_offsets
= elf_local_got_offsets (abfd
);
2401 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2402 sym_hashes
= elf_sym_hashes (abfd
);
2403 sym_hashes_end
= sym_hashes
2404 + symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
2406 if (!elf_bad_symtab (abfd
))
2407 sym_hashes_end
-= symtab_hdr
->sh_info
;
2409 rel_end
= relocs
+ sec
->reloc_count
;
2410 for (rel
= relocs
; rel
< rel_end
; rel
++)
2412 struct elf_link_hash_entry
*h
;
2413 unsigned long r_symndx
;
2415 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2416 if (r_symndx
< symtab_hdr
->sh_info
)
2419 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2421 /* Some relocs require a global offset table. */
2424 switch (ELF32_R_TYPE (rel
->r_info
))
2429 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
2430 if (! _bfd_elf_create_got_section (dynobj
, info
))
2439 switch (ELF32_R_TYPE (rel
->r_info
))
2442 /* This symbol requires a global offset table entry. */
2445 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2446 BFD_ASSERT (sgot
!= NULL
);
2449 /* Get the got relocation section if necessary. */
2451 && (h
!= NULL
|| info
->shared
))
2453 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
2455 /* If no got relocation section, make one and initialize. */
2456 if (srelgot
== NULL
)
2458 srelgot
= bfd_make_section (dynobj
, ".rel.got");
2460 || ! bfd_set_section_flags (dynobj
, srelgot
,
2465 | SEC_LINKER_CREATED
2467 || ! bfd_set_section_alignment (dynobj
, srelgot
, 2))
2474 if (h
->got
.offset
!= (bfd_vma
) -1)
2475 /* We have already allocated space in the .got. */
2478 h
->got
.offset
= sgot
->_raw_size
;
2480 /* Make sure this symbol is output as a dynamic symbol. */
2481 if (h
->dynindx
== -1)
2482 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2485 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2489 /* This is a global offset table entry for a local
2491 if (local_got_offsets
== NULL
)
2494 register unsigned int i
;
2496 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
2497 local_got_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
2498 if (local_got_offsets
== NULL
)
2500 elf_local_got_offsets (abfd
) = local_got_offsets
;
2501 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
2502 local_got_offsets
[i
] = (bfd_vma
) -1;
2505 if (local_got_offsets
[r_symndx
] != (bfd_vma
) -1)
2506 /* We have already allocated space in the .got. */
2509 local_got_offsets
[r_symndx
] = sgot
->_raw_size
;
2512 /* If we are generating a shared object, we need to
2513 output a R_ARM_RELATIVE reloc so that the dynamic
2514 linker can adjust this GOT entry. */
2515 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2518 sgot
->_raw_size
+= 4;
2522 /* This symbol requires a procedure linkage table entry. We
2523 actually build the entry in adjust_dynamic_symbol,
2524 because this might be a case of linking PIC code which is
2525 never referenced by a dynamic object, in which case we
2526 don't need to generate a procedure linkage table entry
2529 /* If this is a local symbol, we resolve it directly without
2530 creating a procedure linkage table entry. */
2534 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2540 /* If we are creating a shared library, and this is a reloc
2541 against a global symbol, or a non PC relative reloc
2542 against a local symbol, then we need to copy the reloc
2543 into the shared library. However, if we are linking with
2544 -Bsymbolic, we do not need to copy a reloc against a
2545 global symbol which is defined in an object we are
2546 including in the link (i.e., DEF_REGULAR is set). At
2547 this point we have not seen all the input files, so it is
2548 possible that DEF_REGULAR is not set now but will be set
2549 later (it is never cleared). We account for that
2550 possibility below by storing information in the
2551 pcrel_relocs_copied field of the hash table entry. */
2553 && (ELF32_R_TYPE (rel
->r_info
) != R_ARM_PC24
2555 && (! info
->symbolic
2556 || (h
->elf_link_hash_flags
2557 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
2559 /* When creating a shared object, we must copy these
2560 reloc types into the output file. We create a reloc
2561 section in dynobj and make room for this reloc. */
2566 name
= (bfd_elf_string_from_elf_section
2568 elf_elfheader (abfd
)->e_shstrndx
,
2569 elf_section_data (sec
)->rel_hdr
.sh_name
));
2573 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
2574 && strcmp (bfd_get_section_name (abfd
, sec
),
2577 sreloc
= bfd_get_section_by_name (dynobj
, name
);
2582 sreloc
= bfd_make_section (dynobj
, name
);
2583 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
2584 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
2585 if ((sec
->flags
& SEC_ALLOC
) != 0)
2586 flags
|= SEC_ALLOC
| SEC_LOAD
;
2588 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
2589 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
2594 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
2595 /* If we are linking with -Bsymbolic, and this is a
2596 global symbol, we count the number of PC relative
2597 relocations we have entered for this symbol, so that
2598 we can discard them again if the symbol is later
2599 defined by a regular object. Note that this function
2600 is only called if we are using an elf_i386 linker
2601 hash table, which means that h is really a pointer to
2602 an elf_i386_link_hash_entry. */
2603 if (h
!= NULL
&& info
->symbolic
2604 && ELF32_R_TYPE (rel
->r_info
) == R_ARM_PC24
)
2606 struct elf32_arm_link_hash_entry
* eh
;
2607 struct elf32_arm_pcrel_relocs_copied
* p
;
2609 eh
= (struct elf32_arm_link_hash_entry
*) h
;
2611 for (p
= eh
->pcrel_relocs_copied
; p
!= NULL
; p
= p
->next
)
2612 if (p
->section
== sreloc
)
2617 p
= ((struct elf32_arm_pcrel_relocs_copied
*)
2618 bfd_alloc (dynobj
, sizeof * p
));
2622 p
->next
= eh
->pcrel_relocs_copied
;
2623 eh
->pcrel_relocs_copied
= p
;
2624 p
->section
= sreloc
;
2633 /* This relocation describes the C++ object vtable hierarchy.
2634 Reconstruct it for later use during GC. */
2635 case R_ARM_GNU_VTINHERIT
:
2636 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2640 /* This relocation describes which C++ vtable entries are actually
2641 used. Record for later use during GC. */
2642 case R_ARM_GNU_VTENTRY
:
2643 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
2652 /* Find the nearest line to a particular section and offset, for error
2653 reporting. This code is a duplicate of the code in elf.c, except
2654 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
2657 elf32_arm_find_nearest_line
2658 (abfd
, section
, symbols
, offset
, filename_ptr
, functionname_ptr
, line_ptr
)
2663 CONST
char ** filename_ptr
;
2664 CONST
char ** functionname_ptr
;
2665 unsigned int * line_ptr
;
2668 const char * filename
;
2673 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
2674 filename_ptr
, functionname_ptr
,
2676 &elf_tdata (abfd
)->dwarf2_find_line_info
))
2679 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2680 &found
, filename_ptr
,
2681 functionname_ptr
, line_ptr
,
2682 &elf_tdata (abfd
)->line_info
))
2688 if (symbols
== NULL
)
2695 for (p
= symbols
; *p
!= NULL
; p
++)
2699 q
= (elf_symbol_type
*) *p
;
2701 if (bfd_get_section (&q
->symbol
) != section
)
2704 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
2709 filename
= bfd_asymbol_name (&q
->symbol
);
2714 if (q
->symbol
.section
== section
2715 && q
->symbol
.value
>= low_func
2716 && q
->symbol
.value
<= offset
)
2718 func
= (asymbol
*) q
;
2719 low_func
= q
->symbol
.value
;
2728 *filename_ptr
= filename
;
2729 *functionname_ptr
= bfd_asymbol_name (func
);
2735 /* Adjust a symbol defined by a dynamic object and referenced by a
2736 regular object. The current definition is in some section of the
2737 dynamic object, but we're not including those sections. We have to
2738 change the definition to something the rest of the link can
2742 elf32_arm_adjust_dynamic_symbol (info
, h
)
2743 struct bfd_link_info
* info
;
2744 struct elf_link_hash_entry
* h
;
2748 unsigned int power_of_two
;
2750 dynobj
= elf_hash_table (info
)->dynobj
;
2752 /* Make sure we know what is going on here. */
2753 BFD_ASSERT (dynobj
!= NULL
2754 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
2755 || h
->weakdef
!= NULL
2756 || ((h
->elf_link_hash_flags
2757 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2758 && (h
->elf_link_hash_flags
2759 & ELF_LINK_HASH_REF_REGULAR
) != 0
2760 && (h
->elf_link_hash_flags
2761 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
2763 /* If this is a function, put it in the procedure linkage table. We
2764 will fill in the contents of the procedure linkage table later,
2765 when we know the address of the .got section. */
2766 if (h
->type
== STT_FUNC
2767 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
2770 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
2771 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0)
2773 /* This case can occur if we saw a PLT32 reloc in an input
2774 file, but the symbol was never referred to by a dynamic
2775 object. In such a case, we don't actually need to build
2776 a procedure linkage table, and we can just do a PC32
2778 BFD_ASSERT ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0);
2782 /* Make sure this symbol is output as a dynamic symbol. */
2783 if (h
->dynindx
== -1)
2785 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2789 s
= bfd_get_section_by_name (dynobj
, ".plt");
2790 BFD_ASSERT (s
!= NULL
);
2792 /* If this is the first .plt entry, make room for the special
2794 if (s
->_raw_size
== 0)
2795 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2797 /* If this symbol is not defined in a regular file, and we are
2798 not generating a shared library, then set the symbol to this
2799 location in the .plt. This is required to make function
2800 pointers compare as equal between the normal executable and
2801 the shared library. */
2803 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2805 h
->root
.u
.def
.section
= s
;
2806 h
->root
.u
.def
.value
= s
->_raw_size
;
2809 h
->plt
.offset
= s
->_raw_size
;
2811 /* Make room for this entry. */
2812 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2814 /* We also need to make an entry in the .got.plt section, which
2815 will be placed in the .got section by the linker script. */
2816 s
= bfd_get_section_by_name (dynobj
, ".got.plt");
2817 BFD_ASSERT (s
!= NULL
);
2820 /* We also need to make an entry in the .rel.plt section. */
2822 s
= bfd_get_section_by_name (dynobj
, ".rel.plt");
2823 BFD_ASSERT (s
!= NULL
);
2824 s
->_raw_size
+= sizeof (Elf32_External_Rel
);
2829 /* If this is a weak symbol, and there is a real definition, the
2830 processor independent code will have arranged for us to see the
2831 real definition first, and we can just use the same value. */
2832 if (h
->weakdef
!= NULL
)
2834 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
2835 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
2836 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
2837 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
2841 /* This is a reference to a symbol defined by a dynamic object which
2842 is not a function. */
2844 /* If we are creating a shared library, we must presume that the
2845 only references to the symbol are via the global offset table.
2846 For such cases we need not do anything here; the relocations will
2847 be handled correctly by relocate_section. */
2851 /* We must allocate the symbol in our .dynbss section, which will
2852 become part of the .bss section of the executable. There will be
2853 an entry for this symbol in the .dynsym section. The dynamic
2854 object will contain position independent code, so all references
2855 from the dynamic object to this symbol will go through the global
2856 offset table. The dynamic linker will use the .dynsym entry to
2857 determine the address it must put in the global offset table, so
2858 both the dynamic object and the regular object will refer to the
2859 same memory location for the variable. */
2860 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
2861 BFD_ASSERT (s
!= NULL
);
2863 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
2864 copy the initial value out of the dynamic object and into the
2865 runtime process image. We need to remember the offset into the
2866 .rel.bss section we are going to use. */
2867 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2871 srel
= bfd_get_section_by_name (dynobj
, ".rel.bss");
2872 BFD_ASSERT (srel
!= NULL
);
2873 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
2874 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
2877 /* We need to figure out the alignment required for this symbol. I
2878 have no idea how ELF linkers handle this. */
2879 power_of_two
= bfd_log2 (h
->size
);
2880 if (power_of_two
> 3)
2883 /* Apply the required alignment. */
2884 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
2885 (bfd_size_type
) (1 << power_of_two
));
2886 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
2888 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
2892 /* Define the symbol as being at this point in the section. */
2893 h
->root
.u
.def
.section
= s
;
2894 h
->root
.u
.def
.value
= s
->_raw_size
;
2896 /* Increment the section size to make room for the symbol. */
2897 s
->_raw_size
+= h
->size
;
2902 /* Set the sizes of the dynamic sections. */
2905 elf32_arm_size_dynamic_sections (output_bfd
, info
)
2907 struct bfd_link_info
* info
;
2915 dynobj
= elf_hash_table (info
)->dynobj
;
2916 BFD_ASSERT (dynobj
!= NULL
);
2918 if (elf_hash_table (info
)->dynamic_sections_created
)
2920 /* Set the contents of the .interp section to the interpreter. */
2923 s
= bfd_get_section_by_name (dynobj
, ".interp");
2924 BFD_ASSERT (s
!= NULL
);
2925 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2926 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2931 /* We may have created entries in the .rel.got section.
2932 However, if we are not creating the dynamic sections, we will
2933 not actually use these entries. Reset the size of .rel.got,
2934 which will cause it to get stripped from the output file
2936 s
= bfd_get_section_by_name (dynobj
, ".rel.got");
2941 /* If this is a -Bsymbolic shared link, then we need to discard all
2942 PC relative relocs against symbols defined in a regular object.
2943 We allocated space for them in the check_relocs routine, but we
2944 will not fill them in in the relocate_section routine. */
2945 if (info
->shared
&& info
->symbolic
)
2946 elf32_arm_link_hash_traverse (elf32_arm_hash_table (info
),
2947 elf32_arm_discard_copies
,
2950 /* The check_relocs and adjust_dynamic_symbol entry points have
2951 determined the sizes of the various dynamic sections. Allocate
2956 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2961 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2964 /* It's OK to base decisions on the section name, because none
2965 of the dynobj section names depend upon the input files. */
2966 name
= bfd_get_section_name (dynobj
, s
);
2970 if (strcmp (name
, ".plt") == 0)
2972 if (s
->_raw_size
== 0)
2974 /* Strip this section if we don't need it; see the
2980 /* Remember whether there is a PLT. */
2984 else if (strncmp (name
, ".rel", 4) == 0)
2986 if (s
->_raw_size
== 0)
2988 /* If we don't need this section, strip it from the
2989 output file. This is mostly to handle .rel.bss and
2990 .rel.plt. We must create both sections in
2991 create_dynamic_sections, because they must be created
2992 before the linker maps input sections to output
2993 sections. The linker does that before
2994 adjust_dynamic_symbol is called, and it is that
2995 function which decides whether anything needs to go
2996 into these sections. */
3003 /* Remember whether there are any reloc sections other
3005 if (strcmp (name
, ".rel.plt") != 0)
3007 const char *outname
;
3011 /* If this relocation section applies to a read only
3012 section, then we probably need a DT_TEXTREL
3013 entry. The entries in the .rel.plt section
3014 really apply to the .got section, which we
3015 created ourselves and so know is not readonly. */
3016 outname
= bfd_get_section_name (output_bfd
,
3018 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
3021 && (target
->flags
& SEC_READONLY
) != 0
3022 && (target
->flags
& SEC_ALLOC
) != 0)
3026 /* We use the reloc_count field as a counter if we need
3027 to copy relocs into the output file. */
3031 else if (strncmp (name
, ".got", 4) != 0)
3033 /* It's not one of our sections, so don't allocate space. */
3041 for (spp
= &s
->output_section
->owner
->sections
;
3042 *spp
!= s
->output_section
;
3043 spp
= &(*spp
)->next
)
3045 *spp
= s
->output_section
->next
;
3046 --s
->output_section
->owner
->section_count
;
3051 /* Allocate memory for the section contents. */
3052 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
3053 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
3057 if (elf_hash_table (info
)->dynamic_sections_created
)
3059 /* Add some entries to the .dynamic section. We fill in the
3060 values later, in elf32_arm_finish_dynamic_sections, but we
3061 must add the entries now so that we get the correct size for
3062 the .dynamic section. The DT_DEBUG entry is filled in by the
3063 dynamic linker and used by the debugger. */
3066 if (! bfd_elf32_add_dynamic_entry (info
, DT_DEBUG
, 0))
3072 if ( ! bfd_elf32_add_dynamic_entry (info
, DT_PLTGOT
, 0)
3073 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
3074 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTREL
, DT_REL
)
3075 || ! bfd_elf32_add_dynamic_entry (info
, DT_JMPREL
, 0))
3081 if ( ! bfd_elf32_add_dynamic_entry (info
, DT_REL
, 0)
3082 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELSZ
, 0)
3083 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELENT
,
3084 sizeof (Elf32_External_Rel
)))
3090 if (! bfd_elf32_add_dynamic_entry (info
, DT_TEXTREL
, 0))
3092 info
->flags
|= DF_TEXTREL
;
3099 /* This function is called via elf32_arm_link_hash_traverse if we are
3100 creating a shared object with -Bsymbolic. It discards the space
3101 allocated to copy PC relative relocs against symbols which are
3102 defined in regular objects. We allocated space for them in the
3103 check_relocs routine, but we won't fill them in in the
3104 relocate_section routine. */
3107 elf32_arm_discard_copies (h
, ignore
)
3108 struct elf32_arm_link_hash_entry
* h
;
3109 PTR ignore ATTRIBUTE_UNUSED
;
3111 struct elf32_arm_pcrel_relocs_copied
* s
;
3113 /* We only discard relocs for symbols defined in a regular object. */
3114 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3117 for (s
= h
->pcrel_relocs_copied
; s
!= NULL
; s
= s
->next
)
3118 s
->section
->_raw_size
-= s
->count
* sizeof (Elf32_External_Rel
);
3123 /* Finish up dynamic symbol handling. We set the contents of various
3124 dynamic sections here. */
3127 elf32_arm_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
3129 struct bfd_link_info
* info
;
3130 struct elf_link_hash_entry
* h
;
3131 Elf_Internal_Sym
* sym
;
3135 dynobj
= elf_hash_table (info
)->dynobj
;
3137 if (h
->plt
.offset
!= (bfd_vma
) -1)
3144 Elf_Internal_Rel rel
;
3146 /* This symbol has an entry in the procedure linkage table. Set
3149 BFD_ASSERT (h
->dynindx
!= -1);
3151 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3152 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3153 srel
= bfd_get_section_by_name (dynobj
, ".rel.plt");
3154 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
3156 /* Get the index in the procedure linkage table which
3157 corresponds to this symbol. This is the index of this symbol
3158 in all the symbols for which we are making plt entries. The
3159 first entry in the procedure linkage table is reserved. */
3160 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
3162 /* Get the offset into the .got table of the entry that
3163 corresponds to this function. Each .got entry is 4 bytes.
3164 The first three are reserved. */
3165 got_offset
= (plt_index
+ 3) * 4;
3167 /* Fill in the entry in the procedure linkage table. */
3168 memcpy (splt
->contents
+ h
->plt
.offset
,
3169 elf32_arm_plt_entry
,
3171 bfd_put_32 (output_bfd
,
3172 (sgot
->output_section
->vma
3173 + sgot
->output_offset
3175 - splt
->output_section
->vma
3176 - splt
->output_offset
3177 - h
->plt
.offset
- 12),
3178 splt
->contents
+ h
->plt
.offset
+ 12);
3180 /* Fill in the entry in the global offset table. */
3181 bfd_put_32 (output_bfd
,
3182 (splt
->output_section
->vma
3183 + splt
->output_offset
),
3184 sgot
->contents
+ got_offset
);
3186 /* Fill in the entry in the .rel.plt section. */
3187 rel
.r_offset
= (sgot
->output_section
->vma
3188 + sgot
->output_offset
3190 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_JUMP_SLOT
);
3191 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3192 ((Elf32_External_Rel
*) srel
->contents
3195 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3197 /* Mark the symbol as undefined, rather than as defined in
3198 the .plt section. Leave the value alone. */
3199 sym
->st_shndx
= SHN_UNDEF
;
3200 /* If the symbol is weak, we do need to clear the value.
3201 Otherwise, the PLT entry would provide a definition for
3202 the symbol even if the symbol wasn't defined anywhere,
3203 and so the symbol would never be NULL. */
3204 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR_NONWEAK
)
3210 if (h
->got
.offset
!= (bfd_vma
) -1)
3214 Elf_Internal_Rel rel
;
3216 /* This symbol has an entry in the global offset table. Set it
3218 sgot
= bfd_get_section_by_name (dynobj
, ".got");
3219 srel
= bfd_get_section_by_name (dynobj
, ".rel.got");
3220 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
3222 rel
.r_offset
= (sgot
->output_section
->vma
3223 + sgot
->output_offset
3224 + (h
->got
.offset
&~ 1));
3226 /* If this is a -Bsymbolic link, and the symbol is defined
3227 locally, we just want to emit a RELATIVE reloc. The entry in
3228 the global offset table will already have been initialized in
3229 the relocate_section function. */
3231 && (info
->symbolic
|| h
->dynindx
== -1)
3232 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
3233 rel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
3236 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
3237 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_GLOB_DAT
);
3240 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3241 ((Elf32_External_Rel
*) srel
->contents
3242 + srel
->reloc_count
));
3243 ++srel
->reloc_count
;
3246 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
3249 Elf_Internal_Rel rel
;
3251 /* This symbol needs a copy reloc. Set it up. */
3252 BFD_ASSERT (h
->dynindx
!= -1
3253 && (h
->root
.type
== bfd_link_hash_defined
3254 || h
->root
.type
== bfd_link_hash_defweak
));
3256 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
3258 BFD_ASSERT (s
!= NULL
);
3260 rel
.r_offset
= (h
->root
.u
.def
.value
3261 + h
->root
.u
.def
.section
->output_section
->vma
3262 + h
->root
.u
.def
.section
->output_offset
);
3263 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_COPY
);
3264 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3265 ((Elf32_External_Rel
*) s
->contents
3270 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3271 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3272 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
3273 sym
->st_shndx
= SHN_ABS
;
3278 /* Finish up the dynamic sections. */
3281 elf32_arm_finish_dynamic_sections (output_bfd
, info
)
3283 struct bfd_link_info
* info
;
3289 dynobj
= elf_hash_table (info
)->dynobj
;
3291 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3292 BFD_ASSERT (sgot
!= NULL
);
3293 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3295 if (elf_hash_table (info
)->dynamic_sections_created
)
3298 Elf32_External_Dyn
*dyncon
, *dynconend
;
3300 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3301 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3303 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3304 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
3306 for (; dyncon
< dynconend
; dyncon
++)
3308 Elf_Internal_Dyn dyn
;
3312 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3325 s
= bfd_get_section_by_name (output_bfd
, name
);
3326 BFD_ASSERT (s
!= NULL
);
3327 dyn
.d_un
.d_ptr
= s
->vma
;
3328 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3332 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3333 BFD_ASSERT (s
!= NULL
);
3334 if (s
->_cooked_size
!= 0)
3335 dyn
.d_un
.d_val
= s
->_cooked_size
;
3337 dyn
.d_un
.d_val
= s
->_raw_size
;
3338 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3342 /* My reading of the SVR4 ABI indicates that the
3343 procedure linkage table relocs (DT_JMPREL) should be
3344 included in the overall relocs (DT_REL). This is
3345 what Solaris does. However, UnixWare can not handle
3346 that case. Therefore, we override the DT_RELSZ entry
3347 here to make it not include the JMPREL relocs. Since
3348 the linker script arranges for .rel.plt to follow all
3349 other relocation sections, we don't have to worry
3350 about changing the DT_REL entry. */
3351 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3354 if (s
->_cooked_size
!= 0)
3355 dyn
.d_un
.d_val
-= s
->_cooked_size
;
3357 dyn
.d_un
.d_val
-= s
->_raw_size
;
3359 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3364 /* Fill in the first entry in the procedure linkage table. */
3365 if (splt
->_raw_size
> 0)
3366 memcpy (splt
->contents
, elf32_arm_plt0_entry
, PLT_ENTRY_SIZE
);
3368 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3369 really seem like the right value. */
3370 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
3373 /* Fill in the first three entries in the global offset table. */
3374 if (sgot
->_raw_size
> 0)
3377 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
3379 bfd_put_32 (output_bfd
,
3380 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3382 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
3383 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
3386 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
3392 elf32_arm_post_process_headers (abfd
, link_info
)
3394 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
;
3396 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
3398 i_ehdrp
= elf_elfheader (abfd
);
3400 i_ehdrp
->e_ident
[EI_OSABI
] = ARM_ELF_OS_ABI_VERSION
;
3401 i_ehdrp
->e_ident
[EI_ABIVERSION
] = ARM_ELF_ABI_VERSION
;
3404 #define ELF_ARCH bfd_arch_arm
3405 #define ELF_MACHINE_CODE EM_ARM
3406 #define ELF_MAXPAGESIZE 0x8000
3408 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
3409 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
3410 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
3411 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
3412 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
3413 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
3414 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
3416 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
3417 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
3418 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
3419 #define elf_backend_check_relocs elf32_arm_check_relocs
3420 #define elf_backend_relocate_section elf32_arm_relocate_section
3421 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
3422 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
3423 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
3424 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
3425 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
3426 #define elf_backend_post_process_headers elf32_arm_post_process_headers
3428 #define elf_backend_can_gc_sections 1
3429 #define elf_backend_plt_readonly 1
3430 #define elf_backend_want_got_plt 1
3431 #define elf_backend_want_plt_sym 0
3433 #define elf_backend_got_header_size 12
3434 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
3436 #include "elf32-target.h"