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