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