projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* tic54x-opc.c: Add default initializers to avoid warnings.
[deliverable/binutils-gdb.git] / bfd / elf32-arm.h
CommitLineData
252b5132 1/* 32-bit ELF support for ARM
7898deda 2 Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
252b5132
RH		 3
4 This file is part of BFD, the Binary File Descriptor library.
5
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.
10
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.
15
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. */
19
252b5132
RH		 20typedef unsigned long int insn32;
21typedef unsigned short int insn16;
22
23static boolean elf32_arm_set_private_flags
24 PARAMS ((bfd *, flagword));
25static boolean elf32_arm_copy_private_bfd_data
26 PARAMS ((bfd *, bfd *));
27static boolean elf32_arm_merge_private_bfd_data
28 PARAMS ((bfd *, bfd *));
29static boolean elf32_arm_print_private_bfd_data
30 PARAMS ((bfd *, PTR));
f21f3fe0 31static int elf32_arm_get_symbol_type
252b5132
RH		 32 PARAMS (( Elf_Internal_Sym *, int));
33static struct bfd_link_hash_table *elf32_arm_link_hash_table_create
34 PARAMS ((bfd *));
35static bfd_reloc_status_type elf32_arm_final_link_relocate
780a67af
NC		 36 PARAMS ((reloc_howto_type *, bfd *, bfd *, asection *, bfd_byte *,
37 Elf_Internal_Rela *, bfd_vma, struct bfd_link_info *, asection *,
38 const char *, unsigned char, struct elf_link_hash_entry *));
252b5132
RH		 39static insn32 insert_thumb_branch
40 PARAMS ((insn32, int));
41static struct elf_link_hash_entry *find_thumb_glue
917583ad 42 PARAMS ((struct bfd_link_info *, const char *, bfd *));
252b5132 43static struct elf_link_hash_entry *find_arm_glue
917583ad 44 PARAMS ((struct bfd_link_info *, const char *, bfd *));
252b5132
RH		 45static void record_arm_to_thumb_glue
46 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
47static void record_thumb_to_arm_glue
48 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
ba96a88f
NC		 49static void elf32_arm_post_process_headers
50 PARAMS ((bfd *, struct bfd_link_info *));
bcbdc74c
NC		 51static 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));
54static 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));
917583ad
NC		 57static boolean elf32_arm_relocate_section
58 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
59 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
60static 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 *));
63static boolean elf32_arm_gc_sweep_hook
64 PARAMS ((bfd *, struct bfd_link_info *, asection *,
65 const Elf_Internal_Rela *));
66static boolean elf32_arm_check_relocs
67 PARAMS ((bfd *, struct bfd_link_info *, asection *,
68 const Elf_Internal_Rela *));
69static boolean elf32_arm_find_nearest_line
70 PARAMS ((bfd *, asection *, asymbol **, bfd_vma, const char **,
71 const char **, unsigned int *));
72static boolean elf32_arm_adjust_dynamic_symbol
73 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
74static boolean elf32_arm_size_dynamic_sections
75 PARAMS ((bfd *, struct bfd_link_info *));
76static boolean elf32_arm_finish_dynamic_symbol
77 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
78 Elf_Internal_Sym *));
79static boolean elf32_arm_finish_dynamic_sections
80 PARAMS ((bfd *, struct bfd_link_info *));
81static 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
84static void arm_add_to_rel
85 PARAMS ((bfd *, bfd_byte *, reloc_howto_type *, bfd_signed_vma));
86#endif
252b5132 87
917583ad
NC		 88boolean bfd_elf32_arm_allocate_interworking_sections
89 PARAMS ((struct bfd_link_info *));
90boolean bfd_elf32_arm_get_bfd_for_interworking
91 PARAMS ((bfd *, struct bfd_link_info *));
92boolean bfd_elf32_arm_process_before_allocation
93 PARAMS ((bfd *, struct bfd_link_info *, int));
99e4ae17
AJ		 94static enum elf_reloc_type_class elf32_arm_reloc_type_class
95 PARAMS ((int));
96
fd2ec330 97#define INTERWORK_FLAG(abfd) (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK)
9b485d32 98
252b5132
RH		 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
9b485d32 102 name can be changed. The only requirement is the %s be present. */
252b5132
RH		 103#define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
104#define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
105
106#define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
107#define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
108
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"
112
113/* The size in bytes of an entry in the procedure linkage table. */
252b5132
RH		 114#define PLT_ENTRY_SIZE 16
115
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
59f2c4e7 118 called before the relocation has been set up calls the dynamic
9b485d32 119 linker first. */
7a25cd3e 120static const unsigned long elf32_arm_plt0_entry [PLT_ENTRY_SIZE / 4] =
917583ad
NC		 121 {
122 0xe52de004, /* str lr, [sp, #-4]! */
123 0xe59fe010, /* ldr lr, [pc, #16] */
124 0xe08fe00e, /* add lr, pc, lr */
125 0xe5bef008 /* ldr pc, [lr, #8]! */
126 };
252b5132
RH		 127
128/* Subsequent entries in a procedure linkage table look like
129 this. */
7a25cd3e 130static const unsigned long elf32_arm_plt_entry [PLT_ENTRY_SIZE / 4] =
99e4ae17 131 {
917583ad
NC		 132 0xe59fc004, /* ldr ip, [pc, #4] */
133 0xe08fc00c, /* add ip, pc, ip */
134 0xe59cf000, /* ldr pc, [ip] */
135 0x00000000 /* offset to symbol in got */
136 };
252b5132 137
252b5132
RH		 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. */
143
144/* This structure keeps track of the number of PC relative relocs we
145 have copied for a given symbol. */
252b5132 146struct elf32_arm_pcrel_relocs_copied
917583ad
NC		 147 {
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;
154 };
252b5132 155
ba96a88f 156/* Arm ELF linker hash entry. */
252b5132 157struct elf32_arm_link_hash_entry
917583ad
NC		 158 {
159 struct elf_link_hash_entry root;
252b5132 160
917583ad
NC		 161 /* Number of PC relative relocs copied for this symbol. */
162 struct elf32_arm_pcrel_relocs_copied * pcrel_relocs_copied;
163 };
252b5132
RH		 164
165/* Declare this now that the above structures are defined. */
252b5132
RH		 166static boolean elf32_arm_discard_copies
167 PARAMS ((struct elf32_arm_link_hash_entry *, PTR));
168
169/* Traverse an arm ELF linker hash table. */
252b5132
RH		 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)))
175
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))
179
9b485d32 180/* ARM ELF linker hash table. */
252b5132 181struct elf32_arm_link_hash_table
917583ad
NC		 182 {
183 /* The main hash table. */
184 struct elf_link_hash_table root;
252b5132 185
917583ad
NC		 186 /* The size in bytes of the section containg the Thumb-to-ARM glue. */
187 long int thumb_glue_size;
252b5132 188
917583ad
NC		 189 /* The size in bytes of the section containg the ARM-to-Thumb glue. */
190 long int arm_glue_size;
252b5132 191
917583ad
NC		 192 /* An arbitary input BFD chosen to hold the glue sections. */
193 bfd * bfd_of_glue_owner;
ba96a88f 194
917583ad
NC		 195 /* A boolean indicating whether knowledge of the ARM's pipeline
196 length should be applied by the linker. */
197 int no_pipeline_knowledge;
198 };
252b5132 199
780a67af
NC		 200/* Create an entry in an ARM ELF linker hash table. */
201
202static struct bfd_hash_entry *
203elf32_arm_link_hash_newfunc (entry, table, string)
204 struct bfd_hash_entry * entry;
205 struct bfd_hash_table * table;
206 const char * string;
207{
208 struct elf32_arm_link_hash_entry * ret =
209 (struct elf32_arm_link_hash_entry *) entry;
210
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;
219
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;
226
227 return (struct bfd_hash_entry *) ret;
228}
229
9b485d32 230/* Create an ARM elf linker hash table. */
252b5132
RH		 231
232static struct bfd_link_hash_table *
233elf32_arm_link_hash_table_create (abfd)
234 bfd *abfd;
235{
236 struct elf32_arm_link_hash_table *ret;
237
238 ret = ((struct elf32_arm_link_hash_table *)
239 bfd_alloc (abfd, sizeof (struct elf32_arm_link_hash_table)));
240 if (ret == (struct elf32_arm_link_hash_table *) NULL)
241 return NULL;
242
243 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
780a67af 244 elf32_arm_link_hash_newfunc))
252b5132
RH		 245 {
246 bfd_release (abfd, ret);
247 return NULL;
248 }
249
250 ret->thumb_glue_size = 0;
251 ret->arm_glue_size = 0;
252 ret->bfd_of_glue_owner = NULL;
ba96a88f 253 ret->no_pipeline_knowledge = 0;
252b5132
RH		 254
255 return &ret->root.root;
256}
257
9b485d32
NC		 258/* Locate the Thumb encoded calling stub for NAME. */
259
252b5132
RH		 260static struct elf_link_hash_entry *
261find_thumb_glue (link_info, name, input_bfd)
262 struct bfd_link_info *link_info;
917583ad 263 const char *name;
252b5132
RH		 264 bfd *input_bfd;
265{
266 char *tmp_name;
267 struct elf_link_hash_entry *hash;
268 struct elf32_arm_link_hash_table *hash_table;
269
270 /* We need a pointer to the armelf specific hash table. */
271 hash_table = elf32_arm_hash_table (link_info);
272
252b5132
RH		 273 tmp_name = ((char *)
274 bfd_malloc (strlen (name) + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1));
275
276 BFD_ASSERT (tmp_name);
277
278 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
279
280 hash = elf_link_hash_lookup
281 (&(hash_table)->root, tmp_name, false, false, true);
282
283 if (hash == NULL)
284 /* xgettext:c-format */
9b485d32 285 _bfd_error_handler (_("%s: unable to find THUMB glue '%s' for `%s'"),
252b5132
RH		 286 bfd_get_filename (input_bfd), tmp_name, name);
287
288 free (tmp_name);
289
290 return hash;
291}
292
9b485d32
NC		 293/* Locate the ARM encoded calling stub for NAME. */
294
252b5132
RH		 295static struct elf_link_hash_entry *
296find_arm_glue (link_info, name, input_bfd)
297 struct bfd_link_info *link_info;
917583ad 298 const char *name;
252b5132
RH		 299 bfd *input_bfd;
300{
301 char *tmp_name;
302 struct elf_link_hash_entry *myh;
303 struct elf32_arm_link_hash_table *hash_table;
304
305 /* We need a pointer to the elfarm specific hash table. */
306 hash_table = elf32_arm_hash_table (link_info);
307
308 tmp_name = ((char *)
309 bfd_malloc (strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1));
310
311 BFD_ASSERT (tmp_name);
312
313 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
314
315 myh = elf_link_hash_lookup
316 (&(hash_table)->root, tmp_name, false, false, true);
317
318 if (myh == NULL)
319 /* xgettext:c-format */
9b485d32 320 _bfd_error_handler (_("%s: unable to find ARM glue '%s' for `%s'"),
252b5132
RH		 321 bfd_get_filename (input_bfd), tmp_name, name);
322
323 free (tmp_name);
324
325 return myh;
326}
327
9b485d32 328/* ARM->Thumb glue:
252b5132
RH		 329
330 .arm
331 __func_from_arm:
332 ldr r12, __func_addr
333 bx r12
334 __func_addr:
9b485d32 335 .word func @ behave as if you saw a ARM_32 reloc. */
252b5132
RH		 336
337#define ARM2THUMB_GLUE_SIZE 12
338static const insn32 a2t1_ldr_insn = 0xe59fc000;
339static const insn32 a2t2_bx_r12_insn = 0xe12fff1c;
340static const insn32 a2t3_func_addr_insn = 0x00000001;
341
9b485d32 342/* Thumb->ARM: Thumb->(non-interworking aware) ARM
252b5132
RH		 343
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:
9b485d32 356 .word func */
252b5132
RH		 357
358#define THUMB2ARM_GLUE_SIZE 8
359static const insn16 t2a1_bx_pc_insn = 0x4778;
360static const insn16 t2a2_noop_insn = 0x46c0;
361static const insn32 t2a3_b_insn = 0xea000000;
362
363static const insn16 t2a1_push_insn = 0xb540;
364static const insn16 t2a2_ldr_insn = 0x4e03;
365static const insn16 t2a3_mov_insn = 0x46fe;
366static const insn16 t2a4_bx_insn = 0x4730;
367static const insn32 t2a5_pop_insn = 0xe8bd4040;
368static const insn32 t2a6_bx_insn = 0xe12fff1e;
369
370boolean
371bfd_elf32_arm_allocate_interworking_sections (info)
372 struct bfd_link_info * info;
373{
374 asection * s;
375 bfd_byte * foo;
376 struct elf32_arm_link_hash_table * globals;
377
378 globals = elf32_arm_hash_table (info);
379
380 BFD_ASSERT (globals != NULL);
381
382 if (globals->arm_glue_size != 0)
383 {
384 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
385
386 s = bfd_get_section_by_name
387 (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
388
389 BFD_ASSERT (s != NULL);
390
391 foo = (bfd_byte *) bfd_alloc
392 (globals->bfd_of_glue_owner, globals->arm_glue_size);
393
394 s->_raw_size = s->_cooked_size = globals->arm_glue_size;
395 s->contents = foo;
396 }
397
398 if (globals->thumb_glue_size != 0)
399 {
400 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
401
402 s = bfd_get_section_by_name
403 (globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
404
405 BFD_ASSERT (s != NULL);
406
407 foo = (bfd_byte *) bfd_alloc
408 (globals->bfd_of_glue_owner, globals->thumb_glue_size);
409
410 s->_raw_size = s->_cooked_size = globals->thumb_glue_size;
411 s->contents = foo;
412 }
413
414 return true;
415}
416
417static void
418record_arm_to_thumb_glue (link_info, h)
419 struct bfd_link_info * link_info;
420 struct elf_link_hash_entry * h;
421{
422 const char * name = h->root.root.string;
423 register asection * s;
424 char * tmp_name;
425 struct elf_link_hash_entry * myh;
426 struct elf32_arm_link_hash_table * globals;
427
428 globals = elf32_arm_hash_table (link_info);
429
430 BFD_ASSERT (globals != NULL);
431 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
432
433 s = bfd_get_section_by_name
434 (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
435
252b5132
RH		 436 BFD_ASSERT (s != NULL);
437
438 tmp_name = ((char *)
439 bfd_malloc (strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1));
440
441 BFD_ASSERT (tmp_name);
442
443 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
444
445 myh = elf_link_hash_lookup
446 (&(globals)->root, tmp_name, false, false, true);
447
448 if (myh != NULL)
449 {
9b485d32 450 /* We've already seen this guy. */
252b5132 451 free (tmp_name);
9b485d32 452 return;
252b5132
RH		 453 }
454
455 /* The only trick here is using hash_table->arm_glue_size as the value. Even
456 though the section isn't allocated yet, this is where we will be putting
457 it. */
252b5132
RH		 458 _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner, tmp_name,
459 BSF_GLOBAL,
460 s, globals->arm_glue_size + 1,
461 NULL, true, false,
462 (struct bfd_link_hash_entry **) &myh);
463
464 free (tmp_name);
465
466 globals->arm_glue_size += ARM2THUMB_GLUE_SIZE;
467
468 return;
469}
470
471static void
472record_thumb_to_arm_glue (link_info, h)
473 struct bfd_link_info *link_info;
474 struct elf_link_hash_entry *h;
475{
476 const char *name = h->root.root.string;
477 register asection *s;
478 char *tmp_name;
479 struct elf_link_hash_entry *myh;
480 struct elf32_arm_link_hash_table *hash_table;
481 char bind;
482
483 hash_table = elf32_arm_hash_table (link_info);
484
485 BFD_ASSERT (hash_table != NULL);
486 BFD_ASSERT (hash_table->bfd_of_glue_owner != NULL);
487
488 s = bfd_get_section_by_name
489 (hash_table->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
490
491 BFD_ASSERT (s != NULL);
492
493 tmp_name = (char *) bfd_malloc (strlen (name) + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
494
495 BFD_ASSERT (tmp_name);
496
497 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
498
499 myh = elf_link_hash_lookup
500 (&(hash_table)->root, tmp_name, false, false, true);
501
502 if (myh != NULL)
503 {
9b485d32 504 /* We've already seen this guy. */
252b5132 505 free (tmp_name);
9b485d32 506 return;
252b5132
RH		 507 }
508
509 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner, tmp_name,
510 BSF_GLOBAL, s, hash_table->thumb_glue_size + 1,
511 NULL, true, false,
512 (struct bfd_link_hash_entry **) &myh);
513
9b485d32 514 /* If we mark it 'Thumb', the disassembler will do a better job. */
252b5132
RH		 515 bind = ELF_ST_BIND (myh->type);
516 myh->type = ELF_ST_INFO (bind, STT_ARM_TFUNC);
517
518 free (tmp_name);
519
252b5132
RH		 520#define CHANGE_TO_ARM "__%s_change_to_arm"
521#define BACK_FROM_ARM "__%s_back_from_arm"
522
9b485d32 523 /* Allocate another symbol to mark where we switch to Arm mode. */
252b5132
RH		 524 tmp_name = (char *) bfd_malloc (strlen (name) + strlen (CHANGE_TO_ARM) + 1);
525
526 BFD_ASSERT (tmp_name);
527
528 sprintf (tmp_name, CHANGE_TO_ARM, name);
529
530 myh = NULL;
531
532 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner, tmp_name,
533 BSF_LOCAL, s, hash_table->thumb_glue_size + 4,
534 NULL, true, false,
535 (struct bfd_link_hash_entry **) &myh);
536
537 free (tmp_name);
538
539 hash_table->thumb_glue_size += THUMB2ARM_GLUE_SIZE;
540
541 return;
542}
543
544/* Select a BFD to be used to hold the sections used by the glue code.
545 This function is called from the linker scripts in ld/emultempl/
546 {armelf/pe}.em */
9b485d32 547
252b5132
RH		 548boolean
549bfd_elf32_arm_get_bfd_for_interworking (abfd, info)
550 bfd *abfd;
551 struct bfd_link_info *info;
552{
553 struct elf32_arm_link_hash_table *globals;
554 flagword flags;
555 asection *sec;
556
557 /* If we are only performing a partial link do not bother
558 getting a bfd to hold the glue. */
559 if (info->relocateable)
560 return true;
561
562 globals = elf32_arm_hash_table (info);
563
564 BFD_ASSERT (globals != NULL);
565
566 if (globals->bfd_of_glue_owner != NULL)
567 return true;
568
569 sec = bfd_get_section_by_name (abfd, ARM2THUMB_GLUE_SECTION_NAME);
570
571 if (sec == NULL)
572 {
57db232e
NC		 573 /* Note: we do not include the flag SEC_LINKER_CREATED, as this
574 will prevent elf_link_input_bfd() from processing the contents
575 of this section. */
811b4bf6 576 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE | SEC_READONLY;
252b5132
RH		 577
578 sec = bfd_make_section (abfd, ARM2THUMB_GLUE_SECTION_NAME);
579
580 if (sec == NULL
581 || !bfd_set_section_flags (abfd, sec, flags)
582 || !bfd_set_section_alignment (abfd, sec, 2))
583 return false;
9a5aca8c 584
57db232e
NC		 585 /* Set the gc mark to prevent the section from being removed by garbage
586 collection, despite the fact that no relocs refer to this section. */
587 sec->gc_mark = 1;
252b5132
RH		 588 }
589
590 sec = bfd_get_section_by_name (abfd, THUMB2ARM_GLUE_SECTION_NAME);
591
592 if (sec == NULL)
593 {
811b4bf6 594 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE | SEC_READONLY;
252b5132
RH		 595
596 sec = bfd_make_section (abfd, THUMB2ARM_GLUE_SECTION_NAME);
597
598 if (sec == NULL
599 || !bfd_set_section_flags (abfd, sec, flags)
600 || !bfd_set_section_alignment (abfd, sec, 2))
601 return false;
9a5aca8c 602
57db232e 603 sec->gc_mark = 1;
252b5132
RH		 604 }
605
606 /* Save the bfd for later use. */
607 globals->bfd_of_glue_owner = abfd;
608
609 return true;
610}
611
612boolean
ba96a88f 613bfd_elf32_arm_process_before_allocation (abfd, link_info, no_pipeline_knowledge)
252b5132
RH		 614 bfd *abfd;
615 struct bfd_link_info *link_info;
ba96a88f 616 int no_pipeline_knowledge;
252b5132
RH		 617{
618 Elf_Internal_Shdr *symtab_hdr;
619 Elf_Internal_Rela *free_relocs = NULL;
620 Elf_Internal_Rela *irel, *irelend;
621 bfd_byte *contents = NULL;
622 bfd_byte *free_contents = NULL;
623 Elf32_External_Sym *extsyms = NULL;
624 Elf32_External_Sym *free_extsyms = NULL;
625
626 asection *sec;
627 struct elf32_arm_link_hash_table *globals;
628
629 /* If we are only performing a partial link do not bother
630 to construct any glue. */
631 if (link_info->relocateable)
632 return true;
633
634 /* Here we have a bfd that is to be included on the link. We have a hook
635 to do reloc rummaging, before section sizes are nailed down. */
252b5132
RH		 636 globals = elf32_arm_hash_table (link_info);
637
638 BFD_ASSERT (globals != NULL);
639 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
640
ba96a88f 641 globals->no_pipeline_knowledge = no_pipeline_knowledge;
f21f3fe0 642
252b5132
RH		 643 /* Rummage around all the relocs and map the glue vectors. */
644 sec = abfd->sections;
645
646 if (sec == NULL)
647 return true;
648
649 for (; sec != NULL; sec = sec->next)
650 {
651 if (sec->reloc_count == 0)
652 continue;
653
654 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
252b5132 655
9b485d32 656 /* Load the relocs. */
252b5132
RH		 657 irel = (_bfd_elf32_link_read_relocs (abfd, sec, (PTR) NULL,
658 (Elf_Internal_Rela *) NULL, false));
659
660 BFD_ASSERT (irel != 0);
661
662 irelend = irel + sec->reloc_count;
663 for (; irel < irelend; irel++)
664 {
665 long r_type;
666 unsigned long r_index;
252b5132
RH		 667
668 struct elf_link_hash_entry *h;
669
670 r_type = ELF32_R_TYPE (irel->r_info);
671 r_index = ELF32_R_SYM (irel->r_info);
672
9b485d32 673 /* These are the only relocation types we care about. */
ba96a88f 674 if ( r_type != R_ARM_PC24
252b5132
RH		 675 && r_type != R_ARM_THM_PC22)
676 continue;
677
678 /* Get the section contents if we haven't done so already. */
679 if (contents == NULL)
680 {
681 /* Get cached copy if it exists. */
682 if (elf_section_data (sec)->this_hdr.contents != NULL)
683 contents = elf_section_data (sec)->this_hdr.contents;
684 else
685 {
686 /* Go get them off disk. */
687 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
688 if (contents == NULL)
689 goto error_return;
9b485d32 690
252b5132
RH		 691 free_contents = contents;
692
693 if (!bfd_get_section_contents (abfd, sec, contents,
694 (file_ptr) 0, sec->_raw_size))
695 goto error_return;
696 }
697 }
698
699 /* Read this BFD's symbols if we haven't done so already. */
700 if (extsyms == NULL)
701 {
702 /* Get cached copy if it exists. */
703 if (symtab_hdr->contents != NULL)
704 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
705 else
706 {
707 /* Go get them off disk. */
708 extsyms = ((Elf32_External_Sym *)
709 bfd_malloc (symtab_hdr->sh_size));
710 if (extsyms == NULL)
711 goto error_return;
9b485d32 712
252b5132 713 free_extsyms = extsyms;
9b485d32 714
252b5132
RH		 715 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
716 || (bfd_read (extsyms, 1, symtab_hdr->sh_size, abfd)
717 != symtab_hdr->sh_size))
718 goto error_return;
719 }
720 }
721
a7c10850 722 /* If the relocation is not against a symbol it cannot concern us. */
252b5132
RH		 723 h = NULL;
724
9b485d32 725 /* We don't care about local symbols. */
252b5132
RH		 726 if (r_index < symtab_hdr->sh_info)
727 continue;
728
9b485d32 729 /* This is an external symbol. */
252b5132
RH		 730 r_index -= symtab_hdr->sh_info;
731 h = (struct elf_link_hash_entry *)
732 elf_sym_hashes (abfd)[r_index];
733
734 /* If the relocation is against a static symbol it must be within
735 the current section and so cannot be a cross ARM/Thumb relocation. */
736 if (h == NULL)
737 continue;
738
739 switch (r_type)
740 {
741 case R_ARM_PC24:
742 /* This one is a call from arm code. We need to look up
2f0ca46a 743 the target of the call. If it is a thumb target, we
252b5132 744 insert glue. */
252b5132
RH		 745 if (ELF_ST_TYPE(h->type) == STT_ARM_TFUNC)
746 record_arm_to_thumb_glue (link_info, h);
747 break;
748
749 case R_ARM_THM_PC22:
f21f3fe0 750 /* This one is a call from thumb code. We look
2f0ca46a 751 up the target of the call. If it is not a thumb
bcbdc74c 752 target, we insert glue. */
252b5132
RH		 753 if (ELF_ST_TYPE (h->type) != STT_ARM_TFUNC)
754 record_thumb_to_arm_glue (link_info, h);
755 break;
756
757 default:
758 break;
759 }
760 }
761 }
762
763 return true;
9a5aca8c 764
252b5132
RH		 765error_return:
766 if (free_relocs != NULL)
767 free (free_relocs);
768 if (free_contents != NULL)
769 free (free_contents);
770 if (free_extsyms != NULL)
771 free (free_extsyms);
9a5aca8c 772
252b5132 773 return false;
252b5132
RH		 774}
775
776/* The thumb form of a long branch is a bit finicky, because the offset
777 encoding is split over two fields, each in it's own instruction. They
f21f3fe0 778 can occur in any order. So given a thumb form of long branch, and an
252b5132 779 offset, insert the offset into the thumb branch and return finished
f21f3fe0 780 instruction.
252b5132 781
f21f3fe0 782 It takes two thumb instructions to encode the target address. Each has
252b5132 783 11 bits to invest. The upper 11 bits are stored in one (identifed by
f21f3fe0
UD		 784 H-0.. see below), the lower 11 bits are stored in the other (identified
785 by H-1).
252b5132 786
f21f3fe0 787 Combine together and shifted left by 1 (it's a half word address) and
252b5132
RH		 788 there you have it.
789
790 Op: 1111 = F,
791 H-0, upper address-0 = 000
792 Op: 1111 = F,
793 H-1, lower address-0 = 800
794
f21f3fe0 795 They can be ordered either way, but the arm tools I've seen always put
252b5132
RH		 796 the lower one first. It probably doesn't matter. krk@cygnus.com
797
798 XXX: Actually the order does matter. The second instruction (H-1)
799 moves the computed address into the PC, so it must be the second one
800 in the sequence. The problem, however is that whilst little endian code
801 stores the instructions in HI then LOW order, big endian code does the
dfc5f959 802 reverse. nickc@cygnus.com. */
252b5132 803
dfc5f959
NC		 804#define LOW_HI_ORDER 0xF800F000
805#define HI_LOW_ORDER 0xF000F800
252b5132
RH		 806
807static insn32
808insert_thumb_branch (br_insn, rel_off)
809 insn32 br_insn;
810 int rel_off;
811{
812 unsigned int low_bits;
813 unsigned int high_bits;
814
252b5132
RH		 815 BFD_ASSERT ((rel_off & 1) != 1);
816
dfc5f959
NC		 817 rel_off >>= 1; /* Half word aligned address. */
818 low_bits = rel_off & 0x000007FF; /* The bottom 11 bits. */
819 high_bits = (rel_off >> 11) & 0x000007FF; /* The top 11 bits. */
252b5132
RH		 820
821 if ((br_insn & LOW_HI_ORDER) == LOW_HI_ORDER)
822 br_insn = LOW_HI_ORDER | (low_bits << 16) | high_bits;
823 else if ((br_insn & HI_LOW_ORDER) == HI_LOW_ORDER)
824 br_insn = HI_LOW_ORDER | (high_bits << 16) | low_bits;
825 else
9b485d32
NC		 826 /* FIXME: abort is probably not the right call. krk@cygnus.com */
827 abort (); /* error - not a valid branch instruction form. */
252b5132 828
252b5132
RH		 829 return br_insn;
830}
831
9b485d32
NC		 832/* Thumb code calling an ARM function. */
833
252b5132
RH		 834static int
835elf32_thumb_to_arm_stub (info, name, input_bfd, output_bfd, input_section,
836 hit_data, sym_sec, offset, addend, val)
bcbdc74c
NC		 837 struct bfd_link_info * info;
838 const char * name;
839 bfd * input_bfd;
840 bfd * output_bfd;
841 asection * input_section;
842 bfd_byte * hit_data;
843 asection * sym_sec;
844 bfd_vma offset;
845 bfd_signed_vma addend;
846 bfd_vma val;
252b5132 847{
bcbdc74c 848 asection * s = 0;
252b5132
RH		 849 long int my_offset;
850 unsigned long int tmp;
851 long int ret_offset;
bcbdc74c
NC		 852 struct elf_link_hash_entry * myh;
853 struct elf32_arm_link_hash_table * globals;
252b5132
RH		 854
855 myh = find_thumb_glue (info, name, input_bfd);
856 if (myh == NULL)
857 return false;
858
859 globals = elf32_arm_hash_table (info);
860
861 BFD_ASSERT (globals != NULL);
862 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
863
864 my_offset = myh->root.u.def.value;
865
866 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
867 THUMB2ARM_GLUE_SECTION_NAME);
868
869 BFD_ASSERT (s != NULL);
870 BFD_ASSERT (s->contents != NULL);
871 BFD_ASSERT (s->output_section != NULL);
872
873 if ((my_offset & 0x01) == 0x01)
874 {
875 if (sym_sec != NULL
876 && sym_sec->owner != NULL
877 && !INTERWORK_FLAG (sym_sec->owner))
878 {
879 _bfd_error_handler
9b485d32 880 (_("%s(%s): warning: interworking not enabled."),
252b5132
RH		 881 bfd_get_filename (sym_sec->owner), name);
882 _bfd_error_handler
9b485d32 883 (_(" first occurrence: %s: thumb call to arm"),
252b5132
RH		 884 bfd_get_filename (input_bfd));
885
886 return false;
887 }
888
889 --my_offset;
890 myh->root.u.def.value = my_offset;
891
892 bfd_put_16 (output_bfd, t2a1_bx_pc_insn,
893 s->contents + my_offset);
894
895 bfd_put_16 (output_bfd, t2a2_noop_insn,
896 s->contents + my_offset + 2);
897
898 ret_offset =
9b485d32
NC		 899 /* Address of destination of the stub. */
900 ((bfd_signed_vma) val)
252b5132 901 - ((bfd_signed_vma)
9b485d32
NC		 902 /* Offset from the start of the current section to the start of the stubs. */
903 (s->output_offset
904 /* Offset of the start of this stub from the start of the stubs. */
905 + my_offset
906 /* Address of the start of the current section. */
907 + s->output_section->vma)
908 /* The branch instruction is 4 bytes into the stub. */
909 + 4
910 /* ARM branches work from the pc of the instruction + 8. */
911 + 8);
252b5132
RH		 912
913 bfd_put_32 (output_bfd,
914 t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
915 s->contents + my_offset + 4);
916 }
917
918 BFD_ASSERT (my_offset <= globals->thumb_glue_size);
919
920 /* Now go back and fix up the original BL insn to point
921 to here. */
922 ret_offset =
923 s->output_offset
924 + my_offset
925 - (input_section->output_offset
926 + offset + addend)
756fa1b9 927 - 8;
252b5132
RH		 928
929 tmp = bfd_get_32 (input_bfd, hit_data
930 - input_section->vma);
931
932 bfd_put_32 (output_bfd,
933 insert_thumb_branch (tmp, ret_offset),
934 hit_data - input_section->vma);
935
936 return true;
937}
938
9b485d32
NC		 939/* Arm code calling a Thumb function. */
940
252b5132
RH		 941static int
942elf32_arm_to_thumb_stub (info, name, input_bfd, output_bfd, input_section,
943 hit_data, sym_sec, offset, addend, val)
bcbdc74c
NC		 944 struct bfd_link_info * info;
945 const char * name;
946 bfd * input_bfd;
947 bfd * output_bfd;
948 asection * input_section;
949 bfd_byte * hit_data;
950 asection * sym_sec;
951 bfd_vma offset;
952 bfd_signed_vma addend;
953 bfd_vma val;
252b5132
RH		 954{
955 unsigned long int tmp;
956 long int my_offset;
bcbdc74c 957 asection * s;
252b5132 958 long int ret_offset;
bcbdc74c
NC		 959 struct elf_link_hash_entry * myh;
960 struct elf32_arm_link_hash_table * globals;
252b5132
RH		 961
962 myh = find_arm_glue (info, name, input_bfd);
963 if (myh == NULL)
964 return false;
965
966 globals = elf32_arm_hash_table (info);
967
968 BFD_ASSERT (globals != NULL);
969 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
970
971 my_offset = myh->root.u.def.value;
972 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
973 ARM2THUMB_GLUE_SECTION_NAME);
974 BFD_ASSERT (s != NULL);
975 BFD_ASSERT (s->contents != NULL);
976 BFD_ASSERT (s->output_section != NULL);
977
978 if ((my_offset & 0x01) == 0x01)
979 {
980 if (sym_sec != NULL
981 && sym_sec->owner != NULL
982 && !INTERWORK_FLAG (sym_sec->owner))
983 {
984 _bfd_error_handler
9b485d32 985 (_("%s(%s): warning: interworking not enabled."),
252b5132
RH		 986 bfd_get_filename (sym_sec->owner), name);
987 _bfd_error_handler
9b485d32 988 (_(" first occurrence: %s: arm call to thumb"),
252b5132
RH		 989 bfd_get_filename (input_bfd));
990 }
9b485d32 991
252b5132
RH		 992 --my_offset;
993 myh->root.u.def.value = my_offset;
994
995 bfd_put_32 (output_bfd, a2t1_ldr_insn,
996 s->contents + my_offset);
997
998 bfd_put_32 (output_bfd, a2t2_bx_r12_insn,
999 s->contents + my_offset + 4);
1000
1001 /* It's a thumb address. Add the low order bit. */
1002 bfd_put_32 (output_bfd, val | a2t3_func_addr_insn,
1003 s->contents + my_offset + 8);
1004 }
1005
1006 BFD_ASSERT (my_offset <= globals->arm_glue_size);
1007
1008 tmp = bfd_get_32 (input_bfd, hit_data);
1009 tmp = tmp & 0xFF000000;
1010
9b485d32 1011 /* Somehow these are both 4 too far, so subtract 8. */
252b5132
RH		 1012 ret_offset = s->output_offset
1013 + my_offset
1014 + s->output_section->vma
1015 - (input_section->output_offset
1016 + input_section->output_section->vma
1017 + offset + addend)
1018 - 8;
9a5aca8c 1019
252b5132
RH		 1020 tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
1021
1022 bfd_put_32 (output_bfd, tmp, hit_data
1023 - input_section->vma);
1024
252b5132
RH		 1025 return true;
1026}
1027
1028/* Perform a relocation as part of a final link. */
9b485d32 1029
252b5132
RH		 1030static bfd_reloc_status_type
1031elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
1032 input_section, contents, rel, value,
780a67af 1033 info, sym_sec, sym_name, sym_flags, h)
252b5132
RH		 1034 reloc_howto_type * howto;
1035 bfd * input_bfd;
1036 bfd * output_bfd;
1037 asection * input_section;
1038 bfd_byte * contents;
1039 Elf_Internal_Rela * rel;
1040 bfd_vma value;
1041 struct bfd_link_info * info;
1042 asection * sym_sec;
1043 const char * sym_name;
1044 unsigned char sym_flags;
780a67af 1045 struct elf_link_hash_entry * h;
252b5132
RH		 1046{
1047 unsigned long r_type = howto->type;
1048 unsigned long r_symndx;
1049 bfd_byte * hit_data = contents + rel->r_offset;
1050 bfd * dynobj = NULL;
1051 Elf_Internal_Shdr * symtab_hdr;
1052 struct elf_link_hash_entry ** sym_hashes;
1053 bfd_vma * local_got_offsets;
1054 asection * sgot = NULL;
1055 asection * splt = NULL;
1056 asection * sreloc = NULL;
252b5132 1057 bfd_vma addend;
ba96a88f
NC		 1058 bfd_signed_vma signed_addend;
1059 struct elf32_arm_link_hash_table * globals;
f21f3fe0 1060
cac15327
NC		 1061 /* If the start address has been set, then set the EF_ARM_HASENTRY
1062 flag. Setting this more than once is redundant, but the cost is
1063 not too high, and it keeps the code simple.
99e4ae17 1064
cac15327
NC		 1065 The test is done here, rather than somewhere else, because the
1066 start address is only set just before the final link commences.
1067
1068 Note - if the user deliberately sets a start address of 0, the
1069 flag will not be set. */
1070 if (bfd_get_start_address (output_bfd) != 0)
1071 elf_elfheader (output_bfd)->e_flags |= EF_ARM_HASENTRY;
99e4ae17 1072
ba96a88f 1073 globals = elf32_arm_hash_table (info);
f21f3fe0 1074
252b5132
RH		 1075 dynobj = elf_hash_table (info)->dynobj;
1076 if (dynobj)
1077 {
1078 sgot = bfd_get_section_by_name (dynobj, ".got");
1079 splt = bfd_get_section_by_name (dynobj, ".plt");
1080 }
1081 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1082 sym_hashes = elf_sym_hashes (input_bfd);
1083 local_got_offsets = elf_local_got_offsets (input_bfd);
1084 r_symndx = ELF32_R_SYM (rel->r_info);
1085
1086#ifdef USE_REL
ba96a88f
NC		 1087 addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask;
1088
1089 if (addend & ((howto->src_mask + 1) >> 1))
1090 {
1091 signed_addend = -1;
1092 signed_addend &= ~ howto->src_mask;
1093 signed_addend |= addend;
1094 }
1095 else
1096 signed_addend = addend;
252b5132 1097#else
ba96a88f 1098 addend = signed_addend = rel->r_addend;
252b5132 1099#endif
f21f3fe0 1100
252b5132
RH		 1101 switch (r_type)
1102 {
1103 case R_ARM_NONE:
1104 return bfd_reloc_ok;
1105
1106 case R_ARM_PC24:
1107 case R_ARM_ABS32:
1108 case R_ARM_REL32:
dfc5f959
NC		 1109#ifndef OLD_ARM_ABI
1110 case R_ARM_XPC25:
1111#endif
252b5132 1112 /* When generating a shared object, these relocations are copied
9b485d32 1113 into the output file to be resolved at run time. */
252b5132
RH		 1114 if (info->shared
1115 && (r_type != R_ARM_PC24
99e4ae17 1116 || (h != NULL
252b5132
RH		 1117 && h->dynindx != -1
1118 && (! info->symbolic
1119 || (h->elf_link_hash_flags
1120 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1121 {
1122 Elf_Internal_Rel outrel;
1123 boolean skip, relocate;
f21f3fe0 1124
252b5132
RH		 1125 if (sreloc == NULL)
1126 {
1127 const char * name;
f21f3fe0 1128
252b5132
RH		 1129 name = (bfd_elf_string_from_elf_section
1130 (input_bfd,
1131 elf_elfheader (input_bfd)->e_shstrndx,
1132 elf_section_data (input_section)->rel_hdr.sh_name));
1133 if (name == NULL)
1134 return bfd_reloc_notsupported;
f21f3fe0 1135
252b5132
RH		 1136 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
1137 && strcmp (bfd_get_section_name (input_bfd,
1138 input_section),
1139 name + 4) == 0);
f21f3fe0 1140
252b5132
RH		 1141 sreloc = bfd_get_section_by_name (dynobj, name);
1142 BFD_ASSERT (sreloc != NULL);
1143 }
f21f3fe0 1144
252b5132 1145 skip = false;
f21f3fe0 1146
252b5132
RH		 1147 if (elf_section_data (input_section)->stab_info == NULL)
1148 outrel.r_offset = rel->r_offset;
1149 else
1150 {
1151 bfd_vma off;
f21f3fe0 1152
252b5132
RH		 1153 off = (_bfd_stab_section_offset
1154 (output_bfd, &elf_hash_table (info)->stab_info,
1155 input_section,
1156 & elf_section_data (input_section)->stab_info,
1157 rel->r_offset));
1158 if (off == (bfd_vma) -1)
1159 skip = true;
1160 outrel.r_offset = off;
1161 }
f21f3fe0 1162
252b5132
RH		 1163 outrel.r_offset += (input_section->output_section->vma
1164 + input_section->output_offset);
f21f3fe0 1165
252b5132
RH		 1166 if (skip)
1167 {
1168 memset (&outrel, 0, sizeof outrel);
1169 relocate = false;
1170 }
1171 else if (r_type == R_ARM_PC24)
1172 {
1173 BFD_ASSERT (h != NULL && h->dynindx != -1);
1174 if ((input_section->flags & SEC_ALLOC) != 0)
1175 relocate = false;
1176 else
1177 relocate = true;
1178 outrel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_PC24);
1179 }
1180 else
1181 {
1182 if (h == NULL
1183 || ((info->symbolic || h->dynindx == -1)
1184 && (h->elf_link_hash_flags
1185 & ELF_LINK_HASH_DEF_REGULAR) != 0))
1186 {
1187 relocate = true;
1188 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
1189 }
1190 else
1191 {
1192 BFD_ASSERT (h->dynindx != -1);
1193 if ((input_section->flags & SEC_ALLOC) != 0)
1194 relocate = false;
1195 else
1196 relocate = true;
1197 outrel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_ABS32);
1198 }
1199 }
f21f3fe0 1200
252b5132
RH		 1201 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1202 (((Elf32_External_Rel *)
1203 sreloc->contents)
1204 + sreloc->reloc_count));
1205 ++sreloc->reloc_count;
9a5aca8c 1206
f21f3fe0 1207 /* If this reloc is against an external symbol, we do not want to
252b5132 1208 fiddle with the addend. Otherwise, we need to include the symbol
9b485d32 1209 value so that it becomes an addend for the dynamic reloc. */
252b5132
RH		 1210 if (! relocate)
1211 return bfd_reloc_ok;
9a5aca8c 1212
f21f3fe0 1213 return _bfd_final_link_relocate (howto, input_bfd, input_section,
252b5132
RH		 1214 contents, rel->r_offset, value,
1215 (bfd_vma) 0);
1216 }
1217 else switch (r_type)
1218 {
dfc5f959
NC		 1219#ifndef OLD_ARM_ABI
1220 case R_ARM_XPC25: /* Arm BLX instruction. */
1221#endif
1222 case R_ARM_PC24: /* Arm B/BL instruction */
1223#ifndef OLD_ARM_ABI
1224 if (r_type == R_ARM_XPC25)
252b5132 1225 {
dfc5f959
NC		 1226 /* Check for Arm calling Arm function. */
1227 /* FIXME: Should we translate the instruction into a BL
1228 instruction instead ? */
1229 if (sym_flags != STT_ARM_TFUNC)
1230 _bfd_error_handler (_("\
1231%s: Warning: Arm BLX instruction targets Arm function '%s'."),
1232 bfd_get_filename (input_bfd),
b1bcb49f 1233 h ? h->root.root.string : "(local)");
dfc5f959
NC		 1234 }
1235 else
1236#endif
1237 {
1238 /* Check for Arm calling Thumb function. */
1239 if (sym_flags == STT_ARM_TFUNC)
1240 {
1241 elf32_arm_to_thumb_stub (info, sym_name, input_bfd, output_bfd,
1242 input_section, hit_data, sym_sec, rel->r_offset,
1243 signed_addend, value);
1244 return bfd_reloc_ok;
1245 }
252b5132 1246 }
ba96a88f
NC		 1247
1248 if ( strcmp (bfd_get_target (input_bfd), "elf32-littlearm-oabi") == 0
1249 || strcmp (bfd_get_target (input_bfd), "elf32-bigarm-oabi") == 0)
1250 {
1251 /* The old way of doing things. Trearing the addend as a
1252 byte sized field and adding in the pipeline offset. */
ba96a88f
NC		 1253 value -= (input_section->output_section->vma
1254 + input_section->output_offset);
1255 value -= rel->r_offset;
1256 value += addend;
f21f3fe0 1257
ba96a88f
NC		 1258 if (! globals->no_pipeline_knowledge)
1259 value -= 8;
1260 }
1261 else
1262 {
1263 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
1264 where:
1265 S is the address of the symbol in the relocation.
1266 P is address of the instruction being relocated.
1267 A is the addend (extracted from the instruction) in bytes.
f21f3fe0 1268
ba96a88f
NC		 1269 S is held in 'value'.
1270 P is the base address of the section containing the instruction
1271 plus the offset of the reloc into that section, ie:
1272 (input_section->output_section->vma +
1273 input_section->output_offset +
1274 rel->r_offset).
1275 A is the addend, converted into bytes, ie:
1276 (signed_addend * 4)
1277
1278 Note: None of these operations have knowledge of the pipeline
1279 size of the processor, thus it is up to the assembler to encode
1280 this information into the addend. */
ba96a88f
NC		 1281 value -= (input_section->output_section->vma
1282 + input_section->output_offset);
1283 value -= rel->r_offset;
1284 value += (signed_addend << howto->size);
f21f3fe0 1285
ba96a88f
NC		 1286 /* Previous versions of this code also used to add in the pipeline
1287 offset here. This is wrong because the linker is not supposed
1288 to know about such things, and one day it might change. In order
1289 to support old binaries that need the old behaviour however, so
1290 we attempt to detect which ABI was used to create the reloc. */
1291 if (! globals->no_pipeline_knowledge)
f21f3fe0 1292 {
ba96a88f 1293 Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form */
f21f3fe0 1294
ba96a88f 1295 i_ehdrp = elf_elfheader (input_bfd);
f21f3fe0 1296
ba96a88f
NC		 1297 if (i_ehdrp->e_ident[EI_OSABI] == 0)
1298 value -= 8;
1299 }
1300 }
23080146 1301
dcb5e6e6
NC		 1302 signed_addend = value;
1303 signed_addend >>= howto->rightshift;
9a5aca8c 1304
59f2c4e7
NC		 1305 /* It is not an error for an undefined weak reference to be
1306 out of range. Any program that branches to such a symbol
9a5aca8c
AM		 1307 is going to crash anyway, so there is no point worrying
1308 about getting the destination exactly right. */
59f2c4e7
NC		 1309 if (! h || h->root.type != bfd_link_hash_undefweak)
1310 {
9b485d32 1311 /* Perform a signed range check. */
dcb5e6e6 1312 if ( signed_addend > ((bfd_signed_vma) (howto->dst_mask >> 1))
59f2c4e7
NC		 1313 || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1)))
1314 return bfd_reloc_overflow;
1315 }
9a5aca8c 1316
dcb5e6e6
NC		 1317#ifndef OLD_ARM_ABI
1318 /* If necessary set the H bit in the BLX instruction. */
1319 if (r_type == R_ARM_XPC25 && ((value & 2) == 2))
1320 value = (signed_addend & howto->dst_mask)
1321 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask))
1322 | (1 << 24);
1323 else
1324#endif
1325 value = (signed_addend & howto->dst_mask)
1326 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
252b5132 1327 break;
f21f3fe0 1328
252b5132
RH		 1329 case R_ARM_ABS32:
1330 value += addend;
1331 if (sym_flags == STT_ARM_TFUNC)
1332 value |= 1;
1333 break;
f21f3fe0 1334
252b5132
RH		 1335 case R_ARM_REL32:
1336 value -= (input_section->output_section->vma
62efb346 1337 + input_section->output_offset + rel->r_offset);
252b5132
RH		 1338 value += addend;
1339 break;
1340 }
f21f3fe0 1341
252b5132
RH		 1342 bfd_put_32 (input_bfd, value, hit_data);
1343 return bfd_reloc_ok;
1344
1345 case R_ARM_ABS8:
1346 value += addend;
1347 if ((long) value > 0x7f || (long) value < -0x80)
1348 return bfd_reloc_overflow;
1349
1350 bfd_put_8 (input_bfd, value, hit_data);
1351 return bfd_reloc_ok;
1352
1353 case R_ARM_ABS16:
1354 value += addend;
1355
1356 if ((long) value > 0x7fff || (long) value < -0x8000)
1357 return bfd_reloc_overflow;
1358
1359 bfd_put_16 (input_bfd, value, hit_data);
1360 return bfd_reloc_ok;
1361
1362 case R_ARM_ABS12:
1363 /* Support ldr and str instruction for the arm */
1364 /* Also thumb b (unconditional branch). ??? Really? */
1365 value += addend;
1366
1367 if ((long) value > 0x7ff || (long) value < -0x800)
1368 return bfd_reloc_overflow;
1369
1370 value |= (bfd_get_32 (input_bfd, hit_data) & 0xfffff000);
1371 bfd_put_32 (input_bfd, value, hit_data);
1372 return bfd_reloc_ok;
1373
1374 case R_ARM_THM_ABS5:
9b485d32 1375 /* Support ldr and str instructions for the thumb. */
252b5132
RH		 1376#ifdef USE_REL
1377 /* Need to refetch addend. */
1378 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
1379 /* ??? Need to determine shift amount from operand size. */
1380 addend >>= howto->rightshift;
1381#endif
1382 value += addend;
1383
1384 /* ??? Isn't value unsigned? */
1385 if ((long) value > 0x1f || (long) value < -0x10)
1386 return bfd_reloc_overflow;
1387
1388 /* ??? Value needs to be properly shifted into place first. */
1389 value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
1390 bfd_put_16 (input_bfd, value, hit_data);
1391 return bfd_reloc_ok;
1392
dfc5f959
NC		 1393#ifndef OLD_ARM_ABI
1394 case R_ARM_THM_XPC22:
1395#endif
252b5132 1396 case R_ARM_THM_PC22:
dfc5f959 1397 /* Thumb BL (branch long instruction). */
252b5132 1398 {
ba96a88f
NC		 1399 bfd_vma relocation;
1400 boolean overflow = false;
1401 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
1402 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
252b5132 1403 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
ba96a88f
NC		 1404 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
1405 bfd_vma check;
252b5132 1406 bfd_signed_vma signed_check;
252b5132
RH		 1407
1408#ifdef USE_REL
1409 /* Need to refetch the addend and squish the two 11 bit pieces
1410 together. */
1411 {
ba96a88f
NC		 1412 bfd_vma upper = upper_insn & 0x7ff;
1413 bfd_vma lower = lower_insn & 0x7ff;
9b485d32 1414 upper = (upper ^ 0x400) - 0x400; /* Sign extend. */
252b5132 1415 addend = (upper << 12) | (lower << 1);
ba96a88f 1416 signed_addend = addend;
252b5132
RH		 1417 }
1418#endif
dfc5f959
NC		 1419#ifndef OLD_ARM_ABI
1420 if (r_type == R_ARM_THM_XPC22)
1421 {
1422 /* Check for Thumb to Thumb call. */
1423 /* FIXME: Should we translate the instruction into a BL
1424 instruction instead ? */
1425 if (sym_flags == STT_ARM_TFUNC)
1426 _bfd_error_handler (_("\
1427%s: Warning: Thumb BLX instruction targets thumb function '%s'."),
1428 bfd_get_filename (input_bfd),
b1bcb49f 1429 h ? h->root.root.string : "(local)");
dfc5f959
NC		 1430 }
1431 else
1432#endif
252b5132 1433 {
dfc5f959
NC		 1434 /* If it is not a call to Thumb, assume call to Arm.
1435 If it is a call relative to a section name, then it is not a
1436 function call at all, but rather a long jump. */
1437 if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION)
1438 {
1439 if (elf32_thumb_to_arm_stub
1440 (info, sym_name, input_bfd, output_bfd, input_section,
1441 hit_data, sym_sec, rel->r_offset, signed_addend, value))
1442 return bfd_reloc_ok;
1443 else
1444 return bfd_reloc_dangerous;
1445 }
252b5132 1446 }
f21f3fe0 1447
ba96a88f 1448 relocation = value + signed_addend;
f21f3fe0 1449
252b5132 1450 relocation -= (input_section->output_section->vma
ba96a88f
NC		 1451 + input_section->output_offset
1452 + rel->r_offset);
9a5aca8c 1453
ba96a88f
NC		 1454 if (! globals->no_pipeline_knowledge)
1455 {
9b485d32 1456 Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form. */
9a5aca8c 1457
ba96a88f 1458 i_ehdrp = elf_elfheader (input_bfd);
f21f3fe0 1459
ba96a88f
NC		 1460 /* Previous versions of this code also used to add in the pipline
1461 offset here. This is wrong because the linker is not supposed
1462 to know about such things, and one day it might change. In order
1463 to support old binaries that need the old behaviour however, so
1464 we attempt to detect which ABI was used to create the reloc. */
1465 if ( strcmp (bfd_get_target (input_bfd), "elf32-littlearm-oabi") == 0
1466 || strcmp (bfd_get_target (input_bfd), "elf32-bigarm-oabi") == 0
1467 || i_ehdrp->e_ident[EI_OSABI] == 0)
1468 relocation += 4;
1469 }
f21f3fe0 1470
252b5132
RH		 1471 check = relocation >> howto->rightshift;
1472
1473 /* If this is a signed value, the rightshift just dropped
1474 leading 1 bits (assuming twos complement). */
1475 if ((bfd_signed_vma) relocation >= 0)
1476 signed_check = check;
1477 else
1478 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
1479
252b5132 1480 /* Assumes two's complement. */
ba96a88f 1481 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
252b5132
RH		 1482 overflow = true;
1483
1484 /* Put RELOCATION back into the insn. */
1485 upper_insn = (upper_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 12) & 0x7ff);
1486 lower_insn = (lower_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 1) & 0x7ff);
1487
df425bc0 1488#ifndef OLD_ARM_ABI
4f3c3dbb
NC		 1489 if (r_type == R_ARM_THM_XPC22
1490 && ((lower_insn & 0x1800) == 0x0800))
1491 /* Remove bit zero of the adjusted offset. Bit zero can only be
1492 set if the upper insn is at a half-word boundary, since the
1493 destination address, an ARM instruction, must always be on a
1494 word boundary. The semantics of the BLX (1) instruction, however,
1495 are that bit zero in the offset must always be zero, and the
1496 corresponding bit one in the target address will be set from bit
1497 one of the source address. */
1498 lower_insn &= ~1;
99e4ae17 1499#endif
252b5132
RH		 1500 /* Put the relocated value back in the object file: */
1501 bfd_put_16 (input_bfd, upper_insn, hit_data);
1502 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
1503
1504 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
1505 }
1506 break;
1507
1508 case R_ARM_GNU_VTINHERIT:
1509 case R_ARM_GNU_VTENTRY:
1510 return bfd_reloc_ok;
1511
1512 case R_ARM_COPY:
1513 return bfd_reloc_notsupported;
1514
1515 case R_ARM_GLOB_DAT:
1516 return bfd_reloc_notsupported;
1517
1518 case R_ARM_JUMP_SLOT:
1519 return bfd_reloc_notsupported;
1520
1521 case R_ARM_RELATIVE:
1522 return bfd_reloc_notsupported;
1523
1524 case R_ARM_GOTOFF:
1525 /* Relocation is relative to the start of the
1526 global offset table. */
1527
1528 BFD_ASSERT (sgot != NULL);
1529 if (sgot == NULL)
1530 return bfd_reloc_notsupported;
9a5aca8c 1531
252b5132
RH		 1532 /* Note that sgot->output_offset is not involved in this
1533 calculation. We always want the start of .got. If we
1534 define _GLOBAL_OFFSET_TABLE in a different way, as is
1535 permitted by the ABI, we might have to change this
9b485d32 1536 calculation. */
252b5132 1537 value -= sgot->output_section->vma;
f21f3fe0 1538 return _bfd_final_link_relocate (howto, input_bfd, input_section,
99e4ae17
AJ		 1539 contents, rel->r_offset, value,
1540 (bfd_vma) 0);
252b5132
RH		 1541
1542 case R_ARM_GOTPC:
a7c10850 1543 /* Use global offset table as symbol value. */
252b5132 1544 BFD_ASSERT (sgot != NULL);
f21f3fe0 1545
252b5132
RH		 1546 if (sgot == NULL)
1547 return bfd_reloc_notsupported;
1548
1549 value = sgot->output_section->vma;
f21f3fe0 1550 return _bfd_final_link_relocate (howto, input_bfd, input_section,
99e4ae17
AJ		 1551 contents, rel->r_offset, value,
1552 (bfd_vma) 0);
f21f3fe0 1553
252b5132
RH		 1554 case R_ARM_GOT32:
1555 /* Relocation is to the entry for this symbol in the
9b485d32 1556 global offset table. */
252b5132
RH		 1557 if (sgot == NULL)
1558 return bfd_reloc_notsupported;
f21f3fe0 1559
252b5132
RH		 1560 if (h != NULL)
1561 {
1562 bfd_vma off;
f21f3fe0 1563
252b5132
RH		 1564 off = h->got.offset;
1565 BFD_ASSERT (off != (bfd_vma) -1);
f21f3fe0 1566
252b5132
RH		 1567 if (!elf_hash_table (info)->dynamic_sections_created ||
1568 (info->shared && (info->symbolic || h->dynindx == -1)
1569 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1570 {
1571 /* This is actually a static link, or it is a -Bsymbolic link
1572 and the symbol is defined locally. We must initialize this
1573 entry in the global offset table. Since the offset must
1574 always be a multiple of 4, we use the least significant bit
1575 to record whether we have initialized it already.
f21f3fe0 1576
252b5132 1577 When doing a dynamic link, we create a .rel.got relocation
f21f3fe0 1578 entry to initialize the value. This is done in the
9b485d32 1579 finish_dynamic_symbol routine. */
252b5132
RH		 1580 if ((off & 1) != 0)
1581 off &= ~1;
1582 else
1583 {
1584 bfd_put_32 (output_bfd, value, sgot->contents + off);
1585 h->got.offset |= 1;
1586 }
1587 }
f21f3fe0 1588
252b5132
RH		 1589 value = sgot->output_offset + off;
1590 }
1591 else
1592 {
1593 bfd_vma off;
f21f3fe0 1594
252b5132
RH		 1595 BFD_ASSERT (local_got_offsets != NULL &&
1596 local_got_offsets[r_symndx] != (bfd_vma) -1);
f21f3fe0 1597
252b5132 1598 off = local_got_offsets[r_symndx];
f21f3fe0 1599
252b5132
RH		 1600 /* The offset must always be a multiple of 4. We use the
1601 least significant bit to record whether we have already
9b485d32 1602 generated the necessary reloc. */
252b5132
RH		 1603 if ((off & 1) != 0)
1604 off &= ~1;
1605 else
1606 {
1607 bfd_put_32 (output_bfd, value, sgot->contents + off);
f21f3fe0 1608
252b5132
RH		 1609 if (info->shared)
1610 {
1611 asection * srelgot;
1612 Elf_Internal_Rel outrel;
f21f3fe0 1613
252b5132
RH		 1614 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
1615 BFD_ASSERT (srelgot != NULL);
f21f3fe0 1616
252b5132 1617 outrel.r_offset = (sgot->output_section->vma
f21f3fe0 1618 + sgot->output_offset
252b5132
RH		 1619 + off);
1620 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
1621 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1622 (((Elf32_External_Rel *)
1623 srelgot->contents)
1624 + srelgot->reloc_count));
1625 ++srelgot->reloc_count;
1626 }
f21f3fe0 1627
252b5132
RH		 1628 local_got_offsets[r_symndx] |= 1;
1629 }
f21f3fe0 1630
252b5132
RH		 1631 value = sgot->output_offset + off;
1632 }
9a5aca8c 1633
f21f3fe0 1634 return _bfd_final_link_relocate (howto, input_bfd, input_section,
99e4ae17
AJ		 1635 contents, rel->r_offset, value,
1636 (bfd_vma) 0);
f21f3fe0 1637
252b5132
RH		 1638 case R_ARM_PLT32:
1639 /* Relocation is to the entry for this symbol in the
1640 procedure linkage table. */
1641
1642 /* Resolve a PLT32 reloc against a local symbol directly,
9b485d32 1643 without using the procedure linkage table. */
252b5132
RH		 1644 if (h == NULL)
1645 return _bfd_final_link_relocate (howto, input_bfd, input_section,
99e4ae17
AJ		 1646 contents, rel->r_offset, value,
1647 (bfd_vma) 0);
252b5132
RH		 1648
1649 if (h->plt.offset == (bfd_vma) -1)
1650 /* We didn't make a PLT entry for this symbol. This
1651 happens when statically linking PIC code, or when
1652 using -Bsymbolic. */
1653 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1654 contents, rel->r_offset, value,
1655 (bfd_vma) 0);
1656
1657 BFD_ASSERT(splt != NULL);
1658 if (splt == NULL)
1659 return bfd_reloc_notsupported;
1660
1661 value = (splt->output_section->vma
1662 + splt->output_offset
1663 + h->plt.offset);
1664 return _bfd_final_link_relocate (howto, input_bfd, input_section,
99e4ae17
AJ		 1665 contents, rel->r_offset, value,
1666 (bfd_vma) 0);
f21f3fe0 1667
252b5132
RH		 1668 case R_ARM_SBREL32:
1669 return bfd_reloc_notsupported;
1670
1671 case R_ARM_AMP_VCALL9:
1672 return bfd_reloc_notsupported;
1673
1674 case R_ARM_RSBREL32:
1675 return bfd_reloc_notsupported;
1676
1677 case R_ARM_THM_RPC22:
1678 return bfd_reloc_notsupported;
1679
1680 case R_ARM_RREL32:
1681 return bfd_reloc_notsupported;
1682
1683 case R_ARM_RABS32:
1684 return bfd_reloc_notsupported;
1685
1686 case R_ARM_RPC24:
1687 return bfd_reloc_notsupported;
1688
1689 case R_ARM_RBASE:
1690 return bfd_reloc_notsupported;
1691
1692 default:
1693 return bfd_reloc_notsupported;
1694 }
1695}
1696
98c1d4aa
NC		 1697#ifdef USE_REL
1698/* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
1699static void
1700arm_add_to_rel (abfd, address, howto, increment)
1701 bfd * abfd;
59f2c4e7 1702 bfd_byte * address;
98c1d4aa
NC		 1703 reloc_howto_type * howto;
1704 bfd_signed_vma increment;
1705{
98c1d4aa
NC		 1706 bfd_signed_vma addend;
1707
9a5aca8c 1708 if (howto->type == R_ARM_THM_PC22)
98c1d4aa 1709 {
9a5aca8c
AM		 1710 int upper_insn, lower_insn;
1711 int upper, lower;
98c1d4aa 1712
9a5aca8c
AM		 1713 upper_insn = bfd_get_16 (abfd, address);
1714 lower_insn = bfd_get_16 (abfd, address + 2);
1715 upper = upper_insn & 0x7ff;
1716 lower = lower_insn & 0x7ff;
1717
1718 addend = (upper << 12) | (lower << 1);
ddda4409 1719 addend += increment;
9a5aca8c 1720 addend >>= 1;
98c1d4aa 1721
9a5aca8c
AM		 1722 upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
1723 lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
1724
1725 bfd_put_16 (abfd, upper_insn, address);
1726 bfd_put_16 (abfd, lower_insn, address + 2);
1727 }
1728 else
1729 {
1730 bfd_vma contents;
1731
1732 contents = bfd_get_32 (abfd, address);
1733
1734 /* Get the (signed) value from the instruction. */
1735 addend = contents & howto->src_mask;
1736 if (addend & ((howto->src_mask + 1) >> 1))
1737 {
1738 bfd_signed_vma mask;
1739
1740 mask = -1;
1741 mask &= ~ howto->src_mask;
1742 addend |= mask;
1743 }
1744
1745 /* Add in the increment, (which is a byte value). */
1746 switch (howto->type)
1747 {
1748 default:
1749 addend += increment;
1750 break;
1751
1752 case R_ARM_PC24:
1753 addend <<= howto->size;
1754 addend += increment;
1755
1756 /* Should we check for overflow here ? */
1757
1758 /* Drop any undesired bits. */
1759 addend >>= howto->rightshift;
1760 break;
1761 }
1762
1763 contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
1764
1765 bfd_put_32 (abfd, contents, address);
ddda4409 1766 }
98c1d4aa
NC		 1767}
1768#endif /* USE_REL */
252b5132
RH		 1769
1770/* Relocate an ARM ELF section. */
1771static boolean
1772elf32_arm_relocate_section (output_bfd, info, input_bfd, input_section,
1773 contents, relocs, local_syms, local_sections)
1774 bfd * output_bfd;
1775 struct bfd_link_info * info;
1776 bfd * input_bfd;
1777 asection * input_section;
1778 bfd_byte * contents;
1779 Elf_Internal_Rela * relocs;
1780 Elf_Internal_Sym * local_syms;
1781 asection ** local_sections;
1782{
1783 Elf_Internal_Shdr * symtab_hdr;
1784 struct elf_link_hash_entry ** sym_hashes;
1785 Elf_Internal_Rela * rel;
1786 Elf_Internal_Rela * relend;
1787 const char * name;
1788
1789 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1790 sym_hashes = elf_sym_hashes (input_bfd);
1791
1792 rel = relocs;
1793 relend = relocs + input_section->reloc_count;
1794 for (; rel < relend; rel++)
1795 {
ba96a88f
NC		 1796 int r_type;
1797 reloc_howto_type * howto;
1798 unsigned long r_symndx;
1799 Elf_Internal_Sym * sym;
1800 asection * sec;
252b5132 1801 struct elf_link_hash_entry * h;
ba96a88f
NC		 1802 bfd_vma relocation;
1803 bfd_reloc_status_type r;
1804 arelent bfd_reloc;
f21f3fe0 1805
252b5132 1806 r_symndx = ELF32_R_SYM (rel->r_info);
ba96a88f 1807 r_type = ELF32_R_TYPE (rel->r_info);
252b5132 1808
ba96a88f
NC		 1809 if ( r_type == R_ARM_GNU_VTENTRY
1810 || r_type == R_ARM_GNU_VTINHERIT)
252b5132
RH		 1811 continue;
1812
5fb1c3f2 1813 elf32_arm_info_to_howto (input_bfd, & bfd_reloc, (Elf32_Internal_Rel *) rel);
ba96a88f 1814 howto = bfd_reloc.howto;
252b5132
RH		 1815
1816 if (info->relocateable)
1817 {
1818 /* This is a relocateable link. We don't have to change
1819 anything, unless the reloc is against a section symbol,
1820 in which case we have to adjust according to where the
1821 section symbol winds up in the output section. */
1822 if (r_symndx < symtab_hdr->sh_info)
1823 {
1824 sym = local_syms + r_symndx;
1825 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1826 {
1827 sec = local_sections[r_symndx];
1828#ifdef USE_REL
98c1d4aa
NC		 1829 arm_add_to_rel (input_bfd, contents + rel->r_offset,
1830 howto, sec->output_offset + sym->st_value);
252b5132 1831#else
5fb1c3f2 1832 rel->r_addend += (sec->output_offset + sym->st_value);
252b5132
RH		 1833#endif
1834 }
1835 }
1836
1837 continue;
1838 }
1839
1840 /* This is a final link. */
1841 h = NULL;
1842 sym = NULL;
1843 sec = NULL;
9b485d32 1844
252b5132
RH		 1845 if (r_symndx < symtab_hdr->sh_info)
1846 {
1847 sym = local_syms + r_symndx;
1848 sec = local_sections[r_symndx];
1849 relocation = (sec->output_section->vma
1850 + sec->output_offset
1851 + sym->st_value);
1852 }
1853 else
1854 {
1855 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
9b485d32
NC		 1856
1857 while ( h->root.type == bfd_link_hash_indirect
252b5132
RH		 1858 || h->root.type == bfd_link_hash_warning)
1859 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9b485d32
NC		 1860
1861 if ( h->root.type == bfd_link_hash_defined
252b5132
RH		 1862 || h->root.type == bfd_link_hash_defweak)
1863 {
780a67af 1864 int relocation_needed = 1;
f21f3fe0 1865
780a67af 1866 sec = h->root.u.def.section;
f21f3fe0 1867
252b5132 1868 /* In these cases, we don't need the relocation value.
f21f3fe0 1869 We check specially because in some obscure cases
9b485d32 1870 sec->output_section will be NULL. */
252b5132
RH		 1871 switch (r_type)
1872 {
1873 case R_ARM_PC24:
1874 case R_ARM_ABS32:
1875 if (info->shared
1876 && (
99e4ae17 1877 (!info->symbolic && h->dynindx != -1)
97eaf9de 1878 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
252b5132 1879 )
05924f36
PB		 1880 && ((input_section->flags & SEC_ALLOC) != 0
1881 /* DWARF will emit R_ARM_ABS32 relocations in its
1882 sections against symbols defined externally
1883 in shared libraries. We can't do anything
1884 with them here. */
1885 || ((input_section->flags & SEC_DEBUGGING) != 0
1886 && (h->elf_link_hash_flags
1887 & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
252b5132 1888 )
780a67af 1889 relocation_needed = 0;
252b5132 1890 break;
f21f3fe0 1891
252b5132 1892 case R_ARM_GOTPC:
780a67af 1893 relocation_needed = 0;
252b5132 1894 break;
f21f3fe0 1895
252b5132
RH		 1896 case R_ARM_GOT32:
1897 if (elf_hash_table(info)->dynamic_sections_created
1898 && (!info->shared
1899 || (!info->symbolic && h->dynindx != -1)
1900 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
1901 )
1902 )
780a67af 1903 relocation_needed = 0;
252b5132 1904 break;
f21f3fe0 1905
252b5132
RH		 1906 case R_ARM_PLT32:
1907 if (h->plt.offset != (bfd_vma)-1)
780a67af 1908 relocation_needed = 0;
252b5132 1909 break;
f21f3fe0 1910
252b5132
RH		 1911 default:
1912 if (sec->output_section == NULL)
1913 {
1914 (*_bfd_error_handler)
1915 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1916 bfd_get_filename (input_bfd), h->root.root.string,
1917 bfd_get_section_name (input_bfd, input_section));
780a67af 1918 relocation_needed = 0;
252b5132
RH		 1919 }
1920 }
780a67af
NC		 1921
1922 if (relocation_needed)
1923 relocation = h->root.u.def.value
1924 + sec->output_section->vma
1925 + sec->output_offset;
1926 else
1927 relocation = 0;
252b5132
RH		 1928 }
1929 else if (h->root.type == bfd_link_hash_undefweak)
1930 relocation = 0;
3a27a730
L		 1931 else if (info->shared && !info->symbolic
1932 && !info->no_undefined
1933 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
a72747a3 1934 relocation = 0;
252b5132
RH		 1935 else
1936 {
1937 if (!((*info->callbacks->undefined_symbol)
1938 (info, h->root.root.string, input_bfd,
5cc7c785 1939 input_section, rel->r_offset,
3a27a730
L		 1940 (!info->shared || info->no_undefined
1941 || ELF_ST_VISIBILITY (h->other)))))
252b5132
RH		 1942 return false;
1943 relocation = 0;
1944 }
1945 }
1946
1947 if (h != NULL)
1948 name = h->root.root.string;
1949 else
1950 {
1951 name = (bfd_elf_string_from_elf_section
1952 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1953 if (name == NULL || *name == '\0')
1954 name = bfd_section_name (input_bfd, sec);
1955 }
f21f3fe0 1956
252b5132
RH		 1957 r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
1958 input_section, contents, rel,
1959 relocation, info, sec, name,
1960 (h ? ELF_ST_TYPE (h->type) :
780a67af 1961 ELF_ST_TYPE (sym->st_info)), h);
252b5132
RH		 1962
1963 if (r != bfd_reloc_ok)
1964 {
1965 const char * msg = (const char *) 0;
1966
1967 switch (r)
1968 {
1969 case bfd_reloc_overflow:
cf919dfd
PB		 1970 /* If the overflowing reloc was to an undefined symbol,
1971 we have already printed one error message and there
1972 is no point complaining again. */
1973 if ((! h ||
1974 h->root.type != bfd_link_hash_undefined)
1975 && (!((*info->callbacks->reloc_overflow)
1976 (info, name, howto->name, (bfd_vma) 0,
1977 input_bfd, input_section, rel->r_offset))))
1978 return false;
252b5132
RH		 1979 break;
1980
1981 case bfd_reloc_undefined:
1982 if (!((*info->callbacks->undefined_symbol)
1983 (info, name, input_bfd, input_section,
5cc7c785 1984 rel->r_offset, true)))
252b5132
RH		 1985 return false;
1986 break;
1987
1988 case bfd_reloc_outofrange:
9b485d32 1989 msg = _("internal error: out of range error");
252b5132
RH		 1990 goto common_error;
1991
1992 case bfd_reloc_notsupported:
9b485d32 1993 msg = _("internal error: unsupported relocation error");
252b5132
RH		 1994 goto common_error;
1995
1996 case bfd_reloc_dangerous:
9b485d32 1997 msg = _("internal error: dangerous error");
252b5132
RH		 1998 goto common_error;
1999
2000 default:
9b485d32 2001 msg = _("internal error: unknown error");
252b5132
RH		 2002 /* fall through */
2003
2004 common_error:
2005 if (!((*info->callbacks->warning)
2006 (info, msg, name, input_bfd, input_section,
2007 rel->r_offset)))
2008 return false;
2009 break;
2010 }
2011 }
2012 }
2013
2014 return true;
2015}
2016
fc830a83 2017/* Function to keep ARM specific flags in the ELF header. */
252b5132
RH		 2018static boolean
2019elf32_arm_set_private_flags (abfd, flags)
2020 bfd *abfd;
2021 flagword flags;
2022{
2023 if (elf_flags_init (abfd)
2024 && elf_elfheader (abfd)->e_flags != flags)
2025 {
fc830a83
NC		 2026 if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
2027 {
fd2ec330 2028 if (flags & EF_ARM_INTERWORK)
9b485d32 2029 _bfd_error_handler (_("\
252b5132 2030Warning: Not setting interwork flag of %s since it has already been specified as non-interworking"),
fc830a83
NC		 2031 bfd_get_filename (abfd));
2032 else
9b485d32 2033 _bfd_error_handler (_("\
252b5132 2034Warning: Clearing the interwork flag of %s due to outside request"),
fc830a83
NC		 2035 bfd_get_filename (abfd));
2036 }
252b5132
RH		 2037 }
2038 else
2039 {
2040 elf_elfheader (abfd)->e_flags = flags;
2041 elf_flags_init (abfd) = true;
2042 }
2043
2044 return true;
2045}
2046
fc830a83 2047/* Copy backend specific data from one object module to another. */
9b485d32 2048
252b5132
RH		 2049static boolean
2050elf32_arm_copy_private_bfd_data (ibfd, obfd)
2051 bfd *ibfd;
2052 bfd *obfd;
2053{
2054 flagword in_flags;
2055 flagword out_flags;
2056
fc830a83 2057 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
252b5132
RH		 2058 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2059 return true;
2060
fc830a83 2061 in_flags = elf_elfheader (ibfd)->e_flags;
252b5132
RH		 2062 out_flags = elf_elfheader (obfd)->e_flags;
2063
fc830a83
NC		 2064 if (elf_flags_init (obfd)
2065 && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
2066 && in_flags != out_flags)
252b5132 2067 {
252b5132 2068 /* Cannot mix APCS26 and APCS32 code. */
fd2ec330 2069 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
252b5132
RH		 2070 return false;
2071
2072 /* Cannot mix float APCS and non-float APCS code. */
fd2ec330 2073 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
252b5132
RH		 2074 return false;
2075
2076 /* If the src and dest have different interworking flags
2077 then turn off the interworking bit. */
fd2ec330 2078 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
252b5132 2079 {
fd2ec330 2080 if (out_flags & EF_ARM_INTERWORK)
9b485d32 2081 _bfd_error_handler (_("\
252b5132
RH		 2082Warning: Clearing the interwork flag in %s because non-interworking code in %s has been linked with it"),
2083 bfd_get_filename (obfd), bfd_get_filename (ibfd));
2084
fd2ec330 2085 in_flags &= ~EF_ARM_INTERWORK;
252b5132 2086 }
1006ba19
PB		 2087
2088 /* Likewise for PIC, though don't warn for this case. */
fd2ec330
PB		 2089 if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC))
2090 in_flags &= ~EF_ARM_PIC;
252b5132
RH		 2091 }
2092
2093 elf_elfheader (obfd)->e_flags = in_flags;
2094 elf_flags_init (obfd) = true;
2095
2096 return true;
2097}
2098
2099/* Merge backend specific data from an object file to the output
2100 object file when linking. */
9b485d32 2101
252b5132
RH		 2102static boolean
2103elf32_arm_merge_private_bfd_data (ibfd, obfd)
fc830a83
NC		 2104 bfd * ibfd;
2105 bfd * obfd;
252b5132
RH		 2106{
2107 flagword out_flags;
2108 flagword in_flags;
1006ba19 2109 boolean flags_compatible = true;
cf919dfd
PB		 2110 boolean null_input_bfd = true;
2111 asection *sec;
252b5132 2112
9b485d32 2113 /* Check if we have the same endianess. */
1fe494a5
NC		 2114 if (_bfd_generic_verify_endian_match (ibfd, obfd) == false)
2115 return false;
2116
252b5132
RH		 2117 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2118 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2119 return true;
2120
252b5132
RH		 2121 /* The input BFD must have had its flags initialised. */
2122 /* The following seems bogus to me -- The flags are initialized in
2123 the assembler but I don't think an elf_flags_init field is
9b485d32 2124 written into the object. */
252b5132
RH		 2125 /* BFD_ASSERT (elf_flags_init (ibfd)); */
2126
2127 in_flags = elf_elfheader (ibfd)->e_flags;
2128 out_flags = elf_elfheader (obfd)->e_flags;
2129
2130 if (!elf_flags_init (obfd))
2131 {
fe077fa6
NC		 2132 /* If the input is the default architecture and had the default
2133 flags then do not bother setting the flags for the output
2134 architecture, instead allow future merges to do this. If no
2135 future merges ever set these flags then they will retain their
2136 uninitialised values, which surprise surprise, correspond
252b5132 2137 to the default values. */
fe077fa6
NC		 2138 if (bfd_get_arch_info (ibfd)->the_default
2139 && elf_elfheader (ibfd)->e_flags == 0)
252b5132
RH		 2140 return true;
2141
2142 elf_flags_init (obfd) = true;
2143 elf_elfheader (obfd)->e_flags = in_flags;
2144
2145 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2146 && bfd_get_arch_info (obfd)->the_default)
2147 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
2148
2149 return true;
2150 }
2151
1006ba19 2152 /* Identical flags must be compatible. */
252b5132
RH		 2153 if (in_flags == out_flags)
2154 return true;
2155
cf919dfd
PB		 2156 /* Check to see if the input BFD actually contains any sections.
2157 If not, its flags may not have been initialised either, but it cannot
2158 actually cause any incompatibility. */
2159 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
2160 {
2161 /* Ignore synthetic glue sections. */
2162 if (strcmp (sec->name, ".glue_7")
2163 && strcmp (sec->name, ".glue_7t"))
2164 {
2165 null_input_bfd = false;
2166 break;
2167 }
2168 }
2169 if (null_input_bfd)
2170 return true;
2171
252b5132 2172 /* Complain about various flag mismatches. */
fc830a83
NC		 2173 if (EF_ARM_EABI_VERSION (in_flags) != EF_ARM_EABI_VERSION (out_flags))
2174 {
2175 _bfd_error_handler (_("\
2176Error: %s compiled for EABI version %d, whereas %s is compiled for version %d"),
2177 bfd_get_filename (ibfd),
2178 (in_flags & EF_ARM_EABIMASK) >> 24,
2179 bfd_get_filename (obfd),
2180 (out_flags & EF_ARM_EABIMASK) >> 24);
1006ba19 2181 return false;
fc830a83 2182 }
252b5132 2183
1006ba19
PB		 2184 /* Not sure what needs to be checked for EABI versions >= 1. */
2185 if (EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
2186 {
fd2ec330 2187 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
1006ba19
PB		 2188 {
2189 _bfd_error_handler (_("\
252b5132
RH		 2190Error: %s compiled for APCS-%d, whereas %s is compiled for APCS-%d"),
2191 bfd_get_filename (ibfd),
fd2ec330 2192 in_flags & EF_ARM_APCS_26 ? 26 : 32,
252b5132 2193 bfd_get_filename (obfd),
fd2ec330 2194 out_flags & EF_ARM_APCS_26 ? 26 : 32);
1006ba19
PB		 2195 flags_compatible = false;
2196 }
252b5132 2197
fd2ec330 2198 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
1006ba19
PB		 2199 {
2200 _bfd_error_handler (_("\
252b5132
RH		 2201Error: %s passes floats in %s registers, whereas %s passes them in %s registers"),
2202 bfd_get_filename (ibfd),
fd2ec330 2203 in_flags & EF_ARM_APCS_FLOAT ? _("float") : _("integer"),
252b5132 2204 bfd_get_filename (obfd),
fd2ec330 2205 out_flags & EF_ARM_APCS_26 ? _("float") : _("integer"));
1006ba19
PB		 2206 flags_compatible = false;
2207 }
252b5132 2208
fd2ec330
PB		 2209#ifdef EF_ARM_SOFT_FLOAT
2210 if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
1006ba19
PB		 2211 {
2212 _bfd_error_handler (_ ("\
2213Error: %s uses %s floating point, whereas %s uses %s floating point"),
2214 bfd_get_filename (ibfd),
fd2ec330 2215 in_flags & EF_ARM_SOFT_FLOAT ? _("soft") : _("hard"),
1006ba19 2216 bfd_get_filename (obfd),
fd2ec330 2217 out_flags & EF_ARM_SOFT_FLOAT ? _("soft") : _("hard"));
1006ba19
PB		 2218 flags_compatible = false;
2219 }
ee43f35e 2220#endif
252b5132 2221
1006ba19 2222 /* Interworking mismatch is only a warning. */
fd2ec330 2223 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
1006ba19 2224 _bfd_error_handler (_("\
252b5132 2225Warning: %s %s interworking, whereas %s %s"),
d1659392
NC		 2226 bfd_get_filename (ibfd),
2227 in_flags & EF_ARM_INTERWORK ? _("supports") : _("does not support"),
2228 bfd_get_filename (obfd),
2229 out_flags & EF_ARM_INTERWORK ? _("does") : _("does not"));
252b5132
RH		 2230 }
2231
1006ba19 2232 return flags_compatible;
252b5132
RH		 2233}
2234
9b485d32
NC		 2235/* Display the flags field. */
2236
252b5132
RH		 2237static boolean
2238elf32_arm_print_private_bfd_data (abfd, ptr)
2239 bfd *abfd;
2240 PTR ptr;
2241{
fc830a83
NC		 2242 FILE * file = (FILE *) ptr;
2243 unsigned long flags;
252b5132
RH		 2244
2245 BFD_ASSERT (abfd != NULL && ptr != NULL);
2246
2247 /* Print normal ELF private data. */
2248 _bfd_elf_print_private_bfd_data (abfd, ptr);
2249
fc830a83 2250 flags = elf_elfheader (abfd)->e_flags;
9b485d32
NC		 2251 /* Ignore init flag - it may not be set, despite the flags field
2252 containing valid data. */
252b5132
RH		 2253
2254 /* xgettext:c-format */
9b485d32 2255 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
252b5132 2256
fc830a83
NC		 2257 switch (EF_ARM_EABI_VERSION (flags))
2258 {
2259 case EF_ARM_EABI_UNKNOWN:
2260 /* The following flag bits are GNU extenstions and not part of the
2261 official ARM ELF extended ABI. Hence they are only decoded if
2262 the EABI version is not set. */
fd2ec330 2263 if (flags & EF_ARM_INTERWORK)
9b485d32 2264 fprintf (file, _(" [interworking enabled]"));
9a5aca8c 2265
fd2ec330 2266 if (flags & EF_ARM_APCS_26)
9b485d32 2267 fprintf (file, _(" [APCS-26]"));
fc830a83 2268 else
9b485d32 2269 fprintf (file, _(" [APCS-32]"));
9a5aca8c 2270
fd2ec330 2271 if (flags & EF_ARM_APCS_FLOAT)
9b485d32 2272 fprintf (file, _(" [floats passed in float registers]"));
9a5aca8c 2273
fd2ec330 2274 if (flags & EF_ARM_PIC)
9b485d32 2275 fprintf (file, _(" [position independent]"));
fc830a83 2276
fd2ec330 2277 if (flags & EF_ARM_NEW_ABI)
9b485d32 2278 fprintf (file, _(" [new ABI]"));
9a5aca8c 2279
fd2ec330 2280 if (flags & EF_ARM_OLD_ABI)
9b485d32 2281 fprintf (file, _(" [old ABI]"));
9a5aca8c 2282
fd2ec330 2283 if (flags & EF_ARM_SOFT_FLOAT)
9b485d32 2284 fprintf (file, _(" [software FP]"));
9a5aca8c 2285
fd2ec330
PB		 2286 flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT | EF_ARM_PIC
2287 | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI | EF_ARM_SOFT_FLOAT);
fc830a83 2288 break;
9a5aca8c 2289
fc830a83 2290 case EF_ARM_EABI_VER1:
9b485d32 2291 fprintf (file, _(" [Version1 EABI]"));
9a5aca8c 2292
fc830a83 2293 if (flags & EF_ARM_SYMSARESORTED)
9b485d32 2294 fprintf (file, _(" [sorted symbol table]"));
fc830a83 2295 else
9b485d32 2296 fprintf (file, _(" [unsorted symbol table]"));
9a5aca8c 2297
fc830a83
NC		 2298 flags &= ~ EF_ARM_SYMSARESORTED;
2299 break;
9a5aca8c 2300
fd2ec330
PB		 2301 case EF_ARM_EABI_VER2:
2302 fprintf (file, _(" [Version2 EABI]"));
2303
2304 if (flags & EF_ARM_SYMSARESORTED)
2305 fprintf (file, _(" [sorted symbol table]"));
2306 else
2307 fprintf (file, _(" [unsorted symbol table]"));
2308
2309 if (flags & EF_ARM_DYNSYMSUSESEGIDX)
2310 fprintf (file, _(" [dynamic symbols use segment index]"));
2311
2312 if (flags & EF_ARM_MAPSYMSFIRST)
2313 fprintf (file, _(" [mapping symbols precede others]"));
2314
99e4ae17 2315 flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX
fd2ec330
PB		 2316 | EF_ARM_MAPSYMSFIRST);
2317 break;
2318
fc830a83 2319 default:
9b485d32 2320 fprintf (file, _(" <EABI version unrecognised>"));
fc830a83
NC		 2321 break;
2322 }
252b5132 2323
fc830a83 2324 flags &= ~ EF_ARM_EABIMASK;
252b5132 2325
fc830a83 2326 if (flags & EF_ARM_RELEXEC)
9b485d32 2327 fprintf (file, _(" [relocatable executable]"));
252b5132 2328
fc830a83 2329 if (flags & EF_ARM_HASENTRY)
9b485d32 2330 fprintf (file, _(" [has entry point]"));
252b5132 2331
fc830a83
NC		 2332 flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
2333
2334 if (flags)
9b485d32 2335 fprintf (file, _("<Unrecognised flag bits set>"));
9a5aca8c 2336
252b5132
RH		 2337 fputc ('\n', file);
2338
2339 return true;
2340}
2341
2342static int
2343elf32_arm_get_symbol_type (elf_sym, type)
2344 Elf_Internal_Sym * elf_sym;
2345 int type;
2346{
2f0ca46a
NC		 2347 switch (ELF_ST_TYPE (elf_sym->st_info))
2348 {
2349 case STT_ARM_TFUNC:
2350 return ELF_ST_TYPE (elf_sym->st_info);
ce855c42 2351
2f0ca46a
NC		 2352 case STT_ARM_16BIT:
2353 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2354 This allows us to distinguish between data used by Thumb instructions
2355 and non-data (which is probably code) inside Thumb regions of an
2356 executable. */
2357 if (type != STT_OBJECT)
2358 return ELF_ST_TYPE (elf_sym->st_info);
2359 break;
9a5aca8c 2360
ce855c42
NC		 2361 default:
2362 break;
2f0ca46a
NC		 2363 }
2364
2365 return type;
252b5132 2366}
f21f3fe0 2367
252b5132
RH		 2368static asection *
2369elf32_arm_gc_mark_hook (abfd, info, rel, h, sym)
2370 bfd *abfd;
5f771d47 2371 struct bfd_link_info *info ATTRIBUTE_UNUSED;
252b5132
RH		 2372 Elf_Internal_Rela *rel;
2373 struct elf_link_hash_entry *h;
2374 Elf_Internal_Sym *sym;
2375{
2376 if (h != NULL)
2377 {
2378 switch (ELF32_R_TYPE (rel->r_info))
2379 {
2380 case R_ARM_GNU_VTINHERIT:
2381 case R_ARM_GNU_VTENTRY:
2382 break;
2383
2384 default:
2385 switch (h->root.type)
2386 {
2387 case bfd_link_hash_defined:
2388 case bfd_link_hash_defweak:
2389 return h->root.u.def.section;
2390
2391 case bfd_link_hash_common:
2392 return h->root.u.c.p->section;
e049a0de
ILT		 2393
2394 default:
2395 break;
252b5132
RH		 2396 }
2397 }
2398 }
2399 else
2400 {
2401 if (!(elf_bad_symtab (abfd)
2402 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
2403 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
2404 && sym->st_shndx != SHN_COMMON))
2405 {
2406 return bfd_section_from_elf_index (abfd, sym->st_shndx);
2407 }
2408 }
2409 return NULL;
2410}
2411
780a67af
NC		 2412/* Update the got entry reference counts for the section being removed. */
2413
252b5132
RH		 2414static boolean
2415elf32_arm_gc_sweep_hook (abfd, info, sec, relocs)
5f771d47
ILT		 2416 bfd *abfd ATTRIBUTE_UNUSED;
2417 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2418 asection *sec ATTRIBUTE_UNUSED;
2419 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
252b5132 2420{
780a67af 2421 /* We don't support garbage collection of GOT and PLT relocs yet. */
252b5132
RH		 2422 return true;
2423}
2424
780a67af
NC		 2425/* Look through the relocs for a section during the first phase. */
2426
252b5132
RH		 2427static boolean
2428elf32_arm_check_relocs (abfd, info, sec, relocs)
2429 bfd * abfd;
2430 struct bfd_link_info * info;
2431 asection * sec;
2432 const Elf_Internal_Rela * relocs;
2433{
2434 Elf_Internal_Shdr * symtab_hdr;
2435 struct elf_link_hash_entry ** sym_hashes;
2436 struct elf_link_hash_entry ** sym_hashes_end;
2437 const Elf_Internal_Rela * rel;
2438 const Elf_Internal_Rela * rel_end;
2439 bfd * dynobj;
2440 asection * sgot, *srelgot, *sreloc;
2441 bfd_vma * local_got_offsets;
9a5aca8c 2442
252b5132
RH		 2443 if (info->relocateable)
2444 return true;
9a5aca8c 2445
252b5132 2446 sgot = srelgot = sreloc = NULL;
9a5aca8c 2447
252b5132
RH		 2448 dynobj = elf_hash_table (info)->dynobj;
2449 local_got_offsets = elf_local_got_offsets (abfd);
f21f3fe0 2450
252b5132
RH		 2451 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2452 sym_hashes = elf_sym_hashes (abfd);
9b485d32
NC		 2453 sym_hashes_end = sym_hashes
2454 + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
2455
252b5132
RH		 2456 if (!elf_bad_symtab (abfd))
2457 sym_hashes_end -= symtab_hdr->sh_info;
9b485d32 2458
252b5132
RH		 2459 rel_end = relocs + sec->reloc_count;
2460 for (rel = relocs; rel < rel_end; rel++)
2461 {
2462 struct elf_link_hash_entry *h;
2463 unsigned long r_symndx;
9a5aca8c 2464
252b5132
RH		 2465 r_symndx = ELF32_R_SYM (rel->r_info);
2466 if (r_symndx < symtab_hdr->sh_info)
2467 h = NULL;
2468 else
2469 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
9a5aca8c 2470
252b5132
RH		 2471 /* Some relocs require a global offset table. */
2472 if (dynobj == NULL)
2473 {
2474 switch (ELF32_R_TYPE (rel->r_info))
2475 {
2476 case R_ARM_GOT32:
2477 case R_ARM_GOTOFF:
2478 case R_ARM_GOTPC:
2479 elf_hash_table (info)->dynobj = dynobj = abfd;
2480 if (! _bfd_elf_create_got_section (dynobj, info))
2481 return false;
2482 break;
2483
2484 default:
2485 break;
2486 }
2487 }
2488
2489 switch (ELF32_R_TYPE (rel->r_info))
2490 {
2491 case R_ARM_GOT32:
2492 /* This symbol requires a global offset table entry. */
2493 if (sgot == NULL)
2494 {
2495 sgot = bfd_get_section_by_name (dynobj, ".got");
2496 BFD_ASSERT (sgot != NULL);
2497 }
2498
2499 /* Get the got relocation section if necessary. */
2500 if (srelgot == NULL
2501 && (h != NULL || info->shared))
2502 {
2503 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
9a5aca8c 2504
252b5132
RH		 2505 /* If no got relocation section, make one and initialize. */
2506 if (srelgot == NULL)
2507 {
2508 srelgot = bfd_make_section (dynobj, ".rel.got");
2509 if (srelgot == NULL
2510 || ! bfd_set_section_flags (dynobj, srelgot,
99e4ae17 2511 (SEC_ALLOC
252b5132
RH		 2512 | SEC_LOAD
2513 | SEC_HAS_CONTENTS
2514 | SEC_IN_MEMORY
2515 | SEC_LINKER_CREATED
2516 | SEC_READONLY))
2517 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
2518 return false;
2519 }
2520 }
2521
2522 if (h != NULL)
2523 {
2524 if (h->got.offset != (bfd_vma) -1)
2525 /* We have already allocated space in the .got. */
2526 break;
f21f3fe0 2527
252b5132
RH		 2528 h->got.offset = sgot->_raw_size;
2529
2530 /* Make sure this symbol is output as a dynamic symbol. */
2531 if (h->dynindx == -1)
2532 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2533 return false;
2534
2535 srelgot->_raw_size += sizeof (Elf32_External_Rel);
2536 }
2537 else
2538 {
99e4ae17 2539 /* This is a global offset table entry for a local
252b5132
RH		 2540 symbol. */
2541 if (local_got_offsets == NULL)
2542 {
2543 size_t size;
2544 register unsigned int i;
2545
2546 size = symtab_hdr->sh_info * sizeof (bfd_vma);
2547 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
2548 if (local_got_offsets == NULL)
2549 return false;
2550 elf_local_got_offsets (abfd) = local_got_offsets;
2551 for (i = 0; i < symtab_hdr->sh_info; i++)
2552 local_got_offsets[i] = (bfd_vma) -1;
2553 }
f21f3fe0 2554
252b5132
RH		 2555 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
2556 /* We have already allocated space in the .got. */
2557 break;
2558
2559 local_got_offsets[r_symndx] = sgot->_raw_size;
2560
2561 if (info->shared)
2562 /* If we are generating a shared object, we need to
2563 output a R_ARM_RELATIVE reloc so that the dynamic
2564 linker can adjust this GOT entry. */
2565 srelgot->_raw_size += sizeof (Elf32_External_Rel);
2566 }
2567
2568 sgot->_raw_size += 4;
2569 break;
2570
99e4ae17 2571 case R_ARM_PLT32:
252b5132
RH		 2572 /* This symbol requires a procedure linkage table entry. We
2573 actually build the entry in adjust_dynamic_symbol,
2574 because this might be a case of linking PIC code which is
2575 never referenced by a dynamic object, in which case we
2576 don't need to generate a procedure linkage table entry
2577 after all. */
2578
2579 /* If this is a local symbol, we resolve it directly without
2580 creating a procedure linkage table entry. */
2581 if (h == NULL)
2582 continue;
2583
2584 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2585 break;
2586
2587 case R_ARM_ABS32:
2588 case R_ARM_REL32:
2589 case R_ARM_PC24:
2590 /* If we are creating a shared library, and this is a reloc
2591 against a global symbol, or a non PC relative reloc
2592 against a local symbol, then we need to copy the reloc
2593 into the shared library. However, if we are linking with
2594 -Bsymbolic, we do not need to copy a reloc against a
2595 global symbol which is defined in an object we are
2596 including in the link (i.e., DEF_REGULAR is set). At
2597 this point we have not seen all the input files, so it is
2598 possible that DEF_REGULAR is not set now but will be set
2599 later (it is never cleared). We account for that
2600 possibility below by storing information in the
2601 pcrel_relocs_copied field of the hash table entry. */
2602 if (info->shared
2603 && (ELF32_R_TYPE (rel->r_info) != R_ARM_PC24
2604 || (h != NULL
2605 && (! info->symbolic
2606 || (h->elf_link_hash_flags
2607 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2608 {
2609 /* When creating a shared object, we must copy these
2610 reloc types into the output file. We create a reloc
2611 section in dynobj and make room for this reloc. */
2612 if (sreloc == NULL)
2613 {
2614 const char * name;
2615
2616 name = (bfd_elf_string_from_elf_section
2617 (abfd,
2618 elf_elfheader (abfd)->e_shstrndx,
2619 elf_section_data (sec)->rel_hdr.sh_name));
2620 if (name == NULL)
2621 return false;
2622
2623 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
99e4ae17 2624 && strcmp (bfd_get_section_name (abfd, sec),
252b5132
RH		 2625 name + 4) == 0);
2626
2627 sreloc = bfd_get_section_by_name (dynobj, name);
2628 if (sreloc == NULL)
2629 {
2630 flagword flags;
2631
2632 sreloc = bfd_make_section (dynobj, name);
2633 flags = (SEC_HAS_CONTENTS | SEC_READONLY
2634 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2635 if ((sec->flags & SEC_ALLOC) != 0)
2636 flags |= SEC_ALLOC | SEC_LOAD;
2637 if (sreloc == NULL
2638 || ! bfd_set_section_flags (dynobj, sreloc, flags)
2639 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
2640 return false;
2641 }
99e4ae17
AJ		 2642 if (sec->flags & SEC_READONLY)
2643 info->flags |= DF_TEXTREL;
252b5132
RH		 2644 }
2645
2646 sreloc->_raw_size += sizeof (Elf32_External_Rel);
2647 /* If we are linking with -Bsymbolic, and this is a
2648 global symbol, we count the number of PC relative
2649 relocations we have entered for this symbol, so that
2650 we can discard them again if the symbol is later
2651 defined by a regular object. Note that this function
2652 is only called if we are using an elf_i386 linker
2653 hash table, which means that h is really a pointer to
2654 an elf_i386_link_hash_entry. */
2655 if (h != NULL && info->symbolic
2656 && ELF32_R_TYPE (rel->r_info) == R_ARM_PC24)
2657 {
2658 struct elf32_arm_link_hash_entry * eh;
2659 struct elf32_arm_pcrel_relocs_copied * p;
2660
2661 eh = (struct elf32_arm_link_hash_entry *) h;
2662
2663 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
2664 if (p->section == sreloc)
2665 break;
2666
2667 if (p == NULL)
2668 {
2669 p = ((struct elf32_arm_pcrel_relocs_copied *)
2670 bfd_alloc (dynobj, sizeof * p));
f21f3fe0 2671
252b5132
RH		 2672 if (p == NULL)
2673 return false;
2674 p->next = eh->pcrel_relocs_copied;
2675 eh->pcrel_relocs_copied = p;
2676 p->section = sreloc;
2677 p->count = 0;
2678 }
2679
2680 ++p->count;
2681 }
2682 }
2683 break;
2684
2685 /* This relocation describes the C++ object vtable hierarchy.
2686 Reconstruct it for later use during GC. */
2687 case R_ARM_GNU_VTINHERIT:
2688 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2689 return false;
2690 break;
9a5aca8c 2691
252b5132
RH		 2692 /* This relocation describes which C++ vtable entries are actually
2693 used. Record for later use during GC. */
2694 case R_ARM_GNU_VTENTRY:
d512aa07 2695 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
252b5132
RH		 2696 return false;
2697 break;
2698 }
2699 }
f21f3fe0 2700
252b5132
RH		 2701 return true;
2702}
2703
252b5132
RH		 2704/* Find the nearest line to a particular section and offset, for error
2705 reporting. This code is a duplicate of the code in elf.c, except
9b485d32 2706 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
252b5132
RH		 2707
2708static boolean
2709elf32_arm_find_nearest_line
2710 (abfd, section, symbols, offset, filename_ptr, functionname_ptr, line_ptr)
2711 bfd * abfd;
2712 asection * section;
2713 asymbol ** symbols;
2714 bfd_vma offset;
917583ad
NC		 2715 const char ** filename_ptr;
2716 const char ** functionname_ptr;
252b5132
RH		 2717 unsigned int * line_ptr;
2718{
2719 boolean found;
2720 const char * filename;
2721 asymbol * func;
2722 bfd_vma low_func;
2723 asymbol ** p;
2724
2725 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
f21f3fe0 2726 filename_ptr, functionname_ptr,
857ec808
NC		 2727 line_ptr, 0,
2728 &elf_tdata (abfd)->dwarf2_find_line_info))
252b5132
RH		 2729 return true;
2730
2731 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
2732 &found, filename_ptr,
2733 functionname_ptr, line_ptr,
2734 &elf_tdata (abfd)->line_info))
2735 return false;
f21f3fe0 2736
252b5132
RH		 2737 if (found)
2738 return true;
2739
2740 if (symbols == NULL)
2741 return false;
2742
2743 filename = NULL;
2744 func = NULL;
2745 low_func = 0;
2746
2747 for (p = symbols; *p != NULL; p++)
2748 {
2749 elf_symbol_type *q;
2750
2751 q = (elf_symbol_type *) *p;
2752
2753 if (bfd_get_section (&q->symbol) != section)
2754 continue;
2755
2756 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
2757 {
2758 default:
2759 break;
2760 case STT_FILE:
2761 filename = bfd_asymbol_name (&q->symbol);
2762 break;
2763 case STT_NOTYPE:
2764 case STT_FUNC:
2765 case STT_ARM_TFUNC:
2766 if (q->symbol.section == section
2767 && q->symbol.value >= low_func
2768 && q->symbol.value <= offset)
2769 {
2770 func = (asymbol *) q;
2771 low_func = q->symbol.value;
2772 }
2773 break;
2774 }
2775 }
2776
2777 if (func == NULL)
2778 return false;
2779
2780 *filename_ptr = filename;
2781 *functionname_ptr = bfd_asymbol_name (func);
2782 *line_ptr = 0;
f21f3fe0 2783
252b5132
RH		 2784 return true;
2785}
2786
2787/* Adjust a symbol defined by a dynamic object and referenced by a
2788 regular object. The current definition is in some section of the
2789 dynamic object, but we're not including those sections. We have to
2790 change the definition to something the rest of the link can
2791 understand. */
2792
2793static boolean
2794elf32_arm_adjust_dynamic_symbol (info, h)
2795 struct bfd_link_info * info;
2796 struct elf_link_hash_entry * h;
2797{
2798 bfd * dynobj;
2799 asection * s;
2800 unsigned int power_of_two;
2801
2802 dynobj = elf_hash_table (info)->dynobj;
2803
2804 /* Make sure we know what is going on here. */
2805 BFD_ASSERT (dynobj != NULL
2806 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
2807 || h->weakdef != NULL
2808 || ((h->elf_link_hash_flags
2809 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2810 && (h->elf_link_hash_flags
2811 & ELF_LINK_HASH_REF_REGULAR) != 0
2812 && (h->elf_link_hash_flags
2813 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
2814
2815 /* If this is a function, put it in the procedure linkage table. We
2816 will fill in the contents of the procedure linkage table later,
2817 when we know the address of the .got section. */
2818 if (h->type == STT_FUNC
2819 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2820 {
2821 if (! info->shared
2822 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
2823 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
2824 {
2825 /* This case can occur if we saw a PLT32 reloc in an input
2826 file, but the symbol was never referred to by a dynamic
2827 object. In such a case, we don't actually need to build
2828 a procedure linkage table, and we can just do a PC32
2829 reloc instead. */
2830 BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
2831 return true;
2832 }
2833
2834 /* Make sure this symbol is output as a dynamic symbol. */
2835 if (h->dynindx == -1)
2836 {
2837 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2838 return false;
2839 }
2840
2841 s = bfd_get_section_by_name (dynobj, ".plt");
2842 BFD_ASSERT (s != NULL);
2843
2844 /* If this is the first .plt entry, make room for the special
2845 first entry. */
2846 if (s->_raw_size == 0)
2847 s->_raw_size += PLT_ENTRY_SIZE;
2848
2849 /* If this symbol is not defined in a regular file, and we are
2850 not generating a shared library, then set the symbol to this
2851 location in the .plt. This is required to make function
2852 pointers compare as equal between the normal executable and
2853 the shared library. */
2854 if (! info->shared
2855 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2856 {
2857 h->root.u.def.section = s;
2858 h->root.u.def.value = s->_raw_size;
2859 }
2860
2861 h->plt.offset = s->_raw_size;
2862
2863 /* Make room for this entry. */
2864 s->_raw_size += PLT_ENTRY_SIZE;
2865
2866 /* We also need to make an entry in the .got.plt section, which
2867 will be placed in the .got section by the linker script. */
252b5132
RH		 2868 s = bfd_get_section_by_name (dynobj, ".got.plt");
2869 BFD_ASSERT (s != NULL);
2870 s->_raw_size += 4;
2871
2872 /* We also need to make an entry in the .rel.plt section. */
2873
2874 s = bfd_get_section_by_name (dynobj, ".rel.plt");
2875 BFD_ASSERT (s != NULL);
2876 s->_raw_size += sizeof (Elf32_External_Rel);
2877
2878 return true;
2879 }
2880
2881 /* If this is a weak symbol, and there is a real definition, the
2882 processor independent code will have arranged for us to see the
2883 real definition first, and we can just use the same value. */
2884 if (h->weakdef != NULL)
2885 {
2886 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2887 || h->weakdef->root.type == bfd_link_hash_defweak);
2888 h->root.u.def.section = h->weakdef->root.u.def.section;
2889 h->root.u.def.value = h->weakdef->root.u.def.value;
2890 return true;
2891 }
2892
2893 /* This is a reference to a symbol defined by a dynamic object which
2894 is not a function. */
2895
2896 /* If we are creating a shared library, we must presume that the
2897 only references to the symbol are via the global offset table.
2898 For such cases we need not do anything here; the relocations will
2899 be handled correctly by relocate_section. */
2900 if (info->shared)
2901 return true;
2902
2903 /* We must allocate the symbol in our .dynbss section, which will
2904 become part of the .bss section of the executable. There will be
2905 an entry for this symbol in the .dynsym section. The dynamic
2906 object will contain position independent code, so all references
2907 from the dynamic object to this symbol will go through the global
2908 offset table. The dynamic linker will use the .dynsym entry to
2909 determine the address it must put in the global offset table, so
2910 both the dynamic object and the regular object will refer to the
2911 same memory location for the variable. */
252b5132
RH		 2912 s = bfd_get_section_by_name (dynobj, ".dynbss");
2913 BFD_ASSERT (s != NULL);
2914
2915 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
2916 copy the initial value out of the dynamic object and into the
2917 runtime process image. We need to remember the offset into the
2918 .rel.bss section we are going to use. */
2919 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2920 {
2921 asection *srel;
2922
2923 srel = bfd_get_section_by_name (dynobj, ".rel.bss");
2924 BFD_ASSERT (srel != NULL);
2925 srel->_raw_size += sizeof (Elf32_External_Rel);
2926 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
2927 }
2928
2929 /* We need to figure out the alignment required for this symbol. I
2930 have no idea how ELF linkers handle this. */
2931 power_of_two = bfd_log2 (h->size);
2932 if (power_of_two > 3)
2933 power_of_two = 3;
2934
2935 /* Apply the required alignment. */
2936 s->_raw_size = BFD_ALIGN (s->_raw_size,
2937 (bfd_size_type) (1 << power_of_two));
2938 if (power_of_two > bfd_get_section_alignment (dynobj, s))
2939 {
2940 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
2941 return false;
2942 }
2943
2944 /* Define the symbol as being at this point in the section. */
2945 h->root.u.def.section = s;
2946 h->root.u.def.value = s->_raw_size;
2947
2948 /* Increment the section size to make room for the symbol. */
2949 s->_raw_size += h->size;
2950
2951 return true;
2952}
2953
2954/* Set the sizes of the dynamic sections. */
2955
2956static boolean
2957elf32_arm_size_dynamic_sections (output_bfd, info)
99e4ae17 2958 bfd * output_bfd ATTRIBUTE_UNUSED;
252b5132
RH		 2959 struct bfd_link_info * info;
2960{
2961 bfd * dynobj;
2962 asection * s;
2963 boolean plt;
2964 boolean relocs;
252b5132
RH		 2965
2966 dynobj = elf_hash_table (info)->dynobj;
2967 BFD_ASSERT (dynobj != NULL);
2968
2969 if (elf_hash_table (info)->dynamic_sections_created)
2970 {
2971 /* Set the contents of the .interp section to the interpreter. */
2972 if (! info->shared)
2973 {
2974 s = bfd_get_section_by_name (dynobj, ".interp");
2975 BFD_ASSERT (s != NULL);
2976 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
2977 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2978 }
2979 }
2980 else
2981 {
2982 /* We may have created entries in the .rel.got section.
2983 However, if we are not creating the dynamic sections, we will
2984 not actually use these entries. Reset the size of .rel.got,
2985 which will cause it to get stripped from the output file
2986 below. */
2987 s = bfd_get_section_by_name (dynobj, ".rel.got");
2988 if (s != NULL)
2989 s->_raw_size = 0;
2990 }
2991
2992 /* If this is a -Bsymbolic shared link, then we need to discard all
2993 PC relative relocs against symbols defined in a regular object.
2994 We allocated space for them in the check_relocs routine, but we
2995 will not fill them in in the relocate_section routine. */
2996 if (info->shared && info->symbolic)
2997 elf32_arm_link_hash_traverse (elf32_arm_hash_table (info),
2998 elf32_arm_discard_copies,
2999 (PTR) NULL);
3000
3001 /* The check_relocs and adjust_dynamic_symbol entry points have
3002 determined the sizes of the various dynamic sections. Allocate
3003 memory for them. */
3004 plt = false;
3005 relocs = false;
252b5132
RH		 3006 for (s = dynobj->sections; s != NULL; s = s->next)
3007 {
3008 const char * name;
3009 boolean strip;
3010
3011 if ((s->flags & SEC_LINKER_CREATED) == 0)
3012 continue;
3013
3014 /* It's OK to base decisions on the section name, because none
3015 of the dynobj section names depend upon the input files. */
3016 name = bfd_get_section_name (dynobj, s);
3017
3018 strip = false;
3019
3020 if (strcmp (name, ".plt") == 0)
3021 {
3022 if (s->_raw_size == 0)
3023 {
3024 /* Strip this section if we don't need it; see the
3025 comment below. */
3026 strip = true;
3027 }
3028 else
3029 {
3030 /* Remember whether there is a PLT. */
3031 plt = true;
3032 }
3033 }
3034 else if (strncmp (name, ".rel", 4) == 0)
3035 {
3036 if (s->_raw_size == 0)
3037 {
3038 /* If we don't need this section, strip it from the
3039 output file. This is mostly to handle .rel.bss and
3040 .rel.plt. We must create both sections in
3041 create_dynamic_sections, because they must be created
3042 before the linker maps input sections to output
3043 sections. The linker does that before
3044 adjust_dynamic_symbol is called, and it is that
3045 function which decides whether anything needs to go
3046 into these sections. */
3047 strip = true;
3048 }
3049 else
3050 {
252b5132
RH		 3051 /* Remember whether there are any reloc sections other
3052 than .rel.plt. */
3053 if (strcmp (name, ".rel.plt") != 0)
99e4ae17 3054 relocs = true;
252b5132
RH		 3055
3056 /* We use the reloc_count field as a counter if we need
3057 to copy relocs into the output file. */
3058 s->reloc_count = 0;
3059 }
3060 }
3061 else if (strncmp (name, ".got", 4) != 0)
3062 {
3063 /* It's not one of our sections, so don't allocate space. */
3064 continue;
3065 }
3066
3067 if (strip)
3068 {
3069 asection ** spp;
3070
3071 for (spp = &s->output_section->owner->sections;
3072 *spp != s->output_section;
3073 spp = &(*spp)->next)
3074 ;
3075 *spp = s->output_section->next;
3076 --s->output_section->owner->section_count;
3077
3078 continue;
3079 }
3080
3081 /* Allocate memory for the section contents. */
3082 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
3083 if (s->contents == NULL && s->_raw_size != 0)
3084 return false;
3085 }
3086
3087 if (elf_hash_table (info)->dynamic_sections_created)
3088 {
3089 /* Add some entries to the .dynamic section. We fill in the
3090 values later, in elf32_arm_finish_dynamic_sections, but we
3091 must add the entries now so that we get the correct size for
3092 the .dynamic section. The DT_DEBUG entry is filled in by the
3093 dynamic linker and used by the debugger. */
3094 if (! info->shared)
3095 {
3096 if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
3097 return false;
3098 }
3099
3100 if (plt)
3101 {
9b485d32 3102 if ( ! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
252b5132
RH		 3103 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
3104 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_REL)
3105 || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
3106 return false;
3107 }
3108
3109 if (relocs)
3110 {
9b485d32 3111 if ( ! bfd_elf32_add_dynamic_entry (info, DT_REL, 0)
252b5132
RH		 3112 || ! bfd_elf32_add_dynamic_entry (info, DT_RELSZ, 0)
3113 || ! bfd_elf32_add_dynamic_entry (info, DT_RELENT,
3114 sizeof (Elf32_External_Rel)))
3115 return false;
3116 }
3117
99e4ae17 3118 if ((info->flags & DF_TEXTREL) != 0)
252b5132
RH		 3119 {
3120 if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
3121 return false;
d6cf2879 3122 info->flags |= DF_TEXTREL;
252b5132
RH		 3123 }
3124 }
3125
3126 return true;
3127}
3128
3129/* This function is called via elf32_arm_link_hash_traverse if we are
3130 creating a shared object with -Bsymbolic. It discards the space
3131 allocated to copy PC relative relocs against symbols which are
3132 defined in regular objects. We allocated space for them in the
3133 check_relocs routine, but we won't fill them in in the
3134 relocate_section routine. */
3135
3136static boolean
3137elf32_arm_discard_copies (h, ignore)
3138 struct elf32_arm_link_hash_entry * h;
5f771d47 3139 PTR ignore ATTRIBUTE_UNUSED;
252b5132
RH		 3140{
3141 struct elf32_arm_pcrel_relocs_copied * s;
3142
3143 /* We only discard relocs for symbols defined in a regular object. */
3144 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3145 return true;
3146
3147 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
3148 s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
3149
3150 return true;
3151}
3152
3153/* Finish up dynamic symbol handling. We set the contents of various
3154 dynamic sections here. */
3155
3156static boolean
3157elf32_arm_finish_dynamic_symbol (output_bfd, info, h, sym)
3158 bfd * output_bfd;
3159 struct bfd_link_info * info;
3160 struct elf_link_hash_entry * h;
3161 Elf_Internal_Sym * sym;
3162{
3163 bfd * dynobj;
3164
3165 dynobj = elf_hash_table (info)->dynobj;
3166
3167 if (h->plt.offset != (bfd_vma) -1)
3168 {
3169 asection * splt;
3170 asection * sgot;
3171 asection * srel;
3172 bfd_vma plt_index;
3173 bfd_vma got_offset;
3174 Elf_Internal_Rel rel;
3175
3176 /* This symbol has an entry in the procedure linkage table. Set
3177 it up. */
3178
3179 BFD_ASSERT (h->dynindx != -1);
3180
3181 splt = bfd_get_section_by_name (dynobj, ".plt");
3182 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3183 srel = bfd_get_section_by_name (dynobj, ".rel.plt");
3184 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
3185
3186 /* Get the index in the procedure linkage table which
3187 corresponds to this symbol. This is the index of this symbol
3188 in all the symbols for which we are making plt entries. The
3189 first entry in the procedure linkage table is reserved. */
3190 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3191
3192 /* Get the offset into the .got table of the entry that
3193 corresponds to this function. Each .got entry is 4 bytes.
3194 The first three are reserved. */
3195 got_offset = (plt_index + 3) * 4;
3196
3197 /* Fill in the entry in the procedure linkage table. */
f7a74f8c
NC		 3198 bfd_put_32 (output_bfd, elf32_arm_plt_entry[0],
3199 splt->contents + h->plt.offset + 0);
3200 bfd_put_32 (output_bfd, elf32_arm_plt_entry[1],
3201 splt->contents + h->plt.offset + 4);
3202 bfd_put_32 (output_bfd, elf32_arm_plt_entry[2],
3203 splt->contents + h->plt.offset + 8);
252b5132
RH		 3204 bfd_put_32 (output_bfd,
3205 (sgot->output_section->vma
3206 + sgot->output_offset
f21f3fe0 3207 + got_offset
252b5132
RH		 3208 - splt->output_section->vma
3209 - splt->output_offset
3210 - h->plt.offset - 12),
3211 splt->contents + h->plt.offset + 12);
3212
3213 /* Fill in the entry in the global offset table. */
3214 bfd_put_32 (output_bfd,
3215 (splt->output_section->vma
3216 + splt->output_offset),
3217 sgot->contents + got_offset);
3218
3219 /* Fill in the entry in the .rel.plt section. */
3220 rel.r_offset = (sgot->output_section->vma
3221 + sgot->output_offset
3222 + got_offset);
3223 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
3224 bfd_elf32_swap_reloc_out (output_bfd, &rel,
3225 ((Elf32_External_Rel *) srel->contents
3226 + plt_index));
3227
3228 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3229 {
3230 /* Mark the symbol as undefined, rather than as defined in
3231 the .plt section. Leave the value alone. */
3232 sym->st_shndx = SHN_UNDEF;
d982ba73
PB		 3233 /* If the symbol is weak, we do need to clear the value.
3234 Otherwise, the PLT entry would provide a definition for
3235 the symbol even if the symbol wasn't defined anywhere,
3236 and so the symbol would never be NULL. */
3237 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
3238 == 0)
3239 sym->st_value = 0;
252b5132
RH		 3240 }
3241 }
3242
3243 if (h->got.offset != (bfd_vma) -1)
3244 {
3245 asection * sgot;
3246 asection * srel;
3247 Elf_Internal_Rel rel;
3248
3249 /* This symbol has an entry in the global offset table. Set it
3250 up. */
252b5132
RH		 3251 sgot = bfd_get_section_by_name (dynobj, ".got");
3252 srel = bfd_get_section_by_name (dynobj, ".rel.got");
3253 BFD_ASSERT (sgot != NULL && srel != NULL);
3254
3255 rel.r_offset = (sgot->output_section->vma
3256 + sgot->output_offset
3257 + (h->got.offset &~ 1));
3258
3259 /* If this is a -Bsymbolic link, and the symbol is defined
3260 locally, we just want to emit a RELATIVE reloc. The entry in
3261 the global offset table will already have been initialized in
3262 the relocate_section function. */
3263 if (info->shared
3264 && (info->symbolic || h->dynindx == -1)
3265 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3266 rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
3267 else
3268 {
3269 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
3270 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
3271 }
3272
3273 bfd_elf32_swap_reloc_out (output_bfd, &rel,
3274 ((Elf32_External_Rel *) srel->contents
3275 + srel->reloc_count));
3276 ++srel->reloc_count;
3277 }
3278
3279 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
3280 {
3281 asection * s;
3282 Elf_Internal_Rel rel;
3283
3284 /* This symbol needs a copy reloc. Set it up. */
252b5132
RH		 3285 BFD_ASSERT (h->dynindx != -1
3286 && (h->root.type == bfd_link_hash_defined
3287 || h->root.type == bfd_link_hash_defweak));
3288
3289 s = bfd_get_section_by_name (h->root.u.def.section->owner,
3290 ".rel.bss");
3291 BFD_ASSERT (s != NULL);
3292
3293 rel.r_offset = (h->root.u.def.value
3294 + h->root.u.def.section->output_section->vma
3295 + h->root.u.def.section->output_offset);
3296 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
3297 bfd_elf32_swap_reloc_out (output_bfd, &rel,
3298 ((Elf32_External_Rel *) s->contents
3299 + s->reloc_count));
3300 ++s->reloc_count;
3301 }
3302
3303 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3304 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3305 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3306 sym->st_shndx = SHN_ABS;
3307
3308 return true;
3309}
3310
3311/* Finish up the dynamic sections. */
3312
3313static boolean
3314elf32_arm_finish_dynamic_sections (output_bfd, info)
3315 bfd * output_bfd;
3316 struct bfd_link_info * info;
3317{
3318 bfd * dynobj;
3319 asection * sgot;
3320 asection * sdyn;
3321
3322 dynobj = elf_hash_table (info)->dynobj;
3323
3324 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3325 BFD_ASSERT (sgot != NULL);
3326 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3327
3328 if (elf_hash_table (info)->dynamic_sections_created)
3329 {
3330 asection *splt;
3331 Elf32_External_Dyn *dyncon, *dynconend;
3332
3333 splt = bfd_get_section_by_name (dynobj, ".plt");
3334 BFD_ASSERT (splt != NULL && sdyn != NULL);
3335
3336 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3337 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
9b485d32 3338
252b5132
RH		 3339 for (; dyncon < dynconend; dyncon++)
3340 {
3341 Elf_Internal_Dyn dyn;
3342 const char * name;
3343 asection * s;
3344
3345 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3346
3347 switch (dyn.d_tag)
3348 {
3349 default:
3350 break;
3351
3352 case DT_PLTGOT:
3353 name = ".got";
3354 goto get_vma;
3355 case DT_JMPREL:
3356 name = ".rel.plt";
3357 get_vma:
3358 s = bfd_get_section_by_name (output_bfd, name);
3359 BFD_ASSERT (s != NULL);
3360 dyn.d_un.d_ptr = s->vma;
3361 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3362 break;
3363
3364 case DT_PLTRELSZ:
3365 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3366 BFD_ASSERT (s != NULL);
3367 if (s->_cooked_size != 0)
3368 dyn.d_un.d_val = s->_cooked_size;
3369 else
3370 dyn.d_un.d_val = s->_raw_size;
3371 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3372 break;
3373
3374 case DT_RELSZ:
3375 /* My reading of the SVR4 ABI indicates that the
3376 procedure linkage table relocs (DT_JMPREL) should be
3377 included in the overall relocs (DT_REL). This is
3378 what Solaris does. However, UnixWare can not handle
3379 that case. Therefore, we override the DT_RELSZ entry
3380 here to make it not include the JMPREL relocs. Since
3381 the linker script arranges for .rel.plt to follow all
3382 other relocation sections, we don't have to worry
3383 about changing the DT_REL entry. */
3384 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3385 if (s != NULL)
3386 {
3387 if (s->_cooked_size != 0)
3388 dyn.d_un.d_val -= s->_cooked_size;
3389 else
3390 dyn.d_un.d_val -= s->_raw_size;
3391 }
3392 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3393 break;
3394 }
3395 }
3396
3397 /* Fill in the first entry in the procedure linkage table. */
3398 if (splt->_raw_size > 0)
f7a74f8c
NC		 3399 {
3400 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[0], splt->contents + 0);
3401 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[1], splt->contents + 4);
3402 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[2], splt->contents + 8);
3403 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[3], splt->contents + 12);
3404 }
252b5132
RH		 3405
3406 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3407 really seem like the right value. */
3408 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
3409 }
3410
3411 /* Fill in the first three entries in the global offset table. */
3412 if (sgot->_raw_size > 0)
3413 {
3414 if (sdyn == NULL)
3415 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
3416 else
3417 bfd_put_32 (output_bfd,
3418 sdyn->output_section->vma + sdyn->output_offset,
3419 sgot->contents);
3420 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
3421 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3422 }
3423
3424 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
3425
3426 return true;
3427}
3428
ba96a88f
NC		 3429static void
3430elf32_arm_post_process_headers (abfd, link_info)
3431 bfd * abfd;
5f771d47 3432 struct bfd_link_info * link_info ATTRIBUTE_UNUSED;
ba96a88f 3433{
9b485d32 3434 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
ba96a88f
NC		 3435
3436 i_ehdrp = elf_elfheader (abfd);
3437
3438 i_ehdrp->e_ident[EI_OSABI] = ARM_ELF_OS_ABI_VERSION;
3439 i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
3440}
3441
99e4ae17
AJ		 3442static enum elf_reloc_type_class
3443elf32_arm_reloc_type_class (type)
3444 int type;
3445{
3446 switch (type)
3447 {
3448 case R_ARM_RELATIVE:
3449 return reloc_class_relative;
3450 case R_ARM_JUMP_SLOT:
3451 return reloc_class_plt;
3452 case R_ARM_COPY:
3453 return reloc_class_copy;
3454 default:
3455 return reloc_class_normal;
3456 }
3457}
3458
3459
252b5132
RH		 3460#define ELF_ARCH bfd_arch_arm
3461#define ELF_MACHINE_CODE EM_ARM
f21f3fe0 3462#define ELF_MAXPAGESIZE 0x8000
252b5132 3463
99e4ae17
AJ		 3464#define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
3465#define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
252b5132
RH		 3466#define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
3467#define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
3468#define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
99e4ae17 3469#define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
252b5132
RH		 3470#define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
3471
3472#define elf_backend_get_symbol_type elf32_arm_get_symbol_type
3473#define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
3474#define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
3475#define elf_backend_check_relocs elf32_arm_check_relocs
99e4ae17 3476#define elf_backend_relocate_section elf32_arm_relocate_section
252b5132
RH		 3477#define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
3478#define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
3479#define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
3480#define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
3481#define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
ba96a88f 3482#define elf_backend_post_process_headers elf32_arm_post_process_headers
99e4ae17 3483#define elf_backend_reloc_type_class elf32_arm_reloc_type_class
252b5132
RH		 3484
3485#define elf_backend_can_gc_sections 1
3486#define elf_backend_plt_readonly 1
3487#define elf_backend_want_got_plt 1
3488#define elf_backend_want_plt_sym 0
3489
04f7c78d
NC		 3490#define elf_backend_got_header_size 12
3491#define elf_backend_plt_header_size PLT_ENTRY_SIZE
3492
252b5132 3493#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.251515 seconds and 4 git commands to generate.