]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - bfd/elf32-arm.h
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* armnbsd-tdep.c (arm_netbsd_aout_in_solib_call_trampoline): New
[thirdparty/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
dc810e39 239 ret = (struct elf32_arm_link_hash_table *) bfd_alloc (abfd, 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
RH		 245 {
246 bfd_release (abfd, ret);
247 return NULL;
248 }
249
250 ret->thumb_glue_size = 0;
251 ret->arm_glue_size = 0;
252 ret->bfd_of_glue_owner = NULL;
ba96a88f 253 ret->no_pipeline_knowledge = 0;
252b5132
RH		 254
255 return &ret->root.root;
256}
257
9b485d32
NC		 258/* Locate the Thumb encoded calling stub for NAME. */
259
252b5132
RH		 260static struct elf_link_hash_entry *
261find_thumb_glue (link_info, name, input_bfd)
262 struct bfd_link_info *link_info;
917583ad 263 const char *name;
252b5132
RH		 264 bfd *input_bfd;
265{
266 char *tmp_name;
267 struct elf_link_hash_entry *hash;
268 struct elf32_arm_link_hash_table *hash_table;
269
270 /* We need a pointer to the armelf specific hash table. */
271 hash_table = elf32_arm_hash_table (link_info);
272
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;
f21f3fe0 1151
c629eae0
JJ		 1152 outrel.r_offset =
1153 _bfd_elf_section_offset (output_bfd, info, input_section,
1154 rel->r_offset);
1155 if (outrel.r_offset == (bfd_vma) -1)
1156 skip = true;
252b5132
RH		 1157 outrel.r_offset += (input_section->output_section->vma
1158 + input_section->output_offset);
f21f3fe0 1159
252b5132
RH		 1160 if (skip)
1161 {
1162 memset (&outrel, 0, sizeof outrel);
1163 relocate = false;
1164 }
1165 else if (r_type == R_ARM_PC24)
1166 {
1167 BFD_ASSERT (h != NULL && h->dynindx != -1);
1168 if ((input_section->flags & SEC_ALLOC) != 0)
1169 relocate = false;
1170 else
1171 relocate = true;
1172 outrel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_PC24);
1173 }
1174 else
1175 {
1176 if (h == NULL
1177 || ((info->symbolic || h->dynindx == -1)
1178 && (h->elf_link_hash_flags
1179 & ELF_LINK_HASH_DEF_REGULAR) != 0))
1180 {
1181 relocate = true;
1182 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
1183 }
1184 else
1185 {
1186 BFD_ASSERT (h->dynindx != -1);
1187 if ((input_section->flags & SEC_ALLOC) != 0)
1188 relocate = false;
1189 else
1190 relocate = true;
1191 outrel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_ABS32);
1192 }
1193 }
f21f3fe0 1194
252b5132
RH		 1195 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1196 (((Elf32_External_Rel *)
1197 sreloc->contents)
1198 + sreloc->reloc_count));
1199 ++sreloc->reloc_count;
9a5aca8c 1200
f21f3fe0 1201 /* If this reloc is against an external symbol, we do not want to
252b5132 1202 fiddle with the addend. Otherwise, we need to include the symbol
9b485d32 1203 value so that it becomes an addend for the dynamic reloc. */
252b5132
RH		 1204 if (! relocate)
1205 return bfd_reloc_ok;
9a5aca8c 1206
f21f3fe0 1207 return _bfd_final_link_relocate (howto, input_bfd, input_section,
252b5132
RH		 1208 contents, rel->r_offset, value,
1209 (bfd_vma) 0);
1210 }
1211 else switch (r_type)
1212 {
dfc5f959
NC		 1213#ifndef OLD_ARM_ABI
1214 case R_ARM_XPC25: /* Arm BLX instruction. */
1215#endif
1216 case R_ARM_PC24: /* Arm B/BL instruction */
1217#ifndef OLD_ARM_ABI
1218 if (r_type == R_ARM_XPC25)
252b5132 1219 {
dfc5f959
NC		 1220 /* Check for Arm calling Arm function. */
1221 /* FIXME: Should we translate the instruction into a BL
1222 instruction instead ? */
1223 if (sym_flags != STT_ARM_TFUNC)
8f615d07 1224 (*_bfd_error_handler) (_("\
dfc5f959 1225%s: Warning: Arm BLX instruction targets Arm function '%s'."),
8f615d07
AM		 1226 bfd_archive_filename (input_bfd),
1227 h ? h->root.root.string : "(local)");
dfc5f959
NC		 1228 }
1229 else
1230#endif
1231 {
1232 /* Check for Arm calling Thumb function. */
1233 if (sym_flags == STT_ARM_TFUNC)
1234 {
1235 elf32_arm_to_thumb_stub (info, sym_name, input_bfd, output_bfd,
1236 input_section, hit_data, sym_sec, rel->r_offset,
1237 signed_addend, value);
1238 return bfd_reloc_ok;
1239 }
252b5132 1240 }
ba96a88f
NC		 1241
1242 if ( strcmp (bfd_get_target (input_bfd), "elf32-littlearm-oabi") == 0
1243 || strcmp (bfd_get_target (input_bfd), "elf32-bigarm-oabi") == 0)
1244 {
1245 /* The old way of doing things. Trearing the addend as a
1246 byte sized field and adding in the pipeline offset. */
ba96a88f
NC		 1247 value -= (input_section->output_section->vma
1248 + input_section->output_offset);
1249 value -= rel->r_offset;
1250 value += addend;
f21f3fe0 1251
ba96a88f
NC		 1252 if (! globals->no_pipeline_knowledge)
1253 value -= 8;
1254 }
1255 else
1256 {
1257 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
1258 where:
1259 S is the address of the symbol in the relocation.
1260 P is address of the instruction being relocated.
1261 A is the addend (extracted from the instruction) in bytes.
f21f3fe0 1262
ba96a88f
NC		 1263 S is held in 'value'.
1264 P is the base address of the section containing the instruction
1265 plus the offset of the reloc into that section, ie:
1266 (input_section->output_section->vma +
1267 input_section->output_offset +
1268 rel->r_offset).
1269 A is the addend, converted into bytes, ie:
1270 (signed_addend * 4)
1271
1272 Note: None of these operations have knowledge of the pipeline
1273 size of the processor, thus it is up to the assembler to encode
1274 this information into the addend. */
ba96a88f
NC		 1275 value -= (input_section->output_section->vma
1276 + input_section->output_offset);
1277 value -= rel->r_offset;
1278 value += (signed_addend << howto->size);
f21f3fe0 1279
ba96a88f
NC		 1280 /* Previous versions of this code also used to add in the pipeline
1281 offset here. This is wrong because the linker is not supposed
1282 to know about such things, and one day it might change. In order
1283 to support old binaries that need the old behaviour however, so
1284 we attempt to detect which ABI was used to create the reloc. */
1285 if (! globals->no_pipeline_knowledge)
f21f3fe0 1286 {
ba96a88f 1287 Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form */
f21f3fe0 1288
ba96a88f 1289 i_ehdrp = elf_elfheader (input_bfd);
f21f3fe0 1290
ba96a88f
NC		 1291 if (i_ehdrp->e_ident[EI_OSABI] == 0)
1292 value -= 8;
1293 }
1294 }
23080146 1295
dcb5e6e6
NC		 1296 signed_addend = value;
1297 signed_addend >>= howto->rightshift;
9a5aca8c 1298
59f2c4e7
NC		 1299 /* It is not an error for an undefined weak reference to be
1300 out of range. Any program that branches to such a symbol
9a5aca8c
AM		 1301 is going to crash anyway, so there is no point worrying
1302 about getting the destination exactly right. */
59f2c4e7
NC		 1303 if (! h || h->root.type != bfd_link_hash_undefweak)
1304 {
9b485d32 1305 /* Perform a signed range check. */
dcb5e6e6 1306 if ( signed_addend > ((bfd_signed_vma) (howto->dst_mask >> 1))
59f2c4e7
NC		 1307 || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1)))
1308 return bfd_reloc_overflow;
1309 }
9a5aca8c 1310
dcb5e6e6
NC		 1311#ifndef OLD_ARM_ABI
1312 /* If necessary set the H bit in the BLX instruction. */
1313 if (r_type == R_ARM_XPC25 && ((value & 2) == 2))
1314 value = (signed_addend & howto->dst_mask)
1315 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask))
1316 | (1 << 24);
1317 else
1318#endif
1319 value = (signed_addend & howto->dst_mask)
1320 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
252b5132 1321 break;
f21f3fe0 1322
252b5132
RH		 1323 case R_ARM_ABS32:
1324 value += addend;
1325 if (sym_flags == STT_ARM_TFUNC)
1326 value |= 1;
1327 break;
f21f3fe0 1328
252b5132
RH		 1329 case R_ARM_REL32:
1330 value -= (input_section->output_section->vma
62efb346 1331 + input_section->output_offset + rel->r_offset);
252b5132
RH		 1332 value += addend;
1333 break;
1334 }
f21f3fe0 1335
252b5132
RH		 1336 bfd_put_32 (input_bfd, value, hit_data);
1337 return bfd_reloc_ok;
1338
1339 case R_ARM_ABS8:
1340 value += addend;
1341 if ((long) value > 0x7f || (long) value < -0x80)
1342 return bfd_reloc_overflow;
1343
1344 bfd_put_8 (input_bfd, value, hit_data);
1345 return bfd_reloc_ok;
1346
1347 case R_ARM_ABS16:
1348 value += addend;
1349
1350 if ((long) value > 0x7fff || (long) value < -0x8000)
1351 return bfd_reloc_overflow;
1352
1353 bfd_put_16 (input_bfd, value, hit_data);
1354 return bfd_reloc_ok;
1355
1356 case R_ARM_ABS12:
1357 /* Support ldr and str instruction for the arm */
1358 /* Also thumb b (unconditional branch). ??? Really? */
1359 value += addend;
1360
1361 if ((long) value > 0x7ff || (long) value < -0x800)
1362 return bfd_reloc_overflow;
1363
1364 value |= (bfd_get_32 (input_bfd, hit_data) & 0xfffff000);
1365 bfd_put_32 (input_bfd, value, hit_data);
1366 return bfd_reloc_ok;
1367
1368 case R_ARM_THM_ABS5:
9b485d32 1369 /* Support ldr and str instructions for the thumb. */
252b5132
RH		 1370#ifdef USE_REL
1371 /* Need to refetch addend. */
1372 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
1373 /* ??? Need to determine shift amount from operand size. */
1374 addend >>= howto->rightshift;
1375#endif
1376 value += addend;
1377
1378 /* ??? Isn't value unsigned? */
1379 if ((long) value > 0x1f || (long) value < -0x10)
1380 return bfd_reloc_overflow;
1381
1382 /* ??? Value needs to be properly shifted into place first. */
1383 value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
1384 bfd_put_16 (input_bfd, value, hit_data);
1385 return bfd_reloc_ok;
1386
dfc5f959
NC		 1387#ifndef OLD_ARM_ABI
1388 case R_ARM_THM_XPC22:
1389#endif
252b5132 1390 case R_ARM_THM_PC22:
dfc5f959 1391 /* Thumb BL (branch long instruction). */
252b5132 1392 {
ba96a88f
NC		 1393 bfd_vma relocation;
1394 boolean overflow = false;
1395 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
1396 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
252b5132 1397 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
ba96a88f
NC		 1398 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
1399 bfd_vma check;
252b5132 1400 bfd_signed_vma signed_check;
252b5132
RH		 1401
1402#ifdef USE_REL
1403 /* Need to refetch the addend and squish the two 11 bit pieces
1404 together. */
1405 {
ba96a88f
NC		 1406 bfd_vma upper = upper_insn & 0x7ff;
1407 bfd_vma lower = lower_insn & 0x7ff;
9b485d32 1408 upper = (upper ^ 0x400) - 0x400; /* Sign extend. */
252b5132 1409 addend = (upper << 12) | (lower << 1);
ba96a88f 1410 signed_addend = addend;
252b5132
RH		 1411 }
1412#endif
dfc5f959
NC		 1413#ifndef OLD_ARM_ABI
1414 if (r_type == R_ARM_THM_XPC22)
1415 {
1416 /* Check for Thumb to Thumb call. */
1417 /* FIXME: Should we translate the instruction into a BL
1418 instruction instead ? */
1419 if (sym_flags == STT_ARM_TFUNC)
8f615d07 1420 (*_bfd_error_handler) (_("\
dfc5f959 1421%s: Warning: Thumb BLX instruction targets thumb function '%s'."),
8f615d07
AM		 1422 bfd_archive_filename (input_bfd),
1423 h ? h->root.root.string : "(local)");
dfc5f959
NC		 1424 }
1425 else
1426#endif
252b5132 1427 {
dfc5f959
NC		 1428 /* If it is not a call to Thumb, assume call to Arm.
1429 If it is a call relative to a section name, then it is not a
1430 function call at all, but rather a long jump. */
1431 if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION)
1432 {
1433 if (elf32_thumb_to_arm_stub
1434 (info, sym_name, input_bfd, output_bfd, input_section,
1435 hit_data, sym_sec, rel->r_offset, signed_addend, value))
1436 return bfd_reloc_ok;
1437 else
1438 return bfd_reloc_dangerous;
1439 }
252b5132 1440 }
f21f3fe0 1441
ba96a88f 1442 relocation = value + signed_addend;
f21f3fe0 1443
252b5132 1444 relocation -= (input_section->output_section->vma
ba96a88f
NC		 1445 + input_section->output_offset
1446 + rel->r_offset);
9a5aca8c 1447
ba96a88f
NC		 1448 if (! globals->no_pipeline_knowledge)
1449 {
9b485d32 1450 Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form. */
9a5aca8c 1451
ba96a88f 1452 i_ehdrp = elf_elfheader (input_bfd);
f21f3fe0 1453
ba96a88f
NC		 1454 /* Previous versions of this code also used to add in the pipline
1455 offset here. This is wrong because the linker is not supposed
1456 to know about such things, and one day it might change. In order
1457 to support old binaries that need the old behaviour however, so
1458 we attempt to detect which ABI was used to create the reloc. */
1459 if ( strcmp (bfd_get_target (input_bfd), "elf32-littlearm-oabi") == 0
1460 || strcmp (bfd_get_target (input_bfd), "elf32-bigarm-oabi") == 0
1461 || i_ehdrp->e_ident[EI_OSABI] == 0)
1462 relocation += 4;
1463 }
f21f3fe0 1464
252b5132
RH		 1465 check = relocation >> howto->rightshift;
1466
1467 /* If this is a signed value, the rightshift just dropped
1468 leading 1 bits (assuming twos complement). */
1469 if ((bfd_signed_vma) relocation >= 0)
1470 signed_check = check;
1471 else
1472 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
1473
252b5132 1474 /* Assumes two's complement. */
ba96a88f 1475 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
252b5132
RH		 1476 overflow = true;
1477
1478 /* Put RELOCATION back into the insn. */
1479 upper_insn = (upper_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 12) & 0x7ff);
1480 lower_insn = (lower_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 1) & 0x7ff);
1481
df425bc0 1482#ifndef OLD_ARM_ABI
4f3c3dbb
NC		 1483 if (r_type == R_ARM_THM_XPC22
1484 && ((lower_insn & 0x1800) == 0x0800))
1485 /* Remove bit zero of the adjusted offset. Bit zero can only be
1486 set if the upper insn is at a half-word boundary, since the
1487 destination address, an ARM instruction, must always be on a
1488 word boundary. The semantics of the BLX (1) instruction, however,
1489 are that bit zero in the offset must always be zero, and the
1490 corresponding bit one in the target address will be set from bit
1491 one of the source address. */
1492 lower_insn &= ~1;
99e4ae17 1493#endif
252b5132
RH		 1494 /* Put the relocated value back in the object file: */
1495 bfd_put_16 (input_bfd, upper_insn, hit_data);
1496 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
1497
1498 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
1499 }
1500 break;
1501
51c5503b
NC		 1502 case R_ARM_THM_PC11:
1503 /* Thumb B (branch) instruction). */
1504 {
1505 bfd_vma relocation;
1506 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
1507 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
1508 bfd_vma check;
1509 bfd_signed_vma signed_check;
1510
1511#ifdef USE_REL
1512 /* Need to refetch addend. */
1513 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
1514 /* ??? Need to determine shift amount from operand size. */
1515 addend >>= howto->rightshift;
1516#endif
1517 relocation = value + addend;
1518
1519 relocation -= (input_section->output_section->vma
1520 + input_section->output_offset
1521 + rel->r_offset);
1522
1523 check = relocation >> howto->rightshift;
1524
1525 /* If this is a signed value, the rightshift just
1526 dropped leading 1 bits (assuming twos complement). */
1527 if ((bfd_signed_vma) relocation >= 0)
1528 signed_check = check;
1529 else
1530 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
1531
1532 relocation |= (bfd_get_16 (input_bfd, hit_data) & (~ howto->dst_mask));
1533
1534 bfd_put_16 (input_bfd, relocation, hit_data);
1535
1536 /* Assumes two's complement. */
1537 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
1538 return bfd_reloc_overflow;
1539
1540 return bfd_reloc_ok;
1541 }
1542
252b5132
RH		 1543 case R_ARM_GNU_VTINHERIT:
1544 case R_ARM_GNU_VTENTRY:
1545 return bfd_reloc_ok;
1546
1547 case R_ARM_COPY:
1548 return bfd_reloc_notsupported;
1549
1550 case R_ARM_GLOB_DAT:
1551 return bfd_reloc_notsupported;
1552
1553 case R_ARM_JUMP_SLOT:
1554 return bfd_reloc_notsupported;
1555
1556 case R_ARM_RELATIVE:
1557 return bfd_reloc_notsupported;
1558
1559 case R_ARM_GOTOFF:
1560 /* Relocation is relative to the start of the
1561 global offset table. */
1562
1563 BFD_ASSERT (sgot != NULL);
1564 if (sgot == NULL)
1565 return bfd_reloc_notsupported;
9a5aca8c 1566
252b5132
RH		 1567 /* Note that sgot->output_offset is not involved in this
1568 calculation. We always want the start of .got. If we
1569 define _GLOBAL_OFFSET_TABLE in a different way, as is
1570 permitted by the ABI, we might have to change this
9b485d32 1571 calculation. */
252b5132 1572 value -= sgot->output_section->vma;
f21f3fe0 1573 return _bfd_final_link_relocate (howto, input_bfd, input_section,
99e4ae17
AJ		 1574 contents, rel->r_offset, value,
1575 (bfd_vma) 0);
252b5132
RH		 1576
1577 case R_ARM_GOTPC:
a7c10850 1578 /* Use global offset table as symbol value. */
252b5132 1579 BFD_ASSERT (sgot != NULL);
f21f3fe0 1580
252b5132
RH		 1581 if (sgot == NULL)
1582 return bfd_reloc_notsupported;
1583
1584 value = sgot->output_section->vma;
f21f3fe0 1585 return _bfd_final_link_relocate (howto, input_bfd, input_section,
99e4ae17
AJ		 1586 contents, rel->r_offset, value,
1587 (bfd_vma) 0);
f21f3fe0 1588
252b5132
RH		 1589 case R_ARM_GOT32:
1590 /* Relocation is to the entry for this symbol in the
9b485d32 1591 global offset table. */
252b5132
RH		 1592 if (sgot == NULL)
1593 return bfd_reloc_notsupported;
f21f3fe0 1594
252b5132
RH		 1595 if (h != NULL)
1596 {
1597 bfd_vma off;
f21f3fe0 1598
252b5132
RH		 1599 off = h->got.offset;
1600 BFD_ASSERT (off != (bfd_vma) -1);
f21f3fe0 1601
252b5132
RH		 1602 if (!elf_hash_table (info)->dynamic_sections_created ||
1603 (info->shared && (info->symbolic || h->dynindx == -1)
1604 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1605 {
1606 /* This is actually a static link, or it is a -Bsymbolic link
1607 and the symbol is defined locally. We must initialize this
1608 entry in the global offset table. Since the offset must
1609 always be a multiple of 4, we use the least significant bit
1610 to record whether we have initialized it already.
f21f3fe0 1611
252b5132 1612 When doing a dynamic link, we create a .rel.got relocation
f21f3fe0 1613 entry to initialize the value. This is done in the
9b485d32 1614 finish_dynamic_symbol routine. */
252b5132
RH		 1615 if ((off & 1) != 0)
1616 off &= ~1;
1617 else
1618 {
1619 bfd_put_32 (output_bfd, value, sgot->contents + off);
1620 h->got.offset |= 1;
1621 }
1622 }
f21f3fe0 1623
252b5132
RH		 1624 value = sgot->output_offset + off;
1625 }
1626 else
1627 {
1628 bfd_vma off;
f21f3fe0 1629
252b5132
RH		 1630 BFD_ASSERT (local_got_offsets != NULL &&
1631 local_got_offsets[r_symndx] != (bfd_vma) -1);
f21f3fe0 1632
252b5132 1633 off = local_got_offsets[r_symndx];
f21f3fe0 1634
252b5132
RH		 1635 /* The offset must always be a multiple of 4. We use the
1636 least significant bit to record whether we have already
9b485d32 1637 generated the necessary reloc. */
252b5132
RH		 1638 if ((off & 1) != 0)
1639 off &= ~1;
1640 else
1641 {
1642 bfd_put_32 (output_bfd, value, sgot->contents + off);
f21f3fe0 1643
252b5132
RH		 1644 if (info->shared)
1645 {
1646 asection * srelgot;
1647 Elf_Internal_Rel outrel;
f21f3fe0 1648
252b5132
RH		 1649 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
1650 BFD_ASSERT (srelgot != NULL);
f21f3fe0 1651
252b5132 1652 outrel.r_offset = (sgot->output_section->vma
f21f3fe0 1653 + sgot->output_offset
252b5132
RH		 1654 + off);
1655 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
1656 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1657 (((Elf32_External_Rel *)
1658 srelgot->contents)
1659 + srelgot->reloc_count));
1660 ++srelgot->reloc_count;
1661 }
f21f3fe0 1662
252b5132
RH		 1663 local_got_offsets[r_symndx] |= 1;
1664 }
f21f3fe0 1665
252b5132
RH		 1666 value = sgot->output_offset + off;
1667 }
9a5aca8c 1668
f21f3fe0 1669 return _bfd_final_link_relocate (howto, input_bfd, input_section,
99e4ae17
AJ		 1670 contents, rel->r_offset, value,
1671 (bfd_vma) 0);
f21f3fe0 1672
252b5132
RH		 1673 case R_ARM_PLT32:
1674 /* Relocation is to the entry for this symbol in the
1675 procedure linkage table. */
1676
1677 /* Resolve a PLT32 reloc against a local symbol directly,
9b485d32 1678 without using the procedure linkage table. */
252b5132
RH		 1679 if (h == NULL)
1680 return _bfd_final_link_relocate (howto, input_bfd, input_section,
99e4ae17
AJ		 1681 contents, rel->r_offset, value,
1682 (bfd_vma) 0);
252b5132
RH		 1683
1684 if (h->plt.offset == (bfd_vma) -1)
1685 /* We didn't make a PLT entry for this symbol. This
1686 happens when statically linking PIC code, or when
1687 using -Bsymbolic. */
1688 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1689 contents, rel->r_offset, value,
1690 (bfd_vma) 0);
1691
1692 BFD_ASSERT(splt != NULL);
1693 if (splt == NULL)
1694 return bfd_reloc_notsupported;
1695
1696 value = (splt->output_section->vma
1697 + splt->output_offset
1698 + h->plt.offset);
1699 return _bfd_final_link_relocate (howto, input_bfd, input_section,
99e4ae17
AJ		 1700 contents, rel->r_offset, value,
1701 (bfd_vma) 0);
f21f3fe0 1702
252b5132
RH		 1703 case R_ARM_SBREL32:
1704 return bfd_reloc_notsupported;
1705
1706 case R_ARM_AMP_VCALL9:
1707 return bfd_reloc_notsupported;
1708
1709 case R_ARM_RSBREL32:
1710 return bfd_reloc_notsupported;
1711
1712 case R_ARM_THM_RPC22:
1713 return bfd_reloc_notsupported;
1714
1715 case R_ARM_RREL32:
1716 return bfd_reloc_notsupported;
1717
1718 case R_ARM_RABS32:
1719 return bfd_reloc_notsupported;
1720
1721 case R_ARM_RPC24:
1722 return bfd_reloc_notsupported;
1723
1724 case R_ARM_RBASE:
1725 return bfd_reloc_notsupported;
1726
1727 default:
1728 return bfd_reloc_notsupported;
1729 }
1730}
1731
98c1d4aa
NC		 1732#ifdef USE_REL
1733/* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
1734static void
1735arm_add_to_rel (abfd, address, howto, increment)
1736 bfd * abfd;
59f2c4e7 1737 bfd_byte * address;
98c1d4aa
NC		 1738 reloc_howto_type * howto;
1739 bfd_signed_vma increment;
1740{
98c1d4aa
NC		 1741 bfd_signed_vma addend;
1742
9a5aca8c 1743 if (howto->type == R_ARM_THM_PC22)
98c1d4aa 1744 {
9a5aca8c
AM		 1745 int upper_insn, lower_insn;
1746 int upper, lower;
98c1d4aa 1747
9a5aca8c
AM		 1748 upper_insn = bfd_get_16 (abfd, address);
1749 lower_insn = bfd_get_16 (abfd, address + 2);
1750 upper = upper_insn & 0x7ff;
1751 lower = lower_insn & 0x7ff;
1752
1753 addend = (upper << 12) | (lower << 1);
ddda4409 1754 addend += increment;
9a5aca8c 1755 addend >>= 1;
98c1d4aa 1756
9a5aca8c
AM		 1757 upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
1758 lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
1759
dc810e39
AM		 1760 bfd_put_16 (abfd, (bfd_vma) upper_insn, address);
1761 bfd_put_16 (abfd, (bfd_vma) lower_insn, address + 2);
9a5aca8c
AM		 1762 }
1763 else
1764 {
1765 bfd_vma contents;
1766
1767 contents = bfd_get_32 (abfd, address);
1768
1769 /* Get the (signed) value from the instruction. */
1770 addend = contents & howto->src_mask;
1771 if (addend & ((howto->src_mask + 1) >> 1))
1772 {
1773 bfd_signed_vma mask;
1774
1775 mask = -1;
1776 mask &= ~ howto->src_mask;
1777 addend |= mask;
1778 }
1779
1780 /* Add in the increment, (which is a byte value). */
1781 switch (howto->type)
1782 {
1783 default:
1784 addend += increment;
1785 break;
1786
1787 case R_ARM_PC24:
1788 addend <<= howto->size;
dc810e39 1789 addend += increment;
9a5aca8c
AM		 1790
1791 /* Should we check for overflow here ? */
1792
1793 /* Drop any undesired bits. */
1794 addend >>= howto->rightshift;
1795 break;
1796 }
1797
1798 contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
1799
1800 bfd_put_32 (abfd, contents, address);
ddda4409 1801 }
98c1d4aa
NC		 1802}
1803#endif /* USE_REL */
252b5132
RH		 1804
1805/* Relocate an ARM ELF section. */
1806static boolean
1807elf32_arm_relocate_section (output_bfd, info, input_bfd, input_section,
1808 contents, relocs, local_syms, local_sections)
1809 bfd * output_bfd;
1810 struct bfd_link_info * info;
1811 bfd * input_bfd;
1812 asection * input_section;
1813 bfd_byte * contents;
1814 Elf_Internal_Rela * relocs;
1815 Elf_Internal_Sym * local_syms;
1816 asection ** local_sections;
1817{
1818 Elf_Internal_Shdr * symtab_hdr;
1819 struct elf_link_hash_entry ** sym_hashes;
1820 Elf_Internal_Rela * rel;
1821 Elf_Internal_Rela * relend;
1822 const char * name;
1823
1824 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1825 sym_hashes = elf_sym_hashes (input_bfd);
1826
1827 rel = relocs;
1828 relend = relocs + input_section->reloc_count;
1829 for (; rel < relend; rel++)
1830 {
ba96a88f
NC		 1831 int r_type;
1832 reloc_howto_type * howto;
1833 unsigned long r_symndx;
1834 Elf_Internal_Sym * sym;
1835 asection * sec;
252b5132 1836 struct elf_link_hash_entry * h;
ba96a88f
NC		 1837 bfd_vma relocation;
1838 bfd_reloc_status_type r;
1839 arelent bfd_reloc;
f21f3fe0 1840
252b5132 1841 r_symndx = ELF32_R_SYM (rel->r_info);
ba96a88f 1842 r_type = ELF32_R_TYPE (rel->r_info);
252b5132 1843
ba96a88f
NC		 1844 if ( r_type == R_ARM_GNU_VTENTRY
1845 || r_type == R_ARM_GNU_VTINHERIT)
252b5132
RH		 1846 continue;
1847
dc810e39
AM		 1848#ifdef USE_REL
1849 elf32_arm_info_to_howto (input_bfd, & bfd_reloc,
1850 (Elf_Internal_Rel *) rel);
1851#else
1852 elf32_arm_info_to_howto (input_bfd, & bfd_reloc, rel);
1853#endif
ba96a88f 1854 howto = bfd_reloc.howto;
252b5132
RH		 1855
1856 if (info->relocateable)
1857 {
1858 /* This is a relocateable link. We don't have to change
1859 anything, unless the reloc is against a section symbol,
1860 in which case we have to adjust according to where the
1861 section symbol winds up in the output section. */
1862 if (r_symndx < symtab_hdr->sh_info)
1863 {
1864 sym = local_syms + r_symndx;
1865 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1866 {
1867 sec = local_sections[r_symndx];
1868#ifdef USE_REL
98c1d4aa 1869 arm_add_to_rel (input_bfd, contents + rel->r_offset,
dc810e39
AM		 1870 howto,
1871 (bfd_signed_vma) (sec->output_offset
1872 + sym->st_value));
252b5132 1873#else
5fb1c3f2 1874 rel->r_addend += (sec->output_offset + sym->st_value);
252b5132
RH		 1875#endif
1876 }
1877 }
1878
1879 continue;
1880 }
1881
1882 /* This is a final link. */
1883 h = NULL;
1884 sym = NULL;
1885 sec = NULL;
9b485d32 1886
252b5132
RH		 1887 if (r_symndx < symtab_hdr->sh_info)
1888 {
1889 sym = local_syms + r_symndx;
1890 sec = local_sections[r_symndx];
f8df10f4 1891#ifdef USE_REL
252b5132
RH		 1892 relocation = (sec->output_section->vma
1893 + sec->output_offset
1894 + sym->st_value);
f8df10f4
JJ		 1895 if ((sec->flags & SEC_MERGE)
1896 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1897 {
1898 asection *msec;
1899 bfd_vma addend, value;
1900
1901 if (howto->rightshift)
1902 {
1903 (*_bfd_error_handler)
1904 (_("%s(%s+0x%lx): %s relocation against SEC_MERGE section"),
1905 bfd_archive_filename (input_bfd),
1906 bfd_get_section_name (input_bfd, input_section),
1907 (long) rel->r_offset, howto->name);
1908 return false;
1909 }
1910
1911 value = bfd_get_32 (input_bfd, contents + rel->r_offset);
1912
1913 /* Get the (signed) value from the instruction. */
1914 addend = value & howto->src_mask;
1915 if (addend & ((howto->src_mask + 1) >> 1))
1916 {
1917 bfd_signed_vma mask;
1918
1919 mask = -1;
1920 mask &= ~ howto->src_mask;
1921 addend |= mask;
1922 }
1923 msec = sec;
1924 addend =
c629eae0 1925 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
f8df10f4
JJ		 1926 - relocation;
1927 addend += msec->output_section->vma + msec->output_offset;
1928 value = (value & ~ howto->dst_mask) | (addend & howto->dst_mask);
1929 bfd_put_32 (input_bfd, value, contents + rel->r_offset);
1930 }
1931#else
1932 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1933#endif
252b5132
RH		 1934 }
1935 else
1936 {
1937 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
9b485d32
NC		 1938
1939 while ( h->root.type == bfd_link_hash_indirect
252b5132
RH		 1940 || h->root.type == bfd_link_hash_warning)
1941 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9b485d32
NC		 1942
1943 if ( h->root.type == bfd_link_hash_defined
252b5132
RH		 1944 || h->root.type == bfd_link_hash_defweak)
1945 {
780a67af 1946 int relocation_needed = 1;
f21f3fe0 1947
780a67af 1948 sec = h->root.u.def.section;
f21f3fe0 1949
252b5132 1950 /* In these cases, we don't need the relocation value.
f21f3fe0 1951 We check specially because in some obscure cases
9b485d32 1952 sec->output_section will be NULL. */
252b5132
RH		 1953 switch (r_type)
1954 {
1955 case R_ARM_PC24:
1956 case R_ARM_ABS32:
6a360bf4 1957 case R_ARM_THM_PC22:
252b5132
RH		 1958 if (info->shared
1959 && (
99e4ae17 1960 (!info->symbolic && h->dynindx != -1)
97eaf9de 1961 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
252b5132 1962 )
05924f36
PB		 1963 && ((input_section->flags & SEC_ALLOC) != 0
1964 /* DWARF will emit R_ARM_ABS32 relocations in its
1965 sections against symbols defined externally
1966 in shared libraries. We can't do anything
1967 with them here. */
1968 || ((input_section->flags & SEC_DEBUGGING) != 0
1969 && (h->elf_link_hash_flags
1970 & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
252b5132 1971 )
780a67af 1972 relocation_needed = 0;
252b5132 1973 break;
f21f3fe0 1974
252b5132 1975 case R_ARM_GOTPC:
780a67af 1976 relocation_needed = 0;
252b5132 1977 break;
f21f3fe0 1978
252b5132
RH		 1979 case R_ARM_GOT32:
1980 if (elf_hash_table(info)->dynamic_sections_created
1981 && (!info->shared
1982 || (!info->symbolic && h->dynindx != -1)
1983 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
1984 )
1985 )
780a67af 1986 relocation_needed = 0;
252b5132 1987 break;
f21f3fe0 1988
252b5132
RH		 1989 case R_ARM_PLT32:
1990 if (h->plt.offset != (bfd_vma)-1)
780a67af 1991 relocation_needed = 0;
252b5132 1992 break;
f21f3fe0 1993
252b5132
RH		 1994 default:
1995 if (sec->output_section == NULL)
1996 {
1997 (*_bfd_error_handler)
6a360bf4
NC		 1998 (_("%s: warning: unresolvable relocation %d against symbol `%s' from %s section"),
1999 bfd_archive_filename (input_bfd),
2000 r_type,
2001 h->root.root.string,
252b5132 2002 bfd_get_section_name (input_bfd, input_section));
780a67af 2003 relocation_needed = 0;
252b5132
RH		 2004 }
2005 }
780a67af
NC		 2006
2007 if (relocation_needed)
2008 relocation = h->root.u.def.value
2009 + sec->output_section->vma
2010 + sec->output_offset;
2011 else
2012 relocation = 0;
252b5132
RH		 2013 }
2014 else if (h->root.type == bfd_link_hash_undefweak)
2015 relocation = 0;
3a27a730
L		 2016 else if (info->shared && !info->symbolic
2017 && !info->no_undefined
2018 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
a72747a3 2019 relocation = 0;
252b5132
RH		 2020 else
2021 {
2022 if (!((*info->callbacks->undefined_symbol)
2023 (info, h->root.root.string, input_bfd,
5cc7c785 2024 input_section, rel->r_offset,
3a27a730
L		 2025 (!info->shared || info->no_undefined
2026 || ELF_ST_VISIBILITY (h->other)))))
252b5132
RH		 2027 return false;
2028 relocation = 0;
2029 }
2030 }
2031
2032 if (h != NULL)
2033 name = h->root.root.string;
2034 else
2035 {
2036 name = (bfd_elf_string_from_elf_section
2037 (input_bfd, symtab_hdr->sh_link, sym->st_name));
2038 if (name == NULL || *name == '\0')
2039 name = bfd_section_name (input_bfd, sec);
2040 }
f21f3fe0 2041
252b5132
RH		 2042 r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
2043 input_section, contents, rel,
2044 relocation, info, sec, name,
2045 (h ? ELF_ST_TYPE (h->type) :
780a67af 2046 ELF_ST_TYPE (sym->st_info)), h);
252b5132
RH		 2047
2048 if (r != bfd_reloc_ok)
2049 {
2050 const char * msg = (const char *) 0;
2051
2052 switch (r)
2053 {
2054 case bfd_reloc_overflow:
cf919dfd
PB		 2055 /* If the overflowing reloc was to an undefined symbol,
2056 we have already printed one error message and there
2057 is no point complaining again. */
2058 if ((! h ||
2059 h->root.type != bfd_link_hash_undefined)
2060 && (!((*info->callbacks->reloc_overflow)
2061 (info, name, howto->name, (bfd_vma) 0,
2062 input_bfd, input_section, rel->r_offset))))
2063 return false;
252b5132
RH		 2064 break;
2065
2066 case bfd_reloc_undefined:
2067 if (!((*info->callbacks->undefined_symbol)
2068 (info, name, input_bfd, input_section,
5cc7c785 2069 rel->r_offset, true)))
252b5132
RH		 2070 return false;
2071 break;
2072
2073 case bfd_reloc_outofrange:
9b485d32 2074 msg = _("internal error: out of range error");
252b5132
RH		 2075 goto common_error;
2076
2077 case bfd_reloc_notsupported:
9b485d32 2078 msg = _("internal error: unsupported relocation error");
252b5132
RH		 2079 goto common_error;
2080
2081 case bfd_reloc_dangerous:
9b485d32 2082 msg = _("internal error: dangerous error");
252b5132
RH		 2083 goto common_error;
2084
2085 default:
9b485d32 2086 msg = _("internal error: unknown error");
252b5132
RH		 2087 /* fall through */
2088
2089 common_error:
2090 if (!((*info->callbacks->warning)
2091 (info, msg, name, input_bfd, input_section,
2092 rel->r_offset)))
2093 return false;
2094 break;
2095 }
2096 }
2097 }
2098
2099 return true;
2100}
2101
fc830a83 2102/* Function to keep ARM specific flags in the ELF header. */
252b5132
RH		 2103static boolean
2104elf32_arm_set_private_flags (abfd, flags)
2105 bfd *abfd;
2106 flagword flags;
2107{
2108 if (elf_flags_init (abfd)
2109 && elf_elfheader (abfd)->e_flags != flags)
2110 {
fc830a83
NC		 2111 if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
2112 {
fd2ec330 2113 if (flags & EF_ARM_INTERWORK)
8f615d07 2114 (*_bfd_error_handler) (_("\
ae1a89b7 2115Warning: Not setting interworking flag of %s since it has already been specified as non-interworking"),
8f615d07 2116 bfd_archive_filename (abfd));
fc830a83 2117 else
63b0f745 2118 _bfd_error_handler (_("\
ae1a89b7 2119Warning: Clearing the interworking flag of %s due to outside request"),
63b0f745 2120 bfd_archive_filename (abfd));
fc830a83 2121 }
252b5132
RH		 2122 }
2123 else
2124 {
2125 elf_elfheader (abfd)->e_flags = flags;
2126 elf_flags_init (abfd) = true;
2127 }
2128
2129 return true;
2130}
2131
fc830a83 2132/* Copy backend specific data from one object module to another. */
9b485d32 2133
252b5132
RH		 2134static boolean
2135elf32_arm_copy_private_bfd_data (ibfd, obfd)
2136 bfd *ibfd;
2137 bfd *obfd;
2138{
2139 flagword in_flags;
2140 flagword out_flags;
2141
fc830a83 2142 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
252b5132
RH		 2143 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2144 return true;
2145
fc830a83 2146 in_flags = elf_elfheader (ibfd)->e_flags;
252b5132
RH		 2147 out_flags = elf_elfheader (obfd)->e_flags;
2148
fc830a83
NC		 2149 if (elf_flags_init (obfd)
2150 && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
2151 && in_flags != out_flags)
252b5132 2152 {
252b5132 2153 /* Cannot mix APCS26 and APCS32 code. */
fd2ec330 2154 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
252b5132
RH		 2155 return false;
2156
2157 /* Cannot mix float APCS and non-float APCS code. */
fd2ec330 2158 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
252b5132
RH		 2159 return false;
2160
2161 /* If the src and dest have different interworking flags
2162 then turn off the interworking bit. */
fd2ec330 2163 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
252b5132 2164 {
fd2ec330 2165 if (out_flags & EF_ARM_INTERWORK)
63b0f745 2166 _bfd_error_handler (_("\
ae1a89b7 2167Warning: Clearing the interworking flag of %s because non-interworking code in %s has been linked with it"),
06317a27 2168 bfd_get_filename (obfd),
63b0f745 2169 bfd_archive_filename (ibfd));
252b5132 2170
fd2ec330 2171 in_flags &= ~EF_ARM_INTERWORK;
252b5132 2172 }
1006ba19
PB		 2173
2174 /* Likewise for PIC, though don't warn for this case. */
fd2ec330
PB		 2175 if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC))
2176 in_flags &= ~EF_ARM_PIC;
252b5132
RH		 2177 }
2178
2179 elf_elfheader (obfd)->e_flags = in_flags;
2180 elf_flags_init (obfd) = true;
2181
2182 return true;
2183}
2184
2185/* Merge backend specific data from an object file to the output
2186 object file when linking. */
9b485d32 2187
252b5132
RH		 2188static boolean
2189elf32_arm_merge_private_bfd_data (ibfd, obfd)
fc830a83
NC		 2190 bfd * ibfd;
2191 bfd * obfd;
252b5132
RH		 2192{
2193 flagword out_flags;
2194 flagword in_flags;
1006ba19 2195 boolean flags_compatible = true;
cf919dfd
PB		 2196 boolean null_input_bfd = true;
2197 asection *sec;
252b5132 2198
9b485d32 2199 /* Check if we have the same endianess. */
1fe494a5
NC		 2200 if (_bfd_generic_verify_endian_match (ibfd, obfd) == false)
2201 return false;
2202
252b5132
RH		 2203 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2204 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2205 return true;
2206
252b5132
RH		 2207 /* The input BFD must have had its flags initialised. */
2208 /* The following seems bogus to me -- The flags are initialized in
2209 the assembler but I don't think an elf_flags_init field is
9b485d32 2210 written into the object. */
252b5132
RH		 2211 /* BFD_ASSERT (elf_flags_init (ibfd)); */
2212
2213 in_flags = elf_elfheader (ibfd)->e_flags;
2214 out_flags = elf_elfheader (obfd)->e_flags;
2215
2216 if (!elf_flags_init (obfd))
2217 {
fe077fa6
NC		 2218 /* If the input is the default architecture and had the default
2219 flags then do not bother setting the flags for the output
2220 architecture, instead allow future merges to do this. If no
2221 future merges ever set these flags then they will retain their
2222 uninitialised values, which surprise surprise, correspond
252b5132 2223 to the default values. */
fe077fa6
NC		 2224 if (bfd_get_arch_info (ibfd)->the_default
2225 && elf_elfheader (ibfd)->e_flags == 0)
252b5132
RH		 2226 return true;
2227
2228 elf_flags_init (obfd) = true;
2229 elf_elfheader (obfd)->e_flags = in_flags;
2230
2231 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2232 && bfd_get_arch_info (obfd)->the_default)
2233 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
2234
2235 return true;
2236 }
2237
1006ba19 2238 /* Identical flags must be compatible. */
252b5132
RH		 2239 if (in_flags == out_flags)
2240 return true;
2241
cf919dfd
PB		 2242 /* Check to see if the input BFD actually contains any sections.
2243 If not, its flags may not have been initialised either, but it cannot
2244 actually cause any incompatibility. */
2245 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
2246 {
2247 /* Ignore synthetic glue sections. */
2248 if (strcmp (sec->name, ".glue_7")
2249 && strcmp (sec->name, ".glue_7t"))
2250 {
2251 null_input_bfd = false;
2252 break;
2253 }
2254 }
2255 if (null_input_bfd)
2256 return true;
2257
252b5132 2258 /* Complain about various flag mismatches. */
fc830a83
NC		 2259 if (EF_ARM_EABI_VERSION (in_flags) != EF_ARM_EABI_VERSION (out_flags))
2260 {
63b0f745 2261 _bfd_error_handler (_("\
6c571f00 2262ERROR: %s is compiled for EABI version %d, whereas %s is compiled for version %d"),
63b0f745
NC		 2263 bfd_archive_filename (ibfd),
2264 (in_flags & EF_ARM_EABIMASK) >> 24,
06317a27 2265 bfd_get_filename (obfd),
63b0f745 2266 (out_flags & EF_ARM_EABIMASK) >> 24);
1006ba19 2267 return false;
fc830a83 2268 }
252b5132 2269
1006ba19
PB		 2270 /* Not sure what needs to be checked for EABI versions >= 1. */
2271 if (EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
2272 {
fd2ec330 2273 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
1006ba19 2274 {
63b0f745 2275 _bfd_error_handler (_("\
6c571f00 2276ERROR: %s is compiled for APCS-%d, whereas target %s uses APCS-%d"),
63b0f745
NC		 2277 bfd_archive_filename (ibfd),
2278 in_flags & EF_ARM_APCS_26 ? 26 : 32,
06317a27 2279 bfd_get_filename (obfd),
63b0f745 2280 out_flags & EF_ARM_APCS_26 ? 26 : 32);
1006ba19
PB		 2281 flags_compatible = false;
2282 }
252b5132 2283
fd2ec330 2284 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
1006ba19 2285 {
5eefb65f
NC		 2286 if (in_flags & EF_ARM_APCS_FLOAT)
2287 _bfd_error_handler (_("\
6c571f00 2288ERROR: %s passes floats in float registers, whereas %s passes them in integer registers"),
5eefb65f
NC		 2289 bfd_archive_filename (ibfd),
2290 bfd_get_filename (obfd));
2291 else
2292 _bfd_error_handler (_("\
6c571f00 2293ERROR: %s passes floats in integer registers, whereas %s passes them in float registers"),
5eefb65f
NC		 2294 bfd_archive_filename (ibfd),
2295 bfd_get_filename (obfd));
63b0f745 2296
1006ba19
PB		 2297 flags_compatible = false;
2298 }
252b5132 2299
96a846ea 2300 if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT))
1006ba19 2301 {
96a846ea
RE		 2302 if (in_flags & EF_ARM_VFP_FLOAT)
2303 _bfd_error_handler (_("\
6c571f00 2304ERROR: %s uses VFP instructions, whereas %s uses FPA instructions"),
5eefb65f
NC		 2305 bfd_archive_filename (ibfd),
2306 bfd_get_filename (obfd));
2307 else
96a846ea 2308 _bfd_error_handler (_("\
6c571f00 2309ERROR: %s uses FPA instructions, whereas %s uses VFP instructions"),
5eefb65f
NC		 2310 bfd_archive_filename (ibfd),
2311 bfd_get_filename (obfd));
63b0f745 2312
1006ba19
PB		 2313 flags_compatible = false;
2314 }
96a846ea
RE		 2315
2316#ifdef EF_ARM_SOFT_FLOAT
2317 if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
2318 {
2319 /* We can allow interworking between code that is VFP format
2320 layout, and uses either soft float or integer regs for
2321 passing floating point arguments and results. We already
2322 know that the APCS_FLOAT flags match; similarly for VFP
2323 flags. */
2324 if ((in_flags & EF_ARM_APCS_FLOAT) != 0
2325 || (in_flags & EF_ARM_VFP_FLOAT) == 0)
2326 {
2327 if (in_flags & EF_ARM_SOFT_FLOAT)
517662d4 2328 _bfd_error_handler (_("\
6c571f00 2329ERROR: %s uses software FP, whereas %s uses hardware FP"),
96a846ea
RE		 2330 bfd_archive_filename (ibfd),
2331 bfd_get_filename (obfd));
2332 else
517662d4 2333 _bfd_error_handler (_("\
6c571f00 2334ERROR: %s uses hardware FP, whereas %s uses software FP"),
96a846ea
RE		 2335 bfd_archive_filename (ibfd),
2336 bfd_get_filename (obfd));
2337
2338 flags_compatible = false;
2339 }
2340 }
ee43f35e 2341#endif
252b5132 2342
1006ba19 2343 /* Interworking mismatch is only a warning. */
fd2ec330 2344 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
8f615d07 2345 {
e3c8793a
NC		 2346 if (in_flags & EF_ARM_INTERWORK)
2347 {
2348 _bfd_error_handler (_("\
2349Warning: %s supports interworking, whereas %s does not"),
2350 bfd_archive_filename (ibfd),
2351 bfd_get_filename (obfd));
2352 }
2353 else
2354 {
2355 _bfd_error_handler (_("\
2356Warning: %s does not support interworking, whereas %s does"),
2357 bfd_archive_filename (ibfd),
2358 bfd_get_filename (obfd));
2359 }
8f615d07 2360 }
252b5132 2361 }
63b0f745 2362
1006ba19 2363 return flags_compatible;
252b5132
RH		 2364}
2365
9b485d32
NC		 2366/* Display the flags field. */
2367
252b5132
RH		 2368static boolean
2369elf32_arm_print_private_bfd_data (abfd, ptr)
2370 bfd *abfd;
2371 PTR ptr;
2372{
fc830a83
NC		 2373 FILE * file = (FILE *) ptr;
2374 unsigned long flags;
252b5132
RH		 2375
2376 BFD_ASSERT (abfd != NULL && ptr != NULL);
2377
2378 /* Print normal ELF private data. */
2379 _bfd_elf_print_private_bfd_data (abfd, ptr);
2380
fc830a83 2381 flags = elf_elfheader (abfd)->e_flags;
9b485d32
NC		 2382 /* Ignore init flag - it may not be set, despite the flags field
2383 containing valid data. */
252b5132
RH		 2384
2385 /* xgettext:c-format */
9b485d32 2386 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
252b5132 2387
fc830a83
NC		 2388 switch (EF_ARM_EABI_VERSION (flags))
2389 {
2390 case EF_ARM_EABI_UNKNOWN:
2391 /* The following flag bits are GNU extenstions and not part of the
2392 official ARM ELF extended ABI. Hence they are only decoded if
2393 the EABI version is not set. */
fd2ec330 2394 if (flags & EF_ARM_INTERWORK)
9b485d32 2395 fprintf (file, _(" [interworking enabled]"));
9a5aca8c 2396
fd2ec330 2397 if (flags & EF_ARM_APCS_26)
6c571f00 2398 fprintf (file, " [APCS-26]");
fc830a83 2399 else
6c571f00 2400 fprintf (file, " [APCS-32]");
9a5aca8c 2401
96a846ea
RE		 2402 if (flags & EF_ARM_VFP_FLOAT)
2403 fprintf (file, _(" [VFP float format]"));
2404 else
2405 fprintf (file, _(" [FPA float format]"));
2406
fd2ec330 2407 if (flags & EF_ARM_APCS_FLOAT)
9b485d32 2408 fprintf (file, _(" [floats passed in float registers]"));
9a5aca8c 2409
fd2ec330 2410 if (flags & EF_ARM_PIC)
9b485d32 2411 fprintf (file, _(" [position independent]"));
fc830a83 2412
fd2ec330 2413 if (flags & EF_ARM_NEW_ABI)
9b485d32 2414 fprintf (file, _(" [new ABI]"));
9a5aca8c 2415
fd2ec330 2416 if (flags & EF_ARM_OLD_ABI)
9b485d32 2417 fprintf (file, _(" [old ABI]"));
9a5aca8c 2418
fd2ec330 2419 if (flags & EF_ARM_SOFT_FLOAT)
9b485d32 2420 fprintf (file, _(" [software FP]"));
9a5aca8c 2421
96a846ea
RE		 2422 flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT
2423 | EF_ARM_PIC | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI
2424 | EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT);
fc830a83 2425 break;
9a5aca8c 2426
fc830a83 2427 case EF_ARM_EABI_VER1:
9b485d32 2428 fprintf (file, _(" [Version1 EABI]"));
9a5aca8c 2429
fc830a83 2430 if (flags & EF_ARM_SYMSARESORTED)
9b485d32 2431 fprintf (file, _(" [sorted symbol table]"));
fc830a83 2432 else
9b485d32 2433 fprintf (file, _(" [unsorted symbol table]"));
9a5aca8c 2434
fc830a83
NC		 2435 flags &= ~ EF_ARM_SYMSARESORTED;
2436 break;
9a5aca8c 2437
fd2ec330
PB		 2438 case EF_ARM_EABI_VER2:
2439 fprintf (file, _(" [Version2 EABI]"));
2440
2441 if (flags & EF_ARM_SYMSARESORTED)
2442 fprintf (file, _(" [sorted symbol table]"));
2443 else
2444 fprintf (file, _(" [unsorted symbol table]"));
2445
2446 if (flags & EF_ARM_DYNSYMSUSESEGIDX)
2447 fprintf (file, _(" [dynamic symbols use segment index]"));
2448
2449 if (flags & EF_ARM_MAPSYMSFIRST)
2450 fprintf (file, _(" [mapping symbols precede others]"));
2451
99e4ae17 2452 flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX
fd2ec330
PB		 2453 | EF_ARM_MAPSYMSFIRST);
2454 break;
2455
fc830a83 2456 default:
9b485d32 2457 fprintf (file, _(" <EABI version unrecognised>"));
fc830a83
NC		 2458 break;
2459 }
252b5132 2460
fc830a83 2461 flags &= ~ EF_ARM_EABIMASK;
252b5132 2462
fc830a83 2463 if (flags & EF_ARM_RELEXEC)
9b485d32 2464 fprintf (file, _(" [relocatable executable]"));
252b5132 2465
fc830a83 2466 if (flags & EF_ARM_HASENTRY)
9b485d32 2467 fprintf (file, _(" [has entry point]"));
252b5132 2468
fc830a83
NC		 2469 flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
2470
2471 if (flags)
9b485d32 2472 fprintf (file, _("<Unrecognised flag bits set>"));
9a5aca8c 2473
252b5132
RH		 2474 fputc ('\n', file);
2475
2476 return true;
2477}
2478
2479static int
2480elf32_arm_get_symbol_type (elf_sym, type)
2481 Elf_Internal_Sym * elf_sym;
2482 int type;
2483{
2f0ca46a
NC		 2484 switch (ELF_ST_TYPE (elf_sym->st_info))
2485 {
2486 case STT_ARM_TFUNC:
2487 return ELF_ST_TYPE (elf_sym->st_info);
ce855c42 2488
2f0ca46a
NC		 2489 case STT_ARM_16BIT:
2490 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2491 This allows us to distinguish between data used by Thumb instructions
2492 and non-data (which is probably code) inside Thumb regions of an
2493 executable. */
2494 if (type != STT_OBJECT)
2495 return ELF_ST_TYPE (elf_sym->st_info);
2496 break;
9a5aca8c 2497
ce855c42
NC		 2498 default:
2499 break;
2f0ca46a
NC		 2500 }
2501
2502 return type;
252b5132 2503}
f21f3fe0 2504
252b5132
RH		 2505static asection *
2506elf32_arm_gc_mark_hook (abfd, info, rel, h, sym)
2507 bfd *abfd;
5f771d47 2508 struct bfd_link_info *info ATTRIBUTE_UNUSED;
252b5132
RH		 2509 Elf_Internal_Rela *rel;
2510 struct elf_link_hash_entry *h;
2511 Elf_Internal_Sym *sym;
2512{
2513 if (h != NULL)
2514 {
2515 switch (ELF32_R_TYPE (rel->r_info))
2516 {
2517 case R_ARM_GNU_VTINHERIT:
2518 case R_ARM_GNU_VTENTRY:
2519 break;
2520
2521 default:
2522 switch (h->root.type)
2523 {
2524 case bfd_link_hash_defined:
2525 case bfd_link_hash_defweak:
2526 return h->root.u.def.section;
2527
2528 case bfd_link_hash_common:
2529 return h->root.u.c.p->section;
e049a0de
ILT		 2530
2531 default:
2532 break;
252b5132
RH		 2533 }
2534 }
2535 }
2536 else
2537 {
9ad5cbcf
AM		 2538 return bfd_section_from_elf_index (abfd, sym->st_shndx);
2539 }
2540
252b5132
RH		 2541 return NULL;
2542}
2543
780a67af
NC		 2544/* Update the got entry reference counts for the section being removed. */
2545
252b5132
RH		 2546static boolean
2547elf32_arm_gc_sweep_hook (abfd, info, sec, relocs)
5f771d47
ILT		 2548 bfd *abfd ATTRIBUTE_UNUSED;
2549 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2550 asection *sec ATTRIBUTE_UNUSED;
2551 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
252b5132 2552{
780a67af 2553 /* We don't support garbage collection of GOT and PLT relocs yet. */
252b5132
RH		 2554 return true;
2555}
2556
780a67af
NC		 2557/* Look through the relocs for a section during the first phase. */
2558
252b5132
RH		 2559static boolean
2560elf32_arm_check_relocs (abfd, info, sec, relocs)
2561 bfd * abfd;
2562 struct bfd_link_info * info;
2563 asection * sec;
2564 const Elf_Internal_Rela * relocs;
2565{
2566 Elf_Internal_Shdr * symtab_hdr;
2567 struct elf_link_hash_entry ** sym_hashes;
2568 struct elf_link_hash_entry ** sym_hashes_end;
2569 const Elf_Internal_Rela * rel;
2570 const Elf_Internal_Rela * rel_end;
2571 bfd * dynobj;
2572 asection * sgot, *srelgot, *sreloc;
2573 bfd_vma * local_got_offsets;
9a5aca8c 2574
252b5132
RH		 2575 if (info->relocateable)
2576 return true;
9a5aca8c 2577
252b5132 2578 sgot = srelgot = sreloc = NULL;
9a5aca8c 2579
252b5132
RH		 2580 dynobj = elf_hash_table (info)->dynobj;
2581 local_got_offsets = elf_local_got_offsets (abfd);
f21f3fe0 2582
252b5132
RH		 2583 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2584 sym_hashes = elf_sym_hashes (abfd);
9b485d32
NC		 2585 sym_hashes_end = sym_hashes
2586 + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
2587
252b5132
RH		 2588 if (!elf_bad_symtab (abfd))
2589 sym_hashes_end -= symtab_hdr->sh_info;
9b485d32 2590
252b5132
RH		 2591 rel_end = relocs + sec->reloc_count;
2592 for (rel = relocs; rel < rel_end; rel++)
2593 {
2594 struct elf_link_hash_entry *h;
2595 unsigned long r_symndx;
9a5aca8c 2596
252b5132
RH		 2597 r_symndx = ELF32_R_SYM (rel->r_info);
2598 if (r_symndx < symtab_hdr->sh_info)
2599 h = NULL;
2600 else
2601 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
9a5aca8c 2602
252b5132
RH		 2603 /* Some relocs require a global offset table. */
2604 if (dynobj == NULL)
2605 {
2606 switch (ELF32_R_TYPE (rel->r_info))
2607 {
2608 case R_ARM_GOT32:
2609 case R_ARM_GOTOFF:
2610 case R_ARM_GOTPC:
2611 elf_hash_table (info)->dynobj = dynobj = abfd;
2612 if (! _bfd_elf_create_got_section (dynobj, info))
2613 return false;
2614 break;
2615
2616 default:
2617 break;
2618 }
2619 }
2620
2621 switch (ELF32_R_TYPE (rel->r_info))
2622 {
2623 case R_ARM_GOT32:
2624 /* This symbol requires a global offset table entry. */
2625 if (sgot == NULL)
2626 {
2627 sgot = bfd_get_section_by_name (dynobj, ".got");
2628 BFD_ASSERT (sgot != NULL);
2629 }
2630
2631 /* Get the got relocation section if necessary. */
2632 if (srelgot == NULL
2633 && (h != NULL || info->shared))
2634 {
2635 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
9a5aca8c 2636
252b5132
RH		 2637 /* If no got relocation section, make one and initialize. */
2638 if (srelgot == NULL)
2639 {
2640 srelgot = bfd_make_section (dynobj, ".rel.got");
2641 if (srelgot == NULL
2642 || ! bfd_set_section_flags (dynobj, srelgot,
99e4ae17 2643 (SEC_ALLOC
252b5132
RH		 2644 | SEC_LOAD
2645 | SEC_HAS_CONTENTS
2646 | SEC_IN_MEMORY
2647 | SEC_LINKER_CREATED
2648 | SEC_READONLY))
2649 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
2650 return false;
2651 }
2652 }
2653
2654 if (h != NULL)
2655 {
2656 if (h->got.offset != (bfd_vma) -1)
2657 /* We have already allocated space in the .got. */
2658 break;
f21f3fe0 2659
252b5132
RH		 2660 h->got.offset = sgot->_raw_size;
2661
2662 /* Make sure this symbol is output as a dynamic symbol. */
2663 if (h->dynindx == -1)
2664 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2665 return false;
2666
2667 srelgot->_raw_size += sizeof (Elf32_External_Rel);
2668 }
2669 else
2670 {
99e4ae17 2671 /* This is a global offset table entry for a local
252b5132
RH		 2672 symbol. */
2673 if (local_got_offsets == NULL)
2674 {
dc810e39 2675 bfd_size_type size;
63b0f745 2676 unsigned int i;
252b5132 2677
dc810e39
AM		 2678 size = symtab_hdr->sh_info;
2679 size *= sizeof (bfd_vma);
252b5132
RH		 2680 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
2681 if (local_got_offsets == NULL)
2682 return false;
2683 elf_local_got_offsets (abfd) = local_got_offsets;
2684 for (i = 0; i < symtab_hdr->sh_info; i++)
2685 local_got_offsets[i] = (bfd_vma) -1;
2686 }
f21f3fe0 2687
252b5132
RH		 2688 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
2689 /* We have already allocated space in the .got. */
2690 break;
2691
2692 local_got_offsets[r_symndx] = sgot->_raw_size;
2693
2694 if (info->shared)
2695 /* If we are generating a shared object, we need to
2696 output a R_ARM_RELATIVE reloc so that the dynamic
2697 linker can adjust this GOT entry. */
2698 srelgot->_raw_size += sizeof (Elf32_External_Rel);
2699 }
2700
2701 sgot->_raw_size += 4;
2702 break;
2703
99e4ae17 2704 case R_ARM_PLT32:
252b5132
RH		 2705 /* This symbol requires a procedure linkage table entry. We
2706 actually build the entry in adjust_dynamic_symbol,
2707 because this might be a case of linking PIC code which is
2708 never referenced by a dynamic object, in which case we
2709 don't need to generate a procedure linkage table entry
2710 after all. */
2711
2712 /* If this is a local symbol, we resolve it directly without
2713 creating a procedure linkage table entry. */
2714 if (h == NULL)
2715 continue;
2716
2717 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2718 break;
2719
2720 case R_ARM_ABS32:
2721 case R_ARM_REL32:
2722 case R_ARM_PC24:
2723 /* If we are creating a shared library, and this is a reloc
2724 against a global symbol, or a non PC relative reloc
2725 against a local symbol, then we need to copy the reloc
2726 into the shared library. However, if we are linking with
2727 -Bsymbolic, we do not need to copy a reloc against a
2728 global symbol which is defined in an object we are
2729 including in the link (i.e., DEF_REGULAR is set). At
2730 this point we have not seen all the input files, so it is
2731 possible that DEF_REGULAR is not set now but will be set
2732 later (it is never cleared). We account for that
2733 possibility below by storing information in the
2734 pcrel_relocs_copied field of the hash table entry. */
2735 if (info->shared
2736 && (ELF32_R_TYPE (rel->r_info) != R_ARM_PC24
2737 || (h != NULL
2738 && (! info->symbolic
2739 || (h->elf_link_hash_flags
2740 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2741 {
2742 /* When creating a shared object, we must copy these
2743 reloc types into the output file. We create a reloc
2744 section in dynobj and make room for this reloc. */
2745 if (sreloc == NULL)
2746 {
2747 const char * name;
2748
2749 name = (bfd_elf_string_from_elf_section
2750 (abfd,
2751 elf_elfheader (abfd)->e_shstrndx,
2752 elf_section_data (sec)->rel_hdr.sh_name));
2753 if (name == NULL)
2754 return false;
2755
2756 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
99e4ae17 2757 && strcmp (bfd_get_section_name (abfd, sec),
252b5132
RH		 2758 name + 4) == 0);
2759
2760 sreloc = bfd_get_section_by_name (dynobj, name);
2761 if (sreloc == NULL)
2762 {
2763 flagword flags;
2764
2765 sreloc = bfd_make_section (dynobj, name);
2766 flags = (SEC_HAS_CONTENTS | SEC_READONLY
2767 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2768 if ((sec->flags & SEC_ALLOC) != 0)
2769 flags |= SEC_ALLOC | SEC_LOAD;
2770 if (sreloc == NULL
2771 || ! bfd_set_section_flags (dynobj, sreloc, flags)
2772 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
2773 return false;
2774 }
99e4ae17
AJ		 2775 if (sec->flags & SEC_READONLY)
2776 info->flags |= DF_TEXTREL;
252b5132
RH		 2777 }
2778
2779 sreloc->_raw_size += sizeof (Elf32_External_Rel);
2780 /* If we are linking with -Bsymbolic, and this is a
2781 global symbol, we count the number of PC relative
2782 relocations we have entered for this symbol, so that
2783 we can discard them again if the symbol is later
2784 defined by a regular object. Note that this function
2785 is only called if we are using an elf_i386 linker
2786 hash table, which means that h is really a pointer to
2787 an elf_i386_link_hash_entry. */
2788 if (h != NULL && info->symbolic
2789 && ELF32_R_TYPE (rel->r_info) == R_ARM_PC24)
2790 {
2791 struct elf32_arm_link_hash_entry * eh;
2792 struct elf32_arm_pcrel_relocs_copied * p;
2793
2794 eh = (struct elf32_arm_link_hash_entry *) h;
2795
2796 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
2797 if (p->section == sreloc)
2798 break;
2799
2800 if (p == NULL)
2801 {
2802 p = ((struct elf32_arm_pcrel_relocs_copied *)
dc810e39 2803 bfd_alloc (dynobj, (bfd_size_type) sizeof * p));
252b5132
RH		 2804 if (p == NULL)
2805 return false;
2806 p->next = eh->pcrel_relocs_copied;
2807 eh->pcrel_relocs_copied = p;
2808 p->section = sreloc;
2809 p->count = 0;
2810 }
2811
2812 ++p->count;
2813 }
2814 }
2815 break;
2816
2817 /* This relocation describes the C++ object vtable hierarchy.
2818 Reconstruct it for later use during GC. */
2819 case R_ARM_GNU_VTINHERIT:
2820 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2821 return false;
2822 break;
9a5aca8c 2823
252b5132
RH		 2824 /* This relocation describes which C++ vtable entries are actually
2825 used. Record for later use during GC. */
2826 case R_ARM_GNU_VTENTRY:
d512aa07 2827 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
252b5132
RH		 2828 return false;
2829 break;
2830 }
2831 }
f21f3fe0 2832
252b5132
RH		 2833 return true;
2834}
2835
252b5132
RH		 2836/* Find the nearest line to a particular section and offset, for error
2837 reporting. This code is a duplicate of the code in elf.c, except
9b485d32 2838 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
252b5132
RH		 2839
2840static boolean
2841elf32_arm_find_nearest_line
2842 (abfd, section, symbols, offset, filename_ptr, functionname_ptr, line_ptr)
2843 bfd * abfd;
2844 asection * section;
2845 asymbol ** symbols;
2846 bfd_vma offset;
917583ad
NC		 2847 const char ** filename_ptr;
2848 const char ** functionname_ptr;
252b5132
RH		 2849 unsigned int * line_ptr;
2850{
2851 boolean found;
2852 const char * filename;
2853 asymbol * func;
2854 bfd_vma low_func;
2855 asymbol ** p;
2856
2857 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
f21f3fe0 2858 filename_ptr, functionname_ptr,
857ec808
NC		 2859 line_ptr, 0,
2860 &elf_tdata (abfd)->dwarf2_find_line_info))
252b5132
RH		 2861 return true;
2862
2863 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
2864 &found, filename_ptr,
2865 functionname_ptr, line_ptr,
2866 &elf_tdata (abfd)->line_info))
2867 return false;
f21f3fe0 2868
252b5132
RH		 2869 if (found)
2870 return true;
2871
2872 if (symbols == NULL)
2873 return false;
2874
2875 filename = NULL;
2876 func = NULL;
2877 low_func = 0;
2878
2879 for (p = symbols; *p != NULL; p++)
2880 {
2881 elf_symbol_type *q;
2882
2883 q = (elf_symbol_type *) *p;
2884
2885 if (bfd_get_section (&q->symbol) != section)
2886 continue;
2887
2888 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
2889 {
2890 default:
2891 break;
2892 case STT_FILE:
2893 filename = bfd_asymbol_name (&q->symbol);
2894 break;
2895 case STT_NOTYPE:
2896 case STT_FUNC:
2897 case STT_ARM_TFUNC:
2898 if (q->symbol.section == section
2899 && q->symbol.value >= low_func
2900 && q->symbol.value <= offset)
2901 {
2902 func = (asymbol *) q;
2903 low_func = q->symbol.value;
2904 }
2905 break;
2906 }
2907 }
2908
2909 if (func == NULL)
2910 return false;
2911
2912 *filename_ptr = filename;
2913 *functionname_ptr = bfd_asymbol_name (func);
2914 *line_ptr = 0;
f21f3fe0 2915
252b5132
RH		 2916 return true;
2917}
2918
2919/* Adjust a symbol defined by a dynamic object and referenced by a
2920 regular object. The current definition is in some section of the
2921 dynamic object, but we're not including those sections. We have to
2922 change the definition to something the rest of the link can
2923 understand. */
2924
2925static boolean
2926elf32_arm_adjust_dynamic_symbol (info, h)
2927 struct bfd_link_info * info;
2928 struct elf_link_hash_entry * h;
2929{
2930 bfd * dynobj;
2931 asection * s;
2932 unsigned int power_of_two;
2933
2934 dynobj = elf_hash_table (info)->dynobj;
2935
2936 /* Make sure we know what is going on here. */
2937 BFD_ASSERT (dynobj != NULL
2938 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
2939 || h->weakdef != NULL
2940 || ((h->elf_link_hash_flags
2941 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2942 && (h->elf_link_hash_flags
2943 & ELF_LINK_HASH_REF_REGULAR) != 0
2944 && (h->elf_link_hash_flags
2945 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
2946
2947 /* If this is a function, put it in the procedure linkage table. We
2948 will fill in the contents of the procedure linkage table later,
2949 when we know the address of the .got section. */
2950 if (h->type == STT_FUNC
2951 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2952 {
2953 if (! info->shared
2954 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
2955 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
2956 {
2957 /* This case can occur if we saw a PLT32 reloc in an input
2958 file, but the symbol was never referred to by a dynamic
2959 object. In such a case, we don't actually need to build
2960 a procedure linkage table, and we can just do a PC32
2961 reloc instead. */
2962 BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
2963 return true;
2964 }
2965
2966 /* Make sure this symbol is output as a dynamic symbol. */
2967 if (h->dynindx == -1)
2968 {
2969 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2970 return false;
2971 }
2972
2973 s = bfd_get_section_by_name (dynobj, ".plt");
2974 BFD_ASSERT (s != NULL);
2975
2976 /* If this is the first .plt entry, make room for the special
2977 first entry. */
2978 if (s->_raw_size == 0)
2979 s->_raw_size += PLT_ENTRY_SIZE;
2980
2981 /* If this symbol is not defined in a regular file, and we are
2982 not generating a shared library, then set the symbol to this
2983 location in the .plt. This is required to make function
2984 pointers compare as equal between the normal executable and
2985 the shared library. */
2986 if (! info->shared
2987 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2988 {
2989 h->root.u.def.section = s;
2990 h->root.u.def.value = s->_raw_size;
2991 }
2992
2993 h->plt.offset = s->_raw_size;
2994
2995 /* Make room for this entry. */
2996 s->_raw_size += PLT_ENTRY_SIZE;
2997
2998 /* We also need to make an entry in the .got.plt section, which
2999 will be placed in the .got section by the linker script. */
252b5132
RH		 3000 s = bfd_get_section_by_name (dynobj, ".got.plt");
3001 BFD_ASSERT (s != NULL);
3002 s->_raw_size += 4;
3003
3004 /* We also need to make an entry in the .rel.plt section. */
3005
3006 s = bfd_get_section_by_name (dynobj, ".rel.plt");
3007 BFD_ASSERT (s != NULL);
3008 s->_raw_size += sizeof (Elf32_External_Rel);
3009
3010 return true;
3011 }
3012
3013 /* If this is a weak symbol, and there is a real definition, the
3014 processor independent code will have arranged for us to see the
3015 real definition first, and we can just use the same value. */
3016 if (h->weakdef != NULL)
3017 {
3018 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
3019 || h->weakdef->root.type == bfd_link_hash_defweak);
3020 h->root.u.def.section = h->weakdef->root.u.def.section;
3021 h->root.u.def.value = h->weakdef->root.u.def.value;
3022 return true;
3023 }
3024
3025 /* This is a reference to a symbol defined by a dynamic object which
3026 is not a function. */
3027
3028 /* If we are creating a shared library, we must presume that the
3029 only references to the symbol are via the global offset table.
3030 For such cases we need not do anything here; the relocations will
3031 be handled correctly by relocate_section. */
3032 if (info->shared)
3033 return true;
3034
3035 /* We must allocate the symbol in our .dynbss section, which will
3036 become part of the .bss section of the executable. There will be
3037 an entry for this symbol in the .dynsym section. The dynamic
3038 object will contain position independent code, so all references
3039 from the dynamic object to this symbol will go through the global
3040 offset table. The dynamic linker will use the .dynsym entry to
3041 determine the address it must put in the global offset table, so
3042 both the dynamic object and the regular object will refer to the
3043 same memory location for the variable. */
252b5132
RH		 3044 s = bfd_get_section_by_name (dynobj, ".dynbss");
3045 BFD_ASSERT (s != NULL);
3046
3047 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
3048 copy the initial value out of the dynamic object and into the
3049 runtime process image. We need to remember the offset into the
3050 .rel.bss section we are going to use. */
3051 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
3052 {
3053 asection *srel;
3054
3055 srel = bfd_get_section_by_name (dynobj, ".rel.bss");
3056 BFD_ASSERT (srel != NULL);
3057 srel->_raw_size += sizeof (Elf32_External_Rel);
3058 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
3059 }
3060
3061 /* We need to figure out the alignment required for this symbol. I
3062 have no idea how ELF linkers handle this. */
3063 power_of_two = bfd_log2 (h->size);
3064 if (power_of_two > 3)
3065 power_of_two = 3;
3066
3067 /* Apply the required alignment. */
3068 s->_raw_size = BFD_ALIGN (s->_raw_size,
3069 (bfd_size_type) (1 << power_of_two));
3070 if (power_of_two > bfd_get_section_alignment (dynobj, s))
3071 {
3072 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
3073 return false;
3074 }
3075
3076 /* Define the symbol as being at this point in the section. */
3077 h->root.u.def.section = s;
3078 h->root.u.def.value = s->_raw_size;
3079
3080 /* Increment the section size to make room for the symbol. */
3081 s->_raw_size += h->size;
3082
3083 return true;
3084}
3085
3086/* Set the sizes of the dynamic sections. */
3087
3088static boolean
3089elf32_arm_size_dynamic_sections (output_bfd, info)
99e4ae17 3090 bfd * output_bfd ATTRIBUTE_UNUSED;
252b5132
RH		 3091 struct bfd_link_info * info;
3092{
3093 bfd * dynobj;
3094 asection * s;
3095 boolean plt;
3096 boolean relocs;
252b5132
RH		 3097
3098 dynobj = elf_hash_table (info)->dynobj;
3099 BFD_ASSERT (dynobj != NULL);
3100
3101 if (elf_hash_table (info)->dynamic_sections_created)
3102 {
3103 /* Set the contents of the .interp section to the interpreter. */
3104 if (! info->shared)
3105 {
3106 s = bfd_get_section_by_name (dynobj, ".interp");
3107 BFD_ASSERT (s != NULL);
3108 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3109 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3110 }
3111 }
3112 else
3113 {
3114 /* We may have created entries in the .rel.got section.
3115 However, if we are not creating the dynamic sections, we will
3116 not actually use these entries. Reset the size of .rel.got,
3117 which will cause it to get stripped from the output file
3118 below. */
3119 s = bfd_get_section_by_name (dynobj, ".rel.got");
3120 if (s != NULL)
3121 s->_raw_size = 0;
3122 }
3123
3124 /* If this is a -Bsymbolic shared link, then we need to discard all
3125 PC relative relocs against symbols defined in a regular object.
3126 We allocated space for them in the check_relocs routine, but we
3127 will not fill them in in the relocate_section routine. */
3128 if (info->shared && info->symbolic)
3129 elf32_arm_link_hash_traverse (elf32_arm_hash_table (info),
3130 elf32_arm_discard_copies,
3131 (PTR) NULL);
3132
3133 /* The check_relocs and adjust_dynamic_symbol entry points have
3134 determined the sizes of the various dynamic sections. Allocate
3135 memory for them. */
3136 plt = false;
3137 relocs = false;
252b5132
RH		 3138 for (s = dynobj->sections; s != NULL; s = s->next)
3139 {
3140 const char * name;
3141 boolean strip;
3142
3143 if ((s->flags & SEC_LINKER_CREATED) == 0)
3144 continue;
3145
3146 /* It's OK to base decisions on the section name, because none
3147 of the dynobj section names depend upon the input files. */
3148 name = bfd_get_section_name (dynobj, s);
3149
3150 strip = false;
3151
3152 if (strcmp (name, ".plt") == 0)
3153 {
3154 if (s->_raw_size == 0)
3155 {
3156 /* Strip this section if we don't need it; see the
3157 comment below. */
3158 strip = true;
3159 }
3160 else
3161 {
3162 /* Remember whether there is a PLT. */
3163 plt = true;
3164 }
3165 }
3166 else if (strncmp (name, ".rel", 4) == 0)
3167 {
3168 if (s->_raw_size == 0)
3169 {
3170 /* If we don't need this section, strip it from the
3171 output file. This is mostly to handle .rel.bss and
3172 .rel.plt. We must create both sections in
3173 create_dynamic_sections, because they must be created
3174 before the linker maps input sections to output
3175 sections. The linker does that before
3176 adjust_dynamic_symbol is called, and it is that
3177 function which decides whether anything needs to go
3178 into these sections. */
3179 strip = true;
3180 }
3181 else
3182 {
252b5132
RH		 3183 /* Remember whether there are any reloc sections other
3184 than .rel.plt. */
3185 if (strcmp (name, ".rel.plt") != 0)
99e4ae17 3186 relocs = true;
252b5132
RH		 3187
3188 /* We use the reloc_count field as a counter if we need
3189 to copy relocs into the output file. */
3190 s->reloc_count = 0;
3191 }
3192 }
3193 else if (strncmp (name, ".got", 4) != 0)
3194 {
3195 /* It's not one of our sections, so don't allocate space. */
3196 continue;
3197 }
3198
3199 if (strip)
3200 {
3201 asection ** spp;
3202
3203 for (spp = &s->output_section->owner->sections;
c601ffdb 3204 *spp != NULL;
252b5132 3205 spp = &(*spp)->next)
c601ffdb
AM		 3206 {
3207 if (*spp == s->output_section)
3208 {
3209 bfd_section_list_remove (s->output_section->owner, spp);
3210 --s->output_section->owner->section_count;
3211 break;
3212 }
3213 }
252b5132
RH		 3214 continue;
3215 }
3216
3217 /* Allocate memory for the section contents. */
3218 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
3219 if (s->contents == NULL && s->_raw_size != 0)
3220 return false;
3221 }
3222
3223 if (elf_hash_table (info)->dynamic_sections_created)
3224 {
3225 /* Add some entries to the .dynamic section. We fill in the
3226 values later, in elf32_arm_finish_dynamic_sections, but we
3227 must add the entries now so that we get the correct size for
3228 the .dynamic section. The DT_DEBUG entry is filled in by the
3229 dynamic linker and used by the debugger. */
dc810e39
AM		 3230#define add_dynamic_entry(TAG, VAL) \
3231 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
3232
3233 if (!info->shared)
252b5132 3234 {
dc810e39 3235 if (!add_dynamic_entry (DT_DEBUG, 0))
252b5132
RH		 3236 return false;
3237 }
3238
3239 if (plt)
3240 {
dc810e39
AM		 3241 if ( !add_dynamic_entry (DT_PLTGOT, 0)
3242 || !add_dynamic_entry (DT_PLTRELSZ, 0)
3243 || !add_dynamic_entry (DT_PLTREL, DT_REL)
3244 || !add_dynamic_entry (DT_JMPREL, 0))
252b5132
RH		 3245 return false;
3246 }
3247
3248 if (relocs)
3249 {
dc810e39
AM		 3250 if ( !add_dynamic_entry (DT_REL, 0)
3251 || !add_dynamic_entry (DT_RELSZ, 0)
3252 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
252b5132
RH		 3253 return false;
3254 }
3255
99e4ae17 3256 if ((info->flags & DF_TEXTREL) != 0)
252b5132 3257 {
dc810e39 3258 if (!add_dynamic_entry (DT_TEXTREL, 0))
252b5132 3259 return false;
d6cf2879 3260 info->flags |= DF_TEXTREL;
252b5132
RH		 3261 }
3262 }
dc810e39 3263#undef add_synamic_entry
252b5132
RH		 3264
3265 return true;
3266}
3267
3268/* This function is called via elf32_arm_link_hash_traverse if we are
3269 creating a shared object with -Bsymbolic. It discards the space
3270 allocated to copy PC relative relocs against symbols which are
3271 defined in regular objects. We allocated space for them in the
3272 check_relocs routine, but we won't fill them in in the
3273 relocate_section routine. */
3274
3275static boolean
3276elf32_arm_discard_copies (h, ignore)
3277 struct elf32_arm_link_hash_entry * h;
5f771d47 3278 PTR ignore ATTRIBUTE_UNUSED;
252b5132
RH		 3279{
3280 struct elf32_arm_pcrel_relocs_copied * s;
3281
3282 /* We only discard relocs for symbols defined in a regular object. */
3283 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3284 return true;
3285
3286 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
3287 s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
3288
3289 return true;
3290}
3291
3292/* Finish up dynamic symbol handling. We set the contents of various
3293 dynamic sections here. */
3294
3295static boolean
3296elf32_arm_finish_dynamic_symbol (output_bfd, info, h, sym)
3297 bfd * output_bfd;
3298 struct bfd_link_info * info;
3299 struct elf_link_hash_entry * h;
3300 Elf_Internal_Sym * sym;
3301{
3302 bfd * dynobj;
3303
3304 dynobj = elf_hash_table (info)->dynobj;
3305
3306 if (h->plt.offset != (bfd_vma) -1)
3307 {
3308 asection * splt;
3309 asection * sgot;
3310 asection * srel;
3311 bfd_vma plt_index;
3312 bfd_vma got_offset;
3313 Elf_Internal_Rel rel;
3314
3315 /* This symbol has an entry in the procedure linkage table. Set
3316 it up. */
3317
3318 BFD_ASSERT (h->dynindx != -1);
3319
3320 splt = bfd_get_section_by_name (dynobj, ".plt");
3321 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3322 srel = bfd_get_section_by_name (dynobj, ".rel.plt");
3323 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
3324
3325 /* Get the index in the procedure linkage table which
3326 corresponds to this symbol. This is the index of this symbol
3327 in all the symbols for which we are making plt entries. The
3328 first entry in the procedure linkage table is reserved. */
3329 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3330
3331 /* Get the offset into the .got table of the entry that
3332 corresponds to this function. Each .got entry is 4 bytes.
3333 The first three are reserved. */
3334 got_offset = (plt_index + 3) * 4;
3335
3336 /* Fill in the entry in the procedure linkage table. */
f7a74f8c
NC		 3337 bfd_put_32 (output_bfd, elf32_arm_plt_entry[0],
3338 splt->contents + h->plt.offset + 0);
3339 bfd_put_32 (output_bfd, elf32_arm_plt_entry[1],
3340 splt->contents + h->plt.offset + 4);
3341 bfd_put_32 (output_bfd, elf32_arm_plt_entry[2],
3342 splt->contents + h->plt.offset + 8);
252b5132
RH		 3343 bfd_put_32 (output_bfd,
3344 (sgot->output_section->vma
3345 + sgot->output_offset
f21f3fe0 3346 + got_offset
252b5132
RH		 3347 - splt->output_section->vma
3348 - splt->output_offset
3349 - h->plt.offset - 12),
3350 splt->contents + h->plt.offset + 12);
3351
3352 /* Fill in the entry in the global offset table. */
3353 bfd_put_32 (output_bfd,
3354 (splt->output_section->vma
3355 + splt->output_offset),
3356 sgot->contents + got_offset);
3357
3358 /* Fill in the entry in the .rel.plt section. */
3359 rel.r_offset = (sgot->output_section->vma
3360 + sgot->output_offset
3361 + got_offset);
3362 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
3363 bfd_elf32_swap_reloc_out (output_bfd, &rel,
3364 ((Elf32_External_Rel *) srel->contents
3365 + plt_index));
3366
3367 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3368 {
3369 /* Mark the symbol as undefined, rather than as defined in
3370 the .plt section. Leave the value alone. */
3371 sym->st_shndx = SHN_UNDEF;
d982ba73
PB		 3372 /* If the symbol is weak, we do need to clear the value.
3373 Otherwise, the PLT entry would provide a definition for
3374 the symbol even if the symbol wasn't defined anywhere,
3375 and so the symbol would never be NULL. */
3376 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
3377 == 0)
3378 sym->st_value = 0;
252b5132
RH		 3379 }
3380 }
3381
3382 if (h->got.offset != (bfd_vma) -1)
3383 {
3384 asection * sgot;
3385 asection * srel;
3386 Elf_Internal_Rel rel;
3387
3388 /* This symbol has an entry in the global offset table. Set it
3389 up. */
252b5132
RH		 3390 sgot = bfd_get_section_by_name (dynobj, ".got");
3391 srel = bfd_get_section_by_name (dynobj, ".rel.got");
3392 BFD_ASSERT (sgot != NULL && srel != NULL);
3393
3394 rel.r_offset = (sgot->output_section->vma
3395 + sgot->output_offset
dc810e39 3396 + (h->got.offset &~ (bfd_vma) 1));
252b5132
RH		 3397
3398 /* If this is a -Bsymbolic link, and the symbol is defined
3399 locally, we just want to emit a RELATIVE reloc. The entry in
3400 the global offset table will already have been initialized in
3401 the relocate_section function. */
3402 if (info->shared
3403 && (info->symbolic || h->dynindx == -1)
3404 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3405 rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
3406 else
3407 {
3408 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
3409 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
3410 }
3411
3412 bfd_elf32_swap_reloc_out (output_bfd, &rel,
3413 ((Elf32_External_Rel *) srel->contents
3414 + srel->reloc_count));
3415 ++srel->reloc_count;
3416 }
3417
3418 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
3419 {
3420 asection * s;
3421 Elf_Internal_Rel rel;
3422
3423 /* This symbol needs a copy reloc. Set it up. */
252b5132
RH		 3424 BFD_ASSERT (h->dynindx != -1
3425 && (h->root.type == bfd_link_hash_defined
3426 || h->root.type == bfd_link_hash_defweak));
3427
3428 s = bfd_get_section_by_name (h->root.u.def.section->owner,
3429 ".rel.bss");
3430 BFD_ASSERT (s != NULL);
3431
3432 rel.r_offset = (h->root.u.def.value
3433 + h->root.u.def.section->output_section->vma
3434 + h->root.u.def.section->output_offset);
3435 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
3436 bfd_elf32_swap_reloc_out (output_bfd, &rel,
3437 ((Elf32_External_Rel *) s->contents
3438 + s->reloc_count));
3439 ++s->reloc_count;
3440 }
3441
3442 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3443 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3444 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3445 sym->st_shndx = SHN_ABS;
3446
3447 return true;
3448}
3449
3450/* Finish up the dynamic sections. */
3451
3452static boolean
3453elf32_arm_finish_dynamic_sections (output_bfd, info)
3454 bfd * output_bfd;
3455 struct bfd_link_info * info;
3456{
3457 bfd * dynobj;
3458 asection * sgot;
3459 asection * sdyn;
3460
3461 dynobj = elf_hash_table (info)->dynobj;
3462
3463 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3464 BFD_ASSERT (sgot != NULL);
3465 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3466
3467 if (elf_hash_table (info)->dynamic_sections_created)
3468 {
3469 asection *splt;
3470 Elf32_External_Dyn *dyncon, *dynconend;
3471
3472 splt = bfd_get_section_by_name (dynobj, ".plt");
3473 BFD_ASSERT (splt != NULL && sdyn != NULL);
3474
3475 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3476 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
9b485d32 3477
252b5132
RH		 3478 for (; dyncon < dynconend; dyncon++)
3479 {
3480 Elf_Internal_Dyn dyn;
3481 const char * name;
3482 asection * s;
3483
3484 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3485
3486 switch (dyn.d_tag)
3487 {
3488 default:
3489 break;
3490
3491 case DT_PLTGOT:
3492 name = ".got";
3493 goto get_vma;
3494 case DT_JMPREL:
3495 name = ".rel.plt";
3496 get_vma:
3497 s = bfd_get_section_by_name (output_bfd, name);
3498 BFD_ASSERT (s != NULL);
3499 dyn.d_un.d_ptr = s->vma;
3500 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3501 break;
3502
3503 case DT_PLTRELSZ:
3504 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3505 BFD_ASSERT (s != NULL);
3506 if (s->_cooked_size != 0)
3507 dyn.d_un.d_val = s->_cooked_size;
3508 else
3509 dyn.d_un.d_val = s->_raw_size;
3510 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3511 break;
3512
3513 case DT_RELSZ:
3514 /* My reading of the SVR4 ABI indicates that the
3515 procedure linkage table relocs (DT_JMPREL) should be
3516 included in the overall relocs (DT_REL). This is
3517 what Solaris does. However, UnixWare can not handle
3518 that case. Therefore, we override the DT_RELSZ entry
3519 here to make it not include the JMPREL relocs. Since
3520 the linker script arranges for .rel.plt to follow all
3521 other relocation sections, we don't have to worry
3522 about changing the DT_REL entry. */
3523 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3524 if (s != NULL)
3525 {
3526 if (s->_cooked_size != 0)
3527 dyn.d_un.d_val -= s->_cooked_size;
3528 else
3529 dyn.d_un.d_val -= s->_raw_size;
3530 }
3531 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3532 break;
3533 }
3534 }
3535
3536 /* Fill in the first entry in the procedure linkage table. */
3537 if (splt->_raw_size > 0)
f7a74f8c
NC		 3538 {
3539 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[0], splt->contents + 0);
3540 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[1], splt->contents + 4);
3541 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[2], splt->contents + 8);
3542 bfd_put_32 (output_bfd, elf32_arm_plt0_entry[3], splt->contents + 12);
3543 }
252b5132
RH		 3544
3545 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3546 really seem like the right value. */
3547 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
3548 }
3549
3550 /* Fill in the first three entries in the global offset table. */
3551 if (sgot->_raw_size > 0)
3552 {
3553 if (sdyn == NULL)
3554 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
3555 else
3556 bfd_put_32 (output_bfd,
3557 sdyn->output_section->vma + sdyn->output_offset,
3558 sgot->contents);
3559 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
3560 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3561 }
3562
3563 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
3564
3565 return true;
3566}
3567
ba96a88f
NC		 3568static void
3569elf32_arm_post_process_headers (abfd, link_info)
3570 bfd * abfd;
5f771d47 3571 struct bfd_link_info * link_info ATTRIBUTE_UNUSED;
ba96a88f 3572{
9b485d32 3573 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
ba96a88f
NC		 3574
3575 i_ehdrp = elf_elfheader (abfd);
3576
3577 i_ehdrp->e_ident[EI_OSABI] = ARM_ELF_OS_ABI_VERSION;
3578 i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
3579}
3580
99e4ae17 3581static enum elf_reloc_type_class
f51e552e
AM		 3582elf32_arm_reloc_type_class (rela)
3583 const Elf_Internal_Rela *rela;
99e4ae17 3584{
f51e552e 3585 switch ((int) ELF32_R_TYPE (rela->r_info))
99e4ae17
AJ		 3586 {
3587 case R_ARM_RELATIVE:
3588 return reloc_class_relative;
3589 case R_ARM_JUMP_SLOT:
3590 return reloc_class_plt;
3591 case R_ARM_COPY:
3592 return reloc_class_copy;
3593 default:
3594 return reloc_class_normal;
3595 }
3596}
3597
3598
252b5132
RH		 3599#define ELF_ARCH bfd_arch_arm
3600#define ELF_MACHINE_CODE EM_ARM
f21f3fe0 3601#define ELF_MAXPAGESIZE 0x8000
252b5132 3602
99e4ae17
AJ		 3603#define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
3604#define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
252b5132
RH		 3605#define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
3606#define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
3607#define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
dc810e39 3608#define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
252b5132
RH		 3609#define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
3610
3611#define elf_backend_get_symbol_type elf32_arm_get_symbol_type
3612#define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
3613#define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
3614#define elf_backend_check_relocs elf32_arm_check_relocs
dc810e39 3615#define elf_backend_relocate_section elf32_arm_relocate_section
252b5132
RH		 3616#define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
3617#define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
3618#define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
3619#define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
3620#define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
ba96a88f 3621#define elf_backend_post_process_headers elf32_arm_post_process_headers
99e4ae17 3622#define elf_backend_reloc_type_class elf32_arm_reloc_type_class
252b5132
RH		 3623
3624#define elf_backend_can_gc_sections 1
3625#define elf_backend_plt_readonly 1
3626#define elf_backend_want_got_plt 1
3627#define elf_backend_want_plt_sym 0
3628
04f7c78d
NC		 3629#define elf_backend_got_header_size 12
3630#define elf_backend_plt_header_size PLT_ENTRY_SIZE
3631
252b5132 3632#include "elf32-target.h"
A mirror of the official binutils-gdb repository