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
;
1645 bfd_signed_vma addend
;
1647 if (howto
->type
== R_ARM_THM_PC22
)
1649 int upper_insn
, lower_insn
;
1652 upper_insn
= bfd_get_16 (abfd
, address
);
1653 lower_insn
= bfd_get_16 (abfd
, address
+ 2);
1654 upper
= upper_insn
& 0x7ff;
1655 lower
= lower_insn
& 0x7ff;
1657 addend
= (upper
<< 12) | (lower
<< 1);
1658 addend
+= increment
;
1661 upper_insn
= (upper_insn
& 0xf800) | ((addend
>> 11) & 0x7ff);
1662 lower_insn
= (lower_insn
& 0xf800) | (addend
& 0x7ff);
1664 bfd_put_16 (abfd
, upper_insn
, address
);
1665 bfd_put_16 (abfd
, lower_insn
, address
+ 2);
1671 contents
= bfd_get_32 (abfd
, address
);
1673 /* Get the (signed) value from the instruction. */
1674 addend
= contents
& howto
->src_mask
;
1675 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1677 bfd_signed_vma mask
;
1680 mask
&= ~ howto
->src_mask
;
1684 /* Add in the increment, (which is a byte value). */
1685 switch (howto
->type
)
1688 addend
+= increment
;
1692 addend
<<= howto
->size
;
1693 addend
+= increment
;
1695 /* Should we check for overflow here ? */
1697 /* Drop any undesired bits. */
1698 addend
>>= howto
->rightshift
;
1702 contents
= (contents
& ~ howto
->dst_mask
) | (addend
& howto
->dst_mask
);
1704 bfd_put_32 (abfd
, contents
, address
);
1707 #endif /* USE_REL */
1709 /* Relocate an ARM ELF section. */
1711 elf32_arm_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1712 contents
, relocs
, local_syms
, local_sections
)
1714 struct bfd_link_info
* info
;
1716 asection
* input_section
;
1717 bfd_byte
* contents
;
1718 Elf_Internal_Rela
* relocs
;
1719 Elf_Internal_Sym
* local_syms
;
1720 asection
** local_sections
;
1722 Elf_Internal_Shdr
* symtab_hdr
;
1723 struct elf_link_hash_entry
** sym_hashes
;
1724 Elf_Internal_Rela
* rel
;
1725 Elf_Internal_Rela
* relend
;
1728 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1729 sym_hashes
= elf_sym_hashes (input_bfd
);
1732 relend
= relocs
+ input_section
->reloc_count
;
1733 for (; rel
< relend
; rel
++)
1736 reloc_howto_type
* howto
;
1737 unsigned long r_symndx
;
1738 Elf_Internal_Sym
* sym
;
1740 struct elf_link_hash_entry
* h
;
1742 bfd_reloc_status_type r
;
1745 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1746 r_type
= ELF32_R_TYPE (rel
->r_info
);
1748 if ( r_type
== R_ARM_GNU_VTENTRY
1749 || r_type
== R_ARM_GNU_VTINHERIT
)
1752 elf32_arm_info_to_howto (input_bfd
, & bfd_reloc
, rel
);
1753 howto
= bfd_reloc
.howto
;
1755 if (info
->relocateable
)
1757 /* This is a relocateable link. We don't have to change
1758 anything, unless the reloc is against a section symbol,
1759 in which case we have to adjust according to where the
1760 section symbol winds up in the output section. */
1761 if (r_symndx
< symtab_hdr
->sh_info
)
1763 sym
= local_syms
+ r_symndx
;
1764 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1766 sec
= local_sections
[r_symndx
];
1768 arm_add_to_rel (input_bfd
, contents
+ rel
->r_offset
,
1769 howto
, sec
->output_offset
+ sym
->st_value
);
1771 rel
->r_addend
+= (sec
->output_offset
+ sym
->st_value
)
1772 >> howto
->rightshift
;
1780 /* This is a final link. */
1785 if (r_symndx
< symtab_hdr
->sh_info
)
1787 sym
= local_syms
+ r_symndx
;
1788 sec
= local_sections
[r_symndx
];
1789 relocation
= (sec
->output_section
->vma
1790 + sec
->output_offset
1795 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1797 while ( h
->root
.type
== bfd_link_hash_indirect
1798 || h
->root
.type
== bfd_link_hash_warning
)
1799 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1801 if ( h
->root
.type
== bfd_link_hash_defined
1802 || h
->root
.type
== bfd_link_hash_defweak
)
1804 int relocation_needed
= 1;
1806 sec
= h
->root
.u
.def
.section
;
1808 /* In these cases, we don't need the relocation value.
1809 We check specially because in some obscure cases
1810 sec->output_section will be NULL. */
1817 (!info
->symbolic
&& h
->dynindx
!= -1)
1818 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1820 && ((input_section
->flags
& SEC_ALLOC
) != 0
1821 /* DWARF will emit R_ARM_ABS32 relocations in its
1822 sections against symbols defined externally
1823 in shared libraries. We can't do anything
1825 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
1826 && (h
->elf_link_hash_flags
1827 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
1829 relocation_needed
= 0;
1833 relocation_needed
= 0;
1837 if (elf_hash_table(info
)->dynamic_sections_created
1839 || (!info
->symbolic
&& h
->dynindx
!= -1)
1840 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1843 relocation_needed
= 0;
1847 if (h
->plt
.offset
!= (bfd_vma
)-1)
1848 relocation_needed
= 0;
1852 if (sec
->output_section
== NULL
)
1854 (*_bfd_error_handler
)
1855 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1856 bfd_get_filename (input_bfd
), h
->root
.root
.string
,
1857 bfd_get_section_name (input_bfd
, input_section
));
1858 relocation_needed
= 0;
1862 if (relocation_needed
)
1863 relocation
= h
->root
.u
.def
.value
1864 + sec
->output_section
->vma
1865 + sec
->output_offset
;
1869 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1871 else if (info
->shared
&& !info
->symbolic
1872 && !info
->no_undefined
1873 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1877 if (!((*info
->callbacks
->undefined_symbol
)
1878 (info
, h
->root
.root
.string
, input_bfd
,
1879 input_section
, rel
->r_offset
,
1880 (!info
->shared
|| info
->no_undefined
1881 || ELF_ST_VISIBILITY (h
->other
)))))
1888 name
= h
->root
.root
.string
;
1891 name
= (bfd_elf_string_from_elf_section
1892 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
1893 if (name
== NULL
|| *name
== '\0')
1894 name
= bfd_section_name (input_bfd
, sec
);
1897 r
= elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
1898 input_section
, contents
, rel
,
1899 relocation
, info
, sec
, name
,
1900 (h
? ELF_ST_TYPE (h
->type
) :
1901 ELF_ST_TYPE (sym
->st_info
)), h
);
1903 if (r
!= bfd_reloc_ok
)
1905 const char * msg
= (const char *) 0;
1909 case bfd_reloc_overflow
:
1910 /* If the overflowing reloc was to an undefined symbol,
1911 we have already printed one error message and there
1912 is no point complaining again. */
1914 h
->root
.type
!= bfd_link_hash_undefined
)
1915 && (!((*info
->callbacks
->reloc_overflow
)
1916 (info
, name
, howto
->name
, (bfd_vma
) 0,
1917 input_bfd
, input_section
, rel
->r_offset
))))
1921 case bfd_reloc_undefined
:
1922 if (!((*info
->callbacks
->undefined_symbol
)
1923 (info
, name
, input_bfd
, input_section
,
1924 rel
->r_offset
, true)))
1928 case bfd_reloc_outofrange
:
1929 msg
= _("internal error: out of range error");
1932 case bfd_reloc_notsupported
:
1933 msg
= _("internal error: unsupported relocation error");
1936 case bfd_reloc_dangerous
:
1937 msg
= _("internal error: dangerous error");
1941 msg
= _("internal error: unknown error");
1945 if (!((*info
->callbacks
->warning
)
1946 (info
, msg
, name
, input_bfd
, input_section
,
1957 /* Function to keep ARM specific flags in the ELF header. */
1959 elf32_arm_set_private_flags (abfd
, flags
)
1963 if (elf_flags_init (abfd
)
1964 && elf_elfheader (abfd
)->e_flags
!= flags
)
1966 if (EF_ARM_EABI_VERSION (flags
) == EF_ARM_EABI_UNKNOWN
)
1968 if (flags
& EF_INTERWORK
)
1969 _bfd_error_handler (_("\
1970 Warning: Not setting interwork flag of %s since it has already been specified as non-interworking"),
1971 bfd_get_filename (abfd
));
1973 _bfd_error_handler (_("\
1974 Warning: Clearing the interwork flag of %s due to outside request"),
1975 bfd_get_filename (abfd
));
1980 elf_elfheader (abfd
)->e_flags
= flags
;
1981 elf_flags_init (abfd
) = true;
1987 /* Copy backend specific data from one object module to another. */
1990 elf32_arm_copy_private_bfd_data (ibfd
, obfd
)
1997 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1998 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2001 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2002 out_flags
= elf_elfheader (obfd
)->e_flags
;
2004 if (elf_flags_init (obfd
)
2005 && EF_ARM_EABI_VERSION (out_flags
) == EF_ARM_EABI_UNKNOWN
2006 && in_flags
!= out_flags
)
2008 /* Cannot mix APCS26 and APCS32 code. */
2009 if ((in_flags
& EF_APCS_26
) != (out_flags
& EF_APCS_26
))
2012 /* Cannot mix float APCS and non-float APCS code. */
2013 if ((in_flags
& EF_APCS_FLOAT
) != (out_flags
& EF_APCS_FLOAT
))
2016 /* If the src and dest have different interworking flags
2017 then turn off the interworking bit. */
2018 if ((in_flags
& EF_INTERWORK
) != (out_flags
& EF_INTERWORK
))
2020 if (out_flags
& EF_INTERWORK
)
2021 _bfd_error_handler (_("\
2022 Warning: Clearing the interwork flag in %s because non-interworking code in %s has been linked with it"),
2023 bfd_get_filename (obfd
), bfd_get_filename (ibfd
));
2025 in_flags
&= ~EF_INTERWORK
;
2028 /* Likewise for PIC, though don't warn for this case. */
2029 if ((in_flags
& EF_PIC
) != (out_flags
& EF_PIC
))
2030 in_flags
&= ~EF_PIC
;
2033 elf_elfheader (obfd
)->e_flags
= in_flags
;
2034 elf_flags_init (obfd
) = true;
2039 /* Merge backend specific data from an object file to the output
2040 object file when linking. */
2043 elf32_arm_merge_private_bfd_data (ibfd
, obfd
)
2049 boolean flags_compatible
= true;
2050 boolean null_input_bfd
= true;
2053 /* Check if we have the same endianess. */
2054 if (_bfd_generic_verify_endian_match (ibfd
, obfd
) == false)
2057 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2058 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2061 /* The input BFD must have had its flags initialised. */
2062 /* The following seems bogus to me -- The flags are initialized in
2063 the assembler but I don't think an elf_flags_init field is
2064 written into the object. */
2065 /* BFD_ASSERT (elf_flags_init (ibfd)); */
2067 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2068 out_flags
= elf_elfheader (obfd
)->e_flags
;
2070 if (!elf_flags_init (obfd
))
2072 /* If the input is the default architecture and had the default
2073 flags then do not bother setting the flags for the output
2074 architecture, instead allow future merges to do this. If no
2075 future merges ever set these flags then they will retain their
2076 uninitialised values, which surprise surprise, correspond
2077 to the default values. */
2078 if (bfd_get_arch_info (ibfd
)->the_default
2079 && elf_elfheader (ibfd
)->e_flags
== 0)
2082 elf_flags_init (obfd
) = true;
2083 elf_elfheader (obfd
)->e_flags
= in_flags
;
2085 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
2086 && bfd_get_arch_info (obfd
)->the_default
)
2087 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
), bfd_get_mach (ibfd
));
2092 /* Identical flags must be compatible. */
2093 if (in_flags
== out_flags
)
2096 /* Check to see if the input BFD actually contains any sections.
2097 If not, its flags may not have been initialised either, but it cannot
2098 actually cause any incompatibility. */
2099 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2101 /* Ignore synthetic glue sections. */
2102 if (strcmp (sec
->name
, ".glue_7")
2103 && strcmp (sec
->name
, ".glue_7t"))
2105 null_input_bfd
= false;
2112 /* Complain about various flag mismatches. */
2113 if (EF_ARM_EABI_VERSION (in_flags
) != EF_ARM_EABI_VERSION (out_flags
))
2115 _bfd_error_handler (_("\
2116 Error: %s compiled for EABI version %d, whereas %s is compiled for version %d"),
2117 bfd_get_filename (ibfd
),
2118 (in_flags
& EF_ARM_EABIMASK
) >> 24,
2119 bfd_get_filename (obfd
),
2120 (out_flags
& EF_ARM_EABIMASK
) >> 24);
2124 /* Not sure what needs to be checked for EABI versions >= 1. */
2125 if (EF_ARM_EABI_VERSION (in_flags
) == EF_ARM_EABI_UNKNOWN
)
2127 if ((in_flags
& EF_APCS_26
) != (out_flags
& EF_APCS_26
))
2129 _bfd_error_handler (_("\
2130 Error: %s compiled for APCS-%d, whereas %s is compiled for APCS-%d"),
2131 bfd_get_filename (ibfd
),
2132 in_flags
& EF_APCS_26
? 26 : 32,
2133 bfd_get_filename (obfd
),
2134 out_flags
& EF_APCS_26
? 26 : 32);
2135 flags_compatible
= false;
2138 if ((in_flags
& EF_APCS_FLOAT
) != (out_flags
& EF_APCS_FLOAT
))
2140 _bfd_error_handler (_("\
2141 Error: %s passes floats in %s registers, whereas %s passes them in %s registers"),
2142 bfd_get_filename (ibfd
),
2143 in_flags
& EF_APCS_FLOAT
? _("float") : _("integer"),
2144 bfd_get_filename (obfd
),
2145 out_flags
& EF_APCS_26
? _("float") : _("integer"));
2146 flags_compatible
= false;
2149 #ifdef EF_SOFT_FLOAT
2150 if ((in_flags
& EF_SOFT_FLOAT
) != (out_flags
& EF_SOFT_FLOAT
))
2152 _bfd_error_handler (_ ("\
2153 Error: %s uses %s floating point, whereas %s uses %s floating point"),
2154 bfd_get_filename (ibfd
),
2155 in_flags
& EF_SOFT_FLOAT
? _("soft") : _("hard"),
2156 bfd_get_filename (obfd
),
2157 out_flags
& EF_SOFT_FLOAT
? _("soft") : _("hard"));
2158 flags_compatible
= false;
2162 /* Interworking mismatch is only a warning. */
2163 if ((in_flags
& EF_INTERWORK
) != (out_flags
& EF_INTERWORK
))
2164 _bfd_error_handler (_("\
2165 Warning: %s %s interworking, whereas %s %s"),
2166 bfd_get_filename (ibfd
),
2167 in_flags
& EF_INTERWORK
? _("supports") : _("does not support"),
2168 bfd_get_filename (obfd
),
2169 out_flags
& EF_INTERWORK
? _("does not") : _("does"));
2172 return flags_compatible
;
2175 /* Display the flags field. */
2178 elf32_arm_print_private_bfd_data (abfd
, ptr
)
2182 FILE * file
= (FILE *) ptr
;
2183 unsigned long flags
;
2185 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
2187 /* Print normal ELF private data. */
2188 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
2190 flags
= elf_elfheader (abfd
)->e_flags
;
2191 /* Ignore init flag - it may not be set, despite the flags field
2192 containing valid data. */
2194 /* xgettext:c-format */
2195 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
2197 switch (EF_ARM_EABI_VERSION (flags
))
2199 case EF_ARM_EABI_UNKNOWN
:
2200 /* The following flag bits are GNU extenstions and not part of the
2201 official ARM ELF extended ABI. Hence they are only decoded if
2202 the EABI version is not set. */
2203 if (flags
& EF_INTERWORK
)
2204 fprintf (file
, _(" [interworking enabled]"));
2206 if (flags
& EF_APCS_26
)
2207 fprintf (file
, _(" [APCS-26]"));
2209 fprintf (file
, _(" [APCS-32]"));
2211 if (flags
& EF_APCS_FLOAT
)
2212 fprintf (file
, _(" [floats passed in float registers]"));
2215 fprintf (file
, _(" [position independent]"));
2217 if (flags
& EF_NEW_ABI
)
2218 fprintf (file
, _(" [new ABI]"));
2220 if (flags
& EF_OLD_ABI
)
2221 fprintf (file
, _(" [old ABI]"));
2223 if (flags
& EF_SOFT_FLOAT
)
2224 fprintf (file
, _(" [software FP]"));
2226 flags
&= ~(EF_INTERWORK
| EF_APCS_26
| EF_APCS_FLOAT
| EF_PIC
2227 | EF_NEW_ABI
| EF_OLD_ABI
| EF_SOFT_FLOAT
);
2230 case EF_ARM_EABI_VER1
:
2231 fprintf (file
, _(" [Version1 EABI]"));
2233 if (flags
& EF_ARM_SYMSARESORTED
)
2234 fprintf (file
, _(" [sorted symbol table]"));
2236 fprintf (file
, _(" [unsorted symbol table]"));
2238 flags
&= ~ EF_ARM_SYMSARESORTED
;
2242 fprintf (file
, _(" <EABI version unrecognised>"));
2246 flags
&= ~ EF_ARM_EABIMASK
;
2248 if (flags
& EF_ARM_RELEXEC
)
2249 fprintf (file
, _(" [relocatable executable]"));
2251 if (flags
& EF_ARM_HASENTRY
)
2252 fprintf (file
, _(" [has entry point]"));
2254 flags
&= ~ (EF_ARM_RELEXEC
| EF_ARM_HASENTRY
);
2257 fprintf (file
, _("<Unrecognised flag bits set>"));
2265 elf32_arm_get_symbol_type (elf_sym
, type
)
2266 Elf_Internal_Sym
* elf_sym
;
2269 switch (ELF_ST_TYPE (elf_sym
->st_info
))
2272 return ELF_ST_TYPE (elf_sym
->st_info
);
2275 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2276 This allows us to distinguish between data used by Thumb instructions
2277 and non-data (which is probably code) inside Thumb regions of an
2279 if (type
!= STT_OBJECT
)
2280 return ELF_ST_TYPE (elf_sym
->st_info
);
2291 elf32_arm_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
2293 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2294 Elf_Internal_Rela
*rel
;
2295 struct elf_link_hash_entry
*h
;
2296 Elf_Internal_Sym
*sym
;
2300 switch (ELF32_R_TYPE (rel
->r_info
))
2302 case R_ARM_GNU_VTINHERIT
:
2303 case R_ARM_GNU_VTENTRY
:
2307 switch (h
->root
.type
)
2309 case bfd_link_hash_defined
:
2310 case bfd_link_hash_defweak
:
2311 return h
->root
.u
.def
.section
;
2313 case bfd_link_hash_common
:
2314 return h
->root
.u
.c
.p
->section
;
2323 if (!(elf_bad_symtab (abfd
)
2324 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
2325 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
2326 && sym
->st_shndx
!= SHN_COMMON
))
2328 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
2334 /* Update the got entry reference counts for the section being removed. */
2337 elf32_arm_gc_sweep_hook (abfd
, info
, sec
, relocs
)
2338 bfd
*abfd ATTRIBUTE_UNUSED
;
2339 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2340 asection
*sec ATTRIBUTE_UNUSED
;
2341 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
;
2343 /* We don't support garbage collection of GOT and PLT relocs yet. */
2347 /* Look through the relocs for a section during the first phase. */
2350 elf32_arm_check_relocs (abfd
, info
, sec
, relocs
)
2352 struct bfd_link_info
* info
;
2354 const Elf_Internal_Rela
* relocs
;
2356 Elf_Internal_Shdr
* symtab_hdr
;
2357 struct elf_link_hash_entry
** sym_hashes
;
2358 struct elf_link_hash_entry
** sym_hashes_end
;
2359 const Elf_Internal_Rela
* rel
;
2360 const Elf_Internal_Rela
* rel_end
;
2362 asection
* sgot
, *srelgot
, *sreloc
;
2363 bfd_vma
* local_got_offsets
;
2365 if (info
->relocateable
)
2368 sgot
= srelgot
= sreloc
= NULL
;
2370 dynobj
= elf_hash_table (info
)->dynobj
;
2371 local_got_offsets
= elf_local_got_offsets (abfd
);
2373 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2374 sym_hashes
= elf_sym_hashes (abfd
);
2375 sym_hashes_end
= sym_hashes
2376 + symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
2378 if (!elf_bad_symtab (abfd
))
2379 sym_hashes_end
-= symtab_hdr
->sh_info
;
2381 rel_end
= relocs
+ sec
->reloc_count
;
2382 for (rel
= relocs
; rel
< rel_end
; rel
++)
2384 struct elf_link_hash_entry
*h
;
2385 unsigned long r_symndx
;
2387 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2388 if (r_symndx
< symtab_hdr
->sh_info
)
2391 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2393 /* Some relocs require a global offset table. */
2396 switch (ELF32_R_TYPE (rel
->r_info
))
2401 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
2402 if (! _bfd_elf_create_got_section (dynobj
, info
))
2411 switch (ELF32_R_TYPE (rel
->r_info
))
2414 /* This symbol requires a global offset table entry. */
2417 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2418 BFD_ASSERT (sgot
!= NULL
);
2421 /* Get the got relocation section if necessary. */
2423 && (h
!= NULL
|| info
->shared
))
2425 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
2427 /* If no got relocation section, make one and initialize. */
2428 if (srelgot
== NULL
)
2430 srelgot
= bfd_make_section (dynobj
, ".rel.got");
2432 || ! bfd_set_section_flags (dynobj
, srelgot
,
2437 | SEC_LINKER_CREATED
2439 || ! bfd_set_section_alignment (dynobj
, srelgot
, 2))
2446 if (h
->got
.offset
!= (bfd_vma
) -1)
2447 /* We have already allocated space in the .got. */
2450 h
->got
.offset
= sgot
->_raw_size
;
2452 /* Make sure this symbol is output as a dynamic symbol. */
2453 if (h
->dynindx
== -1)
2454 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2457 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2461 /* This is a global offset table entry for a local
2463 if (local_got_offsets
== NULL
)
2466 register unsigned int i
;
2468 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
2469 local_got_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
2470 if (local_got_offsets
== NULL
)
2472 elf_local_got_offsets (abfd
) = local_got_offsets
;
2473 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
2474 local_got_offsets
[i
] = (bfd_vma
) -1;
2477 if (local_got_offsets
[r_symndx
] != (bfd_vma
) -1)
2478 /* We have already allocated space in the .got. */
2481 local_got_offsets
[r_symndx
] = sgot
->_raw_size
;
2484 /* If we are generating a shared object, we need to
2485 output a R_ARM_RELATIVE reloc so that the dynamic
2486 linker can adjust this GOT entry. */
2487 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2490 sgot
->_raw_size
+= 4;
2494 /* This symbol requires a procedure linkage table entry. We
2495 actually build the entry in adjust_dynamic_symbol,
2496 because this might be a case of linking PIC code which is
2497 never referenced by a dynamic object, in which case we
2498 don't need to generate a procedure linkage table entry
2501 /* If this is a local symbol, we resolve it directly without
2502 creating a procedure linkage table entry. */
2506 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2512 /* If we are creating a shared library, and this is a reloc
2513 against a global symbol, or a non PC relative reloc
2514 against a local symbol, then we need to copy the reloc
2515 into the shared library. However, if we are linking with
2516 -Bsymbolic, we do not need to copy a reloc against a
2517 global symbol which is defined in an object we are
2518 including in the link (i.e., DEF_REGULAR is set). At
2519 this point we have not seen all the input files, so it is
2520 possible that DEF_REGULAR is not set now but will be set
2521 later (it is never cleared). We account for that
2522 possibility below by storing information in the
2523 pcrel_relocs_copied field of the hash table entry. */
2525 && (ELF32_R_TYPE (rel
->r_info
) != R_ARM_PC24
2527 && (! info
->symbolic
2528 || (h
->elf_link_hash_flags
2529 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
2531 /* When creating a shared object, we must copy these
2532 reloc types into the output file. We create a reloc
2533 section in dynobj and make room for this reloc. */
2538 name
= (bfd_elf_string_from_elf_section
2540 elf_elfheader (abfd
)->e_shstrndx
,
2541 elf_section_data (sec
)->rel_hdr
.sh_name
));
2545 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
2546 && strcmp (bfd_get_section_name (abfd
, sec
),
2549 sreloc
= bfd_get_section_by_name (dynobj
, name
);
2554 sreloc
= bfd_make_section (dynobj
, name
);
2555 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
2556 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
2557 if ((sec
->flags
& SEC_ALLOC
) != 0)
2558 flags
|= SEC_ALLOC
| SEC_LOAD
;
2560 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
2561 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
2566 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
2567 /* If we are linking with -Bsymbolic, and this is a
2568 global symbol, we count the number of PC relative
2569 relocations we have entered for this symbol, so that
2570 we can discard them again if the symbol is later
2571 defined by a regular object. Note that this function
2572 is only called if we are using an elf_i386 linker
2573 hash table, which means that h is really a pointer to
2574 an elf_i386_link_hash_entry. */
2575 if (h
!= NULL
&& info
->symbolic
2576 && ELF32_R_TYPE (rel
->r_info
) == R_ARM_PC24
)
2578 struct elf32_arm_link_hash_entry
* eh
;
2579 struct elf32_arm_pcrel_relocs_copied
* p
;
2581 eh
= (struct elf32_arm_link_hash_entry
*) h
;
2583 for (p
= eh
->pcrel_relocs_copied
; p
!= NULL
; p
= p
->next
)
2584 if (p
->section
== sreloc
)
2589 p
= ((struct elf32_arm_pcrel_relocs_copied
*)
2590 bfd_alloc (dynobj
, sizeof * p
));
2594 p
->next
= eh
->pcrel_relocs_copied
;
2595 eh
->pcrel_relocs_copied
= p
;
2596 p
->section
= sreloc
;
2605 /* This relocation describes the C++ object vtable hierarchy.
2606 Reconstruct it for later use during GC. */
2607 case R_ARM_GNU_VTINHERIT
:
2608 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2612 /* This relocation describes which C++ vtable entries are actually
2613 used. Record for later use during GC. */
2614 case R_ARM_GNU_VTENTRY
:
2615 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
2625 /* Find the nearest line to a particular section and offset, for error
2626 reporting. This code is a duplicate of the code in elf.c, except
2627 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
2630 elf32_arm_find_nearest_line
2631 (abfd
, section
, symbols
, offset
, filename_ptr
, functionname_ptr
, line_ptr
)
2636 CONST
char ** filename_ptr
;
2637 CONST
char ** functionname_ptr
;
2638 unsigned int * line_ptr
;
2641 const char * filename
;
2646 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
2647 filename_ptr
, functionname_ptr
,
2651 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2652 &found
, filename_ptr
,
2653 functionname_ptr
, line_ptr
,
2654 &elf_tdata (abfd
)->line_info
))
2660 if (symbols
== NULL
)
2667 for (p
= symbols
; *p
!= NULL
; p
++)
2671 q
= (elf_symbol_type
*) *p
;
2673 if (bfd_get_section (&q
->symbol
) != section
)
2676 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
2681 filename
= bfd_asymbol_name (&q
->symbol
);
2686 if (q
->symbol
.section
== section
2687 && q
->symbol
.value
>= low_func
2688 && q
->symbol
.value
<= offset
)
2690 func
= (asymbol
*) q
;
2691 low_func
= q
->symbol
.value
;
2700 *filename_ptr
= filename
;
2701 *functionname_ptr
= bfd_asymbol_name (func
);
2707 /* Adjust a symbol defined by a dynamic object and referenced by a
2708 regular object. The current definition is in some section of the
2709 dynamic object, but we're not including those sections. We have to
2710 change the definition to something the rest of the link can
2714 elf32_arm_adjust_dynamic_symbol (info
, h
)
2715 struct bfd_link_info
* info
;
2716 struct elf_link_hash_entry
* h
;
2720 unsigned int power_of_two
;
2722 dynobj
= elf_hash_table (info
)->dynobj
;
2724 /* Make sure we know what is going on here. */
2725 BFD_ASSERT (dynobj
!= NULL
2726 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
2727 || h
->weakdef
!= NULL
2728 || ((h
->elf_link_hash_flags
2729 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2730 && (h
->elf_link_hash_flags
2731 & ELF_LINK_HASH_REF_REGULAR
) != 0
2732 && (h
->elf_link_hash_flags
2733 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
2735 /* If this is a function, put it in the procedure linkage table. We
2736 will fill in the contents of the procedure linkage table later,
2737 when we know the address of the .got section. */
2738 if (h
->type
== STT_FUNC
2739 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
2742 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
2743 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0)
2745 /* This case can occur if we saw a PLT32 reloc in an input
2746 file, but the symbol was never referred to by a dynamic
2747 object. In such a case, we don't actually need to build
2748 a procedure linkage table, and we can just do a PC32
2750 BFD_ASSERT ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0);
2754 /* Make sure this symbol is output as a dynamic symbol. */
2755 if (h
->dynindx
== -1)
2757 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2761 s
= bfd_get_section_by_name (dynobj
, ".plt");
2762 BFD_ASSERT (s
!= NULL
);
2764 /* If this is the first .plt entry, make room for the special
2766 if (s
->_raw_size
== 0)
2767 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2769 /* If this symbol is not defined in a regular file, and we are
2770 not generating a shared library, then set the symbol to this
2771 location in the .plt. This is required to make function
2772 pointers compare as equal between the normal executable and
2773 the shared library. */
2775 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2777 h
->root
.u
.def
.section
= s
;
2778 h
->root
.u
.def
.value
= s
->_raw_size
;
2781 h
->plt
.offset
= s
->_raw_size
;
2783 /* Make room for this entry. */
2784 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2786 /* We also need to make an entry in the .got.plt section, which
2787 will be placed in the .got section by the linker script. */
2788 s
= bfd_get_section_by_name (dynobj
, ".got.plt");
2789 BFD_ASSERT (s
!= NULL
);
2792 /* We also need to make an entry in the .rel.plt section. */
2794 s
= bfd_get_section_by_name (dynobj
, ".rel.plt");
2795 BFD_ASSERT (s
!= NULL
);
2796 s
->_raw_size
+= sizeof (Elf32_External_Rel
);
2801 /* If this is a weak symbol, and there is a real definition, the
2802 processor independent code will have arranged for us to see the
2803 real definition first, and we can just use the same value. */
2804 if (h
->weakdef
!= NULL
)
2806 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
2807 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
2808 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
2809 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
2813 /* This is a reference to a symbol defined by a dynamic object which
2814 is not a function. */
2816 /* If we are creating a shared library, we must presume that the
2817 only references to the symbol are via the global offset table.
2818 For such cases we need not do anything here; the relocations will
2819 be handled correctly by relocate_section. */
2823 /* We must allocate the symbol in our .dynbss section, which will
2824 become part of the .bss section of the executable. There will be
2825 an entry for this symbol in the .dynsym section. The dynamic
2826 object will contain position independent code, so all references
2827 from the dynamic object to this symbol will go through the global
2828 offset table. The dynamic linker will use the .dynsym entry to
2829 determine the address it must put in the global offset table, so
2830 both the dynamic object and the regular object will refer to the
2831 same memory location for the variable. */
2832 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
2833 BFD_ASSERT (s
!= NULL
);
2835 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
2836 copy the initial value out of the dynamic object and into the
2837 runtime process image. We need to remember the offset into the
2838 .rel.bss section we are going to use. */
2839 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2843 srel
= bfd_get_section_by_name (dynobj
, ".rel.bss");
2844 BFD_ASSERT (srel
!= NULL
);
2845 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
2846 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
2849 /* We need to figure out the alignment required for this symbol. I
2850 have no idea how ELF linkers handle this. */
2851 power_of_two
= bfd_log2 (h
->size
);
2852 if (power_of_two
> 3)
2855 /* Apply the required alignment. */
2856 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
2857 (bfd_size_type
) (1 << power_of_two
));
2858 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
2860 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
2864 /* Define the symbol as being at this point in the section. */
2865 h
->root
.u
.def
.section
= s
;
2866 h
->root
.u
.def
.value
= s
->_raw_size
;
2868 /* Increment the section size to make room for the symbol. */
2869 s
->_raw_size
+= h
->size
;
2874 /* Set the sizes of the dynamic sections. */
2877 elf32_arm_size_dynamic_sections (output_bfd
, info
)
2879 struct bfd_link_info
* info
;
2887 dynobj
= elf_hash_table (info
)->dynobj
;
2888 BFD_ASSERT (dynobj
!= NULL
);
2890 if (elf_hash_table (info
)->dynamic_sections_created
)
2892 /* Set the contents of the .interp section to the interpreter. */
2895 s
= bfd_get_section_by_name (dynobj
, ".interp");
2896 BFD_ASSERT (s
!= NULL
);
2897 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2898 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2903 /* We may have created entries in the .rel.got section.
2904 However, if we are not creating the dynamic sections, we will
2905 not actually use these entries. Reset the size of .rel.got,
2906 which will cause it to get stripped from the output file
2908 s
= bfd_get_section_by_name (dynobj
, ".rel.got");
2913 /* If this is a -Bsymbolic shared link, then we need to discard all
2914 PC relative relocs against symbols defined in a regular object.
2915 We allocated space for them in the check_relocs routine, but we
2916 will not fill them in in the relocate_section routine. */
2917 if (info
->shared
&& info
->symbolic
)
2918 elf32_arm_link_hash_traverse (elf32_arm_hash_table (info
),
2919 elf32_arm_discard_copies
,
2922 /* The check_relocs and adjust_dynamic_symbol entry points have
2923 determined the sizes of the various dynamic sections. Allocate
2928 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2933 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2936 /* It's OK to base decisions on the section name, because none
2937 of the dynobj section names depend upon the input files. */
2938 name
= bfd_get_section_name (dynobj
, s
);
2942 if (strcmp (name
, ".plt") == 0)
2944 if (s
->_raw_size
== 0)
2946 /* Strip this section if we don't need it; see the
2952 /* Remember whether there is a PLT. */
2956 else if (strncmp (name
, ".rel", 4) == 0)
2958 if (s
->_raw_size
== 0)
2960 /* If we don't need this section, strip it from the
2961 output file. This is mostly to handle .rel.bss and
2962 .rel.plt. We must create both sections in
2963 create_dynamic_sections, because they must be created
2964 before the linker maps input sections to output
2965 sections. The linker does that before
2966 adjust_dynamic_symbol is called, and it is that
2967 function which decides whether anything needs to go
2968 into these sections. */
2975 /* Remember whether there are any reloc sections other
2977 if (strcmp (name
, ".rel.plt") != 0)
2979 const char *outname
;
2983 /* If this relocation section applies to a read only
2984 section, then we probably need a DT_TEXTREL
2985 entry. The entries in the .rel.plt section
2986 really apply to the .got section, which we
2987 created ourselves and so know is not readonly. */
2988 outname
= bfd_get_section_name (output_bfd
,
2990 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
2993 && (target
->flags
& SEC_READONLY
) != 0
2994 && (target
->flags
& SEC_ALLOC
) != 0)
2998 /* We use the reloc_count field as a counter if we need
2999 to copy relocs into the output file. */
3003 else if (strncmp (name
, ".got", 4) != 0)
3005 /* It's not one of our sections, so don't allocate space. */
3013 for (spp
= &s
->output_section
->owner
->sections
;
3014 *spp
!= s
->output_section
;
3015 spp
= &(*spp
)->next
)
3017 *spp
= s
->output_section
->next
;
3018 --s
->output_section
->owner
->section_count
;
3023 /* Allocate memory for the section contents. */
3024 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
3025 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
3029 if (elf_hash_table (info
)->dynamic_sections_created
)
3031 /* Add some entries to the .dynamic section. We fill in the
3032 values later, in elf32_arm_finish_dynamic_sections, but we
3033 must add the entries now so that we get the correct size for
3034 the .dynamic section. The DT_DEBUG entry is filled in by the
3035 dynamic linker and used by the debugger. */
3038 if (! bfd_elf32_add_dynamic_entry (info
, DT_DEBUG
, 0))
3044 if ( ! bfd_elf32_add_dynamic_entry (info
, DT_PLTGOT
, 0)
3045 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
3046 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTREL
, DT_REL
)
3047 || ! bfd_elf32_add_dynamic_entry (info
, DT_JMPREL
, 0))
3053 if ( ! bfd_elf32_add_dynamic_entry (info
, DT_REL
, 0)
3054 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELSZ
, 0)
3055 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELENT
,
3056 sizeof (Elf32_External_Rel
)))
3062 if (! bfd_elf32_add_dynamic_entry (info
, DT_TEXTREL
, 0))
3064 info
->flags
|= DF_TEXTREL
;
3071 /* This function is called via elf32_arm_link_hash_traverse if we are
3072 creating a shared object with -Bsymbolic. It discards the space
3073 allocated to copy PC relative relocs against symbols which are
3074 defined in regular objects. We allocated space for them in the
3075 check_relocs routine, but we won't fill them in in the
3076 relocate_section routine. */
3079 elf32_arm_discard_copies (h
, ignore
)
3080 struct elf32_arm_link_hash_entry
* h
;
3081 PTR ignore ATTRIBUTE_UNUSED
;
3083 struct elf32_arm_pcrel_relocs_copied
* s
;
3085 /* We only discard relocs for symbols defined in a regular object. */
3086 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3089 for (s
= h
->pcrel_relocs_copied
; s
!= NULL
; s
= s
->next
)
3090 s
->section
->_raw_size
-= s
->count
* sizeof (Elf32_External_Rel
);
3095 /* Finish up dynamic symbol handling. We set the contents of various
3096 dynamic sections here. */
3099 elf32_arm_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
3101 struct bfd_link_info
* info
;
3102 struct elf_link_hash_entry
* h
;
3103 Elf_Internal_Sym
* sym
;
3107 dynobj
= elf_hash_table (info
)->dynobj
;
3109 if (h
->plt
.offset
!= (bfd_vma
) -1)
3116 Elf_Internal_Rel rel
;
3118 /* This symbol has an entry in the procedure linkage table. Set
3121 BFD_ASSERT (h
->dynindx
!= -1);
3123 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3124 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3125 srel
= bfd_get_section_by_name (dynobj
, ".rel.plt");
3126 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
3128 /* Get the index in the procedure linkage table which
3129 corresponds to this symbol. This is the index of this symbol
3130 in all the symbols for which we are making plt entries. The
3131 first entry in the procedure linkage table is reserved. */
3132 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
3134 /* Get the offset into the .got table of the entry that
3135 corresponds to this function. Each .got entry is 4 bytes.
3136 The first three are reserved. */
3137 got_offset
= (plt_index
+ 3) * 4;
3139 /* Fill in the entry in the procedure linkage table. */
3140 memcpy (splt
->contents
+ h
->plt
.offset
,
3141 elf32_arm_plt_entry
,
3143 bfd_put_32 (output_bfd
,
3144 (sgot
->output_section
->vma
3145 + sgot
->output_offset
3147 - splt
->output_section
->vma
3148 - splt
->output_offset
3149 - h
->plt
.offset
- 12),
3150 splt
->contents
+ h
->plt
.offset
+ 12);
3152 /* Fill in the entry in the global offset table. */
3153 bfd_put_32 (output_bfd
,
3154 (splt
->output_section
->vma
3155 + splt
->output_offset
),
3156 sgot
->contents
+ got_offset
);
3158 /* Fill in the entry in the .rel.plt section. */
3159 rel
.r_offset
= (sgot
->output_section
->vma
3160 + sgot
->output_offset
3162 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_JUMP_SLOT
);
3163 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3164 ((Elf32_External_Rel
*) srel
->contents
3167 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3169 /* Mark the symbol as undefined, rather than as defined in
3170 the .plt section. Leave the value alone. */
3171 sym
->st_shndx
= SHN_UNDEF
;
3175 if (h
->got
.offset
!= (bfd_vma
) -1)
3179 Elf_Internal_Rel rel
;
3181 /* This symbol has an entry in the global offset table. Set it
3183 sgot
= bfd_get_section_by_name (dynobj
, ".got");
3184 srel
= bfd_get_section_by_name (dynobj
, ".rel.got");
3185 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
3187 rel
.r_offset
= (sgot
->output_section
->vma
3188 + sgot
->output_offset
3189 + (h
->got
.offset
&~ 1));
3191 /* If this is a -Bsymbolic link, and the symbol is defined
3192 locally, we just want to emit a RELATIVE reloc. The entry in
3193 the global offset table will already have been initialized in
3194 the relocate_section function. */
3196 && (info
->symbolic
|| h
->dynindx
== -1)
3197 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
3198 rel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
3201 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
3202 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_GLOB_DAT
);
3205 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3206 ((Elf32_External_Rel
*) srel
->contents
3207 + srel
->reloc_count
));
3208 ++srel
->reloc_count
;
3211 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
3214 Elf_Internal_Rel rel
;
3216 /* This symbol needs a copy reloc. Set it up. */
3217 BFD_ASSERT (h
->dynindx
!= -1
3218 && (h
->root
.type
== bfd_link_hash_defined
3219 || h
->root
.type
== bfd_link_hash_defweak
));
3221 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
3223 BFD_ASSERT (s
!= NULL
);
3225 rel
.r_offset
= (h
->root
.u
.def
.value
3226 + h
->root
.u
.def
.section
->output_section
->vma
3227 + h
->root
.u
.def
.section
->output_offset
);
3228 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_COPY
);
3229 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3230 ((Elf32_External_Rel
*) s
->contents
3235 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3236 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3237 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
3238 sym
->st_shndx
= SHN_ABS
;
3243 /* Finish up the dynamic sections. */
3246 elf32_arm_finish_dynamic_sections (output_bfd
, info
)
3248 struct bfd_link_info
* info
;
3254 dynobj
= elf_hash_table (info
)->dynobj
;
3256 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3257 BFD_ASSERT (sgot
!= NULL
);
3258 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3260 if (elf_hash_table (info
)->dynamic_sections_created
)
3263 Elf32_External_Dyn
*dyncon
, *dynconend
;
3265 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3266 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3268 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3269 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
3271 for (; dyncon
< dynconend
; dyncon
++)
3273 Elf_Internal_Dyn dyn
;
3277 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3290 s
= bfd_get_section_by_name (output_bfd
, name
);
3291 BFD_ASSERT (s
!= NULL
);
3292 dyn
.d_un
.d_ptr
= s
->vma
;
3293 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3297 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3298 BFD_ASSERT (s
!= NULL
);
3299 if (s
->_cooked_size
!= 0)
3300 dyn
.d_un
.d_val
= s
->_cooked_size
;
3302 dyn
.d_un
.d_val
= s
->_raw_size
;
3303 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3307 /* My reading of the SVR4 ABI indicates that the
3308 procedure linkage table relocs (DT_JMPREL) should be
3309 included in the overall relocs (DT_REL). This is
3310 what Solaris does. However, UnixWare can not handle
3311 that case. Therefore, we override the DT_RELSZ entry
3312 here to make it not include the JMPREL relocs. Since
3313 the linker script arranges for .rel.plt to follow all
3314 other relocation sections, we don't have to worry
3315 about changing the DT_REL entry. */
3316 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3319 if (s
->_cooked_size
!= 0)
3320 dyn
.d_un
.d_val
-= s
->_cooked_size
;
3322 dyn
.d_un
.d_val
-= s
->_raw_size
;
3324 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3329 /* Fill in the first entry in the procedure linkage table. */
3330 if (splt
->_raw_size
> 0)
3331 memcpy (splt
->contents
, elf32_arm_plt0_entry
, PLT_ENTRY_SIZE
);
3333 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3334 really seem like the right value. */
3335 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
3338 /* Fill in the first three entries in the global offset table. */
3339 if (sgot
->_raw_size
> 0)
3342 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
3344 bfd_put_32 (output_bfd
,
3345 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3347 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
3348 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
3351 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
3357 elf32_arm_post_process_headers (abfd
, link_info
)
3359 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
;
3361 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
3363 i_ehdrp
= elf_elfheader (abfd
);
3365 i_ehdrp
->e_ident
[EI_OSABI
] = ARM_ELF_OS_ABI_VERSION
;
3366 i_ehdrp
->e_ident
[EI_ABIVERSION
] = ARM_ELF_ABI_VERSION
;
3370 #define ELF_ARCH bfd_arch_arm
3371 #define ELF_MACHINE_CODE EM_ARM
3372 #define ELF_MAXPAGESIZE 0x8000
3375 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
3376 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
3377 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
3378 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
3379 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
3380 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
3381 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
3383 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
3384 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
3385 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
3386 #define elf_backend_check_relocs elf32_arm_check_relocs
3387 #define elf_backend_relocate_section elf32_arm_relocate_section
3388 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
3389 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
3390 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
3391 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
3392 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
3393 #define elf_backend_post_process_headers elf32_arm_post_process_headers
3395 #define elf_backend_can_gc_sections 1
3396 #define elf_backend_plt_readonly 1
3397 #define elf_backend_want_got_plt 1
3398 #define elf_backend_want_plt_sym 0
3400 #define elf_backend_got_header_size 12
3401 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
3403 #include "elf32-target.h"