1 /* BFD back-end for ARM COFF files.
2 Copyright (C) 1990-2017 Free Software Foundation, Inc.
3 Written by Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
26 #include "coff/internal.h"
34 /* Macros for manipulation the bits in the flags field of the coff data
36 #define APCS_26_FLAG(abfd) \
37 (coff_data (abfd)->flags & F_APCS_26)
39 #define APCS_FLOAT_FLAG(abfd) \
40 (coff_data (abfd)->flags & F_APCS_FLOAT)
42 #define PIC_FLAG(abfd) \
43 (coff_data (abfd)->flags & F_PIC)
45 #define APCS_SET(abfd) \
46 (coff_data (abfd)->flags & F_APCS_SET)
48 #define SET_APCS_FLAGS(abfd, flgs) \
51 coff_data (abfd)->flags &= ~(F_APCS_26 | F_APCS_FLOAT | F_PIC); \
52 coff_data (abfd)->flags |= (flgs) | F_APCS_SET; \
56 #define INTERWORK_FLAG(abfd) \
57 (coff_data (abfd)->flags & F_INTERWORK)
59 #define INTERWORK_SET(abfd) \
60 (coff_data (abfd)->flags & F_INTERWORK_SET)
62 #define SET_INTERWORK_FLAG(abfd, flg) \
65 coff_data (abfd)->flags &= ~F_INTERWORK; \
66 coff_data (abfd)->flags |= (flg) | F_INTERWORK_SET; \
71 #define NUM_ELEM(a) ((sizeof (a)) / sizeof ((a)[0]))
74 typedef enum {bunknown, b9, b12, b23} thumb_pcrel_branchtype;
75 /* Some typedefs for holding instructions. */
76 typedef unsigned long int insn32;
77 typedef unsigned short int insn16;
79 /* The linker script knows the section names for placement.
80 The entry_names are used to do simple name mangling on the stubs.
81 Given a function name, and its type, the stub can be found. The
82 name can be changed. The only requirement is the %s be present. */
84 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
85 #define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
87 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
88 #define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
90 /* Used by the assembler. */
92 static bfd_reloc_status_type
93 coff_arm_reloc (bfd *abfd,
95 asymbol *symbol ATTRIBUTE_UNUSED,
97 asection *input_section ATTRIBUTE_UNUSED,
99 char **error_message ATTRIBUTE_UNUSED)
103 if (output_bfd == NULL)
104 return bfd_reloc_continue;
106 diff = reloc_entry->addend;
109 x = ((x & ~howto->dst_mask) \
110 | (((x & howto->src_mask) + diff) & howto->dst_mask))
114 reloc_howto_type *howto = reloc_entry->howto;
115 unsigned char *addr = (unsigned char *) data + reloc_entry->address;
121 char x = bfd_get_8 (abfd, addr);
123 bfd_put_8 (abfd, x, addr);
129 short x = bfd_get_16 (abfd, addr);
131 bfd_put_16 (abfd, (bfd_vma) x, addr);
137 long x = bfd_get_32 (abfd, addr);
139 bfd_put_32 (abfd, (bfd_vma) x, addr);
148 /* Now let bfd_perform_relocation finish everything up. */
149 return bfd_reloc_continue;
152 /* If USER_LABEL_PREFIX is defined as "_" (see coff_arm_is_local_label_name()
153 in this file), then TARGET_UNDERSCORE should be defined, otherwise it
155 #ifndef TARGET_UNDERSCORE
156 #define TARGET_UNDERSCORE '_'
160 #define PCRELOFFSET TRUE
163 /* These most certainly belong somewhere else. Just had to get rid of
164 the manifest constants in the code. */
172 #define ARM_THUMB12 4
173 #define ARM_SECTION 14
174 #define ARM_SECREL 15
190 #define ARM_THUMB9 12
191 #define ARM_THUMB12 13
192 #define ARM_THUMB23 14
196 static bfd_reloc_status_type aoutarm_fix_pcrel_26_done
197 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
198 static bfd_reloc_status_type aoutarm_fix_pcrel_26
199 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
200 static bfd_reloc_status_type coff_thumb_pcrel_12
201 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
203 static bfd_reloc_status_type coff_thumb_pcrel_9
204 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
205 static bfd_reloc_status_type coff_thumb_pcrel_23
206 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
209 static reloc_howto_type aoutarm_std_reloc_howto[] =
218 complain_overflow_dont,
219 aoutarm_fix_pcrel_26_done,
221 TRUE, /* partial_inplace. */
231 complain_overflow_bitfield,
234 TRUE, /* partial_inplace. */
244 complain_overflow_bitfield,
247 TRUE, /* partial_inplace. */
257 complain_overflow_signed,
258 aoutarm_fix_pcrel_26 ,
270 complain_overflow_signed,
271 coff_thumb_pcrel_12 ,
292 complain_overflow_bitfield,
295 TRUE, /* partial_inplace. */
305 complain_overflow_bitfield,
308 TRUE, /* partial_inplace. */
312 #else /* not ARM_WINCE */
319 complain_overflow_bitfield,
332 complain_overflow_bitfield,
345 complain_overflow_bitfield,
358 complain_overflow_signed,
359 aoutarm_fix_pcrel_26 ,
371 complain_overflow_signed,
384 complain_overflow_signed,
397 complain_overflow_signed,
410 complain_overflow_dont,
411 aoutarm_fix_pcrel_26_done,
425 complain_overflow_bitfield,
438 complain_overflow_bitfield,
451 complain_overflow_bitfield,
464 complain_overflow_signed,
477 complain_overflow_signed,
478 coff_thumb_pcrel_12 ,
490 complain_overflow_signed,
491 coff_thumb_pcrel_23 ,
497 #endif /* not ARM_WINCE */
500 #define NUM_RELOCS NUM_ELEM (aoutarm_std_reloc_howto)
503 /* Return TRUE if this relocation should
504 appear in the output .reloc section. */
507 in_reloc_p (bfd * abfd ATTRIBUTE_UNUSED,
508 reloc_howto_type * howto)
510 return !howto->pc_relative && howto->type != ARM_RVA32;
514 #define RTYPE2HOWTO(cache_ptr, dst) \
515 (cache_ptr)->howto = \
516 (dst)->r_type < NUM_RELOCS \
517 ? aoutarm_std_reloc_howto + (dst)->r_type \
520 #define coff_rtype_to_howto coff_arm_rtype_to_howto
522 static reloc_howto_type *
523 coff_arm_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
525 struct internal_reloc *rel,
526 struct coff_link_hash_entry *h ATTRIBUTE_UNUSED,
527 struct internal_syment *sym ATTRIBUTE_UNUSED,
530 reloc_howto_type * howto;
532 if (rel->r_type >= NUM_RELOCS)
535 howto = aoutarm_std_reloc_howto + rel->r_type;
537 if (rel->r_type == ARM_RVA32)
538 *addendp -= pe_data (sec->output_section->owner)->pe_opthdr.ImageBase;
540 #if defined COFF_WITH_PE && defined ARM_WINCE
541 if (rel->r_type == ARM_SECREL)
545 if (h && (h->type == bfd_link_hash_defined
546 || h->type == bfd_link_hash_defweak))
547 osect_vma = h->root.u.def.section->output_section->vma;
552 /* Sigh, the only way to get the section to offset against
553 is to find it the hard way. */
555 for (sec = abfd->sections, i = 1; i < sym->n_scnum; i++)
558 osect_vma = sec->output_section->vma;
561 *addendp -= osect_vma;
568 /* Used by the assembler. */
570 static bfd_reloc_status_type
571 aoutarm_fix_pcrel_26_done (bfd *abfd ATTRIBUTE_UNUSED,
572 arelent *reloc_entry ATTRIBUTE_UNUSED,
573 asymbol *symbol ATTRIBUTE_UNUSED,
574 void * data ATTRIBUTE_UNUSED,
575 asection *input_section ATTRIBUTE_UNUSED,
576 bfd *output_bfd ATTRIBUTE_UNUSED,
577 char **error_message ATTRIBUTE_UNUSED)
579 /* This is dead simple at present. */
583 /* Used by the assembler. */
585 static bfd_reloc_status_type
586 aoutarm_fix_pcrel_26 (bfd *abfd,
587 arelent *reloc_entry,
590 asection *input_section,
592 char **error_message ATTRIBUTE_UNUSED)
595 bfd_size_type addr = reloc_entry->address;
596 long target = bfd_get_32 (abfd, (bfd_byte *) data + addr);
597 bfd_reloc_status_type flag = bfd_reloc_ok;
599 /* If this is an undefined symbol, return error. */
600 if (bfd_is_und_section (symbol->section)
601 && (symbol->flags & BSF_WEAK) == 0)
602 return output_bfd ? bfd_reloc_continue : bfd_reloc_undefined;
604 /* If the sections are different, and we are doing a partial relocation,
605 just ignore it for now. */
606 if (symbol->section->name != input_section->name
607 && output_bfd != (bfd *)NULL)
608 return bfd_reloc_continue;
610 relocation = (target & 0x00ffffff) << 2;
611 relocation = (relocation ^ 0x02000000) - 0x02000000; /* Sign extend. */
612 relocation += symbol->value;
613 relocation += symbol->section->output_section->vma;
614 relocation += symbol->section->output_offset;
615 relocation += reloc_entry->addend;
616 relocation -= input_section->output_section->vma;
617 relocation -= input_section->output_offset;
621 return bfd_reloc_overflow;
623 /* Check for overflow. */
624 if (relocation & 0x02000000)
626 if ((relocation & ~ (bfd_vma) 0x03ffffff) != ~ (bfd_vma) 0x03ffffff)
627 flag = bfd_reloc_overflow;
629 else if (relocation & ~(bfd_vma) 0x03ffffff)
630 flag = bfd_reloc_overflow;
632 target &= ~0x00ffffff;
633 target |= (relocation >> 2) & 0x00ffffff;
634 bfd_put_32 (abfd, (bfd_vma) target, (bfd_byte *) data + addr);
636 /* Now the ARM magic... Change the reloc type so that it is marked as done.
637 Strictly this is only necessary if we are doing a partial relocation. */
638 reloc_entry->howto = &aoutarm_std_reloc_howto[ARM_26D];
643 static bfd_reloc_status_type
644 coff_thumb_pcrel_common (bfd *abfd,
645 arelent *reloc_entry,
648 asection *input_section,
650 char **error_message ATTRIBUTE_UNUSED,
651 thumb_pcrel_branchtype btype)
653 bfd_vma relocation = 0;
654 bfd_size_type addr = reloc_entry->address;
655 long target = bfd_get_32 (abfd, (bfd_byte *) data + addr);
656 bfd_reloc_status_type flag = bfd_reloc_ok;
661 /* NOTE: This routine is currently used by GAS, but not by the link
668 signbit = 0x00000100;
674 signbit = 0x00000800;
680 signbit = 0x00400000;
687 /* If this is an undefined symbol, return error. */
688 if (bfd_is_und_section (symbol->section)
689 && (symbol->flags & BSF_WEAK) == 0)
690 return output_bfd ? bfd_reloc_continue : bfd_reloc_undefined;
692 /* If the sections are different, and we are doing a partial relocation,
693 just ignore it for now. */
694 if (symbol->section->name != input_section->name
695 && output_bfd != (bfd *)NULL)
696 return bfd_reloc_continue;
702 relocation = ((target & dstmsk) << 1);
706 if (bfd_big_endian (abfd))
707 relocation = ((target & 0x7ff) << 1) | ((target & 0x07ff0000) >> 4);
709 relocation = ((target & 0x7ff) << 12) | ((target & 0x07ff0000) >> 15);
716 relocation = (relocation ^ signbit) - signbit; /* Sign extend. */
717 relocation += symbol->value;
718 relocation += symbol->section->output_section->vma;
719 relocation += symbol->section->output_offset;
720 relocation += reloc_entry->addend;
721 relocation -= input_section->output_section->vma;
722 relocation -= input_section->output_offset;
726 return bfd_reloc_overflow;
728 /* Check for overflow. */
729 if (relocation & signbit)
731 if ((relocation & ~offmsk) != ~offmsk)
732 flag = bfd_reloc_overflow;
734 else if (relocation & ~offmsk)
735 flag = bfd_reloc_overflow;
742 target |= (relocation >> 1);
746 if (bfd_big_endian (abfd))
747 target |= (((relocation & 0xfff) >> 1)
748 | ((relocation << 4) & 0x07ff0000));
750 target |= (((relocation & 0xffe) << 15)
751 | ((relocation >> 12) & 0x7ff));
758 bfd_put_32 (abfd, (bfd_vma) target, (bfd_byte *) data + addr);
760 /* Now the ARM magic... Change the reloc type so that it is marked as done.
761 Strictly this is only necessary if we are doing a partial relocation. */
762 reloc_entry->howto = & aoutarm_std_reloc_howto [ARM_26D];
764 /* TODO: We should possibly have DONE entries for the THUMB PCREL relocations. */
769 static bfd_reloc_status_type
770 coff_thumb_pcrel_23 (bfd *abfd,
771 arelent *reloc_entry,
774 asection *input_section,
776 char **error_message)
778 return coff_thumb_pcrel_common (abfd, reloc_entry, symbol, data,
779 input_section, output_bfd, error_message,
783 static bfd_reloc_status_type
784 coff_thumb_pcrel_9 (bfd *abfd,
785 arelent *reloc_entry,
788 asection *input_section,
790 char **error_message)
792 return coff_thumb_pcrel_common (abfd, reloc_entry, symbol, data,
793 input_section, output_bfd, error_message,
796 #endif /* not ARM_WINCE */
798 static bfd_reloc_status_type
799 coff_thumb_pcrel_12 (bfd *abfd,
800 arelent *reloc_entry,
803 asection *input_section,
805 char **error_message)
807 return coff_thumb_pcrel_common (abfd, reloc_entry, symbol, data,
808 input_section, output_bfd, error_message,
812 static const struct reloc_howto_struct *
813 coff_arm_reloc_type_lookup (bfd * abfd, bfd_reloc_code_real_type code)
815 #define ASTD(i,j) case i: return aoutarm_std_reloc_howto + j
817 if (code == BFD_RELOC_CTOR)
818 switch (bfd_arch_bits_per_address (abfd))
830 ASTD (BFD_RELOC_32, ARM_32);
831 ASTD (BFD_RELOC_RVA, ARM_RVA32);
832 ASTD (BFD_RELOC_ARM_PCREL_BRANCH, ARM_26);
833 ASTD (BFD_RELOC_THUMB_PCREL_BRANCH12, ARM_THUMB12);
834 ASTD (BFD_RELOC_32_SECREL, ARM_SECREL);
836 ASTD (BFD_RELOC_8, ARM_8);
837 ASTD (BFD_RELOC_16, ARM_16);
838 ASTD (BFD_RELOC_32, ARM_32);
839 ASTD (BFD_RELOC_ARM_PCREL_BRANCH, ARM_26);
840 ASTD (BFD_RELOC_ARM_PCREL_BLX, ARM_26);
841 ASTD (BFD_RELOC_8_PCREL, ARM_DISP8);
842 ASTD (BFD_RELOC_16_PCREL, ARM_DISP16);
843 ASTD (BFD_RELOC_32_PCREL, ARM_DISP32);
844 ASTD (BFD_RELOC_RVA, ARM_RVA32);
845 ASTD (BFD_RELOC_THUMB_PCREL_BRANCH9, ARM_THUMB9);
846 ASTD (BFD_RELOC_THUMB_PCREL_BRANCH12, ARM_THUMB12);
847 ASTD (BFD_RELOC_THUMB_PCREL_BRANCH23, ARM_THUMB23);
848 ASTD (BFD_RELOC_THUMB_PCREL_BLX, ARM_THUMB23);
850 default: return NULL;
854 static reloc_howto_type *
855 coff_arm_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
861 i < (sizeof (aoutarm_std_reloc_howto)
862 / sizeof (aoutarm_std_reloc_howto[0]));
864 if (aoutarm_std_reloc_howto[i].name != NULL
865 && strcasecmp (aoutarm_std_reloc_howto[i].name, r_name) == 0)
866 return &aoutarm_std_reloc_howto[i];
871 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER 2
872 #define COFF_PAGE_SIZE 0x1000
874 /* Turn a howto into a reloc nunmber. */
875 #define SELECT_RELOC(x,howto) { x.r_type = howto->type; }
876 #define BADMAG(x) ARMBADMAG(x)
877 #define ARM 1 /* Customize coffcode.h. */
880 /* Make sure that the 'r_offset' field is copied properly
881 so that identical binaries will compare the same. */
882 #define SWAP_IN_RELOC_OFFSET H_GET_32
883 #define SWAP_OUT_RELOC_OFFSET H_PUT_32
886 /* Extend the coff_link_hash_table structure with a few ARM specific fields.
887 This allows us to store global data here without actually creating any
888 global variables, which is a no-no in the BFD world. */
889 struct coff_arm_link_hash_table
891 /* The original coff_link_hash_table structure. MUST be first field. */
892 struct coff_link_hash_table root;
894 /* The size in bytes of the section containing the Thumb-to-ARM glue. */
895 bfd_size_type thumb_glue_size;
897 /* The size in bytes of the section containing the ARM-to-Thumb glue. */
898 bfd_size_type arm_glue_size;
900 /* An arbitrary input BFD chosen to hold the glue sections. */
901 bfd * bfd_of_glue_owner;
903 /* Support interworking with old, non-interworking aware ARM code. */
904 int support_old_code;
907 /* Get the ARM coff linker hash table from a link_info structure. */
908 #define coff_arm_hash_table(info) \
909 ((struct coff_arm_link_hash_table *) ((info)->hash))
911 /* Create an ARM coff linker hash table. */
913 static struct bfd_link_hash_table *
914 coff_arm_link_hash_table_create (bfd * abfd)
916 struct coff_arm_link_hash_table * ret;
917 bfd_size_type amt = sizeof (struct coff_arm_link_hash_table);
919 ret = bfd_zmalloc (amt);
923 if (!_bfd_coff_link_hash_table_init (&ret->root,
925 _bfd_coff_link_hash_newfunc,
926 sizeof (struct coff_link_hash_entry)))
932 return & ret->root.root;
936 arm_emit_base_file_entry (struct bfd_link_info *info,
938 asection *input_section,
939 bfd_vma reloc_offset)
941 bfd_vma addr = (reloc_offset
943 + input_section->output_offset
944 + input_section->output_section->vma);
946 if (coff_data (output_bfd)->pe)
947 addr -= pe_data (output_bfd)->pe_opthdr.ImageBase;
948 if (fwrite (&addr, sizeof (addr), 1, (FILE *) info->base_file) == 1)
951 bfd_set_error (bfd_error_system_call);
956 /* The thumb form of a long branch is a bit finicky, because the offset
957 encoding is split over two fields, each in it's own instruction. They
958 can occur in any order. So given a thumb form of long branch, and an
959 offset, insert the offset into the thumb branch and return finished
962 It takes two thumb instructions to encode the target address. Each has
963 11 bits to invest. The upper 11 bits are stored in one (identified by
964 H-0.. see below), the lower 11 bits are stored in the other (identified
967 Combine together and shifted left by 1 (it's a half word address) and
971 H-0, upper address-0 = 000
973 H-1, lower address-0 = 800
975 They can be ordered either way, but the arm tools I've seen always put
976 the lower one first. It probably doesn't matter. krk@cygnus.com
978 XXX: Actually the order does matter. The second instruction (H-1)
979 moves the computed address into the PC, so it must be the second one
980 in the sequence. The problem, however is that whilst little endian code
981 stores the instructions in HI then LOW order, big endian code does the
982 reverse. nickc@cygnus.com. */
984 #define LOW_HI_ORDER 0xF800F000
985 #define HI_LOW_ORDER 0xF000F800
988 insert_thumb_branch (insn32 br_insn, int rel_off)
990 unsigned int low_bits;
991 unsigned int high_bits;
993 BFD_ASSERT ((rel_off & 1) != 1);
995 rel_off >>= 1; /* Half word aligned address. */
996 low_bits = rel_off & 0x000007FF; /* The bottom 11 bits. */
997 high_bits = (rel_off >> 11) & 0x000007FF; /* The top 11 bits. */
999 if ((br_insn & LOW_HI_ORDER) == LOW_HI_ORDER)
1000 br_insn = LOW_HI_ORDER | (low_bits << 16) | high_bits;
1001 else if ((br_insn & HI_LOW_ORDER) == HI_LOW_ORDER)
1002 br_insn = HI_LOW_ORDER | (high_bits << 16) | low_bits;
1004 /* FIXME: the BFD library should never abort except for internal errors
1005 - it should return an error status. */
1006 abort (); /* Error - not a valid branch instruction form. */
1012 static struct coff_link_hash_entry *
1013 find_thumb_glue (struct bfd_link_info *info,
1018 struct coff_link_hash_entry *myh;
1019 bfd_size_type amt = strlen (name) + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1;
1021 tmp_name = bfd_malloc (amt);
1023 BFD_ASSERT (tmp_name);
1025 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
1027 myh = coff_link_hash_lookup
1028 (coff_hash_table (info), tmp_name, FALSE, FALSE, TRUE);
1031 /* xgettext:c-format */
1032 _bfd_error_handler (_("%B: unable to find THUMB glue '%s' for `%s'"),
1033 input_bfd, tmp_name, name);
1039 #endif /* not ARM_WINCE */
1041 static struct coff_link_hash_entry *
1042 find_arm_glue (struct bfd_link_info *info,
1047 struct coff_link_hash_entry * myh;
1048 bfd_size_type amt = strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1;
1050 tmp_name = bfd_malloc (amt);
1052 BFD_ASSERT (tmp_name);
1054 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
1056 myh = coff_link_hash_lookup
1057 (coff_hash_table (info), tmp_name, FALSE, FALSE, TRUE);
1060 /* xgettext:c-format */
1061 _bfd_error_handler (_("%B: unable to find ARM glue '%s' for `%s'"),
1062 input_bfd, tmp_name, name);
1074 ldr r12, __func_addr
1077 .word func @ behave as if you saw a ARM_32 reloc
1080 #define ARM2THUMB_GLUE_SIZE 12
1081 static const insn32 a2t1_ldr_insn = 0xe59fc000;
1082 static const insn32 a2t2_bx_r12_insn = 0xe12fff1c;
1083 static const insn32 a2t3_func_addr_insn = 0x00000001;
1086 Thumb->ARM: Thumb->(non-interworking aware) ARM
1090 __func_from_thumb: __func_from_thumb:
1092 nop ldr r6, __func_addr
1094 __func_change_to_arm: bx r6
1096 __func_back_to_thumb:
1103 #define THUMB2ARM_GLUE_SIZE (globals->support_old_code ? 20 : 8)
1105 static const insn16 t2a1_bx_pc_insn = 0x4778;
1106 static const insn16 t2a2_noop_insn = 0x46c0;
1107 static const insn32 t2a3_b_insn = 0xea000000;
1109 static const insn16 t2a1_push_insn = 0xb540;
1110 static const insn16 t2a2_ldr_insn = 0x4e03;
1111 static const insn16 t2a3_mov_insn = 0x46fe;
1112 static const insn16 t2a4_bx_insn = 0x4730;
1113 static const insn32 t2a5_pop_insn = 0xe8bd4040;
1114 static const insn32 t2a6_bx_insn = 0xe12fff1e;
1118 We should really create new local (static) symbols in destination
1119 object for each stub we create. We should also create local
1120 (static) symbols within the stubs when switching between ARM and
1121 Thumb code. This will ensure that the debugger and disassembler
1122 can present a better view of stubs.
1124 We can treat stubs like literal sections, and for the THUMB9 ones
1125 (short addressing range) we should be able to insert the stubs
1126 between sections. i.e. the simplest approach (since relocations
1127 are done on a section basis) is to dump the stubs at the end of
1128 processing a section. That way we can always try and minimise the
1129 offset to and from a stub. However, this does not map well onto
1130 the way that the linker/BFD does its work: mapping all input
1131 sections to output sections via the linker script before doing
1134 Unfortunately it may be easier to just to disallow short range
1135 Thumb->ARM stubs (i.e. no conditional inter-working branches,
1136 only branch-and-link (BL) calls. This will simplify the processing
1137 since we can then put all of the stubs into their own section.
1140 On a different subject, rather than complaining when a
1141 branch cannot fit in the number of bits available for the
1142 instruction we should generate a trampoline stub (needed to
1143 address the complete 32bit address space). */
1145 /* The standard COFF backend linker does not cope with the special
1146 Thumb BRANCH23 relocation. The alternative would be to split the
1147 BRANCH23 into seperate HI23 and LO23 relocations. However, it is a
1148 bit simpler simply providing our own relocation driver. */
1150 /* The reloc processing routine for the ARM/Thumb COFF linker. NOTE:
1151 This code is a very slightly modified copy of
1152 _bfd_coff_generic_relocate_section. It would be a much more
1153 maintainable solution to have a MACRO that could be expanded within
1154 _bfd_coff_generic_relocate_section that would only be provided for
1155 ARM/Thumb builds. It is only the code marked THUMBEXTENSION that
1156 is different from the original. */
1159 coff_arm_relocate_section (bfd *output_bfd,
1160 struct bfd_link_info *info,
1162 asection *input_section,
1164 struct internal_reloc *relocs,
1165 struct internal_syment *syms,
1166 asection **sections)
1168 struct internal_reloc * rel;
1169 struct internal_reloc * relend;
1171 bfd_vma high_address = bfd_get_section_limit (input_bfd, input_section);
1175 relend = rel + input_section->reloc_count;
1177 for (; rel < relend; rel++)
1181 struct coff_link_hash_entry * h;
1182 struct internal_syment * sym;
1185 reloc_howto_type * howto;
1186 bfd_reloc_status_type rstat;
1189 symndx = rel->r_symndx;
1198 h = obj_coff_sym_hashes (input_bfd)[symndx];
1199 sym = syms + symndx;
1202 /* COFF treats common symbols in one of two ways. Either the
1203 size of the symbol is included in the section contents, or it
1204 is not. We assume that the size is not included, and force
1205 the rtype_to_howto function to adjust the addend as needed. */
1207 if (sym != NULL && sym->n_scnum != 0)
1208 addend = - sym->n_value;
1212 howto = coff_rtype_to_howto (input_bfd, input_section, rel, h,
1217 /* The relocation_section function will skip pcrel_offset relocs
1218 when doing a relocatable link. However, we want to convert
1219 ARM_26 to ARM_26D relocs if possible. We return a fake howto in
1220 this case without pcrel_offset set, and adjust the addend to
1221 compensate. 'partial_inplace' is also set, since we want 'done'
1222 relocations to be reflected in section's data. */
1223 if (rel->r_type == ARM_26
1225 && bfd_link_relocatable (info)
1226 && (h->root.type == bfd_link_hash_defined
1227 || h->root.type == bfd_link_hash_defweak)
1228 && (h->root.u.def.section->output_section
1229 == input_section->output_section))
1231 static reloc_howto_type fake_arm26_reloc =
1238 complain_overflow_signed,
1239 aoutarm_fix_pcrel_26 ,
1246 addend -= rel->r_vaddr - input_section->vma;
1248 /* FIXME: I don't know why, but the hack is necessary for correct
1249 generation of bl's instruction offset. */
1252 howto = & fake_arm26_reloc;
1256 /* MS ARM-CE makes the reloc relative to the opcode's pc, not
1257 the next opcode's pc, so is off by one. */
1258 if (howto->pc_relative && !bfd_link_relocatable (info))
1262 /* If we are doing a relocatable link, then we can just ignore
1263 a PC relative reloc that is pcrel_offset. It will already
1264 have the correct value. If this is not a relocatable link,
1265 then we should ignore the symbol value. */
1266 if (howto->pc_relative && howto->pcrel_offset)
1268 if (bfd_link_relocatable (info))
1270 /* FIXME - it is not clear which targets need this next test
1271 and which do not. It is known that it is needed for the
1272 VxWorks and EPOC-PE targets, but it is also known that it
1273 was suppressed for other ARM targets. This ought to be
1274 sorted out one day. */
1275 #ifdef ARM_COFF_BUGFIX
1276 /* We must not ignore the symbol value. If the symbol is
1277 within the same section, the relocation should have already
1278 been fixed, but if it is not, we'll be handed a reloc into
1279 the beginning of the symbol's section, so we must not cancel
1280 out the symbol's value, otherwise we'll be adding it in
1282 if (sym != NULL && sym->n_scnum != 0)
1283 addend += sym->n_value;
1295 sec = bfd_abs_section_ptr;
1300 sec = sections[symndx];
1301 val = (sec->output_section->vma
1302 + sec->output_offset
1309 /* We don't output the stubs if we are generating a
1310 relocatable output file, since we may as well leave the
1311 stub generation to the final linker pass. If we fail to
1312 verify that the name is defined, we'll try to build stubs
1313 for an undefined name... */
1314 if (! bfd_link_relocatable (info)
1315 && ( h->root.type == bfd_link_hash_defined
1316 || h->root.type == bfd_link_hash_defweak))
1318 asection * h_sec = h->root.u.def.section;
1319 const char * name = h->root.root.string;
1321 /* h locates the symbol referenced in the reloc. */
1322 h_val = (h->root.u.def.value
1323 + h_sec->output_section->vma
1324 + h_sec->output_offset);
1326 if (howto->type == ARM_26)
1328 if ( h->symbol_class == C_THUMBSTATFUNC
1329 || h->symbol_class == C_THUMBEXTFUNC)
1331 /* Arm code calling a Thumb function. */
1332 unsigned long int tmp;
1335 long int ret_offset;
1336 struct coff_link_hash_entry * myh;
1337 struct coff_arm_link_hash_table * globals;
1339 myh = find_arm_glue (info, name, input_bfd);
1343 globals = coff_arm_hash_table (info);
1345 BFD_ASSERT (globals != NULL);
1346 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1348 my_offset = myh->root.u.def.value;
1350 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
1351 ARM2THUMB_GLUE_SECTION_NAME);
1352 BFD_ASSERT (s != NULL);
1353 BFD_ASSERT (s->contents != NULL);
1354 BFD_ASSERT (s->output_section != NULL);
1356 if ((my_offset & 0x01) == 0x01)
1358 if (h_sec->owner != NULL
1359 && INTERWORK_SET (h_sec->owner)
1360 && ! INTERWORK_FLAG (h_sec->owner))
1362 /* xgettext:c-format */
1363 (_("%B(%s): warning: interworking not enabled.\n"
1364 " first occurrence: %B: arm call to thumb"),
1365 h_sec->owner, input_bfd, name);
1368 myh->root.u.def.value = my_offset;
1370 bfd_put_32 (output_bfd, (bfd_vma) a2t1_ldr_insn,
1371 s->contents + my_offset);
1373 bfd_put_32 (output_bfd, (bfd_vma) a2t2_bx_r12_insn,
1374 s->contents + my_offset + 4);
1376 /* It's a thumb address. Add the low order bit. */
1377 bfd_put_32 (output_bfd, h_val | a2t3_func_addr_insn,
1378 s->contents + my_offset + 8);
1381 && !arm_emit_base_file_entry (info, output_bfd,
1386 BFD_ASSERT (my_offset <= globals->arm_glue_size);
1388 tmp = bfd_get_32 (input_bfd, contents + rel->r_vaddr
1389 - input_section->vma);
1391 tmp = tmp & 0xFF000000;
1393 /* Somehow these are both 4 too far, so subtract 8. */
1397 + s->output_section->vma
1398 - (input_section->output_offset
1399 + input_section->output_section->vma
1403 tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
1405 bfd_put_32 (output_bfd, (bfd_vma) tmp,
1406 contents + rel->r_vaddr - input_section->vma);
1412 /* Note: We used to check for ARM_THUMB9 and ARM_THUMB12. */
1413 else if (howto->type == ARM_THUMB23)
1415 if ( h->symbol_class == C_EXT
1416 || h->symbol_class == C_STAT
1417 || h->symbol_class == C_LABEL)
1419 /* Thumb code calling an ARM function. */
1422 unsigned long int tmp;
1423 long int ret_offset;
1424 struct coff_link_hash_entry * myh;
1425 struct coff_arm_link_hash_table * globals;
1427 myh = find_thumb_glue (info, name, input_bfd);
1431 globals = coff_arm_hash_table (info);
1433 BFD_ASSERT (globals != NULL);
1434 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1436 my_offset = myh->root.u.def.value;
1438 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
1439 THUMB2ARM_GLUE_SECTION_NAME);
1441 BFD_ASSERT (s != NULL);
1442 BFD_ASSERT (s->contents != NULL);
1443 BFD_ASSERT (s->output_section != NULL);
1445 if ((my_offset & 0x01) == 0x01)
1447 if (h_sec->owner != NULL
1448 && INTERWORK_SET (h_sec->owner)
1449 && ! INTERWORK_FLAG (h_sec->owner)
1450 && ! globals->support_old_code)
1452 /* xgettext:c-format */
1453 (_("%B(%s): warning: interworking not enabled.\n"
1454 " first occurrence: %B: thumb call to arm\n"
1455 " consider relinking with --support-old-code enabled"),
1456 h_sec->owner, input_bfd, name);
1459 myh->root.u.def.value = my_offset;
1461 if (globals->support_old_code)
1463 bfd_put_16 (output_bfd, (bfd_vma) t2a1_push_insn,
1464 s->contents + my_offset);
1466 bfd_put_16 (output_bfd, (bfd_vma) t2a2_ldr_insn,
1467 s->contents + my_offset + 2);
1469 bfd_put_16 (output_bfd, (bfd_vma) t2a3_mov_insn,
1470 s->contents + my_offset + 4);
1472 bfd_put_16 (output_bfd, (bfd_vma) t2a4_bx_insn,
1473 s->contents + my_offset + 6);
1475 bfd_put_32 (output_bfd, (bfd_vma) t2a5_pop_insn,
1476 s->contents + my_offset + 8);
1478 bfd_put_32 (output_bfd, (bfd_vma) t2a6_bx_insn,
1479 s->contents + my_offset + 12);
1481 /* Store the address of the function in the last word of the stub. */
1482 bfd_put_32 (output_bfd, h_val,
1483 s->contents + my_offset + 16);
1486 && !arm_emit_base_file_entry (info,
1493 bfd_put_16 (output_bfd, (bfd_vma) t2a1_bx_pc_insn,
1494 s->contents + my_offset);
1496 bfd_put_16 (output_bfd, (bfd_vma) t2a2_noop_insn,
1497 s->contents + my_offset + 2);
1500 /* Address of destination of the stub. */
1501 ((bfd_signed_vma) h_val)
1503 /* Offset from the start of the current section to the start of the stubs. */
1505 /* Offset of the start of this stub from the start of the stubs. */
1507 /* Address of the start of the current section. */
1508 + s->output_section->vma)
1509 /* The branch instruction is 4 bytes into the stub. */
1511 /* ARM branches work from the pc of the instruction + 8. */
1514 bfd_put_32 (output_bfd,
1515 (bfd_vma) t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
1516 s->contents + my_offset + 4);
1521 BFD_ASSERT (my_offset <= globals->thumb_glue_size);
1523 /* Now go back and fix up the original BL insn to point
1528 - (input_section->output_offset
1532 tmp = bfd_get_32 (input_bfd, contents + rel->r_vaddr
1533 - input_section->vma);
1535 bfd_put_32 (output_bfd,
1536 (bfd_vma) insert_thumb_branch (tmp,
1538 contents + rel->r_vaddr - input_section->vma);
1546 /* If the relocation type and destination symbol does not
1547 fall into one of the above categories, then we can just
1548 perform a direct link. */
1551 rstat = bfd_reloc_ok;
1553 if ( h->root.type == bfd_link_hash_defined
1554 || h->root.type == bfd_link_hash_defweak)
1558 sec = h->root.u.def.section;
1559 val = (h->root.u.def.value
1560 + sec->output_section->vma
1561 + sec->output_offset);
1564 else if (! bfd_link_relocatable (info))
1565 (*info->callbacks->undefined_symbol)
1566 (info, h->root.root.string, input_bfd, input_section,
1567 rel->r_vaddr - input_section->vma, TRUE);
1570 /* Emit a reloc if the backend thinks it needs it. */
1573 && pe_data(output_bfd)->in_reloc_p(output_bfd, howto)
1574 && !arm_emit_base_file_entry (info, output_bfd, input_section,
1579 rstat = bfd_reloc_ok;
1581 /* Only perform this fix during the final link, not a relocatable link. */
1582 else if (! bfd_link_relocatable (info)
1583 && howto->type == ARM_THUMB23)
1585 /* This is pretty much a copy of what the default
1586 _bfd_final_link_relocate and _bfd_relocate_contents
1587 routines do to perform a relocation, with special
1588 processing for the split addressing of the Thumb BL
1589 instruction. Again, it would probably be simpler adding a
1590 ThumbBRANCH23 specific macro expansion into the default
1593 bfd_vma address = rel->r_vaddr - input_section->vma;
1595 if (address > high_address)
1596 rstat = bfd_reloc_outofrange;
1599 bfd_vma relocation = val + addend;
1600 int size = bfd_get_reloc_size (howto);
1601 bfd_boolean overflow = FALSE;
1602 bfd_byte *location = contents + address;
1603 bfd_vma x = bfd_get_32 (input_bfd, location);
1604 bfd_vma src_mask = 0x007FFFFE;
1605 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
1606 bfd_signed_vma reloc_signed_min = ~reloc_signed_max;
1608 bfd_signed_vma signed_check;
1610 bfd_signed_vma signed_add;
1612 BFD_ASSERT (size == 4);
1614 /* howto->pc_relative should be TRUE for type 14 BRANCH23. */
1615 relocation -= (input_section->output_section->vma
1616 + input_section->output_offset);
1618 /* howto->pcrel_offset should be TRUE for type 14 BRANCH23. */
1619 relocation -= address;
1621 /* No need to negate the relocation with BRANCH23. */
1622 /* howto->complain_on_overflow == complain_overflow_signed for BRANCH23. */
1623 /* howto->rightshift == 1 */
1625 /* Drop unwanted bits from the value we are relocating to. */
1626 check = relocation >> howto->rightshift;
1628 /* If this is a signed value, the rightshift just dropped
1629 leading 1 bits (assuming twos complement). */
1630 if ((bfd_signed_vma) relocation >= 0)
1631 signed_check = check;
1633 signed_check = (check
1635 & ~((bfd_vma) - 1 >> howto->rightshift)));
1637 /* Get the value from the object file. */
1638 if (bfd_big_endian (input_bfd))
1639 add = (((x) & 0x07ff0000) >> 4) | (((x) & 0x7ff) << 1);
1641 add = ((((x) & 0x7ff) << 12) | (((x) & 0x07ff0000) >> 15));
1643 /* Get the value from the object file with an appropriate sign.
1644 The expression involving howto->src_mask isolates the upper
1645 bit of src_mask. If that bit is set in the value we are
1646 adding, it is negative, and we subtract out that number times
1647 two. If src_mask includes the highest possible bit, then we
1648 can not get the upper bit, but that does not matter since
1649 signed_add needs no adjustment to become negative in that
1653 if ((add & (((~ src_mask) >> 1) & src_mask)) != 0)
1654 signed_add -= (((~ src_mask) >> 1) & src_mask) << 1;
1656 /* howto->bitpos == 0 */
1657 /* Add the value from the object file, shifted so that it is a
1659 signed_check += signed_add;
1660 relocation += signed_add;
1662 BFD_ASSERT (howto->complain_on_overflow == complain_overflow_signed);
1664 /* Assumes two's complement. */
1665 if ( signed_check > reloc_signed_max
1666 || signed_check < reloc_signed_min)
1669 /* Put the relocation into the correct bits.
1670 For a BLX instruction, make sure that the relocation is rounded up
1671 to a word boundary. This follows the semantics of the instruction
1672 which specifies that bit 1 of the target address will come from bit
1673 1 of the base address. */
1674 if (bfd_big_endian (input_bfd))
1676 if ((x & 0x1800) == 0x0800 && (relocation & 0x02))
1678 relocation = (((relocation & 0xffe) >> 1) | ((relocation << 4) & 0x07ff0000));
1682 if ((x & 0x18000000) == 0x08000000 && (relocation & 0x02))
1684 relocation = (((relocation & 0xffe) << 15) | ((relocation >> 12) & 0x7ff));
1687 /* Add the relocation to the correct bits of X. */
1688 x = ((x & ~howto->dst_mask) | relocation);
1690 /* Put the relocated value back in the object file. */
1691 bfd_put_32 (input_bfd, x, location);
1693 rstat = overflow ? bfd_reloc_overflow : bfd_reloc_ok;
1698 if (bfd_link_relocatable (info) && ! howto->partial_inplace)
1699 rstat = bfd_reloc_ok;
1701 rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
1703 rel->r_vaddr - input_section->vma,
1705 /* Only perform this fix during the final link, not a relocatable link. */
1706 if (! bfd_link_relocatable (info)
1707 && (rel->r_type == ARM_32 || rel->r_type == ARM_RVA32))
1709 /* Determine if we need to set the bottom bit of a relocated address
1710 because the address is the address of a Thumb code symbol. */
1711 int patchit = FALSE;
1714 && ( h->symbol_class == C_THUMBSTATFUNC
1715 || h->symbol_class == C_THUMBEXTFUNC))
1719 else if (sym != NULL
1720 && sym->n_scnum > N_UNDEF)
1722 /* No hash entry - use the symbol instead. */
1723 if ( sym->n_sclass == C_THUMBSTATFUNC
1724 || sym->n_sclass == C_THUMBEXTFUNC)
1730 bfd_byte * location = contents + rel->r_vaddr - input_section->vma;
1731 bfd_vma x = bfd_get_32 (input_bfd, location);
1733 bfd_put_32 (input_bfd, x | 1, location);
1743 case bfd_reloc_outofrange:
1745 /* xgettext:c-format */
1746 (_("%B: bad reloc address 0x%lx in section `%A'"),
1747 input_bfd, input_section, (unsigned long) rel->r_vaddr);
1749 case bfd_reloc_overflow:
1752 char buf[SYMNMLEN + 1];
1760 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
1765 (*info->callbacks->reloc_overflow)
1766 (info, (h ? &h->root : NULL), name, howto->name,
1767 (bfd_vma) 0, input_bfd, input_section,
1768 rel->r_vaddr - input_section->vma);
1776 #ifndef COFF_IMAGE_WITH_PE
1779 bfd_arm_allocate_interworking_sections (struct bfd_link_info * info)
1783 struct coff_arm_link_hash_table * globals;
1785 globals = coff_arm_hash_table (info);
1787 BFD_ASSERT (globals != NULL);
1789 if (globals->arm_glue_size != 0)
1791 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1793 s = bfd_get_section_by_name
1794 (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
1796 BFD_ASSERT (s != NULL);
1798 foo = bfd_alloc (globals->bfd_of_glue_owner, globals->arm_glue_size);
1800 s->size = globals->arm_glue_size;
1804 if (globals->thumb_glue_size != 0)
1806 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1808 s = bfd_get_section_by_name
1809 (globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
1811 BFD_ASSERT (s != NULL);
1813 foo = bfd_alloc (globals->bfd_of_glue_owner, globals->thumb_glue_size);
1815 s->size = globals->thumb_glue_size;
1823 record_arm_to_thumb_glue (struct bfd_link_info * info,
1824 struct coff_link_hash_entry * h)
1826 const char * name = h->root.root.string;
1827 register asection * s;
1829 struct coff_link_hash_entry * myh;
1830 struct bfd_link_hash_entry * bh;
1831 struct coff_arm_link_hash_table * globals;
1835 globals = coff_arm_hash_table (info);
1837 BFD_ASSERT (globals != NULL);
1838 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1840 s = bfd_get_section_by_name
1841 (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
1843 BFD_ASSERT (s != NULL);
1845 amt = strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1;
1846 tmp_name = bfd_malloc (amt);
1848 BFD_ASSERT (tmp_name);
1850 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
1852 myh = coff_link_hash_lookup
1853 (coff_hash_table (info), tmp_name, FALSE, FALSE, TRUE);
1858 /* We've already seen this guy. */
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
1866 val = globals->arm_glue_size + 1;
1867 bfd_coff_link_add_one_symbol (info, globals->bfd_of_glue_owner, tmp_name,
1868 BSF_GLOBAL, s, val, NULL, TRUE, FALSE, &bh);
1872 globals->arm_glue_size += ARM2THUMB_GLUE_SIZE;
1879 record_thumb_to_arm_glue (struct bfd_link_info * info,
1880 struct coff_link_hash_entry * h)
1882 const char * name = h->root.root.string;
1885 struct coff_link_hash_entry * myh;
1886 struct bfd_link_hash_entry * bh;
1887 struct coff_arm_link_hash_table * globals;
1891 globals = coff_arm_hash_table (info);
1893 BFD_ASSERT (globals != NULL);
1894 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1896 s = bfd_get_section_by_name
1897 (globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
1899 BFD_ASSERT (s != NULL);
1901 amt = strlen (name) + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1;
1902 tmp_name = bfd_malloc (amt);
1904 BFD_ASSERT (tmp_name);
1906 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
1908 myh = coff_link_hash_lookup
1909 (coff_hash_table (info), tmp_name, FALSE, FALSE, TRUE);
1914 /* We've already seen this guy. */
1919 val = globals->thumb_glue_size + 1;
1920 bfd_coff_link_add_one_symbol (info, globals->bfd_of_glue_owner, tmp_name,
1921 BSF_GLOBAL, s, val, NULL, TRUE, FALSE, &bh);
1923 /* If we mark it 'thumb', the disassembler will do a better job. */
1924 myh = (struct coff_link_hash_entry *) bh;
1925 myh->symbol_class = C_THUMBEXTFUNC;
1929 /* Allocate another symbol to mark where we switch to arm mode. */
1931 #define CHANGE_TO_ARM "__%s_change_to_arm"
1932 #define BACK_FROM_ARM "__%s_back_from_arm"
1934 amt = strlen (name) + strlen (CHANGE_TO_ARM) + 1;
1935 tmp_name = bfd_malloc (amt);
1937 BFD_ASSERT (tmp_name);
1939 sprintf (tmp_name, globals->support_old_code ? BACK_FROM_ARM : CHANGE_TO_ARM, name);
1942 val = globals->thumb_glue_size + (globals->support_old_code ? 8 : 4);
1943 bfd_coff_link_add_one_symbol (info, globals->bfd_of_glue_owner, tmp_name,
1944 BSF_LOCAL, s, val, NULL, TRUE, FALSE, &bh);
1948 globals->thumb_glue_size += THUMB2ARM_GLUE_SIZE;
1952 #endif /* not ARM_WINCE */
1954 /* Select a BFD to be used to hold the sections used by the glue code.
1955 This function is called from the linker scripts in ld/emultempl/
1959 bfd_arm_get_bfd_for_interworking (bfd * abfd,
1960 struct bfd_link_info * info)
1962 struct coff_arm_link_hash_table * globals;
1966 /* If we are only performing a partial link do not bother
1967 getting a bfd to hold the glue. */
1968 if (bfd_link_relocatable (info))
1971 globals = coff_arm_hash_table (info);
1973 BFD_ASSERT (globals != NULL);
1975 if (globals->bfd_of_glue_owner != NULL)
1978 sec = bfd_get_section_by_name (abfd, ARM2THUMB_GLUE_SECTION_NAME);
1982 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1983 | SEC_CODE | SEC_READONLY);
1984 sec = bfd_make_section_with_flags (abfd, ARM2THUMB_GLUE_SECTION_NAME,
1987 || ! bfd_set_section_alignment (abfd, sec, 2))
1991 sec = bfd_get_section_by_name (abfd, THUMB2ARM_GLUE_SECTION_NAME);
1995 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1996 | SEC_CODE | SEC_READONLY);
1997 sec = bfd_make_section_with_flags (abfd, THUMB2ARM_GLUE_SECTION_NAME,
2001 || ! bfd_set_section_alignment (abfd, sec, 2))
2005 /* Save the bfd for later use. */
2006 globals->bfd_of_glue_owner = abfd;
2012 bfd_arm_process_before_allocation (bfd * abfd,
2013 struct bfd_link_info * info,
2014 int support_old_code)
2017 struct coff_arm_link_hash_table * globals;
2019 /* If we are only performing a partial link do not bother
2020 to construct any glue. */
2021 if (bfd_link_relocatable (info))
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 _bfd_coff_get_external_symbols (abfd);
2028 globals = coff_arm_hash_table (info);
2030 BFD_ASSERT (globals != NULL);
2031 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2033 globals->support_old_code = support_old_code;
2035 /* Rummage around all the relocs and map the glue vectors. */
2036 sec = abfd->sections;
2041 for (; sec != NULL; sec = sec->next)
2043 struct internal_reloc * i;
2044 struct internal_reloc * rel;
2046 if (sec->reloc_count == 0)
2049 /* Load the relocs. */
2050 /* FIXME: there may be a storage leak here. */
2051 i = _bfd_coff_read_internal_relocs (abfd, sec, 1, 0, 0, 0);
2053 BFD_ASSERT (i != 0);
2055 for (rel = i; rel < i + sec->reloc_count; ++rel)
2057 unsigned short r_type = rel->r_type;
2059 struct coff_link_hash_entry * h;
2061 symndx = rel->r_symndx;
2063 /* If the relocation is not against a symbol it cannot concern us. */
2067 /* If the index is outside of the range of our table, something has gone wrong. */
2068 if (symndx >= obj_conv_table_size (abfd))
2070 /* xgettext:c-format */
2071 _bfd_error_handler (_("%B: illegal symbol index in reloc: %d"),
2076 h = obj_coff_sym_hashes (abfd)[symndx];
2078 /* If the relocation is against a static symbol it must be within
2079 the current section and so cannot be a cross ARM/Thumb relocation. */
2086 /* This one is a call from arm code. We need to look up
2087 the target of the call. If it is a thumb target, we
2090 if (h->symbol_class == C_THUMBEXTFUNC)
2091 record_arm_to_thumb_glue (info, h);
2096 /* This one is a call from thumb code. We used to look
2097 for ARM_THUMB9 and ARM_THUMB12 as well. We need to look
2098 up the target of the call. If it is an arm target, we
2099 insert glue. If the symbol does not exist it will be
2100 given a class of C_EXT and so we will generate a stub
2101 for it. This is not really a problem, since the link
2102 is doomed anyway. */
2104 switch (h->symbol_class)
2109 record_thumb_to_arm_glue (info, h);
2126 #endif /* ! defined (COFF_IMAGE_WITH_PE) */
2128 #define coff_bfd_reloc_type_lookup coff_arm_reloc_type_lookup
2129 #define coff_bfd_reloc_name_lookup coff_arm_reloc_name_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
2141 /* When doing a relocatable link, we want to convert ARM_26 relocs
2142 into ARM_26D relocs. */
2145 coff_arm_adjust_symndx (bfd *obfd ATTRIBUTE_UNUSED,
2146 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2149 struct internal_reloc *irel,
2150 bfd_boolean *adjustedp)
2152 if (irel->r_type == ARM_26)
2154 struct coff_link_hash_entry *h;
2156 h = obj_coff_sym_hashes (ibfd)[irel->r_symndx];
2158 && (h->root.type == bfd_link_hash_defined
2159 || h->root.type == bfd_link_hash_defweak)
2160 && h->root.u.def.section->output_section == sec->output_section)
2161 irel->r_type = ARM_26D;
2167 /* Called when merging the private data areas of two BFDs.
2168 This is important as it allows us to detect if we are
2169 attempting to merge binaries compiled for different ARM
2170 targets, eg different CPUs or different APCS's. */
2173 coff_arm_merge_private_bfd_data (bfd * ibfd, struct bfd_link_info *info)
2175 bfd *obfd = info->output_bfd;
2176 BFD_ASSERT (ibfd != NULL && obfd != NULL);
2181 /* If the two formats are different we cannot merge anything.
2182 This is not an error, since it is permissable to change the
2183 input and output formats. */
2184 if ( ibfd->xvec->flavour != bfd_target_coff_flavour
2185 || obfd->xvec->flavour != bfd_target_coff_flavour)
2188 /* Determine what should happen if the input ARM architecture
2189 does not match the output ARM architecture. */
2190 if (! bfd_arm_merge_machines (ibfd, obfd))
2193 /* Verify that the APCS is the same for the two BFDs. */
2194 if (APCS_SET (ibfd))
2196 if (APCS_SET (obfd))
2198 /* If the src and dest have different APCS flag bits set, fail. */
2199 if (APCS_26_FLAG (obfd) != APCS_26_FLAG (ibfd))
2202 /* xgettext: c-format */
2203 (_("error: %B is compiled for APCS-%d, whereas %B is compiled for APCS-%d"),
2205 APCS_26_FLAG (ibfd) ? 26 : 32,
2206 APCS_26_FLAG (obfd) ? 26 : 32
2209 bfd_set_error (bfd_error_wrong_format);
2213 if (APCS_FLOAT_FLAG (obfd) != APCS_FLOAT_FLAG (ibfd))
2215 if (APCS_FLOAT_FLAG (ibfd))
2216 /* xgettext: c-format */
2217 _bfd_error_handler (_("\
2218 error: %B passes floats in float registers, whereas %B passes them in integer registers"),
2221 /* xgettext: c-format */
2222 _bfd_error_handler (_("\
2223 error: %B passes floats in integer registers, whereas %B passes them in float registers"),
2226 bfd_set_error (bfd_error_wrong_format);
2230 if (PIC_FLAG (obfd) != PIC_FLAG (ibfd))
2232 if (PIC_FLAG (ibfd))
2233 /* xgettext: c-format */
2234 _bfd_error_handler (_("\
2235 error: %B is compiled as position independent code, whereas target %B is absolute position"),
2238 /* xgettext: c-format */
2239 _bfd_error_handler (_("\
2240 error: %B is compiled as absolute position code, whereas target %B is position independent"),
2243 bfd_set_error (bfd_error_wrong_format);
2249 SET_APCS_FLAGS (obfd, APCS_26_FLAG (ibfd) | APCS_FLOAT_FLAG (ibfd) | PIC_FLAG (ibfd));
2251 /* Set up the arch and fields as well as these are probably wrong. */
2252 bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
2256 /* Check the interworking support. */
2257 if (INTERWORK_SET (ibfd))
2259 if (INTERWORK_SET (obfd))
2261 /* If the src and dest differ in their interworking issue a warning. */
2262 if (INTERWORK_FLAG (obfd) != INTERWORK_FLAG (ibfd))
2264 if (INTERWORK_FLAG (ibfd))
2265 /* xgettext: c-format */
2266 _bfd_error_handler (_("\
2267 Warning: %B supports interworking, whereas %B does not"),
2270 /* xgettext: c-format */
2271 _bfd_error_handler (_("\
2272 Warning: %B does not support interworking, whereas %B does"),
2278 SET_INTERWORK_FLAG (obfd, INTERWORK_FLAG (ibfd));
2285 /* Display the flags field. */
2288 coff_arm_print_private_bfd_data (bfd * abfd, void * ptr)
2290 FILE * file = (FILE *) ptr;
2292 BFD_ASSERT (abfd != NULL && ptr != NULL);
2294 fprintf (file, _("private flags = %x:"), coff_data (abfd)->flags);
2296 if (APCS_SET (abfd))
2298 /* xgettext: APCS is ARM Procedure Call Standard, it should not be translated. */
2299 fprintf (file, " [APCS-%d]", APCS_26_FLAG (abfd) ? 26 : 32);
2301 if (APCS_FLOAT_FLAG (abfd))
2302 fprintf (file, _(" [floats passed in float registers]"));
2304 fprintf (file, _(" [floats passed in integer registers]"));
2306 if (PIC_FLAG (abfd))
2307 fprintf (file, _(" [position independent]"));
2309 fprintf (file, _(" [absolute position]"));
2312 if (! INTERWORK_SET (abfd))
2313 fprintf (file, _(" [interworking flag not initialised]"));
2314 else if (INTERWORK_FLAG (abfd))
2315 fprintf (file, _(" [interworking supported]"));
2317 fprintf (file, _(" [interworking not supported]"));
2324 /* Copies the given flags into the coff_tdata.flags field.
2325 Typically these flags come from the f_flags[] field of
2326 the COFF filehdr structure, which contains important,
2327 target specific information.
2328 Note: Although this function is static, it is explicitly
2329 called from both coffcode.h and peicode.h. */
2332 _bfd_coff_arm_set_private_flags (bfd * abfd, flagword flags)
2336 BFD_ASSERT (abfd != NULL);
2338 flag = (flags & F_APCS26) ? F_APCS_26 : 0;
2340 /* Make sure that the APCS field has not been initialised to the opposite
2343 && ( (APCS_26_FLAG (abfd) != flag)
2344 || (APCS_FLOAT_FLAG (abfd) != (flags & F_APCS_FLOAT))
2345 || (PIC_FLAG (abfd) != (flags & F_PIC))
2349 flag |= (flags & (F_APCS_FLOAT | F_PIC));
2351 SET_APCS_FLAGS (abfd, flag);
2353 flag = (flags & F_INTERWORK);
2355 /* If the BFD has already had its interworking flag set, but it
2356 is different from the value that we have been asked to set,
2357 then assume that that merged code will not support interworking
2358 and set the flag accordingly. */
2359 if (INTERWORK_SET (abfd) && (INTERWORK_FLAG (abfd) != flag))
2362 _bfd_error_handler (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
2365 _bfd_error_handler (_("Warning: Clearing the interworking flag of %B due to outside request"),
2370 SET_INTERWORK_FLAG (abfd, flag);
2375 /* Copy the important parts of the target specific data
2376 from one instance of a BFD to another. */
2379 coff_arm_copy_private_bfd_data (bfd * src, bfd * dest)
2381 BFD_ASSERT (src != NULL && dest != NULL);
2386 /* If the destination is not in the same format as the source, do not do
2388 if (src->xvec != dest->xvec)
2391 /* Copy the flags field. */
2394 if (APCS_SET (dest))
2396 /* If the src and dest have different APCS flag bits set, fail. */
2397 if (APCS_26_FLAG (dest) != APCS_26_FLAG (src))
2400 if (APCS_FLOAT_FLAG (dest) != APCS_FLOAT_FLAG (src))
2403 if (PIC_FLAG (dest) != PIC_FLAG (src))
2407 SET_APCS_FLAGS (dest, APCS_26_FLAG (src) | APCS_FLOAT_FLAG (src)
2411 if (INTERWORK_SET (src))
2413 if (INTERWORK_SET (dest))
2415 /* If the src and dest have different interworking flags then turn
2416 off the interworking bit. */
2417 if (INTERWORK_FLAG (dest) != INTERWORK_FLAG (src))
2419 if (INTERWORK_FLAG (dest))
2421 /* xgettext:c-format */
2422 _bfd_error_handler (_("\
2423 Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
2427 SET_INTERWORK_FLAG (dest, 0);
2432 SET_INTERWORK_FLAG (dest, INTERWORK_FLAG (src));
2439 /* Note: the definitions here of LOCAL_LABEL_PREFIX and USER_LABEL_PREIFX
2440 *must* match the definitions in gcc/config/arm/{coff|semi|aout}.h. */
2441 #ifndef LOCAL_LABEL_PREFIX
2442 #define LOCAL_LABEL_PREFIX ""
2444 #ifndef USER_LABEL_PREFIX
2445 #define USER_LABEL_PREFIX "_"
2448 /* Like _bfd_coff_is_local_label_name, but
2449 a) test against USER_LABEL_PREFIX, to avoid stripping labels known to be
2451 b) Allow other prefixes than ".", e.g. an empty prefix would cause all
2452 labels of the form Lxxx to be stripped. */
2455 coff_arm_is_local_label_name (bfd * abfd ATTRIBUTE_UNUSED,
2458 #ifdef USER_LABEL_PREFIX
2459 if (USER_LABEL_PREFIX[0] != 0)
2461 size_t len = strlen (USER_LABEL_PREFIX);
2463 if (strncmp (name, USER_LABEL_PREFIX, len) == 0)
2468 #ifdef LOCAL_LABEL_PREFIX
2469 /* If there is a prefix for local labels then look for this.
2470 If the prefix exists, but it is empty, then ignore the test. */
2472 if (LOCAL_LABEL_PREFIX[0] != 0)
2474 size_t len = strlen (LOCAL_LABEL_PREFIX);
2476 if (strncmp (name, LOCAL_LABEL_PREFIX, len) != 0)
2479 /* Perform the checks below for the rest of the name. */
2484 return name[0] == 'L';
2487 /* This piece of machinery exists only to guarantee that the bfd that holds
2488 the glue section is written last.
2490 This does depend on bfd_make_section attaching a new section to the
2491 end of the section list for the bfd. */
2494 coff_arm_link_output_has_begun (bfd * sub, struct coff_final_link_info * info)
2496 return (sub->output_has_begun
2497 || sub == coff_arm_hash_table (info->info)->bfd_of_glue_owner);
2501 coff_arm_final_link_postscript (bfd * abfd ATTRIBUTE_UNUSED,
2502 struct coff_final_link_info * pfinfo)
2504 struct coff_arm_link_hash_table * globals;
2506 globals = coff_arm_hash_table (pfinfo->info);
2508 BFD_ASSERT (globals != NULL);
2510 if (globals->bfd_of_glue_owner != NULL)
2512 if (! _bfd_coff_link_input_bfd (pfinfo, globals->bfd_of_glue_owner))
2515 globals->bfd_of_glue_owner->output_has_begun = TRUE;
2518 return bfd_arm_update_notes (abfd, ARM_NOTE_SECTION);
2521 #ifndef bfd_pe_print_pdata
2522 #define bfd_pe_print_pdata NULL
2525 #include "coffcode.h"
2527 #ifndef TARGET_LITTLE_SYM
2528 #define TARGET_LITTLE_SYM arm_coff_le_vec
2530 #ifndef TARGET_LITTLE_NAME
2531 #define TARGET_LITTLE_NAME "coff-arm-little"
2533 #ifndef TARGET_BIG_SYM
2534 #define TARGET_BIG_SYM arm_coff_be_vec
2536 #ifndef TARGET_BIG_NAME
2537 #define TARGET_BIG_NAME "coff-arm-big"
2540 #ifndef TARGET_UNDERSCORE
2541 #define TARGET_UNDERSCORE 0
2544 #ifndef EXTRA_S_FLAGS
2546 #define EXTRA_S_FLAGS (SEC_CODE | SEC_LINK_ONCE | SEC_LINK_DUPLICATES)
2548 #define EXTRA_S_FLAGS SEC_CODE
2552 /* Forward declaration for use initialising alternative_target field. */
2553 extern const bfd_target TARGET_BIG_SYM ;
2555 /* Target vectors. */
2556 CREATE_LITTLE_COFF_TARGET_VEC (TARGET_LITTLE_SYM, TARGET_LITTLE_NAME, D_PAGED, EXTRA_S_FLAGS, TARGET_UNDERSCORE, & TARGET_BIG_SYM, COFF_SWAP_TABLE)
2557 CREATE_BIG_COFF_TARGET_VEC (TARGET_BIG_SYM, TARGET_BIG_NAME, D_PAGED, EXTRA_S_FLAGS, TARGET_UNDERSCORE, & TARGET_LITTLE_SYM, COFF_SWAP_TABLE)