1 /* 32-bit ELF support for ARM
2 Copyright 1998, 1999, 2000 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);
1437 if (r_type
== R_ARM_THM_XPC22
1438 && ((lower_insn
& 0x1800) == 0x0800))
1439 /* Remove bit zero of the adjusted offset. Bit zero can only be
1440 set if the upper insn is at a half-word boundary, since the
1441 destination address, an ARM instruction, must always be on a
1442 word boundary. The semantics of the BLX (1) instruction, however,
1443 are that bit zero in the offset must always be zero, and the
1444 corresponding bit one in the target address will be set from bit
1445 one of the source address. */
1448 /* Put the relocated value back in the object file: */
1449 bfd_put_16 (input_bfd
, upper_insn
, hit_data
);
1450 bfd_put_16 (input_bfd
, lower_insn
, hit_data
+ 2);
1452 return (overflow
? bfd_reloc_overflow
: bfd_reloc_ok
);
1456 case R_ARM_GNU_VTINHERIT
:
1457 case R_ARM_GNU_VTENTRY
:
1458 return bfd_reloc_ok
;
1461 return bfd_reloc_notsupported
;
1463 case R_ARM_GLOB_DAT
:
1464 return bfd_reloc_notsupported
;
1466 case R_ARM_JUMP_SLOT
:
1467 return bfd_reloc_notsupported
;
1469 case R_ARM_RELATIVE
:
1470 return bfd_reloc_notsupported
;
1473 /* Relocation is relative to the start of the
1474 global offset table. */
1476 BFD_ASSERT (sgot
!= NULL
);
1478 return bfd_reloc_notsupported
;
1480 /* Note that sgot->output_offset is not involved in this
1481 calculation. We always want the start of .got. If we
1482 define _GLOBAL_OFFSET_TABLE in a different way, as is
1483 permitted by the ABI, we might have to change this
1485 value
-= sgot
->output_section
->vma
;
1486 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1487 contents
, rel
->r_offset
, value
,
1491 /* Use global offset table as symbol value. */
1492 BFD_ASSERT (sgot
!= NULL
);
1495 return bfd_reloc_notsupported
;
1497 value
= sgot
->output_section
->vma
;
1498 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1499 contents
, rel
->r_offset
, value
,
1503 /* Relocation is to the entry for this symbol in the
1504 global offset table. */
1506 return bfd_reloc_notsupported
;
1512 off
= h
->got
.offset
;
1513 BFD_ASSERT (off
!= (bfd_vma
) -1);
1515 if (!elf_hash_table (info
)->dynamic_sections_created
||
1516 (info
->shared
&& (info
->symbolic
|| h
->dynindx
== -1)
1517 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1519 /* This is actually a static link, or it is a -Bsymbolic link
1520 and the symbol is defined locally. We must initialize this
1521 entry in the global offset table. Since the offset must
1522 always be a multiple of 4, we use the least significant bit
1523 to record whether we have initialized it already.
1525 When doing a dynamic link, we create a .rel.got relocation
1526 entry to initialize the value. This is done in the
1527 finish_dynamic_symbol routine. */
1532 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1537 value
= sgot
->output_offset
+ off
;
1543 BFD_ASSERT (local_got_offsets
!= NULL
&&
1544 local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1546 off
= local_got_offsets
[r_symndx
];
1548 /* The offset must always be a multiple of 4. We use the
1549 least significant bit to record whether we have already
1550 generated the necessary reloc. */
1555 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1560 Elf_Internal_Rel outrel
;
1562 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
1563 BFD_ASSERT (srelgot
!= NULL
);
1565 outrel
.r_offset
= (sgot
->output_section
->vma
1566 + sgot
->output_offset
1568 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1569 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1570 (((Elf32_External_Rel
*)
1572 + srelgot
->reloc_count
));
1573 ++srelgot
->reloc_count
;
1576 local_got_offsets
[r_symndx
] |= 1;
1579 value
= sgot
->output_offset
+ off
;
1582 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1583 contents
, rel
->r_offset
, value
,
1587 /* Relocation is to the entry for this symbol in the
1588 procedure linkage table. */
1590 /* Resolve a PLT32 reloc against a local symbol directly,
1591 without using the procedure linkage table. */
1593 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1594 contents
, rel
->r_offset
, value
,
1597 if (h
->plt
.offset
== (bfd_vma
) -1)
1598 /* We didn't make a PLT entry for this symbol. This
1599 happens when statically linking PIC code, or when
1600 using -Bsymbolic. */
1601 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1602 contents
, rel
->r_offset
, value
,
1605 BFD_ASSERT(splt
!= NULL
);
1607 return bfd_reloc_notsupported
;
1609 value
= (splt
->output_section
->vma
1610 + splt
->output_offset
1612 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1613 contents
, rel
->r_offset
, value
,
1617 return bfd_reloc_notsupported
;
1619 case R_ARM_AMP_VCALL9
:
1620 return bfd_reloc_notsupported
;
1622 case R_ARM_RSBREL32
:
1623 return bfd_reloc_notsupported
;
1625 case R_ARM_THM_RPC22
:
1626 return bfd_reloc_notsupported
;
1629 return bfd_reloc_notsupported
;
1632 return bfd_reloc_notsupported
;
1635 return bfd_reloc_notsupported
;
1638 return bfd_reloc_notsupported
;
1641 return bfd_reloc_notsupported
;
1646 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
1648 arm_add_to_rel (abfd
, address
, howto
, increment
)
1651 reloc_howto_type
* howto
;
1652 bfd_signed_vma increment
;
1654 bfd_signed_vma addend
;
1656 if (howto
->type
== R_ARM_THM_PC22
)
1658 int upper_insn
, lower_insn
;
1661 upper_insn
= bfd_get_16 (abfd
, address
);
1662 lower_insn
= bfd_get_16 (abfd
, address
+ 2);
1663 upper
= upper_insn
& 0x7ff;
1664 lower
= lower_insn
& 0x7ff;
1666 addend
= (upper
<< 12) | (lower
<< 1);
1667 addend
+= increment
;
1670 upper_insn
= (upper_insn
& 0xf800) | ((addend
>> 11) & 0x7ff);
1671 lower_insn
= (lower_insn
& 0xf800) | (addend
& 0x7ff);
1673 bfd_put_16 (abfd
, upper_insn
, address
);
1674 bfd_put_16 (abfd
, lower_insn
, address
+ 2);
1680 contents
= bfd_get_32 (abfd
, address
);
1682 /* Get the (signed) value from the instruction. */
1683 addend
= contents
& howto
->src_mask
;
1684 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1686 bfd_signed_vma mask
;
1689 mask
&= ~ howto
->src_mask
;
1693 /* Add in the increment, (which is a byte value). */
1694 switch (howto
->type
)
1697 addend
+= increment
;
1701 addend
<<= howto
->size
;
1702 addend
+= increment
;
1704 /* Should we check for overflow here ? */
1706 /* Drop any undesired bits. */
1707 addend
>>= howto
->rightshift
;
1711 contents
= (contents
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
1713 bfd_put_32 (abfd
, contents
, address
);
1716 #endif /* USE_REL */
1718 /* Relocate an ARM ELF section. */
1720 elf32_arm_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1721 contents
, relocs
, local_syms
, local_sections
)
1723 struct bfd_link_info
* info
;
1725 asection
* input_section
;
1726 bfd_byte
* contents
;
1727 Elf_Internal_Rela
* relocs
;
1728 Elf_Internal_Sym
* local_syms
;
1729 asection
** local_sections
;
1731 Elf_Internal_Shdr
* symtab_hdr
;
1732 struct elf_link_hash_entry
** sym_hashes
;
1733 Elf_Internal_Rela
* rel
;
1734 Elf_Internal_Rela
* relend
;
1737 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1738 sym_hashes
= elf_sym_hashes (input_bfd
);
1741 relend
= relocs
+ input_section
->reloc_count
;
1742 for (; rel
< relend
; rel
++)
1745 reloc_howto_type
* howto
;
1746 unsigned long r_symndx
;
1747 Elf_Internal_Sym
* sym
;
1749 struct elf_link_hash_entry
* h
;
1751 bfd_reloc_status_type r
;
1754 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1755 r_type
= ELF32_R_TYPE (rel
->r_info
);
1757 if ( r_type
== R_ARM_GNU_VTENTRY
1758 || r_type
== R_ARM_GNU_VTINHERIT
)
1761 elf32_arm_info_to_howto (input_bfd
, & bfd_reloc
, rel
);
1762 howto
= bfd_reloc
.howto
;
1764 if (info
->relocateable
)
1766 /* This is a relocateable link. We don't have to change
1767 anything, unless the reloc is against a section symbol,
1768 in which case we have to adjust according to where the
1769 section symbol winds up in the output section. */
1770 if (r_symndx
< symtab_hdr
->sh_info
)
1772 sym
= local_syms
+ r_symndx
;
1773 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1775 sec
= local_sections
[r_symndx
];
1777 arm_add_to_rel (input_bfd
, contents
+ rel
->r_offset
,
1778 howto
, sec
->output_offset
+ sym
->st_value
);
1780 rel
->r_addend
+= (sec
->output_offset
+ sym
->st_value
)
1781 >> howto
->rightshift
;
1789 /* This is a final link. */
1794 if (r_symndx
< symtab_hdr
->sh_info
)
1796 sym
= local_syms
+ r_symndx
;
1797 sec
= local_sections
[r_symndx
];
1798 relocation
= (sec
->output_section
->vma
1799 + sec
->output_offset
1804 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1806 while ( h
->root
.type
== bfd_link_hash_indirect
1807 || h
->root
.type
== bfd_link_hash_warning
)
1808 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1810 if ( h
->root
.type
== bfd_link_hash_defined
1811 || h
->root
.type
== bfd_link_hash_defweak
)
1813 int relocation_needed
= 1;
1815 sec
= h
->root
.u
.def
.section
;
1817 /* In these cases, we don't need the relocation value.
1818 We check specially because in some obscure cases
1819 sec->output_section will be NULL. */
1826 (!info
->symbolic
&& h
->dynindx
!= -1)
1827 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1829 && ((input_section
->flags
& SEC_ALLOC
) != 0
1830 /* DWARF will emit R_ARM_ABS32 relocations in its
1831 sections against symbols defined externally
1832 in shared libraries. We can't do anything
1834 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
1835 && (h
->elf_link_hash_flags
1836 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
1838 relocation_needed
= 0;
1842 relocation_needed
= 0;
1846 if (elf_hash_table(info
)->dynamic_sections_created
1848 || (!info
->symbolic
&& h
->dynindx
!= -1)
1849 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1852 relocation_needed
= 0;
1856 if (h
->plt
.offset
!= (bfd_vma
)-1)
1857 relocation_needed
= 0;
1861 if (sec
->output_section
== NULL
)
1863 (*_bfd_error_handler
)
1864 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1865 bfd_get_filename (input_bfd
), h
->root
.root
.string
,
1866 bfd_get_section_name (input_bfd
, input_section
));
1867 relocation_needed
= 0;
1871 if (relocation_needed
)
1872 relocation
= h
->root
.u
.def
.value
1873 + sec
->output_section
->vma
1874 + sec
->output_offset
;
1878 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1880 else if (info
->shared
&& !info
->symbolic
1881 && !info
->no_undefined
1882 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1886 if (!((*info
->callbacks
->undefined_symbol
)
1887 (info
, h
->root
.root
.string
, input_bfd
,
1888 input_section
, rel
->r_offset
,
1889 (!info
->shared
|| info
->no_undefined
1890 || ELF_ST_VISIBILITY (h
->other
)))))
1897 name
= h
->root
.root
.string
;
1900 name
= (bfd_elf_string_from_elf_section
1901 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
1902 if (name
== NULL
|| *name
== '\0')
1903 name
= bfd_section_name (input_bfd
, sec
);
1906 r
= elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
1907 input_section
, contents
, rel
,
1908 relocation
, info
, sec
, name
,
1909 (h
? ELF_ST_TYPE (h
->type
) :
1910 ELF_ST_TYPE (sym
->st_info
)), h
);
1912 if (r
!= bfd_reloc_ok
)
1914 const char * msg
= (const char *) 0;
1918 case bfd_reloc_overflow
:
1919 /* If the overflowing reloc was to an undefined symbol,
1920 we have already printed one error message and there
1921 is no point complaining again. */
1923 h
->root
.type
!= bfd_link_hash_undefined
)
1924 && (!((*info
->callbacks
->reloc_overflow
)
1925 (info
, name
, howto
->name
, (bfd_vma
) 0,
1926 input_bfd
, input_section
, rel
->r_offset
))))
1930 case bfd_reloc_undefined
:
1931 if (!((*info
->callbacks
->undefined_symbol
)
1932 (info
, name
, input_bfd
, input_section
,
1933 rel
->r_offset
, true)))
1937 case bfd_reloc_outofrange
:
1938 msg
= _("internal error: out of range error");
1941 case bfd_reloc_notsupported
:
1942 msg
= _("internal error: unsupported relocation error");
1945 case bfd_reloc_dangerous
:
1946 msg
= _("internal error: dangerous error");
1950 msg
= _("internal error: unknown error");
1954 if (!((*info
->callbacks
->warning
)
1955 (info
, msg
, name
, input_bfd
, input_section
,
1966 /* Function to keep ARM specific flags in the ELF header. */
1968 elf32_arm_set_private_flags (abfd
, flags
)
1972 if (elf_flags_init (abfd
)
1973 && elf_elfheader (abfd
)->e_flags
!= flags
)
1975 if (EF_ARM_EABI_VERSION (flags
) == EF_ARM_EABI_UNKNOWN
)
1977 if (flags
& EF_ARM_INTERWORK
)
1978 _bfd_error_handler (_("\
1979 Warning: Not setting interwork flag of %s since it has already been specified as non-interworking"),
1980 bfd_get_filename (abfd
));
1982 _bfd_error_handler (_("\
1983 Warning: Clearing the interwork flag of %s due to outside request"),
1984 bfd_get_filename (abfd
));
1989 elf_elfheader (abfd
)->e_flags
= flags
;
1990 elf_flags_init (abfd
) = true;
1996 /* Copy backend specific data from one object module to another. */
1999 elf32_arm_copy_private_bfd_data (ibfd
, obfd
)
2006 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2007 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2010 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2011 out_flags
= elf_elfheader (obfd
)->e_flags
;
2013 if (elf_flags_init (obfd
)
2014 && EF_ARM_EABI_VERSION (out_flags
) == EF_ARM_EABI_UNKNOWN
2015 && in_flags
!= out_flags
)
2017 /* Cannot mix APCS26 and APCS32 code. */
2018 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2021 /* Cannot mix float APCS and non-float APCS code. */
2022 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2025 /* If the src and dest have different interworking flags
2026 then turn off the interworking bit. */
2027 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2029 if (out_flags
& EF_ARM_INTERWORK
)
2030 _bfd_error_handler (_("\
2031 Warning: Clearing the interwork flag in %s because non-interworking code in %s has been linked with it"),
2032 bfd_get_filename (obfd
), bfd_get_filename (ibfd
));
2034 in_flags
&= ~EF_ARM_INTERWORK
;
2037 /* Likewise for PIC, though don't warn for this case. */
2038 if ((in_flags
& EF_ARM_PIC
) != (out_flags
& EF_ARM_PIC
))
2039 in_flags
&= ~EF_ARM_PIC
;
2042 elf_elfheader (obfd
)->e_flags
= in_flags
;
2043 elf_flags_init (obfd
) = true;
2048 /* Merge backend specific data from an object file to the output
2049 object file when linking. */
2052 elf32_arm_merge_private_bfd_data (ibfd
, obfd
)
2058 boolean flags_compatible
= true;
2059 boolean null_input_bfd
= true;
2062 /* Check if we have the same endianess. */
2063 if (_bfd_generic_verify_endian_match (ibfd
, obfd
) == false)
2066 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2067 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2070 /* The input BFD must have had its flags initialised. */
2071 /* The following seems bogus to me -- The flags are initialized in
2072 the assembler but I don't think an elf_flags_init field is
2073 written into the object. */
2074 /* BFD_ASSERT (elf_flags_init (ibfd)); */
2076 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2077 out_flags
= elf_elfheader (obfd
)->e_flags
;
2079 if (!elf_flags_init (obfd
))
2081 /* If the input is the default architecture and had the default
2082 flags then do not bother setting the flags for the output
2083 architecture, instead allow future merges to do this. If no
2084 future merges ever set these flags then they will retain their
2085 uninitialised values, which surprise surprise, correspond
2086 to the default values. */
2087 if (bfd_get_arch_info (ibfd
)->the_default
2088 && elf_elfheader (ibfd
)->e_flags
== 0)
2091 elf_flags_init (obfd
) = true;
2092 elf_elfheader (obfd
)->e_flags
= in_flags
;
2094 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
2095 && bfd_get_arch_info (obfd
)->the_default
)
2096 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
), bfd_get_mach (ibfd
));
2101 /* Identical flags must be compatible. */
2102 if (in_flags
== out_flags
)
2105 /* Check to see if the input BFD actually contains any sections.
2106 If not, its flags may not have been initialised either, but it cannot
2107 actually cause any incompatibility. */
2108 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2110 /* Ignore synthetic glue sections. */
2111 if (strcmp (sec
->name
, ".glue_7")
2112 && strcmp (sec
->name
, ".glue_7t"))
2114 null_input_bfd
= false;
2121 /* Complain about various flag mismatches. */
2122 if (EF_ARM_EABI_VERSION (in_flags
) != EF_ARM_EABI_VERSION (out_flags
))
2124 _bfd_error_handler (_("\
2125 Error: %s compiled for EABI version %d, whereas %s is compiled for version %d"),
2126 bfd_get_filename (ibfd
),
2127 (in_flags
& EF_ARM_EABIMASK
) >> 24,
2128 bfd_get_filename (obfd
),
2129 (out_flags
& EF_ARM_EABIMASK
) >> 24);
2133 /* Not sure what needs to be checked for EABI versions >= 1. */
2134 if (EF_ARM_EABI_VERSION (in_flags
) == EF_ARM_EABI_UNKNOWN
)
2136 if ((in_flags
& EF_ARM_APCS_26
) != (out_flags
& EF_ARM_APCS_26
))
2138 _bfd_error_handler (_("\
2139 Error: %s compiled for APCS-%d, whereas %s is compiled for APCS-%d"),
2140 bfd_get_filename (ibfd
),
2141 in_flags
& EF_ARM_APCS_26
? 26 : 32,
2142 bfd_get_filename (obfd
),
2143 out_flags
& EF_ARM_APCS_26
? 26 : 32);
2144 flags_compatible
= false;
2147 if ((in_flags
& EF_ARM_APCS_FLOAT
) != (out_flags
& EF_ARM_APCS_FLOAT
))
2149 _bfd_error_handler (_("\
2150 Error: %s passes floats in %s registers, whereas %s passes them in %s registers"),
2151 bfd_get_filename (ibfd
),
2152 in_flags
& EF_ARM_APCS_FLOAT
? _("float") : _("integer"),
2153 bfd_get_filename (obfd
),
2154 out_flags
& EF_ARM_APCS_26
? _("float") : _("integer"));
2155 flags_compatible
= false;
2158 #ifdef EF_ARM_SOFT_FLOAT
2159 if ((in_flags
& EF_ARM_SOFT_FLOAT
) != (out_flags
& EF_ARM_SOFT_FLOAT
))
2161 _bfd_error_handler (_ ("\
2162 Error: %s uses %s floating point, whereas %s uses %s floating point"),
2163 bfd_get_filename (ibfd
),
2164 in_flags
& EF_ARM_SOFT_FLOAT
? _("soft") : _("hard"),
2165 bfd_get_filename (obfd
),
2166 out_flags
& EF_ARM_SOFT_FLOAT
? _("soft") : _("hard"));
2167 flags_compatible
= false;
2171 /* Interworking mismatch is only a warning. */
2172 if ((in_flags
& EF_ARM_INTERWORK
) != (out_flags
& EF_ARM_INTERWORK
))
2173 _bfd_error_handler (_("\
2174 Warning: %s %s interworking, whereas %s %s"),
2175 bfd_get_filename (ibfd
),
2176 in_flags
& EF_ARM_INTERWORK
? _("supports") : _("does not support"),
2177 bfd_get_filename (obfd
),
2178 out_flags
& EF_ARM_INTERWORK
? _("does not") : _("does"));
2181 return flags_compatible
;
2184 /* Display the flags field. */
2187 elf32_arm_print_private_bfd_data (abfd
, ptr
)
2191 FILE * file
= (FILE *) ptr
;
2192 unsigned long flags
;
2194 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
2196 /* Print normal ELF private data. */
2197 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
2199 flags
= elf_elfheader (abfd
)->e_flags
;
2200 /* Ignore init flag - it may not be set, despite the flags field
2201 containing valid data. */
2203 /* xgettext:c-format */
2204 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
2206 switch (EF_ARM_EABI_VERSION (flags
))
2208 case EF_ARM_EABI_UNKNOWN
:
2209 /* The following flag bits are GNU extenstions and not part of the
2210 official ARM ELF extended ABI. Hence they are only decoded if
2211 the EABI version is not set. */
2212 if (flags
& EF_ARM_INTERWORK
)
2213 fprintf (file
, _(" [interworking enabled]"));
2215 if (flags
& EF_ARM_APCS_26
)
2216 fprintf (file
, _(" [APCS-26]"));
2218 fprintf (file
, _(" [APCS-32]"));
2220 if (flags
& EF_ARM_APCS_FLOAT
)
2221 fprintf (file
, _(" [floats passed in float registers]"));
2223 if (flags
& EF_ARM_PIC
)
2224 fprintf (file
, _(" [position independent]"));
2226 if (flags
& EF_ARM_NEW_ABI
)
2227 fprintf (file
, _(" [new ABI]"));
2229 if (flags
& EF_ARM_OLD_ABI
)
2230 fprintf (file
, _(" [old ABI]"));
2232 if (flags
& EF_ARM_SOFT_FLOAT
)
2233 fprintf (file
, _(" [software FP]"));
2235 flags
&= ~(EF_ARM_INTERWORK
| EF_ARM_APCS_26
| EF_ARM_APCS_FLOAT
| EF_ARM_PIC
2236 | EF_ARM_NEW_ABI
| EF_ARM_OLD_ABI
| EF_ARM_SOFT_FLOAT
);
2239 case EF_ARM_EABI_VER1
:
2240 fprintf (file
, _(" [Version1 EABI]"));
2242 if (flags
& EF_ARM_SYMSARESORTED
)
2243 fprintf (file
, _(" [sorted symbol table]"));
2245 fprintf (file
, _(" [unsorted symbol table]"));
2247 flags
&= ~ EF_ARM_SYMSARESORTED
;
2250 case EF_ARM_EABI_VER2
:
2251 fprintf (file
, _(" [Version2 EABI]"));
2253 if (flags
& EF_ARM_SYMSARESORTED
)
2254 fprintf (file
, _(" [sorted symbol table]"));
2256 fprintf (file
, _(" [unsorted symbol table]"));
2258 if (flags
& EF_ARM_DYNSYMSUSESEGIDX
)
2259 fprintf (file
, _(" [dynamic symbols use segment index]"));
2261 if (flags
& EF_ARM_MAPSYMSFIRST
)
2262 fprintf (file
, _(" [mapping symbols precede others]"));
2264 flags
&= ~(EF_ARM_SYMSARESORTED
| EF_ARM_DYNSYMSUSESEGIDX
2265 | EF_ARM_MAPSYMSFIRST
);
2269 fprintf (file
, _(" <EABI version unrecognised>"));
2273 flags
&= ~ EF_ARM_EABIMASK
;
2275 if (flags
& EF_ARM_RELEXEC
)
2276 fprintf (file
, _(" [relocatable executable]"));
2278 if (flags
& EF_ARM_HASENTRY
)
2279 fprintf (file
, _(" [has entry point]"));
2281 flags
&= ~ (EF_ARM_RELEXEC
| EF_ARM_HASENTRY
);
2284 fprintf (file
, _("<Unrecognised flag bits set>"));
2292 elf32_arm_get_symbol_type (elf_sym
, type
)
2293 Elf_Internal_Sym
* elf_sym
;
2296 switch (ELF_ST_TYPE (elf_sym
->st_info
))
2299 return ELF_ST_TYPE (elf_sym
->st_info
);
2302 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2303 This allows us to distinguish between data used by Thumb instructions
2304 and non-data (which is probably code) inside Thumb regions of an
2306 if (type
!= STT_OBJECT
)
2307 return ELF_ST_TYPE (elf_sym
->st_info
);
2318 elf32_arm_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
2320 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2321 Elf_Internal_Rela
*rel
;
2322 struct elf_link_hash_entry
*h
;
2323 Elf_Internal_Sym
*sym
;
2327 switch (ELF32_R_TYPE (rel
->r_info
))
2329 case R_ARM_GNU_VTINHERIT
:
2330 case R_ARM_GNU_VTENTRY
:
2334 switch (h
->root
.type
)
2336 case bfd_link_hash_defined
:
2337 case bfd_link_hash_defweak
:
2338 return h
->root
.u
.def
.section
;
2340 case bfd_link_hash_common
:
2341 return h
->root
.u
.c
.p
->section
;
2350 if (!(elf_bad_symtab (abfd
)
2351 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
2352 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
2353 && sym
->st_shndx
!= SHN_COMMON
))
2355 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
2361 /* Update the got entry reference counts for the section being removed. */
2364 elf32_arm_gc_sweep_hook (abfd
, info
, sec
, relocs
)
2365 bfd
*abfd ATTRIBUTE_UNUSED
;
2366 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2367 asection
*sec ATTRIBUTE_UNUSED
;
2368 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
;
2370 /* We don't support garbage collection of GOT and PLT relocs yet. */
2374 /* Look through the relocs for a section during the first phase. */
2377 elf32_arm_check_relocs (abfd
, info
, sec
, relocs
)
2379 struct bfd_link_info
* info
;
2381 const Elf_Internal_Rela
* relocs
;
2383 Elf_Internal_Shdr
* symtab_hdr
;
2384 struct elf_link_hash_entry
** sym_hashes
;
2385 struct elf_link_hash_entry
** sym_hashes_end
;
2386 const Elf_Internal_Rela
* rel
;
2387 const Elf_Internal_Rela
* rel_end
;
2389 asection
* sgot
, *srelgot
, *sreloc
;
2390 bfd_vma
* local_got_offsets
;
2392 if (info
->relocateable
)
2395 sgot
= srelgot
= sreloc
= NULL
;
2397 dynobj
= elf_hash_table (info
)->dynobj
;
2398 local_got_offsets
= elf_local_got_offsets (abfd
);
2400 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2401 sym_hashes
= elf_sym_hashes (abfd
);
2402 sym_hashes_end
= sym_hashes
2403 + symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
2405 if (!elf_bad_symtab (abfd
))
2406 sym_hashes_end
-= symtab_hdr
->sh_info
;
2408 rel_end
= relocs
+ sec
->reloc_count
;
2409 for (rel
= relocs
; rel
< rel_end
; rel
++)
2411 struct elf_link_hash_entry
*h
;
2412 unsigned long r_symndx
;
2414 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2415 if (r_symndx
< symtab_hdr
->sh_info
)
2418 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2420 /* Some relocs require a global offset table. */
2423 switch (ELF32_R_TYPE (rel
->r_info
))
2428 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
2429 if (! _bfd_elf_create_got_section (dynobj
, info
))
2438 switch (ELF32_R_TYPE (rel
->r_info
))
2441 /* This symbol requires a global offset table entry. */
2444 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2445 BFD_ASSERT (sgot
!= NULL
);
2448 /* Get the got relocation section if necessary. */
2450 && (h
!= NULL
|| info
->shared
))
2452 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
2454 /* If no got relocation section, make one and initialize. */
2455 if (srelgot
== NULL
)
2457 srelgot
= bfd_make_section (dynobj
, ".rel.got");
2459 || ! bfd_set_section_flags (dynobj
, srelgot
,
2464 | SEC_LINKER_CREATED
2466 || ! bfd_set_section_alignment (dynobj
, srelgot
, 2))
2473 if (h
->got
.offset
!= (bfd_vma
) -1)
2474 /* We have already allocated space in the .got. */
2477 h
->got
.offset
= sgot
->_raw_size
;
2479 /* Make sure this symbol is output as a dynamic symbol. */
2480 if (h
->dynindx
== -1)
2481 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2484 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2488 /* This is a global offset table entry for a local
2490 if (local_got_offsets
== NULL
)
2493 register unsigned int i
;
2495 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
2496 local_got_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
2497 if (local_got_offsets
== NULL
)
2499 elf_local_got_offsets (abfd
) = local_got_offsets
;
2500 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
2501 local_got_offsets
[i
] = (bfd_vma
) -1;
2504 if (local_got_offsets
[r_symndx
] != (bfd_vma
) -1)
2505 /* We have already allocated space in the .got. */
2508 local_got_offsets
[r_symndx
] = sgot
->_raw_size
;
2511 /* If we are generating a shared object, we need to
2512 output a R_ARM_RELATIVE reloc so that the dynamic
2513 linker can adjust this GOT entry. */
2514 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2517 sgot
->_raw_size
+= 4;
2521 /* This symbol requires a procedure linkage table entry. We
2522 actually build the entry in adjust_dynamic_symbol,
2523 because this might be a case of linking PIC code which is
2524 never referenced by a dynamic object, in which case we
2525 don't need to generate a procedure linkage table entry
2528 /* If this is a local symbol, we resolve it directly without
2529 creating a procedure linkage table entry. */
2533 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2539 /* If we are creating a shared library, and this is a reloc
2540 against a global symbol, or a non PC relative reloc
2541 against a local symbol, then we need to copy the reloc
2542 into the shared library. However, if we are linking with
2543 -Bsymbolic, we do not need to copy a reloc against a
2544 global symbol which is defined in an object we are
2545 including in the link (i.e., DEF_REGULAR is set). At
2546 this point we have not seen all the input files, so it is
2547 possible that DEF_REGULAR is not set now but will be set
2548 later (it is never cleared). We account for that
2549 possibility below by storing information in the
2550 pcrel_relocs_copied field of the hash table entry. */
2552 && (ELF32_R_TYPE (rel
->r_info
) != R_ARM_PC24
2554 && (! info
->symbolic
2555 || (h
->elf_link_hash_flags
2556 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
2558 /* When creating a shared object, we must copy these
2559 reloc types into the output file. We create a reloc
2560 section in dynobj and make room for this reloc. */
2565 name
= (bfd_elf_string_from_elf_section
2567 elf_elfheader (abfd
)->e_shstrndx
,
2568 elf_section_data (sec
)->rel_hdr
.sh_name
));
2572 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
2573 && strcmp (bfd_get_section_name (abfd
, sec
),
2576 sreloc
= bfd_get_section_by_name (dynobj
, name
);
2581 sreloc
= bfd_make_section (dynobj
, name
);
2582 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
2583 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
2584 if ((sec
->flags
& SEC_ALLOC
) != 0)
2585 flags
|= SEC_ALLOC
| SEC_LOAD
;
2587 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
2588 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
2593 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
2594 /* If we are linking with -Bsymbolic, and this is a
2595 global symbol, we count the number of PC relative
2596 relocations we have entered for this symbol, so that
2597 we can discard them again if the symbol is later
2598 defined by a regular object. Note that this function
2599 is only called if we are using an elf_i386 linker
2600 hash table, which means that h is really a pointer to
2601 an elf_i386_link_hash_entry. */
2602 if (h
!= NULL
&& info
->symbolic
2603 && ELF32_R_TYPE (rel
->r_info
) == R_ARM_PC24
)
2605 struct elf32_arm_link_hash_entry
* eh
;
2606 struct elf32_arm_pcrel_relocs_copied
* p
;
2608 eh
= (struct elf32_arm_link_hash_entry
*) h
;
2610 for (p
= eh
->pcrel_relocs_copied
; p
!= NULL
; p
= p
->next
)
2611 if (p
->section
== sreloc
)
2616 p
= ((struct elf32_arm_pcrel_relocs_copied
*)
2617 bfd_alloc (dynobj
, sizeof * p
));
2621 p
->next
= eh
->pcrel_relocs_copied
;
2622 eh
->pcrel_relocs_copied
= p
;
2623 p
->section
= sreloc
;
2632 /* This relocation describes the C++ object vtable hierarchy.
2633 Reconstruct it for later use during GC. */
2634 case R_ARM_GNU_VTINHERIT
:
2635 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2639 /* This relocation describes which C++ vtable entries are actually
2640 used. Record for later use during GC. */
2641 case R_ARM_GNU_VTENTRY
:
2642 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
2651 /* Find the nearest line to a particular section and offset, for error
2652 reporting. This code is a duplicate of the code in elf.c, except
2653 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
2656 elf32_arm_find_nearest_line
2657 (abfd
, section
, symbols
, offset
, filename_ptr
, functionname_ptr
, line_ptr
)
2662 CONST
char ** filename_ptr
;
2663 CONST
char ** functionname_ptr
;
2664 unsigned int * line_ptr
;
2667 const char * filename
;
2672 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
2673 filename_ptr
, functionname_ptr
,
2675 &elf_tdata (abfd
)->dwarf2_find_line_info
))
2678 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2679 &found
, filename_ptr
,
2680 functionname_ptr
, line_ptr
,
2681 &elf_tdata (abfd
)->line_info
))
2687 if (symbols
== NULL
)
2694 for (p
= symbols
; *p
!= NULL
; p
++)
2698 q
= (elf_symbol_type
*) *p
;
2700 if (bfd_get_section (&q
->symbol
) != section
)
2703 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
2708 filename
= bfd_asymbol_name (&q
->symbol
);
2713 if (q
->symbol
.section
== section
2714 && q
->symbol
.value
>= low_func
2715 && q
->symbol
.value
<= offset
)
2717 func
= (asymbol
*) q
;
2718 low_func
= q
->symbol
.value
;
2727 *filename_ptr
= filename
;
2728 *functionname_ptr
= bfd_asymbol_name (func
);
2734 /* Adjust a symbol defined by a dynamic object and referenced by a
2735 regular object. The current definition is in some section of the
2736 dynamic object, but we're not including those sections. We have to
2737 change the definition to something the rest of the link can
2741 elf32_arm_adjust_dynamic_symbol (info
, h
)
2742 struct bfd_link_info
* info
;
2743 struct elf_link_hash_entry
* h
;
2747 unsigned int power_of_two
;
2749 dynobj
= elf_hash_table (info
)->dynobj
;
2751 /* Make sure we know what is going on here. */
2752 BFD_ASSERT (dynobj
!= NULL
2753 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
2754 || h
->weakdef
!= NULL
2755 || ((h
->elf_link_hash_flags
2756 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2757 && (h
->elf_link_hash_flags
2758 & ELF_LINK_HASH_REF_REGULAR
) != 0
2759 && (h
->elf_link_hash_flags
2760 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
2762 /* If this is a function, put it in the procedure linkage table. We
2763 will fill in the contents of the procedure linkage table later,
2764 when we know the address of the .got section. */
2765 if (h
->type
== STT_FUNC
2766 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
2769 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
2770 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0)
2772 /* This case can occur if we saw a PLT32 reloc in an input
2773 file, but the symbol was never referred to by a dynamic
2774 object. In such a case, we don't actually need to build
2775 a procedure linkage table, and we can just do a PC32
2777 BFD_ASSERT ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0);
2781 /* Make sure this symbol is output as a dynamic symbol. */
2782 if (h
->dynindx
== -1)
2784 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2788 s
= bfd_get_section_by_name (dynobj
, ".plt");
2789 BFD_ASSERT (s
!= NULL
);
2791 /* If this is the first .plt entry, make room for the special
2793 if (s
->_raw_size
== 0)
2794 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2796 /* If this symbol is not defined in a regular file, and we are
2797 not generating a shared library, then set the symbol to this
2798 location in the .plt. This is required to make function
2799 pointers compare as equal between the normal executable and
2800 the shared library. */
2802 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2804 h
->root
.u
.def
.section
= s
;
2805 h
->root
.u
.def
.value
= s
->_raw_size
;
2808 h
->plt
.offset
= s
->_raw_size
;
2810 /* Make room for this entry. */
2811 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2813 /* We also need to make an entry in the .got.plt section, which
2814 will be placed in the .got section by the linker script. */
2815 s
= bfd_get_section_by_name (dynobj
, ".got.plt");
2816 BFD_ASSERT (s
!= NULL
);
2819 /* We also need to make an entry in the .rel.plt section. */
2821 s
= bfd_get_section_by_name (dynobj
, ".rel.plt");
2822 BFD_ASSERT (s
!= NULL
);
2823 s
->_raw_size
+= sizeof (Elf32_External_Rel
);
2828 /* If this is a weak symbol, and there is a real definition, the
2829 processor independent code will have arranged for us to see the
2830 real definition first, and we can just use the same value. */
2831 if (h
->weakdef
!= NULL
)
2833 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
2834 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
2835 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
2836 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
2840 /* This is a reference to a symbol defined by a dynamic object which
2841 is not a function. */
2843 /* If we are creating a shared library, we must presume that the
2844 only references to the symbol are via the global offset table.
2845 For such cases we need not do anything here; the relocations will
2846 be handled correctly by relocate_section. */
2850 /* We must allocate the symbol in our .dynbss section, which will
2851 become part of the .bss section of the executable. There will be
2852 an entry for this symbol in the .dynsym section. The dynamic
2853 object will contain position independent code, so all references
2854 from the dynamic object to this symbol will go through the global
2855 offset table. The dynamic linker will use the .dynsym entry to
2856 determine the address it must put in the global offset table, so
2857 both the dynamic object and the regular object will refer to the
2858 same memory location for the variable. */
2859 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
2860 BFD_ASSERT (s
!= NULL
);
2862 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
2863 copy the initial value out of the dynamic object and into the
2864 runtime process image. We need to remember the offset into the
2865 .rel.bss section we are going to use. */
2866 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2870 srel
= bfd_get_section_by_name (dynobj
, ".rel.bss");
2871 BFD_ASSERT (srel
!= NULL
);
2872 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
2873 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
2876 /* We need to figure out the alignment required for this symbol. I
2877 have no idea how ELF linkers handle this. */
2878 power_of_two
= bfd_log2 (h
->size
);
2879 if (power_of_two
> 3)
2882 /* Apply the required alignment. */
2883 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
2884 (bfd_size_type
) (1 << power_of_two
));
2885 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
2887 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
2891 /* Define the symbol as being at this point in the section. */
2892 h
->root
.u
.def
.section
= s
;
2893 h
->root
.u
.def
.value
= s
->_raw_size
;
2895 /* Increment the section size to make room for the symbol. */
2896 s
->_raw_size
+= h
->size
;
2901 /* Set the sizes of the dynamic sections. */
2904 elf32_arm_size_dynamic_sections (output_bfd
, info
)
2906 struct bfd_link_info
* info
;
2914 dynobj
= elf_hash_table (info
)->dynobj
;
2915 BFD_ASSERT (dynobj
!= NULL
);
2917 if (elf_hash_table (info
)->dynamic_sections_created
)
2919 /* Set the contents of the .interp section to the interpreter. */
2922 s
= bfd_get_section_by_name (dynobj
, ".interp");
2923 BFD_ASSERT (s
!= NULL
);
2924 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2925 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2930 /* We may have created entries in the .rel.got section.
2931 However, if we are not creating the dynamic sections, we will
2932 not actually use these entries. Reset the size of .rel.got,
2933 which will cause it to get stripped from the output file
2935 s
= bfd_get_section_by_name (dynobj
, ".rel.got");
2940 /* If this is a -Bsymbolic shared link, then we need to discard all
2941 PC relative relocs against symbols defined in a regular object.
2942 We allocated space for them in the check_relocs routine, but we
2943 will not fill them in in the relocate_section routine. */
2944 if (info
->shared
&& info
->symbolic
)
2945 elf32_arm_link_hash_traverse (elf32_arm_hash_table (info
),
2946 elf32_arm_discard_copies
,
2949 /* The check_relocs and adjust_dynamic_symbol entry points have
2950 determined the sizes of the various dynamic sections. Allocate
2955 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2960 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2963 /* It's OK to base decisions on the section name, because none
2964 of the dynobj section names depend upon the input files. */
2965 name
= bfd_get_section_name (dynobj
, s
);
2969 if (strcmp (name
, ".plt") == 0)
2971 if (s
->_raw_size
== 0)
2973 /* Strip this section if we don't need it; see the
2979 /* Remember whether there is a PLT. */
2983 else if (strncmp (name
, ".rel", 4) == 0)
2985 if (s
->_raw_size
== 0)
2987 /* If we don't need this section, strip it from the
2988 output file. This is mostly to handle .rel.bss and
2989 .rel.plt. We must create both sections in
2990 create_dynamic_sections, because they must be created
2991 before the linker maps input sections to output
2992 sections. The linker does that before
2993 adjust_dynamic_symbol is called, and it is that
2994 function which decides whether anything needs to go
2995 into these sections. */
3002 /* Remember whether there are any reloc sections other
3004 if (strcmp (name
, ".rel.plt") != 0)
3006 const char *outname
;
3010 /* If this relocation section applies to a read only
3011 section, then we probably need a DT_TEXTREL
3012 entry. The entries in the .rel.plt section
3013 really apply to the .got section, which we
3014 created ourselves and so know is not readonly. */
3015 outname
= bfd_get_section_name (output_bfd
,
3017 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
3020 && (target
->flags
& SEC_READONLY
) != 0
3021 && (target
->flags
& SEC_ALLOC
) != 0)
3025 /* We use the reloc_count field as a counter if we need
3026 to copy relocs into the output file. */
3030 else if (strncmp (name
, ".got", 4) != 0)
3032 /* It's not one of our sections, so don't allocate space. */
3040 for (spp
= &s
->output_section
->owner
->sections
;
3041 *spp
!= s
->output_section
;
3042 spp
= &(*spp
)->next
)
3044 *spp
= s
->output_section
->next
;
3045 --s
->output_section
->owner
->section_count
;
3050 /* Allocate memory for the section contents. */
3051 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
3052 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
3056 if (elf_hash_table (info
)->dynamic_sections_created
)
3058 /* Add some entries to the .dynamic section. We fill in the
3059 values later, in elf32_arm_finish_dynamic_sections, but we
3060 must add the entries now so that we get the correct size for
3061 the .dynamic section. The DT_DEBUG entry is filled in by the
3062 dynamic linker and used by the debugger. */
3065 if (! bfd_elf32_add_dynamic_entry (info
, DT_DEBUG
, 0))
3071 if ( ! bfd_elf32_add_dynamic_entry (info
, DT_PLTGOT
, 0)
3072 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
3073 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTREL
, DT_REL
)
3074 || ! bfd_elf32_add_dynamic_entry (info
, DT_JMPREL
, 0))
3080 if ( ! bfd_elf32_add_dynamic_entry (info
, DT_REL
, 0)
3081 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELSZ
, 0)
3082 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELENT
,
3083 sizeof (Elf32_External_Rel
)))
3089 if (! bfd_elf32_add_dynamic_entry (info
, DT_TEXTREL
, 0))
3091 info
->flags
|= DF_TEXTREL
;
3098 /* This function is called via elf32_arm_link_hash_traverse if we are
3099 creating a shared object with -Bsymbolic. It discards the space
3100 allocated to copy PC relative relocs against symbols which are
3101 defined in regular objects. We allocated space for them in the
3102 check_relocs routine, but we won't fill them in in the
3103 relocate_section routine. */
3106 elf32_arm_discard_copies (h
, ignore
)
3107 struct elf32_arm_link_hash_entry
* h
;
3108 PTR ignore ATTRIBUTE_UNUSED
;
3110 struct elf32_arm_pcrel_relocs_copied
* s
;
3112 /* We only discard relocs for symbols defined in a regular object. */
3113 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3116 for (s
= h
->pcrel_relocs_copied
; s
!= NULL
; s
= s
->next
)
3117 s
->section
->_raw_size
-= s
->count
* sizeof (Elf32_External_Rel
);
3122 /* Finish up dynamic symbol handling. We set the contents of various
3123 dynamic sections here. */
3126 elf32_arm_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
3128 struct bfd_link_info
* info
;
3129 struct elf_link_hash_entry
* h
;
3130 Elf_Internal_Sym
* sym
;
3134 dynobj
= elf_hash_table (info
)->dynobj
;
3136 if (h
->plt
.offset
!= (bfd_vma
) -1)
3143 Elf_Internal_Rel rel
;
3145 /* This symbol has an entry in the procedure linkage table. Set
3148 BFD_ASSERT (h
->dynindx
!= -1);
3150 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3151 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3152 srel
= bfd_get_section_by_name (dynobj
, ".rel.plt");
3153 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
3155 /* Get the index in the procedure linkage table which
3156 corresponds to this symbol. This is the index of this symbol
3157 in all the symbols for which we are making plt entries. The
3158 first entry in the procedure linkage table is reserved. */
3159 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
3161 /* Get the offset into the .got table of the entry that
3162 corresponds to this function. Each .got entry is 4 bytes.
3163 The first three are reserved. */
3164 got_offset
= (plt_index
+ 3) * 4;
3166 /* Fill in the entry in the procedure linkage table. */
3167 memcpy (splt
->contents
+ h
->plt
.offset
,
3168 elf32_arm_plt_entry
,
3170 bfd_put_32 (output_bfd
,
3171 (sgot
->output_section
->vma
3172 + sgot
->output_offset
3174 - splt
->output_section
->vma
3175 - splt
->output_offset
3176 - h
->plt
.offset
- 12),
3177 splt
->contents
+ h
->plt
.offset
+ 12);
3179 /* Fill in the entry in the global offset table. */
3180 bfd_put_32 (output_bfd
,
3181 (splt
->output_section
->vma
3182 + splt
->output_offset
),
3183 sgot
->contents
+ got_offset
);
3185 /* Fill in the entry in the .rel.plt section. */
3186 rel
.r_offset
= (sgot
->output_section
->vma
3187 + sgot
->output_offset
3189 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_JUMP_SLOT
);
3190 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3191 ((Elf32_External_Rel
*) srel
->contents
3194 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3196 /* Mark the symbol as undefined, rather than as defined in
3197 the .plt section. Leave the value alone. */
3198 sym
->st_shndx
= SHN_UNDEF
;
3202 if (h
->got
.offset
!= (bfd_vma
) -1)
3206 Elf_Internal_Rel rel
;
3208 /* This symbol has an entry in the global offset table. Set it
3210 sgot
= bfd_get_section_by_name (dynobj
, ".got");
3211 srel
= bfd_get_section_by_name (dynobj
, ".rel.got");
3212 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
3214 rel
.r_offset
= (sgot
->output_section
->vma
3215 + sgot
->output_offset
3216 + (h
->got
.offset
&~ 1));
3218 /* If this is a -Bsymbolic link, and the symbol is defined
3219 locally, we just want to emit a RELATIVE reloc. The entry in
3220 the global offset table will already have been initialized in
3221 the relocate_section function. */
3223 && (info
->symbolic
|| h
->dynindx
== -1)
3224 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
3225 rel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
3228 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
3229 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_GLOB_DAT
);
3232 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3233 ((Elf32_External_Rel
*) srel
->contents
3234 + srel
->reloc_count
));
3235 ++srel
->reloc_count
;
3238 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
3241 Elf_Internal_Rel rel
;
3243 /* This symbol needs a copy reloc. Set it up. */
3244 BFD_ASSERT (h
->dynindx
!= -1
3245 && (h
->root
.type
== bfd_link_hash_defined
3246 || h
->root
.type
== bfd_link_hash_defweak
));
3248 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
3250 BFD_ASSERT (s
!= NULL
);
3252 rel
.r_offset
= (h
->root
.u
.def
.value
3253 + h
->root
.u
.def
.section
->output_section
->vma
3254 + h
->root
.u
.def
.section
->output_offset
);
3255 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_COPY
);
3256 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3257 ((Elf32_External_Rel
*) s
->contents
3262 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3263 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3264 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
3265 sym
->st_shndx
= SHN_ABS
;
3270 /* Finish up the dynamic sections. */
3273 elf32_arm_finish_dynamic_sections (output_bfd
, info
)
3275 struct bfd_link_info
* info
;
3281 dynobj
= elf_hash_table (info
)->dynobj
;
3283 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3284 BFD_ASSERT (sgot
!= NULL
);
3285 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3287 if (elf_hash_table (info
)->dynamic_sections_created
)
3290 Elf32_External_Dyn
*dyncon
, *dynconend
;
3292 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3293 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3295 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3296 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
3298 for (; dyncon
< dynconend
; dyncon
++)
3300 Elf_Internal_Dyn dyn
;
3304 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3317 s
= bfd_get_section_by_name (output_bfd
, name
);
3318 BFD_ASSERT (s
!= NULL
);
3319 dyn
.d_un
.d_ptr
= s
->vma
;
3320 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3324 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3325 BFD_ASSERT (s
!= NULL
);
3326 if (s
->_cooked_size
!= 0)
3327 dyn
.d_un
.d_val
= s
->_cooked_size
;
3329 dyn
.d_un
.d_val
= s
->_raw_size
;
3330 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3334 /* My reading of the SVR4 ABI indicates that the
3335 procedure linkage table relocs (DT_JMPREL) should be
3336 included in the overall relocs (DT_REL). This is
3337 what Solaris does. However, UnixWare can not handle
3338 that case. Therefore, we override the DT_RELSZ entry
3339 here to make it not include the JMPREL relocs. Since
3340 the linker script arranges for .rel.plt to follow all
3341 other relocation sections, we don't have to worry
3342 about changing the DT_REL entry. */
3343 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3346 if (s
->_cooked_size
!= 0)
3347 dyn
.d_un
.d_val
-= s
->_cooked_size
;
3349 dyn
.d_un
.d_val
-= s
->_raw_size
;
3351 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3356 /* Fill in the first entry in the procedure linkage table. */
3357 if (splt
->_raw_size
> 0)
3358 memcpy (splt
->contents
, elf32_arm_plt0_entry
, PLT_ENTRY_SIZE
);
3360 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3361 really seem like the right value. */
3362 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
3365 /* Fill in the first three entries in the global offset table. */
3366 if (sgot
->_raw_size
> 0)
3369 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
3371 bfd_put_32 (output_bfd
,
3372 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3374 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
3375 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
3378 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
3384 elf32_arm_post_process_headers (abfd
, link_info
)
3386 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
;
3388 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
3390 i_ehdrp
= elf_elfheader (abfd
);
3392 i_ehdrp
->e_ident
[EI_OSABI
] = ARM_ELF_OS_ABI_VERSION
;
3393 i_ehdrp
->e_ident
[EI_ABIVERSION
] = ARM_ELF_ABI_VERSION
;
3396 #define ELF_ARCH bfd_arch_arm
3397 #define ELF_MACHINE_CODE EM_ARM
3398 #define ELF_MAXPAGESIZE 0x8000
3400 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
3401 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
3402 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
3403 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
3404 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
3405 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
3406 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
3408 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
3409 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
3410 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
3411 #define elf_backend_check_relocs elf32_arm_check_relocs
3412 #define elf_backend_relocate_section elf32_arm_relocate_section
3413 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
3414 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
3415 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
3416 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
3417 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
3418 #define elf_backend_post_process_headers elf32_arm_post_process_headers
3420 #define elf_backend_can_gc_sections 1
3421 #define elf_backend_plt_readonly 1
3422 #define elf_backend_want_got_plt 1
3423 #define elf_backend_want_plt_sym 0
3425 #define elf_backend_got_header_size 12
3426 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
3428 #include "elf32-target.h"