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