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