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