Fix typo.
[binutils.git] / bfd / elf32-arm.h
blob3a5939dca3281a4ec300174d994bc52b2891b2c7
1 /* 32-bit ELF support for ARM
2 Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20 typedef unsigned long int insn32;
21 typedef unsigned short int insn16;
23 static boolean elf32_arm_set_private_flags
24 PARAMS ((bfd *, flagword));
25 static boolean elf32_arm_copy_private_bfd_data
26 PARAMS ((bfd *, bfd *));
27 static boolean elf32_arm_merge_private_bfd_data
28 PARAMS ((bfd *, bfd *));
29 static boolean elf32_arm_print_private_bfd_data
30 PARAMS ((bfd *, PTR));
31 static int elf32_arm_get_symbol_type
32 PARAMS (( Elf_Internal_Sym *, int));
33 static struct bfd_link_hash_table *elf32_arm_link_hash_table_create
34 PARAMS ((bfd *));
35 static bfd_reloc_status_type elf32_arm_final_link_relocate
36 PARAMS ((reloc_howto_type *, bfd *, bfd *, asection *, bfd_byte *,
37 Elf_Internal_Rela *, bfd_vma, struct bfd_link_info *, asection *,
38 const char *, int, struct elf_link_hash_entry *));
39 static insn32 insert_thumb_branch
40 PARAMS ((insn32, int));
41 static struct elf_link_hash_entry *find_thumb_glue
42 PARAMS ((struct bfd_link_info *, const char *, bfd *));
43 static struct elf_link_hash_entry *find_arm_glue
44 PARAMS ((struct bfd_link_info *, const char *, bfd *));
45 static void record_arm_to_thumb_glue
46 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
47 static void record_thumb_to_arm_glue
48 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
49 static void elf32_arm_post_process_headers
50 PARAMS ((bfd *, struct bfd_link_info *));
51 static int elf32_arm_to_thumb_stub
52 PARAMS ((struct bfd_link_info *, const char *, bfd *, bfd *, asection *,
53 bfd_byte *, asection *, bfd_vma, bfd_signed_vma, bfd_vma));
54 static int elf32_thumb_to_arm_stub
55 PARAMS ((struct bfd_link_info *, const char *, bfd *, bfd *, asection *,
56 bfd_byte *, asection *, bfd_vma, bfd_signed_vma, bfd_vma));
57 static boolean elf32_arm_relocate_section
58 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
59 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
60 static asection * elf32_arm_gc_mark_hook
61 PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *,
62 struct elf_link_hash_entry *, Elf_Internal_Sym *));
63 static boolean elf32_arm_gc_sweep_hook
64 PARAMS ((bfd *, struct bfd_link_info *, asection *,
65 const Elf_Internal_Rela *));
66 static boolean elf32_arm_check_relocs
67 PARAMS ((bfd *, struct bfd_link_info *, asection *,
68 const Elf_Internal_Rela *));
69 static boolean elf32_arm_find_nearest_line
70 PARAMS ((bfd *, asection *, asymbol **, bfd_vma, const char **,
71 const char **, unsigned int *));
72 static boolean elf32_arm_adjust_dynamic_symbol
73 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
74 static boolean elf32_arm_size_dynamic_sections
75 PARAMS ((bfd *, struct bfd_link_info *));
76 static boolean elf32_arm_finish_dynamic_symbol
77 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
78 Elf_Internal_Sym *));
79 static boolean elf32_arm_finish_dynamic_sections
80 PARAMS ((bfd *, struct bfd_link_info *));
81 static struct bfd_hash_entry * elf32_arm_link_hash_newfunc
82 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
83 #ifdef USE_REL
84 static void arm_add_to_rel
85 PARAMS ((bfd *, bfd_byte *, reloc_howto_type *, bfd_signed_vma));
86 #endif
88 boolean bfd_elf32_arm_allocate_interworking_sections
89 PARAMS ((struct bfd_link_info *));
90 boolean bfd_elf32_arm_get_bfd_for_interworking
91 PARAMS ((bfd *, struct bfd_link_info *));
92 boolean bfd_elf32_arm_process_before_allocation
93 PARAMS ((bfd *, struct bfd_link_info *, int));
94 static enum elf_reloc_type_class elf32_arm_reloc_type_class
95 PARAMS ((const Elf_Internal_Rela *));
97 #define INTERWORK_FLAG(abfd) (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK)
99 /* The linker script knows the section names for placement.
100 The entry_names are used to do simple name mangling on the stubs.
101 Given a function name, and its type, the stub can be found. The
102 name can be changed. The only requirement is the %s be present. */
103 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
104 #define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
106 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
107 #define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
109 /* The name of the dynamic interpreter. This is put in the .interp
110 section. */
111 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
113 /* The size in bytes of an entry in the procedure linkage table. */
114 #define PLT_ENTRY_SIZE 16
116 /* The first entry in a procedure linkage table looks like
117 this. It is set up so that any shared library function that is
118 called before the relocation has been set up calls the dynamic
119 linker first. */
120 static const bfd_vma elf32_arm_plt0_entry [PLT_ENTRY_SIZE / 4] =
122 0xe52de004, /* str lr, [sp, #-4]! */
123 0xe59fe010, /* ldr lr, [pc, #16] */
124 0xe08fe00e, /* add lr, pc, lr */
125 0xe5bef008 /* ldr pc, [lr, #8]! */
128 /* Subsequent entries in a procedure linkage table look like
129 this. */
130 static const bfd_vma elf32_arm_plt_entry [PLT_ENTRY_SIZE / 4] =
132 0xe59fc004, /* ldr ip, [pc, #4] */
133 0xe08fc00c, /* add ip, pc, ip */
134 0xe59cf000, /* ldr pc, [ip] */
135 0x00000000 /* offset to symbol in got */
138 /* The ARM linker needs to keep track of the number of relocs that it
139 decides to copy in check_relocs for each symbol. This is so that
140 it can discard PC relative relocs if it doesn't need them when
141 linking with -Bsymbolic. We store the information in a field
142 extending the regular ELF linker hash table. */
144 /* This structure keeps track of the number of PC relative relocs we
145 have copied for a given symbol. */
146 struct elf32_arm_pcrel_relocs_copied
148 /* Next section. */
149 struct elf32_arm_pcrel_relocs_copied * next;
150 /* A section in dynobj. */
151 asection * section;
152 /* Number of relocs copied in this section. */
153 bfd_size_type count;
156 /* Arm ELF linker hash entry. */
157 struct elf32_arm_link_hash_entry
159 struct elf_link_hash_entry root;
161 /* Number of PC relative relocs copied for this symbol. */
162 struct elf32_arm_pcrel_relocs_copied * pcrel_relocs_copied;
165 /* Declare this now that the above structures are defined. */
166 static boolean elf32_arm_discard_copies
167 PARAMS ((struct elf32_arm_link_hash_entry *, PTR));
169 /* Traverse an arm ELF linker hash table. */
170 #define elf32_arm_link_hash_traverse(table, func, info) \
171 (elf_link_hash_traverse \
172 (&(table)->root, \
173 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
174 (info)))
176 /* Get the ARM elf linker hash table from a link_info structure. */
177 #define elf32_arm_hash_table(info) \
178 ((struct elf32_arm_link_hash_table *) ((info)->hash))
180 /* ARM ELF linker hash table. */
181 struct elf32_arm_link_hash_table
183 /* The main hash table. */
184 struct elf_link_hash_table root;
186 /* The size in bytes of the section containg the Thumb-to-ARM glue. */
187 bfd_size_type thumb_glue_size;
189 /* The size in bytes of the section containg the ARM-to-Thumb glue. */
190 bfd_size_type arm_glue_size;
192 /* An arbitary input BFD chosen to hold the glue sections. */
193 bfd * bfd_of_glue_owner;
195 /* A boolean indicating whether knowledge of the ARM's pipeline
196 length should be applied by the linker. */
197 int no_pipeline_knowledge;
200 /* Create an entry in an ARM ELF linker hash table. */
202 static struct bfd_hash_entry *
203 elf32_arm_link_hash_newfunc (entry, table, string)
204 struct bfd_hash_entry * entry;
205 struct bfd_hash_table * table;
206 const char * string;
208 struct elf32_arm_link_hash_entry * ret =
209 (struct elf32_arm_link_hash_entry *) entry;
211 /* Allocate the structure if it has not already been allocated by a
212 subclass. */
213 if (ret == (struct elf32_arm_link_hash_entry *) NULL)
214 ret = ((struct elf32_arm_link_hash_entry *)
215 bfd_hash_allocate (table,
216 sizeof (struct elf32_arm_link_hash_entry)));
217 if (ret == (struct elf32_arm_link_hash_entry *) NULL)
218 return (struct bfd_hash_entry *) ret;
220 /* Call the allocation method of the superclass. */
221 ret = ((struct elf32_arm_link_hash_entry *)
222 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
223 table, string));
224 if (ret != (struct elf32_arm_link_hash_entry *) NULL)
225 ret->pcrel_relocs_copied = NULL;
227 return (struct bfd_hash_entry *) ret;
230 /* Create an ARM elf linker hash table. */
232 static struct bfd_link_hash_table *
233 elf32_arm_link_hash_table_create (abfd)
234 bfd *abfd;
236 struct elf32_arm_link_hash_table *ret;
237 bfd_size_type amt = sizeof (struct elf32_arm_link_hash_table);
239 ret = (struct elf32_arm_link_hash_table *) bfd_alloc (abfd, amt);
240 if (ret == (struct elf32_arm_link_hash_table *) NULL)
241 return NULL;
243 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
244 elf32_arm_link_hash_newfunc))
246 bfd_release (abfd, ret);
247 return NULL;
250 ret->thumb_glue_size = 0;
251 ret->arm_glue_size = 0;
252 ret->bfd_of_glue_owner = NULL;
253 ret->no_pipeline_knowledge = 0;
255 return &ret->root.root;
258 /* Locate the Thumb encoded calling stub for NAME. */
260 static struct elf_link_hash_entry *
261 find_thumb_glue (link_info, name, input_bfd)
262 struct bfd_link_info *link_info;
263 const char *name;
264 bfd *input_bfd;
266 char *tmp_name;
267 struct elf_link_hash_entry *hash;
268 struct elf32_arm_link_hash_table *hash_table;
270 /* We need a pointer to the armelf specific hash table. */
271 hash_table = elf32_arm_hash_table (link_info);
273 tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
274 + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
276 BFD_ASSERT (tmp_name);
278 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
280 hash = elf_link_hash_lookup
281 (&(hash_table)->root, tmp_name, false, false, true);
283 if (hash == NULL)
284 /* xgettext:c-format */
285 (*_bfd_error_handler) (_("%s: unable to find THUMB glue '%s' for `%s'"),
286 bfd_archive_filename (input_bfd), tmp_name, name);
288 free (tmp_name);
290 return hash;
293 /* Locate the ARM encoded calling stub for NAME. */
295 static struct elf_link_hash_entry *
296 find_arm_glue (link_info, name, input_bfd)
297 struct bfd_link_info *link_info;
298 const char *name;
299 bfd *input_bfd;
301 char *tmp_name;
302 struct elf_link_hash_entry *myh;
303 struct elf32_arm_link_hash_table *hash_table;
305 /* We need a pointer to the elfarm specific hash table. */
306 hash_table = elf32_arm_hash_table (link_info);
308 tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
309 + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
311 BFD_ASSERT (tmp_name);
313 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
315 myh = elf_link_hash_lookup
316 (&(hash_table)->root, tmp_name, false, false, true);
318 if (myh == NULL)
319 /* xgettext:c-format */
320 (*_bfd_error_handler) (_("%s: unable to find ARM glue '%s' for `%s'"),
321 bfd_archive_filename (input_bfd), tmp_name, name);
323 free (tmp_name);
325 return myh;
328 /* ARM->Thumb glue:
330 .arm
331 __func_from_arm:
332 ldr r12, __func_addr
333 bx r12
334 __func_addr:
335 .word func @ behave as if you saw a ARM_32 reloc. */
337 #define ARM2THUMB_GLUE_SIZE 12
338 static const insn32 a2t1_ldr_insn = 0xe59fc000;
339 static const insn32 a2t2_bx_r12_insn = 0xe12fff1c;
340 static const insn32 a2t3_func_addr_insn = 0x00000001;
342 /* Thumb->ARM: Thumb->(non-interworking aware) ARM
344 .thumb .thumb
345 .align 2 .align 2
346 __func_from_thumb: __func_from_thumb:
347 bx pc push {r6, lr}
348 nop ldr r6, __func_addr
349 .arm mov lr, pc
350 __func_change_to_arm: bx r6
351 b func .arm
352 __func_back_to_thumb:
353 ldmia r13! {r6, lr}
354 bx lr
355 __func_addr:
356 .word func */
358 #define THUMB2ARM_GLUE_SIZE 8
359 static const insn16 t2a1_bx_pc_insn = 0x4778;
360 static const insn16 t2a2_noop_insn = 0x46c0;
361 static const insn32 t2a3_b_insn = 0xea000000;
363 static const insn16 t2a1_push_insn = 0xb540;
364 static const insn16 t2a2_ldr_insn = 0x4e03;
365 static const insn16 t2a3_mov_insn = 0x46fe;
366 static const insn16 t2a4_bx_insn = 0x4730;
367 static const insn32 t2a5_pop_insn = 0xe8bd4040;
368 static const insn32 t2a6_bx_insn = 0xe12fff1e;
370 boolean
371 bfd_elf32_arm_allocate_interworking_sections (info)
372 struct bfd_link_info * info;
374 asection * s;
375 bfd_byte * foo;
376 struct elf32_arm_link_hash_table * globals;
378 globals = elf32_arm_hash_table (info);
380 BFD_ASSERT (globals != NULL);
382 if (globals->arm_glue_size != 0)
384 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
386 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
387 ARM2THUMB_GLUE_SECTION_NAME);
389 BFD_ASSERT (s != NULL);
391 foo = (bfd_byte *) bfd_alloc (globals->bfd_of_glue_owner,
392 globals->arm_glue_size);
394 s->_raw_size = s->_cooked_size = globals->arm_glue_size;
395 s->contents = foo;
398 if (globals->thumb_glue_size != 0)
400 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
402 s = bfd_get_section_by_name
403 (globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
405 BFD_ASSERT (s != NULL);
407 foo = (bfd_byte *) bfd_alloc (globals->bfd_of_glue_owner,
408 globals->thumb_glue_size);
410 s->_raw_size = s->_cooked_size = globals->thumb_glue_size;
411 s->contents = foo;
414 return true;
417 static void
418 record_arm_to_thumb_glue (link_info, h)
419 struct bfd_link_info * link_info;
420 struct elf_link_hash_entry * h;
422 const char * name = h->root.root.string;
423 asection * s;
424 char * tmp_name;
425 struct elf_link_hash_entry * myh;
426 struct elf32_arm_link_hash_table * globals;
427 bfd_vma val;
429 globals = elf32_arm_hash_table (link_info);
431 BFD_ASSERT (globals != NULL);
432 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
434 s = bfd_get_section_by_name
435 (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
437 BFD_ASSERT (s != NULL);
439 tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
440 + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
442 BFD_ASSERT (tmp_name);
444 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
446 myh = elf_link_hash_lookup
447 (&(globals)->root, tmp_name, false, false, true);
449 if (myh != NULL)
451 /* We've already seen this guy. */
452 free (tmp_name);
453 return;
456 /* The only trick here is using hash_table->arm_glue_size as the value. Even
457 though the section isn't allocated yet, this is where we will be putting
458 it. */
459 val = globals->arm_glue_size + 1;
460 _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner,
461 tmp_name, BSF_GLOBAL, s, val,
462 NULL, true, false,
463 (struct bfd_link_hash_entry **) &myh);
465 free (tmp_name);
467 globals->arm_glue_size += ARM2THUMB_GLUE_SIZE;
469 return;
472 static void
473 record_thumb_to_arm_glue (link_info, h)
474 struct bfd_link_info *link_info;
475 struct elf_link_hash_entry *h;
477 const char *name = h->root.root.string;
478 asection *s;
479 char *tmp_name;
480 struct elf_link_hash_entry *myh;
481 struct elf32_arm_link_hash_table *hash_table;
482 char bind;
483 bfd_vma val;
485 hash_table = elf32_arm_hash_table (link_info);
487 BFD_ASSERT (hash_table != NULL);
488 BFD_ASSERT (hash_table->bfd_of_glue_owner != NULL);
490 s = bfd_get_section_by_name
491 (hash_table->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
493 BFD_ASSERT (s != NULL);
495 tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
496 + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
498 BFD_ASSERT (tmp_name);
500 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
502 myh = elf_link_hash_lookup
503 (&(hash_table)->root, tmp_name, false, false, true);
505 if (myh != NULL)
507 /* We've already seen this guy. */
508 free (tmp_name);
509 return;
512 val = hash_table->thumb_glue_size + 1;
513 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
514 tmp_name, BSF_GLOBAL, s, val,
515 NULL, true, false,
516 (struct bfd_link_hash_entry **) &myh);
518 /* If we mark it 'Thumb', the disassembler will do a better job. */
519 bind = ELF_ST_BIND (myh->type);
520 myh->type = ELF_ST_INFO (bind, STT_ARM_TFUNC);
522 free (tmp_name);
524 #define CHANGE_TO_ARM "__%s_change_to_arm"
525 #define BACK_FROM_ARM "__%s_back_from_arm"
527 /* Allocate another symbol to mark where we switch to Arm mode. */
528 tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
529 + strlen (CHANGE_TO_ARM) + 1);
531 BFD_ASSERT (tmp_name);
533 sprintf (tmp_name, CHANGE_TO_ARM, name);
535 myh = NULL;
537 val = hash_table->thumb_glue_size + 4,
538 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
539 tmp_name, BSF_LOCAL, s, val,
540 NULL, true, false,
541 (struct bfd_link_hash_entry **) &myh);
543 free (tmp_name);
545 hash_table->thumb_glue_size += THUMB2ARM_GLUE_SIZE;
547 return;
550 /* Select a BFD to be used to hold the sections used by the glue code.
551 This function is called from the linker scripts in ld/emultempl/
552 {armelf/pe}.em */
554 boolean
555 bfd_elf32_arm_get_bfd_for_interworking (abfd, info)
556 bfd *abfd;
557 struct bfd_link_info *info;
559 struct elf32_arm_link_hash_table *globals;
560 flagword flags;
561 asection *sec;
563 /* If we are only performing a partial link do not bother
564 getting a bfd to hold the glue. */
565 if (info->relocateable)
566 return true;
568 globals = elf32_arm_hash_table (info);
570 BFD_ASSERT (globals != NULL);
572 if (globals->bfd_of_glue_owner != NULL)
573 return true;
575 sec = bfd_get_section_by_name (abfd, ARM2THUMB_GLUE_SECTION_NAME);
577 if (sec == NULL)
579 /* Note: we do not include the flag SEC_LINKER_CREATED, as this
580 will prevent elf_link_input_bfd() from processing the contents
581 of this section. */
582 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE | SEC_READONLY;
584 sec = bfd_make_section (abfd, ARM2THUMB_GLUE_SECTION_NAME);
586 if (sec == NULL
587 || !bfd_set_section_flags (abfd, sec, flags)
588 || !bfd_set_section_alignment (abfd, sec, 2))
589 return false;
591 /* Set the gc mark to prevent the section from being removed by garbage
592 collection, despite the fact that no relocs refer to this section. */
593 sec->gc_mark = 1;
596 sec = bfd_get_section_by_name (abfd, THUMB2ARM_GLUE_SECTION_NAME);
598 if (sec == NULL)
600 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE | SEC_READONLY;
602 sec = bfd_make_section (abfd, THUMB2ARM_GLUE_SECTION_NAME);
604 if (sec == NULL
605 || !bfd_set_section_flags (abfd, sec, flags)
606 || !bfd_set_section_alignment (abfd, sec, 2))
607 return false;
609 sec->gc_mark = 1;
612 /* Save the bfd for later use. */
613 globals->bfd_of_glue_owner = abfd;
615 return true;
618 boolean
619 bfd_elf32_arm_process_before_allocation (abfd, link_info, no_pipeline_knowledge)
620 bfd *abfd;
621 struct bfd_link_info *link_info;
622 int no_pipeline_knowledge;
624 Elf_Internal_Shdr *symtab_hdr;
625 Elf_Internal_Rela *free_relocs = NULL;
626 Elf_Internal_Rela *irel, *irelend;
627 bfd_byte *contents = NULL;
628 bfd_byte *free_contents = NULL;
629 Elf32_External_Sym *extsyms = NULL;
630 Elf32_External_Sym *free_extsyms = NULL;
632 asection *sec;
633 struct elf32_arm_link_hash_table *globals;
635 /* If we are only performing a partial link do not bother
636 to construct any glue. */
637 if (link_info->relocateable)
638 return true;
640 /* Here we have a bfd that is to be included on the link. We have a hook
641 to do reloc rummaging, before section sizes are nailed down. */
642 globals = elf32_arm_hash_table (link_info);
644 BFD_ASSERT (globals != NULL);
645 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
647 globals->no_pipeline_knowledge = no_pipeline_knowledge;
649 /* Rummage around all the relocs and map the glue vectors. */
650 sec = abfd->sections;
652 if (sec == NULL)
653 return true;
655 for (; sec != NULL; sec = sec->next)
657 if (sec->reloc_count == 0)
658 continue;
660 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
662 /* Load the relocs. */
663 irel = (_bfd_elf32_link_read_relocs (abfd, sec, (PTR) NULL,
664 (Elf_Internal_Rela *) NULL, false));
666 BFD_ASSERT (irel != 0);
668 irelend = irel + sec->reloc_count;
669 for (; irel < irelend; irel++)
671 long r_type;
672 unsigned long r_index;
674 struct elf_link_hash_entry *h;
676 r_type = ELF32_R_TYPE (irel->r_info);
677 r_index = ELF32_R_SYM (irel->r_info);
679 /* These are the only relocation types we care about. */
680 if ( r_type != R_ARM_PC24
681 && r_type != R_ARM_THM_PC22)
682 continue;
684 /* Get the section contents if we haven't done so already. */
685 if (contents == NULL)
687 /* Get cached copy if it exists. */
688 if (elf_section_data (sec)->this_hdr.contents != NULL)
689 contents = elf_section_data (sec)->this_hdr.contents;
690 else
692 /* Go get them off disk. */
693 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
694 if (contents == NULL)
695 goto error_return;
697 free_contents = contents;
699 if (!bfd_get_section_contents (abfd, sec, contents,
700 (file_ptr) 0, sec->_raw_size))
701 goto error_return;
705 /* Read this BFD's symbols if we haven't done so already. */
706 if (extsyms == NULL)
708 /* Get cached copy if it exists. */
709 if (symtab_hdr->contents != NULL)
710 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
711 else
713 /* Go get them off disk. */
714 extsyms = ((Elf32_External_Sym *)
715 bfd_malloc (symtab_hdr->sh_size));
716 if (extsyms == NULL)
717 goto error_return;
719 free_extsyms = extsyms;
721 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
722 || (bfd_bread (extsyms, symtab_hdr->sh_size, abfd)
723 != symtab_hdr->sh_size))
724 goto error_return;
728 /* If the relocation is not against a symbol it cannot concern us. */
729 h = NULL;
731 /* We don't care about local symbols. */
732 if (r_index < symtab_hdr->sh_info)
733 continue;
735 /* This is an external symbol. */
736 r_index -= symtab_hdr->sh_info;
737 h = (struct elf_link_hash_entry *)
738 elf_sym_hashes (abfd)[r_index];
740 /* If the relocation is against a static symbol it must be within
741 the current section and so cannot be a cross ARM/Thumb relocation. */
742 if (h == NULL)
743 continue;
745 switch (r_type)
747 case R_ARM_PC24:
748 /* This one is a call from arm code. We need to look up
749 the target of the call. If it is a thumb target, we
750 insert glue. */
751 if (ELF_ST_TYPE(h->type) == STT_ARM_TFUNC)
752 record_arm_to_thumb_glue (link_info, h);
753 break;
755 case R_ARM_THM_PC22:
756 /* This one is a call from thumb code. We look
757 up the target of the call. If it is not a thumb
758 target, we insert glue. */
759 if (ELF_ST_TYPE (h->type) != STT_ARM_TFUNC)
760 record_thumb_to_arm_glue (link_info, h);
761 break;
763 default:
764 break;
769 return true;
771 error_return:
772 if (free_relocs != NULL)
773 free (free_relocs);
774 if (free_contents != NULL)
775 free (free_contents);
776 if (free_extsyms != NULL)
777 free (free_extsyms);
779 return false;
782 /* The thumb form of a long branch is a bit finicky, because the offset
783 encoding is split over two fields, each in it's own instruction. They
784 can occur in any order. So given a thumb form of long branch, and an
785 offset, insert the offset into the thumb branch and return finished
786 instruction.
788 It takes two thumb instructions to encode the target address. Each has
789 11 bits to invest. The upper 11 bits are stored in one (identifed by
790 H-0.. see below), the lower 11 bits are stored in the other (identified
791 by H-1).
793 Combine together and shifted left by 1 (it's a half word address) and
794 there you have it.
796 Op: 1111 = F,
797 H-0, upper address-0 = 000
798 Op: 1111 = F,
799 H-1, lower address-0 = 800
801 They can be ordered either way, but the arm tools I've seen always put
802 the lower one first. It probably doesn't matter. krk@cygnus.com
804 XXX: Actually the order does matter. The second instruction (H-1)
805 moves the computed address into the PC, so it must be the second one
806 in the sequence. The problem, however is that whilst little endian code
807 stores the instructions in HI then LOW order, big endian code does the
808 reverse. nickc@cygnus.com. */
810 #define LOW_HI_ORDER 0xF800F000
811 #define HI_LOW_ORDER 0xF000F800
813 static insn32
814 insert_thumb_branch (br_insn, rel_off)
815 insn32 br_insn;
816 int rel_off;
818 unsigned int low_bits;
819 unsigned int high_bits;
821 BFD_ASSERT ((rel_off & 1) != 1);
823 rel_off >>= 1; /* Half word aligned address. */
824 low_bits = rel_off & 0x000007FF; /* The bottom 11 bits. */
825 high_bits = (rel_off >> 11) & 0x000007FF; /* The top 11 bits. */
827 if ((br_insn & LOW_HI_ORDER) == LOW_HI_ORDER)
828 br_insn = LOW_HI_ORDER | (low_bits << 16) | high_bits;
829 else if ((br_insn & HI_LOW_ORDER) == HI_LOW_ORDER)
830 br_insn = HI_LOW_ORDER | (high_bits << 16) | low_bits;
831 else
832 /* FIXME: abort is probably not the right call. krk@cygnus.com */
833 abort (); /* error - not a valid branch instruction form. */
835 return br_insn;
838 /* Thumb code calling an ARM function. */
840 static int
841 elf32_thumb_to_arm_stub (info, name, input_bfd, output_bfd, input_section,
842 hit_data, sym_sec, offset, addend, val)
843 struct bfd_link_info * info;
844 const char * name;
845 bfd * input_bfd;
846 bfd * output_bfd;
847 asection * input_section;
848 bfd_byte * hit_data;
849 asection * sym_sec;
850 bfd_vma offset;
851 bfd_signed_vma addend;
852 bfd_vma val;
854 asection * s = 0;
855 bfd_vma my_offset;
856 unsigned long int tmp;
857 long int ret_offset;
858 struct elf_link_hash_entry * myh;
859 struct elf32_arm_link_hash_table * globals;
861 myh = find_thumb_glue (info, name, input_bfd);
862 if (myh == NULL)
863 return false;
865 globals = elf32_arm_hash_table (info);
867 BFD_ASSERT (globals != NULL);
868 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
870 my_offset = myh->root.u.def.value;
872 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
873 THUMB2ARM_GLUE_SECTION_NAME);
875 BFD_ASSERT (s != NULL);
876 BFD_ASSERT (s->contents != NULL);
877 BFD_ASSERT (s->output_section != NULL);
879 if ((my_offset & 0x01) == 0x01)
881 if (sym_sec != NULL
882 && sym_sec->owner != NULL
883 && !INTERWORK_FLAG (sym_sec->owner))
885 (*_bfd_error_handler)
886 (_("%s(%s): warning: interworking not enabled."),
887 bfd_archive_filename (sym_sec->owner), name);
888 (*_bfd_error_handler)
889 (_(" first occurrence: %s: thumb call to arm"),
890 bfd_archive_filename (input_bfd));
892 return false;
895 --my_offset;
896 myh->root.u.def.value = my_offset;
898 bfd_put_16 (output_bfd, (bfd_vma) t2a1_bx_pc_insn,
899 s->contents + my_offset);
901 bfd_put_16 (output_bfd, (bfd_vma) t2a2_noop_insn,
902 s->contents + my_offset + 2);
904 ret_offset =
905 /* Address of destination of the stub. */
906 ((bfd_signed_vma) val)
907 - ((bfd_signed_vma)
908 /* Offset from the start of the current section to the start of the stubs. */
909 (s->output_offset
910 /* Offset of the start of this stub from the start of the stubs. */
911 + my_offset
912 /* Address of the start of the current section. */
913 + s->output_section->vma)
914 /* The branch instruction is 4 bytes into the stub. */
916 /* ARM branches work from the pc of the instruction + 8. */
917 + 8);
919 bfd_put_32 (output_bfd,
920 (bfd_vma) t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
921 s->contents + my_offset + 4);
924 BFD_ASSERT (my_offset <= globals->thumb_glue_size);
926 /* Now go back and fix up the original BL insn to point
927 to here. */
928 ret_offset = (s->output_offset
929 + my_offset
930 - (input_section->output_offset
931 + offset + addend)
932 - 8);
934 tmp = bfd_get_32 (input_bfd, hit_data
935 - input_section->vma);
937 bfd_put_32 (output_bfd,
938 (bfd_vma) insert_thumb_branch (tmp, ret_offset),
939 hit_data - input_section->vma);
941 return true;
944 /* Arm code calling a Thumb function. */
946 static int
947 elf32_arm_to_thumb_stub (info, name, input_bfd, output_bfd, input_section,
948 hit_data, sym_sec, offset, addend, val)
949 struct bfd_link_info * info;
950 const char * name;
951 bfd * input_bfd;
952 bfd * output_bfd;
953 asection * input_section;
954 bfd_byte * hit_data;
955 asection * sym_sec;
956 bfd_vma offset;
957 bfd_signed_vma addend;
958 bfd_vma val;
960 unsigned long int tmp;
961 bfd_vma my_offset;
962 asection * s;
963 long int ret_offset;
964 struct elf_link_hash_entry * myh;
965 struct elf32_arm_link_hash_table * globals;
967 myh = find_arm_glue (info, name, input_bfd);
968 if (myh == NULL)
969 return false;
971 globals = elf32_arm_hash_table (info);
973 BFD_ASSERT (globals != NULL);
974 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
976 my_offset = myh->root.u.def.value;
977 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
978 ARM2THUMB_GLUE_SECTION_NAME);
979 BFD_ASSERT (s != NULL);
980 BFD_ASSERT (s->contents != NULL);
981 BFD_ASSERT (s->output_section != NULL);
983 if ((my_offset & 0x01) == 0x01)
985 if (sym_sec != NULL
986 && sym_sec->owner != NULL
987 && !INTERWORK_FLAG (sym_sec->owner))
989 (*_bfd_error_handler)
990 (_("%s(%s): warning: interworking not enabled."),
991 bfd_archive_filename (sym_sec->owner), name);
992 (*_bfd_error_handler)
993 (_(" first occurrence: %s: arm call to thumb"),
994 bfd_archive_filename (input_bfd));
997 --my_offset;
998 myh->root.u.def.value = my_offset;
1000 bfd_put_32 (output_bfd, (bfd_vma) a2t1_ldr_insn,
1001 s->contents + my_offset);
1003 bfd_put_32 (output_bfd, (bfd_vma) a2t2_bx_r12_insn,
1004 s->contents + my_offset + 4);
1006 /* It's a thumb address. Add the low order bit. */
1007 bfd_put_32 (output_bfd, val | a2t3_func_addr_insn,
1008 s->contents + my_offset + 8);
1011 BFD_ASSERT (my_offset <= globals->arm_glue_size);
1013 tmp = bfd_get_32 (input_bfd, hit_data);
1014 tmp = tmp & 0xFF000000;
1016 /* Somehow these are both 4 too far, so subtract 8. */
1017 ret_offset = (s->output_offset
1018 + my_offset
1019 + s->output_section->vma
1020 - (input_section->output_offset
1021 + input_section->output_section->vma
1022 + offset + addend)
1023 - 8);
1025 tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
1027 bfd_put_32 (output_bfd, (bfd_vma) tmp, hit_data - input_section->vma);
1029 return true;
1032 /* Perform a relocation as part of a final link. */
1034 static bfd_reloc_status_type
1035 elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
1036 input_section, contents, rel, value,
1037 info, sym_sec, sym_name, sym_flags, h)
1038 reloc_howto_type * howto;
1039 bfd * input_bfd;
1040 bfd * output_bfd;
1041 asection * input_section;
1042 bfd_byte * contents;
1043 Elf_Internal_Rela * rel;
1044 bfd_vma value;
1045 struct bfd_link_info * info;
1046 asection * sym_sec;
1047 const char * sym_name;
1048 int sym_flags;
1049 struct elf_link_hash_entry * h;
1051 unsigned long r_type = howto->type;
1052 unsigned long r_symndx;
1053 bfd_byte * hit_data = contents + rel->r_offset;
1054 bfd * dynobj = NULL;
1055 Elf_Internal_Shdr * symtab_hdr;
1056 struct elf_link_hash_entry ** sym_hashes;
1057 bfd_vma * local_got_offsets;
1058 asection * sgot = NULL;
1059 asection * splt = NULL;
1060 asection * sreloc = NULL;
1061 bfd_vma addend;
1062 bfd_signed_vma signed_addend;
1063 struct elf32_arm_link_hash_table * globals;
1065 /* If the start address has been set, then set the EF_ARM_HASENTRY
1066 flag. Setting this more than once is redundant, but the cost is
1067 not too high, and it keeps the code simple.
1069 The test is done here, rather than somewhere else, because the
1070 start address is only set just before the final link commences.
1072 Note - if the user deliberately sets a start address of 0, the
1073 flag will not be set. */
1074 if (bfd_get_start_address (output_bfd) != 0)
1075 elf_elfheader (output_bfd)->e_flags |= EF_ARM_HASENTRY;
1077 globals = elf32_arm_hash_table (info);
1079 dynobj = elf_hash_table (info)->dynobj;
1080 if (dynobj)
1082 sgot = bfd_get_section_by_name (dynobj, ".got");
1083 splt = bfd_get_section_by_name (dynobj, ".plt");
1085 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1086 sym_hashes = elf_sym_hashes (input_bfd);
1087 local_got_offsets = elf_local_got_offsets (input_bfd);
1088 r_symndx = ELF32_R_SYM (rel->r_info);
1090 #ifdef USE_REL
1091 addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask;
1093 if (addend & ((howto->src_mask + 1) >> 1))
1095 signed_addend = -1;
1096 signed_addend &= ~ howto->src_mask;
1097 signed_addend |= addend;
1099 else
1100 signed_addend = addend;
1101 #else
1102 addend = signed_addend = rel->r_addend;
1103 #endif
1105 switch (r_type)
1107 case R_ARM_NONE:
1108 return bfd_reloc_ok;
1110 case R_ARM_PC24:
1111 case R_ARM_ABS32:
1112 case R_ARM_REL32:
1113 #ifndef OLD_ARM_ABI
1114 case R_ARM_XPC25:
1115 #endif
1116 /* When generating a shared object, these relocations are copied
1117 into the output file to be resolved at run time. */
1118 if (info->shared
1119 && r_symndx != 0
1120 && (r_type != R_ARM_PC24
1121 || (h != NULL
1122 && h->dynindx != -1
1123 && (! info->symbolic
1124 || (h->elf_link_hash_flags
1125 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1127 Elf_Internal_Rel outrel;
1128 boolean skip, relocate;
1130 if (sreloc == NULL)
1132 const char * name;
1134 name = (bfd_elf_string_from_elf_section
1135 (input_bfd,
1136 elf_elfheader (input_bfd)->e_shstrndx,
1137 elf_section_data (input_section)->rel_hdr.sh_name));
1138 if (name == NULL)
1139 return bfd_reloc_notsupported;
1141 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
1142 && strcmp (bfd_get_section_name (input_bfd,
1143 input_section),
1144 name + 4) == 0);
1146 sreloc = bfd_get_section_by_name (dynobj, name);
1147 BFD_ASSERT (sreloc != NULL);
1150 skip = false;
1152 outrel.r_offset =
1153 _bfd_elf_section_offset (output_bfd, info, input_section,
1154 rel->r_offset);
1155 if (outrel.r_offset == (bfd_vma) -1)
1156 skip = true;
1157 outrel.r_offset += (input_section->output_section->vma
1158 + input_section->output_offset);
1160 if (skip)
1162 memset (&outrel, 0, sizeof outrel);
1163 relocate = false;
1165 else if (r_type == R_ARM_PC24)
1167 BFD_ASSERT (h != NULL && h->dynindx != -1);
1168 if ((input_section->flags & SEC_ALLOC) != 0)
1169 relocate = false;
1170 else
1171 relocate = true;
1172 outrel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_PC24);
1174 else
1176 if (h == NULL
1177 || ((info->symbolic || h->dynindx == -1)
1178 && (h->elf_link_hash_flags
1179 & ELF_LINK_HASH_DEF_REGULAR) != 0))
1181 relocate = true;
1182 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
1184 else
1186 BFD_ASSERT (h->dynindx != -1);
1187 if ((input_section->flags & SEC_ALLOC) != 0)
1188 relocate = false;
1189 else
1190 relocate = true;
1191 outrel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_ABS32);
1195 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1196 (((Elf32_External_Rel *)
1197 sreloc->contents)
1198 + sreloc->reloc_count));
1199 ++sreloc->reloc_count;
1201 /* If this reloc is against an external symbol, we do not want to
1202 fiddle with the addend. Otherwise, we need to include the symbol
1203 value so that it becomes an addend for the dynamic reloc. */
1204 if (! relocate)
1205 return bfd_reloc_ok;
1207 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1208 contents, rel->r_offset, value,
1209 (bfd_vma) 0);
1211 else switch (r_type)
1213 #ifndef OLD_ARM_ABI
1214 case R_ARM_XPC25: /* Arm BLX instruction. */
1215 #endif
1216 case R_ARM_PC24: /* Arm B/BL instruction */
1217 #ifndef OLD_ARM_ABI
1218 if (r_type == R_ARM_XPC25)
1220 /* Check for Arm calling Arm function. */
1221 /* FIXME: Should we translate the instruction into a BL
1222 instruction instead ? */
1223 if (sym_flags != STT_ARM_TFUNC)
1224 (*_bfd_error_handler) (_("\
1225 %s: Warning: Arm BLX instruction targets Arm function '%s'."),
1226 bfd_archive_filename (input_bfd),
1227 h ? h->root.root.string : "(local)");
1229 else
1230 #endif
1232 /* Check for Arm calling Thumb function. */
1233 if (sym_flags == STT_ARM_TFUNC)
1235 elf32_arm_to_thumb_stub (info, sym_name, input_bfd, output_bfd,
1236 input_section, hit_data, sym_sec, rel->r_offset,
1237 signed_addend, value);
1238 return bfd_reloc_ok;
1242 if ( strcmp (bfd_get_target (input_bfd), "elf32-littlearm-oabi") == 0
1243 || strcmp (bfd_get_target (input_bfd), "elf32-bigarm-oabi") == 0)
1245 /* The old way of doing things. Trearing the addend as a
1246 byte sized field and adding in the pipeline offset. */
1247 value -= (input_section->output_section->vma
1248 + input_section->output_offset);
1249 value -= rel->r_offset;
1250 value += addend;
1252 if (! globals->no_pipeline_knowledge)
1253 value -= 8;
1255 else
1257 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
1258 where:
1259 S is the address of the symbol in the relocation.
1260 P is address of the instruction being relocated.
1261 A is the addend (extracted from the instruction) in bytes.
1263 S is held in 'value'.
1264 P is the base address of the section containing the instruction
1265 plus the offset of the reloc into that section, ie:
1266 (input_section->output_section->vma +
1267 input_section->output_offset +
1268 rel->r_offset).
1269 A is the addend, converted into bytes, ie:
1270 (signed_addend * 4)
1272 Note: None of these operations have knowledge of the pipeline
1273 size of the processor, thus it is up to the assembler to encode
1274 this information into the addend. */
1275 value -= (input_section->output_section->vma
1276 + input_section->output_offset);
1277 value -= rel->r_offset;
1278 value += (signed_addend << howto->size);
1280 /* Previous versions of this code also used to add in the pipeline
1281 offset here. This is wrong because the linker is not supposed
1282 to know about such things, and one day it might change. In order
1283 to support old binaries that need the old behaviour however, so
1284 we attempt to detect which ABI was used to create the reloc. */
1285 if (! globals->no_pipeline_knowledge)
1287 Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form */
1289 i_ehdrp = elf_elfheader (input_bfd);
1291 if (i_ehdrp->e_ident[EI_OSABI] == 0)
1292 value -= 8;
1296 signed_addend = value;
1297 signed_addend >>= howto->rightshift;
1299 /* It is not an error for an undefined weak reference to be
1300 out of range. Any program that branches to such a symbol
1301 is going to crash anyway, so there is no point worrying
1302 about getting the destination exactly right. */
1303 if (! h || h->root.type != bfd_link_hash_undefweak)
1305 /* Perform a signed range check. */
1306 if ( signed_addend > ((bfd_signed_vma) (howto->dst_mask >> 1))
1307 || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1)))
1308 return bfd_reloc_overflow;
1311 #ifndef OLD_ARM_ABI
1312 /* If necessary set the H bit in the BLX instruction. */
1313 if (r_type == R_ARM_XPC25 && ((value & 2) == 2))
1314 value = (signed_addend & howto->dst_mask)
1315 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask))
1316 | (1 << 24);
1317 else
1318 #endif
1319 value = (signed_addend & howto->dst_mask)
1320 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
1321 break;
1323 case R_ARM_ABS32:
1324 value += addend;
1325 if (sym_flags == STT_ARM_TFUNC)
1326 value |= 1;
1327 break;
1329 case R_ARM_REL32:
1330 value -= (input_section->output_section->vma
1331 + input_section->output_offset + rel->r_offset);
1332 value += addend;
1333 break;
1336 bfd_put_32 (input_bfd, value, hit_data);
1337 return bfd_reloc_ok;
1339 case R_ARM_ABS8:
1340 value += addend;
1341 if ((long) value > 0x7f || (long) value < -0x80)
1342 return bfd_reloc_overflow;
1344 bfd_put_8 (input_bfd, value, hit_data);
1345 return bfd_reloc_ok;
1347 case R_ARM_ABS16:
1348 value += addend;
1350 if ((long) value > 0x7fff || (long) value < -0x8000)
1351 return bfd_reloc_overflow;
1353 bfd_put_16 (input_bfd, value, hit_data);
1354 return bfd_reloc_ok;
1356 case R_ARM_ABS12:
1357 /* Support ldr and str instruction for the arm */
1358 /* Also thumb b (unconditional branch). ??? Really? */
1359 value += addend;
1361 if ((long) value > 0x7ff || (long) value < -0x800)
1362 return bfd_reloc_overflow;
1364 value |= (bfd_get_32 (input_bfd, hit_data) & 0xfffff000);
1365 bfd_put_32 (input_bfd, value, hit_data);
1366 return bfd_reloc_ok;
1368 case R_ARM_THM_ABS5:
1369 /* Support ldr and str instructions for the thumb. */
1370 #ifdef USE_REL
1371 /* Need to refetch addend. */
1372 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
1373 /* ??? Need to determine shift amount from operand size. */
1374 addend >>= howto->rightshift;
1375 #endif
1376 value += addend;
1378 /* ??? Isn't value unsigned? */
1379 if ((long) value > 0x1f || (long) value < -0x10)
1380 return bfd_reloc_overflow;
1382 /* ??? Value needs to be properly shifted into place first. */
1383 value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
1384 bfd_put_16 (input_bfd, value, hit_data);
1385 return bfd_reloc_ok;
1387 #ifndef OLD_ARM_ABI
1388 case R_ARM_THM_XPC22:
1389 #endif
1390 case R_ARM_THM_PC22:
1391 /* Thumb BL (branch long instruction). */
1393 bfd_vma relocation;
1394 boolean overflow = false;
1395 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
1396 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
1397 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
1398 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
1399 bfd_vma check;
1400 bfd_signed_vma signed_check;
1402 #ifdef USE_REL
1403 /* Need to refetch the addend and squish the two 11 bit pieces
1404 together. */
1406 bfd_vma upper = upper_insn & 0x7ff;
1407 bfd_vma lower = lower_insn & 0x7ff;
1408 upper = (upper ^ 0x400) - 0x400; /* Sign extend. */
1409 addend = (upper << 12) | (lower << 1);
1410 signed_addend = addend;
1412 #endif
1413 #ifndef OLD_ARM_ABI
1414 if (r_type == R_ARM_THM_XPC22)
1416 /* Check for Thumb to Thumb call. */
1417 /* FIXME: Should we translate the instruction into a BL
1418 instruction instead ? */
1419 if (sym_flags == STT_ARM_TFUNC)
1420 (*_bfd_error_handler) (_("\
1421 %s: Warning: Thumb BLX instruction targets thumb function '%s'."),
1422 bfd_archive_filename (input_bfd),
1423 h ? h->root.root.string : "(local)");
1425 else
1426 #endif
1428 /* If it is not a call to Thumb, assume call to Arm.
1429 If it is a call relative to a section name, then it is not a
1430 function call at all, but rather a long jump. */
1431 if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION)
1433 if (elf32_thumb_to_arm_stub
1434 (info, sym_name, input_bfd, output_bfd, input_section,
1435 hit_data, sym_sec, rel->r_offset, signed_addend, value))
1436 return bfd_reloc_ok;
1437 else
1438 return bfd_reloc_dangerous;
1442 relocation = value + signed_addend;
1444 relocation -= (input_section->output_section->vma
1445 + input_section->output_offset
1446 + rel->r_offset);
1448 if (! globals->no_pipeline_knowledge)
1450 Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form. */
1452 i_ehdrp = elf_elfheader (input_bfd);
1454 /* Previous versions of this code also used to add in the pipline
1455 offset here. This is wrong because the linker is not supposed
1456 to know about such things, and one day it might change. In order
1457 to support old binaries that need the old behaviour however, so
1458 we attempt to detect which ABI was used to create the reloc. */
1459 if ( strcmp (bfd_get_target (input_bfd), "elf32-littlearm-oabi") == 0
1460 || strcmp (bfd_get_target (input_bfd), "elf32-bigarm-oabi") == 0
1461 || i_ehdrp->e_ident[EI_OSABI] == 0)
1462 relocation += 4;
1465 check = relocation >> howto->rightshift;
1467 /* If this is a signed value, the rightshift just dropped
1468 leading 1 bits (assuming twos complement). */
1469 if ((bfd_signed_vma) relocation >= 0)
1470 signed_check = check;
1471 else
1472 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
1474 /* Assumes two's complement. */
1475 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
1476 overflow = true;
1478 /* Put RELOCATION back into the insn. */
1479 upper_insn = (upper_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 12) & 0x7ff);
1480 lower_insn = (lower_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 1) & 0x7ff);
1482 #ifndef OLD_ARM_ABI
1483 if (r_type == R_ARM_THM_XPC22
1484 && ((lower_insn & 0x1800) == 0x0800))
1485 /* Remove bit zero of the adjusted offset. Bit zero can only be
1486 set if the upper insn is at a half-word boundary, since the
1487 destination address, an ARM instruction, must always be on a
1488 word boundary. The semantics of the BLX (1) instruction, however,
1489 are that bit zero in the offset must always be zero, and the
1490 corresponding bit one in the target address will be set from bit
1491 one of the source address. */
1492 lower_insn &= ~1;
1493 #endif
1494 /* Put the relocated value back in the object file: */
1495 bfd_put_16 (input_bfd, upper_insn, hit_data);
1496 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
1498 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
1500 break;
1502 case R_ARM_THM_PC11:
1503 /* Thumb B (branch) instruction). */
1505 bfd_vma relocation;
1506 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
1507 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
1508 bfd_vma check;
1509 bfd_signed_vma signed_check;
1511 #ifdef USE_REL
1512 /* Need to refetch addend. */
1513 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
1514 /* ??? Need to determine shift amount from operand size. */
1515 addend >>= howto->rightshift;
1516 #endif
1517 relocation = value + addend;
1519 relocation -= (input_section->output_section->vma
1520 + input_section->output_offset
1521 + rel->r_offset);
1523 check = relocation >> howto->rightshift;
1525 /* If this is a signed value, the rightshift just
1526 dropped leading 1 bits (assuming twos complement). */
1527 if ((bfd_signed_vma) relocation >= 0)
1528 signed_check = check;
1529 else
1530 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
1532 relocation |= (bfd_get_16 (input_bfd, hit_data) & (~ howto->dst_mask));
1534 bfd_put_16 (input_bfd, relocation, hit_data);
1536 /* Assumes two's complement. */
1537 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
1538 return bfd_reloc_overflow;
1540 return bfd_reloc_ok;
1543 case R_ARM_GNU_VTINHERIT:
1544 case R_ARM_GNU_VTENTRY:
1545 return bfd_reloc_ok;
1547 case R_ARM_COPY:
1548 return bfd_reloc_notsupported;
1550 case R_ARM_GLOB_DAT:
1551 return bfd_reloc_notsupported;
1553 case R_ARM_JUMP_SLOT:
1554 return bfd_reloc_notsupported;
1556 case R_ARM_RELATIVE:
1557 return bfd_reloc_notsupported;
1559 case R_ARM_GOTOFF:
1560 /* Relocation is relative to the start of the
1561 global offset table. */
1563 BFD_ASSERT (sgot != NULL);
1564 if (sgot == NULL)
1565 return bfd_reloc_notsupported;
1567 /* Note that sgot->output_offset is not involved in this
1568 calculation. We always want the start of .got. If we
1569 define _GLOBAL_OFFSET_TABLE in a different way, as is
1570 permitted by the ABI, we might have to change this
1571 calculation. */
1572 value -= sgot->output_section->vma;
1573 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1574 contents, rel->r_offset, value,
1575 (bfd_vma) 0);
1577 case R_ARM_GOTPC:
1578 /* Use global offset table as symbol value. */
1579 BFD_ASSERT (sgot != NULL);
1581 if (sgot == NULL)
1582 return bfd_reloc_notsupported;
1584 value = sgot->output_section->vma;
1585 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1586 contents, rel->r_offset, value,
1587 (bfd_vma) 0);
1589 case R_ARM_GOT32:
1590 /* Relocation is to the entry for this symbol in the
1591 global offset table. */
1592 if (sgot == NULL)
1593 return bfd_reloc_notsupported;
1595 if (h != NULL)
1597 bfd_vma off;
1599 off = h->got.offset;
1600 BFD_ASSERT (off != (bfd_vma) -1);
1602 if (!elf_hash_table (info)->dynamic_sections_created ||
1603 (info->shared && (info->symbolic || h->dynindx == -1)
1604 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1606 /* This is actually a static link, or it is a -Bsymbolic link
1607 and the symbol is defined locally. We must initialize this
1608 entry in the global offset table. Since the offset must
1609 always be a multiple of 4, we use the least significant bit
1610 to record whether we have initialized it already.
1612 When doing a dynamic link, we create a .rel.got relocation
1613 entry to initialize the value. This is done in the
1614 finish_dynamic_symbol routine. */
1615 if ((off & 1) != 0)
1616 off &= ~1;
1617 else
1619 bfd_put_32 (output_bfd, value, sgot->contents + off);
1620 h->got.offset |= 1;
1624 value = sgot->output_offset + off;
1626 else
1628 bfd_vma off;
1630 BFD_ASSERT (local_got_offsets != NULL &&
1631 local_got_offsets[r_symndx] != (bfd_vma) -1);
1633 off = local_got_offsets[r_symndx];
1635 /* The offset must always be a multiple of 4. We use the
1636 least significant bit to record whether we have already
1637 generated the necessary reloc. */
1638 if ((off & 1) != 0)
1639 off &= ~1;
1640 else
1642 bfd_put_32 (output_bfd, value, sgot->contents + off);
1644 if (info->shared)
1646 asection * srelgot;
1647 Elf_Internal_Rel outrel;
1649 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
1650 BFD_ASSERT (srelgot != NULL);
1652 outrel.r_offset = (sgot->output_section->vma
1653 + sgot->output_offset
1654 + off);
1655 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
1656 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1657 (((Elf32_External_Rel *)
1658 srelgot->contents)
1659 + srelgot->reloc_count));
1660 ++srelgot->reloc_count;
1663 local_got_offsets[r_symndx] |= 1;
1666 value = sgot->output_offset + off;
1669 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1670 contents, rel->r_offset, value,
1671 (bfd_vma) 0);
1673 case R_ARM_PLT32:
1674 /* Relocation is to the entry for this symbol in the
1675 procedure linkage table. */
1677 /* Resolve a PLT32 reloc against a local symbol directly,
1678 without using the procedure linkage table. */
1679 if (h == NULL)
1680 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1681 contents, rel->r_offset, value,
1682 (bfd_vma) 0);
1684 if (h->plt.offset == (bfd_vma) -1)
1685 /* We didn't make a PLT entry for this symbol. This
1686 happens when statically linking PIC code, or when
1687 using -Bsymbolic. */
1688 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1689 contents, rel->r_offset, value,
1690 (bfd_vma) 0);
1692 BFD_ASSERT(splt != NULL);
1693 if (splt == NULL)
1694 return bfd_reloc_notsupported;
1696 value = (splt->output_section->vma
1697 + splt->output_offset
1698 + h->plt.offset);
1699 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1700 contents, rel->r_offset, value,
1701 (bfd_vma) 0);
1703 case R_ARM_SBREL32:
1704 return bfd_reloc_notsupported;
1706 case R_ARM_AMP_VCALL9:
1707 return bfd_reloc_notsupported;
1709 case R_ARM_RSBREL32:
1710 return bfd_reloc_notsupported;
1712 case R_ARM_THM_RPC22:
1713 return bfd_reloc_notsupported;
1715 case R_ARM_RREL32:
1716 return bfd_reloc_notsupported;
1718 case R_ARM_RABS32:
1719 return bfd_reloc_notsupported;
1721 case R_ARM_RPC24:
1722 return bfd_reloc_notsupported;
1724 case R_ARM_RBASE:
1725 return bfd_reloc_notsupported;
1727 default:
1728 return bfd_reloc_notsupported;
1732 #ifdef USE_REL
1733 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
1734 static void
1735 arm_add_to_rel (abfd, address, howto, increment)
1736 bfd * abfd;
1737 bfd_byte * address;
1738 reloc_howto_type * howto;
1739 bfd_signed_vma increment;
1741 bfd_signed_vma addend;
1743 if (howto->type == R_ARM_THM_PC22)
1745 int upper_insn, lower_insn;
1746 int upper, lower;
1748 upper_insn = bfd_get_16 (abfd, address);
1749 lower_insn = bfd_get_16 (abfd, address + 2);
1750 upper = upper_insn & 0x7ff;
1751 lower = lower_insn & 0x7ff;
1753 addend = (upper << 12) | (lower << 1);
1754 addend += increment;
1755 addend >>= 1;
1757 upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
1758 lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
1760 bfd_put_16 (abfd, (bfd_vma) upper_insn, address);
1761 bfd_put_16 (abfd, (bfd_vma) lower_insn, address + 2);
1763 else
1765 bfd_vma contents;
1767 contents = bfd_get_32 (abfd, address);
1769 /* Get the (signed) value from the instruction. */
1770 addend = contents & howto->src_mask;
1771 if (addend & ((howto->src_mask + 1) >> 1))
1773 bfd_signed_vma mask;
1775 mask = -1;
1776 mask &= ~ howto->src_mask;
1777 addend |= mask;
1780 /* Add in the increment, (which is a byte value). */
1781 switch (howto->type)
1783 default:
1784 addend += increment;
1785 break;
1787 case R_ARM_PC24:
1788 addend <<= howto->size;
1789 addend += increment;
1791 /* Should we check for overflow here ? */
1793 /* Drop any undesired bits. */
1794 addend >>= howto->rightshift;
1795 break;
1798 contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
1800 bfd_put_32 (abfd, contents, address);
1803 #endif /* USE_REL */
1805 /* Relocate an ARM ELF section. */
1806 static boolean
1807 elf32_arm_relocate_section (output_bfd, info, input_bfd, input_section,
1808 contents, relocs, local_syms, local_sections)
1809 bfd * output_bfd;
1810 struct bfd_link_info * info;
1811 bfd * input_bfd;
1812 asection * input_section;
1813 bfd_byte * contents;
1814 Elf_Internal_Rela * relocs;
1815 Elf_Internal_Sym * local_syms;
1816 asection ** local_sections;
1818 Elf_Internal_Shdr * symtab_hdr;
1819 struct elf_link_hash_entry ** sym_hashes;
1820 Elf_Internal_Rela * rel;
1821 Elf_Internal_Rela * relend;
1822 const char * name;
1824 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1825 sym_hashes = elf_sym_hashes (input_bfd);
1827 rel = relocs;
1828 relend = relocs + input_section->reloc_count;
1829 for (; rel < relend; rel++)
1831 int r_type;
1832 reloc_howto_type * howto;
1833 unsigned long r_symndx;
1834 Elf_Internal_Sym * sym;
1835 asection * sec;
1836 struct elf_link_hash_entry * h;
1837 bfd_vma relocation;
1838 bfd_reloc_status_type r;
1839 arelent bfd_reloc;
1841 r_symndx = ELF32_R_SYM (rel->r_info);
1842 r_type = ELF32_R_TYPE (rel->r_info);
1844 if ( r_type == R_ARM_GNU_VTENTRY
1845 || r_type == R_ARM_GNU_VTINHERIT)
1846 continue;
1848 #ifdef USE_REL
1849 elf32_arm_info_to_howto (input_bfd, & bfd_reloc,
1850 (Elf_Internal_Rel *) rel);
1851 #else
1852 elf32_arm_info_to_howto (input_bfd, & bfd_reloc, rel);
1853 #endif
1854 howto = bfd_reloc.howto;
1856 if (info->relocateable)
1858 /* This is a relocateable link. We don't have to change
1859 anything, unless the reloc is against a section symbol,
1860 in which case we have to adjust according to where the
1861 section symbol winds up in the output section. */
1862 if (r_symndx < symtab_hdr->sh_info)
1864 sym = local_syms + r_symndx;
1865 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1867 sec = local_sections[r_symndx];
1868 #ifdef USE_REL
1869 arm_add_to_rel (input_bfd, contents + rel->r_offset,
1870 howto,
1871 (bfd_signed_vma) (sec->output_offset
1872 + sym->st_value));
1873 #else
1874 rel->r_addend += (sec->output_offset + sym->st_value);
1875 #endif
1879 continue;
1882 /* This is a final link. */
1883 h = NULL;
1884 sym = NULL;
1885 sec = NULL;
1887 if (r_symndx < symtab_hdr->sh_info)
1889 sym = local_syms + r_symndx;
1890 sec = local_sections[r_symndx];
1891 #ifdef USE_REL
1892 relocation = (sec->output_section->vma
1893 + sec->output_offset
1894 + sym->st_value);
1895 if ((sec->flags & SEC_MERGE)
1896 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1898 asection *msec;
1899 bfd_vma addend, value;
1901 if (howto->rightshift)
1903 (*_bfd_error_handler)
1904 (_("%s(%s+0x%lx): %s relocation against SEC_MERGE section"),
1905 bfd_archive_filename (input_bfd),
1906 bfd_get_section_name (input_bfd, input_section),
1907 (long) rel->r_offset, howto->name);
1908 return false;
1911 value = bfd_get_32 (input_bfd, contents + rel->r_offset);
1913 /* Get the (signed) value from the instruction. */
1914 addend = value & howto->src_mask;
1915 if (addend & ((howto->src_mask + 1) >> 1))
1917 bfd_signed_vma mask;
1919 mask = -1;
1920 mask &= ~ howto->src_mask;
1921 addend |= mask;
1923 msec = sec;
1924 addend =
1925 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
1926 - relocation;
1927 addend += msec->output_section->vma + msec->output_offset;
1928 value = (value & ~ howto->dst_mask) | (addend & howto->dst_mask);
1929 bfd_put_32 (input_bfd, value, contents + rel->r_offset);
1931 #else
1932 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1933 #endif
1935 else
1937 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1939 while ( h->root.type == bfd_link_hash_indirect
1940 || h->root.type == bfd_link_hash_warning)
1941 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1943 if ( h->root.type == bfd_link_hash_defined
1944 || h->root.type == bfd_link_hash_defweak)
1946 int relocation_needed = 1;
1948 sec = h->root.u.def.section;
1950 /* In these cases, we don't need the relocation value.
1951 We check specially because in some obscure cases
1952 sec->output_section will be NULL. */
1953 switch (r_type)
1955 case R_ARM_PC24:
1956 case R_ARM_ABS32:
1957 case R_ARM_THM_PC22:
1958 if (info->shared
1959 && (
1960 (!info->symbolic && h->dynindx != -1)
1961 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
1963 && ((input_section->flags & SEC_ALLOC) != 0
1964 /* DWARF will emit R_ARM_ABS32 relocations in its
1965 sections against symbols defined externally
1966 in shared libraries. We can't do anything
1967 with them here. */
1968 || ((input_section->flags & SEC_DEBUGGING) != 0
1969 && (h->elf_link_hash_flags
1970 & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
1972 relocation_needed = 0;
1973 break;
1975 case R_ARM_GOTPC:
1976 relocation_needed = 0;
1977 break;
1979 case R_ARM_GOT32:
1980 if (elf_hash_table(info)->dynamic_sections_created
1981 && (!info->shared
1982 || (!info->symbolic && h->dynindx != -1)
1983 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
1986 relocation_needed = 0;
1987 break;
1989 case R_ARM_PLT32:
1990 if (h->plt.offset != (bfd_vma)-1)
1991 relocation_needed = 0;
1992 break;
1994 default:
1995 if (sec->output_section == NULL)
1997 (*_bfd_error_handler)
1998 (_("%s: warning: unresolvable relocation %d against symbol `%s' from %s section"),
1999 bfd_archive_filename (input_bfd),
2000 r_type,
2001 h->root.root.string,
2002 bfd_get_section_name (input_bfd, input_section));
2003 relocation_needed = 0;
2007 if (relocation_needed)
2008 relocation = h->root.u.def.value
2009 + sec->output_section->vma
2010 + sec->output_offset;
2011 else
2012 relocation = 0;
2014 else if (h->root.type == bfd_link_hash_undefweak)
2015 relocation = 0;
2016 else if (info->shared && !info->symbolic
2017 && !info->no_undefined
2018 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2019 relocation = 0;
2020 else
2022 if (!((*info->callbacks->undefined_symbol)
2023 (info, h->root.root.string, input_bfd,
2024 input_section, rel->r_offset,
2025 (!info->shared || info->no_undefined
2026 || ELF_ST_VISIBILITY (h->other)))))
2027 return false;
2028 relocation = 0;
2032 if (h != NULL)
2033 name = h->root.root.string;
2034 else
2036 name = (bfd_elf_string_from_elf_section
2037 (input_bfd, symtab_hdr->sh_link, sym->st_name));
2038 if (name == NULL || *name == '\0')
2039 name = bfd_section_name (input_bfd, sec);
2042 r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
2043 input_section, contents, rel,
2044 relocation, info, sec, name,
2045 (h ? ELF_ST_TYPE (h->type) :
2046 ELF_ST_TYPE (sym->st_info)), h);
2048 if (r != bfd_reloc_ok)
2050 const char * msg = (const char *) 0;
2052 switch (r)
2054 case bfd_reloc_overflow:
2055 /* If the overflowing reloc was to an undefined symbol,
2056 we have already printed one error message and there
2057 is no point complaining again. */
2058 if ((! h ||
2059 h->root.type != bfd_link_hash_undefined)
2060 && (!((*info->callbacks->reloc_overflow)
2061 (info, name, howto->name, (bfd_vma) 0,
2062 input_bfd, input_section, rel->r_offset))))
2063 return false;
2064 break;
2066 case bfd_reloc_undefined:
2067 if (!((*info->callbacks->undefined_symbol)
2068 (info, name, input_bfd, input_section,
2069 rel->r_offset, true)))
2070 return false;
2071 break;
2073 case bfd_reloc_outofrange:
2074 msg = _("internal error: out of range error");
2075 goto common_error;
2077 case bfd_reloc_notsupported:
2078 msg = _("internal error: unsupported relocation error");
2079 goto common_error;
2081 case bfd_reloc_dangerous:
2082 msg = _("internal error: dangerous error");
2083 goto common_error;
2085 default:
2086 msg = _("internal error: unknown error");
2087 /* fall through */
2089 common_error:
2090 if (!((*info->callbacks->warning)
2091 (info, msg, name, input_bfd, input_section,
2092 rel->r_offset)))
2093 return false;
2094 break;
2099 return true;
2102 /* Function to keep ARM specific flags in the ELF header. */
2103 static boolean
2104 elf32_arm_set_private_flags (abfd, flags)
2105 bfd *abfd;
2106 flagword flags;
2108 if (elf_flags_init (abfd)
2109 && elf_elfheader (abfd)->e_flags != flags)
2111 if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
2113 if (flags & EF_ARM_INTERWORK)
2114 (*_bfd_error_handler) (_("\
2115 Warning: Not setting interwork flag of %s since it has already been specified as non-interworking"),
2116 bfd_archive_filename (abfd));
2117 else
2118 _bfd_error_handler (_("\
2119 Warning: Clearing the interwork flag of %s due to outside request"),
2120 bfd_archive_filename (abfd));
2123 else
2125 elf_elfheader (abfd)->e_flags = flags;
2126 elf_flags_init (abfd) = true;
2129 return true;
2132 /* Copy backend specific data from one object module to another. */
2134 static boolean
2135 elf32_arm_copy_private_bfd_data (ibfd, obfd)
2136 bfd *ibfd;
2137 bfd *obfd;
2139 flagword in_flags;
2140 flagword out_flags;
2142 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2143 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2144 return true;
2146 in_flags = elf_elfheader (ibfd)->e_flags;
2147 out_flags = elf_elfheader (obfd)->e_flags;
2149 if (elf_flags_init (obfd)
2150 && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
2151 && in_flags != out_flags)
2153 /* Cannot mix APCS26 and APCS32 code. */
2154 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
2155 return false;
2157 /* Cannot mix float APCS and non-float APCS code. */
2158 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
2159 return false;
2161 /* If the src and dest have different interworking flags
2162 then turn off the interworking bit. */
2163 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
2165 if (out_flags & EF_ARM_INTERWORK)
2166 _bfd_error_handler (_("\
2167 Warning: Clearing the interwork flag in %s because non-interworking code in %s has been linked with it"),
2168 bfd_get_filename (obfd),
2169 bfd_archive_filename (ibfd));
2171 in_flags &= ~EF_ARM_INTERWORK;
2174 /* Likewise for PIC, though don't warn for this case. */
2175 if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC))
2176 in_flags &= ~EF_ARM_PIC;
2179 elf_elfheader (obfd)->e_flags = in_flags;
2180 elf_flags_init (obfd) = true;
2182 return true;
2185 /* Merge backend specific data from an object file to the output
2186 object file when linking. */
2188 static boolean
2189 elf32_arm_merge_private_bfd_data (ibfd, obfd)
2190 bfd * ibfd;
2191 bfd * obfd;
2193 flagword out_flags;
2194 flagword in_flags;
2195 boolean flags_compatible = true;
2196 boolean null_input_bfd = true;
2197 asection *sec;
2199 /* Check if we have the same endianess. */
2200 if (_bfd_generic_verify_endian_match (ibfd, obfd) == false)
2201 return false;
2203 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2204 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2205 return true;
2207 /* The input BFD must have had its flags initialised. */
2208 /* The following seems bogus to me -- The flags are initialized in
2209 the assembler but I don't think an elf_flags_init field is
2210 written into the object. */
2211 /* BFD_ASSERT (elf_flags_init (ibfd)); */
2213 in_flags = elf_elfheader (ibfd)->e_flags;
2214 out_flags = elf_elfheader (obfd)->e_flags;
2216 if (!elf_flags_init (obfd))
2218 /* If the input is the default architecture and had the default
2219 flags then do not bother setting the flags for the output
2220 architecture, instead allow future merges to do this. If no
2221 future merges ever set these flags then they will retain their
2222 uninitialised values, which surprise surprise, correspond
2223 to the default values. */
2224 if (bfd_get_arch_info (ibfd)->the_default
2225 && elf_elfheader (ibfd)->e_flags == 0)
2226 return true;
2228 elf_flags_init (obfd) = true;
2229 elf_elfheader (obfd)->e_flags = in_flags;
2231 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2232 && bfd_get_arch_info (obfd)->the_default)
2233 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
2235 return true;
2238 /* Identical flags must be compatible. */
2239 if (in_flags == out_flags)
2240 return true;
2242 /* Check to see if the input BFD actually contains any sections.
2243 If not, its flags may not have been initialised either, but it cannot
2244 actually cause any incompatibility. */
2245 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
2247 /* Ignore synthetic glue sections. */
2248 if (strcmp (sec->name, ".glue_7")
2249 && strcmp (sec->name, ".glue_7t"))
2251 null_input_bfd = false;
2252 break;
2255 if (null_input_bfd)
2256 return true;
2258 /* Complain about various flag mismatches. */
2259 if (EF_ARM_EABI_VERSION (in_flags) != EF_ARM_EABI_VERSION (out_flags))
2261 _bfd_error_handler (_("\
2262 Error: %s compiled for EABI version %d, whereas %s is compiled for version %d"),
2263 bfd_archive_filename (ibfd),
2264 (in_flags & EF_ARM_EABIMASK) >> 24,
2265 bfd_get_filename (obfd),
2266 (out_flags & EF_ARM_EABIMASK) >> 24);
2267 return false;
2270 /* Not sure what needs to be checked for EABI versions >= 1. */
2271 if (EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
2273 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
2275 _bfd_error_handler (_("\
2276 Error: %s compiled for APCS-%d, whereas %s is compiled for APCS-%d"),
2277 bfd_archive_filename (ibfd),
2278 in_flags & EF_ARM_APCS_26 ? 26 : 32,
2279 bfd_get_filename (obfd),
2280 out_flags & EF_ARM_APCS_26 ? 26 : 32);
2281 flags_compatible = false;
2284 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
2286 if (in_flags & EF_ARM_APCS_FLOAT)
2287 _bfd_error_handler (_("\
2288 Error: %s passes floats in FP registers, whereas %s passes them in integer registers"),
2289 bfd_archive_filename (ibfd),
2290 bfd_get_filename (obfd));
2291 else
2292 _bfd_error_handler (_("\
2293 Error: %s passes floats in integer registers, whereas %s passes them in FP registers"),
2294 bfd_archive_filename (ibfd),
2295 bfd_get_filename (obfd));
2297 flags_compatible = false;
2300 #ifdef EF_ARM_SOFT_FLOAT
2301 if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
2303 if (in_flags & EF_ARM_SOFT_FLOAT)
2304 _bfd_error_handler (_ ("\
2305 Error: %s uses software FP, whereas %s uses hardware FP"),
2306 bfd_archive_filename (ibfd),
2307 bfd_get_filename (obfd));
2308 else
2309 _bfd_error_handler (_ ("\
2310 Error: %s uses hardware FP, whereas %s uses software FP"),
2311 bfd_archive_filename (ibfd),
2312 bfd_get_filename (obfd));
2314 flags_compatible = false;
2316 #endif
2318 /* Interworking mismatch is only a warning. */
2319 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
2321 if (in_flags & EF_ARM_INTERWORK)
2323 _bfd_error_handler (_("\
2324 Warning: %s supports interworking, whereas %s does not"),
2325 bfd_archive_filename (ibfd),
2326 bfd_get_filename (obfd));
2328 else
2330 _bfd_error_handler (_("\
2331 Warning: %s does not support interworking, whereas %s does"),
2332 bfd_archive_filename (ibfd),
2333 bfd_get_filename (obfd));
2338 return flags_compatible;
2341 /* Display the flags field. */
2343 static boolean
2344 elf32_arm_print_private_bfd_data (abfd, ptr)
2345 bfd *abfd;
2346 PTR ptr;
2348 FILE * file = (FILE *) ptr;
2349 unsigned long flags;
2351 BFD_ASSERT (abfd != NULL && ptr != NULL);
2353 /* Print normal ELF private data. */
2354 _bfd_elf_print_private_bfd_data (abfd, ptr);
2356 flags = elf_elfheader (abfd)->e_flags;
2357 /* Ignore init flag - it may not be set, despite the flags field
2358 containing valid data. */
2360 /* xgettext:c-format */
2361 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
2363 switch (EF_ARM_EABI_VERSION (flags))
2365 case EF_ARM_EABI_UNKNOWN:
2366 /* The following flag bits are GNU extenstions and not part of the
2367 official ARM ELF extended ABI. Hence they are only decoded if
2368 the EABI version is not set. */
2369 if (flags & EF_ARM_INTERWORK)
2370 fprintf (file, _(" [interworking enabled]"));
2372 if (flags & EF_ARM_APCS_26)
2373 fprintf (file, _(" [APCS-26]"));
2374 else
2375 fprintf (file, _(" [APCS-32]"));
2377 if (flags & EF_ARM_APCS_FLOAT)
2378 fprintf (file, _(" [floats passed in float registers]"));
2380 if (flags & EF_ARM_PIC)
2381 fprintf (file, _(" [position independent]"));
2383 if (flags & EF_ARM_NEW_ABI)
2384 fprintf (file, _(" [new ABI]"));
2386 if (flags & EF_ARM_OLD_ABI)
2387 fprintf (file, _(" [old ABI]"));
2389 if (flags & EF_ARM_SOFT_FLOAT)
2390 fprintf (file, _(" [software FP]"));
2392 flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT | EF_ARM_PIC
2393 | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI | EF_ARM_SOFT_FLOAT);
2394 break;
2396 case EF_ARM_EABI_VER1:
2397 fprintf (file, _(" [Version1 EABI]"));
2399 if (flags & EF_ARM_SYMSARESORTED)
2400 fprintf (file, _(" [sorted symbol table]"));
2401 else
2402 fprintf (file, _(" [unsorted symbol table]"));
2404 flags &= ~ EF_ARM_SYMSARESORTED;
2405 break;
2407 case EF_ARM_EABI_VER2:
2408 fprintf (file, _(" [Version2 EABI]"));
2410 if (flags & EF_ARM_SYMSARESORTED)
2411 fprintf (file, _(" [sorted symbol table]"));
2412 else
2413 fprintf (file, _(" [unsorted symbol table]"));
2415 if (flags & EF_ARM_DYNSYMSUSESEGIDX)
2416 fprintf (file, _(" [dynamic symbols use segment index]"));
2418 if (flags & EF_ARM_MAPSYMSFIRST)
2419 fprintf (file, _(" [mapping symbols precede others]"));
2421 flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX
2422 | EF_ARM_MAPSYMSFIRST);
2423 break;
2425 default:
2426 fprintf (file, _(" <EABI version unrecognised>"));
2427 break;
2430 flags &= ~ EF_ARM_EABIMASK;
2432 if (flags & EF_ARM_RELEXEC)
2433 fprintf (file, _(" [relocatable executable]"));
2435 if (flags & EF_ARM_HASENTRY)
2436 fprintf (file, _(" [has entry point]"));
2438 flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
2440 if (flags)
2441 fprintf (file, _("<Unrecognised flag bits set>"));
2443 fputc ('\n', file);
2445 return true;
2448 static int
2449 elf32_arm_get_symbol_type (elf_sym, type)
2450 Elf_Internal_Sym * elf_sym;
2451 int type;
2453 switch (ELF_ST_TYPE (elf_sym->st_info))
2455 case STT_ARM_TFUNC:
2456 return ELF_ST_TYPE (elf_sym->st_info);
2458 case STT_ARM_16BIT:
2459 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2460 This allows us to distinguish between data used by Thumb instructions
2461 and non-data (which is probably code) inside Thumb regions of an
2462 executable. */
2463 if (type != STT_OBJECT)
2464 return ELF_ST_TYPE (elf_sym->st_info);
2465 break;
2467 default:
2468 break;
2471 return type;
2474 static asection *
2475 elf32_arm_gc_mark_hook (abfd, info, rel, h, sym)
2476 bfd *abfd;
2477 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2478 Elf_Internal_Rela *rel;
2479 struct elf_link_hash_entry *h;
2480 Elf_Internal_Sym *sym;
2482 if (h != NULL)
2484 switch (ELF32_R_TYPE (rel->r_info))
2486 case R_ARM_GNU_VTINHERIT:
2487 case R_ARM_GNU_VTENTRY:
2488 break;
2490 default:
2491 switch (h->root.type)
2493 case bfd_link_hash_defined:
2494 case bfd_link_hash_defweak:
2495 return h->root.u.def.section;
2497 case bfd_link_hash_common:
2498 return h->root.u.c.p->section;
2500 default:
2501 break;
2505 else
2507 return bfd_section_from_elf_index (abfd, sym->st_shndx);
2510 return NULL;
2513 /* Update the got entry reference counts for the section being removed. */
2515 static boolean
2516 elf32_arm_gc_sweep_hook (abfd, info, sec, relocs)
2517 bfd *abfd ATTRIBUTE_UNUSED;
2518 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2519 asection *sec ATTRIBUTE_UNUSED;
2520 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
2522 /* We don't support garbage collection of GOT and PLT relocs yet. */
2523 return true;
2526 /* Look through the relocs for a section during the first phase. */
2528 static boolean
2529 elf32_arm_check_relocs (abfd, info, sec, relocs)
2530 bfd * abfd;
2531 struct bfd_link_info * info;
2532 asection * sec;
2533 const Elf_Internal_Rela * relocs;
2535 Elf_Internal_Shdr * symtab_hdr;
2536 struct elf_link_hash_entry ** sym_hashes;
2537 struct elf_link_hash_entry ** sym_hashes_end;
2538 const Elf_Internal_Rela * rel;
2539 const Elf_Internal_Rela * rel_end;
2540 bfd * dynobj;
2541 asection * sgot, *srelgot, *sreloc;
2542 bfd_vma * local_got_offsets;
2544 if (info->relocateable)
2545 return true;
2547 sgot = srelgot = sreloc = NULL;
2549 dynobj = elf_hash_table (info)->dynobj;
2550 local_got_offsets = elf_local_got_offsets (abfd);
2552 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2553 sym_hashes = elf_sym_hashes (abfd);
2554 sym_hashes_end = sym_hashes
2555 + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
2557 if (!elf_bad_symtab (abfd))
2558 sym_hashes_end -= symtab_hdr->sh_info;
2560 rel_end = relocs + sec->reloc_count;
2561 for (rel = relocs; rel < rel_end; rel++)
2563 struct elf_link_hash_entry *h;
2564 unsigned long r_symndx;
2566 r_symndx = ELF32_R_SYM (rel->r_info);
2567 if (r_symndx < symtab_hdr->sh_info)
2568 h = NULL;
2569 else
2570 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2572 /* Some relocs require a global offset table. */
2573 if (dynobj == NULL)
2575 switch (ELF32_R_TYPE (rel->r_info))
2577 case R_ARM_GOT32:
2578 case R_ARM_GOTOFF:
2579 case R_ARM_GOTPC:
2580 elf_hash_table (info)->dynobj = dynobj = abfd;
2581 if (! _bfd_elf_create_got_section (dynobj, info))
2582 return false;
2583 break;
2585 default:
2586 break;
2590 switch (ELF32_R_TYPE (rel->r_info))
2592 case R_ARM_GOT32:
2593 /* This symbol requires a global offset table entry. */
2594 if (sgot == NULL)
2596 sgot = bfd_get_section_by_name (dynobj, ".got");
2597 BFD_ASSERT (sgot != NULL);
2600 /* Get the got relocation section if necessary. */
2601 if (srelgot == NULL
2602 && (h != NULL || info->shared))
2604 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
2606 /* If no got relocation section, make one and initialize. */
2607 if (srelgot == NULL)
2609 srelgot = bfd_make_section (dynobj, ".rel.got");
2610 if (srelgot == NULL
2611 || ! bfd_set_section_flags (dynobj, srelgot,
2612 (SEC_ALLOC
2613 | SEC_LOAD
2614 | SEC_HAS_CONTENTS
2615 | SEC_IN_MEMORY
2616 | SEC_LINKER_CREATED
2617 | SEC_READONLY))
2618 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
2619 return false;
2623 if (h != NULL)
2625 if (h->got.offset != (bfd_vma) -1)
2626 /* We have already allocated space in the .got. */
2627 break;
2629 h->got.offset = sgot->_raw_size;
2631 /* Make sure this symbol is output as a dynamic symbol. */
2632 if (h->dynindx == -1)
2633 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2634 return false;
2636 srelgot->_raw_size += sizeof (Elf32_External_Rel);
2638 else
2640 /* This is a global offset table entry for a local
2641 symbol. */
2642 if (local_got_offsets == NULL)
2644 bfd_size_type size;
2645 unsigned int i;
2647 size = symtab_hdr->sh_info;
2648 size *= sizeof (bfd_vma);
2649 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
2650 if (local_got_offsets == NULL)
2651 return false;
2652 elf_local_got_offsets (abfd) = local_got_offsets;
2653 for (i = 0; i < symtab_hdr->sh_info; i++)
2654 local_got_offsets[i] = (bfd_vma) -1;
2657 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
2658 /* We have already allocated space in the .got. */
2659 break;
2661 local_got_offsets[r_symndx] = sgot->_raw_size;
2663 if (info->shared)
2664 /* If we are generating a shared object, we need to
2665 output a R_ARM_RELATIVE reloc so that the dynamic
2666 linker can adjust this GOT entry. */
2667 srelgot->_raw_size += sizeof (Elf32_External_Rel);
2670 sgot->_raw_size += 4;
2671 break;
2673 case R_ARM_PLT32:
2674 /* This symbol requires a procedure linkage table entry. We
2675 actually build the entry in adjust_dynamic_symbol,
2676 because this might be a case of linking PIC code which is
2677 never referenced by a dynamic object, in which case we
2678 don't need to generate a procedure linkage table entry
2679 after all. */
2681 /* If this is a local symbol, we resolve it directly without
2682 creating a procedure linkage table entry. */
2683 if (h == NULL)
2684 continue;
2686 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2687 break;
2689 case R_ARM_ABS32:
2690 case R_ARM_REL32:
2691 case R_ARM_PC24:
2692 /* If we are creating a shared library, and this is a reloc
2693 against a global symbol, or a non PC relative reloc
2694 against a local symbol, then we need to copy the reloc
2695 into the shared library. However, if we are linking with
2696 -Bsymbolic, we do not need to copy a reloc against a
2697 global symbol which is defined in an object we are
2698 including in the link (i.e., DEF_REGULAR is set). At
2699 this point we have not seen all the input files, so it is
2700 possible that DEF_REGULAR is not set now but will be set
2701 later (it is never cleared). We account for that
2702 possibility below by storing information in the
2703 pcrel_relocs_copied field of the hash table entry. */
2704 if (info->shared
2705 && (ELF32_R_TYPE (rel->r_info) != R_ARM_PC24
2706 || (h != NULL
2707 && (! info->symbolic
2708 || (h->elf_link_hash_flags
2709 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2711 /* When creating a shared object, we must copy these
2712 reloc types into the output file. We create a reloc
2713 section in dynobj and make room for this reloc. */
2714 if (sreloc == NULL)
2716 const char * name;
2718 name = (bfd_elf_string_from_elf_section
2719 (abfd,
2720 elf_elfheader (abfd)->e_shstrndx,
2721 elf_section_data (sec)->rel_hdr.sh_name));
2722 if (name == NULL)
2723 return false;
2725 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
2726 && strcmp (bfd_get_section_name (abfd, sec),
2727 name + 4) == 0);
2729 sreloc = bfd_get_section_by_name (dynobj, name);
2730 if (sreloc == NULL)
2732 flagword flags;
2734 sreloc = bfd_make_section (dynobj, name);
2735 flags = (SEC_HAS_CONTENTS | SEC_READONLY
2736 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2737 if ((sec->flags & SEC_ALLOC) != 0)
2738 flags |= SEC_ALLOC | SEC_LOAD;
2739 if (sreloc == NULL
2740 || ! bfd_set_section_flags (dynobj, sreloc, flags)
2741 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
2742 return false;
2744 if (sec->flags & SEC_READONLY)
2745 info->flags |= DF_TEXTREL;
2748 sreloc->_raw_size += sizeof (Elf32_External_Rel);
2749 /* If we are linking with -Bsymbolic, and this is a
2750 global symbol, we count the number of PC relative
2751 relocations we have entered for this symbol, so that
2752 we can discard them again if the symbol is later
2753 defined by a regular object. Note that this function
2754 is only called if we are using an elf_i386 linker
2755 hash table, which means that h is really a pointer to
2756 an elf_i386_link_hash_entry. */
2757 if (h != NULL && info->symbolic
2758 && ELF32_R_TYPE (rel->r_info) == R_ARM_PC24)
2760 struct elf32_arm_link_hash_entry * eh;
2761 struct elf32_arm_pcrel_relocs_copied * p;
2763 eh = (struct elf32_arm_link_hash_entry *) h;
2765 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
2766 if (p->section == sreloc)
2767 break;
2769 if (p == NULL)
2771 p = ((struct elf32_arm_pcrel_relocs_copied *)
2772 bfd_alloc (dynobj, (bfd_size_type) sizeof * p));
2773 if (p == NULL)
2774 return false;
2775 p->next = eh->pcrel_relocs_copied;
2776 eh->pcrel_relocs_copied = p;
2777 p->section = sreloc;
2778 p->count = 0;
2781 ++p->count;
2784 break;
2786 /* This relocation describes the C++ object vtable hierarchy.
2787 Reconstruct it for later use during GC. */
2788 case R_ARM_GNU_VTINHERIT:
2789 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2790 return false;
2791 break;
2793 /* This relocation describes which C++ vtable entries are actually
2794 used. Record for later use during GC. */
2795 case R_ARM_GNU_VTENTRY:
2796 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
2797 return false;
2798 break;
2802 return true;
2805 /* Find the nearest line to a particular section and offset, for error
2806 reporting. This code is a duplicate of the code in elf.c, except
2807 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
2809 static boolean
2810 elf32_arm_find_nearest_line
2811 (abfd, section, symbols, offset, filename_ptr, functionname_ptr, line_ptr)
2812 bfd * abfd;
2813 asection * section;
2814 asymbol ** symbols;
2815 bfd_vma offset;
2816 const char ** filename_ptr;
2817 const char ** functionname_ptr;
2818 unsigned int * line_ptr;
2820 boolean found;
2821 const char * filename;
2822 asymbol * func;
2823 bfd_vma low_func;
2824 asymbol ** p;
2826 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
2827 filename_ptr, functionname_ptr,
2828 line_ptr, 0,
2829 &elf_tdata (abfd)->dwarf2_find_line_info))
2830 return true;
2832 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
2833 &found, filename_ptr,
2834 functionname_ptr, line_ptr,
2835 &elf_tdata (abfd)->line_info))
2836 return false;
2838 if (found)
2839 return true;
2841 if (symbols == NULL)
2842 return false;
2844 filename = NULL;
2845 func = NULL;
2846 low_func = 0;
2848 for (p = symbols; *p != NULL; p++)
2850 elf_symbol_type *q;
2852 q = (elf_symbol_type *) *p;
2854 if (bfd_get_section (&q->symbol) != section)
2855 continue;
2857 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
2859 default:
2860 break;
2861 case STT_FILE:
2862 filename = bfd_asymbol_name (&q->symbol);
2863 break;
2864 case STT_NOTYPE:
2865 case STT_FUNC:
2866 case STT_ARM_TFUNC:
2867 if (q->symbol.section == section
2868 && q->symbol.value >= low_func
2869 && q->symbol.value <= offset)
2871 func = (asymbol *) q;
2872 low_func = q->symbol.value;
2874 break;
2878 if (func == NULL)
2879 return false;
2881 *filename_ptr = filename;
2882 *functionname_ptr = bfd_asymbol_name (func);
2883 *line_ptr = 0;
2885 return true;
2888 /* Adjust a symbol defined by a dynamic object and referenced by a
2889 regular object. The current definition is in some section of the
2890 dynamic object, but we're not including those sections. We have to
2891 change the definition to something the rest of the link can
2892 understand. */
2894 static boolean
2895 elf32_arm_adjust_dynamic_symbol (info, h)
2896 struct bfd_link_info * info;
2897 struct elf_link_hash_entry * h;
2899 bfd * dynobj;
2900 asection * s;
2901 unsigned int power_of_two;
2903 dynobj = elf_hash_table (info)->dynobj;
2905 /* Make sure we know what is going on here. */
2906 BFD_ASSERT (dynobj != NULL
2907 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
2908 || h->weakdef != NULL
2909 || ((h->elf_link_hash_flags
2910 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2911 && (h->elf_link_hash_flags
2912 & ELF_LINK_HASH_REF_REGULAR) != 0
2913 && (h->elf_link_hash_flags
2914 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
2916 /* If this is a function, put it in the procedure linkage table. We
2917 will fill in the contents of the procedure linkage table later,
2918 when we know the address of the .got section. */
2919 if (h->type == STT_FUNC
2920 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2922 if (! info->shared
2923 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
2924 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
2926 /* This case can occur if we saw a PLT32 reloc in an input
2927 file, but the symbol was never referred to by a dynamic
2928 object. In such a case, we don't actually need to build
2929 a procedure linkage table, and we can just do a PC32
2930 reloc instead. */
2931 BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
2932 return true;
2935 /* Make sure this symbol is output as a dynamic symbol. */
2936 if (h->dynindx == -1)
2938 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2939 return false;
2942 s = bfd_get_section_by_name (dynobj, ".plt");
2943 BFD_ASSERT (s != NULL);
2945 /* If this is the first .plt entry, make room for the special
2946 first entry. */
2947 if (s->_raw_size == 0)
2948 s->_raw_size += PLT_ENTRY_SIZE;
2950 /* If this symbol is not defined in a regular file, and we are
2951 not generating a shared library, then set the symbol to this
2952 location in the .plt. This is required to make function
2953 pointers compare as equal between the normal executable and
2954 the shared library. */
2955 if (! info->shared
2956 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2958 h->root.u.def.section = s;
2959 h->root.u.def.value = s->_raw_size;
2962 h->plt.offset = s->_raw_size;
2964 /* Make room for this entry. */
2965 s->_raw_size += PLT_ENTRY_SIZE;
2967 /* We also need to make an entry in the .got.plt section, which
2968 will be placed in the .got section by the linker script. */
2969 s = bfd_get_section_by_name (dynobj, ".got.plt");
2970 BFD_ASSERT (s != NULL);
2971 s->_raw_size += 4;
2973 /* We also need to make an entry in the .rel.plt section. */
2975 s = bfd_get_section_by_name (dynobj, ".rel.plt");
2976 BFD_ASSERT (s != NULL);
2977 s->_raw_size += sizeof (Elf32_External_Rel);
2979 return true;
2982 /* If this is a weak symbol, and there is a real definition, the
2983 processor independent code will have arranged for us to see the
2984 real definition first, and we can just use the same value. */
2985 if (h->weakdef != NULL)
2987 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2988 || h->weakdef->root.type == bfd_link_hash_defweak);
2989 h->root.u.def.section = h->weakdef->root.u.def.section;
2990 h->root.u.def.value = h->weakdef->root.u.def.value;
2991 return true;
2994 /* This is a reference to a symbol defined by a dynamic object which
2995 is not a function. */
2997 /* If we are creating a shared library, we must presume that the
2998 only references to the symbol are via the global offset table.
2999 For such cases we need not do anything here; the relocations will
3000 be handled correctly by relocate_section. */
3001 if (info->shared)
3002 return true;
3004 /* We must allocate the symbol in our .dynbss section, which will
3005 become part of the .bss section of the executable. There will be
3006 an entry for this symbol in the .dynsym section. The dynamic
3007 object will contain position independent code, so all references
3008 from the dynamic object to this symbol will go through the global
3009 offset table. The dynamic linker will use the .dynsym entry to
3010 determine the address it must put in the global offset table, so
3011 both the dynamic object and the regular object will refer to the
3012 same memory location for the variable. */
3013 s = bfd_get_section_by_name (dynobj, ".dynbss");
3014 BFD_ASSERT (s != NULL);
3016 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
3017 copy the initial value out of the dynamic object and into the
3018 runtime process image. We need to remember the offset into the
3019 .rel.bss section we are going to use. */
3020 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
3022 asection *srel;
3024 srel = bfd_get_section_by_name (dynobj, ".rel.bss");
3025 BFD_ASSERT (srel != NULL);
3026 srel->_raw_size += sizeof (Elf32_External_Rel);
3027 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
3030 /* We need to figure out the alignment required for this symbol. I
3031 have no idea how ELF linkers handle this. */
3032 power_of_two = bfd_log2 (h->size);
3033 if (power_of_two > 3)
3034 power_of_two = 3;
3036 /* Apply the required alignment. */
3037 s->_raw_size = BFD_ALIGN (s->_raw_size,
3038 (bfd_size_type) (1 << power_of_two));
3039 if (power_of_two > bfd_get_section_alignment (dynobj, s))
3041 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
3042 return false;
3045 /* Define the symbol as being at this point in the section. */
3046 h->root.u.def.section = s;
3047 h->root.u.def.value = s->_raw_size;
3049 /* Increment the section size to make room for the symbol. */
3050 s->_raw_size += h->size;
3052 return true;
3055 /* Set the sizes of the dynamic sections. */
3057 static boolean
3058 elf32_arm_size_dynamic_sections (output_bfd, info)
3059 bfd * output_bfd ATTRIBUTE_UNUSED;
3060 struct bfd_link_info * info;
3062 bfd * dynobj;
3063 asection * s;
3064 boolean plt;
3065 boolean relocs;
3067 dynobj = elf_hash_table (info)->dynobj;
3068 BFD_ASSERT (dynobj != NULL);
3070 if (elf_hash_table (info)->dynamic_sections_created)
3072 /* Set the contents of the .interp section to the interpreter. */
3073 if (! info->shared)
3075 s = bfd_get_section_by_name (dynobj, ".interp");
3076 BFD_ASSERT (s != NULL);
3077 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3078 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3081 else
3083 /* We may have created entries in the .rel.got section.
3084 However, if we are not creating the dynamic sections, we will
3085 not actually use these entries. Reset the size of .rel.got,
3086 which will cause it to get stripped from the output file
3087 below. */
3088 s = bfd_get_section_by_name (dynobj, ".rel.got");
3089 if (s != NULL)
3090 s->_raw_size = 0;
3093 /* If this is a -Bsymbolic shared link, then we need to discard all
3094 PC relative relocs against symbols defined in a regular object.
3095 We allocated space for them in the check_relocs routine, but we
3096 will not fill them in in the relocate_section routine. */
3097 if (info->shared && info->symbolic)
3098 elf32_arm_link_hash_traverse (elf32_arm_hash_table (info),
3099 elf32_arm_discard_copies,
3100 (PTR) NULL);
3102 /* The check_relocs and adjust_dynamic_symbol entry points have
3103 determined the sizes of the various dynamic sections. Allocate
3104 memory for them. */
3105 plt = false;
3106 relocs = false;
3107 for (s = dynobj->sections; s != NULL; s = s->next)
3109 const char * name;
3110 boolean strip;
3112 if ((s->flags & SEC_LINKER_CREATED) == 0)
3113 continue;
3115 /* It's OK to base decisions on the section name, because none
3116 of the dynobj section names depend upon the input files. */
3117 name = bfd_get_section_name (dynobj, s);
3119 strip = false;
3121 if (strcmp (name, ".plt") == 0)
3123 if (s->_raw_size == 0)
3125 /* Strip this section if we don't need it; see the
3126 comment below. */
3127 strip = true;
3129 else
3131 /* Remember whether there is a PLT. */
3132 plt = true;
3135 else if (strncmp (name, ".rel", 4) == 0)
3137 if (s->_raw_size == 0)
3139 /* If we don't need this section, strip it from the
3140 output file. This is mostly to handle .rel.bss and
3141 .rel.plt. We must create both sections in
3142 create_dynamic_sections, because they must be created
3143 before the linker maps input sections to output
3144 sections. The linker does that before
3145 adjust_dynamic_symbol is called, and it is that
3146 function which decides whether anything needs to go
3147 into these sections. */
3148 strip = true;
3150 else
3152 /* Remember whether there are any reloc sections other
3153 than .rel.plt. */
3154 if (strcmp (name, ".rel.plt") != 0)
3155 relocs = true;
3157 /* We use the reloc_count field as a counter if we need
3158 to copy relocs into the output file. */
3159 s->reloc_count = 0;
3162 else if (strncmp (name, ".got", 4) != 0)
3164 /* It's not one of our sections, so don't allocate space. */
3165 continue;
3168 if (strip)
3170 asection ** spp;
3172 for (spp = &s->output_section->owner->sections;
3173 *spp != s->output_section;
3174 spp = &(*spp)->next)
3176 *spp = s->output_section->next;
3177 --s->output_section->owner->section_count;
3179 continue;
3182 /* Allocate memory for the section contents. */
3183 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
3184 if (s->contents == NULL && s->_raw_size != 0)
3185 return false;
3188 if (elf_hash_table (info)->dynamic_sections_created)
3190 /* Add some entries to the .dynamic section. We fill in the
3191 values later, in elf32_arm_finish_dynamic_sections, but we
3192 must add the entries now so that we get the correct size for
3193 the .dynamic section. The DT_DEBUG entry is filled in by the
3194 dynamic linker and used by the debugger. */
3195 #define add_dynamic_entry(TAG, VAL) \
3196 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
3198 if (!info->shared)
3200 if (!add_dynamic_entry (DT_DEBUG, 0))
3201 return false;
3204 if (plt)
3206 if ( !add_dynamic_entry (DT_PLTGOT, 0)
3207 || !add_dynamic_entry (DT_PLTRELSZ, 0)
3208 || !add_dynamic_entry (DT_PLTREL, DT_REL)
3209 || !add_dynamic_entry (DT_JMPREL, 0))
3210 return false;
3213 if (relocs)
3215 if ( !add_dynamic_entry (DT_REL, 0)
3216 || !add_dynamic_entry (DT_RELSZ, 0)
3217 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
3218 return false;
3221 if ((info->flags & DF_TEXTREL) != 0)
3223 if (!add_dynamic_entry (DT_TEXTREL, 0))
3224 return false;
3225 info->flags |= DF_TEXTREL;
3228 #undef add_synamic_entry
3230 return true;
3233 /* This function is called via elf32_arm_link_hash_traverse if we are
3234 creating a shared object with -Bsymbolic. It discards the space
3235 allocated to copy PC relative relocs against symbols which are
3236 defined in regular objects. We allocated space for them in the
3237 check_relocs routine, but we won't fill them in in the
3238 relocate_section routine. */
3240 static boolean
3241 elf32_arm_discard_copies (h, ignore)
3242 struct elf32_arm_link_hash_entry * h;
3243 PTR ignore ATTRIBUTE_UNUSED;
3245 struct elf32_arm_pcrel_relocs_copied * s;
3247 /* We only discard relocs for symbols defined in a regular object. */
3248 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3249 return true;
3251 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
3252 s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
3254 return true;
3257 /* Finish up dynamic symbol handling. We set the contents of various
3258 dynamic sections here. */
3260 static boolean
3261 elf32_arm_finish_dynamic_symbol (output_bfd, info, h, sym)
3262 bfd * output_bfd;
3263 struct bfd_link_info * info;
3264 struct elf_link_hash_entry * h;
3265 Elf_Internal_Sym * sym;
3267 bfd * dynobj;
3269 dynobj = elf_hash_table (info)->dynobj;
3271 if (h->plt.offset != (bfd_vma) -1)
3273 asection * splt;
3274 asection * sgot;
3275 asection * srel;
3276 bfd_vma plt_index;
3277 bfd_vma got_offset;
3278 Elf_Internal_Rel rel;
3280 /* This symbol has an entry in the procedure linkage table. Set
3281 it up. */
3283 BFD_ASSERT (h->dynindx != -1);
3285 splt = bfd_get_section_by_name (dynobj, ".plt");
3286 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3287 srel = bfd_get_section_by_name (dynobj, ".rel.plt");
3288 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
3290 /* Get the index in the procedure linkage table which
3291 corresponds to this symbol. This is the index of this symbol
3292 in all the symbols for which we are making plt entries. The
3293 first entry in the procedure linkage table is reserved. */
3294 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3296 /* Get the offset into the .got table of the entry that
3297 corresponds to this function. Each .got entry is 4 bytes.
3298 The first three are reserved. */
3299 got_offset = (plt_index + 3) * 4;
3301 /* Fill in the entry in the procedure linkage table. */
3302 bfd_put_32 (output_bfd, elf32_arm_plt_entry[0],
3303 splt->contents + h->plt.offset + 0);
3304 bfd_put_32 (output_bfd, elf32_arm_plt_entry[1],
3305 splt->contents + h->plt.offset + 4);
3306 bfd_put_32 (output_bfd, elf32_arm_plt_entry[2],
3307 splt->contents + h->plt.offset + 8);
3308 bfd_put_32 (output_bfd,
3309 (sgot->output_section->vma
3310 + sgot->output_offset
3311 + got_offset
3312 - splt->output_section->vma
3313 - splt->output_offset
3314 - h->plt.offset - 12),
3315 splt->contents + h->plt.offset + 12);
3317 /* Fill in the entry in the global offset table. */
3318 bfd_put_32 (output_bfd,
3319 (splt->output_section->vma
3320 + splt->output_offset),
3321 sgot->contents + got_offset);
3323 /* Fill in the entry in the .rel.plt section. */
3324 rel.r_offset = (sgot->output_section->vma
3325 + sgot->output_offset
3326 + got_offset);
3327 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
3328 bfd_elf32_swap_reloc_out (output_bfd, &rel,
3329 ((Elf32_External_Rel *) srel->contents
3330 + plt_index));
3332 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3334 /* Mark the symbol as undefined, rather than as defined in
3335 the .plt section. Leave the value alone. */
3336 sym->st_shndx = SHN_UNDEF;
3337 /* If the symbol is weak, we do need to clear the value.
3338 Otherwise, the PLT entry would provide a definition for
3339 the symbol even if the symbol wasn't defined anywhere,
3340 and so the symbol would never be NULL. */
3341 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
3342 == 0)
3343 sym->st_value = 0;
3347 if (h->got.offset != (bfd_vma) -1)
3349 asection * sgot;
3350 asection * srel;
3351 Elf_Internal_Rel rel;
3353 /* This symbol has an entry in the global offset table. Set it
3354 up. */
3355 sgot = bfd_get_section_by_name (dynobj, ".got");
3356 srel = bfd_get_section_by_name (dynobj, ".rel.got");
3357 BFD_ASSERT (sgot != NULL && srel != NULL);
3359 rel.r_offset = (sgot->output_section->vma
3360 + sgot->output_offset
3361 + (h->got.offset &~ (bfd_vma) 1));
3363 /* If this is a -Bsymbolic link, and the symbol is defined
3364 locally, we just want to emit a RELATIVE reloc. The entry in
3365 the global offset table will already have been initialized in
3366 the relocate_section function. */
3367 if (info->shared
3368 && (info->symbolic || h->dynindx == -1)
3369 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3370 rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
3371 else
3373 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
3374 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
3377 bfd_elf32_swap_reloc_out (output_bfd, &rel,
3378 ((Elf32_External_Rel *) srel->contents
3379 + srel->reloc_count));
3380 ++srel->reloc_count;
3383 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
3385 asection * s;
3386 Elf_Internal_Rel rel;
3388 /* This symbol needs a copy reloc. Set it up. */
3389 BFD_ASSERT (h->dynindx != -1
3390 && (h->root.type == bfd_link_hash_defined
3391 || h->root.type == bfd_link_hash_defweak));
3393 s = bfd_get_section_by_name (h->root.u.def.section->owner,
3394 ".rel.bss");
3395 BFD_ASSERT (s != NULL);
3397 rel.r_offset = (h->root.u.def.value
3398 + h->root.u.def.section->output_section->vma
3399 + h->root.u.def.section->output_offset);
3400 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
3401 bfd_elf32_swap_reloc_out (output_bfd, &rel,
3402 ((Elf32_External_Rel *) s->contents
3403 + s->reloc_count));
3404 ++s->reloc_count;
3407 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3408 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3409 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3410 sym->st_shndx = SHN_ABS;
3412 return true;
3415 /* Finish up the dynamic sections. */
3417 static boolean
3418 elf32_arm_finish_dynamic_sections (output_bfd, info)
3419 bfd * output_bfd;
3420 struct bfd_link_info * info;
3422 bfd * dynobj;
3423 asection * sgot;
3424 asection * sdyn;
3426 dynobj = elf_hash_table (info)->dynobj;
3428 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3429 BFD_ASSERT (sgot != NULL);
3430 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3432 if (elf_hash_table (info)->dynamic_sections_created)
3434 asection *splt;
3435 Elf32_External_Dyn *dyncon, *dynconend;
3437 splt = bfd_get_section_by_name (dynobj, ".plt");
3438 BFD_ASSERT (splt != NULL && sdyn != NULL);
3440 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3441 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3443 for (; dyncon < dynconend; dyncon++)
3445 Elf_Internal_Dyn dyn;
3446 const char * name;
3447 asection * s;
3449 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3451 switch (dyn.d_tag)
3453 default:
3454 break;
3456 case DT_PLTGOT:
3457 name = ".got";
3458 goto get_vma;
3459 case DT_JMPREL:
3460 name = ".rel.plt";
3461 get_vma:
3462 s = bfd_get_section_by_name (output_bfd, name);
3463 BFD_ASSERT (s != NULL);
3464 dyn.d_un.d_ptr = s->vma;
3465 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3466 break;
3468 case DT_PLTRELSZ:
3469 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3470 BFD_ASSERT (s != NULL);
3471 if (s->_cooked_size != 0)
3472 dyn.d_un.d_val = s->_cooked_size;
3473 else
3474 dyn.d_un.d_val = s->_raw_size;
3475 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3476 break;
3478 case DT_RELSZ:
3479 /* My reading of the SVR4 ABI indicates that the
3480 procedure linkage table relocs (DT_JMPREL) should be
3481 included in the overall relocs (DT_REL). This is
3482 what Solaris does. However, UnixWare can not handle
3483 that case. Therefore, we override the DT_RELSZ entry
3484 here to make it not include the JMPREL relocs. Since
3485 the linker script arranges for .rel.plt to follow all
3486 other relocation sections, we don't have to worry
3487 about changing the DT_REL entry. */
3488 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3489 if (s != NULL)
3491 if (s->_cooked_size != 0)
3492 dyn.d_un.d_val -= s->_cooked_size;
3493 else
3494 dyn.d_un.d_val -= s->_raw_size;
3496 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3497 break;
3501 /* Fill in the first entry in the procedure linkage table. */
3502 if (splt->_raw_size > 0)
3504 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[0], splt->contents + 0);
3505 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[1], splt->contents + 4);
3506 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[2], splt->contents + 8);
3507 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[3], splt->contents + 12);
3510 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3511 really seem like the right value. */
3512 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
3515 /* Fill in the first three entries in the global offset table. */
3516 if (sgot->_raw_size > 0)
3518 if (sdyn == NULL)
3519 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
3520 else
3521 bfd_put_32 (output_bfd,
3522 sdyn->output_section->vma + sdyn->output_offset,
3523 sgot->contents);
3524 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
3525 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3528 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
3530 return true;
3533 static void
3534 elf32_arm_post_process_headers (abfd, link_info)
3535 bfd * abfd;
3536 struct bfd_link_info * link_info ATTRIBUTE_UNUSED;
3538 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
3540 i_ehdrp = elf_elfheader (abfd);
3542 i_ehdrp->e_ident[EI_OSABI] = ARM_ELF_OS_ABI_VERSION;
3543 i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
3546 static enum elf_reloc_type_class
3547 elf32_arm_reloc_type_class (rela)
3548 const Elf_Internal_Rela *rela;
3550 switch ((int) ELF32_R_TYPE (rela->r_info))
3552 case R_ARM_RELATIVE:
3553 return reloc_class_relative;
3554 case R_ARM_JUMP_SLOT:
3555 return reloc_class_plt;
3556 case R_ARM_COPY:
3557 return reloc_class_copy;
3558 default:
3559 return reloc_class_normal;
3564 #define ELF_ARCH bfd_arch_arm
3565 #define ELF_MACHINE_CODE EM_ARM
3566 #define ELF_MAXPAGESIZE 0x8000
3568 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
3569 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
3570 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
3571 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
3572 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
3573 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
3574 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
3576 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
3577 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
3578 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
3579 #define elf_backend_check_relocs elf32_arm_check_relocs
3580 #define elf_backend_relocate_section elf32_arm_relocate_section
3581 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
3582 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
3583 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
3584 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
3585 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
3586 #define elf_backend_post_process_headers elf32_arm_post_process_headers
3587 #define elf_backend_reloc_type_class elf32_arm_reloc_type_class
3589 #define elf_backend_can_gc_sections 1
3590 #define elf_backend_plt_readonly 1
3591 #define elf_backend_want_got_plt 1
3592 #define elf_backend_want_plt_sym 0
3594 #define elf_backend_got_header_size 12
3595 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
3597 #include "elf32-target.h"