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