projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* elflink.h (elf_gc_mark): Pass in the section whose relocs we are
[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
1e2f5b6e 61 PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
917583ad
NC		 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;
cedb70c5 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));
cedb70c5 1543
51c5503b
NC		 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 }
cedb70c5 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
cedb70c5 1577 /* If we are addressing a Thumb function, we need to adjust the
ee29b9fb
RE		 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. */
82e51918 2226 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
1fe494a5
NC		 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),
cedb70c5 2377 bfd_get_filename (obfd));
e3c8793a
NC		 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 2531static asection *
1e2f5b6e
AM		 2532elf32_arm_gc_mark_hook (sec, info, rel, h, sym)
2533 asection *sec;
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
1e2f5b6e 2563 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
9ad5cbcf 2564
252b5132
RH		 2565 return NULL;
2566}
2567
780a67af
NC		 2568/* Update the got entry reference counts for the section being removed. */
2569
252b5132
RH		 2570static boolean
2571elf32_arm_gc_sweep_hook (abfd, info, sec, relocs)
5f771d47
ILT		 2572 bfd *abfd ATTRIBUTE_UNUSED;
2573 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2574 asection *sec ATTRIBUTE_UNUSED;
2575 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
252b5132 2576{
780a67af 2577 /* We don't support garbage collection of GOT and PLT relocs yet. */
252b5132
RH		 2578 return true;
2579}
2580
780a67af
NC		 2581/* Look through the relocs for a section during the first phase. */
2582
252b5132
RH		 2583static boolean
2584elf32_arm_check_relocs (abfd, info, sec, relocs)
2585 bfd * abfd;
2586 struct bfd_link_info * info;
2587 asection * sec;
2588 const Elf_Internal_Rela * relocs;
2589{
2590 Elf_Internal_Shdr * symtab_hdr;
2591 struct elf_link_hash_entry ** sym_hashes;
2592 struct elf_link_hash_entry ** sym_hashes_end;
2593 const Elf_Internal_Rela * rel;
2594 const Elf_Internal_Rela * rel_end;
2595 bfd * dynobj;
2596 asection * sgot, *srelgot, *sreloc;
2597 bfd_vma * local_got_offsets;
9a5aca8c 2598
252b5132
RH		 2599 if (info->relocateable)
2600 return true;
9a5aca8c 2601
252b5132 2602 sgot = srelgot = sreloc = NULL;
9a5aca8c 2603
252b5132
RH		 2604 dynobj = elf_hash_table (info)->dynobj;
2605 local_got_offsets = elf_local_got_offsets (abfd);
f21f3fe0 2606
252b5132
RH		 2607 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2608 sym_hashes = elf_sym_hashes (abfd);
9b485d32
NC		 2609 sym_hashes_end = sym_hashes
2610 + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
2611
252b5132
RH		 2612 if (!elf_bad_symtab (abfd))
2613 sym_hashes_end -= symtab_hdr->sh_info;
9b485d32 2614
252b5132
RH		 2615 rel_end = relocs + sec->reloc_count;
2616 for (rel = relocs; rel < rel_end; rel++)
2617 {
2618 struct elf_link_hash_entry *h;
2619 unsigned long r_symndx;
9a5aca8c 2620
252b5132
RH		 2621 r_symndx = ELF32_R_SYM (rel->r_info);
2622 if (r_symndx < symtab_hdr->sh_info)
2623 h = NULL;
2624 else
2625 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
9a5aca8c 2626
252b5132
RH		 2627 /* Some relocs require a global offset table. */
2628 if (dynobj == NULL)
2629 {
2630 switch (ELF32_R_TYPE (rel->r_info))
2631 {
2632 case R_ARM_GOT32:
2633 case R_ARM_GOTOFF:
2634 case R_ARM_GOTPC:
2635 elf_hash_table (info)->dynobj = dynobj = abfd;
2636 if (! _bfd_elf_create_got_section (dynobj, info))
2637 return false;
2638 break;
2639
2640 default:
2641 break;
2642 }
2643 }
2644
2645 switch (ELF32_R_TYPE (rel->r_info))
2646 {
2647 case R_ARM_GOT32:
2648 /* This symbol requires a global offset table entry. */
2649 if (sgot == NULL)
2650 {
2651 sgot = bfd_get_section_by_name (dynobj, ".got");
2652 BFD_ASSERT (sgot != NULL);
2653 }
2654
2655 /* Get the got relocation section if necessary. */
2656 if (srelgot == NULL
2657 && (h != NULL || info->shared))
2658 {
2659 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
9a5aca8c 2660
252b5132
RH		 2661 /* If no got relocation section, make one and initialize. */
2662 if (srelgot == NULL)
2663 {
2664 srelgot = bfd_make_section (dynobj, ".rel.got");
2665 if (srelgot == NULL
2666 || ! bfd_set_section_flags (dynobj, srelgot,
99e4ae17 2667 (SEC_ALLOC
252b5132
RH		 2668 | SEC_LOAD
2669 | SEC_HAS_CONTENTS
2670 | SEC_IN_MEMORY
2671 | SEC_LINKER_CREATED
2672 | SEC_READONLY))
2673 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
2674 return false;
2675 }
2676 }
2677
2678 if (h != NULL)
2679 {
2680 if (h->got.offset != (bfd_vma) -1)
2681 /* We have already allocated space in the .got. */
2682 break;
f21f3fe0 2683
252b5132
RH		 2684 h->got.offset = sgot->_raw_size;
2685
2686 /* Make sure this symbol is output as a dynamic symbol. */
2687 if (h->dynindx == -1)
2688 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2689 return false;
2690
2691 srelgot->_raw_size += sizeof (Elf32_External_Rel);
2692 }
2693 else
2694 {
99e4ae17 2695 /* This is a global offset table entry for a local
252b5132
RH		 2696 symbol. */
2697 if (local_got_offsets == NULL)
2698 {
dc810e39 2699 bfd_size_type size;
63b0f745 2700 unsigned int i;
252b5132 2701
dc810e39
AM		 2702 size = symtab_hdr->sh_info;
2703 size *= sizeof (bfd_vma);
252b5132
RH		 2704 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
2705 if (local_got_offsets == NULL)
2706 return false;
2707 elf_local_got_offsets (abfd) = local_got_offsets;
2708 for (i = 0; i < symtab_hdr->sh_info; i++)
2709 local_got_offsets[i] = (bfd_vma) -1;
2710 }
f21f3fe0 2711
252b5132
RH		 2712 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
2713 /* We have already allocated space in the .got. */
2714 break;
2715
2716 local_got_offsets[r_symndx] = sgot->_raw_size;
2717
2718 if (info->shared)
2719 /* If we are generating a shared object, we need to
2720 output a R_ARM_RELATIVE reloc so that the dynamic
2721 linker can adjust this GOT entry. */
2722 srelgot->_raw_size += sizeof (Elf32_External_Rel);
2723 }
2724
2725 sgot->_raw_size += 4;
2726 break;
2727
99e4ae17 2728 case R_ARM_PLT32:
252b5132
RH		 2729 /* This symbol requires a procedure linkage table entry. We
2730 actually build the entry in adjust_dynamic_symbol,
2731 because this might be a case of linking PIC code which is
2732 never referenced by a dynamic object, in which case we
2733 don't need to generate a procedure linkage table entry
2734 after all. */
2735
2736 /* If this is a local symbol, we resolve it directly without
2737 creating a procedure linkage table entry. */
2738 if (h == NULL)
2739 continue;
2740
2741 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2742 break;
2743
2744 case R_ARM_ABS32:
2745 case R_ARM_REL32:
2746 case R_ARM_PC24:
2747 /* If we are creating a shared library, and this is a reloc
2748 against a global symbol, or a non PC relative reloc
2749 against a local symbol, then we need to copy the reloc
2750 into the shared library. However, if we are linking with
2751 -Bsymbolic, we do not need to copy a reloc against a
2752 global symbol which is defined in an object we are
2753 including in the link (i.e., DEF_REGULAR is set). At
2754 this point we have not seen all the input files, so it is
2755 possible that DEF_REGULAR is not set now but will be set
2756 later (it is never cleared). We account for that
2757 possibility below by storing information in the
2758 pcrel_relocs_copied field of the hash table entry. */
2759 if (info->shared
2760 && (ELF32_R_TYPE (rel->r_info) != R_ARM_PC24
2761 || (h != NULL
2762 && (! info->symbolic
2763 || (h->elf_link_hash_flags
2764 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2765 {
2766 /* When creating a shared object, we must copy these
2767 reloc types into the output file. We create a reloc
2768 section in dynobj and make room for this reloc. */
2769 if (sreloc == NULL)
2770 {
2771 const char * name;
2772
2773 name = (bfd_elf_string_from_elf_section
2774 (abfd,
2775 elf_elfheader (abfd)->e_shstrndx,
2776 elf_section_data (sec)->rel_hdr.sh_name));
2777 if (name == NULL)
2778 return false;
2779
2780 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
99e4ae17 2781 && strcmp (bfd_get_section_name (abfd, sec),
252b5132
RH		 2782 name + 4) == 0);
2783
2784 sreloc = bfd_get_section_by_name (dynobj, name);
2785 if (sreloc == NULL)
2786 {
2787 flagword flags;
2788
2789 sreloc = bfd_make_section (dynobj, name);
2790 flags = (SEC_HAS_CONTENTS | SEC_READONLY
2791 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2792 if ((sec->flags & SEC_ALLOC) != 0)
2793 flags |= SEC_ALLOC | SEC_LOAD;
2794 if (sreloc == NULL
2795 || ! bfd_set_section_flags (dynobj, sreloc, flags)
2796 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
2797 return false;
2798 }
99e4ae17
AJ		 2799 if (sec->flags & SEC_READONLY)
2800 info->flags |= DF_TEXTREL;
252b5132
RH		 2801 }
2802
2803 sreloc->_raw_size += sizeof (Elf32_External_Rel);
2804 /* If we are linking with -Bsymbolic, and this is a
2805 global symbol, we count the number of PC relative
2806 relocations we have entered for this symbol, so that
2807 we can discard them again if the symbol is later
2808 defined by a regular object. Note that this function
2809 is only called if we are using an elf_i386 linker
2810 hash table, which means that h is really a pointer to
2811 an elf_i386_link_hash_entry. */
2812 if (h != NULL && info->symbolic
2813 && ELF32_R_TYPE (rel->r_info) == R_ARM_PC24)
2814 {
2815 struct elf32_arm_link_hash_entry * eh;
2816 struct elf32_arm_pcrel_relocs_copied * p;
2817
2818 eh = (struct elf32_arm_link_hash_entry *) h;
2819
2820 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
2821 if (p->section == sreloc)
2822 break;
2823
2824 if (p == NULL)
2825 {
2826 p = ((struct elf32_arm_pcrel_relocs_copied *)
dc810e39 2827 bfd_alloc (dynobj, (bfd_size_type) sizeof * p));
252b5132
RH		 2828 if (p == NULL)
2829 return false;
2830 p->next = eh->pcrel_relocs_copied;
2831 eh->pcrel_relocs_copied = p;
2832 p->section = sreloc;
2833 p->count = 0;
2834 }
2835
2836 ++p->count;
2837 }
2838 }
2839 break;
2840
2841 /* This relocation describes the C++ object vtable hierarchy.
2842 Reconstruct it for later use during GC. */
2843 case R_ARM_GNU_VTINHERIT:
2844 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2845 return false;
2846 break;
9a5aca8c 2847
252b5132
RH		 2848 /* This relocation describes which C++ vtable entries are actually
2849 used. Record for later use during GC. */
2850 case R_ARM_GNU_VTENTRY:
d512aa07 2851 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
252b5132
RH		 2852 return false;
2853 break;
2854 }
2855 }
f21f3fe0 2856
252b5132
RH		 2857 return true;
2858}
2859
252b5132
RH		 2860/* Find the nearest line to a particular section and offset, for error
2861 reporting. This code is a duplicate of the code in elf.c, except
9b485d32 2862 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
252b5132
RH		 2863
2864static boolean
2865elf32_arm_find_nearest_line
2866 (abfd, section, symbols, offset, filename_ptr, functionname_ptr, line_ptr)
2867 bfd * abfd;
2868 asection * section;
2869 asymbol ** symbols;
2870 bfd_vma offset;
917583ad
NC		 2871 const char ** filename_ptr;
2872 const char ** functionname_ptr;
252b5132
RH		 2873 unsigned int * line_ptr;
2874{
2875 boolean found;
2876 const char * filename;
2877 asymbol * func;
2878 bfd_vma low_func;
2879 asymbol ** p;
2880
2881 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
f21f3fe0 2882 filename_ptr, functionname_ptr,
857ec808
NC		 2883 line_ptr, 0,
2884 &elf_tdata (abfd)->dwarf2_find_line_info))
252b5132
RH		 2885 return true;
2886
2887 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
2888 &found, filename_ptr,
2889 functionname_ptr, line_ptr,
2890 &elf_tdata (abfd)->line_info))
2891 return false;
f21f3fe0 2892
252b5132
RH		 2893 if (found)
2894 return true;
2895
2896 if (symbols == NULL)
2897 return false;
2898
2899 filename = NULL;
2900 func = NULL;
2901 low_func = 0;
2902
2903 for (p = symbols; *p != NULL; p++)
2904 {
2905 elf_symbol_type *q;
2906
2907 q = (elf_symbol_type *) *p;
2908
2909 if (bfd_get_section (&q->symbol) != section)
2910 continue;
2911
2912 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
2913 {
2914 default:
2915 break;
2916 case STT_FILE:
2917 filename = bfd_asymbol_name (&q->symbol);
2918 break;
2919 case STT_NOTYPE:
2920 case STT_FUNC:
2921 case STT_ARM_TFUNC:
2922 if (q->symbol.section == section
2923 && q->symbol.value >= low_func
2924 && q->symbol.value <= offset)
2925 {
2926 func = (asymbol *) q;
2927 low_func = q->symbol.value;
2928 }
2929 break;
2930 }
2931 }
2932
2933 if (func == NULL)
2934 return false;
2935
2936 *filename_ptr = filename;
2937 *functionname_ptr = bfd_asymbol_name (func);
2938 *line_ptr = 0;
f21f3fe0 2939
252b5132
RH		 2940 return true;
2941}
2942
2943/* Adjust a symbol defined by a dynamic object and referenced by a
2944 regular object. The current definition is in some section of the
2945 dynamic object, but we're not including those sections. We have to
2946 change the definition to something the rest of the link can
2947 understand. */
2948
2949static boolean
2950elf32_arm_adjust_dynamic_symbol (info, h)
2951 struct bfd_link_info * info;
2952 struct elf_link_hash_entry * h;
2953{
2954 bfd * dynobj;
2955 asection * s;
2956 unsigned int power_of_two;
2957
2958 dynobj = elf_hash_table (info)->dynobj;
2959
2960 /* Make sure we know what is going on here. */
2961 BFD_ASSERT (dynobj != NULL
2962 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
2963 || h->weakdef != NULL
2964 || ((h->elf_link_hash_flags
2965 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2966 && (h->elf_link_hash_flags
2967 & ELF_LINK_HASH_REF_REGULAR) != 0
2968 && (h->elf_link_hash_flags
2969 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
2970
2971 /* If this is a function, put it in the procedure linkage table. We
2972 will fill in the contents of the procedure linkage table later,
2973 when we know the address of the .got section. */
2974 if (h->type == STT_FUNC
2975 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2976 {
2977 if (! info->shared
2978 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
2979 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
2980 {
2981 /* This case can occur if we saw a PLT32 reloc in an input
2982 file, but the symbol was never referred to by a dynamic
2983 object. In such a case, we don't actually need to build
2984 a procedure linkage table, and we can just do a PC32
2985 reloc instead. */
2986 BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
2987 return true;
2988 }
2989
2990 /* Make sure this symbol is output as a dynamic symbol. */
2991 if (h->dynindx == -1)
2992 {
2993 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2994 return false;
2995 }
2996
2997 s = bfd_get_section_by_name (dynobj, ".plt");
2998 BFD_ASSERT (s != NULL);
2999
3000 /* If this is the first .plt entry, make room for the special
3001 first entry. */
3002 if (s->_raw_size == 0)
3003 s->_raw_size += PLT_ENTRY_SIZE;
3004
3005 /* If this symbol is not defined in a regular file, and we are
3006 not generating a shared library, then set the symbol to this
3007 location in the .plt. This is required to make function
3008 pointers compare as equal between the normal executable and
3009 the shared library. */
3010 if (! info->shared
3011 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3012 {
3013 h->root.u.def.section = s;
3014 h->root.u.def.value = s->_raw_size;
3015 }
3016
3017 h->plt.offset = s->_raw_size;
3018
3019 /* Make room for this entry. */
3020 s->_raw_size += PLT_ENTRY_SIZE;
3021
3022 /* We also need to make an entry in the .got.plt section, which
3023 will be placed in the .got section by the linker script. */
252b5132
RH		 3024 s = bfd_get_section_by_name (dynobj, ".got.plt");
3025 BFD_ASSERT (s != NULL);
3026 s->_raw_size += 4;
3027
3028 /* We also need to make an entry in the .rel.plt section. */
3029
3030 s = bfd_get_section_by_name (dynobj, ".rel.plt");
3031 BFD_ASSERT (s != NULL);
3032 s->_raw_size += sizeof (Elf32_External_Rel);
3033
3034 return true;
3035 }
3036
3037 /* If this is a weak symbol, and there is a real definition, the
3038 processor independent code will have arranged for us to see the
3039 real definition first, and we can just use the same value. */
3040 if (h->weakdef != NULL)
3041 {
3042 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
3043 || h->weakdef->root.type == bfd_link_hash_defweak);
3044 h->root.u.def.section = h->weakdef->root.u.def.section;
3045 h->root.u.def.value = h->weakdef->root.u.def.value;
3046 return true;
3047 }
3048
3049 /* This is a reference to a symbol defined by a dynamic object which
3050 is not a function. */
3051
3052 /* If we are creating a shared library, we must presume that the
3053 only references to the symbol are via the global offset table.
3054 For such cases we need not do anything here; the relocations will
3055 be handled correctly by relocate_section. */
3056 if (info->shared)
3057 return true;
3058
3059 /* We must allocate the symbol in our .dynbss section, which will
3060 become part of the .bss section of the executable. There will be
3061 an entry for this symbol in the .dynsym section. The dynamic
3062 object will contain position independent code, so all references
3063 from the dynamic object to this symbol will go through the global
3064 offset table. The dynamic linker will use the .dynsym entry to
3065 determine the address it must put in the global offset table, so
3066 both the dynamic object and the regular object will refer to the
3067 same memory location for the variable. */
252b5132
RH		 3068 s = bfd_get_section_by_name (dynobj, ".dynbss");
3069 BFD_ASSERT (s != NULL);
3070
3071 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
3072 copy the initial value out of the dynamic object and into the
3073 runtime process image. We need to remember the offset into the
3074 .rel.bss section we are going to use. */
3075 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
3076 {
3077 asection *srel;
3078
3079 srel = bfd_get_section_by_name (dynobj, ".rel.bss");
3080 BFD_ASSERT (srel != NULL);
3081 srel->_raw_size += sizeof (Elf32_External_Rel);
3082 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
3083 }
3084
3085 /* We need to figure out the alignment required for this symbol. I
3086 have no idea how ELF linkers handle this. */
3087 power_of_two = bfd_log2 (h->size);
3088 if (power_of_two > 3)
3089 power_of_two = 3;
3090
3091 /* Apply the required alignment. */
3092 s->_raw_size = BFD_ALIGN (s->_raw_size,
3093 (bfd_size_type) (1 << power_of_two));
3094 if (power_of_two > bfd_get_section_alignment (dynobj, s))
3095 {
3096 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
3097 return false;
3098 }
3099
3100 /* Define the symbol as being at this point in the section. */
3101 h->root.u.def.section = s;
3102 h->root.u.def.value = s->_raw_size;
3103
3104 /* Increment the section size to make room for the symbol. */
3105 s->_raw_size += h->size;
3106
3107 return true;
3108}
3109
3110/* Set the sizes of the dynamic sections. */
3111
3112static boolean
3113elf32_arm_size_dynamic_sections (output_bfd, info)
99e4ae17 3114 bfd * output_bfd ATTRIBUTE_UNUSED;
252b5132
RH		 3115 struct bfd_link_info * info;
3116{
3117 bfd * dynobj;
3118 asection * s;
3119 boolean plt;
3120 boolean relocs;
252b5132
RH		 3121
3122 dynobj = elf_hash_table (info)->dynobj;
3123 BFD_ASSERT (dynobj != NULL);
3124
3125 if (elf_hash_table (info)->dynamic_sections_created)
3126 {
3127 /* Set the contents of the .interp section to the interpreter. */
3128 if (! info->shared)
3129 {
3130 s = bfd_get_section_by_name (dynobj, ".interp");
3131 BFD_ASSERT (s != NULL);
3132 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3133 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3134 }
3135 }
3136 else
3137 {
3138 /* We may have created entries in the .rel.got section.
3139 However, if we are not creating the dynamic sections, we will
3140 not actually use these entries. Reset the size of .rel.got,
3141 which will cause it to get stripped from the output file
3142 below. */
3143 s = bfd_get_section_by_name (dynobj, ".rel.got");
3144 if (s != NULL)
3145 s->_raw_size = 0;
3146 }
3147
3148 /* If this is a -Bsymbolic shared link, then we need to discard all
3149 PC relative relocs against symbols defined in a regular object.
3150 We allocated space for them in the check_relocs routine, but we
3151 will not fill them in in the relocate_section routine. */
3152 if (info->shared && info->symbolic)
3153 elf32_arm_link_hash_traverse (elf32_arm_hash_table (info),
3154 elf32_arm_discard_copies,
3155 (PTR) NULL);
3156
3157 /* The check_relocs and adjust_dynamic_symbol entry points have
3158 determined the sizes of the various dynamic sections. Allocate
3159 memory for them. */
3160 plt = false;
3161 relocs = false;
252b5132
RH		 3162 for (s = dynobj->sections; s != NULL; s = s->next)
3163 {
3164 const char * name;
3165 boolean strip;
3166
3167 if ((s->flags & SEC_LINKER_CREATED) == 0)
3168 continue;
3169
3170 /* It's OK to base decisions on the section name, because none
3171 of the dynobj section names depend upon the input files. */
3172 name = bfd_get_section_name (dynobj, s);
3173
3174 strip = false;
3175
3176 if (strcmp (name, ".plt") == 0)
3177 {
3178 if (s->_raw_size == 0)
3179 {
3180 /* Strip this section if we don't need it; see the
3181 comment below. */
3182 strip = true;
3183 }
3184 else
3185 {
3186 /* Remember whether there is a PLT. */
3187 plt = true;
3188 }
3189 }
3190 else if (strncmp (name, ".rel", 4) == 0)
3191 {
3192 if (s->_raw_size == 0)
3193 {
3194 /* If we don't need this section, strip it from the
3195 output file. This is mostly to handle .rel.bss and
3196 .rel.plt. We must create both sections in
3197 create_dynamic_sections, because they must be created
3198 before the linker maps input sections to output
3199 sections. The linker does that before
3200 adjust_dynamic_symbol is called, and it is that
3201 function which decides whether anything needs to go
3202 into these sections. */
3203 strip = true;
3204 }
3205 else
3206 {
252b5132
RH		 3207 /* Remember whether there are any reloc sections other
3208 than .rel.plt. */
3209 if (strcmp (name, ".rel.plt") != 0)
99e4ae17 3210 relocs = true;
252b5132
RH		 3211
3212 /* We use the reloc_count field as a counter if we need
3213 to copy relocs into the output file. */
3214 s->reloc_count = 0;
3215 }
3216 }
3217 else if (strncmp (name, ".got", 4) != 0)
3218 {
3219 /* It's not one of our sections, so don't allocate space. */
3220 continue;
3221 }
3222
3223 if (strip)
3224 {
3225 asection ** spp;
3226
3227 for (spp = &s->output_section->owner->sections;
c601ffdb 3228 *spp != NULL;
252b5132 3229 spp = &(*spp)->next)
c601ffdb
AM		 3230 {
3231 if (*spp == s->output_section)
3232 {
3233 bfd_section_list_remove (s->output_section->owner, spp);
3234 --s->output_section->owner->section_count;
3235 break;
3236 }
3237 }
252b5132
RH		 3238 continue;
3239 }
3240
3241 /* Allocate memory for the section contents. */
3242 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
3243 if (s->contents == NULL && s->_raw_size != 0)
3244 return false;
3245 }
3246
3247 if (elf_hash_table (info)->dynamic_sections_created)
3248 {
3249 /* Add some entries to the .dynamic section. We fill in the
3250 values later, in elf32_arm_finish_dynamic_sections, but we
3251 must add the entries now so that we get the correct size for
3252 the .dynamic section. The DT_DEBUG entry is filled in by the
3253 dynamic linker and used by the debugger. */
dc810e39
AM		 3254#define add_dynamic_entry(TAG, VAL) \
3255 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
3256
3257 if (!info->shared)
252b5132 3258 {
dc810e39 3259 if (!add_dynamic_entry (DT_DEBUG, 0))
252b5132
RH		 3260 return false;
3261 }
3262
3263 if (plt)
3264 {
dc810e39
AM		 3265 if ( !add_dynamic_entry (DT_PLTGOT, 0)
3266 || !add_dynamic_entry (DT_PLTRELSZ, 0)
3267 || !add_dynamic_entry (DT_PLTREL, DT_REL)
3268 || !add_dynamic_entry (DT_JMPREL, 0))
252b5132
RH		 3269 return false;
3270 }
3271
3272 if (relocs)
3273 {
dc810e39
AM		 3274 if ( !add_dynamic_entry (DT_REL, 0)
3275 || !add_dynamic_entry (DT_RELSZ, 0)
3276 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
252b5132
RH		 3277 return false;
3278 }
3279
99e4ae17 3280 if ((info->flags & DF_TEXTREL) != 0)
252b5132 3281 {
dc810e39 3282 if (!add_dynamic_entry (DT_TEXTREL, 0))
252b5132 3283 return false;
d6cf2879 3284 info->flags |= DF_TEXTREL;
252b5132
RH		 3285 }
3286 }
dc810e39 3287#undef add_synamic_entry
252b5132
RH		 3288
3289 return true;
3290}
3291
3292/* This function is called via elf32_arm_link_hash_traverse if we are
3293 creating a shared object with -Bsymbolic. It discards the space
3294 allocated to copy PC relative relocs against symbols which are
3295 defined in regular objects. We allocated space for them in the
3296 check_relocs routine, but we won't fill them in in the
3297 relocate_section routine. */
3298
3299static boolean
3300elf32_arm_discard_copies (h, ignore)
3301 struct elf32_arm_link_hash_entry * h;
5f771d47 3302 PTR ignore ATTRIBUTE_UNUSED;
252b5132
RH		 3303{
3304 struct elf32_arm_pcrel_relocs_copied * s;
3305
e92d460e
AM		 3306 if (h->root.root.type == bfd_link_hash_warning)
3307 h = (struct elf32_arm_link_hash_entry *) h->root.root.u.i.link;
3308
252b5132
RH		 3309 /* We only discard relocs for symbols defined in a regular object. */
3310 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3311 return true;
3312
3313 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
3314 s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
3315
3316 return true;
3317}
3318
3319/* Finish up dynamic symbol handling. We set the contents of various
3320 dynamic sections here. */
3321
3322static boolean
3323elf32_arm_finish_dynamic_symbol (output_bfd, info, h, sym)
3324 bfd * output_bfd;
3325 struct bfd_link_info * info;
3326 struct elf_link_hash_entry * h;
3327 Elf_Internal_Sym * sym;
3328{
3329 bfd * dynobj;
3330
3331 dynobj = elf_hash_table (info)->dynobj;
3332
3333 if (h->plt.offset != (bfd_vma) -1)
3334 {
3335 asection * splt;
3336 asection * sgot;
3337 asection * srel;
3338 bfd_vma plt_index;
3339 bfd_vma got_offset;
3340 Elf_Internal_Rel rel;
3341
3342 /* This symbol has an entry in the procedure linkage table. Set
3343 it up. */
3344
3345 BFD_ASSERT (h->dynindx != -1);
3346
3347 splt = bfd_get_section_by_name (dynobj, ".plt");
3348 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3349 srel = bfd_get_section_by_name (dynobj, ".rel.plt");
3350 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
3351
3352 /* Get the index in the procedure linkage table which
3353 corresponds to this symbol. This is the index of this symbol
3354 in all the symbols for which we are making plt entries. The
3355 first entry in the procedure linkage table is reserved. */
3356 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3357
3358 /* Get the offset into the .got table of the entry that
3359 corresponds to this function. Each .got entry is 4 bytes.
3360 The first three are reserved. */
3361 got_offset = (plt_index + 3) * 4;
3362
3363 /* Fill in the entry in the procedure linkage table. */
f7a74f8c
NC		 3364 bfd_put_32 (output_bfd, elf32_arm_plt_entry[0],
3365 splt->contents + h->plt.offset + 0);
3366 bfd_put_32 (output_bfd, elf32_arm_plt_entry[1],
3367 splt->contents + h->plt.offset + 4);
3368 bfd_put_32 (output_bfd, elf32_arm_plt_entry[2],
3369 splt->contents + h->plt.offset + 8);
252b5132
RH		 3370 bfd_put_32 (output_bfd,
3371 (sgot->output_section->vma
3372 + sgot->output_offset
f21f3fe0 3373 + got_offset
252b5132
RH		 3374 - splt->output_section->vma
3375 - splt->output_offset
3376 - h->plt.offset - 12),
3377 splt->contents + h->plt.offset + 12);
3378
3379 /* Fill in the entry in the global offset table. */
3380 bfd_put_32 (output_bfd,
3381 (splt->output_section->vma
3382 + splt->output_offset),
3383 sgot->contents + got_offset);
3384
3385 /* Fill in the entry in the .rel.plt section. */
3386 rel.r_offset = (sgot->output_section->vma
3387 + sgot->output_offset
3388 + got_offset);
3389 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
3390 bfd_elf32_swap_reloc_out (output_bfd, &rel,
3391 ((Elf32_External_Rel *) srel->contents
3392 + plt_index));
3393
3394 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3395 {
3396 /* Mark the symbol as undefined, rather than as defined in
3397 the .plt section. Leave the value alone. */
3398 sym->st_shndx = SHN_UNDEF;
d982ba73
PB		 3399 /* If the symbol is weak, we do need to clear the value.
3400 Otherwise, the PLT entry would provide a definition for
3401 the symbol even if the symbol wasn't defined anywhere,
3402 and so the symbol would never be NULL. */
3403 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
3404 == 0)
3405 sym->st_value = 0;
252b5132
RH		 3406 }
3407 }
3408
3409 if (h->got.offset != (bfd_vma) -1)
3410 {
3411 asection * sgot;
3412 asection * srel;
3413 Elf_Internal_Rel rel;
3414
3415 /* This symbol has an entry in the global offset table. Set it
3416 up. */
252b5132
RH		 3417 sgot = bfd_get_section_by_name (dynobj, ".got");
3418 srel = bfd_get_section_by_name (dynobj, ".rel.got");
3419 BFD_ASSERT (sgot != NULL && srel != NULL);
3420
3421 rel.r_offset = (sgot->output_section->vma
3422 + sgot->output_offset
dc810e39 3423 + (h->got.offset &~ (bfd_vma) 1));
252b5132
RH		 3424
3425 /* If this is a -Bsymbolic link, and the symbol is defined
3426 locally, we just want to emit a RELATIVE reloc. The entry in
3427 the global offset table will already have been initialized in
3428 the relocate_section function. */
3429 if (info->shared
3430 && (info->symbolic || h->dynindx == -1)
3431 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3432 rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
3433 else
3434 {
3435 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
3436 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
3437 }
3438
3439 bfd_elf32_swap_reloc_out (output_bfd, &rel,
3440 ((Elf32_External_Rel *) srel->contents
3441 + srel->reloc_count));
3442 ++srel->reloc_count;
3443 }
3444
3445 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
3446 {
3447 asection * s;
3448 Elf_Internal_Rel rel;
3449
3450 /* This symbol needs a copy reloc. Set it up. */
252b5132
RH		 3451 BFD_ASSERT (h->dynindx != -1
3452 && (h->root.type == bfd_link_hash_defined
3453 || h->root.type == bfd_link_hash_defweak));
3454
3455 s = bfd_get_section_by_name (h->root.u.def.section->owner,
3456 ".rel.bss");
3457 BFD_ASSERT (s != NULL);
3458
3459 rel.r_offset = (h->root.u.def.value
3460 + h->root.u.def.section->output_section->vma
3461 + h->root.u.def.section->output_offset);
3462 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
3463 bfd_elf32_swap_reloc_out (output_bfd, &rel,
3464 ((Elf32_External_Rel *) s->contents
3465 + s->reloc_count));
3466 ++s->reloc_count;
3467 }
3468
3469 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3470 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3471 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3472 sym->st_shndx = SHN_ABS;
3473
3474 return true;
3475}
3476
3477/* Finish up the dynamic sections. */
3478
3479static boolean
3480elf32_arm_finish_dynamic_sections (output_bfd, info)
3481 bfd * output_bfd;
3482 struct bfd_link_info * info;
3483{
3484 bfd * dynobj;
3485 asection * sgot;
3486 asection * sdyn;
3487
3488 dynobj = elf_hash_table (info)->dynobj;
3489
3490 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3491 BFD_ASSERT (sgot != NULL);
3492 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3493
3494 if (elf_hash_table (info)->dynamic_sections_created)
3495 {
3496 asection *splt;
3497 Elf32_External_Dyn *dyncon, *dynconend;
3498
3499 splt = bfd_get_section_by_name (dynobj, ".plt");
3500 BFD_ASSERT (splt != NULL && sdyn != NULL);
3501
3502 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3503 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
9b485d32 3504
252b5132
RH		 3505 for (; dyncon < dynconend; dyncon++)
3506 {
3507 Elf_Internal_Dyn dyn;
3508 const char * name;
3509 asection * s;
3510
3511 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3512
3513 switch (dyn.d_tag)
3514 {
3515 default:
3516 break;
3517
3518 case DT_PLTGOT:
3519 name = ".got";
3520 goto get_vma;
3521 case DT_JMPREL:
3522 name = ".rel.plt";
3523 get_vma:
3524 s = bfd_get_section_by_name (output_bfd, name);
3525 BFD_ASSERT (s != NULL);
3526 dyn.d_un.d_ptr = s->vma;
3527 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3528 break;
3529
3530 case DT_PLTRELSZ:
3531 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3532 BFD_ASSERT (s != NULL);
3533 if (s->_cooked_size != 0)
3534 dyn.d_un.d_val = s->_cooked_size;
3535 else
3536 dyn.d_un.d_val = s->_raw_size;
3537 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3538 break;
3539
3540 case DT_RELSZ:
3541 /* My reading of the SVR4 ABI indicates that the
3542 procedure linkage table relocs (DT_JMPREL) should be
3543 included in the overall relocs (DT_REL). This is
3544 what Solaris does. However, UnixWare can not handle
3545 that case. Therefore, we override the DT_RELSZ entry
3546 here to make it not include the JMPREL relocs. Since
3547 the linker script arranges for .rel.plt to follow all
3548 other relocation sections, we don't have to worry
3549 about changing the DT_REL entry. */
3550 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3551 if (s != NULL)
3552 {
3553 if (s->_cooked_size != 0)
3554 dyn.d_un.d_val -= s->_cooked_size;
3555 else
3556 dyn.d_un.d_val -= s->_raw_size;
3557 }
3558 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3559 break;
3560 }
3561 }
3562
3563 /* Fill in the first entry in the procedure linkage table. */
3564 if (splt->_raw_size > 0)
f7a74f8c
NC		 3565 {
3566 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[0], splt->contents + 0);
3567 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[1], splt->contents + 4);
3568 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[2], splt->contents + 8);
3569 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[3], splt->contents + 12);
3570 }
252b5132
RH		 3571
3572 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3573 really seem like the right value. */
3574 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
3575 }
3576
3577 /* Fill in the first three entries in the global offset table. */
3578 if (sgot->_raw_size > 0)
3579 {
3580 if (sdyn == NULL)
3581 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
3582 else
3583 bfd_put_32 (output_bfd,
3584 sdyn->output_section->vma + sdyn->output_offset,
3585 sgot->contents);
3586 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
3587 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3588 }
3589
3590 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
3591
3592 return true;
3593}
3594
ba96a88f
NC		 3595static void
3596elf32_arm_post_process_headers (abfd, link_info)
3597 bfd * abfd;
5f771d47 3598 struct bfd_link_info * link_info ATTRIBUTE_UNUSED;
ba96a88f 3599{
9b485d32 3600 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
ba96a88f
NC		 3601
3602 i_ehdrp = elf_elfheader (abfd);
3603
3604 i_ehdrp->e_ident[EI_OSABI] = ARM_ELF_OS_ABI_VERSION;
3605 i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
3606}
3607
99e4ae17 3608static enum elf_reloc_type_class
f51e552e
AM		 3609elf32_arm_reloc_type_class (rela)
3610 const Elf_Internal_Rela *rela;
99e4ae17 3611{
f51e552e 3612 switch ((int) ELF32_R_TYPE (rela->r_info))
99e4ae17
AJ		 3613 {
3614 case R_ARM_RELATIVE:
3615 return reloc_class_relative;
3616 case R_ARM_JUMP_SLOT:
3617 return reloc_class_plt;
3618 case R_ARM_COPY:
3619 return reloc_class_copy;
3620 default:
3621 return reloc_class_normal;
3622 }
3623}
3624
3625
252b5132
RH		 3626#define ELF_ARCH bfd_arch_arm
3627#define ELF_MACHINE_CODE EM_ARM
f21f3fe0 3628#define ELF_MAXPAGESIZE 0x8000
252b5132 3629
99e4ae17
AJ		 3630#define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
3631#define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
252b5132
RH		 3632#define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
3633#define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
3634#define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
dc810e39 3635#define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
252b5132
RH		 3636#define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
3637
3638#define elf_backend_get_symbol_type elf32_arm_get_symbol_type
3639#define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
3640#define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
3641#define elf_backend_check_relocs elf32_arm_check_relocs
dc810e39 3642#define elf_backend_relocate_section elf32_arm_relocate_section
252b5132
RH		 3643#define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
3644#define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
3645#define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
3646#define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
3647#define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
ba96a88f 3648#define elf_backend_post_process_headers elf32_arm_post_process_headers
99e4ae17 3649#define elf_backend_reloc_type_class elf32_arm_reloc_type_class
252b5132
RH		 3650
3651#define elf_backend_can_gc_sections 1
3652#define elf_backend_plt_readonly 1
3653#define elf_backend_want_got_plt 1
3654#define elf_backend_want_plt_sym 0
b491616a
AM		 3655#ifndef USE_REL
3656#define elf_backend_rela_normal 1
3657#endif
252b5132 3658
04f7c78d
NC		 3659#define elf_backend_got_header_size 12
3660#define elf_backend_plt_header_size PLT_ENTRY_SIZE
3661
252b5132 3662#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.357864 seconds and 4 git commands to generate.