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