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