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