projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix warning message
[deliverable/binutils-gdb.git] / bfd / elf32-arm.h
CommitLineData
252b5132 1/* 32-bit ELF support for ARM
7898deda 2 Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
252b5132
RH		 3
4 This file is part of BFD, the Binary File Descriptor library.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
19
252b5132
RH		 20typedef unsigned long int insn32;
21typedef unsigned short int insn16;
22
23static boolean elf32_arm_set_private_flags
24 PARAMS ((bfd *, flagword));
25static boolean elf32_arm_copy_private_bfd_data
26 PARAMS ((bfd *, bfd *));
27static boolean elf32_arm_merge_private_bfd_data
28 PARAMS ((bfd *, bfd *));
29static boolean elf32_arm_print_private_bfd_data
30 PARAMS ((bfd *, PTR));
f21f3fe0 31static int elf32_arm_get_symbol_type
252b5132
RH		 32 PARAMS (( Elf_Internal_Sym *, int));
33static struct bfd_link_hash_table *elf32_arm_link_hash_table_create
34 PARAMS ((bfd *));
35static bfd_reloc_status_type elf32_arm_final_link_relocate
780a67af
NC		 36 PARAMS ((reloc_howto_type *, bfd *, bfd *, asection *, bfd_byte *,
37 Elf_Internal_Rela *, bfd_vma, struct bfd_link_info *, asection *,
38 const char *, unsigned char, struct elf_link_hash_entry *));
252b5132
RH		 39static insn32 insert_thumb_branch
40 PARAMS ((insn32, int));
41static struct elf_link_hash_entry *find_thumb_glue
42 PARAMS ((struct bfd_link_info *, CONST char *, bfd *));
43static struct elf_link_hash_entry *find_arm_glue
44 PARAMS ((struct bfd_link_info *, CONST char *, bfd *));
45static void record_arm_to_thumb_glue
46 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
47static void record_thumb_to_arm_glue
48 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
ba96a88f
NC		 49static void elf32_arm_post_process_headers
50 PARAMS ((bfd *, struct bfd_link_info *));
bcbdc74c
NC		 51static int elf32_arm_to_thumb_stub
52 PARAMS ((struct bfd_link_info *, const char *, bfd *, bfd *, asection *,
53 bfd_byte *, asection *, bfd_vma, bfd_signed_vma, bfd_vma));
54static int elf32_thumb_to_arm_stub
55 PARAMS ((struct bfd_link_info *, const char *, bfd *, bfd *, asection *,
56 bfd_byte *, asection *, bfd_vma, bfd_signed_vma, bfd_vma));
252b5132 57
fd2ec330 58#define INTERWORK_FLAG(abfd) (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK)
9b485d32 59
252b5132
RH		 60/* The linker script knows the section names for placement.
61 The entry_names are used to do simple name mangling on the stubs.
62 Given a function name, and its type, the stub can be found. The
9b485d32 63 name can be changed. The only requirement is the %s be present. */
252b5132
RH		 64#define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
65#define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
66
67#define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
68#define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
69
70/* The name of the dynamic interpreter. This is put in the .interp
71 section. */
72#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
73
74/* The size in bytes of an entry in the procedure linkage table. */
252b5132
RH		 75#define PLT_ENTRY_SIZE 16
76
77/* The first entry in a procedure linkage table looks like
78 this. It is set up so that any shared library function that is
59f2c4e7 79 called before the relocation has been set up calls the dynamic
9b485d32 80 linker first. */
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
df425bc0 1437#ifndef OLD_ARM_ABI
4f3c3dbb
NC		 1438 if (r_type == R_ARM_THM_XPC22
1439 && ((lower_insn & 0x1800) == 0x0800))
1440 /* Remove bit zero of the adjusted offset. Bit zero can only be
1441 set if the upper insn is at a half-word boundary, since the
1442 destination address, an ARM instruction, must always be on a
1443 word boundary. The semantics of the BLX (1) instruction, however,
1444 are that bit zero in the offset must always be zero, and the
1445 corresponding bit one in the target address will be set from bit
1446 one of the source address. */
1447 lower_insn &= ~1;
df425bc0 1448#endif
252b5132
RH		 1449 /* Put the relocated value back in the object file: */
1450 bfd_put_16 (input_bfd, upper_insn, hit_data);
1451 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
1452
1453 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
1454 }
1455 break;
1456
1457 case R_ARM_GNU_VTINHERIT:
1458 case R_ARM_GNU_VTENTRY:
1459 return bfd_reloc_ok;
1460
1461 case R_ARM_COPY:
1462 return bfd_reloc_notsupported;
1463
1464 case R_ARM_GLOB_DAT:
1465 return bfd_reloc_notsupported;
1466
1467 case R_ARM_JUMP_SLOT:
1468 return bfd_reloc_notsupported;
1469
1470 case R_ARM_RELATIVE:
1471 return bfd_reloc_notsupported;
1472
1473 case R_ARM_GOTOFF:
1474 /* Relocation is relative to the start of the
1475 global offset table. */
1476
1477 BFD_ASSERT (sgot != NULL);
1478 if (sgot == NULL)
1479 return bfd_reloc_notsupported;
9a5aca8c 1480
252b5132
RH		 1481 /* Note that sgot->output_offset is not involved in this
1482 calculation. We always want the start of .got. If we
1483 define _GLOBAL_OFFSET_TABLE in a different way, as is
1484 permitted by the ABI, we might have to change this
9b485d32 1485 calculation. */
252b5132 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);
1490
1491 case R_ARM_GOTPC:
a7c10850 1492 /* Use global offset table as symbol value. */
252b5132 1493 BFD_ASSERT (sgot != NULL);
f21f3fe0 1494
252b5132
RH		 1495 if (sgot == NULL)
1496 return bfd_reloc_notsupported;
1497
1498 value = sgot->output_section->vma;
f21f3fe0 1499 return _bfd_final_link_relocate (howto, input_bfd, input_section,
252b5132
RH		 1500 contents, rel->r_offset, value,
1501 (bfd_vma) 0);
f21f3fe0 1502
252b5132
RH		 1503 case R_ARM_GOT32:
1504 /* Relocation is to the entry for this symbol in the
9b485d32 1505 global offset table. */
252b5132
RH		 1506 if (sgot == NULL)
1507 return bfd_reloc_notsupported;
f21f3fe0 1508
252b5132
RH		 1509 if (h != NULL)
1510 {
1511 bfd_vma off;
f21f3fe0 1512
252b5132
RH		 1513 off = h->got.offset;
1514 BFD_ASSERT (off != (bfd_vma) -1);
f21f3fe0 1515
252b5132
RH		 1516 if (!elf_hash_table (info)->dynamic_sections_created ||
1517 (info->shared && (info->symbolic || h->dynindx == -1)
1518 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1519 {
1520 /* This is actually a static link, or it is a -Bsymbolic link
1521 and the symbol is defined locally. We must initialize this
1522 entry in the global offset table. Since the offset must
1523 always be a multiple of 4, we use the least significant bit
1524 to record whether we have initialized it already.
f21f3fe0 1525
252b5132 1526 When doing a dynamic link, we create a .rel.got relocation
f21f3fe0 1527 entry to initialize the value. This is done in the
9b485d32 1528 finish_dynamic_symbol routine. */
252b5132
RH		 1529 if ((off & 1) != 0)
1530 off &= ~1;
1531 else
1532 {
1533 bfd_put_32 (output_bfd, value, sgot->contents + off);
1534 h->got.offset |= 1;
1535 }
1536 }
f21f3fe0 1537
252b5132
RH		 1538 value = sgot->output_offset + off;
1539 }
1540 else
1541 {
1542 bfd_vma off;
f21f3fe0 1543
252b5132
RH		 1544 BFD_ASSERT (local_got_offsets != NULL &&
1545 local_got_offsets[r_symndx] != (bfd_vma) -1);
f21f3fe0 1546
252b5132 1547 off = local_got_offsets[r_symndx];
f21f3fe0 1548
252b5132
RH		 1549 /* The offset must always be a multiple of 4. We use the
1550 least significant bit to record whether we have already
9b485d32 1551 generated the necessary reloc. */
252b5132
RH		 1552 if ((off & 1) != 0)
1553 off &= ~1;
1554 else
1555 {
1556 bfd_put_32 (output_bfd, value, sgot->contents + off);
f21f3fe0 1557
252b5132
RH		 1558 if (info->shared)
1559 {
1560 asection * srelgot;
1561 Elf_Internal_Rel outrel;
f21f3fe0 1562
252b5132
RH		 1563 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
1564 BFD_ASSERT (srelgot != NULL);
f21f3fe0 1565
252b5132 1566 outrel.r_offset = (sgot->output_section->vma
f21f3fe0 1567 + sgot->output_offset
252b5132
RH		 1568 + off);
1569 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
1570 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1571 (((Elf32_External_Rel *)
1572 srelgot->contents)
1573 + srelgot->reloc_count));
1574 ++srelgot->reloc_count;
1575 }
f21f3fe0 1576
252b5132
RH		 1577 local_got_offsets[r_symndx] |= 1;
1578 }
f21f3fe0 1579
252b5132
RH		 1580 value = sgot->output_offset + off;
1581 }
9a5aca8c 1582
f21f3fe0 1583 return _bfd_final_link_relocate (howto, input_bfd, input_section,
252b5132
RH		 1584 contents, rel->r_offset, value,
1585 (bfd_vma) 0);
f21f3fe0 1586
252b5132
RH		 1587 case R_ARM_PLT32:
1588 /* Relocation is to the entry for this symbol in the
1589 procedure linkage table. */
1590
1591 /* Resolve a PLT32 reloc against a local symbol directly,
9b485d32 1592 without using the procedure linkage table. */
252b5132
RH		 1593 if (h == NULL)
1594 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1595 contents, rel->r_offset, value,
1596 (bfd_vma) 0);
1597
1598 if (h->plt.offset == (bfd_vma) -1)
1599 /* We didn't make a PLT entry for this symbol. This
1600 happens when statically linking PIC code, or when
1601 using -Bsymbolic. */
1602 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1603 contents, rel->r_offset, value,
1604 (bfd_vma) 0);
1605
1606 BFD_ASSERT(splt != NULL);
1607 if (splt == NULL)
1608 return bfd_reloc_notsupported;
1609
1610 value = (splt->output_section->vma
1611 + splt->output_offset
1612 + h->plt.offset);
1613 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1614 contents, rel->r_offset, value,
1615 (bfd_vma) 0);
f21f3fe0 1616
252b5132
RH		 1617 case R_ARM_SBREL32:
1618 return bfd_reloc_notsupported;
1619
1620 case R_ARM_AMP_VCALL9:
1621 return bfd_reloc_notsupported;
1622
1623 case R_ARM_RSBREL32:
1624 return bfd_reloc_notsupported;
1625
1626 case R_ARM_THM_RPC22:
1627 return bfd_reloc_notsupported;
1628
1629 case R_ARM_RREL32:
1630 return bfd_reloc_notsupported;
1631
1632 case R_ARM_RABS32:
1633 return bfd_reloc_notsupported;
1634
1635 case R_ARM_RPC24:
1636 return bfd_reloc_notsupported;
1637
1638 case R_ARM_RBASE:
1639 return bfd_reloc_notsupported;
1640
1641 default:
1642 return bfd_reloc_notsupported;
1643 }
1644}
1645
98c1d4aa
NC		 1646#ifdef USE_REL
1647/* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
1648static void
1649arm_add_to_rel (abfd, address, howto, increment)
1650 bfd * abfd;
59f2c4e7 1651 bfd_byte * address;
98c1d4aa
NC		 1652 reloc_howto_type * howto;
1653 bfd_signed_vma increment;
1654{
98c1d4aa
NC		 1655 bfd_signed_vma addend;
1656
9a5aca8c 1657 if (howto->type == R_ARM_THM_PC22)
98c1d4aa 1658 {
9a5aca8c
AM		 1659 int upper_insn, lower_insn;
1660 int upper, lower;
98c1d4aa 1661
9a5aca8c
AM		 1662 upper_insn = bfd_get_16 (abfd, address);
1663 lower_insn = bfd_get_16 (abfd, address + 2);
1664 upper = upper_insn & 0x7ff;
1665 lower = lower_insn & 0x7ff;
1666
1667 addend = (upper << 12) | (lower << 1);
ddda4409 1668 addend += increment;
9a5aca8c 1669 addend >>= 1;
98c1d4aa 1670
9a5aca8c
AM		 1671 upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
1672 lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
1673
1674 bfd_put_16 (abfd, upper_insn, address);
1675 bfd_put_16 (abfd, lower_insn, address + 2);
1676 }
1677 else
1678 {
1679 bfd_vma contents;
1680
1681 contents = bfd_get_32 (abfd, address);
1682
1683 /* Get the (signed) value from the instruction. */
1684 addend = contents & howto->src_mask;
1685 if (addend & ((howto->src_mask + 1) >> 1))
1686 {
1687 bfd_signed_vma mask;
1688
1689 mask = -1;
1690 mask &= ~ howto->src_mask;
1691 addend |= mask;
1692 }
1693
1694 /* Add in the increment, (which is a byte value). */
1695 switch (howto->type)
1696 {
1697 default:
1698 addend += increment;
1699 break;
1700
1701 case R_ARM_PC24:
1702 addend <<= howto->size;
1703 addend += increment;
1704
1705 /* Should we check for overflow here ? */
1706
1707 /* Drop any undesired bits. */
1708 addend >>= howto->rightshift;
1709 break;
1710 }
1711
1712 contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
1713
1714 bfd_put_32 (abfd, contents, address);
ddda4409 1715 }
98c1d4aa
NC		 1716}
1717#endif /* USE_REL */
252b5132
RH		 1718
1719/* Relocate an ARM ELF section. */
1720static boolean
1721elf32_arm_relocate_section (output_bfd, info, input_bfd, input_section,
1722 contents, relocs, local_syms, local_sections)
1723 bfd * output_bfd;
1724 struct bfd_link_info * info;
1725 bfd * input_bfd;
1726 asection * input_section;
1727 bfd_byte * contents;
1728 Elf_Internal_Rela * relocs;
1729 Elf_Internal_Sym * local_syms;
1730 asection ** local_sections;
1731{
1732 Elf_Internal_Shdr * symtab_hdr;
1733 struct elf_link_hash_entry ** sym_hashes;
1734 Elf_Internal_Rela * rel;
1735 Elf_Internal_Rela * relend;
1736 const char * name;
1737
1738 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1739 sym_hashes = elf_sym_hashes (input_bfd);
1740
1741 rel = relocs;
1742 relend = relocs + input_section->reloc_count;
1743 for (; rel < relend; rel++)
1744 {
ba96a88f
NC		 1745 int r_type;
1746 reloc_howto_type * howto;
1747 unsigned long r_symndx;
1748 Elf_Internal_Sym * sym;
1749 asection * sec;
252b5132 1750 struct elf_link_hash_entry * h;
ba96a88f
NC		 1751 bfd_vma relocation;
1752 bfd_reloc_status_type r;
1753 arelent bfd_reloc;
f21f3fe0 1754
252b5132 1755 r_symndx = ELF32_R_SYM (rel->r_info);
ba96a88f 1756 r_type = ELF32_R_TYPE (rel->r_info);
252b5132 1757
ba96a88f
NC		 1758 if ( r_type == R_ARM_GNU_VTENTRY
1759 || r_type == R_ARM_GNU_VTINHERIT)
252b5132
RH		 1760 continue;
1761
ba96a88f
NC		 1762 elf32_arm_info_to_howto (input_bfd, & bfd_reloc, rel);
1763 howto = bfd_reloc.howto;
252b5132
RH		 1764
1765 if (info->relocateable)
1766 {
1767 /* This is a relocateable link. We don't have to change
1768 anything, unless the reloc is against a section symbol,
1769 in which case we have to adjust according to where the
1770 section symbol winds up in the output section. */
1771 if (r_symndx < symtab_hdr->sh_info)
1772 {
1773 sym = local_syms + r_symndx;
1774 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1775 {
1776 sec = local_sections[r_symndx];
1777#ifdef USE_REL
98c1d4aa
NC		 1778 arm_add_to_rel (input_bfd, contents + rel->r_offset,
1779 howto, sec->output_offset + sym->st_value);
252b5132
RH		 1780#else
1781 rel->r_addend += (sec->output_offset + sym->st_value)
1782 >> howto->rightshift;
1783#endif
1784 }
1785 }
1786
1787 continue;
1788 }
1789
1790 /* This is a final link. */
1791 h = NULL;
1792 sym = NULL;
1793 sec = NULL;
9b485d32 1794
252b5132
RH		 1795 if (r_symndx < symtab_hdr->sh_info)
1796 {
1797 sym = local_syms + r_symndx;
1798 sec = local_sections[r_symndx];
1799 relocation = (sec->output_section->vma
1800 + sec->output_offset
1801 + sym->st_value);
1802 }
1803 else
1804 {
1805 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
9b485d32
NC		 1806
1807 while ( h->root.type == bfd_link_hash_indirect
252b5132
RH		 1808 || h->root.type == bfd_link_hash_warning)
1809 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9b485d32
NC		 1810
1811 if ( h->root.type == bfd_link_hash_defined
252b5132
RH		 1812 || h->root.type == bfd_link_hash_defweak)
1813 {
780a67af 1814 int relocation_needed = 1;
f21f3fe0 1815
780a67af 1816 sec = h->root.u.def.section;
f21f3fe0 1817
252b5132 1818 /* In these cases, we don't need the relocation value.
f21f3fe0 1819 We check specially because in some obscure cases
9b485d32 1820 sec->output_section will be NULL. */
252b5132
RH		 1821 switch (r_type)
1822 {
1823 case R_ARM_PC24:
1824 case R_ARM_ABS32:
1825 if (info->shared
1826 && (
1827 (!info->symbolic && h->dynindx != -1)
97eaf9de 1828 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
252b5132 1829 )
05924f36
PB		 1830 && ((input_section->flags & SEC_ALLOC) != 0
1831 /* DWARF will emit R_ARM_ABS32 relocations in its
1832 sections against symbols defined externally
1833 in shared libraries. We can't do anything
1834 with them here. */
1835 || ((input_section->flags & SEC_DEBUGGING) != 0
1836 && (h->elf_link_hash_flags
1837 & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
252b5132 1838 )
780a67af 1839 relocation_needed = 0;
252b5132 1840 break;
f21f3fe0 1841
252b5132 1842 case R_ARM_GOTPC:
780a67af 1843 relocation_needed = 0;
252b5132 1844 break;
f21f3fe0 1845
252b5132
RH		 1846 case R_ARM_GOT32:
1847 if (elf_hash_table(info)->dynamic_sections_created
1848 && (!info->shared
1849 || (!info->symbolic && h->dynindx != -1)
1850 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
1851 )
1852 )
780a67af 1853 relocation_needed = 0;
252b5132 1854 break;
f21f3fe0 1855
252b5132
RH		 1856 case R_ARM_PLT32:
1857 if (h->plt.offset != (bfd_vma)-1)
780a67af 1858 relocation_needed = 0;
252b5132 1859 break;
f21f3fe0 1860
252b5132
RH		 1861 default:
1862 if (sec->output_section == NULL)
1863 {
1864 (*_bfd_error_handler)
1865 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1866 bfd_get_filename (input_bfd), h->root.root.string,
1867 bfd_get_section_name (input_bfd, input_section));
780a67af 1868 relocation_needed = 0;
252b5132
RH		 1869 }
1870 }
780a67af
NC		 1871
1872 if (relocation_needed)
1873 relocation = h->root.u.def.value
1874 + sec->output_section->vma
1875 + sec->output_offset;
1876 else
1877 relocation = 0;
252b5132
RH		 1878 }
1879 else if (h->root.type == bfd_link_hash_undefweak)
1880 relocation = 0;
3a27a730
L		 1881 else if (info->shared && !info->symbolic
1882 && !info->no_undefined
1883 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
a72747a3 1884 relocation = 0;
252b5132
RH		 1885 else
1886 {
1887 if (!((*info->callbacks->undefined_symbol)
1888 (info, h->root.root.string, input_bfd,
5cc7c785 1889 input_section, rel->r_offset,
3a27a730
L		 1890 (!info->shared || info->no_undefined
1891 || ELF_ST_VISIBILITY (h->other)))))
252b5132
RH		 1892 return false;
1893 relocation = 0;
1894 }
1895 }
1896
1897 if (h != NULL)
1898 name = h->root.root.string;
1899 else
1900 {
1901 name = (bfd_elf_string_from_elf_section
1902 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1903 if (name == NULL || *name == '\0')
1904 name = bfd_section_name (input_bfd, sec);
1905 }
f21f3fe0 1906
252b5132
RH		 1907 r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
1908 input_section, contents, rel,
1909 relocation, info, sec, name,
1910 (h ? ELF_ST_TYPE (h->type) :
780a67af 1911 ELF_ST_TYPE (sym->st_info)), h);
252b5132
RH		 1912
1913 if (r != bfd_reloc_ok)
1914 {
1915 const char * msg = (const char *) 0;
1916
1917 switch (r)
1918 {
1919 case bfd_reloc_overflow:
cf919dfd
PB		 1920 /* If the overflowing reloc was to an undefined symbol,
1921 we have already printed one error message and there
1922 is no point complaining again. */
1923 if ((! h ||
1924 h->root.type != bfd_link_hash_undefined)
1925 && (!((*info->callbacks->reloc_overflow)
1926 (info, name, howto->name, (bfd_vma) 0,
1927 input_bfd, input_section, rel->r_offset))))
1928 return false;
252b5132
RH		 1929 break;
1930
1931 case bfd_reloc_undefined:
1932 if (!((*info->callbacks->undefined_symbol)
1933 (info, name, input_bfd, input_section,
5cc7c785 1934 rel->r_offset, true)))
252b5132
RH		 1935 return false;
1936 break;
1937
1938 case bfd_reloc_outofrange:
9b485d32 1939 msg = _("internal error: out of range error");
252b5132
RH		 1940 goto common_error;
1941
1942 case bfd_reloc_notsupported:
9b485d32 1943 msg = _("internal error: unsupported relocation error");
252b5132
RH		 1944 goto common_error;
1945
1946 case bfd_reloc_dangerous:
9b485d32 1947 msg = _("internal error: dangerous error");
252b5132
RH		 1948 goto common_error;
1949
1950 default:
9b485d32 1951 msg = _("internal error: unknown error");
252b5132
RH		 1952 /* fall through */
1953
1954 common_error:
1955 if (!((*info->callbacks->warning)
1956 (info, msg, name, input_bfd, input_section,
1957 rel->r_offset)))
1958 return false;
1959 break;
1960 }
1961 }
1962 }
1963
1964 return true;
1965}
1966
fc830a83 1967/* Function to keep ARM specific flags in the ELF header. */
252b5132
RH		 1968static boolean
1969elf32_arm_set_private_flags (abfd, flags)
1970 bfd *abfd;
1971 flagword flags;
1972{
1973 if (elf_flags_init (abfd)
1974 && elf_elfheader (abfd)->e_flags != flags)
1975 {
fc830a83
NC		 1976 if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
1977 {
fd2ec330 1978 if (flags & EF_ARM_INTERWORK)
9b485d32 1979 _bfd_error_handler (_("\
252b5132 1980Warning: Not setting interwork flag of %s since it has already been specified as non-interworking"),
fc830a83
NC		 1981 bfd_get_filename (abfd));
1982 else
9b485d32 1983 _bfd_error_handler (_("\
252b5132 1984Warning: Clearing the interwork flag of %s due to outside request"),
fc830a83
NC		 1985 bfd_get_filename (abfd));
1986 }
252b5132
RH		 1987 }
1988 else
1989 {
1990 elf_elfheader (abfd)->e_flags = flags;
1991 elf_flags_init (abfd) = true;
1992 }
1993
1994 return true;
1995}
1996
fc830a83 1997/* Copy backend specific data from one object module to another. */
9b485d32 1998
252b5132
RH		 1999static boolean
2000elf32_arm_copy_private_bfd_data (ibfd, obfd)
2001 bfd *ibfd;
2002 bfd *obfd;
2003{
2004 flagword in_flags;
2005 flagword out_flags;
2006
fc830a83 2007 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
252b5132
RH		 2008 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2009 return true;
2010
fc830a83 2011 in_flags = elf_elfheader (ibfd)->e_flags;
252b5132
RH		 2012 out_flags = elf_elfheader (obfd)->e_flags;
2013
fc830a83
NC		 2014 if (elf_flags_init (obfd)
2015 && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
2016 && in_flags != out_flags)
252b5132 2017 {
252b5132 2018 /* Cannot mix APCS26 and APCS32 code. */
fd2ec330 2019 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
252b5132
RH		 2020 return false;
2021
2022 /* Cannot mix float APCS and non-float APCS code. */
fd2ec330 2023 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
252b5132
RH		 2024 return false;
2025
2026 /* If the src and dest have different interworking flags
2027 then turn off the interworking bit. */
fd2ec330 2028 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
252b5132 2029 {
fd2ec330 2030 if (out_flags & EF_ARM_INTERWORK)
9b485d32 2031 _bfd_error_handler (_("\
252b5132
RH		 2032Warning: Clearing the interwork flag in %s because non-interworking code in %s has been linked with it"),
2033 bfd_get_filename (obfd), bfd_get_filename (ibfd));
2034
fd2ec330 2035 in_flags &= ~EF_ARM_INTERWORK;
252b5132 2036 }
1006ba19
PB		 2037
2038 /* Likewise for PIC, though don't warn for this case. */
fd2ec330
PB		 2039 if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC))
2040 in_flags &= ~EF_ARM_PIC;
252b5132
RH		 2041 }
2042
2043 elf_elfheader (obfd)->e_flags = in_flags;
2044 elf_flags_init (obfd) = true;
2045
2046 return true;
2047}
2048
2049/* Merge backend specific data from an object file to the output
2050 object file when linking. */
9b485d32 2051
252b5132
RH		 2052static boolean
2053elf32_arm_merge_private_bfd_data (ibfd, obfd)
fc830a83
NC		 2054 bfd * ibfd;
2055 bfd * obfd;
252b5132
RH		 2056{
2057 flagword out_flags;
2058 flagword in_flags;
1006ba19 2059 boolean flags_compatible = true;
cf919dfd
PB		 2060 boolean null_input_bfd = true;
2061 asection *sec;
252b5132 2062
9b485d32 2063 /* Check if we have the same endianess. */
1fe494a5
NC		 2064 if (_bfd_generic_verify_endian_match (ibfd, obfd) == false)
2065 return false;
2066
252b5132
RH		 2067 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2068 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2069 return true;
2070
252b5132
RH		 2071 /* The input BFD must have had its flags initialised. */
2072 /* The following seems bogus to me -- The flags are initialized in
2073 the assembler but I don't think an elf_flags_init field is
9b485d32 2074 written into the object. */
252b5132
RH		 2075 /* BFD_ASSERT (elf_flags_init (ibfd)); */
2076
2077 in_flags = elf_elfheader (ibfd)->e_flags;
2078 out_flags = elf_elfheader (obfd)->e_flags;
2079
2080 if (!elf_flags_init (obfd))
2081 {
fe077fa6
NC		 2082 /* If the input is the default architecture and had the default
2083 flags then do not bother setting the flags for the output
2084 architecture, instead allow future merges to do this. If no
2085 future merges ever set these flags then they will retain their
2086 uninitialised values, which surprise surprise, correspond
252b5132 2087 to the default values. */
fe077fa6
NC		 2088 if (bfd_get_arch_info (ibfd)->the_default
2089 && elf_elfheader (ibfd)->e_flags == 0)
252b5132
RH		 2090 return true;
2091
2092 elf_flags_init (obfd) = true;
2093 elf_elfheader (obfd)->e_flags = in_flags;
2094
2095 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2096 && bfd_get_arch_info (obfd)->the_default)
2097 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
2098
2099 return true;
2100 }
2101
1006ba19 2102 /* Identical flags must be compatible. */
252b5132
RH		 2103 if (in_flags == out_flags)
2104 return true;
2105
cf919dfd
PB		 2106 /* Check to see if the input BFD actually contains any sections.
2107 If not, its flags may not have been initialised either, but it cannot
2108 actually cause any incompatibility. */
2109 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
2110 {
2111 /* Ignore synthetic glue sections. */
2112 if (strcmp (sec->name, ".glue_7")
2113 && strcmp (sec->name, ".glue_7t"))
2114 {
2115 null_input_bfd = false;
2116 break;
2117 }
2118 }
2119 if (null_input_bfd)
2120 return true;
2121
252b5132 2122 /* Complain about various flag mismatches. */
fc830a83
NC		 2123 if (EF_ARM_EABI_VERSION (in_flags) != EF_ARM_EABI_VERSION (out_flags))
2124 {
2125 _bfd_error_handler (_("\
2126Error: %s compiled for EABI version %d, whereas %s is compiled for version %d"),
2127 bfd_get_filename (ibfd),
2128 (in_flags & EF_ARM_EABIMASK) >> 24,
2129 bfd_get_filename (obfd),
2130 (out_flags & EF_ARM_EABIMASK) >> 24);
1006ba19 2131 return false;
fc830a83 2132 }
252b5132 2133
1006ba19
PB		 2134 /* Not sure what needs to be checked for EABI versions >= 1. */
2135 if (EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
2136 {
fd2ec330 2137 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
1006ba19
PB		 2138 {
2139 _bfd_error_handler (_("\
252b5132
RH		 2140Error: %s compiled for APCS-%d, whereas %s is compiled for APCS-%d"),
2141 bfd_get_filename (ibfd),
fd2ec330 2142 in_flags & EF_ARM_APCS_26 ? 26 : 32,
252b5132 2143 bfd_get_filename (obfd),
fd2ec330 2144 out_flags & EF_ARM_APCS_26 ? 26 : 32);
1006ba19
PB		 2145 flags_compatible = false;
2146 }
252b5132 2147
fd2ec330 2148 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
1006ba19
PB		 2149 {
2150 _bfd_error_handler (_("\
252b5132
RH		 2151Error: %s passes floats in %s registers, whereas %s passes them in %s registers"),
2152 bfd_get_filename (ibfd),
fd2ec330 2153 in_flags & EF_ARM_APCS_FLOAT ? _("float") : _("integer"),
252b5132 2154 bfd_get_filename (obfd),
fd2ec330 2155 out_flags & EF_ARM_APCS_26 ? _("float") : _("integer"));
1006ba19
PB		 2156 flags_compatible = false;
2157 }
252b5132 2158
fd2ec330
PB		 2159#ifdef EF_ARM_SOFT_FLOAT
2160 if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
1006ba19
PB		 2161 {
2162 _bfd_error_handler (_ ("\
2163Error: %s uses %s floating point, whereas %s uses %s floating point"),
2164 bfd_get_filename (ibfd),
fd2ec330 2165 in_flags & EF_ARM_SOFT_FLOAT ? _("soft") : _("hard"),
1006ba19 2166 bfd_get_filename (obfd),
fd2ec330 2167 out_flags & EF_ARM_SOFT_FLOAT ? _("soft") : _("hard"));
1006ba19
PB		 2168 flags_compatible = false;
2169 }
ee43f35e 2170#endif
252b5132 2171
1006ba19 2172 /* Interworking mismatch is only a warning. */
fd2ec330 2173 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
1006ba19 2174 _bfd_error_handler (_("\
252b5132 2175Warning: %s %s interworking, whereas %s %s"),
d1659392
NC		 2176 bfd_get_filename (ibfd),
2177 in_flags & EF_ARM_INTERWORK ? _("supports") : _("does not support"),
2178 bfd_get_filename (obfd),
2179 out_flags & EF_ARM_INTERWORK ? _("does") : _("does not"));
252b5132
RH		 2180 }
2181
1006ba19 2182 return flags_compatible;
252b5132
RH		 2183}
2184
9b485d32
NC		 2185/* Display the flags field. */
2186
252b5132
RH		 2187static boolean
2188elf32_arm_print_private_bfd_data (abfd, ptr)
2189 bfd *abfd;
2190 PTR ptr;
2191{
fc830a83
NC		 2192 FILE * file = (FILE *) ptr;
2193 unsigned long flags;
252b5132
RH		 2194
2195 BFD_ASSERT (abfd != NULL && ptr != NULL);
2196
2197 /* Print normal ELF private data. */
2198 _bfd_elf_print_private_bfd_data (abfd, ptr);
2199
fc830a83 2200 flags = elf_elfheader (abfd)->e_flags;
9b485d32
NC		 2201 /* Ignore init flag - it may not be set, despite the flags field
2202 containing valid data. */
252b5132
RH		 2203
2204 /* xgettext:c-format */
9b485d32 2205 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
252b5132 2206
fc830a83
NC		 2207 switch (EF_ARM_EABI_VERSION (flags))
2208 {
2209 case EF_ARM_EABI_UNKNOWN:
2210 /* The following flag bits are GNU extenstions and not part of the
2211 official ARM ELF extended ABI. Hence they are only decoded if
2212 the EABI version is not set. */
fd2ec330 2213 if (flags & EF_ARM_INTERWORK)
9b485d32 2214 fprintf (file, _(" [interworking enabled]"));
9a5aca8c 2215
fd2ec330 2216 if (flags & EF_ARM_APCS_26)
9b485d32 2217 fprintf (file, _(" [APCS-26]"));
fc830a83 2218 else
9b485d32 2219 fprintf (file, _(" [APCS-32]"));
9a5aca8c 2220
fd2ec330 2221 if (flags & EF_ARM_APCS_FLOAT)
9b485d32 2222 fprintf (file, _(" [floats passed in float registers]"));
9a5aca8c 2223
fd2ec330 2224 if (flags & EF_ARM_PIC)
9b485d32 2225 fprintf (file, _(" [position independent]"));
fc830a83 2226
fd2ec330 2227 if (flags & EF_ARM_NEW_ABI)
9b485d32 2228 fprintf (file, _(" [new ABI]"));
9a5aca8c 2229
fd2ec330 2230 if (flags & EF_ARM_OLD_ABI)
9b485d32 2231 fprintf (file, _(" [old ABI]"));
9a5aca8c 2232
fd2ec330 2233 if (flags & EF_ARM_SOFT_FLOAT)
9b485d32 2234 fprintf (file, _(" [software FP]"));
9a5aca8c 2235
fd2ec330
PB		 2236 flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT | EF_ARM_PIC
2237 | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI | EF_ARM_SOFT_FLOAT);
fc830a83 2238 break;
9a5aca8c 2239
fc830a83 2240 case EF_ARM_EABI_VER1:
9b485d32 2241 fprintf (file, _(" [Version1 EABI]"));
9a5aca8c 2242
fc830a83 2243 if (flags & EF_ARM_SYMSARESORTED)
9b485d32 2244 fprintf (file, _(" [sorted symbol table]"));
fc830a83 2245 else
9b485d32 2246 fprintf (file, _(" [unsorted symbol table]"));
9a5aca8c 2247
fc830a83
NC		 2248 flags &= ~ EF_ARM_SYMSARESORTED;
2249 break;
9a5aca8c 2250
fd2ec330
PB		 2251 case EF_ARM_EABI_VER2:
2252 fprintf (file, _(" [Version2 EABI]"));
2253
2254 if (flags & EF_ARM_SYMSARESORTED)
2255 fprintf (file, _(" [sorted symbol table]"));
2256 else
2257 fprintf (file, _(" [unsorted symbol table]"));
2258
2259 if (flags & EF_ARM_DYNSYMSUSESEGIDX)
2260 fprintf (file, _(" [dynamic symbols use segment index]"));
2261
2262 if (flags & EF_ARM_MAPSYMSFIRST)
2263 fprintf (file, _(" [mapping symbols precede others]"));
2264
2265 flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX
2266 | EF_ARM_MAPSYMSFIRST);
2267 break;
2268
fc830a83 2269 default:
9b485d32 2270 fprintf (file, _(" <EABI version unrecognised>"));
fc830a83
NC		 2271 break;
2272 }
252b5132 2273
fc830a83 2274 flags &= ~ EF_ARM_EABIMASK;
252b5132 2275
fc830a83 2276 if (flags & EF_ARM_RELEXEC)
9b485d32 2277 fprintf (file, _(" [relocatable executable]"));
252b5132 2278
fc830a83 2279 if (flags & EF_ARM_HASENTRY)
9b485d32 2280 fprintf (file, _(" [has entry point]"));
252b5132 2281
fc830a83
NC		 2282 flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
2283
2284 if (flags)
9b485d32 2285 fprintf (file, _("<Unrecognised flag bits set>"));
9a5aca8c 2286
252b5132
RH		 2287 fputc ('\n', file);
2288
2289 return true;
2290}
2291
2292static int
2293elf32_arm_get_symbol_type (elf_sym, type)
2294 Elf_Internal_Sym * elf_sym;
2295 int type;
2296{
2f0ca46a
NC		 2297 switch (ELF_ST_TYPE (elf_sym->st_info))
2298 {
2299 case STT_ARM_TFUNC:
2300 return ELF_ST_TYPE (elf_sym->st_info);
ce855c42 2301
2f0ca46a
NC		 2302 case STT_ARM_16BIT:
2303 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2304 This allows us to distinguish between data used by Thumb instructions
2305 and non-data (which is probably code) inside Thumb regions of an
2306 executable. */
2307 if (type != STT_OBJECT)
2308 return ELF_ST_TYPE (elf_sym->st_info);
2309 break;
9a5aca8c 2310
ce855c42
NC		 2311 default:
2312 break;
2f0ca46a
NC		 2313 }
2314
2315 return type;
252b5132 2316}
f21f3fe0 2317
252b5132
RH		 2318static asection *
2319elf32_arm_gc_mark_hook (abfd, info, rel, h, sym)
2320 bfd *abfd;
5f771d47 2321 struct bfd_link_info *info ATTRIBUTE_UNUSED;
252b5132
RH		 2322 Elf_Internal_Rela *rel;
2323 struct elf_link_hash_entry *h;
2324 Elf_Internal_Sym *sym;
2325{
2326 if (h != NULL)
2327 {
2328 switch (ELF32_R_TYPE (rel->r_info))
2329 {
2330 case R_ARM_GNU_VTINHERIT:
2331 case R_ARM_GNU_VTENTRY:
2332 break;
2333
2334 default:
2335 switch (h->root.type)
2336 {
2337 case bfd_link_hash_defined:
2338 case bfd_link_hash_defweak:
2339 return h->root.u.def.section;
2340
2341 case bfd_link_hash_common:
2342 return h->root.u.c.p->section;
e049a0de
ILT		 2343
2344 default:
2345 break;
252b5132
RH		 2346 }
2347 }
2348 }
2349 else
2350 {
2351 if (!(elf_bad_symtab (abfd)
2352 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
2353 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
2354 && sym->st_shndx != SHN_COMMON))
2355 {
2356 return bfd_section_from_elf_index (abfd, sym->st_shndx);
2357 }
2358 }
2359 return NULL;
2360}
2361
780a67af
NC		 2362/* Update the got entry reference counts for the section being removed. */
2363
252b5132
RH		 2364static boolean
2365elf32_arm_gc_sweep_hook (abfd, info, sec, relocs)
5f771d47
ILT		 2366 bfd *abfd ATTRIBUTE_UNUSED;
2367 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2368 asection *sec ATTRIBUTE_UNUSED;
2369 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
252b5132 2370{
780a67af 2371 /* We don't support garbage collection of GOT and PLT relocs yet. */
252b5132
RH		 2372 return true;
2373}
2374
780a67af
NC		 2375/* Look through the relocs for a section during the first phase. */
2376
252b5132
RH		 2377static boolean
2378elf32_arm_check_relocs (abfd, info, sec, relocs)
2379 bfd * abfd;
2380 struct bfd_link_info * info;
2381 asection * sec;
2382 const Elf_Internal_Rela * relocs;
2383{
2384 Elf_Internal_Shdr * symtab_hdr;
2385 struct elf_link_hash_entry ** sym_hashes;
2386 struct elf_link_hash_entry ** sym_hashes_end;
2387 const Elf_Internal_Rela * rel;
2388 const Elf_Internal_Rela * rel_end;
2389 bfd * dynobj;
2390 asection * sgot, *srelgot, *sreloc;
2391 bfd_vma * local_got_offsets;
9a5aca8c 2392
252b5132
RH		 2393 if (info->relocateable)
2394 return true;
9a5aca8c 2395
252b5132 2396 sgot = srelgot = sreloc = NULL;
9a5aca8c 2397
252b5132
RH		 2398 dynobj = elf_hash_table (info)->dynobj;
2399 local_got_offsets = elf_local_got_offsets (abfd);
f21f3fe0 2400
252b5132
RH		 2401 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2402 sym_hashes = elf_sym_hashes (abfd);
9b485d32
NC		 2403 sym_hashes_end = sym_hashes
2404 + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
2405
252b5132
RH		 2406 if (!elf_bad_symtab (abfd))
2407 sym_hashes_end -= symtab_hdr->sh_info;
9b485d32 2408
252b5132
RH		 2409 rel_end = relocs + sec->reloc_count;
2410 for (rel = relocs; rel < rel_end; rel++)
2411 {
2412 struct elf_link_hash_entry *h;
2413 unsigned long r_symndx;
9a5aca8c 2414
252b5132
RH		 2415 r_symndx = ELF32_R_SYM (rel->r_info);
2416 if (r_symndx < symtab_hdr->sh_info)
2417 h = NULL;
2418 else
2419 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
9a5aca8c 2420
252b5132
RH		 2421 /* Some relocs require a global offset table. */
2422 if (dynobj == NULL)
2423 {
2424 switch (ELF32_R_TYPE (rel->r_info))
2425 {
2426 case R_ARM_GOT32:
2427 case R_ARM_GOTOFF:
2428 case R_ARM_GOTPC:
2429 elf_hash_table (info)->dynobj = dynobj = abfd;
2430 if (! _bfd_elf_create_got_section (dynobj, info))
2431 return false;
2432 break;
2433
2434 default:
2435 break;
2436 }
2437 }
2438
2439 switch (ELF32_R_TYPE (rel->r_info))
2440 {
2441 case R_ARM_GOT32:
2442 /* This symbol requires a global offset table entry. */
2443 if (sgot == NULL)
2444 {
2445 sgot = bfd_get_section_by_name (dynobj, ".got");
2446 BFD_ASSERT (sgot != NULL);
2447 }
2448
2449 /* Get the got relocation section if necessary. */
2450 if (srelgot == NULL
2451 && (h != NULL || info->shared))
2452 {
2453 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
9a5aca8c 2454
252b5132
RH		 2455 /* If no got relocation section, make one and initialize. */
2456 if (srelgot == NULL)
2457 {
2458 srelgot = bfd_make_section (dynobj, ".rel.got");
2459 if (srelgot == NULL
2460 || ! bfd_set_section_flags (dynobj, srelgot,
2461 (SEC_ALLOC
2462 | SEC_LOAD
2463 | SEC_HAS_CONTENTS
2464 | SEC_IN_MEMORY
2465 | SEC_LINKER_CREATED
2466 | SEC_READONLY))
2467 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
2468 return false;
2469 }
2470 }
2471
2472 if (h != NULL)
2473 {
2474 if (h->got.offset != (bfd_vma) -1)
2475 /* We have already allocated space in the .got. */
2476 break;
f21f3fe0 2477
252b5132
RH		 2478 h->got.offset = sgot->_raw_size;
2479
2480 /* Make sure this symbol is output as a dynamic symbol. */
2481 if (h->dynindx == -1)
2482 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2483 return false;
2484
2485 srelgot->_raw_size += sizeof (Elf32_External_Rel);
2486 }
2487 else
2488 {
2489 /* This is a global offset table entry for a local
2490 symbol. */
2491 if (local_got_offsets == NULL)
2492 {
2493 size_t size;
2494 register unsigned int i;
2495
2496 size = symtab_hdr->sh_info * sizeof (bfd_vma);
2497 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
2498 if (local_got_offsets == NULL)
2499 return false;
2500 elf_local_got_offsets (abfd) = local_got_offsets;
2501 for (i = 0; i < symtab_hdr->sh_info; i++)
2502 local_got_offsets[i] = (bfd_vma) -1;
2503 }
f21f3fe0 2504
252b5132
RH		 2505 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
2506 /* We have already allocated space in the .got. */
2507 break;
2508
2509 local_got_offsets[r_symndx] = sgot->_raw_size;
2510
2511 if (info->shared)
2512 /* If we are generating a shared object, we need to
2513 output a R_ARM_RELATIVE reloc so that the dynamic
2514 linker can adjust this GOT entry. */
2515 srelgot->_raw_size += sizeof (Elf32_External_Rel);
2516 }
2517
2518 sgot->_raw_size += 4;
2519 break;
2520
2521 case R_ARM_PLT32:
2522 /* This symbol requires a procedure linkage table entry. We
2523 actually build the entry in adjust_dynamic_symbol,
2524 because this might be a case of linking PIC code which is
2525 never referenced by a dynamic object, in which case we
2526 don't need to generate a procedure linkage table entry
2527 after all. */
2528
2529 /* If this is a local symbol, we resolve it directly without
2530 creating a procedure linkage table entry. */
2531 if (h == NULL)
2532 continue;
2533
2534 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2535 break;
2536
2537 case R_ARM_ABS32:
2538 case R_ARM_REL32:
2539 case R_ARM_PC24:
2540 /* If we are creating a shared library, and this is a reloc
2541 against a global symbol, or a non PC relative reloc
2542 against a local symbol, then we need to copy the reloc
2543 into the shared library. However, if we are linking with
2544 -Bsymbolic, we do not need to copy a reloc against a
2545 global symbol which is defined in an object we are
2546 including in the link (i.e., DEF_REGULAR is set). At
2547 this point we have not seen all the input files, so it is
2548 possible that DEF_REGULAR is not set now but will be set
2549 later (it is never cleared). We account for that
2550 possibility below by storing information in the
2551 pcrel_relocs_copied field of the hash table entry. */
2552 if (info->shared
2553 && (ELF32_R_TYPE (rel->r_info) != R_ARM_PC24
2554 || (h != NULL
2555 && (! info->symbolic
2556 || (h->elf_link_hash_flags
2557 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2558 {
2559 /* When creating a shared object, we must copy these
2560 reloc types into the output file. We create a reloc
2561 section in dynobj and make room for this reloc. */
2562 if (sreloc == NULL)
2563 {
2564 const char * name;
2565
2566 name = (bfd_elf_string_from_elf_section
2567 (abfd,
2568 elf_elfheader (abfd)->e_shstrndx,
2569 elf_section_data (sec)->rel_hdr.sh_name));
2570 if (name == NULL)
2571 return false;
2572
2573 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
2574 && strcmp (bfd_get_section_name (abfd, sec),
2575 name + 4) == 0);
2576
2577 sreloc = bfd_get_section_by_name (dynobj, name);
2578 if (sreloc == NULL)
2579 {
2580 flagword flags;
2581
2582 sreloc = bfd_make_section (dynobj, name);
2583 flags = (SEC_HAS_CONTENTS | SEC_READONLY
2584 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2585 if ((sec->flags & SEC_ALLOC) != 0)
2586 flags |= SEC_ALLOC | SEC_LOAD;
2587 if (sreloc == NULL
2588 || ! bfd_set_section_flags (dynobj, sreloc, flags)
2589 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
2590 return false;
2591 }
2592 }
2593
2594 sreloc->_raw_size += sizeof (Elf32_External_Rel);
2595 /* If we are linking with -Bsymbolic, and this is a
2596 global symbol, we count the number of PC relative
2597 relocations we have entered for this symbol, so that
2598 we can discard them again if the symbol is later
2599 defined by a regular object. Note that this function
2600 is only called if we are using an elf_i386 linker
2601 hash table, which means that h is really a pointer to
2602 an elf_i386_link_hash_entry. */
2603 if (h != NULL && info->symbolic
2604 && ELF32_R_TYPE (rel->r_info) == R_ARM_PC24)
2605 {
2606 struct elf32_arm_link_hash_entry * eh;
2607 struct elf32_arm_pcrel_relocs_copied * p;
2608
2609 eh = (struct elf32_arm_link_hash_entry *) h;
2610
2611 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
2612 if (p->section == sreloc)
2613 break;
2614
2615 if (p == NULL)
2616 {
2617 p = ((struct elf32_arm_pcrel_relocs_copied *)
2618 bfd_alloc (dynobj, sizeof * p));
f21f3fe0 2619
252b5132
RH		 2620 if (p == NULL)
2621 return false;
2622 p->next = eh->pcrel_relocs_copied;
2623 eh->pcrel_relocs_copied = p;
2624 p->section = sreloc;
2625 p->count = 0;
2626 }
2627
2628 ++p->count;
2629 }
2630 }
2631 break;
2632
2633 /* This relocation describes the C++ object vtable hierarchy.
2634 Reconstruct it for later use during GC. */
2635 case R_ARM_GNU_VTINHERIT:
2636 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2637 return false;
2638 break;
9a5aca8c 2639
252b5132
RH		 2640 /* This relocation describes which C++ vtable entries are actually
2641 used. Record for later use during GC. */
2642 case R_ARM_GNU_VTENTRY:
d512aa07 2643 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
252b5132
RH		 2644 return false;
2645 break;
2646 }
2647 }
f21f3fe0 2648
252b5132
RH		 2649 return true;
2650}
2651
252b5132
RH		 2652/* Find the nearest line to a particular section and offset, for error
2653 reporting. This code is a duplicate of the code in elf.c, except
9b485d32 2654 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
252b5132
RH		 2655
2656static boolean
2657elf32_arm_find_nearest_line
2658 (abfd, section, symbols, offset, filename_ptr, functionname_ptr, line_ptr)
2659 bfd * abfd;
2660 asection * section;
2661 asymbol ** symbols;
2662 bfd_vma offset;
2663 CONST char ** filename_ptr;
2664 CONST char ** functionname_ptr;
2665 unsigned int * line_ptr;
2666{
2667 boolean found;
2668 const char * filename;
2669 asymbol * func;
2670 bfd_vma low_func;
2671 asymbol ** p;
2672
2673 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
f21f3fe0 2674 filename_ptr, functionname_ptr,
857ec808
NC		 2675 line_ptr, 0,
2676 &elf_tdata (abfd)->dwarf2_find_line_info))
252b5132
RH		 2677 return true;
2678
2679 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
2680 &found, filename_ptr,
2681 functionname_ptr, line_ptr,
2682 &elf_tdata (abfd)->line_info))
2683 return false;
f21f3fe0 2684
252b5132
RH		 2685 if (found)
2686 return true;
2687
2688 if (symbols == NULL)
2689 return false;
2690
2691 filename = NULL;
2692 func = NULL;
2693 low_func = 0;
2694
2695 for (p = symbols; *p != NULL; p++)
2696 {
2697 elf_symbol_type *q;
2698
2699 q = (elf_symbol_type *) *p;
2700
2701 if (bfd_get_section (&q->symbol) != section)
2702 continue;
2703
2704 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
2705 {
2706 default:
2707 break;
2708 case STT_FILE:
2709 filename = bfd_asymbol_name (&q->symbol);
2710 break;
2711 case STT_NOTYPE:
2712 case STT_FUNC:
2713 case STT_ARM_TFUNC:
2714 if (q->symbol.section == section
2715 && q->symbol.value >= low_func
2716 && q->symbol.value <= offset)
2717 {
2718 func = (asymbol *) q;
2719 low_func = q->symbol.value;
2720 }
2721 break;
2722 }
2723 }
2724
2725 if (func == NULL)
2726 return false;
2727
2728 *filename_ptr = filename;
2729 *functionname_ptr = bfd_asymbol_name (func);
2730 *line_ptr = 0;
f21f3fe0 2731
252b5132
RH		 2732 return true;
2733}
2734
2735/* Adjust a symbol defined by a dynamic object and referenced by a
2736 regular object. The current definition is in some section of the
2737 dynamic object, but we're not including those sections. We have to
2738 change the definition to something the rest of the link can
2739 understand. */
2740
2741static boolean
2742elf32_arm_adjust_dynamic_symbol (info, h)
2743 struct bfd_link_info * info;
2744 struct elf_link_hash_entry * h;
2745{
2746 bfd * dynobj;
2747 asection * s;
2748 unsigned int power_of_two;
2749
2750 dynobj = elf_hash_table (info)->dynobj;
2751
2752 /* Make sure we know what is going on here. */
2753 BFD_ASSERT (dynobj != NULL
2754 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
2755 || h->weakdef != NULL
2756 || ((h->elf_link_hash_flags
2757 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2758 && (h->elf_link_hash_flags
2759 & ELF_LINK_HASH_REF_REGULAR) != 0
2760 && (h->elf_link_hash_flags
2761 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
2762
2763 /* If this is a function, put it in the procedure linkage table. We
2764 will fill in the contents of the procedure linkage table later,
2765 when we know the address of the .got section. */
2766 if (h->type == STT_FUNC
2767 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2768 {
2769 if (! info->shared
2770 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
2771 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
2772 {
2773 /* This case can occur if we saw a PLT32 reloc in an input
2774 file, but the symbol was never referred to by a dynamic
2775 object. In such a case, we don't actually need to build
2776 a procedure linkage table, and we can just do a PC32
2777 reloc instead. */
2778 BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
2779 return true;
2780 }
2781
2782 /* Make sure this symbol is output as a dynamic symbol. */
2783 if (h->dynindx == -1)
2784 {
2785 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2786 return false;
2787 }
2788
2789 s = bfd_get_section_by_name (dynobj, ".plt");
2790 BFD_ASSERT (s != NULL);
2791
2792 /* If this is the first .plt entry, make room for the special
2793 first entry. */
2794 if (s->_raw_size == 0)
2795 s->_raw_size += PLT_ENTRY_SIZE;
2796
2797 /* If this symbol is not defined in a regular file, and we are
2798 not generating a shared library, then set the symbol to this
2799 location in the .plt. This is required to make function
2800 pointers compare as equal between the normal executable and
2801 the shared library. */
2802 if (! info->shared
2803 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2804 {
2805 h->root.u.def.section = s;
2806 h->root.u.def.value = s->_raw_size;
2807 }
2808
2809 h->plt.offset = s->_raw_size;
2810
2811 /* Make room for this entry. */
2812 s->_raw_size += PLT_ENTRY_SIZE;
2813
2814 /* We also need to make an entry in the .got.plt section, which
2815 will be placed in the .got section by the linker script. */
252b5132
RH		 2816 s = bfd_get_section_by_name (dynobj, ".got.plt");
2817 BFD_ASSERT (s != NULL);
2818 s->_raw_size += 4;
2819
2820 /* We also need to make an entry in the .rel.plt section. */
2821
2822 s = bfd_get_section_by_name (dynobj, ".rel.plt");
2823 BFD_ASSERT (s != NULL);
2824 s->_raw_size += sizeof (Elf32_External_Rel);
2825
2826 return true;
2827 }
2828
2829 /* If this is a weak symbol, and there is a real definition, the
2830 processor independent code will have arranged for us to see the
2831 real definition first, and we can just use the same value. */
2832 if (h->weakdef != NULL)
2833 {
2834 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2835 || h->weakdef->root.type == bfd_link_hash_defweak);
2836 h->root.u.def.section = h->weakdef->root.u.def.section;
2837 h->root.u.def.value = h->weakdef->root.u.def.value;
2838 return true;
2839 }
2840
2841 /* This is a reference to a symbol defined by a dynamic object which
2842 is not a function. */
2843
2844 /* If we are creating a shared library, we must presume that the
2845 only references to the symbol are via the global offset table.
2846 For such cases we need not do anything here; the relocations will
2847 be handled correctly by relocate_section. */
2848 if (info->shared)
2849 return true;
2850
2851 /* We must allocate the symbol in our .dynbss section, which will
2852 become part of the .bss section of the executable. There will be
2853 an entry for this symbol in the .dynsym section. The dynamic
2854 object will contain position independent code, so all references
2855 from the dynamic object to this symbol will go through the global
2856 offset table. The dynamic linker will use the .dynsym entry to
2857 determine the address it must put in the global offset table, so
2858 both the dynamic object and the regular object will refer to the
2859 same memory location for the variable. */
252b5132
RH		 2860 s = bfd_get_section_by_name (dynobj, ".dynbss");
2861 BFD_ASSERT (s != NULL);
2862
2863 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
2864 copy the initial value out of the dynamic object and into the
2865 runtime process image. We need to remember the offset into the
2866 .rel.bss section we are going to use. */
2867 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2868 {
2869 asection *srel;
2870
2871 srel = bfd_get_section_by_name (dynobj, ".rel.bss");
2872 BFD_ASSERT (srel != NULL);
2873 srel->_raw_size += sizeof (Elf32_External_Rel);
2874 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
2875 }
2876
2877 /* We need to figure out the alignment required for this symbol. I
2878 have no idea how ELF linkers handle this. */
2879 power_of_two = bfd_log2 (h->size);
2880 if (power_of_two > 3)
2881 power_of_two = 3;
2882
2883 /* Apply the required alignment. */
2884 s->_raw_size = BFD_ALIGN (s->_raw_size,
2885 (bfd_size_type) (1 << power_of_two));
2886 if (power_of_two > bfd_get_section_alignment (dynobj, s))
2887 {
2888 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
2889 return false;
2890 }
2891
2892 /* Define the symbol as being at this point in the section. */
2893 h->root.u.def.section = s;
2894 h->root.u.def.value = s->_raw_size;
2895
2896 /* Increment the section size to make room for the symbol. */
2897 s->_raw_size += h->size;
2898
2899 return true;
2900}
2901
2902/* Set the sizes of the dynamic sections. */
2903
2904static boolean
2905elf32_arm_size_dynamic_sections (output_bfd, info)
2906 bfd * output_bfd;
2907 struct bfd_link_info * info;
2908{
2909 bfd * dynobj;
2910 asection * s;
2911 boolean plt;
2912 boolean relocs;
2913 boolean reltext;
2914
2915 dynobj = elf_hash_table (info)->dynobj;
2916 BFD_ASSERT (dynobj != NULL);
2917
2918 if (elf_hash_table (info)->dynamic_sections_created)
2919 {
2920 /* Set the contents of the .interp section to the interpreter. */
2921 if (! info->shared)
2922 {
2923 s = bfd_get_section_by_name (dynobj, ".interp");
2924 BFD_ASSERT (s != NULL);
2925 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
2926 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2927 }
2928 }
2929 else
2930 {
2931 /* We may have created entries in the .rel.got section.
2932 However, if we are not creating the dynamic sections, we will
2933 not actually use these entries. Reset the size of .rel.got,
2934 which will cause it to get stripped from the output file
2935 below. */
2936 s = bfd_get_section_by_name (dynobj, ".rel.got");
2937 if (s != NULL)
2938 s->_raw_size = 0;
2939 }
2940
2941 /* If this is a -Bsymbolic shared link, then we need to discard all
2942 PC relative relocs against symbols defined in a regular object.
2943 We allocated space for them in the check_relocs routine, but we
2944 will not fill them in in the relocate_section routine. */
2945 if (info->shared && info->symbolic)
2946 elf32_arm_link_hash_traverse (elf32_arm_hash_table (info),
2947 elf32_arm_discard_copies,
2948 (PTR) NULL);
2949
2950 /* The check_relocs and adjust_dynamic_symbol entry points have
2951 determined the sizes of the various dynamic sections. Allocate
2952 memory for them. */
2953 plt = false;
2954 relocs = false;
2955 reltext = false;
2956 for (s = dynobj->sections; s != NULL; s = s->next)
2957 {
2958 const char * name;
2959 boolean strip;
2960
2961 if ((s->flags & SEC_LINKER_CREATED) == 0)
2962 continue;
2963
2964 /* It's OK to base decisions on the section name, because none
2965 of the dynobj section names depend upon the input files. */
2966 name = bfd_get_section_name (dynobj, s);
2967
2968 strip = false;
2969
2970 if (strcmp (name, ".plt") == 0)
2971 {
2972 if (s->_raw_size == 0)
2973 {
2974 /* Strip this section if we don't need it; see the
2975 comment below. */
2976 strip = true;
2977 }
2978 else
2979 {
2980 /* Remember whether there is a PLT. */
2981 plt = true;
2982 }
2983 }
2984 else if (strncmp (name, ".rel", 4) == 0)
2985 {
2986 if (s->_raw_size == 0)
2987 {
2988 /* If we don't need this section, strip it from the
2989 output file. This is mostly to handle .rel.bss and
2990 .rel.plt. We must create both sections in
2991 create_dynamic_sections, because they must be created
2992 before the linker maps input sections to output
2993 sections. The linker does that before
2994 adjust_dynamic_symbol is called, and it is that
2995 function which decides whether anything needs to go
2996 into these sections. */
2997 strip = true;
2998 }
2999 else
3000 {
3001 asection * target;
3002
3003 /* Remember whether there are any reloc sections other
3004 than .rel.plt. */
3005 if (strcmp (name, ".rel.plt") != 0)
3006 {
3007 const char *outname;
3008
3009 relocs = true;
3010
3011 /* If this relocation section applies to a read only
3012 section, then we probably need a DT_TEXTREL
3013 entry. The entries in the .rel.plt section
3014 really apply to the .got section, which we
3015 created ourselves and so know is not readonly. */
3016 outname = bfd_get_section_name (output_bfd,
3017 s->output_section);
3018 target = bfd_get_section_by_name (output_bfd, outname + 4);
9a5aca8c 3019
252b5132
RH		 3020 if (target != NULL
3021 && (target->flags & SEC_READONLY) != 0
3022 && (target->flags & SEC_ALLOC) != 0)
3023 reltext = true;
3024 }
3025
3026 /* We use the reloc_count field as a counter if we need
3027 to copy relocs into the output file. */
3028 s->reloc_count = 0;
3029 }
3030 }
3031 else if (strncmp (name, ".got", 4) != 0)
3032 {
3033 /* It's not one of our sections, so don't allocate space. */
3034 continue;
3035 }
3036
3037 if (strip)
3038 {
3039 asection ** spp;
3040
3041 for (spp = &s->output_section->owner->sections;
3042 *spp != s->output_section;
3043 spp = &(*spp)->next)
3044 ;
3045 *spp = s->output_section->next;
3046 --s->output_section->owner->section_count;
3047
3048 continue;
3049 }
3050
3051 /* Allocate memory for the section contents. */
3052 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
3053 if (s->contents == NULL && s->_raw_size != 0)
3054 return false;
3055 }
3056
3057 if (elf_hash_table (info)->dynamic_sections_created)
3058 {
3059 /* Add some entries to the .dynamic section. We fill in the
3060 values later, in elf32_arm_finish_dynamic_sections, but we
3061 must add the entries now so that we get the correct size for
3062 the .dynamic section. The DT_DEBUG entry is filled in by the
3063 dynamic linker and used by the debugger. */
3064 if (! info->shared)
3065 {
3066 if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
3067 return false;
3068 }
3069
3070 if (plt)
3071 {
9b485d32 3072 if ( ! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
252b5132
RH		 3073 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
3074 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_REL)
3075 || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
3076 return false;
3077 }
3078
3079 if (relocs)
3080 {
9b485d32 3081 if ( ! bfd_elf32_add_dynamic_entry (info, DT_REL, 0)
252b5132
RH		 3082 || ! bfd_elf32_add_dynamic_entry (info, DT_RELSZ, 0)
3083 || ! bfd_elf32_add_dynamic_entry (info, DT_RELENT,
3084 sizeof (Elf32_External_Rel)))
3085 return false;
3086 }
3087
3088 if (reltext)
3089 {
3090 if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
3091 return false;
d6cf2879 3092 info->flags |= DF_TEXTREL;
252b5132
RH		 3093 }
3094 }
3095
3096 return true;
3097}
3098
3099/* This function is called via elf32_arm_link_hash_traverse if we are
3100 creating a shared object with -Bsymbolic. It discards the space
3101 allocated to copy PC relative relocs against symbols which are
3102 defined in regular objects. We allocated space for them in the
3103 check_relocs routine, but we won't fill them in in the
3104 relocate_section routine. */
3105
3106static boolean
3107elf32_arm_discard_copies (h, ignore)
3108 struct elf32_arm_link_hash_entry * h;
5f771d47 3109 PTR ignore ATTRIBUTE_UNUSED;
252b5132
RH		 3110{
3111 struct elf32_arm_pcrel_relocs_copied * s;
3112
3113 /* We only discard relocs for symbols defined in a regular object. */
3114 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3115 return true;
3116
3117 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
3118 s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
3119
3120 return true;
3121}
3122
3123/* Finish up dynamic symbol handling. We set the contents of various
3124 dynamic sections here. */
3125
3126static boolean
3127elf32_arm_finish_dynamic_symbol (output_bfd, info, h, sym)
3128 bfd * output_bfd;
3129 struct bfd_link_info * info;
3130 struct elf_link_hash_entry * h;
3131 Elf_Internal_Sym * sym;
3132{
3133 bfd * dynobj;
3134
3135 dynobj = elf_hash_table (info)->dynobj;
3136
3137 if (h->plt.offset != (bfd_vma) -1)
3138 {
3139 asection * splt;
3140 asection * sgot;
3141 asection * srel;
3142 bfd_vma plt_index;
3143 bfd_vma got_offset;
3144 Elf_Internal_Rel rel;
3145
3146 /* This symbol has an entry in the procedure linkage table. Set
3147 it up. */
3148
3149 BFD_ASSERT (h->dynindx != -1);
3150
3151 splt = bfd_get_section_by_name (dynobj, ".plt");
3152 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3153 srel = bfd_get_section_by_name (dynobj, ".rel.plt");
3154 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
3155
3156 /* Get the index in the procedure linkage table which
3157 corresponds to this symbol. This is the index of this symbol
3158 in all the symbols for which we are making plt entries. The
3159 first entry in the procedure linkage table is reserved. */
3160 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3161
3162 /* Get the offset into the .got table of the entry that
3163 corresponds to this function. Each .got entry is 4 bytes.
3164 The first three are reserved. */
3165 got_offset = (plt_index + 3) * 4;
3166
3167 /* Fill in the entry in the procedure linkage table. */
3168 memcpy (splt->contents + h->plt.offset,
3169 elf32_arm_plt_entry,
3170 PLT_ENTRY_SIZE);
3171 bfd_put_32 (output_bfd,
3172 (sgot->output_section->vma
3173 + sgot->output_offset
f21f3fe0 3174 + got_offset
252b5132
RH		 3175 - splt->output_section->vma
3176 - splt->output_offset
3177 - h->plt.offset - 12),
3178 splt->contents + h->plt.offset + 12);
3179
3180 /* Fill in the entry in the global offset table. */
3181 bfd_put_32 (output_bfd,
3182 (splt->output_section->vma
3183 + splt->output_offset),
3184 sgot->contents + got_offset);
3185
3186 /* Fill in the entry in the .rel.plt section. */
3187 rel.r_offset = (sgot->output_section->vma
3188 + sgot->output_offset
3189 + got_offset);
3190 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
3191 bfd_elf32_swap_reloc_out (output_bfd, &rel,
3192 ((Elf32_External_Rel *) srel->contents
3193 + plt_index));
3194
3195 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3196 {
3197 /* Mark the symbol as undefined, rather than as defined in
3198 the .plt section. Leave the value alone. */
3199 sym->st_shndx = SHN_UNDEF;
d982ba73
PB		 3200 /* If the symbol is weak, we do need to clear the value.
3201 Otherwise, the PLT entry would provide a definition for
3202 the symbol even if the symbol wasn't defined anywhere,
3203 and so the symbol would never be NULL. */
3204 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
3205 == 0)
3206 sym->st_value = 0;
252b5132
RH		 3207 }
3208 }
3209
3210 if (h->got.offset != (bfd_vma) -1)
3211 {
3212 asection * sgot;
3213 asection * srel;
3214 Elf_Internal_Rel rel;
3215
3216 /* This symbol has an entry in the global offset table. Set it
3217 up. */
252b5132
RH		 3218 sgot = bfd_get_section_by_name (dynobj, ".got");
3219 srel = bfd_get_section_by_name (dynobj, ".rel.got");
3220 BFD_ASSERT (sgot != NULL && srel != NULL);
3221
3222 rel.r_offset = (sgot->output_section->vma
3223 + sgot->output_offset
3224 + (h->got.offset &~ 1));
3225
3226 /* If this is a -Bsymbolic link, and the symbol is defined
3227 locally, we just want to emit a RELATIVE reloc. The entry in
3228 the global offset table will already have been initialized in
3229 the relocate_section function. */
3230 if (info->shared
3231 && (info->symbolic || h->dynindx == -1)
3232 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3233 rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
3234 else
3235 {
3236 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
3237 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
3238 }
3239
3240 bfd_elf32_swap_reloc_out (output_bfd, &rel,
3241 ((Elf32_External_Rel *) srel->contents
3242 + srel->reloc_count));
3243 ++srel->reloc_count;
3244 }
3245
3246 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
3247 {
3248 asection * s;
3249 Elf_Internal_Rel rel;
3250
3251 /* This symbol needs a copy reloc. Set it up. */
252b5132
RH		 3252 BFD_ASSERT (h->dynindx != -1
3253 && (h->root.type == bfd_link_hash_defined
3254 || h->root.type == bfd_link_hash_defweak));
3255
3256 s = bfd_get_section_by_name (h->root.u.def.section->owner,
3257 ".rel.bss");
3258 BFD_ASSERT (s != NULL);
3259
3260 rel.r_offset = (h->root.u.def.value
3261 + h->root.u.def.section->output_section->vma
3262 + h->root.u.def.section->output_offset);
3263 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
3264 bfd_elf32_swap_reloc_out (output_bfd, &rel,
3265 ((Elf32_External_Rel *) s->contents
3266 + s->reloc_count));
3267 ++s->reloc_count;
3268 }
3269
3270 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3271 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3272 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3273 sym->st_shndx = SHN_ABS;
3274
3275 return true;
3276}
3277
3278/* Finish up the dynamic sections. */
3279
3280static boolean
3281elf32_arm_finish_dynamic_sections (output_bfd, info)
3282 bfd * output_bfd;
3283 struct bfd_link_info * info;
3284{
3285 bfd * dynobj;
3286 asection * sgot;
3287 asection * sdyn;
3288
3289 dynobj = elf_hash_table (info)->dynobj;
3290
3291 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3292 BFD_ASSERT (sgot != NULL);
3293 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3294
3295 if (elf_hash_table (info)->dynamic_sections_created)
3296 {
3297 asection *splt;
3298 Elf32_External_Dyn *dyncon, *dynconend;
3299
3300 splt = bfd_get_section_by_name (dynobj, ".plt");
3301 BFD_ASSERT (splt != NULL && sdyn != NULL);
3302
3303 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3304 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
9b485d32 3305
252b5132
RH		 3306 for (; dyncon < dynconend; dyncon++)
3307 {
3308 Elf_Internal_Dyn dyn;
3309 const char * name;
3310 asection * s;
3311
3312 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3313
3314 switch (dyn.d_tag)
3315 {
3316 default:
3317 break;
3318
3319 case DT_PLTGOT:
3320 name = ".got";
3321 goto get_vma;
3322 case DT_JMPREL:
3323 name = ".rel.plt";
3324 get_vma:
3325 s = bfd_get_section_by_name (output_bfd, name);
3326 BFD_ASSERT (s != NULL);
3327 dyn.d_un.d_ptr = s->vma;
3328 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3329 break;
3330
3331 case DT_PLTRELSZ:
3332 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3333 BFD_ASSERT (s != NULL);
3334 if (s->_cooked_size != 0)
3335 dyn.d_un.d_val = s->_cooked_size;
3336 else
3337 dyn.d_un.d_val = s->_raw_size;
3338 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3339 break;
3340
3341 case DT_RELSZ:
3342 /* My reading of the SVR4 ABI indicates that the
3343 procedure linkage table relocs (DT_JMPREL) should be
3344 included in the overall relocs (DT_REL). This is
3345 what Solaris does. However, UnixWare can not handle
3346 that case. Therefore, we override the DT_RELSZ entry
3347 here to make it not include the JMPREL relocs. Since
3348 the linker script arranges for .rel.plt to follow all
3349 other relocation sections, we don't have to worry
3350 about changing the DT_REL entry. */
3351 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3352 if (s != NULL)
3353 {
3354 if (s->_cooked_size != 0)
3355 dyn.d_un.d_val -= s->_cooked_size;
3356 else
3357 dyn.d_un.d_val -= s->_raw_size;
3358 }
3359 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3360 break;
3361 }
3362 }
3363
3364 /* Fill in the first entry in the procedure linkage table. */
3365 if (splt->_raw_size > 0)
3366 memcpy (splt->contents, elf32_arm_plt0_entry, PLT_ENTRY_SIZE);
3367
3368 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3369 really seem like the right value. */
3370 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
3371 }
3372
3373 /* Fill in the first three entries in the global offset table. */
3374 if (sgot->_raw_size > 0)
3375 {
3376 if (sdyn == NULL)
3377 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
3378 else
3379 bfd_put_32 (output_bfd,
3380 sdyn->output_section->vma + sdyn->output_offset,
3381 sgot->contents);
3382 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
3383 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3384 }
3385
3386 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
3387
3388 return true;
3389}
3390
ba96a88f
NC		 3391static void
3392elf32_arm_post_process_headers (abfd, link_info)
3393 bfd * abfd;
5f771d47 3394 struct bfd_link_info * link_info ATTRIBUTE_UNUSED;
ba96a88f 3395{
9b485d32 3396 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
ba96a88f
NC		 3397
3398 i_ehdrp = elf_elfheader (abfd);
3399
3400 i_ehdrp->e_ident[EI_OSABI] = ARM_ELF_OS_ABI_VERSION;
3401 i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
3402}
3403
252b5132
RH		 3404#define ELF_ARCH bfd_arch_arm
3405#define ELF_MACHINE_CODE EM_ARM
f21f3fe0 3406#define ELF_MAXPAGESIZE 0x8000
252b5132 3407
252b5132
RH		 3408#define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
3409#define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
3410#define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
3411#define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
3412#define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
3413#define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
3414#define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
3415
3416#define elf_backend_get_symbol_type elf32_arm_get_symbol_type
3417#define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
3418#define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
3419#define elf_backend_check_relocs elf32_arm_check_relocs
3420#define elf_backend_relocate_section elf32_arm_relocate_section
3421#define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
3422#define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
3423#define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
3424#define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
3425#define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
ba96a88f 3426#define elf_backend_post_process_headers elf32_arm_post_process_headers
252b5132
RH		 3427
3428#define elf_backend_can_gc_sections 1
3429#define elf_backend_plt_readonly 1
3430#define elf_backend_want_got_plt 1
3431#define elf_backend_want_plt_sym 0
3432
04f7c78d
NC		 3433#define elf_backend_got_header_size 12
3434#define elf_backend_plt_header_size PLT_ENTRY_SIZE
3435
252b5132 3436#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.229792 seconds and 4 git commands to generate.