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 then do not
2042 bother setting the flags for the output architecture,
2043 instead allow future merges to do this. If no future
2044 merges ever set these flags then they will retain their
2045 unitialised values, which surprise surprise, correspond
2046 to the default values. */
2047 if (bfd_get_arch_info (ibfd
)->the_default
)
2050 elf_flags_init (obfd
) = true;
2051 elf_elfheader (obfd
)->e_flags
= in_flags
;
2053 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
2054 && bfd_get_arch_info (obfd
)->the_default
)
2055 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
), bfd_get_mach (ibfd
));
2060 /* Check flag compatibility. */
2061 if (in_flags
== out_flags
)
2064 /* Complain about various flag mismatches. */
2065 if (EF_ARM_EABI_VERSION (in_flags
) != EF_ARM_EABI_VERSION (out_flags
))
2067 _bfd_error_handler (_("\
2068 Error: %s compiled for EABI version %d, whereas %s is compiled for version %d"),
2069 bfd_get_filename (ibfd
),
2070 (in_flags
& EF_ARM_EABIMASK
) >> 24,
2071 bfd_get_filename (obfd
),
2072 (out_flags
& EF_ARM_EABIMASK
) >> 24);
2074 else if (EF_ARM_EABI_VERSION (in_flags
) != EF_ARM_EABI_UNKNOWN
)
2075 /* Not sure what needs to be checked for EABI versions >= 1. */
2078 if ((in_flags
& EF_APCS_26
) != (out_flags
& EF_APCS_26
))
2079 _bfd_error_handler (_("\
2080 Error: %s compiled for APCS-%d, whereas %s is compiled for APCS-%d"),
2081 bfd_get_filename (ibfd
),
2082 in_flags
& EF_APCS_26
? 26 : 32,
2083 bfd_get_filename (obfd
),
2084 out_flags
& EF_APCS_26
? 26 : 32);
2086 if ((in_flags
& EF_APCS_FLOAT
) != (out_flags
& EF_APCS_FLOAT
))
2087 _bfd_error_handler (_("\
2088 Error: %s passes floats in %s registers, whereas %s passes them in %s registers"),
2089 bfd_get_filename (ibfd
),
2090 in_flags
& EF_APCS_FLOAT
? _("float") : _("integer"),
2091 bfd_get_filename (obfd
),
2092 out_flags
& EF_APCS_26
? _("float") : _("integer"));
2094 if ((in_flags
& EF_PIC
) != (out_flags
& EF_PIC
))
2095 _bfd_error_handler (_("\
2096 Error: %s is compiled as position %s code, whereas %s is not"),
2097 bfd_get_filename (ibfd
),
2098 in_flags
& EF_PIC
? _("independent") : _("dependent"),
2099 bfd_get_filename (obfd
));
2101 /* Interworking mismatch is only a warning. */
2102 if ((in_flags
& EF_INTERWORK
) != (out_flags
& EF_INTERWORK
))
2104 _bfd_error_handler (_("\
2105 Warning: %s %s interworking, whereas %s %s"),
2106 bfd_get_filename (ibfd
),
2107 in_flags
& EF_INTERWORK
? _("supports") : _("does not support"),
2108 bfd_get_filename (obfd
),
2109 out_flags
& EF_INTERWORK
? _("does not") : _("does"));
2116 /* Display the flags field. */
2119 elf32_arm_print_private_bfd_data (abfd
, ptr
)
2123 FILE * file
= (FILE *) ptr
;
2124 unsigned long flags
;
2126 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
2128 /* Print normal ELF private data. */
2129 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
2131 flags
= elf_elfheader (abfd
)->e_flags
;
2132 /* Ignore init flag - it may not be set, despite the flags field
2133 containing valid data. */
2135 /* xgettext:c-format */
2136 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
2138 switch (EF_ARM_EABI_VERSION (flags
))
2140 case EF_ARM_EABI_UNKNOWN
:
2141 /* The following flag bits are GNU extenstions and not part of the
2142 official ARM ELF extended ABI. Hence they are only decoded if
2143 the EABI version is not set. */
2144 if (flags
& EF_INTERWORK
)
2145 fprintf (file
, _(" [interworking enabled]"));
2147 if (flags
& EF_APCS_26
)
2148 fprintf (file
, _(" [APCS-26]"));
2150 fprintf (file
, _(" [APCS-32]"));
2152 if (flags
& EF_APCS_FLOAT
)
2153 fprintf (file
, _(" [floats passed in float registers]"));
2156 fprintf (file
, _(" [position independent]"));
2158 if (flags
& EF_NEW_ABI
)
2159 fprintf (file
, _(" [new ABI]"));
2161 if (flags
& EF_OLD_ABI
)
2162 fprintf (file
, _(" [old ABI]"));
2164 if (flags
& EF_SOFT_FLOAT
)
2165 fprintf (file
, _(" [software FP]"));
2167 flags
&= ~(EF_INTERWORK
| EF_APCS_26
| EF_APCS_FLOAT
| EF_PIC
2168 | EF_NEW_ABI
| EF_OLD_ABI
| EF_SOFT_FLOAT
);
2171 case EF_ARM_EABI_VER1
:
2172 fprintf (file
, _(" [Version1 EABI]"));
2174 if (flags
& EF_ARM_SYMSARESORTED
)
2175 fprintf (file
, _(" [sorted symbol table]"));
2177 fprintf (file
, _(" [unsorted symbol table]"));
2179 flags
&= ~ EF_ARM_SYMSARESORTED
;
2183 fprintf (file
, _(" <EABI version unrecognised>"));
2187 flags
&= ~ EF_ARM_EABIMASK
;
2189 if (flags
& EF_ARM_RELEXEC
)
2190 fprintf (file
, _(" [relocatable executable]"));
2192 if (flags
& EF_ARM_HASENTRY
)
2193 fprintf (file
, _(" [has entry point]"));
2195 flags
&= ~ (EF_ARM_RELEXEC
| EF_ARM_HASENTRY
);
2198 fprintf (file
, _("<Unrecognised flag bits set>"));
2206 elf32_arm_get_symbol_type (elf_sym
, type
)
2207 Elf_Internal_Sym
* elf_sym
;
2210 switch (ELF_ST_TYPE (elf_sym
->st_info
))
2213 return ELF_ST_TYPE (elf_sym
->st_info
);
2216 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2217 This allows us to distinguish between data used by Thumb instructions
2218 and non-data (which is probably code) inside Thumb regions of an
2220 if (type
!= STT_OBJECT
)
2221 return ELF_ST_TYPE (elf_sym
->st_info
);
2232 elf32_arm_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
2234 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2235 Elf_Internal_Rela
*rel
;
2236 struct elf_link_hash_entry
*h
;
2237 Elf_Internal_Sym
*sym
;
2241 switch (ELF32_R_TYPE (rel
->r_info
))
2243 case R_ARM_GNU_VTINHERIT
:
2244 case R_ARM_GNU_VTENTRY
:
2248 switch (h
->root
.type
)
2250 case bfd_link_hash_defined
:
2251 case bfd_link_hash_defweak
:
2252 return h
->root
.u
.def
.section
;
2254 case bfd_link_hash_common
:
2255 return h
->root
.u
.c
.p
->section
;
2264 if (!(elf_bad_symtab (abfd
)
2265 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
2266 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
2267 && sym
->st_shndx
!= SHN_COMMON
))
2269 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
2275 /* Update the got entry reference counts for the section being removed. */
2278 elf32_arm_gc_sweep_hook (abfd
, info
, sec
, relocs
)
2279 bfd
*abfd ATTRIBUTE_UNUSED
;
2280 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2281 asection
*sec ATTRIBUTE_UNUSED
;
2282 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
;
2284 /* We don't support garbage collection of GOT and PLT relocs yet. */
2288 /* Look through the relocs for a section during the first phase. */
2291 elf32_arm_check_relocs (abfd
, info
, sec
, relocs
)
2293 struct bfd_link_info
* info
;
2295 const Elf_Internal_Rela
* relocs
;
2297 Elf_Internal_Shdr
* symtab_hdr
;
2298 struct elf_link_hash_entry
** sym_hashes
;
2299 struct elf_link_hash_entry
** sym_hashes_end
;
2300 const Elf_Internal_Rela
* rel
;
2301 const Elf_Internal_Rela
* rel_end
;
2303 asection
* sgot
, *srelgot
, *sreloc
;
2304 bfd_vma
* local_got_offsets
;
2306 if (info
->relocateable
)
2309 sgot
= srelgot
= sreloc
= NULL
;
2311 dynobj
= elf_hash_table (info
)->dynobj
;
2312 local_got_offsets
= elf_local_got_offsets (abfd
);
2314 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2315 sym_hashes
= elf_sym_hashes (abfd
);
2316 sym_hashes_end
= sym_hashes
2317 + symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
2319 if (!elf_bad_symtab (abfd
))
2320 sym_hashes_end
-= symtab_hdr
->sh_info
;
2322 rel_end
= relocs
+ sec
->reloc_count
;
2323 for (rel
= relocs
; rel
< rel_end
; rel
++)
2325 struct elf_link_hash_entry
*h
;
2326 unsigned long r_symndx
;
2328 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2329 if (r_symndx
< symtab_hdr
->sh_info
)
2332 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2334 /* Some relocs require a global offset table. */
2337 switch (ELF32_R_TYPE (rel
->r_info
))
2342 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
2343 if (! _bfd_elf_create_got_section (dynobj
, info
))
2352 switch (ELF32_R_TYPE (rel
->r_info
))
2355 /* This symbol requires a global offset table entry. */
2358 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2359 BFD_ASSERT (sgot
!= NULL
);
2362 /* Get the got relocation section if necessary. */
2364 && (h
!= NULL
|| info
->shared
))
2366 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
2368 /* If no got relocation section, make one and initialize. */
2369 if (srelgot
== NULL
)
2371 srelgot
= bfd_make_section (dynobj
, ".rel.got");
2373 || ! bfd_set_section_flags (dynobj
, srelgot
,
2378 | SEC_LINKER_CREATED
2380 || ! bfd_set_section_alignment (dynobj
, srelgot
, 2))
2387 if (h
->got
.offset
!= (bfd_vma
) -1)
2388 /* We have already allocated space in the .got. */
2391 h
->got
.offset
= sgot
->_raw_size
;
2393 /* Make sure this symbol is output as a dynamic symbol. */
2394 if (h
->dynindx
== -1)
2395 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2398 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2402 /* This is a global offset table entry for a local
2404 if (local_got_offsets
== NULL
)
2407 register unsigned int i
;
2409 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
2410 local_got_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
2411 if (local_got_offsets
== NULL
)
2413 elf_local_got_offsets (abfd
) = local_got_offsets
;
2414 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
2415 local_got_offsets
[i
] = (bfd_vma
) -1;
2418 if (local_got_offsets
[r_symndx
] != (bfd_vma
) -1)
2419 /* We have already allocated space in the .got. */
2422 local_got_offsets
[r_symndx
] = sgot
->_raw_size
;
2425 /* If we are generating a shared object, we need to
2426 output a R_ARM_RELATIVE reloc so that the dynamic
2427 linker can adjust this GOT entry. */
2428 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
2431 sgot
->_raw_size
+= 4;
2435 /* This symbol requires a procedure linkage table entry. We
2436 actually build the entry in adjust_dynamic_symbol,
2437 because this might be a case of linking PIC code which is
2438 never referenced by a dynamic object, in which case we
2439 don't need to generate a procedure linkage table entry
2442 /* If this is a local symbol, we resolve it directly without
2443 creating a procedure linkage table entry. */
2447 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2453 /* If we are creating a shared library, and this is a reloc
2454 against a global symbol, or a non PC relative reloc
2455 against a local symbol, then we need to copy the reloc
2456 into the shared library. However, if we are linking with
2457 -Bsymbolic, we do not need to copy a reloc against a
2458 global symbol which is defined in an object we are
2459 including in the link (i.e., DEF_REGULAR is set). At
2460 this point we have not seen all the input files, so it is
2461 possible that DEF_REGULAR is not set now but will be set
2462 later (it is never cleared). We account for that
2463 possibility below by storing information in the
2464 pcrel_relocs_copied field of the hash table entry. */
2466 && (ELF32_R_TYPE (rel
->r_info
) != R_ARM_PC24
2468 && (! info
->symbolic
2469 || (h
->elf_link_hash_flags
2470 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
2472 /* When creating a shared object, we must copy these
2473 reloc types into the output file. We create a reloc
2474 section in dynobj and make room for this reloc. */
2479 name
= (bfd_elf_string_from_elf_section
2481 elf_elfheader (abfd
)->e_shstrndx
,
2482 elf_section_data (sec
)->rel_hdr
.sh_name
));
2486 BFD_ASSERT (strncmp (name
, ".rel", 4) == 0
2487 && strcmp (bfd_get_section_name (abfd
, sec
),
2490 sreloc
= bfd_get_section_by_name (dynobj
, name
);
2495 sreloc
= bfd_make_section (dynobj
, name
);
2496 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
2497 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
2498 if ((sec
->flags
& SEC_ALLOC
) != 0)
2499 flags
|= SEC_ALLOC
| SEC_LOAD
;
2501 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
2502 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
2507 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
2508 /* If we are linking with -Bsymbolic, and this is a
2509 global symbol, we count the number of PC relative
2510 relocations we have entered for this symbol, so that
2511 we can discard them again if the symbol is later
2512 defined by a regular object. Note that this function
2513 is only called if we are using an elf_i386 linker
2514 hash table, which means that h is really a pointer to
2515 an elf_i386_link_hash_entry. */
2516 if (h
!= NULL
&& info
->symbolic
2517 && ELF32_R_TYPE (rel
->r_info
) == R_ARM_PC24
)
2519 struct elf32_arm_link_hash_entry
* eh
;
2520 struct elf32_arm_pcrel_relocs_copied
* p
;
2522 eh
= (struct elf32_arm_link_hash_entry
*) h
;
2524 for (p
= eh
->pcrel_relocs_copied
; p
!= NULL
; p
= p
->next
)
2525 if (p
->section
== sreloc
)
2530 p
= ((struct elf32_arm_pcrel_relocs_copied
*)
2531 bfd_alloc (dynobj
, sizeof * p
));
2535 p
->next
= eh
->pcrel_relocs_copied
;
2536 eh
->pcrel_relocs_copied
= p
;
2537 p
->section
= sreloc
;
2546 /* This relocation describes the C++ object vtable hierarchy.
2547 Reconstruct it for later use during GC. */
2548 case R_ARM_GNU_VTINHERIT
:
2549 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2553 /* This relocation describes which C++ vtable entries are actually
2554 used. Record for later use during GC. */
2555 case R_ARM_GNU_VTENTRY
:
2556 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
2566 /* Find the nearest line to a particular section and offset, for error
2567 reporting. This code is a duplicate of the code in elf.c, except
2568 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
2571 elf32_arm_find_nearest_line
2572 (abfd
, section
, symbols
, offset
, filename_ptr
, functionname_ptr
, line_ptr
)
2577 CONST
char ** filename_ptr
;
2578 CONST
char ** functionname_ptr
;
2579 unsigned int * line_ptr
;
2582 const char * filename
;
2587 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
2588 filename_ptr
, functionname_ptr
,
2592 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2593 &found
, filename_ptr
,
2594 functionname_ptr
, line_ptr
,
2595 &elf_tdata (abfd
)->line_info
))
2601 if (symbols
== NULL
)
2608 for (p
= symbols
; *p
!= NULL
; p
++)
2612 q
= (elf_symbol_type
*) *p
;
2614 if (bfd_get_section (&q
->symbol
) != section
)
2617 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
2622 filename
= bfd_asymbol_name (&q
->symbol
);
2627 if (q
->symbol
.section
== section
2628 && q
->symbol
.value
>= low_func
2629 && q
->symbol
.value
<= offset
)
2631 func
= (asymbol
*) q
;
2632 low_func
= q
->symbol
.value
;
2641 *filename_ptr
= filename
;
2642 *functionname_ptr
= bfd_asymbol_name (func
);
2648 /* Adjust a symbol defined by a dynamic object and referenced by a
2649 regular object. The current definition is in some section of the
2650 dynamic object, but we're not including those sections. We have to
2651 change the definition to something the rest of the link can
2655 elf32_arm_adjust_dynamic_symbol (info
, h
)
2656 struct bfd_link_info
* info
;
2657 struct elf_link_hash_entry
* h
;
2661 unsigned int power_of_two
;
2663 dynobj
= elf_hash_table (info
)->dynobj
;
2665 /* Make sure we know what is going on here. */
2666 BFD_ASSERT (dynobj
!= NULL
2667 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
2668 || h
->weakdef
!= NULL
2669 || ((h
->elf_link_hash_flags
2670 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2671 && (h
->elf_link_hash_flags
2672 & ELF_LINK_HASH_REF_REGULAR
) != 0
2673 && (h
->elf_link_hash_flags
2674 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
2676 /* If this is a function, put it in the procedure linkage table. We
2677 will fill in the contents of the procedure linkage table later,
2678 when we know the address of the .got section. */
2679 if (h
->type
== STT_FUNC
2680 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
2683 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
2684 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0)
2686 /* This case can occur if we saw a PLT32 reloc in an input
2687 file, but the symbol was never referred to by a dynamic
2688 object. In such a case, we don't actually need to build
2689 a procedure linkage table, and we can just do a PC32
2691 BFD_ASSERT ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0);
2695 /* Make sure this symbol is output as a dynamic symbol. */
2696 if (h
->dynindx
== -1)
2698 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2702 s
= bfd_get_section_by_name (dynobj
, ".plt");
2703 BFD_ASSERT (s
!= NULL
);
2705 /* If this is the first .plt entry, make room for the special
2707 if (s
->_raw_size
== 0)
2708 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2710 /* If this symbol is not defined in a regular file, and we are
2711 not generating a shared library, then set the symbol to this
2712 location in the .plt. This is required to make function
2713 pointers compare as equal between the normal executable and
2714 the shared library. */
2716 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2718 h
->root
.u
.def
.section
= s
;
2719 h
->root
.u
.def
.value
= s
->_raw_size
;
2722 h
->plt
.offset
= s
->_raw_size
;
2724 /* Make room for this entry. */
2725 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2727 /* We also need to make an entry in the .got.plt section, which
2728 will be placed in the .got section by the linker script. */
2729 s
= bfd_get_section_by_name (dynobj
, ".got.plt");
2730 BFD_ASSERT (s
!= NULL
);
2733 /* We also need to make an entry in the .rel.plt section. */
2735 s
= bfd_get_section_by_name (dynobj
, ".rel.plt");
2736 BFD_ASSERT (s
!= NULL
);
2737 s
->_raw_size
+= sizeof (Elf32_External_Rel
);
2742 /* If this is a weak symbol, and there is a real definition, the
2743 processor independent code will have arranged for us to see the
2744 real definition first, and we can just use the same value. */
2745 if (h
->weakdef
!= NULL
)
2747 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
2748 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
2749 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
2750 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
2754 /* This is a reference to a symbol defined by a dynamic object which
2755 is not a function. */
2757 /* If we are creating a shared library, we must presume that the
2758 only references to the symbol are via the global offset table.
2759 For such cases we need not do anything here; the relocations will
2760 be handled correctly by relocate_section. */
2764 /* We must allocate the symbol in our .dynbss section, which will
2765 become part of the .bss section of the executable. There will be
2766 an entry for this symbol in the .dynsym section. The dynamic
2767 object will contain position independent code, so all references
2768 from the dynamic object to this symbol will go through the global
2769 offset table. The dynamic linker will use the .dynsym entry to
2770 determine the address it must put in the global offset table, so
2771 both the dynamic object and the regular object will refer to the
2772 same memory location for the variable. */
2773 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
2774 BFD_ASSERT (s
!= NULL
);
2776 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
2777 copy the initial value out of the dynamic object and into the
2778 runtime process image. We need to remember the offset into the
2779 .rel.bss section we are going to use. */
2780 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2784 srel
= bfd_get_section_by_name (dynobj
, ".rel.bss");
2785 BFD_ASSERT (srel
!= NULL
);
2786 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
2787 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
2790 /* We need to figure out the alignment required for this symbol. I
2791 have no idea how ELF linkers handle this. */
2792 power_of_two
= bfd_log2 (h
->size
);
2793 if (power_of_two
> 3)
2796 /* Apply the required alignment. */
2797 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
2798 (bfd_size_type
) (1 << power_of_two
));
2799 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
2801 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
2805 /* Define the symbol as being at this point in the section. */
2806 h
->root
.u
.def
.section
= s
;
2807 h
->root
.u
.def
.value
= s
->_raw_size
;
2809 /* Increment the section size to make room for the symbol. */
2810 s
->_raw_size
+= h
->size
;
2815 /* Set the sizes of the dynamic sections. */
2818 elf32_arm_size_dynamic_sections (output_bfd
, info
)
2820 struct bfd_link_info
* info
;
2828 dynobj
= elf_hash_table (info
)->dynobj
;
2829 BFD_ASSERT (dynobj
!= NULL
);
2831 if (elf_hash_table (info
)->dynamic_sections_created
)
2833 /* Set the contents of the .interp section to the interpreter. */
2836 s
= bfd_get_section_by_name (dynobj
, ".interp");
2837 BFD_ASSERT (s
!= NULL
);
2838 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2839 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2844 /* We may have created entries in the .rel.got section.
2845 However, if we are not creating the dynamic sections, we will
2846 not actually use these entries. Reset the size of .rel.got,
2847 which will cause it to get stripped from the output file
2849 s
= bfd_get_section_by_name (dynobj
, ".rel.got");
2854 /* If this is a -Bsymbolic shared link, then we need to discard all
2855 PC relative relocs against symbols defined in a regular object.
2856 We allocated space for them in the check_relocs routine, but we
2857 will not fill them in in the relocate_section routine. */
2858 if (info
->shared
&& info
->symbolic
)
2859 elf32_arm_link_hash_traverse (elf32_arm_hash_table (info
),
2860 elf32_arm_discard_copies
,
2863 /* The check_relocs and adjust_dynamic_symbol entry points have
2864 determined the sizes of the various dynamic sections. Allocate
2869 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2874 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2877 /* It's OK to base decisions on the section name, because none
2878 of the dynobj section names depend upon the input files. */
2879 name
= bfd_get_section_name (dynobj
, s
);
2883 if (strcmp (name
, ".plt") == 0)
2885 if (s
->_raw_size
== 0)
2887 /* Strip this section if we don't need it; see the
2893 /* Remember whether there is a PLT. */
2897 else if (strncmp (name
, ".rel", 4) == 0)
2899 if (s
->_raw_size
== 0)
2901 /* If we don't need this section, strip it from the
2902 output file. This is mostly to handle .rel.bss and
2903 .rel.plt. We must create both sections in
2904 create_dynamic_sections, because they must be created
2905 before the linker maps input sections to output
2906 sections. The linker does that before
2907 adjust_dynamic_symbol is called, and it is that
2908 function which decides whether anything needs to go
2909 into these sections. */
2916 /* Remember whether there are any reloc sections other
2918 if (strcmp (name
, ".rel.plt") != 0)
2920 const char *outname
;
2924 /* If this relocation section applies to a read only
2925 section, then we probably need a DT_TEXTREL
2926 entry. The entries in the .rel.plt section
2927 really apply to the .got section, which we
2928 created ourselves and so know is not readonly. */
2929 outname
= bfd_get_section_name (output_bfd
,
2931 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
2934 && (target
->flags
& SEC_READONLY
) != 0
2935 && (target
->flags
& SEC_ALLOC
) != 0)
2939 /* We use the reloc_count field as a counter if we need
2940 to copy relocs into the output file. */
2944 else if (strncmp (name
, ".got", 4) != 0)
2946 /* It's not one of our sections, so don't allocate space. */
2954 for (spp
= &s
->output_section
->owner
->sections
;
2955 *spp
!= s
->output_section
;
2956 spp
= &(*spp
)->next
)
2958 *spp
= s
->output_section
->next
;
2959 --s
->output_section
->owner
->section_count
;
2964 /* Allocate memory for the section contents. */
2965 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
2966 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
2970 if (elf_hash_table (info
)->dynamic_sections_created
)
2972 /* Add some entries to the .dynamic section. We fill in the
2973 values later, in elf32_arm_finish_dynamic_sections, but we
2974 must add the entries now so that we get the correct size for
2975 the .dynamic section. The DT_DEBUG entry is filled in by the
2976 dynamic linker and used by the debugger. */
2979 if (! bfd_elf32_add_dynamic_entry (info
, DT_DEBUG
, 0))
2985 if ( ! bfd_elf32_add_dynamic_entry (info
, DT_PLTGOT
, 0)
2986 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
2987 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTREL
, DT_REL
)
2988 || ! bfd_elf32_add_dynamic_entry (info
, DT_JMPREL
, 0))
2994 if ( ! bfd_elf32_add_dynamic_entry (info
, DT_REL
, 0)
2995 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELSZ
, 0)
2996 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELENT
,
2997 sizeof (Elf32_External_Rel
)))
3003 if (! bfd_elf32_add_dynamic_entry (info
, DT_TEXTREL
, 0))
3005 info
->flags
|= DF_TEXTREL
;
3012 /* This function is called via elf32_arm_link_hash_traverse if we are
3013 creating a shared object with -Bsymbolic. It discards the space
3014 allocated to copy PC relative relocs against symbols which are
3015 defined in regular objects. We allocated space for them in the
3016 check_relocs routine, but we won't fill them in in the
3017 relocate_section routine. */
3020 elf32_arm_discard_copies (h
, ignore
)
3021 struct elf32_arm_link_hash_entry
* h
;
3022 PTR ignore ATTRIBUTE_UNUSED
;
3024 struct elf32_arm_pcrel_relocs_copied
* s
;
3026 /* We only discard relocs for symbols defined in a regular object. */
3027 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3030 for (s
= h
->pcrel_relocs_copied
; s
!= NULL
; s
= s
->next
)
3031 s
->section
->_raw_size
-= s
->count
* sizeof (Elf32_External_Rel
);
3036 /* Finish up dynamic symbol handling. We set the contents of various
3037 dynamic sections here. */
3040 elf32_arm_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
3042 struct bfd_link_info
* info
;
3043 struct elf_link_hash_entry
* h
;
3044 Elf_Internal_Sym
* sym
;
3048 dynobj
= elf_hash_table (info
)->dynobj
;
3050 if (h
->plt
.offset
!= (bfd_vma
) -1)
3057 Elf_Internal_Rel rel
;
3059 /* This symbol has an entry in the procedure linkage table. Set
3062 BFD_ASSERT (h
->dynindx
!= -1);
3064 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3065 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3066 srel
= bfd_get_section_by_name (dynobj
, ".rel.plt");
3067 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
3069 /* Get the index in the procedure linkage table which
3070 corresponds to this symbol. This is the index of this symbol
3071 in all the symbols for which we are making plt entries. The
3072 first entry in the procedure linkage table is reserved. */
3073 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
3075 /* Get the offset into the .got table of the entry that
3076 corresponds to this function. Each .got entry is 4 bytes.
3077 The first three are reserved. */
3078 got_offset
= (plt_index
+ 3) * 4;
3080 /* Fill in the entry in the procedure linkage table. */
3081 memcpy (splt
->contents
+ h
->plt
.offset
,
3082 elf32_arm_plt_entry
,
3084 bfd_put_32 (output_bfd
,
3085 (sgot
->output_section
->vma
3086 + sgot
->output_offset
3088 - splt
->output_section
->vma
3089 - splt
->output_offset
3090 - h
->plt
.offset
- 12),
3091 splt
->contents
+ h
->plt
.offset
+ 12);
3093 /* Fill in the entry in the global offset table. */
3094 bfd_put_32 (output_bfd
,
3095 (splt
->output_section
->vma
3096 + splt
->output_offset
),
3097 sgot
->contents
+ got_offset
);
3099 /* Fill in the entry in the .rel.plt section. */
3100 rel
.r_offset
= (sgot
->output_section
->vma
3101 + sgot
->output_offset
3103 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_JUMP_SLOT
);
3104 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3105 ((Elf32_External_Rel
*) srel
->contents
3108 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3110 /* Mark the symbol as undefined, rather than as defined in
3111 the .plt section. Leave the value alone. */
3112 sym
->st_shndx
= SHN_UNDEF
;
3116 if (h
->got
.offset
!= (bfd_vma
) -1)
3120 Elf_Internal_Rel rel
;
3122 /* This symbol has an entry in the global offset table. Set it
3124 sgot
= bfd_get_section_by_name (dynobj
, ".got");
3125 srel
= bfd_get_section_by_name (dynobj
, ".rel.got");
3126 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
3128 rel
.r_offset
= (sgot
->output_section
->vma
3129 + sgot
->output_offset
3130 + (h
->got
.offset
&~ 1));
3132 /* If this is a -Bsymbolic link, and the symbol is defined
3133 locally, we just want to emit a RELATIVE reloc. The entry in
3134 the global offset table will already have been initialized in
3135 the relocate_section function. */
3137 && (info
->symbolic
|| h
->dynindx
== -1)
3138 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
3139 rel
.r_info
= ELF32_R_INFO (0, R_ARM_RELATIVE
);
3142 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
3143 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_GLOB_DAT
);
3146 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3147 ((Elf32_External_Rel
*) srel
->contents
3148 + srel
->reloc_count
));
3149 ++srel
->reloc_count
;
3152 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
3155 Elf_Internal_Rel rel
;
3157 /* This symbol needs a copy reloc. Set it up. */
3158 BFD_ASSERT (h
->dynindx
!= -1
3159 && (h
->root
.type
== bfd_link_hash_defined
3160 || h
->root
.type
== bfd_link_hash_defweak
));
3162 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
3164 BFD_ASSERT (s
!= NULL
);
3166 rel
.r_offset
= (h
->root
.u
.def
.value
3167 + h
->root
.u
.def
.section
->output_section
->vma
3168 + h
->root
.u
.def
.section
->output_offset
);
3169 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_ARM_COPY
);
3170 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
3171 ((Elf32_External_Rel
*) s
->contents
3176 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3177 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3178 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
3179 sym
->st_shndx
= SHN_ABS
;
3184 /* Finish up the dynamic sections. */
3187 elf32_arm_finish_dynamic_sections (output_bfd
, info
)
3189 struct bfd_link_info
* info
;
3195 dynobj
= elf_hash_table (info
)->dynobj
;
3197 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
3198 BFD_ASSERT (sgot
!= NULL
);
3199 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3201 if (elf_hash_table (info
)->dynamic_sections_created
)
3204 Elf32_External_Dyn
*dyncon
, *dynconend
;
3206 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3207 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3209 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3210 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
3212 for (; dyncon
< dynconend
; dyncon
++)
3214 Elf_Internal_Dyn dyn
;
3218 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3231 s
= bfd_get_section_by_name (output_bfd
, name
);
3232 BFD_ASSERT (s
!= NULL
);
3233 dyn
.d_un
.d_ptr
= s
->vma
;
3234 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3238 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3239 BFD_ASSERT (s
!= NULL
);
3240 if (s
->_cooked_size
!= 0)
3241 dyn
.d_un
.d_val
= s
->_cooked_size
;
3243 dyn
.d_un
.d_val
= s
->_raw_size
;
3244 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3248 /* My reading of the SVR4 ABI indicates that the
3249 procedure linkage table relocs (DT_JMPREL) should be
3250 included in the overall relocs (DT_REL). This is
3251 what Solaris does. However, UnixWare can not handle
3252 that case. Therefore, we override the DT_RELSZ entry
3253 here to make it not include the JMPREL relocs. Since
3254 the linker script arranges for .rel.plt to follow all
3255 other relocation sections, we don't have to worry
3256 about changing the DT_REL entry. */
3257 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
3260 if (s
->_cooked_size
!= 0)
3261 dyn
.d_un
.d_val
-= s
->_cooked_size
;
3263 dyn
.d_un
.d_val
-= s
->_raw_size
;
3265 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3270 /* Fill in the first entry in the procedure linkage table. */
3271 if (splt
->_raw_size
> 0)
3272 memcpy (splt
->contents
, elf32_arm_plt0_entry
, PLT_ENTRY_SIZE
);
3274 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3275 really seem like the right value. */
3276 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
3279 /* Fill in the first three entries in the global offset table. */
3280 if (sgot
->_raw_size
> 0)
3283 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
3285 bfd_put_32 (output_bfd
,
3286 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3288 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
3289 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
3292 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
3298 elf32_arm_post_process_headers (abfd
, link_info
)
3300 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
;
3302 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
3304 i_ehdrp
= elf_elfheader (abfd
);
3306 i_ehdrp
->e_ident
[EI_OSABI
] = ARM_ELF_OS_ABI_VERSION
;
3307 i_ehdrp
->e_ident
[EI_ABIVERSION
] = ARM_ELF_ABI_VERSION
;
3311 #define ELF_ARCH bfd_arch_arm
3312 #define ELF_MACHINE_CODE EM_ARM
3313 #define ELF_MAXPAGESIZE 0x8000
3316 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
3317 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
3318 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
3319 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
3320 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
3321 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
3322 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
3324 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
3325 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
3326 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
3327 #define elf_backend_check_relocs elf32_arm_check_relocs
3328 #define elf_backend_relocate_section elf32_arm_relocate_section
3329 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
3330 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
3331 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
3332 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
3333 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
3334 #define elf_backend_post_process_headers elf32_arm_post_process_headers
3336 #define elf_backend_can_gc_sections 1
3337 #define elf_backend_plt_readonly 1
3338 #define elf_backend_want_got_plt 1
3339 #define elf_backend_want_plt_sym 0
3341 #define elf_backend_got_header_size 12
3342 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
3344 #include "elf32-target.h"