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