projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix gdb.trace/mi-traceframe-changed.exp on s390.
[deliverable/binutils-gdb.git] / bfd / coff-arm.c
1 /* BFD back-end for ARM COFF files.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012
4 Free Software Foundation, Inc.
5 Written by Cygnus Support.
6
7 This file is part of BFD, the Binary File Descriptor library.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
23
24 #include "sysdep.h"
25 #include "bfd.h"
26 #include "libbfd.h"
27 #include "coff/arm.h"
28 #include "coff/internal.h"
29
30 #ifdef COFF_WITH_PE
31 #include "coff/pe.h"
32 #endif
33
34 #include "libcoff.h"
35
36 /* Macros for manipulation the bits in the flags field of the coff data
37 structure. */
38 #define APCS_26_FLAG(abfd) \
39 (coff_data (abfd)->flags & F_APCS_26)
40
41 #define APCS_FLOAT_FLAG(abfd) \
42 (coff_data (abfd)->flags & F_APCS_FLOAT)
43
44 #define PIC_FLAG(abfd) \
45 (coff_data (abfd)->flags & F_PIC)
46
47 #define APCS_SET(abfd) \
48 (coff_data (abfd)->flags & F_APCS_SET)
49
50 #define SET_APCS_FLAGS(abfd, flgs) \
51 do \
52 { \
53 coff_data (abfd)->flags &= ~(F_APCS_26 | F_APCS_FLOAT | F_PIC); \
54 coff_data (abfd)->flags |= (flgs) | F_APCS_SET; \
55 } \
56 while (0)
57
58 #define INTERWORK_FLAG(abfd) \
59 (coff_data (abfd)->flags & F_INTERWORK)
60
61 #define INTERWORK_SET(abfd) \
62 (coff_data (abfd)->flags & F_INTERWORK_SET)
63
64 #define SET_INTERWORK_FLAG(abfd, flg) \
65 do \
66 { \
67 coff_data (abfd)->flags &= ~F_INTERWORK; \
68 coff_data (abfd)->flags |= (flg) | F_INTERWORK_SET; \
69 } \
70 while (0)
71
72 #ifndef NUM_ELEM
73 #define NUM_ELEM(a) ((sizeof (a)) / sizeof ((a)[0]))
74 #endif
75
76 typedef enum {bunknown, b9, b12, b23} thumb_pcrel_branchtype;
77 /* Some typedefs for holding instructions. */
78 typedef unsigned long int insn32;
79 typedef unsigned short int insn16;
80
81 /* The linker script knows the section names for placement.
82 The entry_names are used to do simple name mangling on the stubs.
83 Given a function name, and its type, the stub can be found. The
84 name can be changed. The only requirement is the %s be present. */
85
86 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
87 #define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
88
89 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
90 #define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
91
92 /* Used by the assembler. */
93
94 static bfd_reloc_status_type
95 coff_arm_reloc (bfd *abfd,
96 arelent *reloc_entry,
97 asymbol *symbol ATTRIBUTE_UNUSED,
98 void * data,
99 asection *input_section ATTRIBUTE_UNUSED,
100 bfd *output_bfd,
101 char **error_message ATTRIBUTE_UNUSED)
102 {
103 symvalue diff;
104
105 if (output_bfd == NULL)
106 return bfd_reloc_continue;
107
108 diff = reloc_entry->addend;
109
110 #define DOIT(x) \
111 x = ((x & ~howto->dst_mask) \
112 | (((x & howto->src_mask) + diff) & howto->dst_mask))
113
114 if (diff != 0)
115 {
116 reloc_howto_type *howto = reloc_entry->howto;
117 unsigned char *addr = (unsigned char *) data + reloc_entry->address;
118
119 switch (howto->size)
120 {
121 case 0:
122 {
123 char x = bfd_get_8 (abfd, addr);
124 DOIT (x);
125 bfd_put_8 (abfd, x, addr);
126 }
127 break;
128
129 case 1:
130 {
131 short x = bfd_get_16 (abfd, addr);
132 DOIT (x);
133 bfd_put_16 (abfd, (bfd_vma) x, addr);
134 }
135 break;
136
137 case 2:
138 {
139 long x = bfd_get_32 (abfd, addr);
140 DOIT (x);
141 bfd_put_32 (abfd, (bfd_vma) x, addr);
142 }
143 break;
144
145 default:
146 abort ();
147 }
148 }
149
150 /* Now let bfd_perform_relocation finish everything up. */
151 return bfd_reloc_continue;
152 }
153
154 /* If USER_LABEL_PREFIX is defined as "_" (see coff_arm_is_local_label_name()
155 in this file), then TARGET_UNDERSCORE should be defined, otherwise it
156 should not. */
157 #ifndef TARGET_UNDERSCORE
158 #define TARGET_UNDERSCORE '_'
159 #endif
160
161 #ifndef PCRELOFFSET
162 #define PCRELOFFSET TRUE
163 #endif
164
165 /* These most certainly belong somewhere else. Just had to get rid of
166 the manifest constants in the code. */
167
168 #ifdef ARM_WINCE
169
170 #define ARM_26D 0
171 #define ARM_32 1
172 #define ARM_RVA32 2
173 #define ARM_26 3
174 #define ARM_THUMB12 4
175 #define ARM_SECTION 14
176 #define ARM_SECREL 15
177
178 #else
179
180 #define ARM_8 0
181 #define ARM_16 1
182 #define ARM_32 2
183 #define ARM_26 3
184 #define ARM_DISP8 4
185 #define ARM_DISP16 5
186 #define ARM_DISP32 6
187 #define ARM_26D 7
188 /* 8 is unused. */
189 #define ARM_NEG16 9
190 #define ARM_NEG32 10
191 #define ARM_RVA32 11
192 #define ARM_THUMB9 12
193 #define ARM_THUMB12 13
194 #define ARM_THUMB23 14
195
196 #endif
197
198 static bfd_reloc_status_type aoutarm_fix_pcrel_26_done
199 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
200 static bfd_reloc_status_type aoutarm_fix_pcrel_26
201 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
202 static bfd_reloc_status_type coff_thumb_pcrel_12
203 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
204 #ifndef ARM_WINCE
205 static bfd_reloc_status_type coff_thumb_pcrel_9
206 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
207 static bfd_reloc_status_type coff_thumb_pcrel_23
208 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
209 #endif
210
211 static reloc_howto_type aoutarm_std_reloc_howto[] =
212 {
213 #ifdef ARM_WINCE
214 HOWTO (ARM_26D,
215 2,
216 2,
217 24,
218 TRUE,
219 0,
220 complain_overflow_dont,
221 aoutarm_fix_pcrel_26_done,
222 "ARM_26D",
223 TRUE, /* partial_inplace. */
224 0x00ffffff,
225 0x0,
226 PCRELOFFSET),
227 HOWTO (ARM_32,
228 0,
229 2,
230 32,
231 FALSE,
232 0,
233 complain_overflow_bitfield,
234 coff_arm_reloc,
235 "ARM_32",
236 TRUE, /* partial_inplace. */
237 0xffffffff,
238 0xffffffff,
239 PCRELOFFSET),
240 HOWTO (ARM_RVA32,
241 0,
242 2,
243 32,
244 FALSE,
245 0,
246 complain_overflow_bitfield,
247 coff_arm_reloc,
248 "ARM_RVA32",
249 TRUE, /* partial_inplace. */
250 0xffffffff,
251 0xffffffff,
252 PCRELOFFSET),
253 HOWTO (ARM_26,
254 2,
255 2,
256 24,
257 TRUE,
258 0,
259 complain_overflow_signed,
260 aoutarm_fix_pcrel_26 ,
261 "ARM_26",
262 FALSE,
263 0x00ffffff,
264 0x00ffffff,
265 PCRELOFFSET),
266 HOWTO (ARM_THUMB12,
267 1,
268 1,
269 11,
270 TRUE,
271 0,
272 complain_overflow_signed,
273 coff_thumb_pcrel_12 ,
274 "ARM_THUMB12",
275 FALSE,
276 0x000007ff,
277 0x000007ff,
278 PCRELOFFSET),
279 EMPTY_HOWTO (-1),
280 EMPTY_HOWTO (-1),
281 EMPTY_HOWTO (-1),
282 EMPTY_HOWTO (-1),
283 EMPTY_HOWTO (-1),
284 EMPTY_HOWTO (-1),
285 EMPTY_HOWTO (-1),
286 EMPTY_HOWTO (-1),
287 EMPTY_HOWTO (-1),
288 HOWTO (ARM_SECTION,
289 0,
290 1,
291 16,
292 FALSE,
293 0,
294 complain_overflow_bitfield,
295 coff_arm_reloc,
296 "ARM_SECTION",
297 TRUE, /* partial_inplace. */
298 0x0000ffff,
299 0x0000ffff,
300 PCRELOFFSET),
301 HOWTO (ARM_SECREL,
302 0,
303 2,
304 32,
305 FALSE,
306 0,
307 complain_overflow_bitfield,
308 coff_arm_reloc,
309 "ARM_SECREL",
310 TRUE, /* partial_inplace. */
311 0xffffffff,
312 0xffffffff,
313 PCRELOFFSET),
314 #else /* not ARM_WINCE */
315 HOWTO (ARM_8,
316 0,
317 0,
318 8,
319 FALSE,
320 0,
321 complain_overflow_bitfield,
322 coff_arm_reloc,
323 "ARM_8",
324 TRUE,
325 0x000000ff,
326 0x000000ff,
327 PCRELOFFSET),
328 HOWTO (ARM_16,
329 0,
330 1,
331 16,
332 FALSE,
333 0,
334 complain_overflow_bitfield,
335 coff_arm_reloc,
336 "ARM_16",
337 TRUE,
338 0x0000ffff,
339 0x0000ffff,
340 PCRELOFFSET),
341 HOWTO (ARM_32,
342 0,
343 2,
344 32,
345 FALSE,
346 0,
347 complain_overflow_bitfield,
348 coff_arm_reloc,
349 "ARM_32",
350 TRUE,
351 0xffffffff,
352 0xffffffff,
353 PCRELOFFSET),
354 HOWTO (ARM_26,
355 2,
356 2,
357 24,
358 TRUE,
359 0,
360 complain_overflow_signed,
361 aoutarm_fix_pcrel_26 ,
362 "ARM_26",
363 FALSE,
364 0x00ffffff,
365 0x00ffffff,
366 PCRELOFFSET),
367 HOWTO (ARM_DISP8,
368 0,
369 0,
370 8,
371 TRUE,
372 0,
373 complain_overflow_signed,
374 coff_arm_reloc,
375 "ARM_DISP8",
376 TRUE,
377 0x000000ff,
378 0x000000ff,
379 TRUE),
380 HOWTO (ARM_DISP16,
381 0,
382 1,
383 16,
384 TRUE,
385 0,
386 complain_overflow_signed,
387 coff_arm_reloc,
388 "ARM_DISP16",
389 TRUE,
390 0x0000ffff,
391 0x0000ffff,
392 TRUE),
393 HOWTO (ARM_DISP32,
394 0,
395 2,
396 32,
397 TRUE,
398 0,
399 complain_overflow_signed,
400 coff_arm_reloc,
401 "ARM_DISP32",
402 TRUE,
403 0xffffffff,
404 0xffffffff,
405 TRUE),
406 HOWTO (ARM_26D,
407 2,
408 2,
409 24,
410 FALSE,
411 0,
412 complain_overflow_dont,
413 aoutarm_fix_pcrel_26_done,
414 "ARM_26D",
415 TRUE,
416 0x00ffffff,
417 0x0,
418 FALSE),
419 /* 8 is unused */
420 EMPTY_HOWTO (-1),
421 HOWTO (ARM_NEG16,
422 0,
423 -1,
424 16,
425 FALSE,
426 0,
427 complain_overflow_bitfield,
428 coff_arm_reloc,
429 "ARM_NEG16",
430 TRUE,
431 0x0000ffff,
432 0x0000ffff,
433 FALSE),
434 HOWTO (ARM_NEG32,
435 0,
436 -2,
437 32,
438 FALSE,
439 0,
440 complain_overflow_bitfield,
441 coff_arm_reloc,
442 "ARM_NEG32",
443 TRUE,
444 0xffffffff,
445 0xffffffff,
446 FALSE),
447 HOWTO (ARM_RVA32,
448 0,
449 2,
450 32,
451 FALSE,
452 0,
453 complain_overflow_bitfield,
454 coff_arm_reloc,
455 "ARM_RVA32",
456 TRUE,
457 0xffffffff,
458 0xffffffff,
459 PCRELOFFSET),
460 HOWTO (ARM_THUMB9,
461 1,
462 1,
463 8,
464 TRUE,
465 0,
466 complain_overflow_signed,
467 coff_thumb_pcrel_9 ,
468 "ARM_THUMB9",
469 FALSE,
470 0x000000ff,
471 0x000000ff,
472 PCRELOFFSET),
473 HOWTO (ARM_THUMB12,
474 1,
475 1,
476 11,
477 TRUE,
478 0,
479 complain_overflow_signed,
480 coff_thumb_pcrel_12 ,
481 "ARM_THUMB12",
482 FALSE,
483 0x000007ff,
484 0x000007ff,
485 PCRELOFFSET),
486 HOWTO (ARM_THUMB23,
487 1,
488 2,
489 22,
490 TRUE,
491 0,
492 complain_overflow_signed,
493 coff_thumb_pcrel_23 ,
494 "ARM_THUMB23",
495 FALSE,
496 0x07ff07ff,
497 0x07ff07ff,
498 PCRELOFFSET)
499 #endif /* not ARM_WINCE */
500 };
501
502 #define NUM_RELOCS NUM_ELEM (aoutarm_std_reloc_howto)
503
504 #ifdef COFF_WITH_PE
505 /* Return TRUE if this relocation should
506 appear in the output .reloc section. */
507
508 static bfd_boolean
509 in_reloc_p (bfd * abfd ATTRIBUTE_UNUSED,
510 reloc_howto_type * howto)
511 {
512 return !howto->pc_relative && howto->type != ARM_RVA32;
513 }
514 #endif
515
516 #define RTYPE2HOWTO(cache_ptr, dst) \
517 (cache_ptr)->howto = \
518 (dst)->r_type < NUM_RELOCS \
519 ? aoutarm_std_reloc_howto + (dst)->r_type \
520 : NULL
521
522 #define coff_rtype_to_howto coff_arm_rtype_to_howto
523
524 static reloc_howto_type *
525 coff_arm_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
526 asection *sec,
527 struct internal_reloc *rel,
528 struct coff_link_hash_entry *h ATTRIBUTE_UNUSED,
529 struct internal_syment *sym ATTRIBUTE_UNUSED,
530 bfd_vma *addendp)
531 {
532 reloc_howto_type * howto;
533
534 if (rel->r_type >= NUM_RELOCS)
535 return NULL;
536
537 howto = aoutarm_std_reloc_howto + rel->r_type;
538
539 if (rel->r_type == ARM_RVA32)
540 *addendp -= pe_data (sec->output_section->owner)->pe_opthdr.ImageBase;
541
542 #if defined COFF_WITH_PE && defined ARM_WINCE
543 if (rel->r_type == ARM_SECREL)
544 {
545 bfd_vma osect_vma;
546
547 if (h && (h->type == bfd_link_hash_defined
548 || h->type == bfd_link_hash_defweak))
549 osect_vma = h->root.u.def.section->output_section->vma;
550 else
551 {
552 int i;
553
554 /* Sigh, the only way to get the section to offset against
555 is to find it the hard way. */
556
557 for (sec = abfd->sections, i = 1; i < sym->n_scnum; i++)
558 sec = sec->next;
559
560 osect_vma = sec->output_section->vma;
561 }
562
563 *addendp -= osect_vma;
564 }
565 #endif
566
567 return howto;
568 }
569
570 /* Used by the assembler. */
571
572 static bfd_reloc_status_type
573 aoutarm_fix_pcrel_26_done (bfd *abfd ATTRIBUTE_UNUSED,
574 arelent *reloc_entry ATTRIBUTE_UNUSED,
575 asymbol *symbol ATTRIBUTE_UNUSED,
576 void * data ATTRIBUTE_UNUSED,
577 asection *input_section ATTRIBUTE_UNUSED,
578 bfd *output_bfd ATTRIBUTE_UNUSED,
579 char **error_message ATTRIBUTE_UNUSED)
580 {
581 /* This is dead simple at present. */
582 return bfd_reloc_ok;
583 }
584
585 /* Used by the assembler. */
586
587 static bfd_reloc_status_type
588 aoutarm_fix_pcrel_26 (bfd *abfd,
589 arelent *reloc_entry,
590 asymbol *symbol,
591 void * data,
592 asection *input_section,
593 bfd *output_bfd,
594 char **error_message ATTRIBUTE_UNUSED)
595 {
596 bfd_vma relocation;
597 bfd_size_type addr = reloc_entry->address;
598 long target = bfd_get_32 (abfd, (bfd_byte *) data + addr);
599 bfd_reloc_status_type flag = bfd_reloc_ok;
600
601 /* If this is an undefined symbol, return error. */
602 if (bfd_is_und_section (symbol->section)
603 && (symbol->flags & BSF_WEAK) == 0)
604 return output_bfd ? bfd_reloc_continue : bfd_reloc_undefined;
605
606 /* If the sections are different, and we are doing a partial relocation,
607 just ignore it for now. */
608 if (symbol->section->name != input_section->name
609 && output_bfd != (bfd *)NULL)
610 return bfd_reloc_continue;
611
612 relocation = (target & 0x00ffffff) << 2;
613 relocation = (relocation ^ 0x02000000) - 0x02000000; /* Sign extend. */
614 relocation += symbol->value;
615 relocation += symbol->section->output_section->vma;
616 relocation += symbol->section->output_offset;
617 relocation += reloc_entry->addend;
618 relocation -= input_section->output_section->vma;
619 relocation -= input_section->output_offset;
620 relocation -= addr;
621
622 if (relocation & 3)
623 return bfd_reloc_overflow;
624
625 /* Check for overflow. */
626 if (relocation & 0x02000000)
627 {
628 if ((relocation & ~ (bfd_vma) 0x03ffffff) != ~ (bfd_vma) 0x03ffffff)
629 flag = bfd_reloc_overflow;
630 }
631 else if (relocation & ~(bfd_vma) 0x03ffffff)
632 flag = bfd_reloc_overflow;
633
634 target &= ~0x00ffffff;
635 target |= (relocation >> 2) & 0x00ffffff;
636 bfd_put_32 (abfd, (bfd_vma) target, (bfd_byte *) data + addr);
637
638 /* Now the ARM magic... Change the reloc type so that it is marked as done.
639 Strictly this is only necessary if we are doing a partial relocation. */
640 reloc_entry->howto = &aoutarm_std_reloc_howto[ARM_26D];
641
642 return flag;
643 }
644
645 static bfd_reloc_status_type
646 coff_thumb_pcrel_common (bfd *abfd,
647 arelent *reloc_entry,
648 asymbol *symbol,
649 void * data,
650 asection *input_section,
651 bfd *output_bfd,
652 char **error_message ATTRIBUTE_UNUSED,
653 thumb_pcrel_branchtype btype)
654 {
655 bfd_vma relocation = 0;
656 bfd_size_type addr = reloc_entry->address;
657 long target = bfd_get_32 (abfd, (bfd_byte *) data + addr);
658 bfd_reloc_status_type flag = bfd_reloc_ok;
659 bfd_vma dstmsk;
660 bfd_vma offmsk;
661 bfd_vma signbit;
662
663 /* NOTE: This routine is currently used by GAS, but not by the link
664 phase. */
665 switch (btype)
666 {
667 case b9:
668 dstmsk = 0x000000ff;
669 offmsk = 0x000001fe;
670 signbit = 0x00000100;
671 break;
672
673 case b12:
674 dstmsk = 0x000007ff;
675 offmsk = 0x00000ffe;
676 signbit = 0x00000800;
677 break;
678
679 case b23:
680 dstmsk = 0x07ff07ff;
681 offmsk = 0x007fffff;
682 signbit = 0x00400000;
683 break;
684
685 default:
686 abort ();
687 }
688
689 /* If this is an undefined symbol, return error. */
690 if (bfd_is_und_section (symbol->section)
691 && (symbol->flags & BSF_WEAK) == 0)
692 return output_bfd ? bfd_reloc_continue : bfd_reloc_undefined;
693
694 /* If the sections are different, and we are doing a partial relocation,
695 just ignore it for now. */
696 if (symbol->section->name != input_section->name
697 && output_bfd != (bfd *)NULL)
698 return bfd_reloc_continue;
699
700 switch (btype)
701 {
702 case b9:
703 case b12:
704 relocation = ((target & dstmsk) << 1);
705 break;
706
707 case b23:
708 if (bfd_big_endian (abfd))
709 relocation = ((target & 0x7ff) << 1) | ((target & 0x07ff0000) >> 4);
710 else
711 relocation = ((target & 0x7ff) << 12) | ((target & 0x07ff0000) >> 15);
712 break;
713
714 default:
715 abort ();
716 }
717
718 relocation = (relocation ^ signbit) - signbit; /* Sign extend. */
719 relocation += symbol->value;
720 relocation += symbol->section->output_section->vma;
721 relocation += symbol->section->output_offset;
722 relocation += reloc_entry->addend;
723 relocation -= input_section->output_section->vma;
724 relocation -= input_section->output_offset;
725 relocation -= addr;
726
727 if (relocation & 1)
728 return bfd_reloc_overflow;
729
730 /* Check for overflow. */
731 if (relocation & signbit)
732 {
733 if ((relocation & ~offmsk) != ~offmsk)
734 flag = bfd_reloc_overflow;
735 }
736 else if (relocation & ~offmsk)
737 flag = bfd_reloc_overflow;
738
739 target &= ~dstmsk;
740 switch (btype)
741 {
742 case b9:
743 case b12:
744 target |= (relocation >> 1);
745 break;
746
747 case b23:
748 if (bfd_big_endian (abfd))
749 target |= (((relocation & 0xfff) >> 1)
750 | ((relocation << 4) & 0x07ff0000));
751 else
752 target |= (((relocation & 0xffe) << 15)
753 | ((relocation >> 12) & 0x7ff));
754 break;
755
756 default:
757 abort ();
758 }
759
760 bfd_put_32 (abfd, (bfd_vma) target, (bfd_byte *) data + addr);
761
762 /* Now the ARM magic... Change the reloc type so that it is marked as done.
763 Strictly this is only necessary if we are doing a partial relocation. */
764 reloc_entry->howto = & aoutarm_std_reloc_howto [ARM_26D];
765
766 /* TODO: We should possibly have DONE entries for the THUMB PCREL relocations. */
767 return flag;
768 }
769
770 #ifndef ARM_WINCE
771 static bfd_reloc_status_type
772 coff_thumb_pcrel_23 (bfd *abfd,
773 arelent *reloc_entry,
774 asymbol *symbol,
775 void * data,
776 asection *input_section,
777 bfd *output_bfd,
778 char **error_message)
779 {
780 return coff_thumb_pcrel_common (abfd, reloc_entry, symbol, data,
781 input_section, output_bfd, error_message,
782 b23);
783 }
784
785 static bfd_reloc_status_type
786 coff_thumb_pcrel_9 (bfd *abfd,
787 arelent *reloc_entry,
788 asymbol *symbol,
789 void * data,
790 asection *input_section,
791 bfd *output_bfd,
792 char **error_message)
793 {
794 return coff_thumb_pcrel_common (abfd, reloc_entry, symbol, data,
795 input_section, output_bfd, error_message,
796 b9);
797 }
798 #endif /* not ARM_WINCE */
799
800 static bfd_reloc_status_type
801 coff_thumb_pcrel_12 (bfd *abfd,
802 arelent *reloc_entry,
803 asymbol *symbol,
804 void * data,
805 asection *input_section,
806 bfd *output_bfd,
807 char **error_message)
808 {
809 return coff_thumb_pcrel_common (abfd, reloc_entry, symbol, data,
810 input_section, output_bfd, error_message,
811 b12);
812 }
813
814 static const struct reloc_howto_struct *
815 coff_arm_reloc_type_lookup (bfd * abfd, bfd_reloc_code_real_type code)
816 {
817 #define ASTD(i,j) case i: return aoutarm_std_reloc_howto + j
818
819 if (code == BFD_RELOC_CTOR)
820 switch (bfd_arch_bits_per_address (abfd))
821 {
822 case 32:
823 code = BFD_RELOC_32;
824 break;
825 default:
826 return NULL;
827 }
828
829 switch (code)
830 {
831 #ifdef ARM_WINCE
832 ASTD (BFD_RELOC_32, ARM_32);
833 ASTD (BFD_RELOC_RVA, ARM_RVA32);
834 ASTD (BFD_RELOC_ARM_PCREL_BRANCH, ARM_26);
835 ASTD (BFD_RELOC_THUMB_PCREL_BRANCH12, ARM_THUMB12);
836 ASTD (BFD_RELOC_32_SECREL, ARM_SECREL);
837 #else
838 ASTD (BFD_RELOC_8, ARM_8);
839 ASTD (BFD_RELOC_16, ARM_16);
840 ASTD (BFD_RELOC_32, ARM_32);
841 ASTD (BFD_RELOC_ARM_PCREL_BRANCH, ARM_26);
842 ASTD (BFD_RELOC_ARM_PCREL_BLX, ARM_26);
843 ASTD (BFD_RELOC_8_PCREL, ARM_DISP8);
844 ASTD (BFD_RELOC_16_PCREL, ARM_DISP16);
845 ASTD (BFD_RELOC_32_PCREL, ARM_DISP32);
846 ASTD (BFD_RELOC_RVA, ARM_RVA32);
847 ASTD (BFD_RELOC_THUMB_PCREL_BRANCH9, ARM_THUMB9);
848 ASTD (BFD_RELOC_THUMB_PCREL_BRANCH12, ARM_THUMB12);
849 ASTD (BFD_RELOC_THUMB_PCREL_BRANCH23, ARM_THUMB23);
850 ASTD (BFD_RELOC_THUMB_PCREL_BLX, ARM_THUMB23);
851 #endif
852 default: return NULL;
853 }
854 }
855
856 static reloc_howto_type *
857 coff_arm_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
858 const char *r_name)
859 {
860 unsigned int i;
861
862 for (i = 0;
863 i < (sizeof (aoutarm_std_reloc_howto)
864 / sizeof (aoutarm_std_reloc_howto[0]));
865 i++)
866 if (aoutarm_std_reloc_howto[i].name != NULL
867 && strcasecmp (aoutarm_std_reloc_howto[i].name, r_name) == 0)
868 return &aoutarm_std_reloc_howto[i];
869
870 return NULL;
871 }
872
873 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER 2
874 #define COFF_PAGE_SIZE 0x1000
875
876 /* Turn a howto into a reloc nunmber. */
877 #define SELECT_RELOC(x,howto) { x.r_type = howto->type; }
878 #define BADMAG(x) ARMBADMAG(x)
879 #define ARM 1 /* Customize coffcode.h. */
880
881 #ifndef ARM_WINCE
882 /* Make sure that the 'r_offset' field is copied properly
883 so that identical binaries will compare the same. */
884 #define SWAP_IN_RELOC_OFFSET H_GET_32
885 #define SWAP_OUT_RELOC_OFFSET H_PUT_32
886 #endif
887
888 /* Extend the coff_link_hash_table structure with a few ARM specific fields.
889 This allows us to store global data here without actually creating any
890 global variables, which is a no-no in the BFD world. */
891 struct coff_arm_link_hash_table
892 {
893 /* The original coff_link_hash_table structure. MUST be first field. */
894 struct coff_link_hash_table root;
895
896 /* The size in bytes of the section containing the Thumb-to-ARM glue. */
897 bfd_size_type thumb_glue_size;
898
899 /* The size in bytes of the section containing the ARM-to-Thumb glue. */
900 bfd_size_type arm_glue_size;
901
902 /* An arbitrary input BFD chosen to hold the glue sections. */
903 bfd * bfd_of_glue_owner;
904
905 /* Support interworking with old, non-interworking aware ARM code. */
906 int support_old_code;
907 };
908
909 /* Get the ARM coff linker hash table from a link_info structure. */
910 #define coff_arm_hash_table(info) \
911 ((struct coff_arm_link_hash_table *) ((info)->hash))
912
913 /* Create an ARM coff linker hash table. */
914
915 static struct bfd_link_hash_table *
916 coff_arm_link_hash_table_create (bfd * abfd)
917 {
918 struct coff_arm_link_hash_table * ret;
919 bfd_size_type amt = sizeof (struct coff_arm_link_hash_table);
920
921 ret = bfd_zmalloc (amt);
922 if (ret == NULL)
923 return NULL;
924
925 if (!_bfd_coff_link_hash_table_init (&ret->root,
926 abfd,
927 _bfd_coff_link_hash_newfunc,
928 sizeof (struct coff_link_hash_entry)))
929 {
930 free (ret);
931 return NULL;
932 }
933
934 return & ret->root.root;
935 }
936
937 static bfd_boolean
938 arm_emit_base_file_entry (struct bfd_link_info *info,
939 bfd *output_bfd,
940 asection *input_section,
941 bfd_vma reloc_offset)
942 {
943 bfd_vma addr = (reloc_offset
944 - input_section->vma
945 + input_section->output_offset
946 + input_section->output_section->vma);
947
948 if (coff_data (output_bfd)->pe)
949 addr -= pe_data (output_bfd)->pe_opthdr.ImageBase;
950 if (fwrite (&addr, sizeof (addr), 1, (FILE *) info->base_file) == 1)
951 return TRUE;
952
953 bfd_set_error (bfd_error_system_call);
954 return FALSE;
955 }
956 \f
957 #ifndef ARM_WINCE
958 /* The thumb form of a long branch is a bit finicky, because the offset
959 encoding is split over two fields, each in it's own instruction. They
960 can occur in any order. So given a thumb form of long branch, and an
961 offset, insert the offset into the thumb branch and return finished
962 instruction.
963
964 It takes two thumb instructions to encode the target address. Each has
965 11 bits to invest. The upper 11 bits are stored in one (identified by
966 H-0.. see below), the lower 11 bits are stored in the other (identified
967 by H-1).
968
969 Combine together and shifted left by 1 (it's a half word address) and
970 there you have it.
971
972 Op: 1111 = F,
973 H-0, upper address-0 = 000
974 Op: 1111 = F,
975 H-1, lower address-0 = 800
976
977 They can be ordered either way, but the arm tools I've seen always put
978 the lower one first. It probably doesn't matter. krk@cygnus.com
979
980 XXX: Actually the order does matter. The second instruction (H-1)
981 moves the computed address into the PC, so it must be the second one
982 in the sequence. The problem, however is that whilst little endian code
983 stores the instructions in HI then LOW order, big endian code does the
984 reverse. nickc@cygnus.com. */
985
986 #define LOW_HI_ORDER 0xF800F000
987 #define HI_LOW_ORDER 0xF000F800
988
989 static insn32
990 insert_thumb_branch (insn32 br_insn, int rel_off)
991 {
992 unsigned int low_bits;
993 unsigned int high_bits;
994
995 BFD_ASSERT ((rel_off & 1) != 1);
996
997 rel_off >>= 1; /* Half word aligned address. */
998 low_bits = rel_off & 0x000007FF; /* The bottom 11 bits. */
999 high_bits = (rel_off >> 11) & 0x000007FF; /* The top 11 bits. */
1000
1001 if ((br_insn & LOW_HI_ORDER) == LOW_HI_ORDER)
1002 br_insn = LOW_HI_ORDER | (low_bits << 16) | high_bits;
1003 else if ((br_insn & HI_LOW_ORDER) == HI_LOW_ORDER)
1004 br_insn = HI_LOW_ORDER | (high_bits << 16) | low_bits;
1005 else
1006 /* FIXME: the BFD library should never abort except for internal errors
1007 - it should return an error status. */
1008 abort (); /* Error - not a valid branch instruction form. */
1009
1010 return br_insn;
1011 }
1012
1013 \f
1014 static struct coff_link_hash_entry *
1015 find_thumb_glue (struct bfd_link_info *info,
1016 const char *name,
1017 bfd *input_bfd)
1018 {
1019 char *tmp_name;
1020 struct coff_link_hash_entry *myh;
1021 bfd_size_type amt = strlen (name) + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1;
1022
1023 tmp_name = bfd_malloc (amt);
1024
1025 BFD_ASSERT (tmp_name);
1026
1027 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
1028
1029 myh = coff_link_hash_lookup
1030 (coff_hash_table (info), tmp_name, FALSE, FALSE, TRUE);
1031
1032 if (myh == NULL)
1033 /* xgettext:c-format */
1034 _bfd_error_handler (_("%B: unable to find THUMB glue '%s' for `%s'"),
1035 input_bfd, tmp_name, name);
1036
1037 free (tmp_name);
1038
1039 return myh;
1040 }
1041 #endif /* not ARM_WINCE */
1042
1043 static struct coff_link_hash_entry *
1044 find_arm_glue (struct bfd_link_info *info,
1045 const char *name,
1046 bfd *input_bfd)
1047 {
1048 char *tmp_name;
1049 struct coff_link_hash_entry * myh;
1050 bfd_size_type amt = strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1;
1051
1052 tmp_name = bfd_malloc (amt);
1053
1054 BFD_ASSERT (tmp_name);
1055
1056 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
1057
1058 myh = coff_link_hash_lookup
1059 (coff_hash_table (info), tmp_name, FALSE, FALSE, TRUE);
1060
1061 if (myh == NULL)
1062 /* xgettext:c-format */
1063 _bfd_error_handler (_("%B: unable to find ARM glue '%s' for `%s'"),
1064 input_bfd, tmp_name, name);
1065
1066 free (tmp_name);
1067
1068 return myh;
1069 }
1070
1071 /*
1072 ARM->Thumb glue:
1073
1074 .arm
1075 __func_from_arm:
1076 ldr r12, __func_addr
1077 bx r12
1078 __func_addr:
1079 .word func @ behave as if you saw a ARM_32 reloc
1080 */
1081
1082 #define ARM2THUMB_GLUE_SIZE 12
1083 static const insn32 a2t1_ldr_insn = 0xe59fc000;
1084 static const insn32 a2t2_bx_r12_insn = 0xe12fff1c;
1085 static const insn32 a2t3_func_addr_insn = 0x00000001;
1086
1087 /*
1088 Thumb->ARM: Thumb->(non-interworking aware) ARM
1089
1090 .thumb .thumb
1091 .align 2 .align 2
1092 __func_from_thumb: __func_from_thumb:
1093 bx pc push {r6, lr}
1094 nop ldr r6, __func_addr
1095 .arm mov lr, pc
1096 __func_change_to_arm: bx r6
1097 b func .arm
1098 __func_back_to_thumb:
1099 ldmia r13! {r6, lr}
1100 bx lr
1101 __func_addr:
1102 .word func
1103 */
1104
1105 #define THUMB2ARM_GLUE_SIZE (globals->support_old_code ? 20 : 8)
1106 #ifndef ARM_WINCE
1107 static const insn16 t2a1_bx_pc_insn = 0x4778;
1108 static const insn16 t2a2_noop_insn = 0x46c0;
1109 static const insn32 t2a3_b_insn = 0xea000000;
1110
1111 static const insn16 t2a1_push_insn = 0xb540;
1112 static const insn16 t2a2_ldr_insn = 0x4e03;
1113 static const insn16 t2a3_mov_insn = 0x46fe;
1114 static const insn16 t2a4_bx_insn = 0x4730;
1115 static const insn32 t2a5_pop_insn = 0xe8bd4040;
1116 static const insn32 t2a6_bx_insn = 0xe12fff1e;
1117 #endif
1118
1119 /* TODO:
1120 We should really create new local (static) symbols in destination
1121 object for each stub we create. We should also create local
1122 (static) symbols within the stubs when switching between ARM and
1123 Thumb code. This will ensure that the debugger and disassembler
1124 can present a better view of stubs.
1125
1126 We can treat stubs like literal sections, and for the THUMB9 ones
1127 (short addressing range) we should be able to insert the stubs
1128 between sections. i.e. the simplest approach (since relocations
1129 are done on a section basis) is to dump the stubs at the end of
1130 processing a section. That way we can always try and minimise the
1131 offset to and from a stub. However, this does not map well onto
1132 the way that the linker/BFD does its work: mapping all input
1133 sections to output sections via the linker script before doing
1134 all the processing.
1135
1136 Unfortunately it may be easier to just to disallow short range
1137 Thumb->ARM stubs (i.e. no conditional inter-working branches,
1138 only branch-and-link (BL) calls. This will simplify the processing
1139 since we can then put all of the stubs into their own section.
1140
1141 TODO:
1142 On a different subject, rather than complaining when a
1143 branch cannot fit in the number of bits available for the
1144 instruction we should generate a trampoline stub (needed to
1145 address the complete 32bit address space). */
1146
1147 /* The standard COFF backend linker does not cope with the special
1148 Thumb BRANCH23 relocation. The alternative would be to split the
1149 BRANCH23 into seperate HI23 and LO23 relocations. However, it is a
1150 bit simpler simply providing our own relocation driver. */
1151
1152 /* The reloc processing routine for the ARM/Thumb COFF linker. NOTE:
1153 This code is a very slightly modified copy of
1154 _bfd_coff_generic_relocate_section. It would be a much more
1155 maintainable solution to have a MACRO that could be expanded within
1156 _bfd_coff_generic_relocate_section that would only be provided for
1157 ARM/Thumb builds. It is only the code marked THUMBEXTENSION that
1158 is different from the original. */
1159
1160 static bfd_boolean
1161 coff_arm_relocate_section (bfd *output_bfd,
1162 struct bfd_link_info *info,
1163 bfd *input_bfd,
1164 asection *input_section,
1165 bfd_byte *contents,
1166 struct internal_reloc *relocs,
1167 struct internal_syment *syms,
1168 asection **sections)
1169 {
1170 struct internal_reloc * rel;
1171 struct internal_reloc * relend;
1172 #ifndef ARM_WINCE
1173 bfd_vma high_address = bfd_get_section_limit (input_bfd, input_section);
1174 #endif
1175
1176 rel = relocs;
1177 relend = rel + input_section->reloc_count;
1178
1179 for (; rel < relend; rel++)
1180 {
1181 int done = 0;
1182 long symndx;
1183 struct coff_link_hash_entry * h;
1184 struct internal_syment * sym;
1185 bfd_vma addend;
1186 bfd_vma val;
1187 reloc_howto_type * howto;
1188 bfd_reloc_status_type rstat;
1189 bfd_vma h_val;
1190
1191 symndx = rel->r_symndx;
1192
1193 if (symndx == -1)
1194 {
1195 h = NULL;
1196 sym = NULL;
1197 }
1198 else
1199 {
1200 h = obj_coff_sym_hashes (input_bfd)[symndx];
1201 sym = syms + symndx;
1202 }
1203
1204 /* COFF treats common symbols in one of two ways. Either the
1205 size of the symbol is included in the section contents, or it
1206 is not. We assume that the size is not included, and force
1207 the rtype_to_howto function to adjust the addend as needed. */
1208
1209 if (sym != NULL && sym->n_scnum != 0)
1210 addend = - sym->n_value;
1211 else
1212 addend = 0;
1213
1214 howto = coff_rtype_to_howto (input_bfd, input_section, rel, h,
1215 sym, &addend);
1216 if (howto == NULL)
1217 return FALSE;
1218
1219 /* The relocation_section function will skip pcrel_offset relocs
1220 when doing a relocatable link. However, we want to convert
1221 ARM_26 to ARM_26D relocs if possible. We return a fake howto in
1222 this case without pcrel_offset set, and adjust the addend to
1223 compensate. 'partial_inplace' is also set, since we want 'done'
1224 relocations to be reflected in section's data. */
1225 if (rel->r_type == ARM_26
1226 && h != NULL
1227 && info->relocatable
1228 && (h->root.type == bfd_link_hash_defined
1229 || h->root.type == bfd_link_hash_defweak)
1230 && (h->root.u.def.section->output_section
1231 == input_section->output_section))
1232 {
1233 static reloc_howto_type fake_arm26_reloc =
1234 HOWTO (ARM_26,
1235 2,
1236 2,
1237 24,
1238 TRUE,
1239 0,
1240 complain_overflow_signed,
1241 aoutarm_fix_pcrel_26 ,
1242 "ARM_26",
1243 TRUE,
1244 0x00ffffff,
1245 0x00ffffff,
1246 FALSE);
1247
1248 addend -= rel->r_vaddr - input_section->vma;
1249 #ifdef ARM_WINCE
1250 /* FIXME: I don't know why, but the hack is necessary for correct
1251 generation of bl's instruction offset. */
1252 addend -= 8;
1253 #endif
1254 howto = & fake_arm26_reloc;
1255 }
1256
1257 #ifdef ARM_WINCE
1258 /* MS ARM-CE makes the reloc relative to the opcode's pc, not
1259 the next opcode's pc, so is off by one. */
1260 if (howto->pc_relative && !info->relocatable)
1261 addend -= 8;
1262 #endif
1263
1264 /* If we are doing a relocatable link, then we can just ignore
1265 a PC relative reloc that is pcrel_offset. It will already
1266 have the correct value. If this is not a relocatable link,
1267 then we should ignore the symbol value. */
1268 if (howto->pc_relative && howto->pcrel_offset)
1269 {
1270 if (info->relocatable)
1271 continue;
1272 /* FIXME - it is not clear which targets need this next test
1273 and which do not. It is known that it is needed for the
1274 VxWorks and EPOC-PE targets, but it is also known that it
1275 was suppressed for other ARM targets. This ought to be
1276 sorted out one day. */
1277 #ifdef ARM_COFF_BUGFIX
1278 /* We must not ignore the symbol value. If the symbol is
1279 within the same section, the relocation should have already
1280 been fixed, but if it is not, we'll be handed a reloc into
1281 the beginning of the symbol's section, so we must not cancel
1282 out the symbol's value, otherwise we'll be adding it in
1283 twice. */
1284 if (sym != NULL && sym->n_scnum != 0)
1285 addend += sym->n_value;
1286 #endif
1287 }
1288
1289 val = 0;
1290
1291 if (h == NULL)
1292 {
1293 asection *sec;
1294
1295 if (symndx == -1)
1296 {
1297 sec = bfd_abs_section_ptr;
1298 val = 0;
1299 }
1300 else
1301 {
1302 sec = sections[symndx];
1303 val = (sec->output_section->vma
1304 + sec->output_offset
1305 + sym->n_value
1306 - sec->vma);
1307 }
1308 }
1309 else
1310 {
1311 /* We don't output the stubs if we are generating a
1312 relocatable output file, since we may as well leave the
1313 stub generation to the final linker pass. If we fail to
1314 verify that the name is defined, we'll try to build stubs
1315 for an undefined name... */
1316 if (! info->relocatable
1317 && ( h->root.type == bfd_link_hash_defined
1318 || h->root.type == bfd_link_hash_defweak))
1319 {
1320 asection * h_sec = h->root.u.def.section;
1321 const char * name = h->root.root.string;
1322
1323 /* h locates the symbol referenced in the reloc. */
1324 h_val = (h->root.u.def.value
1325 + h_sec->output_section->vma
1326 + h_sec->output_offset);
1327
1328 if (howto->type == ARM_26)
1329 {
1330 if ( h->symbol_class == C_THUMBSTATFUNC
1331 || h->symbol_class == C_THUMBEXTFUNC)
1332 {
1333 /* Arm code calling a Thumb function. */
1334 unsigned long int tmp;
1335 bfd_vma my_offset;
1336 asection * s;
1337 long int ret_offset;
1338 struct coff_link_hash_entry * myh;
1339 struct coff_arm_link_hash_table * globals;
1340
1341 myh = find_arm_glue (info, name, input_bfd);
1342 if (myh == NULL)
1343 return FALSE;
1344
1345 globals = coff_arm_hash_table (info);
1346
1347 BFD_ASSERT (globals != NULL);
1348 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1349
1350 my_offset = myh->root.u.def.value;
1351
1352 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
1353 ARM2THUMB_GLUE_SECTION_NAME);
1354 BFD_ASSERT (s != NULL);
1355 BFD_ASSERT (s->contents != NULL);
1356 BFD_ASSERT (s->output_section != NULL);
1357
1358 if ((my_offset & 0x01) == 0x01)
1359 {
1360 if (h_sec->owner != NULL
1361 && INTERWORK_SET (h_sec->owner)
1362 && ! INTERWORK_FLAG (h_sec->owner))
1363 _bfd_error_handler
1364 /* xgettext:c-format */
1365 (_("%B(%s): warning: interworking not enabled.\n"
1366 " first occurrence: %B: arm call to thumb"),
1367 h_sec->owner, input_bfd, name);
1368
1369 --my_offset;
1370 myh->root.u.def.value = my_offset;
1371
1372 bfd_put_32 (output_bfd, (bfd_vma) a2t1_ldr_insn,
1373 s->contents + my_offset);
1374
1375 bfd_put_32 (output_bfd, (bfd_vma) a2t2_bx_r12_insn,
1376 s->contents + my_offset + 4);
1377
1378 /* It's a thumb address. Add the low order bit. */
1379 bfd_put_32 (output_bfd, h_val | a2t3_func_addr_insn,
1380 s->contents + my_offset + 8);
1381
1382 if (info->base_file
1383 && !arm_emit_base_file_entry (info, output_bfd,
1384 s, my_offset + 8))
1385 return FALSE;
1386 }
1387
1388 BFD_ASSERT (my_offset <= globals->arm_glue_size);
1389
1390 tmp = bfd_get_32 (input_bfd, contents + rel->r_vaddr
1391 - input_section->vma);
1392
1393 tmp = tmp & 0xFF000000;
1394
1395 /* Somehow these are both 4 too far, so subtract 8. */
1396 ret_offset =
1397 s->output_offset
1398 + my_offset
1399 + s->output_section->vma
1400 - (input_section->output_offset
1401 + input_section->output_section->vma
1402 + rel->r_vaddr)
1403 - 8;
1404
1405 tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
1406
1407 bfd_put_32 (output_bfd, (bfd_vma) tmp,
1408 contents + rel->r_vaddr - input_section->vma);
1409 done = 1;
1410 }
1411 }
1412
1413 #ifndef ARM_WINCE
1414 /* Note: We used to check for ARM_THUMB9 and ARM_THUMB12. */
1415 else if (howto->type == ARM_THUMB23)
1416 {
1417 if ( h->symbol_class == C_EXT
1418 || h->symbol_class == C_STAT
1419 || h->symbol_class == C_LABEL)
1420 {
1421 /* Thumb code calling an ARM function. */
1422 asection * s = 0;
1423 bfd_vma my_offset;
1424 unsigned long int tmp;
1425 long int ret_offset;
1426 struct coff_link_hash_entry * myh;
1427 struct coff_arm_link_hash_table * globals;
1428
1429 myh = find_thumb_glue (info, name, input_bfd);
1430 if (myh == NULL)
1431 return FALSE;
1432
1433 globals = coff_arm_hash_table (info);
1434
1435 BFD_ASSERT (globals != NULL);
1436 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1437
1438 my_offset = myh->root.u.def.value;
1439
1440 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
1441 THUMB2ARM_GLUE_SECTION_NAME);
1442
1443 BFD_ASSERT (s != NULL);
1444 BFD_ASSERT (s->contents != NULL);
1445 BFD_ASSERT (s->output_section != NULL);
1446
1447 if ((my_offset & 0x01) == 0x01)
1448 {
1449 if (h_sec->owner != NULL
1450 && INTERWORK_SET (h_sec->owner)
1451 && ! INTERWORK_FLAG (h_sec->owner)
1452 && ! globals->support_old_code)
1453 _bfd_error_handler
1454 /* xgettext:c-format */
1455 (_("%B(%s): warning: interworking not enabled.\n"
1456 " first occurrence: %B: thumb call to arm\n"
1457 " consider relinking with --support-old-code enabled"),
1458 h_sec->owner, input_bfd, name);
1459
1460 -- my_offset;
1461 myh->root.u.def.value = my_offset;
1462
1463 if (globals->support_old_code)
1464 {
1465 bfd_put_16 (output_bfd, (bfd_vma) t2a1_push_insn,
1466 s->contents + my_offset);
1467
1468 bfd_put_16 (output_bfd, (bfd_vma) t2a2_ldr_insn,
1469 s->contents + my_offset + 2);
1470
1471 bfd_put_16 (output_bfd, (bfd_vma) t2a3_mov_insn,
1472 s->contents + my_offset + 4);
1473
1474 bfd_put_16 (output_bfd, (bfd_vma) t2a4_bx_insn,
1475 s->contents + my_offset + 6);
1476
1477 bfd_put_32 (output_bfd, (bfd_vma) t2a5_pop_insn,
1478 s->contents + my_offset + 8);
1479
1480 bfd_put_32 (output_bfd, (bfd_vma) t2a6_bx_insn,
1481 s->contents + my_offset + 12);
1482
1483 /* Store the address of the function in the last word of the stub. */
1484 bfd_put_32 (output_bfd, h_val,
1485 s->contents + my_offset + 16);
1486
1487 if (info->base_file
1488 && !arm_emit_base_file_entry (info,
1489 output_bfd, s,
1490 my_offset + 16))
1491 return FALSE;
1492 }
1493 else
1494 {
1495 bfd_put_16 (output_bfd, (bfd_vma) t2a1_bx_pc_insn,
1496 s->contents + my_offset);
1497
1498 bfd_put_16 (output_bfd, (bfd_vma) t2a2_noop_insn,
1499 s->contents + my_offset + 2);
1500
1501 ret_offset =
1502 /* Address of destination of the stub. */
1503 ((bfd_signed_vma) h_val)
1504 - ((bfd_signed_vma)
1505 /* Offset from the start of the current section to the start of the stubs. */
1506 (s->output_offset
1507 /* Offset of the start of this stub from the start of the stubs. */
1508 + my_offset
1509 /* Address of the start of the current section. */
1510 + s->output_section->vma)
1511 /* The branch instruction is 4 bytes into the stub. */
1512 + 4
1513 /* ARM branches work from the pc of the instruction + 8. */
1514 + 8);
1515
1516 bfd_put_32 (output_bfd,
1517 (bfd_vma) t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
1518 s->contents + my_offset + 4);
1519
1520 }
1521 }
1522
1523 BFD_ASSERT (my_offset <= globals->thumb_glue_size);
1524
1525 /* Now go back and fix up the original BL insn to point
1526 to here. */
1527 ret_offset =
1528 s->output_offset
1529 + my_offset
1530 - (input_section->output_offset
1531 + rel->r_vaddr)
1532 -4;
1533
1534 tmp = bfd_get_32 (input_bfd, contents + rel->r_vaddr
1535 - input_section->vma);
1536
1537 bfd_put_32 (output_bfd,
1538 (bfd_vma) insert_thumb_branch (tmp,
1539 ret_offset),
1540 contents + rel->r_vaddr - input_section->vma);
1541
1542 done = 1;
1543 }
1544 }
1545 #endif
1546 }
1547
1548 /* If the relocation type and destination symbol does not
1549 fall into one of the above categories, then we can just
1550 perform a direct link. */
1551
1552 if (done)
1553 rstat = bfd_reloc_ok;
1554 else
1555 if ( h->root.type == bfd_link_hash_defined
1556 || h->root.type == bfd_link_hash_defweak)
1557 {
1558 asection *sec;
1559
1560 sec = h->root.u.def.section;
1561 val = (h->root.u.def.value
1562 + sec->output_section->vma
1563 + sec->output_offset);
1564 }
1565
1566 else if (! info->relocatable)
1567 {
1568 if (! ((*info->callbacks->undefined_symbol)
1569 (info, h->root.root.string, input_bfd, input_section,
1570 rel->r_vaddr - input_section->vma, TRUE)))
1571 return FALSE;
1572 }
1573 }
1574
1575 /* Emit a reloc if the backend thinks it needs it. */
1576 if (info->base_file
1577 && sym
1578 && pe_data(output_bfd)->in_reloc_p(output_bfd, howto)
1579 && !arm_emit_base_file_entry (info, output_bfd, input_section,
1580 rel->r_vaddr))
1581 return FALSE;
1582
1583 if (done)
1584 rstat = bfd_reloc_ok;
1585 #ifndef ARM_WINCE
1586 /* Only perform this fix during the final link, not a relocatable link. */
1587 else if (! info->relocatable
1588 && howto->type == ARM_THUMB23)
1589 {
1590 /* This is pretty much a copy of what the default
1591 _bfd_final_link_relocate and _bfd_relocate_contents
1592 routines do to perform a relocation, with special
1593 processing for the split addressing of the Thumb BL
1594 instruction. Again, it would probably be simpler adding a
1595 ThumbBRANCH23 specific macro expansion into the default
1596 code. */
1597
1598 bfd_vma address = rel->r_vaddr - input_section->vma;
1599
1600 if (address > high_address)
1601 rstat = bfd_reloc_outofrange;
1602 else
1603 {
1604 bfd_vma relocation = val + addend;
1605 int size = bfd_get_reloc_size (howto);
1606 bfd_boolean overflow = FALSE;
1607 bfd_byte *location = contents + address;
1608 bfd_vma x = bfd_get_32 (input_bfd, location);
1609 bfd_vma src_mask = 0x007FFFFE;
1610 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
1611 bfd_signed_vma reloc_signed_min = ~reloc_signed_max;
1612 bfd_vma check;
1613 bfd_signed_vma signed_check;
1614 bfd_vma add;
1615 bfd_signed_vma signed_add;
1616
1617 BFD_ASSERT (size == 4);
1618
1619 /* howto->pc_relative should be TRUE for type 14 BRANCH23. */
1620 relocation -= (input_section->output_section->vma
1621 + input_section->output_offset);
1622
1623 /* howto->pcrel_offset should be TRUE for type 14 BRANCH23. */
1624 relocation -= address;
1625
1626 /* No need to negate the relocation with BRANCH23. */
1627 /* howto->complain_on_overflow == complain_overflow_signed for BRANCH23. */
1628 /* howto->rightshift == 1 */
1629
1630 /* Drop unwanted bits from the value we are relocating to. */
1631 check = relocation >> howto->rightshift;
1632
1633 /* If this is a signed value, the rightshift just dropped
1634 leading 1 bits (assuming twos complement). */
1635 if ((bfd_signed_vma) relocation >= 0)
1636 signed_check = check;
1637 else
1638 signed_check = (check
1639 | ((bfd_vma) - 1
1640 & ~((bfd_vma) - 1 >> howto->rightshift)));
1641
1642 /* Get the value from the object file. */
1643 if (bfd_big_endian (input_bfd))
1644 add = (((x) & 0x07ff0000) >> 4) | (((x) & 0x7ff) << 1);
1645 else
1646 add = ((((x) & 0x7ff) << 12) | (((x) & 0x07ff0000) >> 15));
1647
1648 /* Get the value from the object file with an appropriate sign.
1649 The expression involving howto->src_mask isolates the upper
1650 bit of src_mask. If that bit is set in the value we are
1651 adding, it is negative, and we subtract out that number times
1652 two. If src_mask includes the highest possible bit, then we
1653 can not get the upper bit, but that does not matter since
1654 signed_add needs no adjustment to become negative in that
1655 case. */
1656 signed_add = add;
1657
1658 if ((add & (((~ src_mask) >> 1) & src_mask)) != 0)
1659 signed_add -= (((~ src_mask) >> 1) & src_mask) << 1;
1660
1661 /* howto->bitpos == 0 */
1662 /* Add the value from the object file, shifted so that it is a
1663 straight number. */
1664 signed_check += signed_add;
1665 relocation += signed_add;
1666
1667 BFD_ASSERT (howto->complain_on_overflow == complain_overflow_signed);
1668
1669 /* Assumes two's complement. */
1670 if ( signed_check > reloc_signed_max
1671 || signed_check < reloc_signed_min)
1672 overflow = TRUE;
1673
1674 /* Put the relocation into the correct bits.
1675 For a BLX instruction, make sure that the relocation is rounded up
1676 to a word boundary. This follows the semantics of the instruction
1677 which specifies that bit 1 of the target address will come from bit
1678 1 of the base address. */
1679 if (bfd_big_endian (input_bfd))
1680 {
1681 if ((x & 0x1800) == 0x0800 && (relocation & 0x02))
1682 relocation += 2;
1683 relocation = (((relocation & 0xffe) >> 1) | ((relocation << 4) & 0x07ff0000));
1684 }
1685 else
1686 {
1687 if ((x & 0x18000000) == 0x08000000 && (relocation & 0x02))
1688 relocation += 2;
1689 relocation = (((relocation & 0xffe) << 15) | ((relocation >> 12) & 0x7ff));
1690 }
1691
1692 /* Add the relocation to the correct bits of X. */
1693 x = ((x & ~howto->dst_mask) | relocation);
1694
1695 /* Put the relocated value back in the object file. */
1696 bfd_put_32 (input_bfd, x, location);
1697
1698 rstat = overflow ? bfd_reloc_overflow : bfd_reloc_ok;
1699 }
1700 }
1701 #endif
1702 else
1703 if (info->relocatable && ! howto->partial_inplace)
1704 rstat = bfd_reloc_ok;
1705 else
1706 rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
1707 contents,
1708 rel->r_vaddr - input_section->vma,
1709 val, addend);
1710 /* Only perform this fix during the final link, not a relocatable link. */
1711 if (! info->relocatable
1712 && (rel->r_type == ARM_32 || rel->r_type == ARM_RVA32))
1713 {
1714 /* Determine if we need to set the bottom bit of a relocated address
1715 because the address is the address of a Thumb code symbol. */
1716 int patchit = FALSE;
1717
1718 if (h != NULL
1719 && ( h->symbol_class == C_THUMBSTATFUNC
1720 || h->symbol_class == C_THUMBEXTFUNC))
1721 {
1722 patchit = TRUE;
1723 }
1724 else if (sym != NULL
1725 && sym->n_scnum > N_UNDEF)
1726 {
1727 /* No hash entry - use the symbol instead. */
1728 if ( sym->n_sclass == C_THUMBSTATFUNC
1729 || sym->n_sclass == C_THUMBEXTFUNC)
1730 patchit = TRUE;
1731 }
1732
1733 if (patchit)
1734 {
1735 bfd_byte * location = contents + rel->r_vaddr - input_section->vma;
1736 bfd_vma x = bfd_get_32 (input_bfd, location);
1737
1738 bfd_put_32 (input_bfd, x | 1, location);
1739 }
1740 }
1741
1742 switch (rstat)
1743 {
1744 default:
1745 abort ();
1746 case bfd_reloc_ok:
1747 break;
1748 case bfd_reloc_outofrange:
1749 (*_bfd_error_handler)
1750 (_("%B: bad reloc address 0x%lx in section `%A'"),
1751 input_bfd, input_section, (unsigned long) rel->r_vaddr);
1752 return FALSE;
1753 case bfd_reloc_overflow:
1754 {
1755 const char *name;
1756 char buf[SYMNMLEN + 1];
1757
1758 if (symndx == -1)
1759 name = "*ABS*";
1760 else if (h != NULL)
1761 name = NULL;
1762 else
1763 {
1764 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
1765 if (name == NULL)
1766 return FALSE;
1767 }
1768
1769 if (! ((*info->callbacks->reloc_overflow)
1770 (info, (h ? &h->root : NULL), name, howto->name,
1771 (bfd_vma) 0, input_bfd, input_section,
1772 rel->r_vaddr - input_section->vma)))
1773 return FALSE;
1774 }
1775 }
1776 }
1777
1778 return TRUE;
1779 }
1780
1781 #ifndef COFF_IMAGE_WITH_PE
1782
1783 bfd_boolean
1784 bfd_arm_allocate_interworking_sections (struct bfd_link_info * info)
1785 {
1786 asection * s;
1787 bfd_byte * foo;
1788 struct coff_arm_link_hash_table * globals;
1789
1790 globals = coff_arm_hash_table (info);
1791
1792 BFD_ASSERT (globals != NULL);
1793
1794 if (globals->arm_glue_size != 0)
1795 {
1796 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1797
1798 s = bfd_get_section_by_name
1799 (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
1800
1801 BFD_ASSERT (s != NULL);
1802
1803 foo = bfd_alloc (globals->bfd_of_glue_owner, globals->arm_glue_size);
1804
1805 s->size = globals->arm_glue_size;
1806 s->contents = foo;
1807 }
1808
1809 if (globals->thumb_glue_size != 0)
1810 {
1811 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1812
1813 s = bfd_get_section_by_name
1814 (globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
1815
1816 BFD_ASSERT (s != NULL);
1817
1818 foo = bfd_alloc (globals->bfd_of_glue_owner, globals->thumb_glue_size);
1819
1820 s->size = globals->thumb_glue_size;
1821 s->contents = foo;
1822 }
1823
1824 return TRUE;
1825 }
1826
1827 static void
1828 record_arm_to_thumb_glue (struct bfd_link_info * info,
1829 struct coff_link_hash_entry * h)
1830 {
1831 const char * name = h->root.root.string;
1832 register asection * s;
1833 char * tmp_name;
1834 struct coff_link_hash_entry * myh;
1835 struct bfd_link_hash_entry * bh;
1836 struct coff_arm_link_hash_table * globals;
1837 bfd_vma val;
1838 bfd_size_type amt;
1839
1840 globals = coff_arm_hash_table (info);
1841
1842 BFD_ASSERT (globals != NULL);
1843 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1844
1845 s = bfd_get_section_by_name
1846 (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
1847
1848 BFD_ASSERT (s != NULL);
1849
1850 amt = strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1;
1851 tmp_name = bfd_malloc (amt);
1852
1853 BFD_ASSERT (tmp_name);
1854
1855 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
1856
1857 myh = coff_link_hash_lookup
1858 (coff_hash_table (info), tmp_name, FALSE, FALSE, TRUE);
1859
1860 if (myh != NULL)
1861 {
1862 free (tmp_name);
1863 /* We've already seen this guy. */
1864 return;
1865 }
1866
1867 /* The only trick here is using globals->arm_glue_size as the value. Even
1868 though the section isn't allocated yet, this is where we will be putting
1869 it. */
1870 bh = NULL;
1871 val = globals->arm_glue_size + 1;
1872 bfd_coff_link_add_one_symbol (info, globals->bfd_of_glue_owner, tmp_name,
1873 BSF_GLOBAL, s, val, NULL, TRUE, FALSE, &bh);
1874
1875 free (tmp_name);
1876
1877 globals->arm_glue_size += ARM2THUMB_GLUE_SIZE;
1878
1879 return;
1880 }
1881
1882 #ifndef ARM_WINCE
1883 static void
1884 record_thumb_to_arm_glue (struct bfd_link_info * info,
1885 struct coff_link_hash_entry * h)
1886 {
1887 const char * name = h->root.root.string;
1888 asection * s;
1889 char * tmp_name;
1890 struct coff_link_hash_entry * myh;
1891 struct bfd_link_hash_entry * bh;
1892 struct coff_arm_link_hash_table * globals;
1893 bfd_vma val;
1894 bfd_size_type amt;
1895
1896 globals = coff_arm_hash_table (info);
1897
1898 BFD_ASSERT (globals != NULL);
1899 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1900
1901 s = bfd_get_section_by_name
1902 (globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
1903
1904 BFD_ASSERT (s != NULL);
1905
1906 amt = strlen (name) + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1;
1907 tmp_name = bfd_malloc (amt);
1908
1909 BFD_ASSERT (tmp_name);
1910
1911 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
1912
1913 myh = coff_link_hash_lookup
1914 (coff_hash_table (info), tmp_name, FALSE, FALSE, TRUE);
1915
1916 if (myh != NULL)
1917 {
1918 free (tmp_name);
1919 /* We've already seen this guy. */
1920 return;
1921 }
1922
1923 bh = NULL;
1924 val = globals->thumb_glue_size + 1;
1925 bfd_coff_link_add_one_symbol (info, globals->bfd_of_glue_owner, tmp_name,
1926 BSF_GLOBAL, s, val, NULL, TRUE, FALSE, &bh);
1927
1928 /* If we mark it 'thumb', the disassembler will do a better job. */
1929 myh = (struct coff_link_hash_entry *) bh;
1930 myh->symbol_class = C_THUMBEXTFUNC;
1931
1932 free (tmp_name);
1933
1934 /* Allocate another symbol to mark where we switch to arm mode. */
1935
1936 #define CHANGE_TO_ARM "__%s_change_to_arm"
1937 #define BACK_FROM_ARM "__%s_back_from_arm"
1938
1939 amt = strlen (name) + strlen (CHANGE_TO_ARM) + 1;
1940 tmp_name = bfd_malloc (amt);
1941
1942 BFD_ASSERT (tmp_name);
1943
1944 sprintf (tmp_name, globals->support_old_code ? BACK_FROM_ARM : CHANGE_TO_ARM, name);
1945
1946 bh = NULL;
1947 val = globals->thumb_glue_size + (globals->support_old_code ? 8 : 4);
1948 bfd_coff_link_add_one_symbol (info, globals->bfd_of_glue_owner, tmp_name,
1949 BSF_LOCAL, s, val, NULL, TRUE, FALSE, &bh);
1950
1951 free (tmp_name);
1952
1953 globals->thumb_glue_size += THUMB2ARM_GLUE_SIZE;
1954
1955 return;
1956 }
1957 #endif /* not ARM_WINCE */
1958
1959 /* Select a BFD to be used to hold the sections used by the glue code.
1960 This function is called from the linker scripts in ld/emultempl/
1961 {armcoff/pe}.em */
1962
1963 bfd_boolean
1964 bfd_arm_get_bfd_for_interworking (bfd * abfd,
1965 struct bfd_link_info * info)
1966 {
1967 struct coff_arm_link_hash_table * globals;
1968 flagword flags;
1969 asection * sec;
1970
1971 /* If we are only performing a partial link do not bother
1972 getting a bfd to hold the glue. */
1973 if (info->relocatable)
1974 return TRUE;
1975
1976 globals = coff_arm_hash_table (info);
1977
1978 BFD_ASSERT (globals != NULL);
1979
1980 if (globals->bfd_of_glue_owner != NULL)
1981 return TRUE;
1982
1983 sec = bfd_get_section_by_name (abfd, ARM2THUMB_GLUE_SECTION_NAME);
1984
1985 if (sec == NULL)
1986 {
1987 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1988 | SEC_CODE | SEC_READONLY);
1989 sec = bfd_make_section_with_flags (abfd, ARM2THUMB_GLUE_SECTION_NAME,
1990 flags);
1991 if (sec == NULL
1992 || ! bfd_set_section_alignment (abfd, sec, 2))
1993 return FALSE;
1994 }
1995
1996 sec = bfd_get_section_by_name (abfd, THUMB2ARM_GLUE_SECTION_NAME);
1997
1998 if (sec == NULL)
1999 {
2000 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2001 | SEC_CODE | SEC_READONLY);
2002 sec = bfd_make_section_with_flags (abfd, THUMB2ARM_GLUE_SECTION_NAME,
2003 flags);
2004
2005 if (sec == NULL
2006 || ! bfd_set_section_alignment (abfd, sec, 2))
2007 return FALSE;
2008 }
2009
2010 /* Save the bfd for later use. */
2011 globals->bfd_of_glue_owner = abfd;
2012
2013 return TRUE;
2014 }
2015
2016 bfd_boolean
2017 bfd_arm_process_before_allocation (bfd * abfd,
2018 struct bfd_link_info * info,
2019 int support_old_code)
2020 {
2021 asection * sec;
2022 struct coff_arm_link_hash_table * globals;
2023
2024 /* If we are only performing a partial link do not bother
2025 to construct any glue. */
2026 if (info->relocatable)
2027 return TRUE;
2028
2029 /* Here we have a bfd that is to be included on the link. We have a hook
2030 to do reloc rummaging, before section sizes are nailed down. */
2031 _bfd_coff_get_external_symbols (abfd);
2032
2033 globals = coff_arm_hash_table (info);
2034
2035 BFD_ASSERT (globals != NULL);
2036 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2037
2038 globals->support_old_code = support_old_code;
2039
2040 /* Rummage around all the relocs and map the glue vectors. */
2041 sec = abfd->sections;
2042
2043 if (sec == NULL)
2044 return TRUE;
2045
2046 for (; sec != NULL; sec = sec->next)
2047 {
2048 struct internal_reloc * i;
2049 struct internal_reloc * rel;
2050
2051 if (sec->reloc_count == 0)
2052 continue;
2053
2054 /* Load the relocs. */
2055 /* FIXME: there may be a storage leak here. */
2056 i = _bfd_coff_read_internal_relocs (abfd, sec, 1, 0, 0, 0);
2057
2058 BFD_ASSERT (i != 0);
2059
2060 for (rel = i; rel < i + sec->reloc_count; ++rel)
2061 {
2062 unsigned short r_type = rel->r_type;
2063 long symndx;
2064 struct coff_link_hash_entry * h;
2065
2066 symndx = rel->r_symndx;
2067
2068 /* If the relocation is not against a symbol it cannot concern us. */
2069 if (symndx == -1)
2070 continue;
2071
2072 /* If the index is outside of the range of our table, something has gone wrong. */
2073 if (symndx >= obj_conv_table_size (abfd))
2074 {
2075 _bfd_error_handler (_("%B: illegal symbol index in reloc: %d"),
2076 abfd, symndx);
2077 continue;
2078 }
2079
2080 h = obj_coff_sym_hashes (abfd)[symndx];
2081
2082 /* If the relocation is against a static symbol it must be within
2083 the current section and so cannot be a cross ARM/Thumb relocation. */
2084 if (h == NULL)
2085 continue;
2086
2087 switch (r_type)
2088 {
2089 case ARM_26:
2090 /* This one is a call from arm code. We need to look up
2091 the target of the call. If it is a thumb target, we
2092 insert glue. */
2093
2094 if (h->symbol_class == C_THUMBEXTFUNC)
2095 record_arm_to_thumb_glue (info, h);
2096 break;
2097
2098 #ifndef ARM_WINCE
2099 case ARM_THUMB23:
2100 /* This one is a call from thumb code. We used to look
2101 for ARM_THUMB9 and ARM_THUMB12 as well. We need to look
2102 up the target of the call. If it is an arm target, we
2103 insert glue. If the symbol does not exist it will be
2104 given a class of C_EXT and so we will generate a stub
2105 for it. This is not really a problem, since the link
2106 is doomed anyway. */
2107
2108 switch (h->symbol_class)
2109 {
2110 case C_EXT:
2111 case C_STAT:
2112 case C_LABEL:
2113 record_thumb_to_arm_glue (info, h);
2114 break;
2115 default:
2116 ;
2117 }
2118 break;
2119 #endif
2120
2121 default:
2122 break;
2123 }
2124 }
2125 }
2126
2127 return TRUE;
2128 }
2129
2130 #endif /* ! defined (COFF_IMAGE_WITH_PE) */
2131
2132 #define coff_bfd_reloc_type_lookup coff_arm_reloc_type_lookup
2133 #define coff_bfd_reloc_name_lookup coff_arm_reloc_name_lookup
2134 #define coff_relocate_section coff_arm_relocate_section
2135 #define coff_bfd_is_local_label_name coff_arm_is_local_label_name
2136 #define coff_adjust_symndx coff_arm_adjust_symndx
2137 #define coff_link_output_has_begun coff_arm_link_output_has_begun
2138 #define coff_final_link_postscript coff_arm_final_link_postscript
2139 #define coff_bfd_merge_private_bfd_data coff_arm_merge_private_bfd_data
2140 #define coff_bfd_print_private_bfd_data coff_arm_print_private_bfd_data
2141 #define coff_bfd_set_private_flags _bfd_coff_arm_set_private_flags
2142 #define coff_bfd_copy_private_bfd_data coff_arm_copy_private_bfd_data
2143 #define coff_bfd_link_hash_table_create coff_arm_link_hash_table_create
2144
2145 /* When doing a relocatable link, we want to convert ARM_26 relocs
2146 into ARM_26D relocs. */
2147
2148 static bfd_boolean
2149 coff_arm_adjust_symndx (bfd *obfd ATTRIBUTE_UNUSED,
2150 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2151 bfd *ibfd,
2152 asection *sec,
2153 struct internal_reloc *irel,
2154 bfd_boolean *adjustedp)
2155 {
2156 if (irel->r_type == ARM_26)
2157 {
2158 struct coff_link_hash_entry *h;
2159
2160 h = obj_coff_sym_hashes (ibfd)[irel->r_symndx];
2161 if (h != NULL
2162 && (h->root.type == bfd_link_hash_defined
2163 || h->root.type == bfd_link_hash_defweak)
2164 && h->root.u.def.section->output_section == sec->output_section)
2165 irel->r_type = ARM_26D;
2166 }
2167 *adjustedp = FALSE;
2168 return TRUE;
2169 }
2170
2171 /* Called when merging the private data areas of two BFDs.
2172 This is important as it allows us to detect if we are
2173 attempting to merge binaries compiled for different ARM
2174 targets, eg different CPUs or different APCS's. */
2175
2176 static bfd_boolean
2177 coff_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
2178 {
2179 BFD_ASSERT (ibfd != NULL && obfd != NULL);
2180
2181 if (ibfd == obfd)
2182 return TRUE;
2183
2184 /* If the two formats are different we cannot merge anything.
2185 This is not an error, since it is permissable to change the
2186 input and output formats. */
2187 if ( ibfd->xvec->flavour != bfd_target_coff_flavour
2188 || obfd->xvec->flavour != bfd_target_coff_flavour)
2189 return TRUE;
2190
2191 /* Determine what should happen if the input ARM architecture
2192 does not match the output ARM architecture. */
2193 if (! bfd_arm_merge_machines (ibfd, obfd))
2194 return FALSE;
2195
2196 /* Verify that the APCS is the same for the two BFDs. */
2197 if (APCS_SET (ibfd))
2198 {
2199 if (APCS_SET (obfd))
2200 {
2201 /* If the src and dest have different APCS flag bits set, fail. */
2202 if (APCS_26_FLAG (obfd) != APCS_26_FLAG (ibfd))
2203 {
2204 _bfd_error_handler
2205 /* xgettext: c-format */
2206 (_("error: %B is compiled for APCS-%d, whereas %B is compiled for APCS-%d"),
2207 ibfd, obfd,
2208 APCS_26_FLAG (ibfd) ? 26 : 32,
2209 APCS_26_FLAG (obfd) ? 26 : 32
2210 );
2211
2212 bfd_set_error (bfd_error_wrong_format);
2213 return FALSE;
2214 }
2215
2216 if (APCS_FLOAT_FLAG (obfd) != APCS_FLOAT_FLAG (ibfd))
2217 {
2218 const char *msg;
2219
2220 if (APCS_FLOAT_FLAG (ibfd))
2221 /* xgettext: c-format */
2222 msg = _("error: %B passes floats in float registers, whereas %B passes them in integer registers");
2223 else
2224 /* xgettext: c-format */
2225 msg = _("error: %B passes floats in integer registers, whereas %B passes them in float registers");
2226
2227 _bfd_error_handler (msg, ibfd, obfd);
2228
2229 bfd_set_error (bfd_error_wrong_format);
2230 return FALSE;
2231 }
2232
2233 if (PIC_FLAG (obfd) != PIC_FLAG (ibfd))
2234 {
2235 const char * msg;
2236
2237 if (PIC_FLAG (ibfd))
2238 /* xgettext: c-format */
2239 msg = _("error: %B is compiled as position independent code, whereas target %B is absolute position");
2240 else
2241 /* xgettext: c-format */
2242 msg = _("error: %B is compiled as absolute position code, whereas target %B is position independent");
2243 _bfd_error_handler (msg, ibfd, obfd);
2244
2245 bfd_set_error (bfd_error_wrong_format);
2246 return FALSE;
2247 }
2248 }
2249 else
2250 {
2251 SET_APCS_FLAGS (obfd, APCS_26_FLAG (ibfd) | APCS_FLOAT_FLAG (ibfd) | PIC_FLAG (ibfd));
2252
2253 /* Set up the arch and fields as well as these are probably wrong. */
2254 bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
2255 }
2256 }
2257
2258 /* Check the interworking support. */
2259 if (INTERWORK_SET (ibfd))
2260 {
2261 if (INTERWORK_SET (obfd))
2262 {
2263 /* If the src and dest differ in their interworking issue a warning. */
2264 if (INTERWORK_FLAG (obfd) != INTERWORK_FLAG (ibfd))
2265 {
2266 const char * msg;
2267
2268 if (INTERWORK_FLAG (ibfd))
2269 /* xgettext: c-format */
2270 msg = _("Warning: %B supports interworking, whereas %B does not");
2271 else
2272 /* xgettext: c-format */
2273 msg = _("Warning: %B does not support interworking, whereas %B does");
2274
2275 _bfd_error_handler (msg, ibfd, obfd);
2276 }
2277 }
2278 else
2279 {
2280 SET_INTERWORK_FLAG (obfd, INTERWORK_FLAG (ibfd));
2281 }
2282 }
2283
2284 return TRUE;
2285 }
2286
2287 /* Display the flags field. */
2288
2289 static bfd_boolean
2290 coff_arm_print_private_bfd_data (bfd * abfd, void * ptr)
2291 {
2292 FILE * file = (FILE *) ptr;
2293
2294 BFD_ASSERT (abfd != NULL && ptr != NULL);
2295
2296 /* xgettext:c-format */
2297 fprintf (file, _("private flags = %x:"), coff_data (abfd)->flags);
2298
2299 if (APCS_SET (abfd))
2300 {
2301 /* xgettext: APCS is ARM Procedure Call Standard, it should not be translated. */
2302 fprintf (file, " [APCS-%d]", APCS_26_FLAG (abfd) ? 26 : 32);
2303
2304 if (APCS_FLOAT_FLAG (abfd))
2305 fprintf (file, _(" [floats passed in float registers]"));
2306 else
2307 fprintf (file, _(" [floats passed in integer registers]"));
2308
2309 if (PIC_FLAG (abfd))
2310 fprintf (file, _(" [position independent]"));
2311 else
2312 fprintf (file, _(" [absolute position]"));
2313 }
2314
2315 if (! INTERWORK_SET (abfd))
2316 fprintf (file, _(" [interworking flag not initialised]"));
2317 else if (INTERWORK_FLAG (abfd))
2318 fprintf (file, _(" [interworking supported]"));
2319 else
2320 fprintf (file, _(" [interworking not supported]"));
2321
2322 fputc ('\n', file);
2323
2324 return TRUE;
2325 }
2326
2327 /* Copies the given flags into the coff_tdata.flags field.
2328 Typically these flags come from the f_flags[] field of
2329 the COFF filehdr structure, which contains important,
2330 target specific information.
2331 Note: Although this function is static, it is explicitly
2332 called from both coffcode.h and peicode.h. */
2333
2334 static bfd_boolean
2335 _bfd_coff_arm_set_private_flags (bfd * abfd, flagword flags)
2336 {
2337 flagword flag;
2338
2339 BFD_ASSERT (abfd != NULL);
2340
2341 flag = (flags & F_APCS26) ? F_APCS_26 : 0;
2342
2343 /* Make sure that the APCS field has not been initialised to the opposite
2344 value. */
2345 if (APCS_SET (abfd)
2346 && ( (APCS_26_FLAG (abfd) != flag)
2347 || (APCS_FLOAT_FLAG (abfd) != (flags & F_APCS_FLOAT))
2348 || (PIC_FLAG (abfd) != (flags & F_PIC))
2349 ))
2350 return FALSE;
2351
2352 flag |= (flags & (F_APCS_FLOAT | F_PIC));
2353
2354 SET_APCS_FLAGS (abfd, flag);
2355
2356 flag = (flags & F_INTERWORK);
2357
2358 /* If the BFD has already had its interworking flag set, but it
2359 is different from the value that we have been asked to set,
2360 then assume that that merged code will not support interworking
2361 and set the flag accordingly. */
2362 if (INTERWORK_SET (abfd) && (INTERWORK_FLAG (abfd) != flag))
2363 {
2364 if (flag)
2365 /* xgettext: c-format */
2366 _bfd_error_handler (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
2367 abfd);
2368 else
2369 /* xgettext: c-format */
2370 _bfd_error_handler (_("Warning: Clearing the interworking flag of %B due to outside request"),
2371 abfd);
2372 flag = 0;
2373 }
2374
2375 SET_INTERWORK_FLAG (abfd, flag);
2376
2377 return TRUE;
2378 }
2379
2380 /* Copy the important parts of the target specific data
2381 from one instance of a BFD to another. */
2382
2383 static bfd_boolean
2384 coff_arm_copy_private_bfd_data (bfd * src, bfd * dest)
2385 {
2386 BFD_ASSERT (src != NULL && dest != NULL);
2387
2388 if (src == dest)
2389 return TRUE;
2390
2391 /* If the destination is not in the same format as the source, do not do
2392 the copy. */
2393 if (src->xvec != dest->xvec)
2394 return TRUE;
2395
2396 /* Copy the flags field. */
2397 if (APCS_SET (src))
2398 {
2399 if (APCS_SET (dest))
2400 {
2401 /* If the src and dest have different APCS flag bits set, fail. */
2402 if (APCS_26_FLAG (dest) != APCS_26_FLAG (src))
2403 return FALSE;
2404
2405 if (APCS_FLOAT_FLAG (dest) != APCS_FLOAT_FLAG (src))
2406 return FALSE;
2407
2408 if (PIC_FLAG (dest) != PIC_FLAG (src))
2409 return FALSE;
2410 }
2411 else
2412 SET_APCS_FLAGS (dest, APCS_26_FLAG (src) | APCS_FLOAT_FLAG (src)
2413 | PIC_FLAG (src));
2414 }
2415
2416 if (INTERWORK_SET (src))
2417 {
2418 if (INTERWORK_SET (dest))
2419 {
2420 /* If the src and dest have different interworking flags then turn
2421 off the interworking bit. */
2422 if (INTERWORK_FLAG (dest) != INTERWORK_FLAG (src))
2423 {
2424 if (INTERWORK_FLAG (dest))
2425 {
2426 /* xgettext:c-format */
2427 _bfd_error_handler (("\
2428 Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
2429 dest, src);
2430 }
2431
2432 SET_INTERWORK_FLAG (dest, 0);
2433 }
2434 }
2435 else
2436 {
2437 SET_INTERWORK_FLAG (dest, INTERWORK_FLAG (src));
2438 }
2439 }
2440
2441 return TRUE;
2442 }
2443
2444 /* Note: the definitions here of LOCAL_LABEL_PREFIX and USER_LABEL_PREIFX
2445 *must* match the definitions in gcc/config/arm/{coff|semi|aout}.h. */
2446 #ifndef LOCAL_LABEL_PREFIX
2447 #define LOCAL_LABEL_PREFIX ""
2448 #endif
2449 #ifndef USER_LABEL_PREFIX
2450 #define USER_LABEL_PREFIX "_"
2451 #endif
2452
2453 /* Like _bfd_coff_is_local_label_name, but
2454 a) test against USER_LABEL_PREFIX, to avoid stripping labels known to be
2455 non-local.
2456 b) Allow other prefixes than ".", e.g. an empty prefix would cause all
2457 labels of the form Lxxx to be stripped. */
2458
2459 static bfd_boolean
2460 coff_arm_is_local_label_name (bfd * abfd ATTRIBUTE_UNUSED,
2461 const char * name)
2462 {
2463 #ifdef USER_LABEL_PREFIX
2464 if (USER_LABEL_PREFIX[0] != 0)
2465 {
2466 size_t len = strlen (USER_LABEL_PREFIX);
2467
2468 if (strncmp (name, USER_LABEL_PREFIX, len) == 0)
2469 return FALSE;
2470 }
2471 #endif
2472
2473 #ifdef LOCAL_LABEL_PREFIX
2474 /* If there is a prefix for local labels then look for this.
2475 If the prefix exists, but it is empty, then ignore the test. */
2476
2477 if (LOCAL_LABEL_PREFIX[0] != 0)
2478 {
2479 size_t len = strlen (LOCAL_LABEL_PREFIX);
2480
2481 if (strncmp (name, LOCAL_LABEL_PREFIX, len) != 0)
2482 return FALSE;
2483
2484 /* Perform the checks below for the rest of the name. */
2485 name += len;
2486 }
2487 #endif
2488
2489 return name[0] == 'L';
2490 }
2491
2492 /* This piece of machinery exists only to guarantee that the bfd that holds
2493 the glue section is written last.
2494
2495 This does depend on bfd_make_section attaching a new section to the
2496 end of the section list for the bfd. */
2497
2498 static bfd_boolean
2499 coff_arm_link_output_has_begun (bfd * sub, struct coff_final_link_info * info)
2500 {
2501 return (sub->output_has_begun
2502 || sub == coff_arm_hash_table (info->info)->bfd_of_glue_owner);
2503 }
2504
2505 static bfd_boolean
2506 coff_arm_final_link_postscript (bfd * abfd ATTRIBUTE_UNUSED,
2507 struct coff_final_link_info * pfinfo)
2508 {
2509 struct coff_arm_link_hash_table * globals;
2510
2511 globals = coff_arm_hash_table (pfinfo->info);
2512
2513 BFD_ASSERT (globals != NULL);
2514
2515 if (globals->bfd_of_glue_owner != NULL)
2516 {
2517 if (! _bfd_coff_link_input_bfd (pfinfo, globals->bfd_of_glue_owner))
2518 return FALSE;
2519
2520 globals->bfd_of_glue_owner->output_has_begun = TRUE;
2521 }
2522
2523 return bfd_arm_update_notes (abfd, ARM_NOTE_SECTION);
2524 }
2525
2526 #ifndef bfd_pe_print_pdata
2527 #define bfd_pe_print_pdata NULL
2528 #endif
2529
2530 #include "coffcode.h"
2531
2532 #ifndef TARGET_LITTLE_SYM
2533 #define TARGET_LITTLE_SYM armcoff_little_vec
2534 #endif
2535 #ifndef TARGET_LITTLE_NAME
2536 #define TARGET_LITTLE_NAME "coff-arm-little"
2537 #endif
2538 #ifndef TARGET_BIG_SYM
2539 #define TARGET_BIG_SYM armcoff_big_vec
2540 #endif
2541 #ifndef TARGET_BIG_NAME
2542 #define TARGET_BIG_NAME "coff-arm-big"
2543 #endif
2544
2545 #ifndef TARGET_UNDERSCORE
2546 #define TARGET_UNDERSCORE 0
2547 #endif
2548
2549 #ifndef EXTRA_S_FLAGS
2550 #ifdef COFF_WITH_PE
2551 #define EXTRA_S_FLAGS (SEC_CODE | SEC_LINK_ONCE | SEC_LINK_DUPLICATES)
2552 #else
2553 #define EXTRA_S_FLAGS SEC_CODE
2554 #endif
2555 #endif
2556
2557 /* Forward declaration for use initialising alternative_target field. */
2558 extern const bfd_target TARGET_BIG_SYM ;
2559
2560 /* Target vectors. */
2561 CREATE_LITTLE_COFF_TARGET_VEC (TARGET_LITTLE_SYM, TARGET_LITTLE_NAME, D_PAGED, EXTRA_S_FLAGS, TARGET_UNDERSCORE, & TARGET_BIG_SYM, COFF_SWAP_TABLE)
2562 CREATE_BIG_COFF_TARGET_VEC (TARGET_BIG_SYM, TARGET_BIG_NAME, D_PAGED, EXTRA_S_FLAGS, TARGET_UNDERSCORE, & TARGET_LITTLE_SYM, COFF_SWAP_TABLE)
GDB Binutils - Deliverables
This page took 0.108069 seconds and 4 git commands to generate.