projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* emultempl/elf32.em (ld_${EMULATION_NAME}_emulation): Add missing
[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;
a72747a3
NC		 1736 else if (info->shared && !info->symbolic && !info->no_undefined)
1737 relocation = 0;
252b5132
RH		 1738 else
1739 {
1740 if (!((*info->callbacks->undefined_symbol)
1741 (info, h->root.root.string, input_bfd,
1742 input_section, rel->r_offset)))
1743 return false;
1744 relocation = 0;
1745 }
1746 }
1747
1748 if (h != NULL)
1749 name = h->root.root.string;
1750 else
1751 {
1752 name = (bfd_elf_string_from_elf_section
1753 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1754 if (name == NULL || *name == '\0')
1755 name = bfd_section_name (input_bfd, sec);
1756 }
f21f3fe0 1757
252b5132
RH		 1758 r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
1759 input_section, contents, rel,
1760 relocation, info, sec, name,
1761 (h ? ELF_ST_TYPE (h->type) :
780a67af 1762 ELF_ST_TYPE (sym->st_info)), h);
252b5132
RH		 1763
1764 if (r != bfd_reloc_ok)
1765 {
1766 const char * msg = (const char *) 0;
1767
1768 switch (r)
1769 {
1770 case bfd_reloc_overflow:
1771 if (!((*info->callbacks->reloc_overflow)
1772 (info, name, howto->name, (bfd_vma) 0,
1773 input_bfd, input_section, rel->r_offset)))
1774 return false;
1775 break;
1776
1777 case bfd_reloc_undefined:
1778 if (!((*info->callbacks->undefined_symbol)
1779 (info, name, input_bfd, input_section,
1780 rel->r_offset)))
1781 return false;
1782 break;
1783
1784 case bfd_reloc_outofrange:
1785 msg = _ ("internal error: out of range error");
1786 goto common_error;
1787
1788 case bfd_reloc_notsupported:
1789 msg = _ ("internal error: unsupported relocation error");
1790 goto common_error;
1791
1792 case bfd_reloc_dangerous:
1793 msg = _ ("internal error: dangerous error");
1794 goto common_error;
1795
1796 default:
1797 msg = _ ("internal error: unknown error");
1798 /* fall through */
1799
1800 common_error:
1801 if (!((*info->callbacks->warning)
1802 (info, msg, name, input_bfd, input_section,
1803 rel->r_offset)))
1804 return false;
1805 break;
1806 }
1807 }
1808 }
1809
1810 return true;
1811}
1812
1813/* Function to keep ARM specific flags in the ELF header. */
1814static boolean
1815elf32_arm_set_private_flags (abfd, flags)
1816 bfd *abfd;
1817 flagword flags;
1818{
1819 if (elf_flags_init (abfd)
1820 && elf_elfheader (abfd)->e_flags != flags)
1821 {
1822 if (flags & EF_INTERWORK)
1823 _bfd_error_handler (_ ("\
1824Warning: Not setting interwork flag of %s since it has already been specified as non-interworking"),
1825 bfd_get_filename (abfd));
1826 else
1827 _bfd_error_handler (_ ("\
1828Warning: Clearing the interwork flag of %s due to outside request"),
1829 bfd_get_filename (abfd));
1830 }
1831 else
1832 {
1833 elf_elfheader (abfd)->e_flags = flags;
1834 elf_flags_init (abfd) = true;
1835 }
1836
1837 return true;
1838}
1839
1840/* Copy backend specific data from one object module to another */
1841static boolean
1842elf32_arm_copy_private_bfd_data (ibfd, obfd)
1843 bfd *ibfd;
1844 bfd *obfd;
1845{
1846 flagword in_flags;
1847 flagword out_flags;
1848
1849 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1850 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1851 return true;
1852
1853 in_flags = elf_elfheader (ibfd)->e_flags;
1854 out_flags = elf_elfheader (obfd)->e_flags;
1855
1856 if (elf_flags_init (obfd) && in_flags != out_flags)
1857 {
1858 /* Cannot mix PIC and non-PIC code. */
1859 if ((in_flags & EF_PIC) != (out_flags & EF_PIC))
1860 return false;
1861
1862 /* Cannot mix APCS26 and APCS32 code. */
1863 if ((in_flags & EF_APCS_26) != (out_flags & EF_APCS_26))
1864 return false;
1865
1866 /* Cannot mix float APCS and non-float APCS code. */
1867 if ((in_flags & EF_APCS_FLOAT) != (out_flags & EF_APCS_FLOAT))
1868 return false;
1869
1870 /* If the src and dest have different interworking flags
1871 then turn off the interworking bit. */
1872 if ((in_flags & EF_INTERWORK) != (out_flags & EF_INTERWORK))
1873 {
1874 if (out_flags & EF_INTERWORK)
1875 _bfd_error_handler (_ ("\
1876Warning: Clearing the interwork flag in %s because non-interworking code in %s has been linked with it"),
1877 bfd_get_filename (obfd), bfd_get_filename (ibfd));
1878
1879 in_flags &= ~EF_INTERWORK;
1880 }
1881 }
1882
1883 elf_elfheader (obfd)->e_flags = in_flags;
1884 elf_flags_init (obfd) = true;
1885
1886 return true;
1887}
1888
1889/* Merge backend specific data from an object file to the output
1890 object file when linking. */
1891static boolean
1892elf32_arm_merge_private_bfd_data (ibfd, obfd)
1893 bfd *ibfd;
1894 bfd *obfd;
1895{
1896 flagword out_flags;
1897 flagword in_flags;
1898
1899 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1900 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1901 return true;
1902
1903 /* Check if we have the same endianess */
1904 if ( ibfd->xvec->byteorder != obfd->xvec->byteorder
1905 && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
1906 && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
1907 {
1908 (*_bfd_error_handler)
1909 (_("%s: compiled for a %s endian system and target is %s endian"),
1910 bfd_get_filename (ibfd),
1911 bfd_big_endian (ibfd) ? "big" : "little",
1912 bfd_big_endian (obfd) ? "big" : "little");
1913
1914 bfd_set_error (bfd_error_wrong_format);
1915 return false;
1916 }
1917
1918 /* The input BFD must have had its flags initialised. */
1919 /* The following seems bogus to me -- The flags are initialized in
1920 the assembler but I don't think an elf_flags_init field is
1921 written into the object */
1922 /* BFD_ASSERT (elf_flags_init (ibfd)); */
1923
1924 in_flags = elf_elfheader (ibfd)->e_flags;
1925 out_flags = elf_elfheader (obfd)->e_flags;
1926
1927 if (!elf_flags_init (obfd))
1928 {
1929 /* If the input is the default architecture then do not
1930 bother setting the flags for the output architecture,
1931 instead allow future merges to do this. If no future
1932 merges ever set these flags then they will retain their
1933 unitialised values, which surprise surprise, correspond
1934 to the default values. */
1935 if (bfd_get_arch_info (ibfd)->the_default)
1936 return true;
1937
1938 elf_flags_init (obfd) = true;
1939 elf_elfheader (obfd)->e_flags = in_flags;
1940
1941 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
1942 && bfd_get_arch_info (obfd)->the_default)
1943 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
1944
1945 return true;
1946 }
1947
1948 /* Check flag compatibility. */
1949 if (in_flags == out_flags)
1950 return true;
1951
1952 /* Complain about various flag mismatches. */
1953
1954 if ((in_flags & EF_APCS_26) != (out_flags & EF_APCS_26))
1955 _bfd_error_handler (_ ("\
1956Error: %s compiled for APCS-%d, whereas %s is compiled for APCS-%d"),
1957 bfd_get_filename (ibfd),
1958 in_flags & EF_APCS_26 ? 26 : 32,
1959 bfd_get_filename (obfd),
1960 out_flags & EF_APCS_26 ? 26 : 32);
1961
1962 if ((in_flags & EF_APCS_FLOAT) != (out_flags & EF_APCS_FLOAT))
1963 _bfd_error_handler (_ ("\
1964Error: %s passes floats in %s registers, whereas %s passes them in %s registers"),
1965 bfd_get_filename (ibfd),
1966 in_flags & EF_APCS_FLOAT ? _ ("float") : _ ("integer"),
1967 bfd_get_filename (obfd),
1968 out_flags & EF_APCS_26 ? _ ("float") : _ ("integer"));
1969
1970 if ((in_flags & EF_PIC) != (out_flags & EF_PIC))
1971 _bfd_error_handler (_ ("\
1972Error: %s is compiled as position %s code, whereas %s is not"),
1973 bfd_get_filename (ibfd),
1974 in_flags & EF_PIC ? _ ("independent") : _ ("dependent"),
1975 bfd_get_filename (obfd));
1976
1977 /* Interworking mismatch is only a warning. */
1978 if ((in_flags & EF_INTERWORK) != (out_flags & EF_INTERWORK))
1979 {
1980 _bfd_error_handler (_ ("\
1981Warning: %s %s interworking, whereas %s %s"),
1982 bfd_get_filename (ibfd),
1983 in_flags & EF_INTERWORK ? _ ("supports") : _ ("does not support"),
1984 bfd_get_filename (obfd),
1985 out_flags & EF_INTERWORK ? _ ("does not") : _ ("does"));
1986 return true;
1987 }
1988
1989 return false;
1990}
1991
1992/* Display the flags field */
1993static boolean
1994elf32_arm_print_private_bfd_data (abfd, ptr)
1995 bfd *abfd;
1996 PTR ptr;
1997{
1998 FILE *file = (FILE *) ptr;
1999
2000 BFD_ASSERT (abfd != NULL && ptr != NULL);
2001
2002 /* Print normal ELF private data. */
2003 _bfd_elf_print_private_bfd_data (abfd, ptr);
2004
2005 /* Ignore init flag - it may not be set, despite the flags field containing valid data. */
2006
2007 /* xgettext:c-format */
2008 fprintf (file, _ ("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
2009
2010 if (elf_elfheader (abfd)->e_flags & EF_INTERWORK)
2011 fprintf (file, _ (" [interworking enabled]"));
2012 else
2013 fprintf (file, _ (" [interworking not enabled]"));
2014
2015 if (elf_elfheader (abfd)->e_flags & EF_APCS_26)
2016 fprintf (file, _ (" [APCS-26]"));
2017 else
2018 fprintf (file, _ (" [APCS-32]"));
2019
2020 if (elf_elfheader (abfd)->e_flags & EF_APCS_FLOAT)
2021 fprintf (file, _ (" [floats passed in float registers]"));
2022 else
2023 fprintf (file, _ (" [floats passed in integer registers]"));
2024
2025 if (elf_elfheader (abfd)->e_flags & EF_PIC)
2026 fprintf (file, _ (" [position independent]"));
2027 else
2028 fprintf (file, _ (" [absolute position]"));
2029
2030 fputc ('\n', file);
2031
2032 return true;
2033}
2034
2035static int
2036elf32_arm_get_symbol_type (elf_sym, type)
2037 Elf_Internal_Sym * elf_sym;
2038 int type;
2039{
2040 if (ELF_ST_TYPE (elf_sym->st_info) == STT_ARM_TFUNC)
2041 return ELF_ST_TYPE (elf_sym->st_info);
2042 else
2043 return type;
2044}
f21f3fe0 2045
252b5132
RH		 2046static asection *
2047elf32_arm_gc_mark_hook (abfd, info, rel, h, sym)
2048 bfd *abfd;
2049 struct bfd_link_info *info;
2050 Elf_Internal_Rela *rel;
2051 struct elf_link_hash_entry *h;
2052 Elf_Internal_Sym *sym;
2053{
2054 if (h != NULL)
2055 {
2056 switch (ELF32_R_TYPE (rel->r_info))
2057 {
2058 case R_ARM_GNU_VTINHERIT:
2059 case R_ARM_GNU_VTENTRY:
2060 break;
2061
2062 default:
2063 switch (h->root.type)
2064 {
2065 case bfd_link_hash_defined:
2066 case bfd_link_hash_defweak:
2067 return h->root.u.def.section;
2068
2069 case bfd_link_hash_common:
2070 return h->root.u.c.p->section;
2071 }
2072 }
2073 }
2074 else
2075 {
2076 if (!(elf_bad_symtab (abfd)
2077 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
2078 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
2079 && sym->st_shndx != SHN_COMMON))
2080 {
2081 return bfd_section_from_elf_index (abfd, sym->st_shndx);
2082 }
2083 }
2084 return NULL;
2085}
2086
780a67af
NC		 2087/* Update the got entry reference counts for the section being removed. */
2088
252b5132
RH		 2089static boolean
2090elf32_arm_gc_sweep_hook (abfd, info, sec, relocs)
2091 bfd *abfd;
2092 struct bfd_link_info *info;
2093 asection *sec;
2094 const Elf_Internal_Rela *relocs;
2095{
780a67af 2096 /* We don't support garbage collection of GOT and PLT relocs yet. */
252b5132
RH		 2097 return true;
2098}
2099
780a67af
NC		 2100/* Look through the relocs for a section during the first phase. */
2101
252b5132
RH		 2102static boolean
2103elf32_arm_check_relocs (abfd, info, sec, relocs)
2104 bfd * abfd;
2105 struct bfd_link_info * info;
2106 asection * sec;
2107 const Elf_Internal_Rela * relocs;
2108{
2109 Elf_Internal_Shdr * symtab_hdr;
2110 struct elf_link_hash_entry ** sym_hashes;
2111 struct elf_link_hash_entry ** sym_hashes_end;
2112 const Elf_Internal_Rela * rel;
2113 const Elf_Internal_Rela * rel_end;
2114 bfd * dynobj;
2115 asection * sgot, *srelgot, *sreloc;
2116 bfd_vma * local_got_offsets;
dece4658 2117
252b5132
RH		 2118 if (info->relocateable)
2119 return true;
dece4658 2120
252b5132 2121 sgot = srelgot = sreloc = NULL;
dece4658 2122
252b5132
RH		 2123 dynobj = elf_hash_table (info)->dynobj;
2124 local_got_offsets = elf_local_got_offsets (abfd);
f21f3fe0 2125
252b5132
RH		 2126 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2127 sym_hashes = elf_sym_hashes (abfd);
2128 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);
2129 if (!elf_bad_symtab (abfd))
2130 sym_hashes_end -= symtab_hdr->sh_info;
dece4658 2131
252b5132
RH		 2132 rel_end = relocs + sec->reloc_count;
2133 for (rel = relocs; rel < rel_end; rel++)
2134 {
2135 struct elf_link_hash_entry *h;
2136 unsigned long r_symndx;
dece4658 2137
252b5132
RH		 2138 r_symndx = ELF32_R_SYM (rel->r_info);
2139 if (r_symndx < symtab_hdr->sh_info)
2140 h = NULL;
2141 else
2142 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
dece4658 2143
252b5132
RH		 2144 /* Some relocs require a global offset table. */
2145 if (dynobj == NULL)
2146 {
2147 switch (ELF32_R_TYPE (rel->r_info))
2148 {
2149 case R_ARM_GOT32:
2150 case R_ARM_GOTOFF:
2151 case R_ARM_GOTPC:
2152 elf_hash_table (info)->dynobj = dynobj = abfd;
2153 if (! _bfd_elf_create_got_section (dynobj, info))
2154 return false;
2155 break;
2156
2157 default:
2158 break;
2159 }
2160 }
2161
2162 switch (ELF32_R_TYPE (rel->r_info))
2163 {
2164 case R_ARM_GOT32:
2165 /* This symbol requires a global offset table entry. */
2166 if (sgot == NULL)
2167 {
2168 sgot = bfd_get_section_by_name (dynobj, ".got");
2169 BFD_ASSERT (sgot != NULL);
2170 }
2171
2172 /* Get the got relocation section if necessary. */
2173 if (srelgot == NULL
2174 && (h != NULL || info->shared))
2175 {
2176 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
dece4658 2177
252b5132
RH		 2178 /* If no got relocation section, make one and initialize. */
2179 if (srelgot == NULL)
2180 {
2181 srelgot = bfd_make_section (dynobj, ".rel.got");
2182 if (srelgot == NULL
2183 || ! bfd_set_section_flags (dynobj, srelgot,
2184 (SEC_ALLOC
2185 | SEC_LOAD
2186 | SEC_HAS_CONTENTS
2187 | SEC_IN_MEMORY
2188 | SEC_LINKER_CREATED
2189 | SEC_READONLY))
2190 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
2191 return false;
2192 }
2193 }
2194
2195 if (h != NULL)
2196 {
2197 if (h->got.offset != (bfd_vma) -1)
2198 /* We have already allocated space in the .got. */
2199 break;
f21f3fe0 2200
252b5132
RH		 2201 h->got.offset = sgot->_raw_size;
2202
2203 /* Make sure this symbol is output as a dynamic symbol. */
2204 if (h->dynindx == -1)
2205 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2206 return false;
2207
2208 srelgot->_raw_size += sizeof (Elf32_External_Rel);
2209 }
2210 else
2211 {
2212 /* This is a global offset table entry for a local
2213 symbol. */
2214 if (local_got_offsets == NULL)
2215 {
2216 size_t size;
2217 register unsigned int i;
2218
2219 size = symtab_hdr->sh_info * sizeof (bfd_vma);
2220 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
2221 if (local_got_offsets == NULL)
2222 return false;
2223 elf_local_got_offsets (abfd) = local_got_offsets;
2224 for (i = 0; i < symtab_hdr->sh_info; i++)
2225 local_got_offsets[i] = (bfd_vma) -1;
2226 }
f21f3fe0 2227
252b5132
RH		 2228 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
2229 /* We have already allocated space in the .got. */
2230 break;
2231
2232 local_got_offsets[r_symndx] = sgot->_raw_size;
2233
2234 if (info->shared)
2235 /* If we are generating a shared object, we need to
2236 output a R_ARM_RELATIVE reloc so that the dynamic
2237 linker can adjust this GOT entry. */
2238 srelgot->_raw_size += sizeof (Elf32_External_Rel);
2239 }
2240
2241 sgot->_raw_size += 4;
2242 break;
2243
2244 case R_ARM_PLT32:
2245 /* This symbol requires a procedure linkage table entry. We
2246 actually build the entry in adjust_dynamic_symbol,
2247 because this might be a case of linking PIC code which is
2248 never referenced by a dynamic object, in which case we
2249 don't need to generate a procedure linkage table entry
2250 after all. */
2251
2252 /* If this is a local symbol, we resolve it directly without
2253 creating a procedure linkage table entry. */
2254 if (h == NULL)
2255 continue;
2256
2257 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2258 break;
2259
2260 case R_ARM_ABS32:
2261 case R_ARM_REL32:
2262 case R_ARM_PC24:
2263 /* If we are creating a shared library, and this is a reloc
2264 against a global symbol, or a non PC relative reloc
2265 against a local symbol, then we need to copy the reloc
2266 into the shared library. However, if we are linking with
2267 -Bsymbolic, we do not need to copy a reloc against a
2268 global symbol which is defined in an object we are
2269 including in the link (i.e., DEF_REGULAR is set). At
2270 this point we have not seen all the input files, so it is
2271 possible that DEF_REGULAR is not set now but will be set
2272 later (it is never cleared). We account for that
2273 possibility below by storing information in the
2274 pcrel_relocs_copied field of the hash table entry. */
2275 if (info->shared
2276 && (ELF32_R_TYPE (rel->r_info) != R_ARM_PC24
2277 || (h != NULL
2278 && (! info->symbolic
2279 || (h->elf_link_hash_flags
2280 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2281 {
2282 /* When creating a shared object, we must copy these
2283 reloc types into the output file. We create a reloc
2284 section in dynobj and make room for this reloc. */
2285 if (sreloc == NULL)
2286 {
2287 const char * name;
2288
2289 name = (bfd_elf_string_from_elf_section
2290 (abfd,
2291 elf_elfheader (abfd)->e_shstrndx,
2292 elf_section_data (sec)->rel_hdr.sh_name));
2293 if (name == NULL)
2294 return false;
2295
2296 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
2297 && strcmp (bfd_get_section_name (abfd, sec),
2298 name + 4) == 0);
2299
2300 sreloc = bfd_get_section_by_name (dynobj, name);
2301 if (sreloc == NULL)
2302 {
2303 flagword flags;
2304
2305 sreloc = bfd_make_section (dynobj, name);
2306 flags = (SEC_HAS_CONTENTS | SEC_READONLY
2307 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2308 if ((sec->flags & SEC_ALLOC) != 0)
2309 flags |= SEC_ALLOC | SEC_LOAD;
2310 if (sreloc == NULL
2311 || ! bfd_set_section_flags (dynobj, sreloc, flags)
2312 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
2313 return false;
2314 }
2315 }
2316
2317 sreloc->_raw_size += sizeof (Elf32_External_Rel);
2318 /* If we are linking with -Bsymbolic, and this is a
2319 global symbol, we count the number of PC relative
2320 relocations we have entered for this symbol, so that
2321 we can discard them again if the symbol is later
2322 defined by a regular object. Note that this function
2323 is only called if we are using an elf_i386 linker
2324 hash table, which means that h is really a pointer to
2325 an elf_i386_link_hash_entry. */
2326 if (h != NULL && info->symbolic
2327 && ELF32_R_TYPE (rel->r_info) == R_ARM_PC24)
2328 {
2329 struct elf32_arm_link_hash_entry * eh;
2330 struct elf32_arm_pcrel_relocs_copied * p;
2331
2332 eh = (struct elf32_arm_link_hash_entry *) h;
2333
2334 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
2335 if (p->section == sreloc)
2336 break;
2337
2338 if (p == NULL)
2339 {
2340 p = ((struct elf32_arm_pcrel_relocs_copied *)
2341 bfd_alloc (dynobj, sizeof * p));
f21f3fe0 2342
252b5132
RH		 2343 if (p == NULL)
2344 return false;
2345 p->next = eh->pcrel_relocs_copied;
2346 eh->pcrel_relocs_copied = p;
2347 p->section = sreloc;
2348 p->count = 0;
2349 }
2350
2351 ++p->count;
2352 }
2353 }
2354 break;
2355
2356 /* This relocation describes the C++ object vtable hierarchy.
2357 Reconstruct it for later use during GC. */
2358 case R_ARM_GNU_VTINHERIT:
2359 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2360 return false;
2361 break;
dece4658 2362
252b5132
RH		 2363 /* This relocation describes which C++ vtable entries are actually
2364 used. Record for later use during GC. */
2365 case R_ARM_GNU_VTENTRY:
2366 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2367 return false;
2368 break;
2369 }
2370 }
f21f3fe0 2371
252b5132
RH		 2372 return true;
2373}
2374
f21f3fe0 2375
252b5132
RH		 2376/* Find the nearest line to a particular section and offset, for error
2377 reporting. This code is a duplicate of the code in elf.c, except
2378 that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
2379
2380static boolean
2381elf32_arm_find_nearest_line
2382 (abfd, section, symbols, offset, filename_ptr, functionname_ptr, line_ptr)
2383 bfd * abfd;
2384 asection * section;
2385 asymbol ** symbols;
2386 bfd_vma offset;
2387 CONST char ** filename_ptr;
2388 CONST char ** functionname_ptr;
2389 unsigned int * line_ptr;
2390{
2391 boolean found;
2392 const char * filename;
2393 asymbol * func;
2394 bfd_vma low_func;
2395 asymbol ** p;
2396
2397 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
f21f3fe0 2398 filename_ptr, functionname_ptr,
5e38c3b8 2399 line_ptr, 0))
252b5132
RH		 2400 return true;
2401
2402 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
2403 &found, filename_ptr,
2404 functionname_ptr, line_ptr,
2405 &elf_tdata (abfd)->line_info))
2406 return false;
f21f3fe0 2407
252b5132
RH		 2408 if (found)
2409 return true;
2410
2411 if (symbols == NULL)
2412 return false;
2413
2414 filename = NULL;
2415 func = NULL;
2416 low_func = 0;
2417
2418 for (p = symbols; *p != NULL; p++)
2419 {
2420 elf_symbol_type *q;
2421
2422 q = (elf_symbol_type *) *p;
2423
2424 if (bfd_get_section (&q->symbol) != section)
2425 continue;
2426
2427 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
2428 {
2429 default:
2430 break;
2431 case STT_FILE:
2432 filename = bfd_asymbol_name (&q->symbol);
2433 break;
2434 case STT_NOTYPE:
2435 case STT_FUNC:
2436 case STT_ARM_TFUNC:
2437 if (q->symbol.section == section
2438 && q->symbol.value >= low_func
2439 && q->symbol.value <= offset)
2440 {
2441 func = (asymbol *) q;
2442 low_func = q->symbol.value;
2443 }
2444 break;
2445 }
2446 }
2447
2448 if (func == NULL)
2449 return false;
2450
2451 *filename_ptr = filename;
2452 *functionname_ptr = bfd_asymbol_name (func);
2453 *line_ptr = 0;
f21f3fe0 2454
252b5132
RH		 2455 return true;
2456}
2457
2458/* Adjust a symbol defined by a dynamic object and referenced by a
2459 regular object. The current definition is in some section of the
2460 dynamic object, but we're not including those sections. We have to
2461 change the definition to something the rest of the link can
2462 understand. */
2463
2464static boolean
2465elf32_arm_adjust_dynamic_symbol (info, h)
2466 struct bfd_link_info * info;
2467 struct elf_link_hash_entry * h;
2468{
2469 bfd * dynobj;
2470 asection * s;
2471 unsigned int power_of_two;
2472
2473 dynobj = elf_hash_table (info)->dynobj;
2474
2475 /* Make sure we know what is going on here. */
2476 BFD_ASSERT (dynobj != NULL
2477 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
2478 || h->weakdef != NULL
2479 || ((h->elf_link_hash_flags
2480 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2481 && (h->elf_link_hash_flags
2482 & ELF_LINK_HASH_REF_REGULAR) != 0
2483 && (h->elf_link_hash_flags
2484 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
2485
2486 /* If this is a function, put it in the procedure linkage table. We
2487 will fill in the contents of the procedure linkage table later,
2488 when we know the address of the .got section. */
2489 if (h->type == STT_FUNC
2490 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2491 {
2492 if (! info->shared
2493 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
2494 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
2495 {
2496 /* This case can occur if we saw a PLT32 reloc in an input
2497 file, but the symbol was never referred to by a dynamic
2498 object. In such a case, we don't actually need to build
2499 a procedure linkage table, and we can just do a PC32
2500 reloc instead. */
2501 BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
2502 return true;
2503 }
2504
2505 /* Make sure this symbol is output as a dynamic symbol. */
2506 if (h->dynindx == -1)
2507 {
2508 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2509 return false;
2510 }
2511
2512 s = bfd_get_section_by_name (dynobj, ".plt");
2513 BFD_ASSERT (s != NULL);
2514
2515 /* If this is the first .plt entry, make room for the special
2516 first entry. */
2517 if (s->_raw_size == 0)
2518 s->_raw_size += PLT_ENTRY_SIZE;
2519
2520 /* If this symbol is not defined in a regular file, and we are
2521 not generating a shared library, then set the symbol to this
2522 location in the .plt. This is required to make function
2523 pointers compare as equal between the normal executable and
2524 the shared library. */
2525 if (! info->shared
2526 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2527 {
2528 h->root.u.def.section = s;
2529 h->root.u.def.value = s->_raw_size;
2530 }
2531
2532 h->plt.offset = s->_raw_size;
2533
2534 /* Make room for this entry. */
2535 s->_raw_size += PLT_ENTRY_SIZE;
2536
2537 /* We also need to make an entry in the .got.plt section, which
2538 will be placed in the .got section by the linker script. */
2539
2540 s = bfd_get_section_by_name (dynobj, ".got.plt");
2541 BFD_ASSERT (s != NULL);
2542 s->_raw_size += 4;
2543
2544 /* We also need to make an entry in the .rel.plt section. */
2545
2546 s = bfd_get_section_by_name (dynobj, ".rel.plt");
2547 BFD_ASSERT (s != NULL);
2548 s->_raw_size += sizeof (Elf32_External_Rel);
2549
2550 return true;
2551 }
2552
2553 /* If this is a weak symbol, and there is a real definition, the
2554 processor independent code will have arranged for us to see the
2555 real definition first, and we can just use the same value. */
2556 if (h->weakdef != NULL)
2557 {
2558 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2559 || h->weakdef->root.type == bfd_link_hash_defweak);
2560 h->root.u.def.section = h->weakdef->root.u.def.section;
2561 h->root.u.def.value = h->weakdef->root.u.def.value;
2562 return true;
2563 }
2564
2565 /* This is a reference to a symbol defined by a dynamic object which
2566 is not a function. */
2567
2568 /* If we are creating a shared library, we must presume that the
2569 only references to the symbol are via the global offset table.
2570 For such cases we need not do anything here; the relocations will
2571 be handled correctly by relocate_section. */
2572 if (info->shared)
2573 return true;
2574
2575 /* We must allocate the symbol in our .dynbss section, which will
2576 become part of the .bss section of the executable. There will be
2577 an entry for this symbol in the .dynsym section. The dynamic
2578 object will contain position independent code, so all references
2579 from the dynamic object to this symbol will go through the global
2580 offset table. The dynamic linker will use the .dynsym entry to
2581 determine the address it must put in the global offset table, so
2582 both the dynamic object and the regular object will refer to the
2583 same memory location for the variable. */
2584
2585 s = bfd_get_section_by_name (dynobj, ".dynbss");
2586 BFD_ASSERT (s != NULL);
2587
2588 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
2589 copy the initial value out of the dynamic object and into the
2590 runtime process image. We need to remember the offset into the
2591 .rel.bss section we are going to use. */
2592 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2593 {
2594 asection *srel;
2595
2596 srel = bfd_get_section_by_name (dynobj, ".rel.bss");
2597 BFD_ASSERT (srel != NULL);
2598 srel->_raw_size += sizeof (Elf32_External_Rel);
2599 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
2600 }
2601
2602 /* We need to figure out the alignment required for this symbol. I
2603 have no idea how ELF linkers handle this. */
2604 power_of_two = bfd_log2 (h->size);
2605 if (power_of_two > 3)
2606 power_of_two = 3;
2607
2608 /* Apply the required alignment. */
2609 s->_raw_size = BFD_ALIGN (s->_raw_size,
2610 (bfd_size_type) (1 << power_of_two));
2611 if (power_of_two > bfd_get_section_alignment (dynobj, s))
2612 {
2613 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
2614 return false;
2615 }
2616
2617 /* Define the symbol as being at this point in the section. */
2618 h->root.u.def.section = s;
2619 h->root.u.def.value = s->_raw_size;
2620
2621 /* Increment the section size to make room for the symbol. */
2622 s->_raw_size += h->size;
2623
2624 return true;
2625}
2626
2627/* Set the sizes of the dynamic sections. */
2628
2629static boolean
2630elf32_arm_size_dynamic_sections (output_bfd, info)
2631 bfd * output_bfd;
2632 struct bfd_link_info * info;
2633{
2634 bfd * dynobj;
2635 asection * s;
2636 boolean plt;
2637 boolean relocs;
2638 boolean reltext;
2639
2640 dynobj = elf_hash_table (info)->dynobj;
2641 BFD_ASSERT (dynobj != NULL);
2642
2643 if (elf_hash_table (info)->dynamic_sections_created)
2644 {
2645 /* Set the contents of the .interp section to the interpreter. */
2646 if (! info->shared)
2647 {
2648 s = bfd_get_section_by_name (dynobj, ".interp");
2649 BFD_ASSERT (s != NULL);
2650 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
2651 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2652 }
2653 }
2654 else
2655 {
2656 /* We may have created entries in the .rel.got section.
2657 However, if we are not creating the dynamic sections, we will
2658 not actually use these entries. Reset the size of .rel.got,
2659 which will cause it to get stripped from the output file
2660 below. */
2661 s = bfd_get_section_by_name (dynobj, ".rel.got");
2662 if (s != NULL)
2663 s->_raw_size = 0;
2664 }
2665
2666 /* If this is a -Bsymbolic shared link, then we need to discard all
2667 PC relative relocs against symbols defined in a regular object.
2668 We allocated space for them in the check_relocs routine, but we
2669 will not fill them in in the relocate_section routine. */
2670 if (info->shared && info->symbolic)
2671 elf32_arm_link_hash_traverse (elf32_arm_hash_table (info),
2672 elf32_arm_discard_copies,
2673 (PTR) NULL);
2674
2675 /* The check_relocs and adjust_dynamic_symbol entry points have
2676 determined the sizes of the various dynamic sections. Allocate
2677 memory for them. */
2678 plt = false;
2679 relocs = false;
2680 reltext = false;
2681 for (s = dynobj->sections; s != NULL; s = s->next)
2682 {
2683 const char * name;
2684 boolean strip;
2685
2686 if ((s->flags & SEC_LINKER_CREATED) == 0)
2687 continue;
2688
2689 /* It's OK to base decisions on the section name, because none
2690 of the dynobj section names depend upon the input files. */
2691 name = bfd_get_section_name (dynobj, s);
2692
2693 strip = false;
2694
2695 if (strcmp (name, ".plt") == 0)
2696 {
2697 if (s->_raw_size == 0)
2698 {
2699 /* Strip this section if we don't need it; see the
2700 comment below. */
2701 strip = true;
2702 }
2703 else
2704 {
2705 /* Remember whether there is a PLT. */
2706 plt = true;
2707 }
2708 }
2709 else if (strncmp (name, ".rel", 4) == 0)
2710 {
2711 if (s->_raw_size == 0)
2712 {
2713 /* If we don't need this section, strip it from the
2714 output file. This is mostly to handle .rel.bss and
2715 .rel.plt. We must create both sections in
2716 create_dynamic_sections, because they must be created
2717 before the linker maps input sections to output
2718 sections. The linker does that before
2719 adjust_dynamic_symbol is called, and it is that
2720 function which decides whether anything needs to go
2721 into these sections. */
2722 strip = true;
2723 }
2724 else
2725 {
2726 asection * target;
2727
2728 /* Remember whether there are any reloc sections other
2729 than .rel.plt. */
2730 if (strcmp (name, ".rel.plt") != 0)
2731 {
2732 const char *outname;
2733
2734 relocs = true;
2735
2736 /* If this relocation section applies to a read only
2737 section, then we probably need a DT_TEXTREL
2738 entry. The entries in the .rel.plt section
2739 really apply to the .got section, which we
2740 created ourselves and so know is not readonly. */
2741 outname = bfd_get_section_name (output_bfd,
2742 s->output_section);
2743 target = bfd_get_section_by_name (output_bfd, outname + 4);
2744 if (target != NULL
2745 && (target->flags & SEC_READONLY) != 0
2746 && (target->flags & SEC_ALLOC) != 0)
2747 reltext = true;
2748 }
2749
2750 /* We use the reloc_count field as a counter if we need
2751 to copy relocs into the output file. */
2752 s->reloc_count = 0;
2753 }
2754 }
2755 else if (strncmp (name, ".got", 4) != 0)
2756 {
2757 /* It's not one of our sections, so don't allocate space. */
2758 continue;
2759 }
2760
2761 if (strip)
2762 {
2763 asection ** spp;
2764
2765 for (spp = &s->output_section->owner->sections;
2766 *spp != s->output_section;
2767 spp = &(*spp)->next)
2768 ;
2769 *spp = s->output_section->next;
2770 --s->output_section->owner->section_count;
2771
2772 continue;
2773 }
2774
2775 /* Allocate memory for the section contents. */
2776 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
2777 if (s->contents == NULL && s->_raw_size != 0)
2778 return false;
2779 }
2780
2781 if (elf_hash_table (info)->dynamic_sections_created)
2782 {
2783 /* Add some entries to the .dynamic section. We fill in the
2784 values later, in elf32_arm_finish_dynamic_sections, but we
2785 must add the entries now so that we get the correct size for
2786 the .dynamic section. The DT_DEBUG entry is filled in by the
2787 dynamic linker and used by the debugger. */
2788 if (! info->shared)
2789 {
2790 if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
2791 return false;
2792 }
2793
2794 if (plt)
2795 {
2796 if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
2797 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
2798 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_REL)
2799 || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
2800 return false;
2801 }
2802
2803 if (relocs)
2804 {
2805 if (! bfd_elf32_add_dynamic_entry (info, DT_REL, 0)
2806 || ! bfd_elf32_add_dynamic_entry (info, DT_RELSZ, 0)
2807 || ! bfd_elf32_add_dynamic_entry (info, DT_RELENT,
2808 sizeof (Elf32_External_Rel)))
2809 return false;
2810 }
2811
2812 if (reltext)
2813 {
2814 if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
2815 return false;
2816 }
2817 }
2818
2819 return true;
2820}
2821
2822/* This function is called via elf32_arm_link_hash_traverse if we are
2823 creating a shared object with -Bsymbolic. It discards the space
2824 allocated to copy PC relative relocs against symbols which are
2825 defined in regular objects. We allocated space for them in the
2826 check_relocs routine, but we won't fill them in in the
2827 relocate_section routine. */
2828
2829static boolean
2830elf32_arm_discard_copies (h, ignore)
2831 struct elf32_arm_link_hash_entry * h;
2832 PTR ignore;
2833{
2834 struct elf32_arm_pcrel_relocs_copied * s;
2835
2836 /* We only discard relocs for symbols defined in a regular object. */
2837 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2838 return true;
2839
2840 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
2841 s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
2842
2843 return true;
2844}
2845
2846/* Finish up dynamic symbol handling. We set the contents of various
2847 dynamic sections here. */
2848
2849static boolean
2850elf32_arm_finish_dynamic_symbol (output_bfd, info, h, sym)
2851 bfd * output_bfd;
2852 struct bfd_link_info * info;
2853 struct elf_link_hash_entry * h;
2854 Elf_Internal_Sym * sym;
2855{
2856 bfd * dynobj;
2857
2858 dynobj = elf_hash_table (info)->dynobj;
2859
2860 if (h->plt.offset != (bfd_vma) -1)
2861 {
2862 asection * splt;
2863 asection * sgot;
2864 asection * srel;
2865 bfd_vma plt_index;
2866 bfd_vma got_offset;
2867 Elf_Internal_Rel rel;
2868
2869 /* This symbol has an entry in the procedure linkage table. Set
2870 it up. */
2871
2872 BFD_ASSERT (h->dynindx != -1);
2873
2874 splt = bfd_get_section_by_name (dynobj, ".plt");
2875 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
2876 srel = bfd_get_section_by_name (dynobj, ".rel.plt");
2877 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
2878
2879 /* Get the index in the procedure linkage table which
2880 corresponds to this symbol. This is the index of this symbol
2881 in all the symbols for which we are making plt entries. The
2882 first entry in the procedure linkage table is reserved. */
2883 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2884
2885 /* Get the offset into the .got table of the entry that
2886 corresponds to this function. Each .got entry is 4 bytes.
2887 The first three are reserved. */
2888 got_offset = (plt_index + 3) * 4;
2889
2890 /* Fill in the entry in the procedure linkage table. */
2891 memcpy (splt->contents + h->plt.offset,
2892 elf32_arm_plt_entry,
2893 PLT_ENTRY_SIZE);
2894 bfd_put_32 (output_bfd,
2895 (sgot->output_section->vma
2896 + sgot->output_offset
f21f3fe0 2897 + got_offset
252b5132
RH		 2898 - splt->output_section->vma
2899 - splt->output_offset
2900 - h->plt.offset - 12),
2901 splt->contents + h->plt.offset + 12);
2902
2903 /* Fill in the entry in the global offset table. */
2904 bfd_put_32 (output_bfd,
2905 (splt->output_section->vma
2906 + splt->output_offset),
2907 sgot->contents + got_offset);
2908
2909 /* Fill in the entry in the .rel.plt section. */
2910 rel.r_offset = (sgot->output_section->vma
2911 + sgot->output_offset
2912 + got_offset);
2913 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
2914 bfd_elf32_swap_reloc_out (output_bfd, &rel,
2915 ((Elf32_External_Rel *) srel->contents
2916 + plt_index));
2917
2918 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2919 {
2920 /* Mark the symbol as undefined, rather than as defined in
2921 the .plt section. Leave the value alone. */
2922 sym->st_shndx = SHN_UNDEF;
2923 }
2924 }
2925
2926 if (h->got.offset != (bfd_vma) -1)
2927 {
2928 asection * sgot;
2929 asection * srel;
2930 Elf_Internal_Rel rel;
2931
2932 /* This symbol has an entry in the global offset table. Set it
2933 up. */
f21f3fe0 2934
252b5132
RH		 2935 sgot = bfd_get_section_by_name (dynobj, ".got");
2936 srel = bfd_get_section_by_name (dynobj, ".rel.got");
2937 BFD_ASSERT (sgot != NULL && srel != NULL);
2938
2939 rel.r_offset = (sgot->output_section->vma
2940 + sgot->output_offset
2941 + (h->got.offset &~ 1));
2942
2943 /* If this is a -Bsymbolic link, and the symbol is defined
2944 locally, we just want to emit a RELATIVE reloc. The entry in
2945 the global offset table will already have been initialized in
2946 the relocate_section function. */
2947 if (info->shared
2948 && (info->symbolic || h->dynindx == -1)
2949 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
2950 rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
2951 else
2952 {
2953 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
2954 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
2955 }
2956
2957 bfd_elf32_swap_reloc_out (output_bfd, &rel,
2958 ((Elf32_External_Rel *) srel->contents
2959 + srel->reloc_count));
2960 ++srel->reloc_count;
2961 }
2962
2963 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
2964 {
2965 asection * s;
2966 Elf_Internal_Rel rel;
2967
2968 /* This symbol needs a copy reloc. Set it up. */
2969
2970 BFD_ASSERT (h->dynindx != -1
2971 && (h->root.type == bfd_link_hash_defined
2972 || h->root.type == bfd_link_hash_defweak));
2973
2974 s = bfd_get_section_by_name (h->root.u.def.section->owner,
2975 ".rel.bss");
2976 BFD_ASSERT (s != NULL);
2977
2978 rel.r_offset = (h->root.u.def.value
2979 + h->root.u.def.section->output_section->vma
2980 + h->root.u.def.section->output_offset);
2981 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
2982 bfd_elf32_swap_reloc_out (output_bfd, &rel,
2983 ((Elf32_External_Rel *) s->contents
2984 + s->reloc_count));
2985 ++s->reloc_count;
2986 }
2987
2988 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2989 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2990 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2991 sym->st_shndx = SHN_ABS;
2992
2993 return true;
2994}
2995
2996/* Finish up the dynamic sections. */
2997
2998static boolean
2999elf32_arm_finish_dynamic_sections (output_bfd, info)
3000 bfd * output_bfd;
3001 struct bfd_link_info * info;
3002{
3003 bfd * dynobj;
3004 asection * sgot;
3005 asection * sdyn;
3006
3007 dynobj = elf_hash_table (info)->dynobj;
3008
3009 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3010 BFD_ASSERT (sgot != NULL);
3011 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3012
3013 if (elf_hash_table (info)->dynamic_sections_created)
3014 {
3015 asection *splt;
3016 Elf32_External_Dyn *dyncon, *dynconend;
3017
3018 splt = bfd_get_section_by_name (dynobj, ".plt");
3019 BFD_ASSERT (splt != NULL && sdyn != NULL);
3020
3021 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3022 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3023 for (; dyncon < dynconend; dyncon++)
3024 {
3025 Elf_Internal_Dyn dyn;
3026 const char * name;
3027 asection * s;
3028
3029 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3030
3031 switch (dyn.d_tag)
3032 {
3033 default:
3034 break;
3035
3036 case DT_PLTGOT:
3037 name = ".got";
3038 goto get_vma;
3039 case DT_JMPREL:
3040 name = ".rel.plt";
3041 get_vma:
3042 s = bfd_get_section_by_name (output_bfd, name);
3043 BFD_ASSERT (s != NULL);
3044 dyn.d_un.d_ptr = s->vma;
3045 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3046 break;
3047
3048 case DT_PLTRELSZ:
3049 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3050 BFD_ASSERT (s != NULL);
3051 if (s->_cooked_size != 0)
3052 dyn.d_un.d_val = s->_cooked_size;
3053 else
3054 dyn.d_un.d_val = s->_raw_size;
3055 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3056 break;
3057
3058 case DT_RELSZ:
3059 /* My reading of the SVR4 ABI indicates that the
3060 procedure linkage table relocs (DT_JMPREL) should be
3061 included in the overall relocs (DT_REL). This is
3062 what Solaris does. However, UnixWare can not handle
3063 that case. Therefore, we override the DT_RELSZ entry
3064 here to make it not include the JMPREL relocs. Since
3065 the linker script arranges for .rel.plt to follow all
3066 other relocation sections, we don't have to worry
3067 about changing the DT_REL entry. */
3068 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3069 if (s != NULL)
3070 {
3071 if (s->_cooked_size != 0)
3072 dyn.d_un.d_val -= s->_cooked_size;
3073 else
3074 dyn.d_un.d_val -= s->_raw_size;
3075 }
3076 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3077 break;
3078 }
3079 }
3080
3081 /* Fill in the first entry in the procedure linkage table. */
3082 if (splt->_raw_size > 0)
3083 memcpy (splt->contents, elf32_arm_plt0_entry, PLT_ENTRY_SIZE);
3084
3085 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3086 really seem like the right value. */
3087 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
3088 }
3089
3090 /* Fill in the first three entries in the global offset table. */
3091 if (sgot->_raw_size > 0)
3092 {
3093 if (sdyn == NULL)
3094 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
3095 else
3096 bfd_put_32 (output_bfd,
3097 sdyn->output_section->vma + sdyn->output_offset,
3098 sgot->contents);
3099 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
3100 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3101 }
3102
3103 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
3104
3105 return true;
3106}
3107
ba96a88f
NC		 3108static void
3109elf32_arm_post_process_headers (abfd, link_info)
3110 bfd * abfd;
3111 struct bfd_link_info * link_info;
3112{
3113 Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form */
3114
3115 i_ehdrp = elf_elfheader (abfd);
3116
3117 i_ehdrp->e_ident[EI_OSABI] = ARM_ELF_OS_ABI_VERSION;
3118 i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
3119}
3120
3121
252b5132
RH		 3122#define ELF_ARCH bfd_arch_arm
3123#define ELF_MACHINE_CODE EM_ARM
f21f3fe0 3124#define ELF_MAXPAGESIZE 0x8000
252b5132
RH		 3125
3126
3127#define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
3128#define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
3129#define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
3130#define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
3131#define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
3132#define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
3133#define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
3134
3135#define elf_backend_get_symbol_type elf32_arm_get_symbol_type
3136#define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
3137#define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
3138#define elf_backend_check_relocs elf32_arm_check_relocs
3139#define elf_backend_relocate_section elf32_arm_relocate_section
3140#define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
3141#define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
3142#define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
3143#define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
3144#define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
ba96a88f 3145#define elf_backend_post_process_headers elf32_arm_post_process_headers
252b5132
RH		 3146
3147#define elf_backend_can_gc_sections 1
3148#define elf_backend_plt_readonly 1
3149#define elf_backend_want_got_plt 1
3150#define elf_backend_want_plt_sym 0
3151
04f7c78d
NC		 3152#define elf_backend_got_header_size 12
3153#define elf_backend_plt_header_size PLT_ENTRY_SIZE
3154
252b5132 3155#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.231938 seconds and 4 git commands to generate.