1 /* BFD back-end for ARM COFF files.
2 Copyright (C) 1990-2019 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"
36 /* Macros for manipulation the bits in the flags field of the coff data
38 #define APCS_26_FLAG(abfd) \
39 (coff_data (abfd)->flags & F_APCS_26)
41 #define APCS_FLOAT_FLAG(abfd) \
42 (coff_data (abfd)->flags & F_APCS_FLOAT)
44 #define PIC_FLAG(abfd) \
45 (coff_data (abfd)->flags & F_PIC)
47 #define APCS_SET(abfd) \
48 (coff_data (abfd)->flags & F_APCS_SET)
50 #define SET_APCS_FLAGS(abfd, flgs) \
53 coff_data (abfd)->flags &= ~(F_APCS_26 | F_APCS_FLOAT | F_PIC); \
54 coff_data (abfd)->flags |= (flgs) | F_APCS_SET; \
58 #define INTERWORK_FLAG(abfd) \
59 (coff_data (abfd)->flags & F_INTERWORK)
61 #define INTERWORK_SET(abfd) \
62 (coff_data (abfd)->flags & F_INTERWORK_SET)
64 #define SET_INTERWORK_FLAG(abfd, flg) \
67 coff_data (abfd)->flags &= ~F_INTERWORK; \
68 coff_data (abfd)->flags |= (flg) | F_INTERWORK_SET; \
73 #define NUM_ELEM(a) ((sizeof (a)) / sizeof ((a)[0]))
76 typedef enum {bunknown
, b9
, b12
, b23
} thumb_pcrel_branchtype
;
77 /* Some typedefs for holding instructions. */
78 typedef unsigned long int insn32
;
79 typedef unsigned short int insn16
;
81 /* The linker script knows the section names for placement.
82 The entry_names are used to do simple name mangling on the stubs.
83 Given a function name, and its type, the stub can be found. The
84 name can be changed. The only requirement is the %s be present. */
86 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
87 #define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
89 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
90 #define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
92 /* Used by the assembler. */
94 static bfd_reloc_status_type
95 coff_arm_reloc (bfd
*abfd
,
97 asymbol
*symbol ATTRIBUTE_UNUSED
,
99 asection
*input_section ATTRIBUTE_UNUSED
,
101 char **error_message ATTRIBUTE_UNUSED
)
105 if (output_bfd
== NULL
)
106 return bfd_reloc_continue
;
108 diff
= reloc_entry
->addend
;
111 x = ((x & ~howto->dst_mask) \
112 | (((x & howto->src_mask) + diff) & howto->dst_mask))
116 reloc_howto_type
*howto
= reloc_entry
->howto
;
117 unsigned char *addr
= (unsigned char *) data
+ reloc_entry
->address
;
119 if (! bfd_reloc_offset_in_range (howto
, abfd
, input_section
,
121 * bfd_octets_per_byte (abfd
)))
122 return bfd_reloc_outofrange
;
128 char x
= bfd_get_8 (abfd
, addr
);
130 bfd_put_8 (abfd
, x
, addr
);
136 short x
= bfd_get_16 (abfd
, addr
);
138 bfd_put_16 (abfd
, (bfd_vma
) x
, addr
);
144 long x
= bfd_get_32 (abfd
, addr
);
146 bfd_put_32 (abfd
, (bfd_vma
) x
, addr
);
155 /* Now let bfd_perform_relocation finish everything up. */
156 return bfd_reloc_continue
;
159 /* If USER_LABEL_PREFIX is defined as "_" (see coff_arm_is_local_label_name()
160 in this file), then TARGET_UNDERSCORE should be defined, otherwise it
162 #ifndef TARGET_UNDERSCORE
163 #define TARGET_UNDERSCORE '_'
167 #define PCRELOFFSET TRUE
170 /* These most certainly belong somewhere else. Just had to get rid of
171 the manifest constants in the code. */
179 #define ARM_THUMB12 4
180 #define ARM_SECTION 14
181 #define ARM_SECREL 15
197 #define ARM_THUMB9 12
198 #define ARM_THUMB12 13
199 #define ARM_THUMB23 14
203 static bfd_reloc_status_type aoutarm_fix_pcrel_26_done
204 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
205 static bfd_reloc_status_type aoutarm_fix_pcrel_26
206 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
207 static bfd_reloc_status_type coff_thumb_pcrel_12
208 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
210 static bfd_reloc_status_type coff_thumb_pcrel_9
211 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
212 static bfd_reloc_status_type coff_thumb_pcrel_23
213 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
216 static reloc_howto_type aoutarm_std_reloc_howto
[] =
225 complain_overflow_dont
,
226 aoutarm_fix_pcrel_26_done
,
228 TRUE
, /* partial_inplace. */
238 complain_overflow_bitfield
,
241 TRUE
, /* partial_inplace. */
251 complain_overflow_bitfield
,
254 TRUE
, /* partial_inplace. */
264 complain_overflow_signed
,
265 aoutarm_fix_pcrel_26
,
277 complain_overflow_signed
,
278 coff_thumb_pcrel_12
,
299 complain_overflow_bitfield
,
302 TRUE
, /* partial_inplace. */
312 complain_overflow_bitfield
,
315 TRUE
, /* partial_inplace. */
319 #else /* not ARM_WINCE */
326 complain_overflow_bitfield
,
339 complain_overflow_bitfield
,
352 complain_overflow_bitfield
,
365 complain_overflow_signed
,
366 aoutarm_fix_pcrel_26
,
378 complain_overflow_signed
,
391 complain_overflow_signed
,
404 complain_overflow_signed
,
417 complain_overflow_dont
,
418 aoutarm_fix_pcrel_26_done
,
432 complain_overflow_bitfield
,
445 complain_overflow_bitfield
,
458 complain_overflow_bitfield
,
471 complain_overflow_signed
,
484 complain_overflow_signed
,
485 coff_thumb_pcrel_12
,
497 complain_overflow_signed
,
498 coff_thumb_pcrel_23
,
504 #endif /* not ARM_WINCE */
507 #define NUM_RELOCS NUM_ELEM (aoutarm_std_reloc_howto)
510 /* Return TRUE if this relocation should
511 appear in the output .reloc section. */
514 in_reloc_p (bfd
* abfd ATTRIBUTE_UNUSED
,
515 reloc_howto_type
* howto
)
517 return !howto
->pc_relative
&& howto
->type
!= ARM_RVA32
;
521 #define RTYPE2HOWTO(cache_ptr, dst) \
522 (cache_ptr)->howto = \
523 (dst)->r_type < NUM_RELOCS \
524 ? aoutarm_std_reloc_howto + (dst)->r_type \
527 #define coff_rtype_to_howto coff_arm_rtype_to_howto
529 static reloc_howto_type
*
530 coff_arm_rtype_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
532 struct internal_reloc
*rel
,
533 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
,
534 struct internal_syment
*sym ATTRIBUTE_UNUSED
,
537 reloc_howto_type
* howto
;
539 if (rel
->r_type
>= NUM_RELOCS
)
542 howto
= aoutarm_std_reloc_howto
+ rel
->r_type
;
544 if (rel
->r_type
== ARM_RVA32
)
545 *addendp
-= pe_data (sec
->output_section
->owner
)->pe_opthdr
.ImageBase
;
547 #if defined COFF_WITH_PE && defined ARM_WINCE
548 if (rel
->r_type
== ARM_SECREL
)
552 if (h
&& (h
->type
== bfd_link_hash_defined
553 || h
->type
== bfd_link_hash_defweak
))
554 osect_vma
= h
->root
.u
.def
.section
->output_section
->vma
;
559 /* Sigh, the only way to get the section to offset against
560 is to find it the hard way. */
562 for (sec
= abfd
->sections
, i
= 1; i
< sym
->n_scnum
; i
++)
565 osect_vma
= sec
->output_section
->vma
;
568 *addendp
-= osect_vma
;
575 /* Used by the assembler. */
577 static bfd_reloc_status_type
578 aoutarm_fix_pcrel_26_done (bfd
*abfd ATTRIBUTE_UNUSED
,
579 arelent
*reloc_entry ATTRIBUTE_UNUSED
,
580 asymbol
*symbol ATTRIBUTE_UNUSED
,
581 void * data ATTRIBUTE_UNUSED
,
582 asection
*input_section ATTRIBUTE_UNUSED
,
583 bfd
*output_bfd ATTRIBUTE_UNUSED
,
584 char **error_message ATTRIBUTE_UNUSED
)
586 /* This is dead simple at present. */
590 /* Used by the assembler. */
592 static bfd_reloc_status_type
593 aoutarm_fix_pcrel_26 (bfd
*abfd
,
594 arelent
*reloc_entry
,
597 asection
*input_section
,
599 char **error_message ATTRIBUTE_UNUSED
)
602 bfd_size_type addr
= reloc_entry
->address
;
603 long target
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ addr
);
604 bfd_reloc_status_type flag
= bfd_reloc_ok
;
606 /* If this is an undefined symbol, return error. */
607 if (bfd_is_und_section (symbol
->section
)
608 && (symbol
->flags
& BSF_WEAK
) == 0)
609 return output_bfd
? bfd_reloc_continue
: bfd_reloc_undefined
;
611 /* If the sections are different, and we are doing a partial relocation,
612 just ignore it for now. */
613 if (symbol
->section
->name
!= input_section
->name
614 && output_bfd
!= (bfd
*)NULL
)
615 return bfd_reloc_continue
;
617 relocation
= (target
& 0x00ffffff) << 2;
618 relocation
= (relocation
^ 0x02000000) - 0x02000000; /* Sign extend. */
619 relocation
+= symbol
->value
;
620 relocation
+= symbol
->section
->output_section
->vma
;
621 relocation
+= symbol
->section
->output_offset
;
622 relocation
+= reloc_entry
->addend
;
623 relocation
-= input_section
->output_section
->vma
;
624 relocation
-= input_section
->output_offset
;
628 return bfd_reloc_overflow
;
630 /* Check for overflow. */
631 if (relocation
& 0x02000000)
633 if ((relocation
& ~ (bfd_vma
) 0x03ffffff) != ~ (bfd_vma
) 0x03ffffff)
634 flag
= bfd_reloc_overflow
;
636 else if (relocation
& ~(bfd_vma
) 0x03ffffff)
637 flag
= bfd_reloc_overflow
;
639 target
&= ~0x00ffffff;
640 target
|= (relocation
>> 2) & 0x00ffffff;
641 bfd_put_32 (abfd
, (bfd_vma
) target
, (bfd_byte
*) data
+ addr
);
643 /* Now the ARM magic... Change the reloc type so that it is marked as done.
644 Strictly this is only necessary if we are doing a partial relocation. */
645 reloc_entry
->howto
= &aoutarm_std_reloc_howto
[ARM_26D
];
650 static bfd_reloc_status_type
651 coff_thumb_pcrel_common (bfd
*abfd
,
652 arelent
*reloc_entry
,
655 asection
*input_section
,
657 char **error_message ATTRIBUTE_UNUSED
,
658 thumb_pcrel_branchtype btype
)
660 bfd_vma relocation
= 0;
661 bfd_size_type addr
= reloc_entry
->address
;
662 long target
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ addr
);
663 bfd_reloc_status_type flag
= bfd_reloc_ok
;
668 /* NOTE: This routine is currently used by GAS, but not by the link
675 signbit
= 0x00000100;
681 signbit
= 0x00000800;
687 signbit
= 0x00400000;
694 /* If this is an undefined symbol, return error. */
695 if (bfd_is_und_section (symbol
->section
)
696 && (symbol
->flags
& BSF_WEAK
) == 0)
697 return output_bfd
? bfd_reloc_continue
: bfd_reloc_undefined
;
699 /* If the sections are different, and we are doing a partial relocation,
700 just ignore it for now. */
701 if (symbol
->section
->name
!= input_section
->name
702 && output_bfd
!= (bfd
*)NULL
)
703 return bfd_reloc_continue
;
709 relocation
= ((target
& dstmsk
) << 1);
713 if (bfd_big_endian (abfd
))
714 relocation
= ((target
& 0x7ff) << 1) | ((target
& 0x07ff0000) >> 4);
716 relocation
= ((target
& 0x7ff) << 12) | ((target
& 0x07ff0000) >> 15);
723 relocation
= (relocation
^ signbit
) - signbit
; /* Sign extend. */
724 relocation
+= symbol
->value
;
725 relocation
+= symbol
->section
->output_section
->vma
;
726 relocation
+= symbol
->section
->output_offset
;
727 relocation
+= reloc_entry
->addend
;
728 relocation
-= input_section
->output_section
->vma
;
729 relocation
-= input_section
->output_offset
;
733 return bfd_reloc_overflow
;
735 /* Check for overflow. */
736 if (relocation
& signbit
)
738 if ((relocation
& ~offmsk
) != ~offmsk
)
739 flag
= bfd_reloc_overflow
;
741 else if (relocation
& ~offmsk
)
742 flag
= bfd_reloc_overflow
;
749 target
|= (relocation
>> 1);
753 if (bfd_big_endian (abfd
))
754 target
|= (((relocation
& 0xfff) >> 1)
755 | ((relocation
<< 4) & 0x07ff0000));
757 target
|= (((relocation
& 0xffe) << 15)
758 | ((relocation
>> 12) & 0x7ff));
765 bfd_put_32 (abfd
, (bfd_vma
) target
, (bfd_byte
*) data
+ addr
);
767 /* Now the ARM magic... Change the reloc type so that it is marked as done.
768 Strictly this is only necessary if we are doing a partial relocation. */
769 reloc_entry
->howto
= & aoutarm_std_reloc_howto
[ARM_26D
];
771 /* TODO: We should possibly have DONE entries for the THUMB PCREL relocations. */
776 static bfd_reloc_status_type
777 coff_thumb_pcrel_23 (bfd
*abfd
,
778 arelent
*reloc_entry
,
781 asection
*input_section
,
783 char **error_message
)
785 return coff_thumb_pcrel_common (abfd
, reloc_entry
, symbol
, data
,
786 input_section
, output_bfd
, error_message
,
790 static bfd_reloc_status_type
791 coff_thumb_pcrel_9 (bfd
*abfd
,
792 arelent
*reloc_entry
,
795 asection
*input_section
,
797 char **error_message
)
799 return coff_thumb_pcrel_common (abfd
, reloc_entry
, symbol
, data
,
800 input_section
, output_bfd
, error_message
,
803 #endif /* not ARM_WINCE */
805 static bfd_reloc_status_type
806 coff_thumb_pcrel_12 (bfd
*abfd
,
807 arelent
*reloc_entry
,
810 asection
*input_section
,
812 char **error_message
)
814 return coff_thumb_pcrel_common (abfd
, reloc_entry
, symbol
, data
,
815 input_section
, output_bfd
, error_message
,
819 static reloc_howto_type
*
820 coff_arm_reloc_type_lookup (bfd
* abfd
, bfd_reloc_code_real_type code
)
822 #define ASTD(i,j) case i: return aoutarm_std_reloc_howto + j
824 if (code
== BFD_RELOC_CTOR
)
825 switch (bfd_arch_bits_per_address (abfd
))
837 ASTD (BFD_RELOC_32
, ARM_32
);
838 ASTD (BFD_RELOC_RVA
, ARM_RVA32
);
839 ASTD (BFD_RELOC_ARM_PCREL_BRANCH
, ARM_26
);
840 ASTD (BFD_RELOC_THUMB_PCREL_BRANCH12
, ARM_THUMB12
);
841 ASTD (BFD_RELOC_32_SECREL
, ARM_SECREL
);
843 ASTD (BFD_RELOC_8
, ARM_8
);
844 ASTD (BFD_RELOC_16
, ARM_16
);
845 ASTD (BFD_RELOC_32
, ARM_32
);
846 ASTD (BFD_RELOC_ARM_PCREL_BRANCH
, ARM_26
);
847 ASTD (BFD_RELOC_ARM_PCREL_BLX
, ARM_26
);
848 ASTD (BFD_RELOC_8_PCREL
, ARM_DISP8
);
849 ASTD (BFD_RELOC_16_PCREL
, ARM_DISP16
);
850 ASTD (BFD_RELOC_32_PCREL
, ARM_DISP32
);
851 ASTD (BFD_RELOC_RVA
, ARM_RVA32
);
852 ASTD (BFD_RELOC_THUMB_PCREL_BRANCH9
, ARM_THUMB9
);
853 ASTD (BFD_RELOC_THUMB_PCREL_BRANCH12
, ARM_THUMB12
);
854 ASTD (BFD_RELOC_THUMB_PCREL_BRANCH23
, ARM_THUMB23
);
855 ASTD (BFD_RELOC_THUMB_PCREL_BLX
, ARM_THUMB23
);
857 default: return NULL
;
861 static reloc_howto_type
*
862 coff_arm_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
868 i
< (sizeof (aoutarm_std_reloc_howto
)
869 / sizeof (aoutarm_std_reloc_howto
[0]));
871 if (aoutarm_std_reloc_howto
[i
].name
!= NULL
872 && strcasecmp (aoutarm_std_reloc_howto
[i
].name
, r_name
) == 0)
873 return &aoutarm_std_reloc_howto
[i
];
878 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER 2
879 #define COFF_PAGE_SIZE 0x1000
881 /* Turn a howto into a reloc nunmber. */
882 #define SELECT_RELOC(x,howto) { x.r_type = howto->type; }
883 #define BADMAG(x) ARMBADMAG(x)
884 #define ARM 1 /* Customize coffcode.h. */
887 /* Make sure that the 'r_offset' field is copied properly
888 so that identical binaries will compare the same. */
889 #define SWAP_IN_RELOC_OFFSET H_GET_32
890 #define SWAP_OUT_RELOC_OFFSET H_PUT_32
893 /* Extend the coff_link_hash_table structure with a few ARM specific fields.
894 This allows us to store global data here without actually creating any
895 global variables, which is a no-no in the BFD world. */
896 struct coff_arm_link_hash_table
898 /* The original coff_link_hash_table structure. MUST be first field. */
899 struct coff_link_hash_table root
;
901 /* The size in bytes of the section containing the Thumb-to-ARM glue. */
902 bfd_size_type thumb_glue_size
;
904 /* The size in bytes of the section containing the ARM-to-Thumb glue. */
905 bfd_size_type arm_glue_size
;
907 /* An arbitrary input BFD chosen to hold the glue sections. */
908 bfd
* bfd_of_glue_owner
;
910 /* Support interworking with old, non-interworking aware ARM code. */
911 int support_old_code
;
914 /* Get the ARM coff linker hash table from a link_info structure. */
915 #define coff_arm_hash_table(info) \
916 ((struct coff_arm_link_hash_table *) ((info)->hash))
918 /* Create an ARM coff linker hash table. */
920 static struct bfd_link_hash_table
*
921 coff_arm_link_hash_table_create (bfd
* abfd
)
923 struct coff_arm_link_hash_table
* ret
;
924 bfd_size_type amt
= sizeof (struct coff_arm_link_hash_table
);
926 ret
= bfd_zmalloc (amt
);
930 if (!_bfd_coff_link_hash_table_init (&ret
->root
,
932 _bfd_coff_link_hash_newfunc
,
933 sizeof (struct coff_link_hash_entry
)))
939 return & ret
->root
.root
;
943 arm_emit_base_file_entry (struct bfd_link_info
*info
,
945 asection
*input_section
,
946 bfd_vma reloc_offset
)
948 bfd_vma addr
= (reloc_offset
950 + input_section
->output_offset
951 + input_section
->output_section
->vma
);
953 if (coff_data (output_bfd
)->pe
)
954 addr
-= pe_data (output_bfd
)->pe_opthdr
.ImageBase
;
955 if (fwrite (&addr
, sizeof (addr
), 1, (FILE *) info
->base_file
) == 1)
958 bfd_set_error (bfd_error_system_call
);
963 /* The thumb form of a long branch is a bit finicky, because the offset
964 encoding is split over two fields, each in it's own instruction. They
965 can occur in any order. So given a thumb form of long branch, and an
966 offset, insert the offset into the thumb branch and return finished
969 It takes two thumb instructions to encode the target address. Each has
970 11 bits to invest. The upper 11 bits are stored in one (identified by
971 H-0.. see below), the lower 11 bits are stored in the other (identified
974 Combine together and shifted left by 1 (it's a half word address) and
978 H-0, upper address-0 = 000
980 H-1, lower address-0 = 800
982 They can be ordered either way, but the arm tools I've seen always put
983 the lower one first. It probably doesn't matter. krk@cygnus.com
985 XXX: Actually the order does matter. The second instruction (H-1)
986 moves the computed address into the PC, so it must be the second one
987 in the sequence. The problem, however is that whilst little endian code
988 stores the instructions in HI then LOW order, big endian code does the
989 reverse. nickc@cygnus.com. */
991 #define LOW_HI_ORDER 0xF800F000
992 #define HI_LOW_ORDER 0xF000F800
995 insert_thumb_branch (insn32 br_insn
, int rel_off
)
997 unsigned int low_bits
;
998 unsigned int high_bits
;
1000 BFD_ASSERT ((rel_off
& 1) != 1);
1002 rel_off
>>= 1; /* Half word aligned address. */
1003 low_bits
= rel_off
& 0x000007FF; /* The bottom 11 bits. */
1004 high_bits
= (rel_off
>> 11) & 0x000007FF; /* The top 11 bits. */
1006 if ((br_insn
& LOW_HI_ORDER
) == LOW_HI_ORDER
)
1007 br_insn
= LOW_HI_ORDER
| (low_bits
<< 16) | high_bits
;
1008 else if ((br_insn
& HI_LOW_ORDER
) == HI_LOW_ORDER
)
1009 br_insn
= HI_LOW_ORDER
| (high_bits
<< 16) | low_bits
;
1011 /* FIXME: the BFD library should never abort except for internal errors
1012 - it should return an error status. */
1013 abort (); /* Error - not a valid branch instruction form. */
1019 static struct coff_link_hash_entry
*
1020 find_thumb_glue (struct bfd_link_info
*info
,
1025 struct coff_link_hash_entry
*myh
;
1026 bfd_size_type amt
= strlen (name
) + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1;
1028 tmp_name
= bfd_malloc (amt
);
1030 BFD_ASSERT (tmp_name
);
1032 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
1034 myh
= coff_link_hash_lookup
1035 (coff_hash_table (info
), tmp_name
, FALSE
, FALSE
, TRUE
);
1038 /* xgettext:c-format */
1039 _bfd_error_handler (_("%pB: unable to find THUMB glue '%s' for `%s'"),
1040 input_bfd
, tmp_name
, name
);
1046 #endif /* not ARM_WINCE */
1048 static struct coff_link_hash_entry
*
1049 find_arm_glue (struct bfd_link_info
*info
,
1054 struct coff_link_hash_entry
* myh
;
1055 bfd_size_type amt
= strlen (name
) + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1;
1057 tmp_name
= bfd_malloc (amt
);
1059 BFD_ASSERT (tmp_name
);
1061 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
1063 myh
= coff_link_hash_lookup
1064 (coff_hash_table (info
), tmp_name
, FALSE
, FALSE
, TRUE
);
1067 /* xgettext:c-format */
1068 _bfd_error_handler (_("%pB: unable to find ARM glue '%s' for `%s'"),
1069 input_bfd
, tmp_name
, name
);
1081 ldr r12, __func_addr
1084 .word func @ behave as if you saw a ARM_32 reloc
1087 #define ARM2THUMB_GLUE_SIZE 12
1088 static const insn32 a2t1_ldr_insn
= 0xe59fc000;
1089 static const insn32 a2t2_bx_r12_insn
= 0xe12fff1c;
1090 static const insn32 a2t3_func_addr_insn
= 0x00000001;
1093 Thumb->ARM: Thumb->(non-interworking aware) ARM
1097 __func_from_thumb: __func_from_thumb:
1099 nop ldr r6, __func_addr
1101 __func_change_to_arm: bx r6
1103 __func_back_to_thumb:
1110 #define THUMB2ARM_GLUE_SIZE (globals->support_old_code ? 20 : 8)
1112 static const insn16 t2a1_bx_pc_insn
= 0x4778;
1113 static const insn16 t2a2_noop_insn
= 0x46c0;
1114 static const insn32 t2a3_b_insn
= 0xea000000;
1116 static const insn16 t2a1_push_insn
= 0xb540;
1117 static const insn16 t2a2_ldr_insn
= 0x4e03;
1118 static const insn16 t2a3_mov_insn
= 0x46fe;
1119 static const insn16 t2a4_bx_insn
= 0x4730;
1120 static const insn32 t2a5_pop_insn
= 0xe8bd4040;
1121 static const insn32 t2a6_bx_insn
= 0xe12fff1e;
1125 We should really create new local (static) symbols in destination
1126 object for each stub we create. We should also create local
1127 (static) symbols within the stubs when switching between ARM and
1128 Thumb code. This will ensure that the debugger and disassembler
1129 can present a better view of stubs.
1131 We can treat stubs like literal sections, and for the THUMB9 ones
1132 (short addressing range) we should be able to insert the stubs
1133 between sections. i.e. the simplest approach (since relocations
1134 are done on a section basis) is to dump the stubs at the end of
1135 processing a section. That way we can always try and minimise the
1136 offset to and from a stub. However, this does not map well onto
1137 the way that the linker/BFD does its work: mapping all input
1138 sections to output sections via the linker script before doing
1141 Unfortunately it may be easier to just to disallow short range
1142 Thumb->ARM stubs (i.e. no conditional inter-working branches,
1143 only branch-and-link (BL) calls. This will simplify the processing
1144 since we can then put all of the stubs into their own section.
1147 On a different subject, rather than complaining when a
1148 branch cannot fit in the number of bits available for the
1149 instruction we should generate a trampoline stub (needed to
1150 address the complete 32bit address space). */
1152 /* The standard COFF backend linker does not cope with the special
1153 Thumb BRANCH23 relocation. The alternative would be to split the
1154 BRANCH23 into seperate HI23 and LO23 relocations. However, it is a
1155 bit simpler simply providing our own relocation driver. */
1157 /* The reloc processing routine for the ARM/Thumb COFF linker. NOTE:
1158 This code is a very slightly modified copy of
1159 _bfd_coff_generic_relocate_section. It would be a much more
1160 maintainable solution to have a MACRO that could be expanded within
1161 _bfd_coff_generic_relocate_section that would only be provided for
1162 ARM/Thumb builds. It is only the code marked THUMBEXTENSION that
1163 is different from the original. */
1166 coff_arm_relocate_section (bfd
*output_bfd
,
1167 struct bfd_link_info
*info
,
1169 asection
*input_section
,
1171 struct internal_reloc
*relocs
,
1172 struct internal_syment
*syms
,
1173 asection
**sections
)
1175 struct internal_reloc
* rel
;
1176 struct internal_reloc
* relend
;
1178 bfd_vma high_address
= bfd_get_section_limit (input_bfd
, input_section
);
1182 relend
= rel
+ input_section
->reloc_count
;
1184 for (; rel
< relend
; rel
++)
1188 struct coff_link_hash_entry
* h
;
1189 struct internal_syment
* sym
;
1192 reloc_howto_type
* howto
;
1193 bfd_reloc_status_type rstat
;
1196 symndx
= rel
->r_symndx
;
1205 h
= obj_coff_sym_hashes (input_bfd
)[symndx
];
1206 sym
= syms
+ symndx
;
1209 /* COFF treats common symbols in one of two ways. Either the
1210 size of the symbol is included in the section contents, or it
1211 is not. We assume that the size is not included, and force
1212 the rtype_to_howto function to adjust the addend as needed. */
1214 if (sym
!= NULL
&& sym
->n_scnum
!= 0)
1215 addend
= - sym
->n_value
;
1219 howto
= coff_rtype_to_howto (input_bfd
, input_section
, rel
, h
,
1224 /* The relocation_section function will skip pcrel_offset relocs
1225 when doing a relocatable link. However, we want to convert
1226 ARM_26 to ARM_26D relocs if possible. We return a fake howto in
1227 this case without pcrel_offset set, and adjust the addend to
1228 compensate. 'partial_inplace' is also set, since we want 'done'
1229 relocations to be reflected in section's data. */
1230 if (rel
->r_type
== ARM_26
1232 && bfd_link_relocatable (info
)
1233 && (h
->root
.type
== bfd_link_hash_defined
1234 || h
->root
.type
== bfd_link_hash_defweak
)
1235 && (h
->root
.u
.def
.section
->output_section
1236 == input_section
->output_section
))
1238 static reloc_howto_type fake_arm26_reloc
=
1245 complain_overflow_signed
,
1246 aoutarm_fix_pcrel_26
,
1253 addend
-= rel
->r_vaddr
- input_section
->vma
;
1255 /* FIXME: I don't know why, but the hack is necessary for correct
1256 generation of bl's instruction offset. */
1259 howto
= & fake_arm26_reloc
;
1263 /* MS ARM-CE makes the reloc relative to the opcode's pc, not
1264 the next opcode's pc, so is off by one. */
1265 if (howto
->pc_relative
&& !bfd_link_relocatable (info
))
1269 /* If we are doing a relocatable link, then we can just ignore
1270 a PC relative reloc that is pcrel_offset. It will already
1271 have the correct value. If this is not a relocatable link,
1272 then we should ignore the symbol value. */
1273 if (howto
->pc_relative
&& howto
->pcrel_offset
)
1275 if (bfd_link_relocatable (info
))
1277 /* FIXME - it is not clear which targets need this next test
1278 and which do not. It is known that it is needed for the
1279 VxWorks targets but it is also known that it was suppressed
1280 for other ARM targets. This ought to be sorted out one day. */
1281 #ifdef ARM_COFF_BUGFIX
1282 /* We must not ignore the symbol value. If the symbol is
1283 within the same section, the relocation should have already
1284 been fixed, but if it is not, we'll be handed a reloc into
1285 the beginning of the symbol's section, so we must not cancel
1286 out the symbol's value, otherwise we'll be adding it in
1288 if (sym
!= NULL
&& sym
->n_scnum
!= 0)
1289 addend
+= sym
->n_value
;
1301 sec
= bfd_abs_section_ptr
;
1306 sec
= sections
[symndx
];
1307 val
= (sec
->output_section
->vma
1308 + sec
->output_offset
1315 /* We don't output the stubs if we are generating a
1316 relocatable output file, since we may as well leave the
1317 stub generation to the final linker pass. If we fail to
1318 verify that the name is defined, we'll try to build stubs
1319 for an undefined name... */
1320 if (! bfd_link_relocatable (info
)
1321 && ( h
->root
.type
== bfd_link_hash_defined
1322 || h
->root
.type
== bfd_link_hash_defweak
))
1324 asection
* h_sec
= h
->root
.u
.def
.section
;
1325 const char * name
= h
->root
.root
.string
;
1327 /* h locates the symbol referenced in the reloc. */
1328 h_val
= (h
->root
.u
.def
.value
1329 + h_sec
->output_section
->vma
1330 + h_sec
->output_offset
);
1332 if (howto
->type
== ARM_26
)
1334 if ( h
->symbol_class
== C_THUMBSTATFUNC
1335 || h
->symbol_class
== C_THUMBEXTFUNC
)
1337 /* Arm code calling a Thumb function. */
1338 unsigned long int tmp
;
1341 long int ret_offset
;
1342 struct coff_link_hash_entry
* myh
;
1343 struct coff_arm_link_hash_table
* globals
;
1345 myh
= find_arm_glue (info
, name
, input_bfd
);
1349 globals
= coff_arm_hash_table (info
);
1351 BFD_ASSERT (globals
!= NULL
);
1352 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
1354 my_offset
= myh
->root
.u
.def
.value
;
1356 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
1357 ARM2THUMB_GLUE_SECTION_NAME
);
1358 BFD_ASSERT (s
!= NULL
);
1359 BFD_ASSERT (s
->contents
!= NULL
);
1360 BFD_ASSERT (s
->output_section
!= NULL
);
1362 if ((my_offset
& 0x01) == 0x01)
1364 if (h_sec
->owner
!= NULL
1365 && INTERWORK_SET (h_sec
->owner
)
1366 && ! INTERWORK_FLAG (h_sec
->owner
))
1368 /* xgettext:c-format */
1369 (_("%pB(%s): warning: interworking not enabled; "
1370 "first occurrence: %pB: arm call to thumb"),
1371 h_sec
->owner
, name
, input_bfd
);
1374 myh
->root
.u
.def
.value
= my_offset
;
1376 bfd_put_32 (output_bfd
, (bfd_vma
) a2t1_ldr_insn
,
1377 s
->contents
+ my_offset
);
1379 bfd_put_32 (output_bfd
, (bfd_vma
) a2t2_bx_r12_insn
,
1380 s
->contents
+ my_offset
+ 4);
1382 /* It's a thumb address. Add the low order bit. */
1383 bfd_put_32 (output_bfd
, h_val
| a2t3_func_addr_insn
,
1384 s
->contents
+ my_offset
+ 8);
1387 && !arm_emit_base_file_entry (info
, output_bfd
,
1392 BFD_ASSERT (my_offset
<= globals
->arm_glue_size
);
1394 tmp
= bfd_get_32 (input_bfd
, contents
+ rel
->r_vaddr
1395 - input_section
->vma
);
1397 tmp
= tmp
& 0xFF000000;
1399 /* Somehow these are both 4 too far, so subtract 8. */
1403 + s
->output_section
->vma
1404 - (input_section
->output_offset
1405 + input_section
->output_section
->vma
1409 tmp
= tmp
| ((ret_offset
>> 2) & 0x00FFFFFF);
1411 bfd_put_32 (output_bfd
, (bfd_vma
) tmp
,
1412 contents
+ rel
->r_vaddr
- input_section
->vma
);
1418 /* Note: We used to check for ARM_THUMB9 and ARM_THUMB12. */
1419 else if (howto
->type
== ARM_THUMB23
)
1421 if ( h
->symbol_class
== C_EXT
1422 || h
->symbol_class
== C_STAT
1423 || h
->symbol_class
== C_LABEL
)
1425 /* Thumb code calling an ARM function. */
1428 unsigned long int tmp
;
1429 long int ret_offset
;
1430 struct coff_link_hash_entry
* myh
;
1431 struct coff_arm_link_hash_table
* globals
;
1433 myh
= find_thumb_glue (info
, name
, input_bfd
);
1437 globals
= coff_arm_hash_table (info
);
1439 BFD_ASSERT (globals
!= NULL
);
1440 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
1442 my_offset
= myh
->root
.u
.def
.value
;
1444 s
= bfd_get_section_by_name (globals
->bfd_of_glue_owner
,
1445 THUMB2ARM_GLUE_SECTION_NAME
);
1447 BFD_ASSERT (s
!= NULL
);
1448 BFD_ASSERT (s
->contents
!= NULL
);
1449 BFD_ASSERT (s
->output_section
!= NULL
);
1451 if ((my_offset
& 0x01) == 0x01)
1453 if (h_sec
->owner
!= NULL
1454 && INTERWORK_SET (h_sec
->owner
)
1455 && ! INTERWORK_FLAG (h_sec
->owner
)
1456 && ! globals
->support_old_code
)
1458 /* xgettext:c-format */
1459 (_("%pB(%s): warning: interworking not enabled; "
1460 "first occurrence: %pB: thumb call to arm; "
1461 "consider relinking with --support-old-code "
1463 h_sec
->owner
, name
, input_bfd
);
1466 myh
->root
.u
.def
.value
= my_offset
;
1468 if (globals
->support_old_code
)
1470 bfd_put_16 (output_bfd
, (bfd_vma
) t2a1_push_insn
,
1471 s
->contents
+ my_offset
);
1473 bfd_put_16 (output_bfd
, (bfd_vma
) t2a2_ldr_insn
,
1474 s
->contents
+ my_offset
+ 2);
1476 bfd_put_16 (output_bfd
, (bfd_vma
) t2a3_mov_insn
,
1477 s
->contents
+ my_offset
+ 4);
1479 bfd_put_16 (output_bfd
, (bfd_vma
) t2a4_bx_insn
,
1480 s
->contents
+ my_offset
+ 6);
1482 bfd_put_32 (output_bfd
, (bfd_vma
) t2a5_pop_insn
,
1483 s
->contents
+ my_offset
+ 8);
1485 bfd_put_32 (output_bfd
, (bfd_vma
) t2a6_bx_insn
,
1486 s
->contents
+ my_offset
+ 12);
1488 /* Store the address of the function in the last word of the stub. */
1489 bfd_put_32 (output_bfd
, h_val
,
1490 s
->contents
+ my_offset
+ 16);
1493 && !arm_emit_base_file_entry (info
,
1500 bfd_put_16 (output_bfd
, (bfd_vma
) t2a1_bx_pc_insn
,
1501 s
->contents
+ my_offset
);
1503 bfd_put_16 (output_bfd
, (bfd_vma
) t2a2_noop_insn
,
1504 s
->contents
+ my_offset
+ 2);
1507 /* Address of destination of the stub. */
1508 ((bfd_signed_vma
) h_val
)
1510 /* Offset from the start of the current section to the start of the stubs. */
1512 /* Offset of the start of this stub from the start of the stubs. */
1514 /* Address of the start of the current section. */
1515 + s
->output_section
->vma
)
1516 /* The branch instruction is 4 bytes into the stub. */
1518 /* ARM branches work from the pc of the instruction + 8. */
1521 bfd_put_32 (output_bfd
,
1522 (bfd_vma
) t2a3_b_insn
| ((ret_offset
>> 2) & 0x00FFFFFF),
1523 s
->contents
+ my_offset
+ 4);
1528 BFD_ASSERT (my_offset
<= globals
->thumb_glue_size
);
1530 /* Now go back and fix up the original BL insn to point
1535 - (input_section
->output_offset
1539 tmp
= bfd_get_32 (input_bfd
, contents
+ rel
->r_vaddr
1540 - input_section
->vma
);
1542 bfd_put_32 (output_bfd
,
1543 (bfd_vma
) insert_thumb_branch (tmp
,
1545 contents
+ rel
->r_vaddr
- input_section
->vma
);
1553 /* If the relocation type and destination symbol does not
1554 fall into one of the above categories, then we can just
1555 perform a direct link. */
1558 rstat
= bfd_reloc_ok
;
1560 if ( h
->root
.type
== bfd_link_hash_defined
1561 || h
->root
.type
== bfd_link_hash_defweak
)
1565 sec
= h
->root
.u
.def
.section
;
1566 val
= (h
->root
.u
.def
.value
1567 + sec
->output_section
->vma
1568 + sec
->output_offset
);
1571 else if (! bfd_link_relocatable (info
))
1572 (*info
->callbacks
->undefined_symbol
)
1573 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1574 rel
->r_vaddr
- input_section
->vma
, TRUE
);
1577 /* Emit a reloc if the backend thinks it needs it. */
1580 && pe_data(output_bfd
)->in_reloc_p(output_bfd
, howto
)
1581 && !arm_emit_base_file_entry (info
, output_bfd
, input_section
,
1586 rstat
= bfd_reloc_ok
;
1588 /* Only perform this fix during the final link, not a relocatable link. */
1589 else if (! bfd_link_relocatable (info
)
1590 && howto
->type
== ARM_THUMB23
)
1592 /* This is pretty much a copy of what the default
1593 _bfd_final_link_relocate and _bfd_relocate_contents
1594 routines do to perform a relocation, with special
1595 processing for the split addressing of the Thumb BL
1596 instruction. Again, it would probably be simpler adding a
1597 ThumbBRANCH23 specific macro expansion into the default
1600 bfd_vma address
= rel
->r_vaddr
- input_section
->vma
;
1602 if (address
> high_address
)
1603 rstat
= bfd_reloc_outofrange
;
1606 bfd_vma relocation
= val
+ addend
;
1607 int size
= bfd_get_reloc_size (howto
);
1608 bfd_boolean overflow
= FALSE
;
1609 bfd_byte
*location
= contents
+ address
;
1610 bfd_vma x
= bfd_get_32 (input_bfd
, location
);
1611 bfd_vma src_mask
= 0x007FFFFE;
1612 bfd_signed_vma reloc_signed_max
= (1 << (howto
->bitsize
- 1)) - 1;
1613 bfd_signed_vma reloc_signed_min
= ~reloc_signed_max
;
1615 bfd_signed_vma signed_check
;
1617 bfd_signed_vma signed_add
;
1619 BFD_ASSERT (size
== 4);
1621 /* howto->pc_relative should be TRUE for type 14 BRANCH23. */
1622 relocation
-= (input_section
->output_section
->vma
1623 + input_section
->output_offset
);
1625 /* howto->pcrel_offset should be TRUE for type 14 BRANCH23. */
1626 relocation
-= address
;
1628 /* No need to negate the relocation with BRANCH23. */
1629 /* howto->complain_on_overflow == complain_overflow_signed for BRANCH23. */
1630 /* howto->rightshift == 1 */
1632 /* Drop unwanted bits from the value we are relocating to. */
1633 check
= relocation
>> howto
->rightshift
;
1635 /* If this is a signed value, the rightshift just dropped
1636 leading 1 bits (assuming twos complement). */
1637 if ((bfd_signed_vma
) relocation
>= 0)
1638 signed_check
= check
;
1640 signed_check
= (check
1642 & ~((bfd_vma
) - 1 >> howto
->rightshift
)));
1644 /* Get the value from the object file. */
1645 if (bfd_big_endian (input_bfd
))
1646 add
= (((x
) & 0x07ff0000) >> 4) | (((x
) & 0x7ff) << 1);
1648 add
= ((((x
) & 0x7ff) << 12) | (((x
) & 0x07ff0000) >> 15));
1650 /* Get the value from the object file with an appropriate sign.
1651 The expression involving howto->src_mask isolates the upper
1652 bit of src_mask. If that bit is set in the value we are
1653 adding, it is negative, and we subtract out that number times
1654 two. If src_mask includes the highest possible bit, then we
1655 can not get the upper bit, but that does not matter since
1656 signed_add needs no adjustment to become negative in that
1660 if ((add
& (((~ src_mask
) >> 1) & src_mask
)) != 0)
1661 signed_add
-= (((~ src_mask
) >> 1) & src_mask
) << 1;
1663 /* howto->bitpos == 0 */
1664 /* Add the value from the object file, shifted so that it is a
1666 signed_check
+= signed_add
;
1667 relocation
+= signed_add
;
1669 BFD_ASSERT (howto
->complain_on_overflow
== complain_overflow_signed
);
1671 /* Assumes two's complement. */
1672 if ( signed_check
> reloc_signed_max
1673 || signed_check
< reloc_signed_min
)
1676 /* Put the relocation into the correct bits.
1677 For a BLX instruction, make sure that the relocation is rounded up
1678 to a word boundary. This follows the semantics of the instruction
1679 which specifies that bit 1 of the target address will come from bit
1680 1 of the base address. */
1681 if (bfd_big_endian (input_bfd
))
1683 if ((x
& 0x1800) == 0x0800 && (relocation
& 0x02))
1685 relocation
= (((relocation
& 0xffe) >> 1) | ((relocation
<< 4) & 0x07ff0000));
1689 if ((x
& 0x18000000) == 0x08000000 && (relocation
& 0x02))
1691 relocation
= (((relocation
& 0xffe) << 15) | ((relocation
>> 12) & 0x7ff));
1694 /* Add the relocation to the correct bits of X. */
1695 x
= ((x
& ~howto
->dst_mask
) | relocation
);
1697 /* Put the relocated value back in the object file. */
1698 bfd_put_32 (input_bfd
, x
, location
);
1700 rstat
= overflow
? bfd_reloc_overflow
: bfd_reloc_ok
;
1705 if (bfd_link_relocatable (info
) && ! howto
->partial_inplace
)
1706 rstat
= bfd_reloc_ok
;
1708 rstat
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1710 rel
->r_vaddr
- input_section
->vma
,
1712 /* Only perform this fix during the final link, not a relocatable link. */
1713 if (! bfd_link_relocatable (info
)
1714 && (rel
->r_type
== ARM_32
|| rel
->r_type
== ARM_RVA32
))
1716 /* Determine if we need to set the bottom bit of a relocated address
1717 because the address is the address of a Thumb code symbol. */
1718 int patchit
= FALSE
;
1721 && ( h
->symbol_class
== C_THUMBSTATFUNC
1722 || h
->symbol_class
== C_THUMBEXTFUNC
))
1726 else if (sym
!= NULL
1727 && sym
->n_scnum
> N_UNDEF
)
1729 /* No hash entry - use the symbol instead. */
1730 if ( sym
->n_sclass
== C_THUMBSTATFUNC
1731 || sym
->n_sclass
== C_THUMBEXTFUNC
)
1737 bfd_byte
* location
= contents
+ rel
->r_vaddr
- input_section
->vma
;
1738 bfd_vma x
= bfd_get_32 (input_bfd
, location
);
1740 bfd_put_32 (input_bfd
, x
| 1, location
);
1750 case bfd_reloc_outofrange
:
1752 /* xgettext:c-format */
1753 (_("%pB: bad reloc address %#" PRIx64
" in section `%pA'"),
1754 input_bfd
, (uint64_t) rel
->r_vaddr
, input_section
);
1756 case bfd_reloc_overflow
:
1759 char buf
[SYMNMLEN
+ 1];
1767 name
= _bfd_coff_internal_syment_name (input_bfd
, sym
, buf
);
1772 (*info
->callbacks
->reloc_overflow
)
1773 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
1774 (bfd_vma
) 0, input_bfd
, input_section
,
1775 rel
->r_vaddr
- input_section
->vma
);
1783 #ifndef COFF_IMAGE_WITH_PE
1786 bfd_arm_allocate_interworking_sections (struct bfd_link_info
* info
)
1790 struct coff_arm_link_hash_table
* globals
;
1792 globals
= coff_arm_hash_table (info
);
1794 BFD_ASSERT (globals
!= NULL
);
1796 if (globals
->arm_glue_size
!= 0)
1798 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
1800 s
= bfd_get_section_by_name
1801 (globals
->bfd_of_glue_owner
, ARM2THUMB_GLUE_SECTION_NAME
);
1803 BFD_ASSERT (s
!= NULL
);
1805 foo
= bfd_alloc (globals
->bfd_of_glue_owner
, globals
->arm_glue_size
);
1807 s
->size
= globals
->arm_glue_size
;
1811 if (globals
->thumb_glue_size
!= 0)
1813 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
1815 s
= bfd_get_section_by_name
1816 (globals
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
1818 BFD_ASSERT (s
!= NULL
);
1820 foo
= bfd_alloc (globals
->bfd_of_glue_owner
, globals
->thumb_glue_size
);
1822 s
->size
= globals
->thumb_glue_size
;
1830 record_arm_to_thumb_glue (struct bfd_link_info
* info
,
1831 struct coff_link_hash_entry
* h
)
1833 const char * name
= h
->root
.root
.string
;
1834 register asection
* s
;
1836 struct coff_link_hash_entry
* myh
;
1837 struct bfd_link_hash_entry
* bh
;
1838 struct coff_arm_link_hash_table
* globals
;
1842 globals
= coff_arm_hash_table (info
);
1844 BFD_ASSERT (globals
!= NULL
);
1845 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
1847 s
= bfd_get_section_by_name
1848 (globals
->bfd_of_glue_owner
, ARM2THUMB_GLUE_SECTION_NAME
);
1850 BFD_ASSERT (s
!= NULL
);
1852 amt
= strlen (name
) + strlen (ARM2THUMB_GLUE_ENTRY_NAME
) + 1;
1853 tmp_name
= bfd_malloc (amt
);
1855 BFD_ASSERT (tmp_name
);
1857 sprintf (tmp_name
, ARM2THUMB_GLUE_ENTRY_NAME
, name
);
1859 myh
= coff_link_hash_lookup
1860 (coff_hash_table (info
), tmp_name
, FALSE
, FALSE
, TRUE
);
1865 /* We've already seen this guy. */
1869 /* The only trick here is using globals->arm_glue_size as the value. Even
1870 though the section isn't allocated yet, this is where we will be putting
1873 val
= globals
->arm_glue_size
+ 1;
1874 bfd_coff_link_add_one_symbol (info
, globals
->bfd_of_glue_owner
, tmp_name
,
1875 BSF_GLOBAL
, s
, val
, NULL
, TRUE
, FALSE
, &bh
);
1879 globals
->arm_glue_size
+= ARM2THUMB_GLUE_SIZE
;
1886 record_thumb_to_arm_glue (struct bfd_link_info
* info
,
1887 struct coff_link_hash_entry
* h
)
1889 const char * name
= h
->root
.root
.string
;
1892 struct coff_link_hash_entry
* myh
;
1893 struct bfd_link_hash_entry
* bh
;
1894 struct coff_arm_link_hash_table
* globals
;
1898 globals
= coff_arm_hash_table (info
);
1900 BFD_ASSERT (globals
!= NULL
);
1901 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
1903 s
= bfd_get_section_by_name
1904 (globals
->bfd_of_glue_owner
, THUMB2ARM_GLUE_SECTION_NAME
);
1906 BFD_ASSERT (s
!= NULL
);
1908 amt
= strlen (name
) + strlen (THUMB2ARM_GLUE_ENTRY_NAME
) + 1;
1909 tmp_name
= bfd_malloc (amt
);
1911 BFD_ASSERT (tmp_name
);
1913 sprintf (tmp_name
, THUMB2ARM_GLUE_ENTRY_NAME
, name
);
1915 myh
= coff_link_hash_lookup
1916 (coff_hash_table (info
), tmp_name
, FALSE
, FALSE
, TRUE
);
1921 /* We've already seen this guy. */
1926 val
= globals
->thumb_glue_size
+ 1;
1927 bfd_coff_link_add_one_symbol (info
, globals
->bfd_of_glue_owner
, tmp_name
,
1928 BSF_GLOBAL
, s
, val
, NULL
, TRUE
, FALSE
, &bh
);
1930 /* If we mark it 'thumb', the disassembler will do a better job. */
1931 myh
= (struct coff_link_hash_entry
*) bh
;
1932 myh
->symbol_class
= C_THUMBEXTFUNC
;
1936 /* Allocate another symbol to mark where we switch to arm mode. */
1938 #define CHANGE_TO_ARM "__%s_change_to_arm"
1939 #define BACK_FROM_ARM "__%s_back_from_arm"
1941 amt
= strlen (name
) + strlen (CHANGE_TO_ARM
) + 1;
1942 tmp_name
= bfd_malloc (amt
);
1944 BFD_ASSERT (tmp_name
);
1946 sprintf (tmp_name
, globals
->support_old_code
? BACK_FROM_ARM
: CHANGE_TO_ARM
, name
);
1949 val
= globals
->thumb_glue_size
+ (globals
->support_old_code
? 8 : 4);
1950 bfd_coff_link_add_one_symbol (info
, globals
->bfd_of_glue_owner
, tmp_name
,
1951 BSF_LOCAL
, s
, val
, NULL
, TRUE
, FALSE
, &bh
);
1955 globals
->thumb_glue_size
+= THUMB2ARM_GLUE_SIZE
;
1959 #endif /* not ARM_WINCE */
1961 /* Select a BFD to be used to hold the sections used by the glue code.
1962 This function is called from the linker scripts in ld/emultempl/
1966 bfd_arm_get_bfd_for_interworking (bfd
* abfd
,
1967 struct bfd_link_info
* info
)
1969 struct coff_arm_link_hash_table
* globals
;
1973 /* If we are only performing a partial link do not bother
1974 getting a bfd to hold the glue. */
1975 if (bfd_link_relocatable (info
))
1978 globals
= coff_arm_hash_table (info
);
1980 BFD_ASSERT (globals
!= NULL
);
1982 if (globals
->bfd_of_glue_owner
!= NULL
)
1985 sec
= bfd_get_section_by_name (abfd
, ARM2THUMB_GLUE_SECTION_NAME
);
1989 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1990 | SEC_CODE
| SEC_READONLY
);
1991 sec
= bfd_make_section_with_flags (abfd
, ARM2THUMB_GLUE_SECTION_NAME
,
1994 || !bfd_set_section_alignment (sec
, 2))
1998 sec
= bfd_get_section_by_name (abfd
, THUMB2ARM_GLUE_SECTION_NAME
);
2002 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2003 | SEC_CODE
| SEC_READONLY
);
2004 sec
= bfd_make_section_with_flags (abfd
, THUMB2ARM_GLUE_SECTION_NAME
,
2008 || !bfd_set_section_alignment (sec
, 2))
2012 /* Save the bfd for later use. */
2013 globals
->bfd_of_glue_owner
= abfd
;
2019 bfd_arm_process_before_allocation (bfd
* abfd
,
2020 struct bfd_link_info
* info
,
2021 int support_old_code
)
2024 struct coff_arm_link_hash_table
* globals
;
2026 /* If we are only performing a partial link do not bother
2027 to construct any glue. */
2028 if (bfd_link_relocatable (info
))
2031 /* Here we have a bfd that is to be included on the link. We have a hook
2032 to do reloc rummaging, before section sizes are nailed down. */
2033 _bfd_coff_get_external_symbols (abfd
);
2035 globals
= coff_arm_hash_table (info
);
2037 BFD_ASSERT (globals
!= NULL
);
2038 BFD_ASSERT (globals
->bfd_of_glue_owner
!= NULL
);
2040 globals
->support_old_code
= support_old_code
;
2042 /* Rummage around all the relocs and map the glue vectors. */
2043 sec
= abfd
->sections
;
2048 for (; sec
!= NULL
; sec
= sec
->next
)
2050 struct internal_reloc
* i
;
2051 struct internal_reloc
* rel
;
2053 if (sec
->reloc_count
== 0)
2056 /* Load the relocs. */
2057 /* FIXME: there may be a storage leak here. */
2058 i
= _bfd_coff_read_internal_relocs (abfd
, sec
, 1, 0, 0, 0);
2060 BFD_ASSERT (i
!= 0);
2062 for (rel
= i
; rel
< i
+ sec
->reloc_count
; ++rel
)
2064 unsigned short r_type
= rel
->r_type
;
2066 struct coff_link_hash_entry
* h
;
2068 symndx
= rel
->r_symndx
;
2070 /* If the relocation is not against a symbol it cannot concern us. */
2074 /* If the index is outside of the range of our table, something has gone wrong. */
2075 if (symndx
>= obj_conv_table_size (abfd
))
2077 /* xgettext:c-format */
2078 _bfd_error_handler (_("%pB: illegal symbol index in reloc: %ld"),
2083 h
= obj_coff_sym_hashes (abfd
)[symndx
];
2085 /* If the relocation is against a static symbol it must be within
2086 the current section and so cannot be a cross ARM/Thumb relocation. */
2093 /* This one is a call from arm code. We need to look up
2094 the target of the call. If it is a thumb target, we
2097 if (h
->symbol_class
== C_THUMBEXTFUNC
)
2098 record_arm_to_thumb_glue (info
, h
);
2103 /* This one is a call from thumb code. We used to look
2104 for ARM_THUMB9 and ARM_THUMB12 as well. We need to look
2105 up the target of the call. If it is an arm target, we
2106 insert glue. If the symbol does not exist it will be
2107 given a class of C_EXT and so we will generate a stub
2108 for it. This is not really a problem, since the link
2109 is doomed anyway. */
2111 switch (h
->symbol_class
)
2116 record_thumb_to_arm_glue (info
, h
);
2133 #endif /* ! defined (COFF_IMAGE_WITH_PE) */
2135 #define coff_bfd_reloc_type_lookup coff_arm_reloc_type_lookup
2136 #define coff_bfd_reloc_name_lookup coff_arm_reloc_name_lookup
2137 #define coff_relocate_section coff_arm_relocate_section
2138 #define coff_bfd_is_local_label_name coff_arm_is_local_label_name
2139 #define coff_adjust_symndx coff_arm_adjust_symndx
2140 #define coff_link_output_has_begun coff_arm_link_output_has_begun
2141 #define coff_final_link_postscript coff_arm_final_link_postscript
2142 #define coff_bfd_merge_private_bfd_data coff_arm_merge_private_bfd_data
2143 #define coff_bfd_print_private_bfd_data coff_arm_print_private_bfd_data
2144 #define coff_bfd_set_private_flags _bfd_coff_arm_set_private_flags
2145 #define coff_bfd_copy_private_bfd_data coff_arm_copy_private_bfd_data
2146 #define coff_bfd_link_hash_table_create coff_arm_link_hash_table_create
2148 /* When doing a relocatable link, we want to convert ARM_26 relocs
2149 into ARM_26D relocs. */
2152 coff_arm_adjust_symndx (bfd
*obfd ATTRIBUTE_UNUSED
,
2153 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2156 struct internal_reloc
*irel
,
2157 bfd_boolean
*adjustedp
)
2159 if (irel
->r_type
== ARM_26
)
2161 struct coff_link_hash_entry
*h
;
2163 h
= obj_coff_sym_hashes (ibfd
)[irel
->r_symndx
];
2165 && (h
->root
.type
== bfd_link_hash_defined
2166 || h
->root
.type
== bfd_link_hash_defweak
)
2167 && h
->root
.u
.def
.section
->output_section
== sec
->output_section
)
2168 irel
->r_type
= ARM_26D
;
2174 /* Called when merging the private data areas of two BFDs.
2175 This is important as it allows us to detect if we are
2176 attempting to merge binaries compiled for different ARM
2177 targets, eg different CPUs or different APCS's. */
2180 coff_arm_merge_private_bfd_data (bfd
* ibfd
, struct bfd_link_info
*info
)
2182 bfd
*obfd
= info
->output_bfd
;
2183 BFD_ASSERT (ibfd
!= NULL
&& obfd
!= NULL
);
2188 /* If the two formats are different we cannot merge anything.
2189 This is not an error, since it is permissable to change the
2190 input and output formats. */
2191 if ( ibfd
->xvec
->flavour
!= bfd_target_coff_flavour
2192 || obfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
2195 /* Determine what should happen if the input ARM architecture
2196 does not match the output ARM architecture. */
2197 if (! bfd_arm_merge_machines (ibfd
, obfd
))
2200 /* Verify that the APCS is the same for the two BFDs. */
2201 if (APCS_SET (ibfd
))
2203 if (APCS_SET (obfd
))
2205 /* If the src and dest have different APCS flag bits set, fail. */
2206 if (APCS_26_FLAG (obfd
) != APCS_26_FLAG (ibfd
))
2209 /* xgettext: c-format */
2210 (_("error: %pB is compiled for APCS-%d, whereas %pB is compiled for APCS-%d"),
2211 ibfd
, APCS_26_FLAG (ibfd
) ? 26 : 32,
2212 obfd
, APCS_26_FLAG (obfd
) ? 26 : 32
2215 bfd_set_error (bfd_error_wrong_format
);
2219 if (APCS_FLOAT_FLAG (obfd
) != APCS_FLOAT_FLAG (ibfd
))
2221 if (APCS_FLOAT_FLAG (ibfd
))
2222 /* xgettext: c-format */
2223 _bfd_error_handler (_("\
2224 error: %pB passes floats in float registers, whereas %pB passes them in integer registers"),
2227 /* xgettext: c-format */
2228 _bfd_error_handler (_("\
2229 error: %pB passes floats in integer registers, whereas %pB passes them in float registers"),
2232 bfd_set_error (bfd_error_wrong_format
);
2236 if (PIC_FLAG (obfd
) != PIC_FLAG (ibfd
))
2238 if (PIC_FLAG (ibfd
))
2239 /* xgettext: c-format */
2240 _bfd_error_handler (_("\
2241 error: %pB is compiled as position independent code, whereas target %pB is absolute position"),
2244 /* xgettext: c-format */
2245 _bfd_error_handler (_("\
2246 error: %pB is compiled as absolute position code, whereas target %pB is position independent"),
2249 bfd_set_error (bfd_error_wrong_format
);
2255 SET_APCS_FLAGS (obfd
, APCS_26_FLAG (ibfd
) | APCS_FLOAT_FLAG (ibfd
) | PIC_FLAG (ibfd
));
2257 /* Set up the arch and fields as well as these are probably wrong. */
2258 bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
), bfd_get_mach (ibfd
));
2262 /* Check the interworking support. */
2263 if (INTERWORK_SET (ibfd
))
2265 if (INTERWORK_SET (obfd
))
2267 /* If the src and dest differ in their interworking issue a warning. */
2268 if (INTERWORK_FLAG (obfd
) != INTERWORK_FLAG (ibfd
))
2270 if (INTERWORK_FLAG (ibfd
))
2271 /* xgettext: c-format */
2272 _bfd_error_handler (_("\
2273 warning: %pB supports interworking, whereas %pB does not"),
2276 /* xgettext: c-format */
2277 _bfd_error_handler (_("\
2278 warning: %pB does not support interworking, whereas %pB does"),
2284 SET_INTERWORK_FLAG (obfd
, INTERWORK_FLAG (ibfd
));
2291 /* Display the flags field. */
2294 coff_arm_print_private_bfd_data (bfd
* abfd
, void * ptr
)
2296 FILE * file
= (FILE *) ptr
;
2298 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
2300 fprintf (file
, _("private flags = %x:"), coff_data (abfd
)->flags
);
2302 if (APCS_SET (abfd
))
2304 /* xgettext: APCS is ARM Procedure Call Standard, it should not be translated. */
2305 fprintf (file
, " [APCS-%d]", APCS_26_FLAG (abfd
) ? 26 : 32);
2307 if (APCS_FLOAT_FLAG (abfd
))
2308 fprintf (file
, _(" [floats passed in float registers]"));
2310 fprintf (file
, _(" [floats passed in integer registers]"));
2312 if (PIC_FLAG (abfd
))
2313 fprintf (file
, _(" [position independent]"));
2315 fprintf (file
, _(" [absolute position]"));
2318 if (! INTERWORK_SET (abfd
))
2319 fprintf (file
, _(" [interworking flag not initialised]"));
2320 else if (INTERWORK_FLAG (abfd
))
2321 fprintf (file
, _(" [interworking supported]"));
2323 fprintf (file
, _(" [interworking not supported]"));
2330 /* Copies the given flags into the coff_tdata.flags field.
2331 Typically these flags come from the f_flags[] field of
2332 the COFF filehdr structure, which contains important,
2333 target specific information.
2334 Note: Although this function is static, it is explicitly
2335 called from both coffcode.h and peicode.h. */
2338 _bfd_coff_arm_set_private_flags (bfd
* abfd
, flagword flags
)
2342 BFD_ASSERT (abfd
!= NULL
);
2344 flag
= (flags
& F_APCS26
) ? F_APCS_26
: 0;
2346 /* Make sure that the APCS field has not been initialised to the opposite
2349 && ( (APCS_26_FLAG (abfd
) != flag
)
2350 || (APCS_FLOAT_FLAG (abfd
) != (flags
& F_APCS_FLOAT
))
2351 || (PIC_FLAG (abfd
) != (flags
& F_PIC
))
2355 flag
|= (flags
& (F_APCS_FLOAT
| F_PIC
));
2357 SET_APCS_FLAGS (abfd
, flag
);
2359 flag
= (flags
& F_INTERWORK
);
2361 /* If the BFD has already had its interworking flag set, but it
2362 is different from the value that we have been asked to set,
2363 then assume that that merged code will not support interworking
2364 and set the flag accordingly. */
2365 if (INTERWORK_SET (abfd
) && (INTERWORK_FLAG (abfd
) != flag
))
2368 _bfd_error_handler (_("warning: not setting interworking flag of %pB since it has already been specified as non-interworking"),
2371 _bfd_error_handler (_("warning: clearing the interworking flag of %pB due to outside request"),
2376 SET_INTERWORK_FLAG (abfd
, flag
);
2381 /* Copy the important parts of the target specific data
2382 from one instance of a BFD to another. */
2385 coff_arm_copy_private_bfd_data (bfd
* src
, bfd
* dest
)
2387 BFD_ASSERT (src
!= NULL
&& dest
!= NULL
);
2392 /* If the destination is not in the same format as the source, do not do
2394 if (src
->xvec
!= dest
->xvec
)
2397 /* Copy the flags field. */
2400 if (APCS_SET (dest
))
2402 /* If the src and dest have different APCS flag bits set, fail. */
2403 if (APCS_26_FLAG (dest
) != APCS_26_FLAG (src
))
2406 if (APCS_FLOAT_FLAG (dest
) != APCS_FLOAT_FLAG (src
))
2409 if (PIC_FLAG (dest
) != PIC_FLAG (src
))
2413 SET_APCS_FLAGS (dest
, APCS_26_FLAG (src
) | APCS_FLOAT_FLAG (src
)
2417 if (INTERWORK_SET (src
))
2419 if (INTERWORK_SET (dest
))
2421 /* If the src and dest have different interworking flags then turn
2422 off the interworking bit. */
2423 if (INTERWORK_FLAG (dest
) != INTERWORK_FLAG (src
))
2425 if (INTERWORK_FLAG (dest
))
2427 /* xgettext:c-format */
2428 _bfd_error_handler (_("\
2429 warning: clearing the interworking flag of %pB because non-interworking code in %pB has been linked with it"),
2433 SET_INTERWORK_FLAG (dest
, 0);
2438 SET_INTERWORK_FLAG (dest
, INTERWORK_FLAG (src
));
2445 /* Note: the definitions here of LOCAL_LABEL_PREFIX and USER_LABEL_PREIFX
2446 *must* match the definitions in gcc/config/arm/{coff|semi|aout}.h. */
2447 #ifndef LOCAL_LABEL_PREFIX
2448 #define LOCAL_LABEL_PREFIX ""
2450 #ifndef USER_LABEL_PREFIX
2451 #define USER_LABEL_PREFIX "_"
2454 /* Like _bfd_coff_is_local_label_name, but
2455 a) test against USER_LABEL_PREFIX, to avoid stripping labels known to be
2457 b) Allow other prefixes than ".", e.g. an empty prefix would cause all
2458 labels of the form Lxxx to be stripped. */
2461 coff_arm_is_local_label_name (bfd
* abfd ATTRIBUTE_UNUSED
,
2464 #ifdef USER_LABEL_PREFIX
2465 if (USER_LABEL_PREFIX
[0] != 0)
2467 size_t len
= strlen (USER_LABEL_PREFIX
);
2469 if (strncmp (name
, USER_LABEL_PREFIX
, len
) == 0)
2474 #ifdef LOCAL_LABEL_PREFIX
2475 /* If there is a prefix for local labels then look for this.
2476 If the prefix exists, but it is empty, then ignore the test. */
2478 if (LOCAL_LABEL_PREFIX
[0] != 0)
2480 size_t len
= strlen (LOCAL_LABEL_PREFIX
);
2482 if (strncmp (name
, LOCAL_LABEL_PREFIX
, len
) != 0)
2485 /* Perform the checks below for the rest of the name. */
2490 return name
[0] == 'L';
2493 /* This piece of machinery exists only to guarantee that the bfd that holds
2494 the glue section is written last.
2496 This does depend on bfd_make_section attaching a new section to the
2497 end of the section list for the bfd. */
2500 coff_arm_link_output_has_begun (bfd
* sub
, struct coff_final_link_info
* info
)
2502 return (sub
->output_has_begun
2503 || sub
== coff_arm_hash_table (info
->info
)->bfd_of_glue_owner
);
2507 coff_arm_final_link_postscript (bfd
* abfd ATTRIBUTE_UNUSED
,
2508 struct coff_final_link_info
* pfinfo
)
2510 struct coff_arm_link_hash_table
* globals
;
2512 globals
= coff_arm_hash_table (pfinfo
->info
);
2514 BFD_ASSERT (globals
!= NULL
);
2516 if (globals
->bfd_of_glue_owner
!= NULL
)
2518 if (! _bfd_coff_link_input_bfd (pfinfo
, globals
->bfd_of_glue_owner
))
2521 globals
->bfd_of_glue_owner
->output_has_begun
= TRUE
;
2524 return bfd_arm_update_notes (abfd
, ARM_NOTE_SECTION
);
2527 #ifndef bfd_pe_print_pdata
2528 #define bfd_pe_print_pdata NULL
2531 #include "coffcode.h"
2533 #ifndef TARGET_LITTLE_SYM
2534 #define TARGET_LITTLE_SYM arm_coff_le_vec
2536 #ifndef TARGET_LITTLE_NAME
2537 #define TARGET_LITTLE_NAME "coff-arm-little"
2539 #ifndef TARGET_BIG_SYM
2540 #define TARGET_BIG_SYM arm_coff_be_vec
2542 #ifndef TARGET_BIG_NAME
2543 #define TARGET_BIG_NAME "coff-arm-big"
2546 #ifndef TARGET_UNDERSCORE
2547 #define TARGET_UNDERSCORE 0
2550 #ifndef EXTRA_S_FLAGS
2552 #define EXTRA_S_FLAGS (SEC_CODE | SEC_LINK_ONCE | SEC_LINK_DUPLICATES)
2554 #define EXTRA_S_FLAGS SEC_CODE
2558 /* Forward declaration for use initialising alternative_target field. */
2559 extern const bfd_target TARGET_BIG_SYM
;
2561 /* Target vectors. */
2562 CREATE_LITTLE_COFF_TARGET_VEC (TARGET_LITTLE_SYM
, TARGET_LITTLE_NAME
, D_PAGED
, EXTRA_S_FLAGS
, TARGET_UNDERSCORE
, & TARGET_BIG_SYM
, COFF_SWAP_TABLE
)
2563 CREATE_BIG_COFF_TARGET_VEC (TARGET_BIG_SYM
, TARGET_BIG_NAME
, D_PAGED
, EXTRA_S_FLAGS
, TARGET_UNDERSCORE
, & TARGET_LITTLE_SYM
, COFF_SWAP_TABLE
)