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