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