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