?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* config/tc-ia64.c (ia64_cons_fix_new): Handle 8 byte iplt reloc
[binutils.git] / bfd / coff-arm.c
blobfd0e0dd15d42e164e595b9a2e6ddd0504bcb4ae9
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 /* Make sure that the 'r_offset' field is copied properly
904 so that identical binaries will compare the same. */
905 #define SWAP_IN_RELOC_OFFSET H_GET_32
906 #define SWAP_OUT_RELOC_OFFSET H_PUT_32
907
908 /* Extend the coff_link_hash_table structure with a few ARM specific fields.
909 This allows us to store global data here without actually creating any
910 global variables, which is a no-no in the BFD world. */
911 struct coff_arm_link_hash_table
912 {
913 /* The original coff_link_hash_table structure. MUST be first field. */
914 struct coff_link_hash_table root;
915
916 /* The size in bytes of the section containg the Thumb-to-ARM glue. */
917 bfd_size_type thumb_glue_size;
918
919 /* The size in bytes of the section containg the ARM-to-Thumb glue. */
920 bfd_size_type arm_glue_size;
921
922 /* An arbitary input BFD chosen to hold the glue sections. */
923 bfd * bfd_of_glue_owner;
924
925 /* Support interworking with old, non-interworking aware ARM code. */
926 int support_old_code;
927 };
928
929 /* Get the ARM coff linker hash table from a link_info structure. */
930 #define coff_arm_hash_table(info) \
931 ((struct coff_arm_link_hash_table *) ((info)->hash))
932
933 /* Create an ARM coff linker hash table. */
934
935 static struct bfd_link_hash_table *
936 coff_arm_link_hash_table_create (abfd)
937 bfd * abfd;
938 {
939 struct coff_arm_link_hash_table * ret;
940 bfd_size_type amt = sizeof (struct coff_arm_link_hash_table);
941
942 ret = (struct coff_arm_link_hash_table *) bfd_alloc (abfd, amt);
943 if (ret == (struct coff_arm_link_hash_table *) NULL)
944 return NULL;
945
946 if (! _bfd_coff_link_hash_table_init
947 (& ret->root, abfd, _bfd_coff_link_hash_newfunc))
948 {
949 bfd_release (abfd, ret);
950 return (struct bfd_link_hash_table *) NULL;
951 }
952
953 ret->thumb_glue_size = 0;
954 ret->arm_glue_size = 0;
955 ret->bfd_of_glue_owner = NULL;
956
957 return & ret->root.root;
958 }
959
960 static void
961 arm_emit_base_file_entry (info, output_bfd, input_section, reloc_offset)
962 struct bfd_link_info *info;
963 bfd *output_bfd;
964 asection *input_section;
965 bfd_vma reloc_offset;
966 {
967 bfd_vma addr = reloc_offset
968 - input_section->vma
969 + input_section->output_offset
970 + input_section->output_section->vma;
971
972 if (coff_data (output_bfd)->pe)
973 addr -= pe_data (output_bfd)->pe_opthdr.ImageBase;
974 fwrite (& addr, 1, sizeof (addr), (FILE *) info->base_file);
975
976 }
977 \f
978 /* The thumb form of a long branch is a bit finicky, because the offset
979 encoding is split over two fields, each in it's own instruction. They
980 can occur in any order. So given a thumb form of long branch, and an
981 offset, insert the offset into the thumb branch and return finished
982 instruction.
983
984 It takes two thumb instructions to encode the target address. Each has
985 11 bits to invest. The upper 11 bits are stored in one (identifed by
986 H-0.. see below), the lower 11 bits are stored in the other (identified
987 by H-1).
988
989 Combine together and shifted left by 1 (it's a half word address) and
990 there you have it.
991
992 Op: 1111 = F,
993 H-0, upper address-0 = 000
994 Op: 1111 = F,
995 H-1, lower address-0 = 800
996
997 They can be ordered either way, but the arm tools I've seen always put
998 the lower one first. It probably doesn't matter. krk@cygnus.com
999
1000 XXX: Actually the order does matter. The second instruction (H-1)
1001 moves the computed address into the PC, so it must be the second one
1002 in the sequence. The problem, however is that whilst little endian code
1003 stores the instructions in HI then LOW order, big endian code does the
1004 reverse. nickc@cygnus.com. */
1005
1006 #define LOW_HI_ORDER 0xF800F000
1007 #define HI_LOW_ORDER 0xF000F800
1008
1009 static insn32
1010 insert_thumb_branch (br_insn, rel_off)
1011 insn32 br_insn;
1012 int rel_off;
1013 {
1014 unsigned int low_bits;
1015 unsigned int high_bits;
1016
1017 BFD_ASSERT((rel_off & 1) != 1);
1018
1019 rel_off >>= 1; /* half word aligned address */
1020 low_bits = rel_off & 0x000007FF; /* the bottom 11 bits */
1021 high_bits = (rel_off >> 11) & 0x000007FF; /* the top 11 bits */
1022
1023 if ((br_insn & LOW_HI_ORDER) == LOW_HI_ORDER)
1024 br_insn = LOW_HI_ORDER | (low_bits << 16) | high_bits;
1025 else if ((br_insn & HI_LOW_ORDER) == HI_LOW_ORDER)
1026 br_insn = HI_LOW_ORDER | (high_bits << 16) | low_bits;
1027 else
1028 /* FIXME: the BFD library should never abort except for internal errors
1029 - it should return an error status. */
1030 abort (); /* Error - not a valid branch instruction form. */
1031
1032 return br_insn;
1033 }
1034 \f
1035 static struct coff_link_hash_entry *
1036 find_thumb_glue (info, name, input_bfd)
1037 struct bfd_link_info *info;
1038 const char *name;
1039 bfd *input_bfd;
1040 {
1041 char *tmp_name;
1042 struct coff_link_hash_entry *myh;
1043 bfd_size_type amt = strlen (name) + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1;
1044
1045 tmp_name = (char *) bfd_malloc (amt);
1046
1047 BFD_ASSERT (tmp_name);
1048
1049 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
1050
1051 myh = coff_link_hash_lookup
1052 (coff_hash_table (info), tmp_name, false, false, true);
1053
1054 if (myh == NULL)
1055 /* xgettext:c-format */
1056 _bfd_error_handler (_("%s: unable to find THUMB glue '%s' for `%s'"),
1057 bfd_archive_filename (input_bfd), tmp_name, name);
1058
1059 free (tmp_name);
1060
1061 return myh;
1062 }
1063
1064 static struct coff_link_hash_entry *
1065 find_arm_glue (info, name, input_bfd)
1066 struct bfd_link_info *info;
1067 const char *name;
1068 bfd *input_bfd;
1069 {
1070 char *tmp_name;
1071 struct coff_link_hash_entry * myh;
1072 bfd_size_type amt = strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1;
1073
1074 tmp_name = (char *) bfd_malloc (amt);
1075
1076 BFD_ASSERT (tmp_name);
1077
1078 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
1079
1080 myh = coff_link_hash_lookup
1081 (coff_hash_table (info), tmp_name, false, false, true);
1082
1083 if (myh == NULL)
1084 /* xgettext:c-format */
1085 _bfd_error_handler (_("%s: unable to find ARM glue '%s' for `%s'"),
1086 bfd_archive_filename (input_bfd), tmp_name, name);
1087
1088 free (tmp_name);
1089
1090 return myh;
1091 }
1092
1093 /*
1094 ARM->Thumb glue:
1095
1096 .arm
1097 __func_from_arm:
1098 ldr r12, __func_addr
1099 bx r12
1100 __func_addr:
1101 .word func @ behave as if you saw a ARM_32 reloc
1102 */
1103
1104 #define ARM2THUMB_GLUE_SIZE 12
1105 static const insn32 a2t1_ldr_insn = 0xe59fc000;
1106 static const insn32 a2t2_bx_r12_insn = 0xe12fff1c;
1107 static const insn32 a2t3_func_addr_insn = 0x00000001;
1108
1109 /*
1110 Thumb->ARM: Thumb->(non-interworking aware) ARM
1111
1112 .thumb .thumb
1113 .align 2 .align 2
1114 __func_from_thumb: __func_from_thumb:
1115 bx pc push {r6, lr}
1116 nop ldr r6, __func_addr
1117 .arm mov lr, pc
1118 __func_change_to_arm: bx r6
1119 b func .arm
1120 __func_back_to_thumb:
1121 ldmia r13! {r6, lr}
1122 bx lr
1123 __func_addr:
1124 .word func
1125 */
1126
1127 #define THUMB2ARM_GLUE_SIZE (globals->support_old_code ? 20 : 8)
1128 static const insn16 t2a1_bx_pc_insn = 0x4778;
1129 static const insn16 t2a2_noop_insn = 0x46c0;
1130 static const insn32 t2a3_b_insn = 0xea000000;
1131
1132 static const insn16 t2a1_push_insn = 0xb540;
1133 static const insn16 t2a2_ldr_insn = 0x4e03;
1134 static const insn16 t2a3_mov_insn = 0x46fe;
1135 static const insn16 t2a4_bx_insn = 0x4730;
1136 static const insn32 t2a5_pop_insn = 0xe8bd4040;
1137 static const insn32 t2a6_bx_insn = 0xe12fff1e;
1138
1139 /* TODO:
1140 We should really create new local (static) symbols in destination
1141 object for each stub we create. We should also create local
1142 (static) symbols within the stubs when switching between ARM and
1143 Thumb code. This will ensure that the debugger and disassembler
1144 can present a better view of stubs.
1145
1146 We can treat stubs like literal sections, and for the THUMB9 ones
1147 (short addressing range) we should be able to insert the stubs
1148 between sections. i.e. the simplest approach (since relocations
1149 are done on a section basis) is to dump the stubs at the end of
1150 processing a section. That way we can always try and minimise the
1151 offset to and from a stub. However, this does not map well onto
1152 the way that the linker/BFD does its work: mapping all input
1153 sections to output sections via the linker script before doing
1154 all the processing.
1155
1156 Unfortunately it may be easier to just to disallow short range
1157 Thumb->ARM stubs (i.e. no conditional inter-working branches,
1158 only branch-and-link (BL) calls. This will simplify the processing
1159 since we can then put all of the stubs into their own section.
1160
1161 TODO:
1162 On a different subject, rather than complaining when a
1163 branch cannot fit in the number of bits available for the
1164 instruction we should generate a trampoline stub (needed to
1165 address the complete 32bit address space). */
1166
1167 /* The standard COFF backend linker does not cope with the special
1168 Thumb BRANCH23 relocation. The alternative would be to split the
1169 BRANCH23 into seperate HI23 and LO23 relocations. However, it is a
1170 bit simpler simply providing our own relocation driver. */
1171
1172 /* The reloc processing routine for the ARM/Thumb COFF linker. NOTE:
1173 This code is a very slightly modified copy of
1174 _bfd_coff_generic_relocate_section. It would be a much more
1175 maintainable solution to have a MACRO that could be expanded within
1176 _bfd_coff_generic_relocate_section that would only be provided for
1177 ARM/Thumb builds. It is only the code marked THUMBEXTENSION that
1178 is different from the original. */
1179
1180 static boolean
1181 coff_arm_relocate_section (output_bfd, info, input_bfd, input_section,
1182 contents, relocs, syms, sections)
1183 bfd *output_bfd;
1184 struct bfd_link_info *info;
1185 bfd *input_bfd;
1186 asection *input_section;
1187 bfd_byte *contents;
1188 struct internal_reloc *relocs;
1189 struct internal_syment *syms;
1190 asection **sections;
1191 {
1192 struct internal_reloc * rel;
1193 struct internal_reloc * relend;
1194
1195 rel = relocs;
1196 relend = rel + input_section->reloc_count;
1197
1198 for (; rel < relend; rel++)
1199 {
1200 int done = 0;
1201 long symndx;
1202 struct coff_link_hash_entry * h;
1203 struct internal_syment * sym;
1204 bfd_vma addend;
1205 bfd_vma val;
1206 reloc_howto_type * howto;
1207 bfd_reloc_status_type rstat;
1208 bfd_vma h_val;
1209
1210 symndx = rel->r_symndx;
1211
1212 if (symndx == -1)
1213 {
1214 h = NULL;
1215 sym = NULL;
1216 }
1217 else
1218 {
1219 h = obj_coff_sym_hashes (input_bfd)[symndx];
1220 sym = syms + symndx;
1221 }
1222
1223 /* COFF treats common symbols in one of two ways. Either the
1224 size of the symbol is included in the section contents, or it
1225 is not. We assume that the size is not included, and force
1226 the rtype_to_howto function to adjust the addend as needed. */
1227
1228 if (sym != NULL && sym->n_scnum != 0)
1229 addend = - sym->n_value;
1230 else
1231 addend = 0;
1232
1233 howto = coff_rtype_to_howto (input_bfd, input_section, rel, h,
1234 sym, &addend);
1235 if (howto == NULL)
1236 return false;
1237
1238 /* The relocation_section function will skip pcrel_offset relocs
1239 when doing a relocateable link. However, we want to convert
1240 ARM26 to ARM26D relocs if possible. We return a fake howto in
1241 this case without pcrel_offset set, and adjust the addend to
1242 compensate. */
1243 if (rel->r_type == ARM_26
1244 && h != NULL
1245 && info->relocateable
1246 && (h->root.type == bfd_link_hash_defined
1247 || h->root.type == bfd_link_hash_defweak)
1248 && (h->root.u.def.section->output_section
1249 == input_section->output_section))
1250 {
1251 static reloc_howto_type fake_arm26_reloc =
1252 HOWTO (ARM_26,
1253 2,
1254 2,
1255 24,
1256 true,
1257 0,
1258 complain_overflow_signed,
1259 aoutarm_fix_pcrel_26 ,
1260 "ARM_26",
1261 false,
1262 0x00ffffff,
1263 0x00ffffff,
1264 false);
1265
1266 addend -= rel->r_vaddr - input_section->vma;
1267 howto = &fake_arm26_reloc;
1268 }
1269
1270 #ifdef ARM_WINCE
1271 /* MS ARM-CE makes the reloc relative to the opcode's pc, not
1272 the next opcode's pc, so is off by one. */
1273 if (howto->pc_relative && !info->relocateable)
1274 addend -= 8;
1275 #endif
1276
1277 /* If we are doing a relocateable link, then we can just ignore
1278 a PC relative reloc that is pcrel_offset. It will already
1279 have the correct value. If this is not a relocateable link,
1280 then we should ignore the symbol value. */
1281 if (howto->pc_relative && howto->pcrel_offset)
1282 {
1283 if (info->relocateable)
1284 continue;
1285 /* FIXME - it is not clear which targets need this next test
1286 and which do not. It is known that it is needed for the
1287 VxWorks and EPOC-PE targets, but it is also known that it
1288 was supressed for other ARM targets. This ought to be
1289 sorted out one day. */
1290 #ifdef ARM_COFF_BUGFIX
1291 /* We must not ignore the symbol value. If the symbol is
1292 within the same section, the relocation should have already
1293 been fixed, but if it is not, we'll be handed a reloc into
1294 the beginning of the symbol's section, so we must not cancel
1295 out the symbol's value, otherwise we'll be adding it in
1296 twice. */
1297 if (sym != NULL && sym->n_scnum != 0)
1298 addend += sym->n_value;
1299 #endif
1300 }
1301
1302 val = 0;
1303
1304 if (h == NULL)
1305 {
1306 asection *sec;
1307
1308 if (symndx == -1)
1309 {
1310 sec = bfd_abs_section_ptr;
1311 val = 0;
1312 }
1313 else
1314 {
1315 sec = sections[symndx];
1316 val = (sec->output_section->vma
1317 + sec->output_offset
1318 + sym->n_value
1319 - sec->vma);
1320 }
1321 }
1322 else
1323 {
1324 #if 1 /* THUMBEXTENSION */
1325 /* We don't output the stubs if we are generating a
1326 relocatable output file, since we may as well leave the
1327 stub generation to the final linker pass. If we fail to
1328 verify that the name is defined, we'll try to build stubs
1329 for an undefined name... */
1330 if (! info->relocateable
1331 && ( h->root.type == bfd_link_hash_defined
1332 || h->root.type == bfd_link_hash_defweak))
1333 {
1334 asection * h_sec = h->root.u.def.section;
1335 const char * name = h->root.root.string;
1336
1337 /* h locates the symbol referenced in the reloc. */
1338 h_val = (h->root.u.def.value
1339 + h_sec->output_section->vma
1340 + h_sec->output_offset);
1341
1342 if (howto->type == ARM_26)
1343 {
1344 if ( h->class == C_THUMBSTATFUNC
1345 || h->class == C_THUMBEXTFUNC)
1346 {
1347 /* Arm code calling a Thumb function. */
1348 unsigned long int tmp;
1349 bfd_vma my_offset;
1350 asection * s;
1351 long int ret_offset;
1352 struct coff_link_hash_entry * myh;
1353 struct coff_arm_link_hash_table * globals;
1354
1355 myh = find_arm_glue (info, name, input_bfd);
1356 if (myh == NULL)
1357 return false;
1358
1359 globals = coff_arm_hash_table (info);
1360
1361 BFD_ASSERT (globals != NULL);
1362 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1363
1364 my_offset = myh->root.u.def.value;
1365
1366 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
1367 ARM2THUMB_GLUE_SECTION_NAME);
1368 BFD_ASSERT (s != NULL);
1369 BFD_ASSERT (s->contents != NULL);
1370 BFD_ASSERT (s->output_section != NULL);
1371
1372 if ((my_offset & 0x01) == 0x01)
1373 {
1374 if (h_sec->owner != NULL
1375 && INTERWORK_SET (h_sec->owner)
1376 && ! INTERWORK_FLAG (h_sec->owner))
1377 {
1378 _bfd_error_handler
1379 /* xgettext:c-format */
1380 (_("%s(%s): warning: interworking not enabled."),
1381 bfd_archive_filename (h_sec->owner), name);
1382 _bfd_error_handler
1383 /* xgettext:c-format */
1384 (_(" first occurrence: %s: arm call to thumb"),
1385 bfd_archive_filename (input_bfd));
1386 }
1387
1388 --my_offset;
1389 myh->root.u.def.value = my_offset;
1390
1391 bfd_put_32 (output_bfd, (bfd_vma) a2t1_ldr_insn,
1392 s->contents + my_offset);
1393
1394 bfd_put_32 (output_bfd, (bfd_vma) a2t2_bx_r12_insn,
1395 s->contents + my_offset + 4);
1396
1397 /* It's a thumb address. Add the low order bit. */
1398 bfd_put_32 (output_bfd, h_val | a2t3_func_addr_insn,
1399 s->contents + my_offset + 8);
1400
1401 if (info->base_file)
1402 arm_emit_base_file_entry (info, output_bfd, s,
1403 my_offset + 8);
1404
1405 }
1406
1407 BFD_ASSERT (my_offset <= globals->arm_glue_size);
1408
1409 tmp = bfd_get_32 (input_bfd, contents + rel->r_vaddr
1410 - input_section->vma);
1411
1412 tmp = tmp & 0xFF000000;
1413
1414 /* Somehow these are both 4 too far, so subtract 8. */
1415 ret_offset =
1416 s->output_offset
1417 + my_offset
1418 + s->output_section->vma
1419 - (input_section->output_offset
1420 + input_section->output_section->vma
1421 + rel->r_vaddr)
1422 - 8;
1423
1424 tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
1425
1426 bfd_put_32 (output_bfd, (bfd_vma) tmp,
1427 contents + rel->r_vaddr - input_section->vma);
1428 done = 1;
1429 }
1430 }
1431
1432 #ifndef ARM_WINCE
1433 /* Note: We used to check for ARM_THUMB9 and ARM_THUMB12. */
1434 else if (howto->type == ARM_THUMB23)
1435 {
1436 if ( h->class == C_EXT
1437 || h->class == C_STAT
1438 || h->class == C_LABEL)
1439 {
1440 /* Thumb code calling an ARM function */
1441 asection * s = 0;
1442 bfd_vma my_offset;
1443 unsigned long int tmp;
1444 long int ret_offset;
1445 struct coff_link_hash_entry * myh;
1446 struct coff_arm_link_hash_table * globals;
1447
1448 myh = find_thumb_glue (info, name, input_bfd);
1449 if (myh == NULL)
1450 return false;
1451
1452 globals = coff_arm_hash_table (info);
1453
1454 BFD_ASSERT (globals != NULL);
1455 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1456
1457 my_offset = myh->root.u.def.value;
1458
1459 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
1460 THUMB2ARM_GLUE_SECTION_NAME);
1461
1462 BFD_ASSERT (s != NULL);
1463 BFD_ASSERT (s->contents != NULL);
1464 BFD_ASSERT (s->output_section != NULL);
1465
1466 if ((my_offset & 0x01) == 0x01)
1467 {
1468 if (h_sec->owner != NULL
1469 && INTERWORK_SET (h_sec->owner)
1470 && ! INTERWORK_FLAG (h_sec->owner)
1471 && ! globals->support_old_code)
1472 {
1473 _bfd_error_handler
1474 /* xgettext:c-format */
1475 (_("%s(%s): warning: interworking not enabled."),
1476 bfd_archive_filename (h_sec->owner), name);
1477 _bfd_error_handler
1478 /* xgettext:c-format */
1479 (_(" first occurrence: %s: thumb call to arm"),
1480 bfd_archive_filename (input_bfd));
1481 _bfd_error_handler
1482 (_(" consider relinking with --support-old-code enabled"));
1483 }
1484
1485 -- my_offset;
1486 myh->root.u.def.value = my_offset;
1487
1488 if (globals->support_old_code)
1489 {
1490 bfd_put_16 (output_bfd, (bfd_vma) t2a1_push_insn,
1491 s->contents + my_offset);
1492
1493 bfd_put_16 (output_bfd, (bfd_vma) t2a2_ldr_insn,
1494 s->contents + my_offset + 2);
1495
1496 bfd_put_16 (output_bfd, (bfd_vma) t2a3_mov_insn,
1497 s->contents + my_offset + 4);
1498
1499 bfd_put_16 (output_bfd, (bfd_vma) t2a4_bx_insn,
1500 s->contents + my_offset + 6);
1501
1502 bfd_put_32 (output_bfd, (bfd_vma) t2a5_pop_insn,
1503 s->contents + my_offset + 8);
1504
1505 bfd_put_32 (output_bfd, (bfd_vma) t2a6_bx_insn,
1506 s->contents + my_offset + 12);
1507
1508 /* Store the address of the function in the last word of the stub. */
1509 bfd_put_32 (output_bfd, h_val,
1510 s->contents + my_offset + 16);
1511
1512 if (info->base_file)
1513 arm_emit_base_file_entry (info, output_bfd, s,
1514 my_offset + 16);
1515 }
1516 else
1517 {
1518 bfd_put_16 (output_bfd, (bfd_vma) t2a1_bx_pc_insn,
1519 s->contents + my_offset);
1520
1521 bfd_put_16 (output_bfd, (bfd_vma) t2a2_noop_insn,
1522 s->contents + my_offset + 2);
1523
1524 ret_offset =
1525 ((bfd_signed_vma) h_val) /* Address of destination of the stub. */
1526 - ((bfd_signed_vma)
1527 (s->output_offset /* Offset from the start of the current section to the start of the stubs. */
1528 + my_offset /* Offset of the start of this stub from the start of the stubs. */
1529 + s->output_section->vma) /* Address of the start of the current section. */
1530 + 4 /* The branch instruction is 4 bytes into the stub. */
1531 + 8); /* ARM branches work from the pc of the instruction + 8. */
1532
1533 bfd_put_32 (output_bfd,
1534 (bfd_vma) t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
1535 s->contents + my_offset + 4);
1536
1537 }
1538 }
1539
1540 BFD_ASSERT (my_offset <= globals->thumb_glue_size);
1541
1542 /* Now go back and fix up the original BL insn to point
1543 to here. */
1544 ret_offset =
1545 s->output_offset
1546 + my_offset
1547 - (input_section->output_offset
1548 + rel->r_vaddr)
1549 -4;
1550
1551 tmp = bfd_get_32 (input_bfd, contents + rel->r_vaddr
1552 - input_section->vma);
1553
1554 bfd_put_32 (output_bfd,
1555 (bfd_vma) insert_thumb_branch (tmp,
1556 ret_offset),
1557 contents + rel->r_vaddr - input_section->vma);
1558
1559 done = 1;
1560 }
1561 }
1562 #endif
1563 }
1564
1565 /* If the relocation type and destination symbol does not
1566 fall into one of the above categories, then we can just
1567 perform a direct link. */
1568
1569 if (done)
1570 rstat = bfd_reloc_ok;
1571 else
1572 #endif /* THUMBEXTENSION */
1573 if ( h->root.type == bfd_link_hash_defined
1574 || h->root.type == bfd_link_hash_defweak)
1575 {
1576 asection *sec;
1577
1578 sec = h->root.u.def.section;
1579 val = (h->root.u.def.value
1580 + sec->output_section->vma
1581 + sec->output_offset);
1582 }
1583
1584 else if (! info->relocateable)
1585 {
1586 if (! ((*info->callbacks->undefined_symbol)
1587 (info, h->root.root.string, input_bfd, input_section,
1588 rel->r_vaddr - input_section->vma, true)))
1589 return false;
1590 }
1591 }
1592
1593 if (info->base_file)
1594 {
1595 /* Emit a reloc if the backend thinks it needs it. */
1596 if (sym && pe_data(output_bfd)->in_reloc_p(output_bfd, howto))
1597 arm_emit_base_file_entry (info, output_bfd, input_section,
1598 rel->r_vaddr);
1599 }
1600
1601 #if 1 /* THUMBEXTENSION */
1602 if (done)
1603 rstat = bfd_reloc_ok;
1604 #ifndef ARM_WINCE
1605 /* Only perform this fix during the final link, not a relocatable link. nickc@cygnus.com */
1606 else if (! info->relocateable
1607 && howto->type == ARM_THUMB23)
1608 {
1609 /* This is pretty much a copy of what the default
1610 _bfd_final_link_relocate and _bfd_relocate_contents
1611 routines do to perform a relocation, with special
1612 processing for the split addressing of the Thumb BL
1613 instruction. Again, it would probably be simpler adding a
1614 ThumbBRANCH23 specific macro expansion into the default
1615 code. */
1616
1617 bfd_vma address = rel->r_vaddr - input_section->vma;
1618
1619 if (address > input_section->_raw_size)
1620 rstat = bfd_reloc_outofrange;
1621 else
1622 {
1623 bfd_vma relocation = val + addend;
1624 int size = bfd_get_reloc_size (howto);
1625 boolean overflow = false;
1626 bfd_byte * location = contents + address;
1627 bfd_vma x = bfd_get_32 (input_bfd, location);
1628 bfd_vma src_mask = 0x007FFFFE;
1629 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
1630 bfd_signed_vma reloc_signed_min = ~reloc_signed_max;
1631 bfd_vma check;
1632 bfd_signed_vma signed_check;
1633 bfd_vma add;
1634 bfd_signed_vma signed_add;
1635
1636 BFD_ASSERT (size == 4);
1637
1638 /* howto->pc_relative should be TRUE for type 14 BRANCH23. */
1639 relocation -= (input_section->output_section->vma
1640 + input_section->output_offset);
1641
1642 /* howto->pcrel_offset should be TRUE for type 14 BRANCH23. */
1643 relocation -= address;
1644
1645 /* No need to negate the relocation with BRANCH23. */
1646 /* howto->complain_on_overflow == complain_overflow_signed for BRANCH23. */
1647 /* howto->rightshift == 1 */
1648
1649 /* Drop unwanted bits from the value we are relocating to. */
1650 check = relocation >> howto->rightshift;
1651
1652 /* If this is a signed value, the rightshift just dropped
1653 leading 1 bits (assuming twos complement). */
1654 if ((bfd_signed_vma) relocation >= 0)
1655 signed_check = check;
1656 else
1657 signed_check = (check
1658 | ((bfd_vma) - 1
1659 & ~((bfd_vma) - 1 >> howto->rightshift)));
1660
1661 /* Get the value from the object file. */
1662 if (bfd_big_endian (input_bfd))
1663 add = (((x) & 0x07ff0000) >> 4) | (((x) & 0x7ff) << 1);
1664 else
1665 add = ((((x) & 0x7ff) << 12) | (((x) & 0x07ff0000) >> 15));
1666
1667 /* Get the value from the object file with an appropriate sign.
1668 The expression involving howto->src_mask isolates the upper
1669 bit of src_mask. If that bit is set in the value we are
1670 adding, it is negative, and we subtract out that number times
1671 two. If src_mask includes the highest possible bit, then we
1672 can not get the upper bit, but that does not matter since
1673 signed_add needs no adjustment to become negative in that
1674 case. */
1675 signed_add = add;
1676
1677 if ((add & (((~ src_mask) >> 1) & src_mask)) != 0)
1678 signed_add -= (((~ src_mask) >> 1) & src_mask) << 1;
1679
1680 /* howto->bitpos == 0 */
1681 /* Add the value from the object file, shifted so that it is a
1682 straight number. */
1683 signed_check += signed_add;
1684 relocation += signed_add;
1685
1686 BFD_ASSERT (howto->complain_on_overflow == complain_overflow_signed);
1687
1688 /* Assumes two's complement. */
1689 if ( signed_check > reloc_signed_max
1690 || signed_check < reloc_signed_min)
1691 overflow = true;
1692
1693 /* For the BLX(1) instruction remove bit 0 of the adjusted offset.
1694 Bit 0 can only be set if the upper insn is at a half-word boundary,
1695 since the destination address, an ARM instruction, must always be
1696 on a word boundary. The semantics of the BLX (1) instruction,
1697 however, are that bit 0 in the offset must always be 0, and the
1698 corresponding bit 1 in the target address will be set from bit
1699 1 of the source address. */
1700 if ((x & 0x18000000) == 0x08000000)
1701 relocation &= ~0x2;
1702
1703 /* Put the relocation into the correct bits. */
1704 if (bfd_big_endian (input_bfd))
1705 relocation = (((relocation & 0xffe) >> 1) | ((relocation << 4) & 0x07ff0000));
1706 else
1707 relocation = (((relocation & 0xffe) << 15) | ((relocation >> 12) & 0x7ff));
1708
1709 /* Add the relocation to the correct bits of X. */
1710 x = ((x & ~howto->dst_mask) | relocation);
1711
1712 /* Put the relocated value back in the object file. */
1713 bfd_put_32 (input_bfd, x, location);
1714
1715 rstat = overflow ? bfd_reloc_overflow : bfd_reloc_ok;
1716 }
1717 }
1718 #endif
1719 else
1720 #endif /* THUMBEXTENSION */
1721 rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
1722 contents,
1723 rel->r_vaddr - input_section->vma,
1724 val, addend);
1725 #if 1 /* THUMBEXTENSION */
1726 /* FIXME:
1727 Is this the best way to fix up thumb addresses? krk@cygnus.com
1728 Probably not, but it works, and if it works it don't need fixing! nickc@cygnus.com */
1729 /* Only perform this fix during the final link, not a relocatable link. nickc@cygnus.com */
1730 if (! info->relocateable
1731 && (rel->r_type == ARM_32 || rel->r_type == ARM_RVA32))
1732 {
1733 /* Determine if we need to set the bottom bit of a relocated address
1734 because the address is the address of a Thumb code symbol. */
1735
1736 int patchit = false;
1737
1738 if (h != NULL
1739 && ( h->class == C_THUMBSTATFUNC
1740 || h->class == C_THUMBEXTFUNC))
1741 {
1742 patchit = true;
1743 }
1744 else if (sym != NULL
1745 && sym->n_scnum > N_UNDEF)
1746 {
1747 /* No hash entry - use the symbol instead. */
1748
1749 if ( sym->n_sclass == C_THUMBSTATFUNC
1750 || sym->n_sclass == C_THUMBEXTFUNC)
1751 patchit = true;
1752 }
1753
1754 if (patchit)
1755 {
1756 bfd_byte * location = contents + rel->r_vaddr - input_section->vma;
1757 bfd_vma x = bfd_get_32 (input_bfd, location);
1758
1759 bfd_put_32 (input_bfd, x | 1, location);
1760 }
1761 }
1762 #endif /* THUMBEXTENSION */
1763
1764 switch (rstat)
1765 {
1766 default:
1767 abort ();
1768 case bfd_reloc_ok:
1769 break;
1770 case bfd_reloc_outofrange:
1771 (*_bfd_error_handler)
1772 (_("%s: bad reloc address 0x%lx in section `%s'"),
1773 bfd_archive_filename (input_bfd),
1774 (unsigned long) rel->r_vaddr,
1775 bfd_get_section_name (input_bfd, input_section));
1776 return false;
1777 case bfd_reloc_overflow:
1778 {
1779 const char *name;
1780 char buf[SYMNMLEN + 1];
1781
1782 if (symndx == -1)
1783 name = "*ABS*";
1784 else if (h != NULL)
1785 name = h->root.root.string;
1786 else
1787 {
1788 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
1789 if (name == NULL)
1790 return false;
1791 }
1792
1793 if (! ((*info->callbacks->reloc_overflow)
1794 (info, name, howto->name, (bfd_vma) 0, input_bfd,
1795 input_section, rel->r_vaddr - input_section->vma)))
1796 return false;
1797 }
1798 }
1799 }
1800
1801 return true;
1802 }
1803
1804 #ifndef COFF_IMAGE_WITH_PE
1805
1806 boolean
1807 bfd_arm_allocate_interworking_sections (info)
1808 struct bfd_link_info * info;
1809 {
1810 asection * s;
1811 bfd_byte * foo;
1812 struct coff_arm_link_hash_table * globals;
1813 #if 0
1814 static char test_char = '1';
1815 #endif
1816
1817 globals = coff_arm_hash_table (info);
1818
1819 BFD_ASSERT (globals != NULL);
1820
1821 if (globals->arm_glue_size != 0)
1822 {
1823 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1824
1825 s = bfd_get_section_by_name
1826 (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
1827
1828 BFD_ASSERT (s != NULL);
1829
1830 foo = (bfd_byte *) bfd_alloc (globals->bfd_of_glue_owner,
1831 globals->arm_glue_size);
1832 #if 0
1833 memset (foo, test_char, (size_t) globals->arm_glue_size);
1834 #endif
1835
1836 s->_raw_size = s->_cooked_size = globals->arm_glue_size;
1837 s->contents = foo;
1838 }
1839
1840 if (globals->thumb_glue_size != 0)
1841 {
1842 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1843
1844 s = bfd_get_section_by_name
1845 (globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
1846
1847 BFD_ASSERT (s != NULL);
1848
1849 foo = (bfd_byte *) bfd_alloc (globals->bfd_of_glue_owner,
1850 globals->thumb_glue_size);
1851 #if 0
1852 memset (foo, test_char, (size_t) globals->thumb_glue_size);
1853 #endif
1854
1855 s->_raw_size = s->_cooked_size = globals->thumb_glue_size;
1856 s->contents = foo;
1857 }
1858
1859 return true;
1860 }
1861
1862 static void
1863 record_arm_to_thumb_glue (info, h)
1864 struct bfd_link_info * info;
1865 struct coff_link_hash_entry * h;
1866 {
1867 const char * name = h->root.root.string;
1868 register asection * s;
1869 char * tmp_name;
1870 struct coff_link_hash_entry * myh;
1871 struct coff_arm_link_hash_table * globals;
1872 bfd_vma val;
1873 bfd_size_type amt;
1874
1875 globals = coff_arm_hash_table (info);
1876
1877 BFD_ASSERT (globals != NULL);
1878 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1879
1880 s = bfd_get_section_by_name
1881 (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
1882
1883 BFD_ASSERT (s != NULL);
1884
1885 amt = strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1;
1886 tmp_name = (char *) bfd_malloc (amt);
1887
1888 BFD_ASSERT (tmp_name);
1889
1890 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
1891
1892 myh = coff_link_hash_lookup
1893 (coff_hash_table (info), tmp_name, false, false, true);
1894
1895 if (myh != NULL)
1896 {
1897 free (tmp_name);
1898 return; /* we've already seen this guy */
1899 }
1900
1901 /* The only trick here is using globals->arm_glue_size as the value. Even
1902 though the section isn't allocated yet, this is where we will be putting
1903 it. */
1904
1905 val = globals->arm_glue_size + 1;
1906 bfd_coff_link_add_one_symbol (info, globals->bfd_of_glue_owner, tmp_name,
1907 BSF_GLOBAL, s, val, NULL, true, false,
1908 (struct bfd_link_hash_entry **) & myh);
1909
1910 free (tmp_name);
1911
1912 globals->arm_glue_size += ARM2THUMB_GLUE_SIZE;
1913
1914 return;
1915 }
1916
1917 static void
1918 record_thumb_to_arm_glue (info, h)
1919 struct bfd_link_info * info;
1920 struct coff_link_hash_entry * h;
1921 {
1922 const char * name = h->root.root.string;
1923 register asection * s;
1924 char * tmp_name;
1925 struct coff_link_hash_entry * myh;
1926 struct coff_arm_link_hash_table * globals;
1927 bfd_vma val;
1928 bfd_size_type amt;
1929
1930 globals = coff_arm_hash_table (info);
1931
1932 BFD_ASSERT (globals != NULL);
1933 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1934
1935 s = bfd_get_section_by_name
1936 (globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
1937
1938 BFD_ASSERT (s != NULL);
1939
1940 amt = strlen (name) + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1;
1941 tmp_name = (char *) bfd_malloc (amt);
1942
1943 BFD_ASSERT (tmp_name);
1944
1945 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
1946
1947 myh = coff_link_hash_lookup
1948 (coff_hash_table (info), tmp_name, false, false, true);
1949
1950 if (myh != NULL)
1951 {
1952 free (tmp_name);
1953 return; /* we've already seen this guy */
1954 }
1955
1956 val = globals->thumb_glue_size + 1;
1957 bfd_coff_link_add_one_symbol (info, globals->bfd_of_glue_owner, tmp_name,
1958 BSF_GLOBAL, s, val, NULL, true, false,
1959 (struct bfd_link_hash_entry **) &myh);
1960
1961 /* If we mark it 'thumb', the disassembler will do a better job. */
1962 myh->class = C_THUMBEXTFUNC;
1963
1964 free (tmp_name);
1965
1966 /* Allocate another symbol to mark where we switch to arm mode. */
1967
1968 #define CHANGE_TO_ARM "__%s_change_to_arm"
1969 #define BACK_FROM_ARM "__%s_back_from_arm"
1970
1971 amt = strlen (name) + strlen (CHANGE_TO_ARM) + 1;
1972 tmp_name = (char *) bfd_malloc (amt);
1973
1974 BFD_ASSERT (tmp_name);
1975
1976 sprintf (tmp_name, globals->support_old_code ? BACK_FROM_ARM : CHANGE_TO_ARM, name);
1977
1978 myh = NULL;
1979 val = globals->thumb_glue_size + (globals->support_old_code ? 8 : 4);
1980 bfd_coff_link_add_one_symbol (info, globals->bfd_of_glue_owner, tmp_name,
1981 BSF_LOCAL, s, val, NULL, true, false,
1982 (struct bfd_link_hash_entry **) & myh);
1983
1984 free (tmp_name);
1985
1986 globals->thumb_glue_size += THUMB2ARM_GLUE_SIZE;
1987
1988 return;
1989 }
1990
1991 /* Select a BFD to be used to hold the sections used by the glue code.
1992 This function is called from the linker scripts in ld/emultempl/
1993 {armcoff/pe}.em */
1994
1995 boolean
1996 bfd_arm_get_bfd_for_interworking (abfd, info)
1997 bfd * abfd;
1998 struct bfd_link_info * info;
1999 {
2000 struct coff_arm_link_hash_table * globals;
2001 flagword flags;
2002 asection * sec;
2003
2004 /* If we are only performing a partial link do not bother
2005 getting a bfd to hold the glue. */
2006 if (info->relocateable)
2007 return true;
2008
2009 globals = coff_arm_hash_table (info);
2010
2011 BFD_ASSERT (globals != NULL);
2012
2013 if (globals->bfd_of_glue_owner != NULL)
2014 return true;
2015
2016 sec = bfd_get_section_by_name (abfd, ARM2THUMB_GLUE_SECTION_NAME);
2017
2018 if (sec == NULL)
2019 {
2020 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE | SEC_READONLY;
2021
2022 sec = bfd_make_section (abfd, ARM2THUMB_GLUE_SECTION_NAME);
2023
2024 if (sec == NULL
2025 || ! bfd_set_section_flags (abfd, sec, flags)
2026 || ! bfd_set_section_alignment (abfd, sec, 2))
2027 return false;
2028 }
2029
2030 sec = bfd_get_section_by_name (abfd, THUMB2ARM_GLUE_SECTION_NAME);
2031
2032 if (sec == NULL)
2033 {
2034 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE | SEC_READONLY;
2035
2036 sec = bfd_make_section (abfd, THUMB2ARM_GLUE_SECTION_NAME);
2037
2038 if (sec == NULL
2039 || ! bfd_set_section_flags (abfd, sec, flags)
2040 || ! bfd_set_section_alignment (abfd, sec, 2))
2041 return false;
2042 }
2043
2044 /* Save the bfd for later use. */
2045 globals->bfd_of_glue_owner = abfd;
2046
2047 return true;
2048 }
2049
2050 boolean
2051 bfd_arm_process_before_allocation (abfd, info, support_old_code)
2052 bfd * abfd;
2053 struct bfd_link_info * info;
2054 int support_old_code;
2055 {
2056 asection * sec;
2057 struct coff_arm_link_hash_table * globals;
2058
2059 /* If we are only performing a partial link do not bother
2060 to construct any glue. */
2061 if (info->relocateable)
2062 return true;
2063
2064 /* Here we have a bfd that is to be included on the link. We have a hook
2065 to do reloc rummaging, before section sizes are nailed down. */
2066
2067 _bfd_coff_get_external_symbols (abfd);
2068
2069 globals = coff_arm_hash_table (info);
2070
2071 BFD_ASSERT (globals != NULL);
2072 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2073
2074 globals->support_old_code = support_old_code;
2075
2076 /* Rummage around all the relocs and map the glue vectors. */
2077 sec = abfd->sections;
2078
2079 if (sec == NULL)
2080 return true;
2081
2082 for (; sec != NULL; sec = sec->next)
2083 {
2084 struct internal_reloc * i;
2085 struct internal_reloc * rel;
2086
2087 if (sec->reloc_count == 0)
2088 continue;
2089
2090 /* Load the relocs. */
2091 /* FIXME: there may be a storage leak here. */
2092
2093 i = _bfd_coff_read_internal_relocs (abfd, sec, 1, 0, 0, 0);
2094
2095 BFD_ASSERT (i != 0);
2096
2097 for (rel = i; rel < i + sec->reloc_count; ++rel)
2098 {
2099 unsigned short r_type = rel->r_type;
2100 long symndx;
2101 struct coff_link_hash_entry * h;
2102
2103 symndx = rel->r_symndx;
2104
2105 /* If the relocation is not against a symbol it cannot concern us. */
2106 if (symndx == -1)
2107 continue;
2108
2109 /* If the index is outside of the range of our table, something has gone wrong. */
2110 if (symndx >= obj_conv_table_size (abfd))
2111 {
2112 _bfd_error_handler (_("%s: illegal symbol index in reloc: %d"),
2113 bfd_archive_filename (abfd), symndx);
2114 continue;
2115 }
2116
2117 h = obj_coff_sym_hashes (abfd)[symndx];
2118
2119 /* If the relocation is against a static symbol it must be within
2120 the current section and so cannot be a cross ARM/Thumb relocation. */
2121 if (h == NULL)
2122 continue;
2123
2124 switch (r_type)
2125 {
2126 case ARM_26:
2127 /* This one is a call from arm code. We need to look up
2128 the target of the call. If it is a thumb target, we
2129 insert glue. */
2130
2131 if (h->class == C_THUMBEXTFUNC)
2132 record_arm_to_thumb_glue (info, h);
2133 break;
2134
2135 #ifndef ARM_WINCE
2136 case ARM_THUMB23:
2137 /* This one is a call from thumb code. We used to look
2138 for ARM_THUMB9 and ARM_THUMB12 as well. We need to look
2139 up the target of the call. If it is an arm target, we
2140 insert glue. If the symbol does not exist it will be
2141 given a class of C_EXT and so we will generate a stub
2142 for it. This is not really a problem, since the link
2143 is doomed anyway. */
2144
2145 switch (h->class)
2146 {
2147 case C_EXT:
2148 case C_STAT:
2149 case C_LABEL:
2150 record_thumb_to_arm_glue (info, h);
2151 break;
2152 default:
2153 ;
2154 }
2155 break;
2156 #endif
2157
2158 default:
2159 break;
2160 }
2161 }
2162 }
2163
2164 return true;
2165 }
2166
2167 #endif /* ! defined (COFF_IMAGE_WITH_PE) */
2168
2169 #define coff_bfd_reloc_type_lookup coff_arm_reloc_type_lookup
2170 #define coff_relocate_section coff_arm_relocate_section
2171 #define coff_bfd_is_local_label_name coff_arm_is_local_label_name
2172 #define coff_adjust_symndx coff_arm_adjust_symndx
2173 #define coff_link_output_has_begun coff_arm_link_output_has_begun
2174 #define coff_final_link_postscript coff_arm_final_link_postscript
2175 #define coff_bfd_merge_private_bfd_data coff_arm_merge_private_bfd_data
2176 #define coff_bfd_print_private_bfd_data coff_arm_print_private_bfd_data
2177 #define coff_bfd_set_private_flags _bfd_coff_arm_set_private_flags
2178 #define coff_bfd_copy_private_bfd_data coff_arm_copy_private_bfd_data
2179 #define coff_bfd_link_hash_table_create coff_arm_link_hash_table_create
2180
2181 /* When doing a relocateable link, we want to convert ARM26 relocs
2182 into ARM26D relocs. */
2183
2184 static boolean
2185 coff_arm_adjust_symndx (obfd, info, ibfd, sec, irel, adjustedp)
2186 bfd *obfd ATTRIBUTE_UNUSED;
2187 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2188 bfd *ibfd;
2189 asection *sec;
2190 struct internal_reloc *irel;
2191 boolean *adjustedp;
2192 {
2193 if (irel->r_type == 3)
2194 {
2195 struct coff_link_hash_entry *h;
2196
2197 h = obj_coff_sym_hashes (ibfd)[irel->r_symndx];
2198 if (h != NULL
2199 && (h->root.type == bfd_link_hash_defined
2200 || h->root.type == bfd_link_hash_defweak)
2201 && h->root.u.def.section->output_section == sec->output_section)
2202 irel->r_type = 7;
2203 }
2204 *adjustedp = false;
2205 return true;
2206 }
2207
2208 /* Called when merging the private data areas of two BFDs.
2209 This is important as it allows us to detect if we are
2210 attempting to merge binaries compiled for different ARM
2211 targets, eg different CPUs or differents APCS's. */
2212
2213 static boolean
2214 coff_arm_merge_private_bfd_data (ibfd, obfd)
2215 bfd * ibfd;
2216 bfd * obfd;
2217 {
2218 BFD_ASSERT (ibfd != NULL && obfd != NULL);
2219
2220 if (ibfd == obfd)
2221 return true;
2222
2223 /* If the two formats are different we cannot merge anything.
2224 This is not an error, since it is permissable to change the
2225 input and output formats. */
2226 if ( ibfd->xvec->flavour != bfd_target_coff_flavour
2227 || obfd->xvec->flavour != bfd_target_coff_flavour)
2228 return true;
2229
2230 /* Verify that the APCS is the same for the two BFDs */
2231 if (APCS_SET (ibfd))
2232 {
2233 if (APCS_SET (obfd))
2234 {
2235 /* If the src and dest have different APCS flag bits set, fail. */
2236 if (APCS_26_FLAG (obfd) != APCS_26_FLAG (ibfd))
2237 {
2238 _bfd_error_handler
2239 /* xgettext: c-format */
2240 (_("ERROR: %s is compiled for APCS-%d, whereas %s is compiled for APCS-%d"),
2241 bfd_archive_filename (ibfd), APCS_26_FLAG (ibfd) ? 26 : 32,
2242 bfd_get_filename (obfd), APCS_26_FLAG (obfd) ? 26 : 32
2243 );
2244
2245 bfd_set_error (bfd_error_wrong_format);
2246 return false;
2247 }
2248
2249 if (APCS_FLOAT_FLAG (obfd) != APCS_FLOAT_FLAG (ibfd))
2250 {
2251 const char *msg;
2252
2253 if (APCS_FLOAT_FLAG (ibfd))
2254 /* xgettext: c-format */
2255 msg = _("ERROR: %s passes floats in float registers, whereas %s passes them in integer registers");
2256 else
2257 /* xgettext: c-format */
2258 msg = _("ERROR: %s passes floats in integer registers, whereas %s passes them in float registers");
2259
2260 _bfd_error_handler (msg, bfd_archive_filename (ibfd),
2261 bfd_get_filename (obfd));
2262
2263 bfd_set_error (bfd_error_wrong_format);
2264 return false;
2265 }
2266
2267 if (PIC_FLAG (obfd) != PIC_FLAG (ibfd))
2268 {
2269 const char * msg;
2270
2271 if (PIC_FLAG (ibfd))
2272 /* xgettext: c-format */
2273 msg = _("ERROR: %s is compiled as position independent code, whereas target %s is absolute position");
2274 else
2275 /* xgettext: c-format */
2276 msg = _("ERROR: %s is compiled as absolute position code, whereas target %s is position independent");
2277 _bfd_error_handler (msg, bfd_archive_filename (ibfd),
2278 bfd_get_filename (obfd));
2279
2280 bfd_set_error (bfd_error_wrong_format);
2281 return false;
2282 }
2283 }
2284 else
2285 {
2286 SET_APCS_FLAGS (obfd, APCS_26_FLAG (ibfd) | APCS_FLOAT_FLAG (ibfd) | PIC_FLAG (ibfd));
2287
2288 /* Set up the arch and fields as well as these are probably wrong. */
2289 bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
2290 }
2291 }
2292
2293 /* Check the interworking support. */
2294 if (INTERWORK_SET (ibfd))
2295 {
2296 if (INTERWORK_SET (obfd))
2297 {
2298 /* If the src and dest differ in their interworking issue a warning. */
2299 if (INTERWORK_FLAG (obfd) != INTERWORK_FLAG (ibfd))
2300 {
2301 const char * msg;
2302
2303 if (INTERWORK_FLAG (ibfd))
2304 /* xgettext: c-format */
2305 msg = _("Warning: %s supports interworking, whereas %s does not");
2306 else
2307 /* xgettext: c-format */
2308 msg = _("Warning: %s does not support interworking, whereas %s does");
2309
2310 _bfd_error_handler (msg, bfd_archive_filename (ibfd),
2311 bfd_get_filename (obfd));
2312 }
2313 }
2314 else
2315 {
2316 SET_INTERWORK_FLAG (obfd, INTERWORK_FLAG (ibfd));
2317 }
2318 }
2319
2320 return true;
2321 }
2322
2323 /* Display the flags field. */
2324
2325 static boolean
2326 coff_arm_print_private_bfd_data (abfd, ptr)
2327 bfd * abfd;
2328 PTR ptr;
2329 {
2330 FILE * file = (FILE *) ptr;
2331
2332 BFD_ASSERT (abfd != NULL && ptr != NULL);
2333
2334 /* xgettext:c-format */
2335 fprintf (file, _("private flags = %x:"), coff_data (abfd)->flags);
2336
2337 if (APCS_SET (abfd))
2338 {
2339 /* xgettext: APCS is ARM Prodecure Call Standard, it should not be translated. */
2340 fprintf (file, " [APCS-%d]", APCS_26_FLAG (abfd) ? 26 : 32);
2341
2342 if (APCS_FLOAT_FLAG (abfd))
2343 fprintf (file, _(" [floats passed in float registers]"));
2344 else
2345 fprintf (file, _(" [floats passed in integer registers]"));
2346
2347 if (PIC_FLAG (abfd))
2348 fprintf (file, _(" [position independent]"));
2349 else
2350 fprintf (file, _(" [absolute position]"));
2351 }
2352
2353 if (! INTERWORK_SET (abfd))
2354 fprintf (file, _(" [interworking flag not initialised]"));
2355 else if (INTERWORK_FLAG (abfd))
2356 fprintf (file, _(" [interworking supported]"));
2357 else
2358 fprintf (file, _(" [interworking not supported]"));
2359
2360 fputc ('\n', file);
2361
2362 return true;
2363 }
2364
2365 /* Copies the given flags into the coff_tdata.flags field.
2366 Typically these flags come from the f_flags[] field of
2367 the COFF filehdr structure, which contains important,
2368 target specific information.
2369 Note: Although this function is static, it is explicitly
2370 called from both coffcode.h and peicode.h. */
2371
2372 static boolean
2373 _bfd_coff_arm_set_private_flags (abfd, flags)
2374 bfd * abfd;
2375 flagword flags;
2376 {
2377 flagword flag;
2378
2379 BFD_ASSERT (abfd != NULL);
2380
2381 flag = (flags & F_APCS26) ? F_APCS_26 : 0;
2382
2383 /* Make sure that the APCS field has not been initialised to the opposite
2384 value. */
2385 if (APCS_SET (abfd)
2386 && ( (APCS_26_FLAG (abfd) != flag)
2387 || (APCS_FLOAT_FLAG (abfd) != (flags & F_APCS_FLOAT))
2388 || (PIC_FLAG (abfd) != (flags & F_PIC))
2389 ))
2390 return false;
2391
2392 flag |= (flags & (F_APCS_FLOAT | F_PIC));
2393
2394 SET_APCS_FLAGS (abfd, flag);
2395
2396 flag = (flags & F_INTERWORK);
2397
2398 /* If the BFD has already had its interworking flag set, but it
2399 is different from the value that we have been asked to set,
2400 then assume that that merged code will not support interworking
2401 and set the flag accordingly. */
2402 if (INTERWORK_SET (abfd) && (INTERWORK_FLAG (abfd) != flag))
2403 {
2404 if (flag)
2405 /* xgettext: c-format */
2406 _bfd_error_handler (_("Warning: Not setting interworking flag of %s since it has already been specified as non-interworking"),
2407 bfd_archive_filename (abfd));
2408 else
2409 /* xgettext: c-format */
2410 _bfd_error_handler (_("Warning: Clearing the interworking flag of %s due to outside request"),
2411 bfd_archive_filename (abfd));
2412 flag = 0;
2413 }
2414
2415 SET_INTERWORK_FLAG (abfd, flag);
2416
2417 return true;
2418 }
2419
2420 /* Copy the important parts of the target specific data
2421 from one instance of a BFD to another. */
2422
2423 static boolean
2424 coff_arm_copy_private_bfd_data (src, dest)
2425 bfd * src;
2426 bfd * dest;
2427 {
2428 BFD_ASSERT (src != NULL && dest != NULL);
2429
2430 if (src == dest)
2431 return true;
2432
2433 /* If the destination is not in the same format as the source, do not do
2434 the copy. */
2435 if (src->xvec != dest->xvec)
2436 return true;
2437
2438 /* copy the flags field */
2439 if (APCS_SET (src))
2440 {
2441 if (APCS_SET (dest))
2442 {
2443 /* If the src and dest have different APCS flag bits set, fail. */
2444 if (APCS_26_FLAG (dest) != APCS_26_FLAG (src))
2445 return false;
2446
2447 if (APCS_FLOAT_FLAG (dest) != APCS_FLOAT_FLAG (src))
2448 return false;
2449
2450 if (PIC_FLAG (dest) != PIC_FLAG (src))
2451 return false;
2452 }
2453 else
2454 SET_APCS_FLAGS (dest, APCS_26_FLAG (src) | APCS_FLOAT_FLAG (src)
2455 | PIC_FLAG (src));
2456 }
2457
2458 if (INTERWORK_SET (src))
2459 {
2460 if (INTERWORK_SET (dest))
2461 {
2462 /* If the src and dest have different interworking flags then turn
2463 off the interworking bit. */
2464 if (INTERWORK_FLAG (dest) != INTERWORK_FLAG (src))
2465 {
2466 if (INTERWORK_FLAG (dest))
2467 {
2468 /* xgettext:c-format */
2469 _bfd_error_handler (("\
2470 Warning: Clearing the interworking flag of %s because non-interworking code in %s has been linked with it"),
2471 bfd_get_filename (dest),
2472 bfd_archive_filename (src));
2473 }
2474
2475 SET_INTERWORK_FLAG (dest, 0);
2476 }
2477 }
2478 else
2479 {
2480 SET_INTERWORK_FLAG (dest, INTERWORK_FLAG (src));
2481 }
2482 }
2483
2484 return true;
2485 }
2486
2487 /* Note: the definitions here of LOCAL_LABEL_PREFIX and USER_LABEL_PREIFX
2488 *must* match the definitions in gcc/config/arm/{coff|semi|aout}.h. */
2489 #define LOCAL_LABEL_PREFIX ""
2490 #ifndef USER_LABEL_PREFIX
2491 #define USER_LABEL_PREFIX "_"
2492 #endif
2493
2494 /* Like _bfd_coff_is_local_label_name, but
2495 a) test against USER_LABEL_PREFIX, to avoid stripping labels known to be
2496 non-local.
2497 b) Allow other prefixes than ".", e.g. an empty prefix would cause all
2498 labels of the form Lxxx to be stripped. */
2499 static boolean
2500 coff_arm_is_local_label_name (abfd, name)
2501 bfd * abfd ATTRIBUTE_UNUSED;
2502 const char * name;
2503 {
2504 #ifdef USER_LABEL_PREFIX
2505 if (USER_LABEL_PREFIX[0] != 0)
2506 {
2507 if (strncmp (name, USER_LABEL_PREFIX, strlen (USER_LABEL_PREFIX)) == 0)
2508 return false;
2509 }
2510 #endif
2511
2512 #ifdef LOCAL_LABEL_PREFIX
2513 /* If there is a prefix for local labels then look for this.
2514 If the prefix exists, but it is empty, then ignore the test. */
2515
2516 if (LOCAL_LABEL_PREFIX[0] != 0)
2517 {
2518 size_t len = strlen (LOCAL_LABEL_PREFIX);
2519
2520 if (strncmp (name, LOCAL_LABEL_PREFIX, len) != 0)
2521 return false;
2522
2523 /* Perform the checks below for the rest of the name. */
2524 name += len;
2525 }
2526 #endif
2527
2528 return name[0] == 'L';
2529 }
2530
2531 /* This piece of machinery exists only to guarantee that the bfd that holds
2532 the glue section is written last.
2533
2534 This does depend on bfd_make_section attaching a new section to the
2535 end of the section list for the bfd.
2536
2537 krk@cygnus.com */
2538
2539 static boolean
2540 coff_arm_link_output_has_begun (sub, info)
2541 bfd * sub;
2542 struct coff_final_link_info * info;
2543 {
2544 return (sub->output_has_begun
2545 || sub == coff_arm_hash_table (info->info)->bfd_of_glue_owner);
2546 }
2547
2548 static boolean
2549 coff_arm_final_link_postscript (abfd, pfinfo)
2550 bfd * abfd ATTRIBUTE_UNUSED;
2551 struct coff_final_link_info * pfinfo;
2552 {
2553 struct coff_arm_link_hash_table * globals;
2554
2555 globals = coff_arm_hash_table (pfinfo->info);
2556
2557 BFD_ASSERT (globals != NULL);
2558
2559 if (globals->bfd_of_glue_owner != NULL)
2560 {
2561 if (! _bfd_coff_link_input_bfd (pfinfo, globals->bfd_of_glue_owner))
2562 return false;
2563
2564 globals->bfd_of_glue_owner->output_has_begun = true;
2565 }
2566
2567 return true;
2568 }
2569
2570 #include "coffcode.h"
2571
2572 #ifndef TARGET_LITTLE_SYM
2573 #define TARGET_LITTLE_SYM armcoff_little_vec
2574 #endif
2575 #ifndef TARGET_LITTLE_NAME
2576 #define TARGET_LITTLE_NAME "coff-arm-little"
2577 #endif
2578 #ifndef TARGET_BIG_SYM
2579 #define TARGET_BIG_SYM armcoff_big_vec
2580 #endif
2581 #ifndef TARGET_BIG_NAME
2582 #define TARGET_BIG_NAME "coff-arm-big"
2583 #endif
2584
2585 #ifndef TARGET_UNDERSCORE
2586 #define TARGET_UNDERSCORE 0
2587 #endif
2588
2589 #ifndef EXTRA_S_FLAGS
2590 #ifdef COFF_WITH_PE
2591 #define EXTRA_S_FLAGS (SEC_LINK_ONCE | SEC_LINK_DUPLICATES)
2592 #else
2593 #define EXTRA_S_FLAGS 0
2594 #endif
2595 #endif
2596
2597 /* Forward declaration for use initialising alternative_target field. */
2598 extern const bfd_target TARGET_BIG_SYM ;
2599
2600 /* Target vectors. */
2601 CREATE_LITTLE_COFF_TARGET_VEC (TARGET_LITTLE_SYM, TARGET_LITTLE_NAME, D_PAGED, EXTRA_S_FLAGS, TARGET_UNDERSCORE, & TARGET_BIG_SYM)
2602 CREATE_BIG_COFF_TARGET_VEC (TARGET_BIG_SYM, TARGET_BIG_NAME, D_PAGED, EXTRA_S_FLAGS, TARGET_UNDERSCORE, & TARGET_LITTLE_SYM)
git-cvsimport of binutils cvsroot