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
1798 /* DWARF will emit R_ARM_ABS32 relocations in its
1799 sections against symbols defined externally
1800 in shared libraries. We can't do anything
1802 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
1803 && (h
->elf_link_hash_flags
1804 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
1806 relocation_needed
= 0;
1810 relocation_needed
= 0;
1814 if (elf_hash_table(info
)->dynamic_sections_created
1816 || (!info
->symbolic
&& h
->dynindx
!= -1)
1817 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1820 relocation_needed
= 0;
1824 if (h
->plt
.offset
!= (bfd_vma
)-1)
1825 relocation_needed
= 0;
1829 if (sec
->output_section
== NULL
)
1831 (*_bfd_error_handler
)
1832 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1833 bfd_get_filename (input_bfd
), h
->root
.root
.string
,
1834 bfd_get_section_name (input_bfd
, input_section
));
1835 relocation_needed
= 0;
1839 if (relocation_needed
)
1840 relocation
= h
->root
.u
.def
.value
1841 + sec
->output_section
->vma
1842 + sec
->output_offset
;
1846 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1848 else if (info
->shared
&& !info
->symbolic
1849 && !info
->no_undefined
1850 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1854 if (!((*info
->callbacks
->undefined_symbol
)
1855 (info
, h
->root
.root
.string
, input_bfd
,
1856 input_section
, rel
->r_offset
,
1857 (!info
->shared
|| info
->no_undefined
1858 || ELF_ST_VISIBILITY (h
->other
)))))
1865 name
= h
->root
.root
.string
;
1868 name
= (bfd_elf_string_from_elf_section
1869 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
1870 if (name
== NULL
|| *name
== '\0')
1871 name
= bfd_section_name (input_bfd
, sec
);
1874 r
= elf32_arm_final_link_relocate (howto
, input_bfd
, output_bfd
,
1875 input_section
, contents
, rel
,
1876 relocation
, info
, sec
, name
,
1877 (h
? ELF_ST_TYPE (h
->type
) :
1878 ELF_ST_TYPE (sym
->st_info
)), h
);
1880 if (r
!= bfd_reloc_ok
)
1882 const char * msg
= (const char *) 0;
1886 case bfd_reloc_overflow
:
1887 if (!((*info
->callbacks
->reloc_overflow
)
1888 (info
, name
, howto
->name
, (bfd_vma
) 0,
1889 input_bfd
, input_section
, rel
->r_offset
)))
1893 case bfd_reloc_undefined
:
1894 if (!((*info
->callbacks
->undefined_symbol
)
1895 (info
, name
, input_bfd
, input_section
,
1896 rel
->r_offset
, true)))
1900 case bfd_reloc_outofrange
:
1901 msg
= _("internal error: out of range error");
1904 case bfd_reloc_notsupported
:
1905 msg
= _("internal error: unsupported relocation error");
1908 case bfd_reloc_dangerous
:
1909 msg
= _("internal error: dangerous error");
1913 msg
= _("internal error: unknown error");
1917 if (!((*info
->callbacks
->warning
)
1918 (info
, msg
, name
, input_bfd
, input_section
,
1929 /* Function to keep ARM specific flags in the ELF header. */
1931 elf32_arm_set_private_flags (abfd
, flags
)
1935 if (elf_flags_init (abfd
)
1936 && elf_elfheader (abfd
)->e_flags
!= flags
)
1938 if (EF_ARM_EABI_VERSION (flags
) == EF_ARM_EABI_UNKNOWN
)
1940 if (flags
& EF_INTERWORK
)
1941 _bfd_error_handler (_("\
1942 Warning: Not setting interwork flag of %s since it has already been specified as non-interworking"),
1943 bfd_get_filename (abfd
));
1945 _bfd_error_handler (_("\
1946 Warning: Clearing the interwork flag of %s due to outside request"),
1947 bfd_get_filename (abfd
));
1952 elf_elfheader (abfd
)->e_flags
= flags
;
1953 elf_flags_init (abfd
) = true;
1959 /* Copy backend specific data from one object module to another. */
1962 elf32_arm_copy_private_bfd_data (ibfd
, obfd
)
1969 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1970 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1973 in_flags
= elf_elfheader (ibfd
)->e_flags
;
1974 out_flags
= elf_elfheader (obfd
)->e_flags
;
1976 if (elf_flags_init (obfd
)
1977 && EF_ARM_EABI_VERSION (out_flags
) == EF_ARM_EABI_UNKNOWN
1978 && in_flags
!= out_flags
)
1980 /* Cannot mix PIC and non-PIC code. */
1981 if ((in_flags
& EF_PIC
) != (out_flags
& EF_PIC
))
1984 /* Cannot mix APCS26 and APCS32 code. */
1985 if ((in_flags
& EF_APCS_26
) != (out_flags
& EF_APCS_26
))
1988 /* Cannot mix float APCS and non-float APCS code. */
1989 if ((in_flags
& EF_APCS_FLOAT
) != (out_flags
& EF_APCS_FLOAT
))
1992 /* If the src and dest have different interworking flags
1993 then turn off the interworking bit. */
1994 if ((in_flags
& EF_INTERWORK
) != (out_flags
& EF_INTERWORK
))
1996 if (out_flags
& EF_INTERWORK
)
1997 _bfd_error_handler (_("\
1998 Warning: Clearing the interwork flag in %s because non-interworking code in %s has been linked with it"),
1999 bfd_get_filename (obfd
), bfd_get_filename (ibfd
));
2001 in_flags
&= ~EF_INTERWORK
;
2005 elf_elfheader (obfd
)->e_flags
= in_flags
;
2006 elf_flags_init (obfd
) = true;
2011 /* Merge backend specific data from an object file to the output
2012 object file when linking. */
2015 elf32_arm_merge_private_bfd_data (ibfd
, obfd
)
2022 /* Check if we have the same endianess. */
2023 if (_bfd_generic_verify_endian_match (ibfd
, obfd
) == false)
2026 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2027 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2030 /* The input BFD must have had its flags initialised. */
2031 /* The following seems bogus to me -- The flags are initialized in
2032 the assembler but I don't think an elf_flags_init field is
2033 written into the object. */
2034 /* BFD_ASSERT (elf_flags_init (ibfd)); */
2036 in_flags
= elf_elfheader (ibfd
)->e_flags
;
2037 out_flags
= elf_elfheader (obfd
)->e_flags
;
2039 if (!elf_flags_init (obfd
))
2041 /* If the input is the default architecture and had the default
2042 flags then do not bother setting the flags for the output
2043 architecture, instead allow future merges to do this. If no
2044 future merges ever set these flags then they will retain their
2045 uninitialised values, which surprise surprise, correspond
2046 to the default values. */
2047 if (bfd_get_arch_info (ibfd
)->the_default
2048 && elf_elfheader (ibfd
)->e_flags
== 0)
2051 elf_flags_init (obfd
) = true;
2052 elf_elfheader (obfd
)->e_flags
= in_flags
;
2054 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
2055 && bfd_get_arch_info (obfd
)->the_default
)
2056 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
), bfd_get_mach (ibfd
));
2061 /* Check flag compatibility. */
2062 if (in_flags
== out_flags
)
2065 /* Complain about various flag mismatches. */
2066 if (EF_ARM_EABI_VERSION (in_flags
) != EF_ARM_EABI_VERSION (out_flags
))
2068 _bfd_error_handler (_("\
2069 Error: %s compiled for EABI version %d, whereas %s is compiled for version %d"),
2070 bfd_get_filename (ibfd
),
2071 (in_flags
& EF_ARM_EABIMASK
) >> 24,
2072 bfd_get_filename (obfd
),
2073 (out_flags
& EF_ARM_EABIMASK
) >> 24);
2075 else if (EF_ARM_EABI_VERSION (in_flags
) != EF_ARM_EABI_UNKNOWN
)
2076 /* Not sure what needs to be checked for EABI versions >= 1. */
2079 if ((in_flags
& EF_APCS_26
) != (out_flags
& EF_APCS_26
))
2080 _bfd_error_handler (_("\
2081 Error: %s compiled for APCS-%d, whereas %s is compiled for APCS-%d"),
2082 bfd_get_filename (ibfd
),
2083 in_flags
& EF_APCS_26
? 26 : 32,
2084 bfd_get_filename (obfd
),
2085 out_flags
& EF_APCS_26
? 26 : 32);
2087 if ((in_flags
& EF_APCS_FLOAT
) != (out_flags
& EF_APCS_FLOAT
))
2088 _bfd_error_handler (_("\
2089 Error: %s passes floats in %s registers, whereas %s passes them in %s registers"),
2090 bfd_get_filename (ibfd
),
2091 in_flags
& EF_APCS_FLOAT
? _("float") : _("integer"),
2092 bfd_get_filename (obfd
),
2093 out_flags
& EF_APCS_26
? _("float") : _("integer"));
2095 if ((in_flags
& EF_PIC
) != (out_flags
& EF_PIC
))
2096 _bfd_error_handler (_("\
2097 Error: %s is compiled as position %s code, whereas %s is not"),
2098 bfd_get_filename (ibfd
),
2099 in_flags
& EF_PIC
? _("independent") : _("dependent"),
2100 bfd_get_filename (obfd
));
2102 /* Interworking mismatch is only a warning. */
2103 if ((in_flags
& EF_INTERWORK
) != (out_flags
& EF_INTERWORK
))
2105 _bfd_error_handler (_("\
2106 Warning: %s %s interworking, whereas %s %s"),
2107 bfd_get_filename (ibfd
),
2108 in_flags
& EF_INTERWORK
? _("supports") : _("does not support"),
2109 bfd_get_filename (obfd
),
2110 out_flags
& EF_INTERWORK
? _("does not") : _("does"));
2117 /* Display the flags field. */
2120 elf32_arm_print_private_bfd_data (abfd
, ptr
)
2124 FILE * file
= (FILE *) ptr
;
2125 unsigned long flags
;
2127 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
2129 /* Print normal ELF private data. */
2130 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
2132 flags
= elf_elfheader (abfd
)->e_flags
;
2133 /* Ignore init flag - it may not be set, despite the flags field
2134 containing valid data. */
2136 /* xgettext:c-format */
2137 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
2139 switch (EF_ARM_EABI_VERSION (flags
))
2141 case EF_ARM_EABI_UNKNOWN
:
2142 /* The following flag bits are GNU extenstions and not part of the
2143 official ARM ELF extended ABI. Hence they are only decoded if
2144 the EABI version is not set. */
2145 if (flags
& EF_INTERWORK
)
2146 fprintf (file
, _(" [interworking enabled]"));
2148 if (flags
& EF_APCS_26
)
2149 fprintf (file
, _(" [APCS-26]"));
2151 fprintf (file
, _(" [APCS-32]"));
2153 if (flags
& EF_APCS_FLOAT
)
2154 fprintf (file
, _(" [floats passed in float registers]"));
2157 fprintf (file
, _(" [position independent]"));
2159 if (flags
& EF_NEW_ABI
)
2160 fprintf (file
, _(" [new ABI]"));
2162 if (flags
& EF_OLD_ABI
)
2163 fprintf (file
, _(" [old ABI]"));
2165 if (flags
& EF_SOFT_FLOAT
)
2166 fprintf (file
, _(" [software FP]"));
2168 flags
&= ~(EF_INTERWORK
| EF_APCS_26
| EF_APCS_FLOAT
| EF_PIC
2169 | EF_NEW_ABI
| EF_OLD_ABI
| EF_SOFT_FLOAT
);
2172 case EF_ARM_EABI_VER1
:
2173 fprintf (file
, _(" [Version1 EABI]"));
2175 if (flags
& EF_ARM_SYMSARESORTED
)
2176 fprintf (file
, _(" [sorted symbol table]"));
2178 fprintf (file
, _(" [unsorted symbol table]"));
2180 flags
&= ~ EF_ARM_SYMSARESORTED
;
2184 fprintf (file
, _(" <EABI version unrecognised>"));
2188 flags
&= ~ EF_ARM_EABIMASK
;
2190 if (flags
& EF_ARM_RELEXEC
)
2191 fprintf (file
, _(" [relocatable executable]"));
2193 if (flags
& EF_ARM_HASENTRY
)
2194 fprintf (file
, _(" [has entry point]"));
2196 flags
&= ~ (EF_ARM_RELEXEC
| EF_ARM_HASENTRY
);
2199 fprintf (file
, _("<Unrecognised flag bits set>"));
2207 elf32_arm_get_symbol_type (elf_sym
, type
)
2208 Elf_Internal_Sym
* elf_sym
;
2211 switch (ELF_ST_TYPE (elf_sym
->st_info
))
2214 return ELF_ST_TYPE (elf_sym
->st_info
);
2217 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2218 This allows us to distinguish between data used by Thumb instructions
2219 and non-data (which is probably code) inside Thumb regions of an
2221 if (type
!= STT_OBJECT
)
2222 return ELF_ST_TYPE (elf_sym
->st_info
);
2233 elf32_arm_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
2235 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2236 Elf_Internal_Rela
*rel
;
2237 struct elf_link_hash_entry
*h
;
2238 Elf_Internal_Sym
*sym
;
2242 switch (ELF32_R_TYPE (rel
->r_info
))
2244 case R_ARM_GNU_VTINHERIT
:
2245 case R_ARM_GNU_VTENTRY
:
2249 switch (h
->root
.type
)
2251 case bfd_link_hash_defined
:
2252 case bfd_link_hash_defweak
:
2253 return h
->root
.u
.def
.section
;
2255 case bfd_link_hash_common
:
2256 return h
->root
.u
.c
.p
->section
;
2265 if (!(elf_bad_symtab (abfd
)
2266 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
2267 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
2268 && sym
->st_shndx
!= SHN_COMMON
))
2270 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
2276 /* Update the got entry reference counts for the section being removed. */
2279 elf32_arm_gc_sweep_hook (abfd
, info
, sec
, relocs
)
2280 bfd
*abfd ATTRIBUTE_UNUSED
;
2281 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2282 asection
*sec ATTRIBUTE_UNUSED
;
2283 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
;
2285 /* We don't support garbage collection of GOT and PLT relocs yet. */
2289 /* Look through the relocs for a section during the first phase. */
2292 elf32_arm_check_relocs (abfd
, info
, sec
, relocs
)
2294 struct bfd_link_info
* info
;
2296 const Elf_Internal_Rela
* relocs
;
2298 Elf_Internal_Shdr
* symtab_hdr
;
2299 struct elf_link_hash_entry
** sym_hashes
;
2300 struct elf_link_hash_entry
** sym_hashes_end
;
2301 const Elf_Internal_Rela
* rel
;
2302 const Elf_Internal_Rela
* rel_end
;
2304 asection
* sgot
, *srelgot
, *sreloc
;
2305 bfd_vma
* local_got_offsets
;
2307 if (info
->relocateable
)
2310 sgot
= srelgot
= sreloc
= NULL
;
2312 dynobj
= elf_hash_table (info
)->dynobj
;
2313 local_got_offsets
= elf_local_got_offsets (abfd
);
2315 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2316 sym_hashes
= elf_sym_hashes (abfd
);
2317 sym_hashes_end
= sym_hashes
2318 + symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
2320 if (!elf_bad_symtab (abfd
))
2321 sym_hashes_end
-= symtab_hdr
->sh_info
;
2323 rel_end
= relocs
+ sec
->reloc_count
;
2324 for (rel
= relocs
; rel
< rel_end
; rel
++)
2326 struct elf_link_hash_entry
*h
;
2327 unsigned long r_symndx
;
2329 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2330 if (r_symndx
< symtab_hdr
->sh_info
)
2333 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2335 /* Some relocs require a global offset table. */
2338 switch (ELF32_R_TYPE (rel
->r_info
))
2343 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
2344 if (! _bfd_elf_create_got_section (dynobj
, info
))
2353 switch (ELF32_R_TYPE (rel
->r_info
))
2356 /* This symbol requires a global offset table entry. */
2359 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2360 BFD_ASSERT (sgot
!= NULL
);
2363 /* Get the got relocation section if necessary. */
2365 && (h
!= NULL
|| info
->shared
))
2367 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
2369 /* If no got relocation section, make one and initialize. */
2370 if (srelgot
== NULL
)
2372 srelgot
= bfd_make_section (dynobj
, ".rel.got");
2374 || ! bfd_set_section_flags (dynobj
, srelgot
,
2379 | SEC_LINKER_CREATED
2381 || ! bfd_set_section_alignment (dynobj
, srelgot
, 2))
2388 if (h
->got
.offset
!= (bfd_vma
) -1)
2389 /* We have already allocated space in the .got. */
2392 h
->got
.offset
= sgot
->_raw_size
;
2394 /* Make sure this symbol is output as a dynamic symbol. */
2395 if (h
->dynindx
== -1)
2396 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2399 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2403 /* This is a global offset table entry for a local
2405 if (local_got_offsets
== NULL
)
2408 register unsigned int i
;
2410 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
2411 local_got_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
2412 if (local_got_offsets
== NULL
)
2414 elf_local_got_offsets (abfd
) = local_got_offsets
;
2415 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
2416 local_got_offsets
[i
] = (bfd_vma
) -1;
2419 if (local_got_offsets
[r_symndx
] != (bfd_vma
) -1)
2420 /* We have already allocated space in the .got. */
2423 local_got_offsets
[r_symndx
] = sgot
->_raw_size
;
2426 /* If we are generating a shared object, we need to
2427 output a R_ARM_RELATIVE reloc so that the dynamic
2428 linker can adjust this GOT entry. */
2429 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2432 sgot
->_raw_size
+= 4;
2436 /* This symbol requires a procedure linkage table entry. We
2437 actually build the entry in adjust_dynamic_symbol,
2438 because this might be a case of linking PIC code which is
2439 never referenced by a dynamic object, in which case we
2440 don't need to generate a procedure linkage table entry
2443 /* If this is a local symbol, we resolve it directly without
2444 creating a procedure linkage table entry. */
2448 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2454 /* If we are creating a shared library, and this is a reloc
2455 against a global symbol, or a non PC relative reloc
2456 against a local symbol, then we need to copy the reloc
2457 into the shared library. However, if we are linking with
2458 -Bsymbolic, we do not need to copy a reloc against a
2459 global symbol which is defined in an object we are
2460 including in the link (i.e., DEF_REGULAR is set). At
2461 this point we have not seen all the input files, so it is
2462 possible that DEF_REGULAR is not set now but will be set
2463 later (it is never cleared). We account for that
2464 possibility below by storing information in the
2465 pcrel_relocs_copied field of the hash table entry. */
2467 && (ELF32_R_TYPE (rel
->r_info
) != R_ARM_PC24
2469 && (! info
->symbolic
2470 || (h
->elf_link_hash_flags
2471 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
2473 /* When creating a shared object, we must copy these
2474 reloc types into the output file. We create a reloc
2475 section in dynobj and make room for this reloc. */
2480 name
= (bfd_elf_string_from_elf_section
2482 elf_elfheader (abfd
)->e_shstrndx
,
2483 elf_section_data (sec
)->rel_hdr
.sh_name
));
2487 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
2488 && strcmp (bfd_get_section_name (abfd
, sec
),
2491 sreloc
= bfd_get_section_by_name (dynobj
, name
);
2496 sreloc
= bfd_make_section (dynobj
, name
);
2497 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
2498 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
2499 if ((sec
->flags
& SEC_ALLOC
) != 0)
2500 flags
|= SEC_ALLOC
| SEC_LOAD
;
2502 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
2503 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
2508 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
2509 /* If we are linking with -Bsymbolic, and this is a
2510 global symbol, we count the number of PC relative
2511 relocations we have entered for this symbol, so that
2512 we can discard them again if the symbol is later
2513 defined by a regular object. Note that this function
2514 is only called if we are using an elf_i386 linker
2515 hash table, which means that h is really a pointer to
2516 an elf_i386_link_hash_entry. */
2517 if (h
!= NULL
&& info
->symbolic
2518 && ELF32_R_TYPE (rel
->r_info
) == R_ARM_PC24
)
2520 struct elf32_arm_link_hash_entry
* eh
;
2521 struct elf32_arm_pcrel_relocs_copied
* p
;
2523 eh
= (struct elf32_arm_link_hash_entry
*) h
;
2525 for (p
= eh
->pcrel_relocs_copied
; p
!= NULL
; p
= p
->next
)
2526 if (p
->section
== sreloc
)
2531 p
= ((struct elf32_arm_pcrel_relocs_copied
*)
2532 bfd_alloc (dynobj
, sizeof * p
));
2536 p
->next
= eh
->pcrel_relocs_copied
;
2537 eh
->pcrel_relocs_copied
= p
;
2538 p
->section
= sreloc
;
2547 /* This relocation describes the C++ object vtable hierarchy.
2548 Reconstruct it for later use during GC. */
2549 case R_ARM_GNU_VTINHERIT
:
2550 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2554 /* This relocation describes which C++ vtable entries are actually
2555 used. Record for later use during GC. */
2556 case R_ARM_GNU_VTENTRY
:
2557 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
2567 /* Find the nearest line to a particular section and offset, for error
2568 reporting. This code is a duplicate of the code in elf.c, except
2569 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
2572 elf32_arm_find_nearest_line
2573 (abfd
, section
, symbols
, offset
, filename_ptr
, functionname_ptr
, line_ptr
)
2578 CONST
char ** filename_ptr
;
2579 CONST
char ** functionname_ptr
;
2580 unsigned int * line_ptr
;
2583 const char * filename
;
2588 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
2589 filename_ptr
, functionname_ptr
,
2593 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2594 &found
, filename_ptr
,
2595 functionname_ptr
, line_ptr
,
2596 &elf_tdata (abfd
)->line_info
))
2602 if (symbols
== NULL
)
2609 for (p
= symbols
; *p
!= NULL
; p
++)
2613 q
= (elf_symbol_type
*) *p
;
2615 if (bfd_get_section (&q
->symbol
) != section
)
2618 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
2623 filename
= bfd_asymbol_name (&q
->symbol
);
2628 if (q
->symbol
.section
== section
2629 && q
->symbol
.value
>= low_func
2630 && q
->symbol
.value
<= offset
)
2632 func
= (asymbol
*) q
;
2633 low_func
= q
->symbol
.value
;
2642 *filename_ptr
= filename
;
2643 *functionname_ptr
= bfd_asymbol_name (func
);
2649 /* Adjust a symbol defined by a dynamic object and referenced by a
2650 regular object. The current definition is in some section of the
2651 dynamic object, but we're not including those sections. We have to
2652 change the definition to something the rest of the link can
2656 elf32_arm_adjust_dynamic_symbol (info
, h
)
2657 struct bfd_link_info
* info
;
2658 struct elf_link_hash_entry
* h
;
2662 unsigned int power_of_two
;
2664 dynobj
= elf_hash_table (info
)->dynobj
;
2666 /* Make sure we know what is going on here. */
2667 BFD_ASSERT (dynobj
!= NULL
2668 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
2669 || h
->weakdef
!= NULL
2670 || ((h
->elf_link_hash_flags
2671 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2672 && (h
->elf_link_hash_flags
2673 & ELF_LINK_HASH_REF_REGULAR
) != 0
2674 && (h
->elf_link_hash_flags
2675 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
2677 /* If this is a function, put it in the procedure linkage table. We
2678 will fill in the contents of the procedure linkage table later,
2679 when we know the address of the .got section. */
2680 if (h
->type
== STT_FUNC
2681 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
2684 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
2685 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0)
2687 /* This case can occur if we saw a PLT32 reloc in an input
2688 file, but the symbol was never referred to by a dynamic
2689 object. In such a case, we don't actually need to build
2690 a procedure linkage table, and we can just do a PC32
2692 BFD_ASSERT ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0);
2696 /* Make sure this symbol is output as a dynamic symbol. */
2697 if (h
->dynindx
== -1)
2699 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2703 s
= bfd_get_section_by_name (dynobj
, ".plt");
2704 BFD_ASSERT (s
!= NULL
);
2706 /* If this is the first .plt entry, make room for the special
2708 if (s
->_raw_size
== 0)
2709 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2711 /* If this symbol is not defined in a regular file, and we are
2712 not generating a shared library, then set the symbol to this
2713 location in the .plt. This is required to make function
2714 pointers compare as equal between the normal executable and
2715 the shared library. */
2717 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2719 h
->root
.u
.def
.section
= s
;
2720 h
->root
.u
.def
.value
= s
->_raw_size
;
2723 h
->plt
.offset
= s
->_raw_size
;
2725 /* Make room for this entry. */
2726 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2728 /* We also need to make an entry in the .got.plt section, which
2729 will be placed in the .got section by the linker script. */
2730 s
= bfd_get_section_by_name (dynobj
, ".got.plt");
2731 BFD_ASSERT (s
!= NULL
);
2734 /* We also need to make an entry in the .rel.plt section. */
2736 s
= bfd_get_section_by_name (dynobj
, ".rel.plt");
2737 BFD_ASSERT (s
!= NULL
);
2738 s
->_raw_size
+= sizeof (Elf32_External_Rel
);
2743 /* If this is a weak symbol, and there is a real definition, the
2744 processor independent code will have arranged for us to see the
2745 real definition first, and we can just use the same value. */
2746 if (h
->weakdef
!= NULL
)
2748 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
2749 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
2750 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
2751 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
2755 /* This is a reference to a symbol defined by a dynamic object which
2756 is not a function. */
2758 /* If we are creating a shared library, we must presume that the
2759 only references to the symbol are via the global offset table.
2760 For such cases we need not do anything here; the relocations will
2761 be handled correctly by relocate_section. */
2765 /* We must allocate the symbol in our .dynbss section, which will
2766 become part of the .bss section of the executable. There will be
2767 an entry for this symbol in the .dynsym section. The dynamic
2768 object will contain position independent code, so all references
2769 from the dynamic object to this symbol will go through the global
2770 offset table. The dynamic linker will use the .dynsym entry to
2771 determine the address it must put in the global offset table, so
2772 both the dynamic object and the regular object will refer to the
2773 same memory location for the variable. */
2774 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
2775 BFD_ASSERT (s
!= NULL
);
2777 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
2778 copy the initial value out of the dynamic object and into the
2779 runtime process image. We need to remember the offset into the
2780 .rel.bss section we are going to use. */
2781 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2785 srel
= bfd_get_section_by_name (dynobj
, ".rel.bss");
2786 BFD_ASSERT (srel
!= NULL
);
2787 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
2788 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
2791 /* We need to figure out the alignment required for this symbol. I
2792 have no idea how ELF linkers handle this. */
2793 power_of_two
= bfd_log2 (h
->size
);
2794 if (power_of_two
> 3)
2797 /* Apply the required alignment. */
2798 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
2799 (bfd_size_type
) (1 << power_of_two
));
2800 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
2802 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
2806 /* Define the symbol as being at this point in the section. */
2807 h
->root
.u
.def
.section
= s
;
2808 h
->root
.u
.def
.value
= s
->_raw_size
;
2810 /* Increment the section size to make room for the symbol. */
2811 s
->_raw_size
+= h
->size
;
2816 /* Set the sizes of the dynamic sections. */
2819 elf32_arm_size_dynamic_sections (output_bfd
, info
)
2821 struct bfd_link_info
* info
;
2829 dynobj
= elf_hash_table (info
)->dynobj
;
2830 BFD_ASSERT (dynobj
!= NULL
);
2832 if (elf_hash_table (info
)->dynamic_sections_created
)
2834 /* Set the contents of the .interp section to the interpreter. */
2837 s
= bfd_get_section_by_name (dynobj
, ".interp");
2838 BFD_ASSERT (s
!= NULL
);
2839 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2840 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2845 /* We may have created entries in the .rel.got section.
2846 However, if we are not creating the dynamic sections, we will
2847 not actually use these entries. Reset the size of .rel.got,
2848 which will cause it to get stripped from the output file
2850 s
= bfd_get_section_by_name (dynobj
, ".rel.got");
2855 /* If this is a -Bsymbolic shared link, then we need to discard all
2856 PC relative relocs against symbols defined in a regular object.
2857 We allocated space for them in the check_relocs routine, but we
2858 will not fill them in in the relocate_section routine. */
2859 if (info
->shared
&& info
->symbolic
)
2860 elf32_arm_link_hash_traverse (elf32_arm_hash_table (info
),
2861 elf32_arm_discard_copies
,
2864 /* The check_relocs and adjust_dynamic_symbol entry points have
2865 determined the sizes of the various dynamic sections. Allocate
2870 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2875 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2878 /* It's OK to base decisions on the section name, because none
2879 of the dynobj section names depend upon the input files. */
2880 name
= bfd_get_section_name (dynobj
, s
);
2884 if (strcmp (name
, ".plt") == 0)
2886 if (s
->_raw_size
== 0)
2888 /* Strip this section if we don't need it; see the
2894 /* Remember whether there is a PLT. */
2898 else if (strncmp (name
, ".rel", 4) == 0)
2900 if (s
->_raw_size
== 0)
2902 /* If we don't need this section, strip it from the
2903 output file. This is mostly to handle .rel.bss and
2904 .rel.plt. We must create both sections in
2905 create_dynamic_sections, because they must be created
2906 before the linker maps input sections to output
2907 sections. The linker does that before
2908 adjust_dynamic_symbol is called, and it is that
2909 function which decides whether anything needs to go
2910 into these sections. */
2917 /* Remember whether there are any reloc sections other
2919 if (strcmp (name
, ".rel.plt") != 0)
2921 const char *outname
;
2925 /* If this relocation section applies to a read only
2926 section, then we probably need a DT_TEXTREL
2927 entry. The entries in the .rel.plt section
2928 really apply to the .got section, which we
2929 created ourselves and so know is not readonly. */
2930 outname
= bfd_get_section_name (output_bfd
,
2932 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
2935 && (target
->flags
& SEC_READONLY
) != 0
2936 && (target
->flags
& SEC_ALLOC
) != 0)
2940 /* We use the reloc_count field as a counter if we need
2941 to copy relocs into the output file. */
2945 else if (strncmp (name
, ".got", 4) != 0)
2947 /* It's not one of our sections, so don't allocate space. */
2955 for (spp
= &s
->output_section
->owner
->sections
;
2956 *spp
!= s
->output_section
;
2957 spp
= &(*spp
)->next
)
2959 *spp
= s
->output_section
->next
;
2960 --s
->output_section
->owner
->section_count
;
2965 /* Allocate memory for the section contents. */
2966 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
2967 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
2971 if (elf_hash_table (info
)->dynamic_sections_created
)
2973 /* Add some entries to the .dynamic section. We fill in the
2974 values later, in elf32_arm_finish_dynamic_sections, but we
2975 must add the entries now so that we get the correct size for
2976 the .dynamic section. The DT_DEBUG entry is filled in by the
2977 dynamic linker and used by the debugger. */
2980 if (! bfd_elf32_add_dynamic_entry (info
, DT_DEBUG
, 0))
2986 if ( ! bfd_elf32_add_dynamic_entry (info
, DT_PLTGOT
, 0)
2987 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
2988 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTREL
, DT_REL
)
2989 || ! bfd_elf32_add_dynamic_entry (info
, DT_JMPREL
, 0))
2995 if ( ! bfd_elf32_add_dynamic_entry (info
, DT_REL
, 0)
2996 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELSZ
, 0)
2997 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELENT
,
2998 sizeof (Elf32_External_Rel
)))
3004 if (! bfd_elf32_add_dynamic_entry (info
, DT_TEXTREL
, 0))
3006 info
->flags
|= DF_TEXTREL
;
3013 /* This function is called via elf32_arm_link_hash_traverse if we are
3014 creating a shared object with -Bsymbolic. It discards the space
3015 allocated to copy PC relative relocs against symbols which are
3016 defined in regular objects. We allocated space for them in the
3017 check_relocs routine, but we won't fill them in in the
3018 relocate_section routine. */
3021 elf32_arm_discard_copies (h
, ignore
)
3022 struct elf32_arm_link_hash_entry
* h
;
3023 PTR ignore ATTRIBUTE_UNUSED
;
3025 struct elf32_arm_pcrel_relocs_copied
* s
;
3027 /* We only discard relocs for symbols defined in a regular object. */
3028 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3031 for (s
= h
->pcrel_relocs_copied
; s
!= NULL
; s
= s
->next
)
3032 s
->section
->_raw_size
-= s
->count
* sizeof (Elf32_External_Rel
);
3037 /* Finish up dynamic symbol handling. We set the contents of various
3038 dynamic sections here. */
3041 elf32_arm_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
3043 struct bfd_link_info
* info
;
3044 struct elf_link_hash_entry
* h
;
3045 Elf_Internal_Sym
* sym
;
3049 dynobj
= elf_hash_table (info
)->dynobj
;
3051 if (h
->plt
.offset
!= (bfd_vma
) -1)
3058 Elf_Internal_Rel rel
;
3060 /* This symbol has an entry in the procedure linkage table. Set
3063 BFD_ASSERT (h
->dynindx
!= -1);
3065 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3066 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3067 srel
= bfd_get_section_by_name (dynobj
, ".rel.plt");
3068 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
3070 /* Get the index in the procedure linkage table which
3071 corresponds to this symbol. This is the index of this symbol
3072 in all the symbols for which we are making plt entries. The
3073 first entry in the procedure linkage table is reserved. */
3074 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
3076 /* Get the offset into the .got table of the entry that
3077 corresponds to this function. Each .got entry is 4 bytes.
3078 The first three are reserved. */
3079 got_offset
= (plt_index
+ 3) * 4;
3081 /* Fill in the entry in the procedure linkage table. */
3082 memcpy (splt
->contents
+ h
->plt
.offset
,
3083 elf32_arm_plt_entry
,
3085 bfd_put_32 (output_bfd
,
3086 (sgot
->output_section
->vma
3087 + sgot
->output_offset
3089 - splt
->output_section
->vma
3090 - splt
->output_offset
3091 - h
->plt
.offset
- 12),
3092 splt
->contents
+ h
->plt
.offset
+ 12);
3094 /* Fill in the entry in the global offset table. */
3095 bfd_put_32 (output_bfd
,
3096 (splt
->output_section
->vma
3097 + splt
->output_offset
),
3098 sgot
->contents
+ got_offset
);
3100 /* Fill in the entry in the .rel.plt section. */
3101 rel
.r_offset
= (sgot
->output_section
->vma
3102 + sgot
->output_offset
3104 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_JUMP_SLOT
);
3105 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3106 ((Elf32_External_Rel
*) srel
->contents
3109 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3111 /* Mark the symbol as undefined, rather than as defined in
3112 the .plt section. Leave the value alone. */
3113 sym
->st_shndx
= SHN_UNDEF
;
3117 if (h
->got
.offset
!= (bfd_vma
) -1)
3121 Elf_Internal_Rel rel
;
3123 /* This symbol has an entry in the global offset table. Set it
3125 sgot
= bfd_get_section_by_name (dynobj
, ".got");
3126 srel
= bfd_get_section_by_name (dynobj
, ".rel.got");
3127 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
3129 rel
.r_offset
= (sgot
->output_section
->vma
3130 + sgot
->output_offset
3131 + (h
->got
.offset
&~ 1));
3133 /* If this is a -Bsymbolic link, and the symbol is defined
3134 locally, we just want to emit a RELATIVE reloc. The entry in
3135 the global offset table will already have been initialized in
3136 the relocate_section function. */
3138 && (info
->symbolic
|| h
->dynindx
== -1)
3139 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
3140 rel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
3143 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
3144 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_GLOB_DAT
);
3147 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3148 ((Elf32_External_Rel
*) srel
->contents
3149 + srel
->reloc_count
));
3150 ++srel
->reloc_count
;
3153 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
3156 Elf_Internal_Rel rel
;
3158 /* This symbol needs a copy reloc. Set it up. */
3159 BFD_ASSERT (h
->dynindx
!= -1
3160 && (h
->root
.type
== bfd_link_hash_defined
3161 || h
->root
.type
== bfd_link_hash_defweak
));
3163 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
3165 BFD_ASSERT (s
!= NULL
);
3167 rel
.r_offset
= (h
->root
.u
.def
.value
3168 + h
->root
.u
.def
.section
->output_section
->vma
3169 + h
->root
.u
.def
.section
->output_offset
);
3170 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_COPY
);
3171 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3172 ((Elf32_External_Rel
*) s
->contents
3177 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3178 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3179 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
3180 sym
->st_shndx
= SHN_ABS
;
3185 /* Finish up the dynamic sections. */
3188 elf32_arm_finish_dynamic_sections (output_bfd
, info
)
3190 struct bfd_link_info
* info
;
3196 dynobj
= elf_hash_table (info
)->dynobj
;
3198 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3199 BFD_ASSERT (sgot
!= NULL
);
3200 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3202 if (elf_hash_table (info
)->dynamic_sections_created
)
3205 Elf32_External_Dyn
*dyncon
, *dynconend
;
3207 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3208 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3210 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3211 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
3213 for (; dyncon
< dynconend
; dyncon
++)
3215 Elf_Internal_Dyn dyn
;
3219 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3232 s
= bfd_get_section_by_name (output_bfd
, name
);
3233 BFD_ASSERT (s
!= NULL
);
3234 dyn
.d_un
.d_ptr
= s
->vma
;
3235 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3239 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3240 BFD_ASSERT (s
!= NULL
);
3241 if (s
->_cooked_size
!= 0)
3242 dyn
.d_un
.d_val
= s
->_cooked_size
;
3244 dyn
.d_un
.d_val
= s
->_raw_size
;
3245 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3249 /* My reading of the SVR4 ABI indicates that the
3250 procedure linkage table relocs (DT_JMPREL) should be
3251 included in the overall relocs (DT_REL). This is
3252 what Solaris does. However, UnixWare can not handle
3253 that case. Therefore, we override the DT_RELSZ entry
3254 here to make it not include the JMPREL relocs. Since
3255 the linker script arranges for .rel.plt to follow all
3256 other relocation sections, we don't have to worry
3257 about changing the DT_REL entry. */
3258 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3261 if (s
->_cooked_size
!= 0)
3262 dyn
.d_un
.d_val
-= s
->_cooked_size
;
3264 dyn
.d_un
.d_val
-= s
->_raw_size
;
3266 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3271 /* Fill in the first entry in the procedure linkage table. */
3272 if (splt
->_raw_size
> 0)
3273 memcpy (splt
->contents
, elf32_arm_plt0_entry
, PLT_ENTRY_SIZE
);
3275 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3276 really seem like the right value. */
3277 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
3280 /* Fill in the first three entries in the global offset table. */
3281 if (sgot
->_raw_size
> 0)
3284 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
3286 bfd_put_32 (output_bfd
,
3287 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3289 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
3290 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
3293 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
3299 elf32_arm_post_process_headers (abfd
, link_info
)
3301 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
;
3303 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
3305 i_ehdrp
= elf_elfheader (abfd
);
3307 i_ehdrp
->e_ident
[EI_OSABI
] = ARM_ELF_OS_ABI_VERSION
;
3308 i_ehdrp
->e_ident
[EI_ABIVERSION
] = ARM_ELF_ABI_VERSION
;
3312 #define ELF_ARCH bfd_arch_arm
3313 #define ELF_MACHINE_CODE EM_ARM
3314 #define ELF_MAXPAGESIZE 0x8000
3317 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
3318 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
3319 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
3320 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
3321 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
3322 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
3323 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
3325 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
3326 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
3327 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
3328 #define elf_backend_check_relocs elf32_arm_check_relocs
3329 #define elf_backend_relocate_section elf32_arm_relocate_section
3330 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
3331 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
3332 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
3333 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
3334 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
3335 #define elf_backend_post_process_headers elf32_arm_post_process_headers
3337 #define elf_backend_can_gc_sections 1
3338 #define elf_backend_plt_readonly 1
3339 #define elf_backend_want_got_plt 1
3340 #define elf_backend_want_plt_sym 0
3342 #define elf_backend_got_header_size 12
3343 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
3345 #include "elf32-target.h"