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