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. */
21 typedef unsigned long int insn32
;
22 typedef unsigned short int insn16
;
24 static boolean elf32_arm_set_private_flags
25 PARAMS ((bfd
*, flagword
));
26 static boolean elf32_arm_copy_private_bfd_data
27 PARAMS ((bfd
*, bfd
*));
28 static boolean elf32_arm_merge_private_bfd_data
29 PARAMS ((bfd
*, bfd
*));
30 static boolean elf32_arm_print_private_bfd_data
31 PARAMS ((bfd
*, PTR
));
32 static int elf32_arm_get_symbol_type
33 PARAMS (( Elf_Internal_Sym
*, int));
34 static struct bfd_link_hash_table
*elf32_arm_link_hash_table_create
36 static bfd_reloc_status_type elf32_arm_final_link_relocate
37 PARAMS ((reloc_howto_type
*, bfd
*, bfd
*, asection
*, bfd_byte
*,
38 Elf_Internal_Rela
*, bfd_vma
, struct bfd_link_info
*, asection
*,
39 const char *, unsigned char, struct elf_link_hash_entry
*));
40 static insn32 insert_thumb_branch
41 PARAMS ((insn32
, int));
42 static struct elf_link_hash_entry
*find_thumb_glue
43 PARAMS ((struct bfd_link_info
*, CONST
char *, bfd
*));
44 static struct elf_link_hash_entry
*find_arm_glue
45 PARAMS ((struct bfd_link_info
*, CONST
char *, bfd
*));
46 static void record_arm_to_thumb_glue
47 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
48 static void record_thumb_to_arm_glue
49 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
50 static void elf32_arm_post_process_headers
51 PARAMS ((bfd
*, struct bfd_link_info
*));
52 static int elf32_arm_to_thumb_stub
53 PARAMS ((struct bfd_link_info
*, const char *, bfd
*, bfd
*, asection
*,
54 bfd_byte
*, asection
*, bfd_vma
, bfd_signed_vma
, bfd_vma
));
55 static int elf32_thumb_to_arm_stub
56 PARAMS ((struct bfd_link_info
*, const char *, bfd
*, bfd
*, asection
*,
57 bfd_byte
*, asection
*, bfd_vma
, bfd_signed_vma
, bfd_vma
));
59 #define INTERWORK_FLAG(abfd) (elf_elfheader (abfd)->e_flags & EF_INTERWORK)
61 /* The linker script knows the section names for placement.
62 The entry_names are used to do simple name mangling on the stubs.
63 Given a function name, and its type, the stub can be found. The
64 name can be changed. The only requirement is the %s be present. */
65 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
66 #define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
68 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
69 #define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
71 /* The name of the dynamic interpreter. This is put in the .interp
73 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
75 /* The size in bytes of an entry in the procedure linkage table. */
76 #define PLT_ENTRY_SIZE 16
78 /* The first entry in a procedure linkage table looks like
79 this. It is set up so that any shared library function that is
80 called before the relocation has been set up calls the dynamic
82 static const bfd_byte elf32_arm_plt0_entry
[PLT_ENTRY_SIZE
] =
84 0x04, 0xe0, 0x2d, 0xe5, /* str lr, [sp, #-4]! */
85 0x10, 0xe0, 0x9f, 0xe5, /* ldr lr, [pc, #16] */
86 0x0e, 0xe0, 0x8f, 0xe0, /* adr lr, pc, lr */
87 0x08, 0xf0, 0xbe, 0xe5 /* ldr pc, [lr, #8]! */
90 /* Subsequent entries in a procedure linkage table look like
92 static const bfd_byte elf32_arm_plt_entry
[PLT_ENTRY_SIZE
] =
94 0x04, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc, #4] */
95 0x0c, 0xc0, 0x8f, 0xe0, /* add ip, pc, ip */
96 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
97 0x00, 0x00, 0x00, 0x00 /* offset to symbol in got */
100 /* The ARM linker needs to keep track of the number of relocs that it
101 decides to copy in check_relocs for each symbol. This is so that
102 it can discard PC relative relocs if it doesn't need them when
103 linking with -Bsymbolic. We store the information in a field
104 extending the regular ELF linker hash table. */
106 /* This structure keeps track of the number of PC relative relocs we
107 have copied for a given symbol. */
108 struct elf32_arm_pcrel_relocs_copied
111 struct elf32_arm_pcrel_relocs_copied
* next
;
112 /* A section in dynobj. */
114 /* Number of relocs copied in this section. */
118 /* Arm ELF linker hash entry. */
119 struct elf32_arm_link_hash_entry
121 struct elf_link_hash_entry root
;
123 /* Number of PC relative relocs copied for this symbol. */
124 struct elf32_arm_pcrel_relocs_copied
* pcrel_relocs_copied
;
127 /* Declare this now that the above structures are defined. */
128 static boolean elf32_arm_discard_copies
129 PARAMS ((struct elf32_arm_link_hash_entry
*, PTR
));
131 /* Traverse an arm ELF linker hash table. */
132 #define elf32_arm_link_hash_traverse(table, func, info) \
133 (elf_link_hash_traverse \
135 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
138 /* Get the ARM elf linker hash table from a link_info structure. */
139 #define elf32_arm_hash_table(info) \
140 ((struct elf32_arm_link_hash_table *) ((info)->hash))
142 /* ARM ELF linker hash table. */
143 struct elf32_arm_link_hash_table
145 /* The main hash table. */
146 struct elf_link_hash_table root
;
148 /* The size in bytes of the section containg the Thumb-to-ARM glue. */
149 long int thumb_glue_size
;
151 /* The size in bytes of the section containg the ARM-to-Thumb glue. */
152 long int arm_glue_size
;
154 /* An arbitary input BFD chosen to hold the glue sections. */
155 bfd
* bfd_of_glue_owner
;
157 /* A boolean indicating whether knowledge of the ARM's pipeline
158 length should be applied by the linker. */
159 int no_pipeline_knowledge
;
163 /* Create an entry in an ARM ELF linker hash table. */
165 static struct bfd_hash_entry
*
166 elf32_arm_link_hash_newfunc (entry
, table
, string
)
167 struct bfd_hash_entry
* entry
;
168 struct bfd_hash_table
* table
;
171 struct elf32_arm_link_hash_entry
* ret
=
172 (struct elf32_arm_link_hash_entry
*) entry
;
174 /* Allocate the structure if it has not already been allocated by a
176 if (ret
== (struct elf32_arm_link_hash_entry
*) NULL
)
177 ret
= ((struct elf32_arm_link_hash_entry
*)
178 bfd_hash_allocate (table
,
179 sizeof (struct elf32_arm_link_hash_entry
)));
180 if (ret
== (struct elf32_arm_link_hash_entry
*) NULL
)
181 return (struct bfd_hash_entry
*) ret
;
183 /* Call the allocation method of the superclass. */
184 ret
= ((struct elf32_arm_link_hash_entry
*)
185 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
187 if (ret
!= (struct elf32_arm_link_hash_entry
*) NULL
)
188 ret
->pcrel_relocs_copied
= NULL
;
190 return (struct bfd_hash_entry
*) ret
;
193 /* Create an ARM elf linker hash table. */
195 static struct bfd_link_hash_table
*
196 elf32_arm_link_hash_table_create (abfd
)
199 struct elf32_arm_link_hash_table
*ret
;
201 ret
= ((struct elf32_arm_link_hash_table
*)
202 bfd_alloc (abfd
, sizeof (struct elf32_arm_link_hash_table
)));
203 if (ret
== (struct elf32_arm_link_hash_table
*) NULL
)
206 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
207 elf32_arm_link_hash_newfunc
))
209 bfd_release (abfd
, ret
);
213 ret
->thumb_glue_size
= 0;
214 ret
->arm_glue_size
= 0;
215 ret
->bfd_of_glue_owner
= NULL
;
216 ret
->no_pipeline_knowledge
= 0;
218 return &ret
->root
.root
;
221 /* Locate the Thumb encoded calling stub for NAME. */
223 static struct elf_link_hash_entry
*
224 find_thumb_glue (link_info
, name
, input_bfd
)
225 struct bfd_link_info
*link_info
;
230 struct elf_link_hash_entry
*hash
;
231 struct elf32_arm_link_hash_table
*hash_table
;
233 /* We need a pointer to the armelf specific hash table. */
234 hash_table
= elf32_arm_hash_table (link_info
);
237 bfd_malloc (strlen (name
) + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1));
239 BFD_ASSERT (tmp_name
);
241 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
243 hash
= elf_link_hash_lookup
244 (&(hash_table
)->root
, tmp_name
, false, false, true);
247 /* xgettext:c-format */
248 _bfd_error_handler (_("%s: unable to find THUMB glue '%s' for `%s'"),
249 bfd_get_filename (input_bfd
), tmp_name
, name
);
256 /* Locate the ARM encoded calling stub for NAME. */
258 static struct elf_link_hash_entry
*
259 find_arm_glue (link_info
, name
, input_bfd
)
260 struct bfd_link_info
*link_info
;
265 struct elf_link_hash_entry
*myh
;
266 struct elf32_arm_link_hash_table
*hash_table
;
268 /* We need a pointer to the elfarm specific hash table. */
269 hash_table
= elf32_arm_hash_table (link_info
);
272 bfd_malloc (strlen (name
) + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1));
274 BFD_ASSERT (tmp_name
);
276 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
278 myh
= elf_link_hash_lookup
279 (&(hash_table
)->root
, tmp_name
, false, false, true);
282 /* xgettext:c-format */
283 _bfd_error_handler (_("%s: unable to find ARM glue '%s' for `%s'"),
284 bfd_get_filename (input_bfd
), tmp_name
, name
);
298 .word func @ behave as if you saw a ARM_32 reloc. */
300 #define ARM2THUMB_GLUE_SIZE 12
301 static const insn32 a2t1_ldr_insn
= 0xe59fc000;
302 static const insn32 a2t2_bx_r12_insn
= 0xe12fff1c;
303 static const insn32 a2t3_func_addr_insn
= 0x00000001;
305 /* Thumb->ARM: Thumb->(non-interworking aware) ARM
309 __func_from_thumb: __func_from_thumb:
311 nop ldr r6, __func_addr
313 __func_change_to_arm: bx r6
315 __func_back_to_thumb:
321 #define THUMB2ARM_GLUE_SIZE 8
322 static const insn16 t2a1_bx_pc_insn
= 0x4778;
323 static const insn16 t2a2_noop_insn
= 0x46c0;
324 static const insn32 t2a3_b_insn
= 0xea000000;
326 static const insn16 t2a1_push_insn
= 0xb540;
327 static const insn16 t2a2_ldr_insn
= 0x4e03;
328 static const insn16 t2a3_mov_insn
= 0x46fe;
329 static const insn16 t2a4_bx_insn
= 0x4730;
330 static const insn32 t2a5_pop_insn
= 0xe8bd4040;
331 static const insn32 t2a6_bx_insn
= 0xe12fff1e;
334 bfd_elf32_arm_allocate_interworking_sections (info
)
335 struct bfd_link_info
* info
;
339 struct elf32_arm_link_hash_table
* globals
;
341 globals
= elf32_arm_hash_table (info
);
343 BFD_ASSERT (globals
!= NULL
);
345 if (globals
->arm_glue_size
!= 0)
347 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
349 s
= bfd_get_section_by_name
350 (globals
->bfd_of_glue_owner
, ARM2THUMB_GLUE_SECTION_NAME
);
352 BFD_ASSERT (s
!= NULL
);
354 foo
= (bfd_byte
*) bfd_alloc
355 (globals
->bfd_of_glue_owner
, globals
->arm_glue_size
);
357 s
->_raw_size
= s
->_cooked_size
= globals
->arm_glue_size
;
361 if (globals
->thumb_glue_size
!= 0)
363 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
365 s
= bfd_get_section_by_name
366 (globals
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
368 BFD_ASSERT (s
!= NULL
);
370 foo
= (bfd_byte
*) bfd_alloc
371 (globals
->bfd_of_glue_owner
, globals
->thumb_glue_size
);
373 s
->_raw_size
= s
->_cooked_size
= globals
->thumb_glue_size
;
381 record_arm_to_thumb_glue (link_info
, h
)
382 struct bfd_link_info
* link_info
;
383 struct elf_link_hash_entry
* h
;
385 const char * name
= h
->root
.root
.string
;
386 register asection
* s
;
388 struct elf_link_hash_entry
* myh
;
389 struct elf32_arm_link_hash_table
* globals
;
391 globals
= elf32_arm_hash_table (link_info
);
393 BFD_ASSERT (globals
!= NULL
);
394 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
396 s
= bfd_get_section_by_name
397 (globals
->bfd_of_glue_owner
, ARM2THUMB_GLUE_SECTION_NAME
);
399 BFD_ASSERT (s
!= NULL
);
402 bfd_malloc (strlen (name
) + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1));
404 BFD_ASSERT (tmp_name
);
406 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
408 myh
= elf_link_hash_lookup
409 (&(globals
)->root
, tmp_name
, false, false, true);
413 /* We've already seen this guy. */
418 /* The only trick here is using hash_table->arm_glue_size as the value. Even
419 though the section isn't allocated yet, this is where we will be putting
421 _bfd_generic_link_add_one_symbol (link_info
, globals
->bfd_of_glue_owner
, tmp_name
,
423 s
, globals
->arm_glue_size
+ 1,
425 (struct bfd_link_hash_entry
**) &myh
);
429 globals
->arm_glue_size
+= ARM2THUMB_GLUE_SIZE
;
435 record_thumb_to_arm_glue (link_info
, h
)
436 struct bfd_link_info
*link_info
;
437 struct elf_link_hash_entry
*h
;
439 const char *name
= h
->root
.root
.string
;
440 register asection
*s
;
442 struct elf_link_hash_entry
*myh
;
443 struct elf32_arm_link_hash_table
*hash_table
;
446 hash_table
= elf32_arm_hash_table (link_info
);
448 BFD_ASSERT (hash_table
!= NULL
);
449 BFD_ASSERT (hash_table
->bfd_of_glue_owner
!= NULL
);
451 s
= bfd_get_section_by_name
452 (hash_table
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
454 BFD_ASSERT (s
!= NULL
);
456 tmp_name
= (char *) bfd_malloc (strlen (name
) + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1);
458 BFD_ASSERT (tmp_name
);
460 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
462 myh
= elf_link_hash_lookup
463 (&(hash_table
)->root
, tmp_name
, false, false, true);
467 /* We've already seen this guy. */
472 _bfd_generic_link_add_one_symbol (link_info
, hash_table
->bfd_of_glue_owner
, tmp_name
,
473 BSF_GLOBAL
, s
, hash_table
->thumb_glue_size
+ 1,
475 (struct bfd_link_hash_entry
**) &myh
);
477 /* If we mark it 'Thumb', the disassembler will do a better job. */
478 bind
= ELF_ST_BIND (myh
->type
);
479 myh
->type
= ELF_ST_INFO (bind
, STT_ARM_TFUNC
);
483 #define CHANGE_TO_ARM "__%s_change_to_arm"
484 #define BACK_FROM_ARM "__%s_back_from_arm"
486 /* Allocate another symbol to mark where we switch to Arm mode. */
487 tmp_name
= (char *) bfd_malloc (strlen (name
) + strlen (CHANGE_TO_ARM
) + 1);
489 BFD_ASSERT (tmp_name
);
491 sprintf (tmp_name
, CHANGE_TO_ARM
, name
);
495 _bfd_generic_link_add_one_symbol (link_info
, hash_table
->bfd_of_glue_owner
, tmp_name
,
496 BSF_LOCAL
, s
, hash_table
->thumb_glue_size
+ 4,
498 (struct bfd_link_hash_entry
**) &myh
);
502 hash_table
->thumb_glue_size
+= THUMB2ARM_GLUE_SIZE
;
507 /* Select a BFD to be used to hold the sections used by the glue code.
508 This function is called from the linker scripts in ld/emultempl/
512 bfd_elf32_arm_get_bfd_for_interworking (abfd
, info
)
514 struct bfd_link_info
*info
;
516 struct elf32_arm_link_hash_table
*globals
;
520 /* If we are only performing a partial link do not bother
521 getting a bfd to hold the glue. */
522 if (info
->relocateable
)
525 globals
= elf32_arm_hash_table (info
);
527 BFD_ASSERT (globals
!= NULL
);
529 if (globals
->bfd_of_glue_owner
!= NULL
)
532 sec
= bfd_get_section_by_name (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
536 /* Note: we do not include the flag SEC_LINKER_CREATED, as this
537 will prevent elf_link_input_bfd() from processing the contents
539 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_CODE
| SEC_READONLY
;
541 sec
= bfd_make_section (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
544 || !bfd_set_section_flags (abfd
, sec
, flags
)
545 || !bfd_set_section_alignment (abfd
, sec
, 2))
548 /* Set the gc mark to prevent the section from being removed by garbage
549 collection, despite the fact that no relocs refer to this section. */
553 sec
= bfd_get_section_by_name (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
557 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_CODE
| SEC_READONLY
;
559 sec
= bfd_make_section (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
562 || !bfd_set_section_flags (abfd
, sec
, flags
)
563 || !bfd_set_section_alignment (abfd
, sec
, 2))
569 /* Save the bfd for later use. */
570 globals
->bfd_of_glue_owner
= abfd
;
576 bfd_elf32_arm_process_before_allocation (abfd
, link_info
, no_pipeline_knowledge
)
578 struct bfd_link_info
*link_info
;
579 int no_pipeline_knowledge
;
581 Elf_Internal_Shdr
*symtab_hdr
;
582 Elf_Internal_Rela
*free_relocs
= NULL
;
583 Elf_Internal_Rela
*irel
, *irelend
;
584 bfd_byte
*contents
= NULL
;
585 bfd_byte
*free_contents
= NULL
;
586 Elf32_External_Sym
*extsyms
= NULL
;
587 Elf32_External_Sym
*free_extsyms
= NULL
;
590 struct elf32_arm_link_hash_table
*globals
;
592 /* If we are only performing a partial link do not bother
593 to construct any glue. */
594 if (link_info
->relocateable
)
597 /* Here we have a bfd that is to be included on the link. We have a hook
598 to do reloc rummaging, before section sizes are nailed down. */
599 globals
= elf32_arm_hash_table (link_info
);
601 BFD_ASSERT (globals
!= NULL
);
602 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
604 globals
->no_pipeline_knowledge
= no_pipeline_knowledge
;
606 /* Rummage around all the relocs and map the glue vectors. */
607 sec
= abfd
->sections
;
612 for (; sec
!= NULL
; sec
= sec
->next
)
614 if (sec
->reloc_count
== 0)
617 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
619 /* Load the relocs. */
620 irel
= (_bfd_elf32_link_read_relocs (abfd
, sec
, (PTR
) NULL
,
621 (Elf_Internal_Rela
*) NULL
, false));
623 BFD_ASSERT (irel
!= 0);
625 irelend
= irel
+ sec
->reloc_count
;
626 for (; irel
< irelend
; irel
++)
629 unsigned long r_index
;
631 struct elf_link_hash_entry
*h
;
633 r_type
= ELF32_R_TYPE (irel
->r_info
);
634 r_index
= ELF32_R_SYM (irel
->r_info
);
636 /* These are the only relocation types we care about. */
637 if ( r_type
!= R_ARM_PC24
638 && r_type
!= R_ARM_THM_PC22
)
641 /* Get the section contents if we haven't done so already. */
642 if (contents
== NULL
)
644 /* Get cached copy if it exists. */
645 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
646 contents
= elf_section_data (sec
)->this_hdr
.contents
;
649 /* Go get them off disk. */
650 contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
651 if (contents
== NULL
)
654 free_contents
= contents
;
656 if (!bfd_get_section_contents (abfd
, sec
, contents
,
657 (file_ptr
) 0, sec
->_raw_size
))
662 /* Read this BFD's symbols if we haven't done so already. */
665 /* Get cached copy if it exists. */
666 if (symtab_hdr
->contents
!= NULL
)
667 extsyms
= (Elf32_External_Sym
*) symtab_hdr
->contents
;
670 /* Go get them off disk. */
671 extsyms
= ((Elf32_External_Sym
*)
672 bfd_malloc (symtab_hdr
->sh_size
));
676 free_extsyms
= extsyms
;
678 if (bfd_seek (abfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
679 || (bfd_read (extsyms
, 1, symtab_hdr
->sh_size
, abfd
)
680 != symtab_hdr
->sh_size
))
685 /* If the relocation is not against a symbol it cannot concern us. */
688 /* We don't care about local symbols. */
689 if (r_index
< symtab_hdr
->sh_info
)
692 /* This is an external symbol. */
693 r_index
-= symtab_hdr
->sh_info
;
694 h
= (struct elf_link_hash_entry
*)
695 elf_sym_hashes (abfd
)[r_index
];
697 /* If the relocation is against a static symbol it must be within
698 the current section and so cannot be a cross ARM/Thumb relocation. */
705 /* This one is a call from arm code. We need to look up
706 the target of the call. If it is a thumb target, we
708 if (ELF_ST_TYPE(h
->type
) == STT_ARM_TFUNC
)
709 record_arm_to_thumb_glue (link_info
, h
);
713 /* This one is a call from thumb code. We look
714 up the target of the call. If it is not a thumb
715 target, we insert glue. */
716 if (ELF_ST_TYPE (h
->type
) != STT_ARM_TFUNC
)
717 record_thumb_to_arm_glue (link_info
, h
);
729 if (free_relocs
!= NULL
)
731 if (free_contents
!= NULL
)
732 free (free_contents
);
733 if (free_extsyms
!= NULL
)
739 /* The thumb form of a long branch is a bit finicky, because the offset
740 encoding is split over two fields, each in it's own instruction. They
741 can occur in any order. So given a thumb form of long branch, and an
742 offset, insert the offset into the thumb branch and return finished
745 It takes two thumb instructions to encode the target address. Each has
746 11 bits to invest. The upper 11 bits are stored in one (identifed by
747 H-0.. see below), the lower 11 bits are stored in the other (identified
750 Combine together and shifted left by 1 (it's a half word address) and
754 H-0, upper address-0 = 000
756 H-1, lower address-0 = 800
758 They can be ordered either way, but the arm tools I've seen always put
759 the lower one first. It probably doesn't matter. krk@cygnus.com
761 XXX: Actually the order does matter. The second instruction (H-1)
762 moves the computed address into the PC, so it must be the second one
763 in the sequence. The problem, however is that whilst little endian code
764 stores the instructions in HI then LOW order, big endian code does the
765 reverse. nickc@cygnus.com. */
767 #define LOW_HI_ORDER 0xF800F000
768 #define HI_LOW_ORDER 0xF000F800
771 insert_thumb_branch (br_insn
, rel_off
)
775 unsigned int low_bits
;
776 unsigned int high_bits
;
778 BFD_ASSERT ((rel_off
& 1) != 1);
780 rel_off
>>= 1; /* Half word aligned address. */
781 low_bits
= rel_off
& 0x000007FF; /* The bottom 11 bits. */
782 high_bits
= (rel_off
>> 11) & 0x000007FF; /* The top 11 bits. */
784 if ((br_insn
& LOW_HI_ORDER
) == LOW_HI_ORDER
)
785 br_insn
= LOW_HI_ORDER
| (low_bits
<< 16) | high_bits
;
786 else if ((br_insn
& HI_LOW_ORDER
) == HI_LOW_ORDER
)
787 br_insn
= HI_LOW_ORDER
| (high_bits
<< 16) | low_bits
;
789 /* FIXME: abort is probably not the right call. krk@cygnus.com */
790 abort (); /* error - not a valid branch instruction form. */
795 /* Thumb code calling an ARM function. */
798 elf32_thumb_to_arm_stub (info
, name
, input_bfd
, output_bfd
, input_section
,
799 hit_data
, sym_sec
, offset
, addend
, val
)
800 struct bfd_link_info
* info
;
804 asection
* input_section
;
808 bfd_signed_vma addend
;
813 unsigned long int tmp
;
815 struct elf_link_hash_entry
* myh
;
816 struct elf32_arm_link_hash_table
* globals
;
818 myh
= find_thumb_glue (info
, name
, input_bfd
);
822 globals
= elf32_arm_hash_table (info
);
824 BFD_ASSERT (globals
!= NULL
);
825 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
827 my_offset
= myh
->root
.u
.def
.value
;
829 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
830 THUMB2ARM_GLUE_SECTION_NAME
);
832 BFD_ASSERT (s
!= NULL
);
833 BFD_ASSERT (s
->contents
!= NULL
);
834 BFD_ASSERT (s
->output_section
!= NULL
);
836 if ((my_offset
& 0x01) == 0x01)
839 && sym_sec
->owner
!= NULL
840 && !INTERWORK_FLAG (sym_sec
->owner
))
843 (_("%s(%s): warning: interworking not enabled."),
844 bfd_get_filename (sym_sec
->owner
), name
);
846 (_(" first occurrence: %s: thumb call to arm"),
847 bfd_get_filename (input_bfd
));
853 myh
->root
.u
.def
.value
= my_offset
;
855 bfd_put_16 (output_bfd
, t2a1_bx_pc_insn
,
856 s
->contents
+ my_offset
);
858 bfd_put_16 (output_bfd
, t2a2_noop_insn
,
859 s
->contents
+ my_offset
+ 2);
862 /* Address of destination of the stub. */
863 ((bfd_signed_vma
) val
)
865 /* Offset from the start of the current section to the start of the stubs. */
867 /* Offset of the start of this stub from the start of the stubs. */
869 /* Address of the start of the current section. */
870 + s
->output_section
->vma
)
871 /* The branch instruction is 4 bytes into the stub. */
873 /* ARM branches work from the pc of the instruction + 8. */
876 bfd_put_32 (output_bfd
,
877 t2a3_b_insn
| ((ret_offset
>> 2) & 0x00FFFFFF),
878 s
->contents
+ my_offset
+ 4);
881 BFD_ASSERT (my_offset
<= globals
->thumb_glue_size
);
883 /* Now go back and fix up the original BL insn to point
888 - (input_section
->output_offset
892 tmp
= bfd_get_32 (input_bfd
, hit_data
893 - input_section
->vma
);
895 bfd_put_32 (output_bfd
,
896 insert_thumb_branch (tmp
, ret_offset
),
897 hit_data
- input_section
->vma
);
902 /* Arm code calling a Thumb function. */
905 elf32_arm_to_thumb_stub (info
, name
, input_bfd
, output_bfd
, input_section
,
906 hit_data
, sym_sec
, offset
, addend
, val
)
907 struct bfd_link_info
* info
;
911 asection
* input_section
;
915 bfd_signed_vma addend
;
918 unsigned long int tmp
;
922 struct elf_link_hash_entry
* myh
;
923 struct elf32_arm_link_hash_table
* globals
;
925 myh
= find_arm_glue (info
, name
, input_bfd
);
929 globals
= elf32_arm_hash_table (info
);
931 BFD_ASSERT (globals
!= NULL
);
932 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
934 my_offset
= myh
->root
.u
.def
.value
;
935 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
936 ARM2THUMB_GLUE_SECTION_NAME
);
937 BFD_ASSERT (s
!= NULL
);
938 BFD_ASSERT (s
->contents
!= NULL
);
939 BFD_ASSERT (s
->output_section
!= NULL
);
941 if ((my_offset
& 0x01) == 0x01)
944 && sym_sec
->owner
!= NULL
945 && !INTERWORK_FLAG (sym_sec
->owner
))
948 (_("%s(%s): warning: interworking not enabled."),
949 bfd_get_filename (sym_sec
->owner
), name
);
951 (_(" first occurrence: %s: arm call to thumb"),
952 bfd_get_filename (input_bfd
));
956 myh
->root
.u
.def
.value
= my_offset
;
958 bfd_put_32 (output_bfd
, a2t1_ldr_insn
,
959 s
->contents
+ my_offset
);
961 bfd_put_32 (output_bfd
, a2t2_bx_r12_insn
,
962 s
->contents
+ my_offset
+ 4);
964 /* It's a thumb address. Add the low order bit. */
965 bfd_put_32 (output_bfd
, val
| a2t3_func_addr_insn
,
966 s
->contents
+ my_offset
+ 8);
969 BFD_ASSERT (my_offset
<= globals
->arm_glue_size
);
971 tmp
= bfd_get_32 (input_bfd
, hit_data
);
972 tmp
= tmp
& 0xFF000000;
974 /* Somehow these are both 4 too far, so subtract 8. */
975 ret_offset
= s
->output_offset
977 + s
->output_section
->vma
978 - (input_section
->output_offset
979 + input_section
->output_section
->vma
983 tmp
= tmp
| ((ret_offset
>> 2) & 0x00FFFFFF);
985 bfd_put_32 (output_bfd
, tmp
, hit_data
986 - input_section
->vma
);
991 /* Perform a relocation as part of a final link. */
993 static bfd_reloc_status_type
994 elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
995 input_section
, contents
, rel
, value
,
996 info
, sym_sec
, sym_name
, sym_flags
, h
)
997 reloc_howto_type
* howto
;
1000 asection
* input_section
;
1001 bfd_byte
* contents
;
1002 Elf_Internal_Rela
* rel
;
1004 struct bfd_link_info
* info
;
1006 const char * sym_name
;
1007 unsigned char sym_flags
;
1008 struct elf_link_hash_entry
* h
;
1010 unsigned long r_type
= howto
->type
;
1011 unsigned long r_symndx
;
1012 bfd_byte
* hit_data
= contents
+ rel
->r_offset
;
1013 bfd
* dynobj
= NULL
;
1014 Elf_Internal_Shdr
* symtab_hdr
;
1015 struct elf_link_hash_entry
** sym_hashes
;
1016 bfd_vma
* local_got_offsets
;
1017 asection
* sgot
= NULL
;
1018 asection
* splt
= NULL
;
1019 asection
* sreloc
= NULL
;
1021 bfd_signed_vma signed_addend
;
1022 struct elf32_arm_link_hash_table
* globals
;
1024 globals
= elf32_arm_hash_table (info
);
1026 dynobj
= elf_hash_table (info
)->dynobj
;
1029 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1030 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1032 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1033 sym_hashes
= elf_sym_hashes (input_bfd
);
1034 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1035 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1038 addend
= bfd_get_32 (input_bfd
, hit_data
) & howto
->src_mask
;
1040 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1043 signed_addend
&= ~ howto
->src_mask
;
1044 signed_addend
|= addend
;
1047 signed_addend
= addend
;
1049 addend
= signed_addend
= rel
->r_addend
;
1055 return bfd_reloc_ok
;
1063 /* When generating a shared object, these relocations are copied
1064 into the output file to be resolved at run time. */
1066 && (r_type
!= R_ARM_PC24
1069 && (! info
->symbolic
1070 || (h
->elf_link_hash_flags
1071 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1073 Elf_Internal_Rel outrel
;
1074 boolean skip
, relocate
;
1080 name
= (bfd_elf_string_from_elf_section
1082 elf_elfheader (input_bfd
)->e_shstrndx
,
1083 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1085 return bfd_reloc_notsupported
;
1087 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
1088 && strcmp (bfd_get_section_name (input_bfd
,
1092 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1093 BFD_ASSERT (sreloc
!= NULL
);
1098 if (elf_section_data (input_section
)->stab_info
== NULL
)
1099 outrel
.r_offset
= rel
->r_offset
;
1104 off
= (_bfd_stab_section_offset
1105 (output_bfd
, &elf_hash_table (info
)->stab_info
,
1107 & elf_section_data (input_section
)->stab_info
,
1109 if (off
== (bfd_vma
) -1)
1111 outrel
.r_offset
= off
;
1114 outrel
.r_offset
+= (input_section
->output_section
->vma
1115 + input_section
->output_offset
);
1119 memset (&outrel
, 0, sizeof outrel
);
1122 else if (r_type
== R_ARM_PC24
)
1124 BFD_ASSERT (h
!= NULL
&& h
->dynindx
!= -1);
1125 if ((input_section
->flags
& SEC_ALLOC
) != 0)
1129 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_PC24
);
1134 || ((info
->symbolic
|| h
->dynindx
== -1)
1135 && (h
->elf_link_hash_flags
1136 & ELF_LINK_HASH_DEF_REGULAR
) != 0))
1139 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1143 BFD_ASSERT (h
->dynindx
!= -1);
1144 if ((input_section
->flags
& SEC_ALLOC
) != 0)
1148 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_ABS32
);
1152 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1153 (((Elf32_External_Rel
*)
1155 + sreloc
->reloc_count
));
1156 ++sreloc
->reloc_count
;
1158 /* If this reloc is against an external symbol, we do not want to
1159 fiddle with the addend. Otherwise, we need to include the symbol
1160 value so that it becomes an addend for the dynamic reloc. */
1162 return bfd_reloc_ok
;
1164 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1165 contents
, rel
->r_offset
, value
,
1168 else switch (r_type
)
1171 case R_ARM_XPC25
: /* Arm BLX instruction. */
1173 case R_ARM_PC24
: /* Arm B/BL instruction */
1175 if (r_type
== R_ARM_XPC25
)
1177 /* Check for Arm calling Arm function. */
1178 /* FIXME: Should we translate the instruction into a BL
1179 instruction instead ? */
1180 if (sym_flags
!= STT_ARM_TFUNC
)
1181 _bfd_error_handler (_("\
1182 %s: Warning: Arm BLX instruction targets Arm function '%s'."),
1183 bfd_get_filename (input_bfd
),
1184 h
? h
->root
.root
.string
: "(local)");
1189 /* Check for Arm calling Thumb function. */
1190 if (sym_flags
== STT_ARM_TFUNC
)
1192 elf32_arm_to_thumb_stub (info
, sym_name
, input_bfd
, output_bfd
,
1193 input_section
, hit_data
, sym_sec
, rel
->r_offset
,
1194 signed_addend
, value
);
1195 return bfd_reloc_ok
;
1199 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1200 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0)
1202 /* The old way of doing things. Trearing the addend as a
1203 byte sized field and adding in the pipeline offset. */
1204 value
-= (input_section
->output_section
->vma
1205 + input_section
->output_offset
);
1206 value
-= rel
->r_offset
;
1209 if (! globals
->no_pipeline_knowledge
)
1214 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
1216 S is the address of the symbol in the relocation.
1217 P is address of the instruction being relocated.
1218 A is the addend (extracted from the instruction) in bytes.
1220 S is held in 'value'.
1221 P is the base address of the section containing the instruction
1222 plus the offset of the reloc into that section, ie:
1223 (input_section->output_section->vma +
1224 input_section->output_offset +
1226 A is the addend, converted into bytes, ie:
1229 Note: None of these operations have knowledge of the pipeline
1230 size of the processor, thus it is up to the assembler to encode
1231 this information into the addend. */
1232 value
-= (input_section
->output_section
->vma
1233 + input_section
->output_offset
);
1234 value
-= rel
->r_offset
;
1235 value
+= (signed_addend
<< howto
->size
);
1237 /* Previous versions of this code also used to add in the pipeline
1238 offset here. This is wrong because the linker is not supposed
1239 to know about such things, and one day it might change. In order
1240 to support old binaries that need the old behaviour however, so
1241 we attempt to detect which ABI was used to create the reloc. */
1242 if (! globals
->no_pipeline_knowledge
)
1244 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form */
1246 i_ehdrp
= elf_elfheader (input_bfd
);
1248 if (i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1253 signed_addend
= value
;
1254 signed_addend
>>= howto
->rightshift
;
1256 /* It is not an error for an undefined weak reference to be
1257 out of range. Any program that branches to such a symbol
1258 is going to crash anyway, so there is no point worrying
1259 about getting the destination exactly right. */
1260 if (! h
|| h
->root
.type
!= bfd_link_hash_undefweak
)
1262 /* Perform a signed range check. */
1263 if ( signed_addend
> ((bfd_signed_vma
) (howto
->dst_mask
>> 1))
1264 || signed_addend
< - ((bfd_signed_vma
) ((howto
->dst_mask
+ 1) >> 1)))
1265 return bfd_reloc_overflow
;
1269 /* If necessary set the H bit in the BLX instruction. */
1270 if (r_type
== R_ARM_XPC25
&& ((value
& 2) == 2))
1271 value
= (signed_addend
& howto
->dst_mask
)
1272 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
))
1276 value
= (signed_addend
& howto
->dst_mask
)
1277 | (bfd_get_32 (input_bfd
, hit_data
) & (~ howto
->dst_mask
));
1282 if (sym_flags
== STT_ARM_TFUNC
)
1287 value
-= (input_section
->output_section
->vma
1288 + input_section
->output_offset
);
1293 bfd_put_32 (input_bfd
, value
, hit_data
);
1294 return bfd_reloc_ok
;
1298 if ((long) value
> 0x7f || (long) value
< -0x80)
1299 return bfd_reloc_overflow
;
1301 bfd_put_8 (input_bfd
, value
, hit_data
);
1302 return bfd_reloc_ok
;
1307 if ((long) value
> 0x7fff || (long) value
< -0x8000)
1308 return bfd_reloc_overflow
;
1310 bfd_put_16 (input_bfd
, value
, hit_data
);
1311 return bfd_reloc_ok
;
1314 /* Support ldr and str instruction for the arm */
1315 /* Also thumb b (unconditional branch). ??? Really? */
1318 if ((long) value
> 0x7ff || (long) value
< -0x800)
1319 return bfd_reloc_overflow
;
1321 value
|= (bfd_get_32 (input_bfd
, hit_data
) & 0xfffff000);
1322 bfd_put_32 (input_bfd
, value
, hit_data
);
1323 return bfd_reloc_ok
;
1325 case R_ARM_THM_ABS5
:
1326 /* Support ldr and str instructions for the thumb. */
1328 /* Need to refetch addend. */
1329 addend
= bfd_get_16 (input_bfd
, hit_data
) & howto
->src_mask
;
1330 /* ??? Need to determine shift amount from operand size. */
1331 addend
>>= howto
->rightshift
;
1335 /* ??? Isn't value unsigned? */
1336 if ((long) value
> 0x1f || (long) value
< -0x10)
1337 return bfd_reloc_overflow
;
1339 /* ??? Value needs to be properly shifted into place first. */
1340 value
|= bfd_get_16 (input_bfd
, hit_data
) & 0xf83f;
1341 bfd_put_16 (input_bfd
, value
, hit_data
);
1342 return bfd_reloc_ok
;
1345 case R_ARM_THM_XPC22
:
1347 case R_ARM_THM_PC22
:
1348 /* Thumb BL (branch long instruction). */
1351 boolean overflow
= false;
1352 bfd_vma upper_insn
= bfd_get_16 (input_bfd
, hit_data
);
1353 bfd_vma lower_insn
= bfd_get_16 (input_bfd
, hit_data
+ 2);
1354 bfd_signed_vma reloc_signed_max
= (1 << (howto
->bitsize
- 1)) - 1;
1355 bfd_signed_vma reloc_signed_min
= ~ reloc_signed_max
;
1357 bfd_signed_vma signed_check
;
1360 /* Need to refetch the addend and squish the two 11 bit pieces
1363 bfd_vma upper
= upper_insn
& 0x7ff;
1364 bfd_vma lower
= lower_insn
& 0x7ff;
1365 upper
= (upper
^ 0x400) - 0x400; /* Sign extend. */
1366 addend
= (upper
<< 12) | (lower
<< 1);
1367 signed_addend
= addend
;
1371 if (r_type
== R_ARM_THM_XPC22
)
1373 /* Check for Thumb to Thumb call. */
1374 /* FIXME: Should we translate the instruction into a BL
1375 instruction instead ? */
1376 if (sym_flags
== STT_ARM_TFUNC
)
1377 _bfd_error_handler (_("\
1378 %s: Warning: Thumb BLX instruction targets thumb function '%s'."),
1379 bfd_get_filename (input_bfd
),
1380 h
? h
->root
.root
.string
: "(local)");
1385 /* If it is not a call to Thumb, assume call to Arm.
1386 If it is a call relative to a section name, then it is not a
1387 function call at all, but rather a long jump. */
1388 if (sym_flags
!= STT_ARM_TFUNC
&& sym_flags
!= STT_SECTION
)
1390 if (elf32_thumb_to_arm_stub
1391 (info
, sym_name
, input_bfd
, output_bfd
, input_section
,
1392 hit_data
, sym_sec
, rel
->r_offset
, signed_addend
, value
))
1393 return bfd_reloc_ok
;
1395 return bfd_reloc_dangerous
;
1399 relocation
= value
+ signed_addend
;
1401 relocation
-= (input_section
->output_section
->vma
1402 + input_section
->output_offset
1405 if (! globals
->no_pipeline_knowledge
)
1407 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form. */
1409 i_ehdrp
= elf_elfheader (input_bfd
);
1411 /* Previous versions of this code also used to add in the pipline
1412 offset here. This is wrong because the linker is not supposed
1413 to know about such things, and one day it might change. In order
1414 to support old binaries that need the old behaviour however, so
1415 we attempt to detect which ABI was used to create the reloc. */
1416 if ( strcmp (bfd_get_target (input_bfd
), "elf32-littlearm-oabi") == 0
1417 || strcmp (bfd_get_target (input_bfd
), "elf32-bigarm-oabi") == 0
1418 || i_ehdrp
->e_ident
[EI_OSABI
] == 0)
1422 check
= relocation
>> howto
->rightshift
;
1424 /* If this is a signed value, the rightshift just dropped
1425 leading 1 bits (assuming twos complement). */
1426 if ((bfd_signed_vma
) relocation
>= 0)
1427 signed_check
= check
;
1429 signed_check
= check
| ~((bfd_vma
) -1 >> howto
->rightshift
);
1431 /* Assumes two's complement. */
1432 if (signed_check
> reloc_signed_max
|| signed_check
< reloc_signed_min
)
1435 /* Put RELOCATION back into the insn. */
1436 upper_insn
= (upper_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 12) & 0x7ff);
1437 lower_insn
= (lower_insn
& ~(bfd_vma
) 0x7ff) | ((relocation
>> 1) & 0x7ff);
1439 /* Put the relocated value back in the object file: */
1440 bfd_put_16 (input_bfd
, upper_insn
, hit_data
);
1441 bfd_put_16 (input_bfd
, lower_insn
, hit_data
+ 2);
1443 return (overflow
? bfd_reloc_overflow
: bfd_reloc_ok
);
1447 case R_ARM_GNU_VTINHERIT
:
1448 case R_ARM_GNU_VTENTRY
:
1449 return bfd_reloc_ok
;
1452 return bfd_reloc_notsupported
;
1454 case R_ARM_GLOB_DAT
:
1455 return bfd_reloc_notsupported
;
1457 case R_ARM_JUMP_SLOT
:
1458 return bfd_reloc_notsupported
;
1460 case R_ARM_RELATIVE
:
1461 return bfd_reloc_notsupported
;
1464 /* Relocation is relative to the start of the
1465 global offset table. */
1467 BFD_ASSERT (sgot
!= NULL
);
1469 return bfd_reloc_notsupported
;
1471 /* Note that sgot->output_offset is not involved in this
1472 calculation. We always want the start of .got. If we
1473 define _GLOBAL_OFFSET_TABLE in a different way, as is
1474 permitted by the ABI, we might have to change this
1476 value
-= sgot
->output_section
->vma
;
1477 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1478 contents
, rel
->r_offset
, value
,
1482 /* Use global offset table as symbol value. */
1483 BFD_ASSERT (sgot
!= NULL
);
1486 return bfd_reloc_notsupported
;
1488 value
= sgot
->output_section
->vma
;
1489 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1490 contents
, rel
->r_offset
, value
,
1494 /* Relocation is to the entry for this symbol in the
1495 global offset table. */
1497 return bfd_reloc_notsupported
;
1503 off
= h
->got
.offset
;
1504 BFD_ASSERT (off
!= (bfd_vma
) -1);
1506 if (!elf_hash_table (info
)->dynamic_sections_created
||
1507 (info
->shared
&& (info
->symbolic
|| h
->dynindx
== -1)
1508 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1510 /* This is actually a static link, or it is a -Bsymbolic link
1511 and the symbol is defined locally. We must initialize this
1512 entry in the global offset table. Since the offset must
1513 always be a multiple of 4, we use the least significant bit
1514 to record whether we have initialized it already.
1516 When doing a dynamic link, we create a .rel.got relocation
1517 entry to initialize the value. This is done in the
1518 finish_dynamic_symbol routine. */
1523 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1528 value
= sgot
->output_offset
+ off
;
1534 BFD_ASSERT (local_got_offsets
!= NULL
&&
1535 local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1537 off
= local_got_offsets
[r_symndx
];
1539 /* The offset must always be a multiple of 4. We use the
1540 least significant bit to record whether we have already
1541 generated the necessary reloc. */
1546 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1551 Elf_Internal_Rel outrel
;
1553 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
1554 BFD_ASSERT (srelgot
!= NULL
);
1556 outrel
.r_offset
= (sgot
->output_section
->vma
1557 + sgot
->output_offset
1559 outrel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
1560 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1561 (((Elf32_External_Rel
*)
1563 + srelgot
->reloc_count
));
1564 ++srelgot
->reloc_count
;
1567 local_got_offsets
[r_symndx
] |= 1;
1570 value
= sgot
->output_offset
+ off
;
1573 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1574 contents
, rel
->r_offset
, value
,
1578 /* Relocation is to the entry for this symbol in the
1579 procedure linkage table. */
1581 /* Resolve a PLT32 reloc against a local symbol directly,
1582 without using the procedure linkage table. */
1584 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1585 contents
, rel
->r_offset
, value
,
1588 if (h
->plt
.offset
== (bfd_vma
) -1)
1589 /* We didn't make a PLT entry for this symbol. This
1590 happens when statically linking PIC code, or when
1591 using -Bsymbolic. */
1592 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1593 contents
, rel
->r_offset
, value
,
1596 BFD_ASSERT(splt
!= NULL
);
1598 return bfd_reloc_notsupported
;
1600 value
= (splt
->output_section
->vma
1601 + splt
->output_offset
1603 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1604 contents
, rel
->r_offset
, value
,
1608 return bfd_reloc_notsupported
;
1610 case R_ARM_AMP_VCALL9
:
1611 return bfd_reloc_notsupported
;
1613 case R_ARM_RSBREL32
:
1614 return bfd_reloc_notsupported
;
1616 case R_ARM_THM_RPC22
:
1617 return bfd_reloc_notsupported
;
1620 return bfd_reloc_notsupported
;
1623 return bfd_reloc_notsupported
;
1626 return bfd_reloc_notsupported
;
1629 return bfd_reloc_notsupported
;
1632 return bfd_reloc_notsupported
;
1637 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
1639 arm_add_to_rel (abfd
, address
, howto
, increment
)
1642 reloc_howto_type
* howto
;
1643 bfd_signed_vma increment
;
1646 bfd_signed_vma addend
;
1648 contents
= bfd_get_32 (abfd
, address
);
1650 /* Get the (signed) value from the instruction. */
1651 addend
= contents
& howto
->src_mask
;
1652 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1654 bfd_signed_vma mask
;
1657 mask
&= ~ howto
->src_mask
;
1661 /* Add in the increment, (which is a byte value). */
1662 switch (howto
->type
)
1664 case R_ARM_THM_PC22
:
1666 addend
+= increment
;
1670 addend
<<= howto
->size
;
1671 addend
+= increment
;
1673 /* Should we check for overflow here ? */
1675 /* Drop any undesired bits. */
1676 addend
>>= howto
->rightshift
;
1680 contents
= (contents
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
1682 bfd_put_32 (abfd
, contents
, address
);
1684 #endif /* USE_REL */
1686 /* Relocate an ARM ELF section. */
1688 elf32_arm_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1689 contents
, relocs
, local_syms
, local_sections
)
1691 struct bfd_link_info
* info
;
1693 asection
* input_section
;
1694 bfd_byte
* contents
;
1695 Elf_Internal_Rela
* relocs
;
1696 Elf_Internal_Sym
* local_syms
;
1697 asection
** local_sections
;
1699 Elf_Internal_Shdr
* symtab_hdr
;
1700 struct elf_link_hash_entry
** sym_hashes
;
1701 Elf_Internal_Rela
* rel
;
1702 Elf_Internal_Rela
* relend
;
1705 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1706 sym_hashes
= elf_sym_hashes (input_bfd
);
1709 relend
= relocs
+ input_section
->reloc_count
;
1710 for (; rel
< relend
; rel
++)
1713 reloc_howto_type
* howto
;
1714 unsigned long r_symndx
;
1715 Elf_Internal_Sym
* sym
;
1717 struct elf_link_hash_entry
* h
;
1719 bfd_reloc_status_type r
;
1722 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1723 r_type
= ELF32_R_TYPE (rel
->r_info
);
1725 if ( r_type
== R_ARM_GNU_VTENTRY
1726 || r_type
== R_ARM_GNU_VTINHERIT
)
1729 elf32_arm_info_to_howto (input_bfd
, & bfd_reloc
, rel
);
1730 howto
= bfd_reloc
.howto
;
1732 if (info
->relocateable
)
1734 /* This is a relocateable link. We don't have to change
1735 anything, unless the reloc is against a section symbol,
1736 in which case we have to adjust according to where the
1737 section symbol winds up in the output section. */
1738 if (r_symndx
< symtab_hdr
->sh_info
)
1740 sym
= local_syms
+ r_symndx
;
1741 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1743 sec
= local_sections
[r_symndx
];
1745 arm_add_to_rel (input_bfd
, contents
+ rel
->r_offset
,
1746 howto
, sec
->output_offset
+ sym
->st_value
);
1748 rel
->r_addend
+= (sec
->output_offset
+ sym
->st_value
)
1749 >> howto
->rightshift
;
1757 /* This is a final link. */
1762 if (r_symndx
< symtab_hdr
->sh_info
)
1764 sym
= local_syms
+ r_symndx
;
1765 sec
= local_sections
[r_symndx
];
1766 relocation
= (sec
->output_section
->vma
1767 + sec
->output_offset
1772 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1774 while ( h
->root
.type
== bfd_link_hash_indirect
1775 || h
->root
.type
== bfd_link_hash_warning
)
1776 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1778 if ( h
->root
.type
== bfd_link_hash_defined
1779 || h
->root
.type
== bfd_link_hash_defweak
)
1781 int relocation_needed
= 1;
1783 sec
= h
->root
.u
.def
.section
;
1785 /* In these cases, we don't need the relocation value.
1786 We check specially because in some obscure cases
1787 sec->output_section will be NULL. */
1794 (!info
->symbolic
&& h
->dynindx
!= -1)
1795 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1797 && ((input_section
->flags
& SEC_ALLOC
) != 0)
1799 relocation_needed
= 0;
1803 relocation_needed
= 0;
1807 if (elf_hash_table(info
)->dynamic_sections_created
1809 || (!info
->symbolic
&& h
->dynindx
!= -1)
1810 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1813 relocation_needed
= 0;
1817 if (h
->plt
.offset
!= (bfd_vma
)-1)
1818 relocation_needed
= 0;
1822 if (sec
->output_section
== NULL
)
1824 (*_bfd_error_handler
)
1825 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1826 bfd_get_filename (input_bfd
), h
->root
.root
.string
,
1827 bfd_get_section_name (input_bfd
, input_section
));
1828 relocation_needed
= 0;
1832 if (relocation_needed
)
1833 relocation
= h
->root
.u
.def
.value
1834 + sec
->output_section
->vma
1835 + sec
->output_offset
;
1839 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1841 else if (info
->shared
&& !info
->symbolic
1842 && !info
->no_undefined
1843 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1847 if (!((*info
->callbacks
->undefined_symbol
)
1848 (info
, h
->root
.root
.string
, input_bfd
,
1849 input_section
, rel
->r_offset
,
1850 (!info
->shared
|| info
->no_undefined
1851 || ELF_ST_VISIBILITY (h
->other
)))))
1858 name
= h
->root
.root
.string
;
1861 name
= (bfd_elf_string_from_elf_section
1862 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
1863 if (name
== NULL
|| *name
== '\0')
1864 name
= bfd_section_name (input_bfd
, sec
);
1867 r
= elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
1868 input_section
, contents
, rel
,
1869 relocation
, info
, sec
, name
,
1870 (h
? ELF_ST_TYPE (h
->type
) :
1871 ELF_ST_TYPE (sym
->st_info
)), h
);
1873 if (r
!= bfd_reloc_ok
)
1875 const char * msg
= (const char *) 0;
1879 case bfd_reloc_overflow
:
1880 if (!((*info
->callbacks
->reloc_overflow
)
1881 (info
, name
, howto
->name
, (bfd_vma
) 0,
1882 input_bfd
, input_section
, rel
->r_offset
)))
1886 case bfd_reloc_undefined
:
1887 if (!((*info
->callbacks
->undefined_symbol
)
1888 (info
, name
, input_bfd
, input_section
,
1889 rel
->r_offset
, true)))
1893 case bfd_reloc_outofrange
:
1894 msg
= _("internal error: out of range error");
1897 case bfd_reloc_notsupported
:
1898 msg
= _("internal error: unsupported relocation error");
1901 case bfd_reloc_dangerous
:
1902 msg
= _("internal error: dangerous error");
1906 msg
= _("internal error: unknown error");
1910 if (!((*info
->callbacks
->warning
)
1911 (info
, msg
, name
, input_bfd
, input_section
,
1922 /* Function to keep ARM specific flags in the ELF header. */
1924 elf32_arm_set_private_flags (abfd
, flags
)
1928 if (elf_flags_init (abfd
)
1929 && elf_elfheader (abfd
)->e_flags
!= flags
)
1931 if (EF_ARM_EABI_VERSION (flags
) == EF_ARM_EABI_UNKNOWN
)
1933 if (flags
& EF_INTERWORK
)
1934 _bfd_error_handler (_("\
1935 Warning: Not setting interwork flag of %s since it has already been specified as non-interworking"),
1936 bfd_get_filename (abfd
));
1938 _bfd_error_handler (_("\
1939 Warning: Clearing the interwork flag of %s due to outside request"),
1940 bfd_get_filename (abfd
));
1945 elf_elfheader (abfd
)->e_flags
= flags
;
1946 elf_flags_init (abfd
) = true;
1952 /* Copy backend specific data from one object module to another. */
1955 elf32_arm_copy_private_bfd_data (ibfd
, obfd
)
1962 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1963 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1966 in_flags
= elf_elfheader (ibfd
)->e_flags
;
1967 out_flags
= elf_elfheader (obfd
)->e_flags
;
1969 if (elf_flags_init (obfd
)
1970 && EF_ARM_EABI_VERSION (out_flags
) == EF_ARM_EABI_UNKNOWN
1971 && in_flags
!= out_flags
)
1973 /* Cannot mix PIC and non-PIC code. */
1974 if ((in_flags
& EF_PIC
) != (out_flags
& EF_PIC
))
1977 /* Cannot mix APCS26 and APCS32 code. */
1978 if ((in_flags
& EF_APCS_26
) != (out_flags
& EF_APCS_26
))
1981 /* Cannot mix float APCS and non-float APCS code. */
1982 if ((in_flags
& EF_APCS_FLOAT
) != (out_flags
& EF_APCS_FLOAT
))
1985 /* If the src and dest have different interworking flags
1986 then turn off the interworking bit. */
1987 if ((in_flags
& EF_INTERWORK
) != (out_flags
& EF_INTERWORK
))
1989 if (out_flags
& EF_INTERWORK
)
1990 _bfd_error_handler (_("\
1991 Warning: Clearing the interwork flag in %s because non-interworking code in %s has been linked with it"),
1992 bfd_get_filename (obfd
), bfd_get_filename (ibfd
));
1994 in_flags
&= ~EF_INTERWORK
;
1998 elf_elfheader (obfd
)->e_flags
= in_flags
;
1999 elf_flags_init (obfd
) = true;
2004 /* Merge backend specific data from an object file to the output
2005 object file when linking. */
2008 elf32_arm_merge_private_bfd_data (ibfd
, obfd
)
2015 /* Check if we have the same endianess. */
2016 if (_bfd_generic_verify_endian_match (ibfd
, obfd
) == false)
2019 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2020 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2023 /* The input BFD must have had its flags initialised. */
2024 /* The following seems bogus to me -- The flags are initialized in
2025 the assembler but I don't think an elf_flags_init field is
2026 written into the object. */
2027 /* BFD_ASSERT (elf_flags_init (ibfd)); */
2029 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2030 out_flags
= elf_elfheader (obfd
)->e_flags
;
2032 if (!elf_flags_init (obfd
))
2034 /* If the input is the default architecture then do not
2035 bother setting the flags for the output architecture,
2036 instead allow future merges to do this. If no future
2037 merges ever set these flags then they will retain their
2038 unitialised values, which surprise surprise, correspond
2039 to the default values. */
2040 if (bfd_get_arch_info (ibfd
)->the_default
)
2043 elf_flags_init (obfd
) = true;
2044 elf_elfheader (obfd
)->e_flags
= in_flags
;
2046 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
2047 && bfd_get_arch_info (obfd
)->the_default
)
2048 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
), bfd_get_mach (ibfd
));
2053 /* Check flag compatibility. */
2054 if (in_flags
== out_flags
)
2057 /* Complain about various flag mismatches. */
2058 if (EF_ARM_EABI_VERSION (in_flags
) != EF_ARM_EABI_VERSION (out_flags
))
2060 _bfd_error_handler (_("\
2061 Error: %s compiled for EABI version %d, whereas %s is compiled for version %d"),
2062 bfd_get_filename (ibfd
),
2063 (in_flags
& EF_ARM_EABIMASK
) >> 24,
2064 bfd_get_filename (obfd
),
2065 (out_flags
& EF_ARM_EABIMASK
) >> 24);
2067 else if (EF_ARM_EABI_VERSION (in_flags
) != EF_ARM_EABI_UNKNOWN
)
2068 /* Not sure what needs to be checked for EABI versions >= 1. */
2071 if ((in_flags
& EF_APCS_26
) != (out_flags
& EF_APCS_26
))
2072 _bfd_error_handler (_("\
2073 Error: %s compiled for APCS-%d, whereas %s is compiled for APCS-%d"),
2074 bfd_get_filename (ibfd
),
2075 in_flags
& EF_APCS_26
? 26 : 32,
2076 bfd_get_filename (obfd
),
2077 out_flags
& EF_APCS_26
? 26 : 32);
2079 if ((in_flags
& EF_APCS_FLOAT
) != (out_flags
& EF_APCS_FLOAT
))
2080 _bfd_error_handler (_("\
2081 Error: %s passes floats in %s registers, whereas %s passes them in %s registers"),
2082 bfd_get_filename (ibfd
),
2083 in_flags
& EF_APCS_FLOAT
? _("float") : _("integer"),
2084 bfd_get_filename (obfd
),
2085 out_flags
& EF_APCS_26
? _("float") : _("integer"));
2087 if ((in_flags
& EF_PIC
) != (out_flags
& EF_PIC
))
2088 _bfd_error_handler (_("\
2089 Error: %s is compiled as position %s code, whereas %s is not"),
2090 bfd_get_filename (ibfd
),
2091 in_flags
& EF_PIC
? _("independent") : _("dependent"),
2092 bfd_get_filename (obfd
));
2094 /* Interworking mismatch is only a warning. */
2095 if ((in_flags
& EF_INTERWORK
) != (out_flags
& EF_INTERWORK
))
2097 _bfd_error_handler (_("\
2098 Warning: %s %s interworking, whereas %s %s"),
2099 bfd_get_filename (ibfd
),
2100 in_flags
& EF_INTERWORK
? _("supports") : _("does not support"),
2101 bfd_get_filename (obfd
),
2102 out_flags
& EF_INTERWORK
? _("does not") : _("does"));
2109 /* Display the flags field. */
2112 elf32_arm_print_private_bfd_data (abfd
, ptr
)
2116 FILE * file
= (FILE *) ptr
;
2117 unsigned long flags
;
2119 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
2121 /* Print normal ELF private data. */
2122 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
2124 flags
= elf_elfheader (abfd
)->e_flags
;
2125 /* Ignore init flag - it may not be set, despite the flags field
2126 containing valid data. */
2128 /* xgettext:c-format */
2129 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
2131 switch (EF_ARM_EABI_VERSION (flags
))
2133 case EF_ARM_EABI_UNKNOWN
:
2134 /* The following flag bits are GNU extenstions and not part of the
2135 official ARM ELF extended ABI. Hence they are only decoded if
2136 the EABI version is not set. */
2137 if (flags
& EF_INTERWORK
)
2138 fprintf (file
, _(" [interworking enabled]"));
2140 if (flags
& EF_APCS_26
)
2141 fprintf (file
, _(" [APCS-26]"));
2143 fprintf (file
, _(" [APCS-32]"));
2145 if (flags
& EF_APCS_FLOAT
)
2146 fprintf (file
, _(" [floats passed in float registers]"));
2149 fprintf (file
, _(" [position independent]"));
2151 if (flags
& EF_NEW_ABI
)
2152 fprintf (file
, _(" [new ABI]"));
2154 if (flags
& EF_OLD_ABI
)
2155 fprintf (file
, _(" [old ABI]"));
2157 if (flags
& EF_SOFT_FLOAT
)
2158 fprintf (file
, _(" [software FP]"));
2160 flags
&= ~(EF_INTERWORK
| EF_APCS_26
| EF_APCS_FLOAT
| EF_PIC
2161 | EF_NEW_ABI
| EF_OLD_ABI
| EF_SOFT_FLOAT
);
2164 case EF_ARM_EABI_VER1
:
2165 fprintf (file
, _(" [Version1 EABI]"));
2167 if (flags
& EF_ARM_SYMSARESORTED
)
2168 fprintf (file
, _(" [sorted symbol table]"));
2170 fprintf (file
, _(" [unsorted symbol table]"));
2172 flags
&= ~ EF_ARM_SYMSARESORTED
;
2176 fprintf (file
, _(" <EABI version unrecognised>"));
2180 flags
&= ~ EF_ARM_EABIMASK
;
2182 if (flags
& EF_ARM_RELEXEC
)
2183 fprintf (file
, _(" [relocatable executable]"));
2185 if (flags
& EF_ARM_HASENTRY
)
2186 fprintf (file
, _(" [has entry point]"));
2188 flags
&= ~ (EF_ARM_RELEXEC
| EF_ARM_HASENTRY
);
2191 fprintf (file
, _("<Unrecognised flag bits set>"));
2199 elf32_arm_get_symbol_type (elf_sym
, type
)
2200 Elf_Internal_Sym
* elf_sym
;
2203 switch (ELF_ST_TYPE (elf_sym
->st_info
))
2206 return ELF_ST_TYPE (elf_sym
->st_info
);
2209 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2210 This allows us to distinguish between data used by Thumb instructions
2211 and non-data (which is probably code) inside Thumb regions of an
2213 if (type
!= STT_OBJECT
)
2214 return ELF_ST_TYPE (elf_sym
->st_info
);
2225 elf32_arm_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
2227 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2228 Elf_Internal_Rela
*rel
;
2229 struct elf_link_hash_entry
*h
;
2230 Elf_Internal_Sym
*sym
;
2234 switch (ELF32_R_TYPE (rel
->r_info
))
2236 case R_ARM_GNU_VTINHERIT
:
2237 case R_ARM_GNU_VTENTRY
:
2241 switch (h
->root
.type
)
2243 case bfd_link_hash_defined
:
2244 case bfd_link_hash_defweak
:
2245 return h
->root
.u
.def
.section
;
2247 case bfd_link_hash_common
:
2248 return h
->root
.u
.c
.p
->section
;
2257 if (!(elf_bad_symtab (abfd
)
2258 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
2259 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
2260 && sym
->st_shndx
!= SHN_COMMON
))
2262 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
2268 /* Update the got entry reference counts for the section being removed. */
2271 elf32_arm_gc_sweep_hook (abfd
, info
, sec
, relocs
)
2272 bfd
*abfd ATTRIBUTE_UNUSED
;
2273 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2274 asection
*sec ATTRIBUTE_UNUSED
;
2275 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
;
2277 /* We don't support garbage collection of GOT and PLT relocs yet. */
2281 /* Look through the relocs for a section during the first phase. */
2284 elf32_arm_check_relocs (abfd
, info
, sec
, relocs
)
2286 struct bfd_link_info
* info
;
2288 const Elf_Internal_Rela
* relocs
;
2290 Elf_Internal_Shdr
* symtab_hdr
;
2291 struct elf_link_hash_entry
** sym_hashes
;
2292 struct elf_link_hash_entry
** sym_hashes_end
;
2293 const Elf_Internal_Rela
* rel
;
2294 const Elf_Internal_Rela
* rel_end
;
2296 asection
* sgot
, *srelgot
, *sreloc
;
2297 bfd_vma
* local_got_offsets
;
2299 if (info
->relocateable
)
2302 sgot
= srelgot
= sreloc
= NULL
;
2304 dynobj
= elf_hash_table (info
)->dynobj
;
2305 local_got_offsets
= elf_local_got_offsets (abfd
);
2307 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2308 sym_hashes
= elf_sym_hashes (abfd
);
2309 sym_hashes_end
= sym_hashes
2310 + symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
2312 if (!elf_bad_symtab (abfd
))
2313 sym_hashes_end
-= symtab_hdr
->sh_info
;
2315 rel_end
= relocs
+ sec
->reloc_count
;
2316 for (rel
= relocs
; rel
< rel_end
; rel
++)
2318 struct elf_link_hash_entry
*h
;
2319 unsigned long r_symndx
;
2321 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2322 if (r_symndx
< symtab_hdr
->sh_info
)
2325 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2327 /* Some relocs require a global offset table. */
2330 switch (ELF32_R_TYPE (rel
->r_info
))
2335 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
2336 if (! _bfd_elf_create_got_section (dynobj
, info
))
2345 switch (ELF32_R_TYPE (rel
->r_info
))
2348 /* This symbol requires a global offset table entry. */
2351 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2352 BFD_ASSERT (sgot
!= NULL
);
2355 /* Get the got relocation section if necessary. */
2357 && (h
!= NULL
|| info
->shared
))
2359 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
2361 /* If no got relocation section, make one and initialize. */
2362 if (srelgot
== NULL
)
2364 srelgot
= bfd_make_section (dynobj
, ".rel.got");
2366 || ! bfd_set_section_flags (dynobj
, srelgot
,
2371 | SEC_LINKER_CREATED
2373 || ! bfd_set_section_alignment (dynobj
, srelgot
, 2))
2380 if (h
->got
.offset
!= (bfd_vma
) -1)
2381 /* We have already allocated space in the .got. */
2384 h
->got
.offset
= sgot
->_raw_size
;
2386 /* Make sure this symbol is output as a dynamic symbol. */
2387 if (h
->dynindx
== -1)
2388 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2391 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2395 /* This is a global offset table entry for a local
2397 if (local_got_offsets
== NULL
)
2400 register unsigned int i
;
2402 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
2403 local_got_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
2404 if (local_got_offsets
== NULL
)
2406 elf_local_got_offsets (abfd
) = local_got_offsets
;
2407 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
2408 local_got_offsets
[i
] = (bfd_vma
) -1;
2411 if (local_got_offsets
[r_symndx
] != (bfd_vma
) -1)
2412 /* We have already allocated space in the .got. */
2415 local_got_offsets
[r_symndx
] = sgot
->_raw_size
;
2418 /* If we are generating a shared object, we need to
2419 output a R_ARM_RELATIVE reloc so that the dynamic
2420 linker can adjust this GOT entry. */
2421 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2424 sgot
->_raw_size
+= 4;
2428 /* This symbol requires a procedure linkage table entry. We
2429 actually build the entry in adjust_dynamic_symbol,
2430 because this might be a case of linking PIC code which is
2431 never referenced by a dynamic object, in which case we
2432 don't need to generate a procedure linkage table entry
2435 /* If this is a local symbol, we resolve it directly without
2436 creating a procedure linkage table entry. */
2440 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2446 /* If we are creating a shared library, and this is a reloc
2447 against a global symbol, or a non PC relative reloc
2448 against a local symbol, then we need to copy the reloc
2449 into the shared library. However, if we are linking with
2450 -Bsymbolic, we do not need to copy a reloc against a
2451 global symbol which is defined in an object we are
2452 including in the link (i.e., DEF_REGULAR is set). At
2453 this point we have not seen all the input files, so it is
2454 possible that DEF_REGULAR is not set now but will be set
2455 later (it is never cleared). We account for that
2456 possibility below by storing information in the
2457 pcrel_relocs_copied field of the hash table entry. */
2459 && (ELF32_R_TYPE (rel
->r_info
) != R_ARM_PC24
2461 && (! info
->symbolic
2462 || (h
->elf_link_hash_flags
2463 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
2465 /* When creating a shared object, we must copy these
2466 reloc types into the output file. We create a reloc
2467 section in dynobj and make room for this reloc. */
2472 name
= (bfd_elf_string_from_elf_section
2474 elf_elfheader (abfd
)->e_shstrndx
,
2475 elf_section_data (sec
)->rel_hdr
.sh_name
));
2479 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
2480 && strcmp (bfd_get_section_name (abfd
, sec
),
2483 sreloc
= bfd_get_section_by_name (dynobj
, name
);
2488 sreloc
= bfd_make_section (dynobj
, name
);
2489 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
2490 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
2491 if ((sec
->flags
& SEC_ALLOC
) != 0)
2492 flags
|= SEC_ALLOC
| SEC_LOAD
;
2494 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
2495 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
2500 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
2501 /* If we are linking with -Bsymbolic, and this is a
2502 global symbol, we count the number of PC relative
2503 relocations we have entered for this symbol, so that
2504 we can discard them again if the symbol is later
2505 defined by a regular object. Note that this function
2506 is only called if we are using an elf_i386 linker
2507 hash table, which means that h is really a pointer to
2508 an elf_i386_link_hash_entry. */
2509 if (h
!= NULL
&& info
->symbolic
2510 && ELF32_R_TYPE (rel
->r_info
) == R_ARM_PC24
)
2512 struct elf32_arm_link_hash_entry
* eh
;
2513 struct elf32_arm_pcrel_relocs_copied
* p
;
2515 eh
= (struct elf32_arm_link_hash_entry
*) h
;
2517 for (p
= eh
->pcrel_relocs_copied
; p
!= NULL
; p
= p
->next
)
2518 if (p
->section
== sreloc
)
2523 p
= ((struct elf32_arm_pcrel_relocs_copied
*)
2524 bfd_alloc (dynobj
, sizeof * p
));
2528 p
->next
= eh
->pcrel_relocs_copied
;
2529 eh
->pcrel_relocs_copied
= p
;
2530 p
->section
= sreloc
;
2539 /* This relocation describes the C++ object vtable hierarchy.
2540 Reconstruct it for later use during GC. */
2541 case R_ARM_GNU_VTINHERIT
:
2542 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2546 /* This relocation describes which C++ vtable entries are actually
2547 used. Record for later use during GC. */
2548 case R_ARM_GNU_VTENTRY
:
2549 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
2559 /* Find the nearest line to a particular section and offset, for error
2560 reporting. This code is a duplicate of the code in elf.c, except
2561 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
2564 elf32_arm_find_nearest_line
2565 (abfd
, section
, symbols
, offset
, filename_ptr
, functionname_ptr
, line_ptr
)
2570 CONST
char ** filename_ptr
;
2571 CONST
char ** functionname_ptr
;
2572 unsigned int * line_ptr
;
2575 const char * filename
;
2580 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
2581 filename_ptr
, functionname_ptr
,
2585 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2586 &found
, filename_ptr
,
2587 functionname_ptr
, line_ptr
,
2588 &elf_tdata (abfd
)->line_info
))
2594 if (symbols
== NULL
)
2601 for (p
= symbols
; *p
!= NULL
; p
++)
2605 q
= (elf_symbol_type
*) *p
;
2607 if (bfd_get_section (&q
->symbol
) != section
)
2610 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
2615 filename
= bfd_asymbol_name (&q
->symbol
);
2620 if (q
->symbol
.section
== section
2621 && q
->symbol
.value
>= low_func
2622 && q
->symbol
.value
<= offset
)
2624 func
= (asymbol
*) q
;
2625 low_func
= q
->symbol
.value
;
2634 *filename_ptr
= filename
;
2635 *functionname_ptr
= bfd_asymbol_name (func
);
2641 /* Adjust a symbol defined by a dynamic object and referenced by a
2642 regular object. The current definition is in some section of the
2643 dynamic object, but we're not including those sections. We have to
2644 change the definition to something the rest of the link can
2648 elf32_arm_adjust_dynamic_symbol (info
, h
)
2649 struct bfd_link_info
* info
;
2650 struct elf_link_hash_entry
* h
;
2654 unsigned int power_of_two
;
2656 dynobj
= elf_hash_table (info
)->dynobj
;
2658 /* Make sure we know what is going on here. */
2659 BFD_ASSERT (dynobj
!= NULL
2660 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
2661 || h
->weakdef
!= NULL
2662 || ((h
->elf_link_hash_flags
2663 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2664 && (h
->elf_link_hash_flags
2665 & ELF_LINK_HASH_REF_REGULAR
) != 0
2666 && (h
->elf_link_hash_flags
2667 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
2669 /* If this is a function, put it in the procedure linkage table. We
2670 will fill in the contents of the procedure linkage table later,
2671 when we know the address of the .got section. */
2672 if (h
->type
== STT_FUNC
2673 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
2676 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
2677 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0)
2679 /* This case can occur if we saw a PLT32 reloc in an input
2680 file, but the symbol was never referred to by a dynamic
2681 object. In such a case, we don't actually need to build
2682 a procedure linkage table, and we can just do a PC32
2684 BFD_ASSERT ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0);
2688 /* Make sure this symbol is output as a dynamic symbol. */
2689 if (h
->dynindx
== -1)
2691 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2695 s
= bfd_get_section_by_name (dynobj
, ".plt");
2696 BFD_ASSERT (s
!= NULL
);
2698 /* If this is the first .plt entry, make room for the special
2700 if (s
->_raw_size
== 0)
2701 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2703 /* If this symbol is not defined in a regular file, and we are
2704 not generating a shared library, then set the symbol to this
2705 location in the .plt. This is required to make function
2706 pointers compare as equal between the normal executable and
2707 the shared library. */
2709 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2711 h
->root
.u
.def
.section
= s
;
2712 h
->root
.u
.def
.value
= s
->_raw_size
;
2715 h
->plt
.offset
= s
->_raw_size
;
2717 /* Make room for this entry. */
2718 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2720 /* We also need to make an entry in the .got.plt section, which
2721 will be placed in the .got section by the linker script. */
2722 s
= bfd_get_section_by_name (dynobj
, ".got.plt");
2723 BFD_ASSERT (s
!= NULL
);
2726 /* We also need to make an entry in the .rel.plt section. */
2728 s
= bfd_get_section_by_name (dynobj
, ".rel.plt");
2729 BFD_ASSERT (s
!= NULL
);
2730 s
->_raw_size
+= sizeof (Elf32_External_Rel
);
2735 /* If this is a weak symbol, and there is a real definition, the
2736 processor independent code will have arranged for us to see the
2737 real definition first, and we can just use the same value. */
2738 if (h
->weakdef
!= NULL
)
2740 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
2741 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
2742 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
2743 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
2747 /* This is a reference to a symbol defined by a dynamic object which
2748 is not a function. */
2750 /* If we are creating a shared library, we must presume that the
2751 only references to the symbol are via the global offset table.
2752 For such cases we need not do anything here; the relocations will
2753 be handled correctly by relocate_section. */
2757 /* We must allocate the symbol in our .dynbss section, which will
2758 become part of the .bss section of the executable. There will be
2759 an entry for this symbol in the .dynsym section. The dynamic
2760 object will contain position independent code, so all references
2761 from the dynamic object to this symbol will go through the global
2762 offset table. The dynamic linker will use the .dynsym entry to
2763 determine the address it must put in the global offset table, so
2764 both the dynamic object and the regular object will refer to the
2765 same memory location for the variable. */
2766 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
2767 BFD_ASSERT (s
!= NULL
);
2769 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
2770 copy the initial value out of the dynamic object and into the
2771 runtime process image. We need to remember the offset into the
2772 .rel.bss section we are going to use. */
2773 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2777 srel
= bfd_get_section_by_name (dynobj
, ".rel.bss");
2778 BFD_ASSERT (srel
!= NULL
);
2779 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
2780 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
2783 /* We need to figure out the alignment required for this symbol. I
2784 have no idea how ELF linkers handle this. */
2785 power_of_two
= bfd_log2 (h
->size
);
2786 if (power_of_two
> 3)
2789 /* Apply the required alignment. */
2790 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
2791 (bfd_size_type
) (1 << power_of_two
));
2792 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
2794 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
2798 /* Define the symbol as being at this point in the section. */
2799 h
->root
.u
.def
.section
= s
;
2800 h
->root
.u
.def
.value
= s
->_raw_size
;
2802 /* Increment the section size to make room for the symbol. */
2803 s
->_raw_size
+= h
->size
;
2808 /* Set the sizes of the dynamic sections. */
2811 elf32_arm_size_dynamic_sections (output_bfd
, info
)
2813 struct bfd_link_info
* info
;
2821 dynobj
= elf_hash_table (info
)->dynobj
;
2822 BFD_ASSERT (dynobj
!= NULL
);
2824 if (elf_hash_table (info
)->dynamic_sections_created
)
2826 /* Set the contents of the .interp section to the interpreter. */
2829 s
= bfd_get_section_by_name (dynobj
, ".interp");
2830 BFD_ASSERT (s
!= NULL
);
2831 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2832 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2837 /* We may have created entries in the .rel.got section.
2838 However, if we are not creating the dynamic sections, we will
2839 not actually use these entries. Reset the size of .rel.got,
2840 which will cause it to get stripped from the output file
2842 s
= bfd_get_section_by_name (dynobj
, ".rel.got");
2847 /* If this is a -Bsymbolic shared link, then we need to discard all
2848 PC relative relocs against symbols defined in a regular object.
2849 We allocated space for them in the check_relocs routine, but we
2850 will not fill them in in the relocate_section routine. */
2851 if (info
->shared
&& info
->symbolic
)
2852 elf32_arm_link_hash_traverse (elf32_arm_hash_table (info
),
2853 elf32_arm_discard_copies
,
2856 /* The check_relocs and adjust_dynamic_symbol entry points have
2857 determined the sizes of the various dynamic sections. Allocate
2862 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2867 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2870 /* It's OK to base decisions on the section name, because none
2871 of the dynobj section names depend upon the input files. */
2872 name
= bfd_get_section_name (dynobj
, s
);
2876 if (strcmp (name
, ".plt") == 0)
2878 if (s
->_raw_size
== 0)
2880 /* Strip this section if we don't need it; see the
2886 /* Remember whether there is a PLT. */
2890 else if (strncmp (name
, ".rel", 4) == 0)
2892 if (s
->_raw_size
== 0)
2894 /* If we don't need this section, strip it from the
2895 output file. This is mostly to handle .rel.bss and
2896 .rel.plt. We must create both sections in
2897 create_dynamic_sections, because they must be created
2898 before the linker maps input sections to output
2899 sections. The linker does that before
2900 adjust_dynamic_symbol is called, and it is that
2901 function which decides whether anything needs to go
2902 into these sections. */
2909 /* Remember whether there are any reloc sections other
2911 if (strcmp (name
, ".rel.plt") != 0)
2913 const char *outname
;
2917 /* If this relocation section applies to a read only
2918 section, then we probably need a DT_TEXTREL
2919 entry. The entries in the .rel.plt section
2920 really apply to the .got section, which we
2921 created ourselves and so know is not readonly. */
2922 outname
= bfd_get_section_name (output_bfd
,
2924 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
2927 && (target
->flags
& SEC_READONLY
) != 0
2928 && (target
->flags
& SEC_ALLOC
) != 0)
2932 /* We use the reloc_count field as a counter if we need
2933 to copy relocs into the output file. */
2937 else if (strncmp (name
, ".got", 4) != 0)
2939 /* It's not one of our sections, so don't allocate space. */
2947 for (spp
= &s
->output_section
->owner
->sections
;
2948 *spp
!= s
->output_section
;
2949 spp
= &(*spp
)->next
)
2951 *spp
= s
->output_section
->next
;
2952 --s
->output_section
->owner
->section_count
;
2957 /* Allocate memory for the section contents. */
2958 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
2959 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
2963 if (elf_hash_table (info
)->dynamic_sections_created
)
2965 /* Add some entries to the .dynamic section. We fill in the
2966 values later, in elf32_arm_finish_dynamic_sections, but we
2967 must add the entries now so that we get the correct size for
2968 the .dynamic section. The DT_DEBUG entry is filled in by the
2969 dynamic linker and used by the debugger. */
2972 if (! bfd_elf32_add_dynamic_entry (info
, DT_DEBUG
, 0))
2978 if ( ! bfd_elf32_add_dynamic_entry (info
, DT_PLTGOT
, 0)
2979 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
2980 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTREL
, DT_REL
)
2981 || ! bfd_elf32_add_dynamic_entry (info
, DT_JMPREL
, 0))
2987 if ( ! bfd_elf32_add_dynamic_entry (info
, DT_REL
, 0)
2988 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELSZ
, 0)
2989 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELENT
,
2990 sizeof (Elf32_External_Rel
)))
2996 if (! bfd_elf32_add_dynamic_entry (info
, DT_TEXTREL
, 0))
2998 info
->flags
|= DF_TEXTREL
;
3005 /* This function is called via elf32_arm_link_hash_traverse if we are
3006 creating a shared object with -Bsymbolic. It discards the space
3007 allocated to copy PC relative relocs against symbols which are
3008 defined in regular objects. We allocated space for them in the
3009 check_relocs routine, but we won't fill them in in the
3010 relocate_section routine. */
3013 elf32_arm_discard_copies (h
, ignore
)
3014 struct elf32_arm_link_hash_entry
* h
;
3015 PTR ignore ATTRIBUTE_UNUSED
;
3017 struct elf32_arm_pcrel_relocs_copied
* s
;
3019 /* We only discard relocs for symbols defined in a regular object. */
3020 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3023 for (s
= h
->pcrel_relocs_copied
; s
!= NULL
; s
= s
->next
)
3024 s
->section
->_raw_size
-= s
->count
* sizeof (Elf32_External_Rel
);
3029 /* Finish up dynamic symbol handling. We set the contents of various
3030 dynamic sections here. */
3033 elf32_arm_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
3035 struct bfd_link_info
* info
;
3036 struct elf_link_hash_entry
* h
;
3037 Elf_Internal_Sym
* sym
;
3041 dynobj
= elf_hash_table (info
)->dynobj
;
3043 if (h
->plt
.offset
!= (bfd_vma
) -1)
3050 Elf_Internal_Rel rel
;
3052 /* This symbol has an entry in the procedure linkage table. Set
3055 BFD_ASSERT (h
->dynindx
!= -1);
3057 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3058 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3059 srel
= bfd_get_section_by_name (dynobj
, ".rel.plt");
3060 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
3062 /* Get the index in the procedure linkage table which
3063 corresponds to this symbol. This is the index of this symbol
3064 in all the symbols for which we are making plt entries. The
3065 first entry in the procedure linkage table is reserved. */
3066 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
3068 /* Get the offset into the .got table of the entry that
3069 corresponds to this function. Each .got entry is 4 bytes.
3070 The first three are reserved. */
3071 got_offset
= (plt_index
+ 3) * 4;
3073 /* Fill in the entry in the procedure linkage table. */
3074 memcpy (splt
->contents
+ h
->plt
.offset
,
3075 elf32_arm_plt_entry
,
3077 bfd_put_32 (output_bfd
,
3078 (sgot
->output_section
->vma
3079 + sgot
->output_offset
3081 - splt
->output_section
->vma
3082 - splt
->output_offset
3083 - h
->plt
.offset
- 12),
3084 splt
->contents
+ h
->plt
.offset
+ 12);
3086 /* Fill in the entry in the global offset table. */
3087 bfd_put_32 (output_bfd
,
3088 (splt
->output_section
->vma
3089 + splt
->output_offset
),
3090 sgot
->contents
+ got_offset
);
3092 /* Fill in the entry in the .rel.plt section. */
3093 rel
.r_offset
= (sgot
->output_section
->vma
3094 + sgot
->output_offset
3096 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_JUMP_SLOT
);
3097 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3098 ((Elf32_External_Rel
*) srel
->contents
3101 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3103 /* Mark the symbol as undefined, rather than as defined in
3104 the .plt section. Leave the value alone. */
3105 sym
->st_shndx
= SHN_UNDEF
;
3109 if (h
->got
.offset
!= (bfd_vma
) -1)
3113 Elf_Internal_Rel rel
;
3115 /* This symbol has an entry in the global offset table. Set it
3117 sgot
= bfd_get_section_by_name (dynobj
, ".got");
3118 srel
= bfd_get_section_by_name (dynobj
, ".rel.got");
3119 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
3121 rel
.r_offset
= (sgot
->output_section
->vma
3122 + sgot
->output_offset
3123 + (h
->got
.offset
&~ 1));
3125 /* If this is a -Bsymbolic link, and the symbol is defined
3126 locally, we just want to emit a RELATIVE reloc. The entry in
3127 the global offset table will already have been initialized in
3128 the relocate_section function. */
3130 && (info
->symbolic
|| h
->dynindx
== -1)
3131 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
3132 rel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
3135 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
3136 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_GLOB_DAT
);
3139 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3140 ((Elf32_External_Rel
*) srel
->contents
3141 + srel
->reloc_count
));
3142 ++srel
->reloc_count
;
3145 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
3148 Elf_Internal_Rel rel
;
3150 /* This symbol needs a copy reloc. Set it up. */
3151 BFD_ASSERT (h
->dynindx
!= -1
3152 && (h
->root
.type
== bfd_link_hash_defined
3153 || h
->root
.type
== bfd_link_hash_defweak
));
3155 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
3157 BFD_ASSERT (s
!= NULL
);
3159 rel
.r_offset
= (h
->root
.u
.def
.value
3160 + h
->root
.u
.def
.section
->output_section
->vma
3161 + h
->root
.u
.def
.section
->output_offset
);
3162 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_COPY
);
3163 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3164 ((Elf32_External_Rel
*) s
->contents
3169 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3170 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3171 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
3172 sym
->st_shndx
= SHN_ABS
;
3177 /* Finish up the dynamic sections. */
3180 elf32_arm_finish_dynamic_sections (output_bfd
, info
)
3182 struct bfd_link_info
* info
;
3188 dynobj
= elf_hash_table (info
)->dynobj
;
3190 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3191 BFD_ASSERT (sgot
!= NULL
);
3192 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3194 if (elf_hash_table (info
)->dynamic_sections_created
)
3197 Elf32_External_Dyn
*dyncon
, *dynconend
;
3199 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3200 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3202 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3203 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
3205 for (; dyncon
< dynconend
; dyncon
++)
3207 Elf_Internal_Dyn dyn
;
3211 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3224 s
= bfd_get_section_by_name (output_bfd
, name
);
3225 BFD_ASSERT (s
!= NULL
);
3226 dyn
.d_un
.d_ptr
= s
->vma
;
3227 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3231 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3232 BFD_ASSERT (s
!= NULL
);
3233 if (s
->_cooked_size
!= 0)
3234 dyn
.d_un
.d_val
= s
->_cooked_size
;
3236 dyn
.d_un
.d_val
= s
->_raw_size
;
3237 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3241 /* My reading of the SVR4 ABI indicates that the
3242 procedure linkage table relocs (DT_JMPREL) should be
3243 included in the overall relocs (DT_REL). This is
3244 what Solaris does. However, UnixWare can not handle
3245 that case. Therefore, we override the DT_RELSZ entry
3246 here to make it not include the JMPREL relocs. Since
3247 the linker script arranges for .rel.plt to follow all
3248 other relocation sections, we don't have to worry
3249 about changing the DT_REL entry. */
3250 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3253 if (s
->_cooked_size
!= 0)
3254 dyn
.d_un
.d_val
-= s
->_cooked_size
;
3256 dyn
.d_un
.d_val
-= s
->_raw_size
;
3258 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3263 /* Fill in the first entry in the procedure linkage table. */
3264 if (splt
->_raw_size
> 0)
3265 memcpy (splt
->contents
, elf32_arm_plt0_entry
, PLT_ENTRY_SIZE
);
3267 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3268 really seem like the right value. */
3269 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
3272 /* Fill in the first three entries in the global offset table. */
3273 if (sgot
->_raw_size
> 0)
3276 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
3278 bfd_put_32 (output_bfd
,
3279 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3281 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
3282 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
3285 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
3291 elf32_arm_post_process_headers (abfd
, link_info
)
3293 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
;
3295 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
3297 i_ehdrp
= elf_elfheader (abfd
);
3299 i_ehdrp
->e_ident
[EI_OSABI
] = ARM_ELF_OS_ABI_VERSION
;
3300 i_ehdrp
->e_ident
[EI_ABIVERSION
] = ARM_ELF_ABI_VERSION
;
3304 #define ELF_ARCH bfd_arch_arm
3305 #define ELF_MACHINE_CODE EM_ARM
3306 #define ELF_MAXPAGESIZE 0x8000
3309 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
3310 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
3311 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
3312 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
3313 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
3314 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
3315 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
3317 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
3318 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
3319 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
3320 #define elf_backend_check_relocs elf32_arm_check_relocs
3321 #define elf_backend_relocate_section elf32_arm_relocate_section
3322 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
3323 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
3324 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
3325 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
3326 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
3327 #define elf_backend_post_process_headers elf32_arm_post_process_headers
3329 #define elf_backend_can_gc_sections 1
3330 #define elf_backend_plt_readonly 1
3331 #define elf_backend_want_got_plt 1
3332 #define elf_backend_want_plt_sym 0
3334 #define elf_backend_got_header_size 12
3335 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
3337 #include "elf32-target.h"