1 /* 32-bit ELF support for Nios II.
2 Copyright (C) 2012-2018 Free Software Foundation, Inc.
3 Contributed by Nigel Gray (ngray@altera.com).
4 Contributed by Mentor Graphics, Inc.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
23 /* This file handles Altera Nios II ELF targets. */
31 #include "elf/nios2.h"
32 #include "opcode/nios2.h"
33 #include "elf32-nios2.h"
35 /* Use RELA relocations. */
44 /* Forward declarations. */
45 static bfd_reloc_status_type nios2_elf32_ignore_reloc
46 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
47 static bfd_reloc_status_type nios2_elf32_hi16_relocate
48 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
49 static bfd_reloc_status_type nios2_elf32_lo16_relocate
50 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
51 static bfd_reloc_status_type nios2_elf32_hiadj16_relocate
52 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
53 static bfd_reloc_status_type nios2_elf32_pcrel_lo16_relocate
54 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
55 static bfd_reloc_status_type nios2_elf32_pcrel_hiadj16_relocate
56 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
57 static bfd_reloc_status_type nios2_elf32_pcrel16_relocate
58 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
59 static bfd_reloc_status_type nios2_elf32_call26_relocate
60 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
61 static bfd_reloc_status_type nios2_elf32_gprel_relocate
62 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
63 static bfd_reloc_status_type nios2_elf32_ujmp_relocate
64 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
65 static bfd_reloc_status_type nios2_elf32_cjmp_relocate
66 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
67 static bfd_reloc_status_type nios2_elf32_callr_relocate
68 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
71 extern const bfd_target nios2_elf32_le_vec
;
72 extern const bfd_target nios2_elf32_be_vec
;
74 /* Offset of tp and dtp pointers from start of TLS block. */
75 #define TP_OFFSET 0x7000
76 #define DTP_OFFSET 0x8000
78 /* The relocation tables used for SHT_REL sections. There are separate
79 tables for R1 and R2 encodings. */
80 static reloc_howto_type elf_nios2_r1_howto_table_rel
[] = {
82 HOWTO (R_NIOS2_NONE
, /* type */
84 3, /* size (0 = byte, 1 = short, 2 = long) */
86 FALSE
, /* pc_relative */
88 complain_overflow_dont
, /* complain_on_overflow */
89 bfd_elf_generic_reloc
, /* special_function */
90 "R_NIOS2_NONE", /* name */
91 FALSE
, /* partial_inplace */
94 FALSE
), /* pcrel_offset */
96 /* 16-bit signed immediate relocation. */
97 HOWTO (R_NIOS2_S16
, /* type */
99 2, /* size (0 = byte, 1 = short, 2 = long) */
101 FALSE
, /* pc_relative */
103 complain_overflow_signed
, /* complain on overflow */
104 bfd_elf_generic_reloc
, /* special function */
105 "R_NIOS2_S16", /* name */
106 FALSE
, /* partial_inplace */
107 0x003fffc0, /* src_mask */
108 0x003fffc0, /* dest_mask */
109 FALSE
), /* pcrel_offset */
111 /* 16-bit unsigned immediate relocation. */
112 HOWTO (R_NIOS2_U16
, /* type */
114 2, /* size (0 = byte, 1 = short, 2 = long) */
116 FALSE
, /* pc_relative */
118 complain_overflow_unsigned
, /* complain on overflow */
119 bfd_elf_generic_reloc
, /* special function */
120 "R_NIOS2_U16", /* name */
121 FALSE
, /* partial_inplace */
122 0x003fffc0, /* src_mask */
123 0x003fffc0, /* dest_mask */
124 FALSE
), /* pcrel_offset */
126 HOWTO (R_NIOS2_PCREL16
, /* type */
128 2, /* size (0 = byte, 1 = short, 2 = long) */
130 TRUE
, /* pc_relative */
132 complain_overflow_signed
, /* complain on overflow */
133 nios2_elf32_pcrel16_relocate
, /* special function */
134 "R_NIOS2_PCREL16", /* name */
135 FALSE
, /* partial_inplace */
136 0x003fffc0, /* src_mask */
137 0x003fffc0, /* dest_mask */
138 TRUE
), /* pcrel_offset */
140 HOWTO (R_NIOS2_CALL26
, /* type */
142 2, /* size (0 = byte, 1 = short, 2 = long) */
144 FALSE
, /* pc_relative */
146 complain_overflow_dont
, /* complain on overflow */
147 nios2_elf32_call26_relocate
, /* special function */
148 "R_NIOS2_CALL26", /* name */
149 FALSE
, /* partial_inplace */
150 0xffffffc0, /* src_mask */
151 0xffffffc0, /* dst_mask */
152 FALSE
), /* pcrel_offset */
160 complain_overflow_bitfield
,
161 bfd_elf_generic_reloc
,
168 HOWTO (R_NIOS2_CACHE_OPX
,
174 complain_overflow_bitfield
,
175 bfd_elf_generic_reloc
,
188 complain_overflow_bitfield
,
189 bfd_elf_generic_reloc
,
202 complain_overflow_bitfield
,
203 bfd_elf_generic_reloc
,
216 complain_overflow_dont
,
217 nios2_elf32_hi16_relocate
,
230 complain_overflow_dont
,
231 nios2_elf32_lo16_relocate
,
238 HOWTO (R_NIOS2_HIADJ16
,
244 complain_overflow_dont
,
245 nios2_elf32_hiadj16_relocate
,
252 HOWTO (R_NIOS2_BFD_RELOC_32
,
258 complain_overflow_dont
,
259 bfd_elf_generic_reloc
,
260 "R_NIOS2_BFD_RELOC32",
266 HOWTO (R_NIOS2_BFD_RELOC_16
,
272 complain_overflow_bitfield
,
273 bfd_elf_generic_reloc
,
274 "R_NIOS2_BFD_RELOC16",
280 HOWTO (R_NIOS2_BFD_RELOC_8
,
286 complain_overflow_bitfield
,
287 bfd_elf_generic_reloc
,
288 "R_NIOS2_BFD_RELOC8",
294 HOWTO (R_NIOS2_GPREL
,
300 complain_overflow_dont
,
301 nios2_elf32_gprel_relocate
,
308 HOWTO (R_NIOS2_GNU_VTINHERIT
,
314 complain_overflow_dont
,
316 "R_NIOS2_GNU_VTINHERIT",
322 HOWTO (R_NIOS2_GNU_VTENTRY
,
328 complain_overflow_dont
,
329 _bfd_elf_rel_vtable_reloc_fn
,
330 "R_NIOS2_GNU_VTENTRY",
342 complain_overflow_dont
,
343 nios2_elf32_ujmp_relocate
,
356 complain_overflow_dont
,
357 nios2_elf32_cjmp_relocate
,
364 HOWTO (R_NIOS2_CALLR
,
370 complain_overflow_dont
,
371 nios2_elf32_callr_relocate
,
378 HOWTO (R_NIOS2_ALIGN
,
384 complain_overflow_dont
,
385 nios2_elf32_ignore_reloc
,
393 HOWTO (R_NIOS2_GOT16
,
399 complain_overflow_bitfield
,
400 bfd_elf_generic_reloc
,
407 HOWTO (R_NIOS2_CALL16
,
413 complain_overflow_bitfield
,
414 bfd_elf_generic_reloc
,
421 HOWTO (R_NIOS2_GOTOFF_LO
,
427 complain_overflow_dont
,
428 bfd_elf_generic_reloc
,
435 HOWTO (R_NIOS2_GOTOFF_HA
,
441 complain_overflow_dont
,
442 bfd_elf_generic_reloc
,
449 HOWTO (R_NIOS2_PCREL_LO
,
455 complain_overflow_dont
,
456 nios2_elf32_pcrel_lo16_relocate
,
463 HOWTO (R_NIOS2_PCREL_HA
,
467 FALSE
, /* This is a PC-relative relocation, but we need to subtract
468 PC ourselves before the HIADJ. */
470 complain_overflow_dont
,
471 nios2_elf32_pcrel_hiadj16_relocate
,
478 HOWTO (R_NIOS2_TLS_GD16
,
484 complain_overflow_bitfield
,
485 bfd_elf_generic_reloc
,
492 HOWTO (R_NIOS2_TLS_LDM16
,
498 complain_overflow_bitfield
,
499 bfd_elf_generic_reloc
,
506 HOWTO (R_NIOS2_TLS_LDO16
,
512 complain_overflow_bitfield
,
513 bfd_elf_generic_reloc
,
520 HOWTO (R_NIOS2_TLS_IE16
,
526 complain_overflow_bitfield
,
527 bfd_elf_generic_reloc
,
534 HOWTO (R_NIOS2_TLS_LE16
,
540 complain_overflow_bitfield
,
541 bfd_elf_generic_reloc
,
548 HOWTO (R_NIOS2_TLS_DTPMOD
,
554 complain_overflow_dont
,
555 bfd_elf_generic_reloc
,
556 "R_NIOS2_TLS_DTPMOD",
562 HOWTO (R_NIOS2_TLS_DTPREL
,
568 complain_overflow_dont
,
569 bfd_elf_generic_reloc
,
570 "R_NIOS2_TLS_DTPREL",
576 HOWTO (R_NIOS2_TLS_TPREL
,
582 complain_overflow_dont
,
583 bfd_elf_generic_reloc
,
596 complain_overflow_dont
,
597 bfd_elf_generic_reloc
,
604 HOWTO (R_NIOS2_GLOB_DAT
,
610 complain_overflow_dont
,
611 bfd_elf_generic_reloc
,
618 HOWTO (R_NIOS2_JUMP_SLOT
,
624 complain_overflow_dont
,
625 bfd_elf_generic_reloc
,
632 HOWTO (R_NIOS2_RELATIVE
,
638 complain_overflow_dont
,
639 bfd_elf_generic_reloc
,
646 HOWTO (R_NIOS2_GOTOFF
,
652 complain_overflow_dont
,
653 bfd_elf_generic_reloc
,
660 HOWTO (R_NIOS2_CALL26_NOAT
, /* type */
662 2, /* size (0 = byte, 1 = short, 2 = long) */
664 FALSE
, /* pc_relative */
666 complain_overflow_dont
, /* complain on overflow */
667 nios2_elf32_call26_relocate
, /* special function */
668 "R_NIOS2_CALL26_NOAT", /* name */
669 FALSE
, /* partial_inplace */
670 0xffffffc0, /* src_mask */
671 0xffffffc0, /* dst_mask */
672 FALSE
), /* pcrel_offset */
674 HOWTO (R_NIOS2_GOT_LO
,
680 complain_overflow_dont
,
681 bfd_elf_generic_reloc
,
688 HOWTO (R_NIOS2_GOT_HA
,
694 complain_overflow_dont
,
695 bfd_elf_generic_reloc
,
702 HOWTO (R_NIOS2_CALL_LO
,
708 complain_overflow_dont
,
709 bfd_elf_generic_reloc
,
716 HOWTO (R_NIOS2_CALL_HA
,
722 complain_overflow_dont
,
723 bfd_elf_generic_reloc
,
730 /* Add other relocations here. */
733 static reloc_howto_type elf_nios2_r2_howto_table_rel
[] = {
735 HOWTO (R_NIOS2_NONE
, /* type */
737 0, /* size (0 = byte, 1 = short, 2 = long) */
739 FALSE
, /* pc_relative */
741 complain_overflow_dont
, /* complain_on_overflow */
742 bfd_elf_generic_reloc
, /* special_function */
743 "R_NIOS2_NONE", /* name */
744 FALSE
, /* partial_inplace */
747 FALSE
), /* pcrel_offset */
749 /* 16-bit signed immediate relocation. */
750 HOWTO (R_NIOS2_S16
, /* type */
752 2, /* size (0 = byte, 1 = short, 2 = long) */
754 FALSE
, /* pc_relative */
756 complain_overflow_signed
, /* complain on overflow */
757 bfd_elf_generic_reloc
, /* special function */
758 "R_NIOS2_S16", /* name */
759 FALSE
, /* partial_inplace */
760 0xffff0000, /* src_mask */
761 0xffff0000, /* dest_mask */
762 FALSE
), /* pcrel_offset */
764 /* 16-bit unsigned immediate relocation. */
765 HOWTO (R_NIOS2_U16
, /* type */
767 2, /* size (0 = byte, 1 = short, 2 = long) */
769 FALSE
, /* pc_relative */
771 complain_overflow_unsigned
, /* complain on overflow */
772 bfd_elf_generic_reloc
, /* special function */
773 "R_NIOS2_U16", /* name */
774 FALSE
, /* partial_inplace */
775 0xffff0000, /* src_mask */
776 0xffff0000, /* dest_mask */
777 FALSE
), /* pcrel_offset */
779 HOWTO (R_NIOS2_PCREL16
, /* type */
781 2, /* size (0 = byte, 1 = short, 2 = long) */
783 TRUE
, /* pc_relative */
785 complain_overflow_signed
, /* complain on overflow */
786 nios2_elf32_pcrel16_relocate
, /* special function */
787 "R_NIOS2_PCREL16", /* name */
788 FALSE
, /* partial_inplace */
789 0xffff0000, /* src_mask */
790 0xffff0000, /* dest_mask */
791 TRUE
), /* pcrel_offset */
793 HOWTO (R_NIOS2_CALL26
, /* type */
795 2, /* size (0 = byte, 1 = short, 2 = long) */
797 FALSE
, /* pc_relative */
799 complain_overflow_dont
, /* complain on overflow */
800 nios2_elf32_call26_relocate
, /* special function */
801 "R_NIOS2_CALL26", /* name */
802 FALSE
, /* partial_inplace */
803 0xffffffc0, /* src_mask */
804 0xffffffc0, /* dst_mask */
805 FALSE
), /* pcrel_offset */
813 complain_overflow_bitfield
,
814 bfd_elf_generic_reloc
,
821 HOWTO (R_NIOS2_CACHE_OPX
,
827 complain_overflow_bitfield
,
828 bfd_elf_generic_reloc
,
841 complain_overflow_bitfield
,
842 bfd_elf_generic_reloc
,
855 complain_overflow_bitfield
,
856 bfd_elf_generic_reloc
,
869 complain_overflow_dont
,
870 nios2_elf32_hi16_relocate
,
883 complain_overflow_dont
,
884 nios2_elf32_lo16_relocate
,
891 HOWTO (R_NIOS2_HIADJ16
,
897 complain_overflow_dont
,
898 nios2_elf32_hiadj16_relocate
,
905 HOWTO (R_NIOS2_BFD_RELOC_32
,
911 complain_overflow_dont
,
912 bfd_elf_generic_reloc
,
913 "R_NIOS2_BFD_RELOC32",
919 HOWTO (R_NIOS2_BFD_RELOC_16
,
925 complain_overflow_bitfield
,
926 bfd_elf_generic_reloc
,
927 "R_NIOS2_BFD_RELOC16",
933 HOWTO (R_NIOS2_BFD_RELOC_8
,
939 complain_overflow_bitfield
,
940 bfd_elf_generic_reloc
,
941 "R_NIOS2_BFD_RELOC8",
947 HOWTO (R_NIOS2_GPREL
,
953 complain_overflow_dont
,
954 nios2_elf32_gprel_relocate
,
961 HOWTO (R_NIOS2_GNU_VTINHERIT
,
967 complain_overflow_dont
,
969 "R_NIOS2_GNU_VTINHERIT",
975 HOWTO (R_NIOS2_GNU_VTENTRY
,
981 complain_overflow_dont
,
982 _bfd_elf_rel_vtable_reloc_fn
,
983 "R_NIOS2_GNU_VTENTRY",
995 complain_overflow_dont
,
996 nios2_elf32_ujmp_relocate
,
1003 HOWTO (R_NIOS2_CJMP
,
1009 complain_overflow_dont
,
1010 nios2_elf32_cjmp_relocate
,
1017 HOWTO (R_NIOS2_CALLR
,
1023 complain_overflow_dont
,
1024 nios2_elf32_callr_relocate
,
1031 HOWTO (R_NIOS2_ALIGN
,
1037 complain_overflow_dont
,
1038 nios2_elf32_ignore_reloc
,
1045 HOWTO (R_NIOS2_GOT16
,
1051 complain_overflow_bitfield
,
1052 bfd_elf_generic_reloc
,
1059 HOWTO (R_NIOS2_CALL16
,
1065 complain_overflow_bitfield
,
1066 bfd_elf_generic_reloc
,
1073 HOWTO (R_NIOS2_GOTOFF_LO
,
1079 complain_overflow_dont
,
1080 bfd_elf_generic_reloc
,
1081 "R_NIOS2_GOTOFF_LO",
1087 HOWTO (R_NIOS2_GOTOFF_HA
,
1093 complain_overflow_dont
,
1094 bfd_elf_generic_reloc
,
1095 "R_NIOS2_GOTOFF_HA",
1101 HOWTO (R_NIOS2_PCREL_LO
,
1107 complain_overflow_dont
,
1108 nios2_elf32_pcrel_lo16_relocate
,
1115 HOWTO (R_NIOS2_PCREL_HA
,
1119 FALSE
, /* This is a PC-relative relocation, but we need to subtract
1120 PC ourselves before the HIADJ. */
1122 complain_overflow_dont
,
1123 nios2_elf32_pcrel_hiadj16_relocate
,
1130 HOWTO (R_NIOS2_TLS_GD16
,
1136 complain_overflow_bitfield
,
1137 bfd_elf_generic_reloc
,
1144 HOWTO (R_NIOS2_TLS_LDM16
,
1150 complain_overflow_bitfield
,
1151 bfd_elf_generic_reloc
,
1152 "R_NIOS2_TLS_LDM16",
1158 HOWTO (R_NIOS2_TLS_LDO16
,
1164 complain_overflow_bitfield
,
1165 bfd_elf_generic_reloc
,
1166 "R_NIOS2_TLS_LDO16",
1172 HOWTO (R_NIOS2_TLS_IE16
,
1178 complain_overflow_bitfield
,
1179 bfd_elf_generic_reloc
,
1186 HOWTO (R_NIOS2_TLS_LE16
,
1192 complain_overflow_bitfield
,
1193 bfd_elf_generic_reloc
,
1200 HOWTO (R_NIOS2_TLS_DTPMOD
,
1206 complain_overflow_dont
,
1207 bfd_elf_generic_reloc
,
1208 "R_NIOS2_TLS_DTPMOD",
1214 HOWTO (R_NIOS2_TLS_DTPREL
,
1220 complain_overflow_dont
,
1221 bfd_elf_generic_reloc
,
1222 "R_NIOS2_TLS_DTPREL",
1228 HOWTO (R_NIOS2_TLS_TPREL
,
1234 complain_overflow_dont
,
1235 bfd_elf_generic_reloc
,
1236 "R_NIOS2_TLS_TPREL",
1242 HOWTO (R_NIOS2_COPY
,
1248 complain_overflow_dont
,
1249 bfd_elf_generic_reloc
,
1256 HOWTO (R_NIOS2_GLOB_DAT
,
1262 complain_overflow_dont
,
1263 bfd_elf_generic_reloc
,
1270 HOWTO (R_NIOS2_JUMP_SLOT
,
1276 complain_overflow_dont
,
1277 bfd_elf_generic_reloc
,
1278 "R_NIOS2_JUMP_SLOT",
1284 HOWTO (R_NIOS2_RELATIVE
,
1290 complain_overflow_dont
,
1291 bfd_elf_generic_reloc
,
1298 HOWTO (R_NIOS2_GOTOFF
,
1304 complain_overflow_dont
,
1305 bfd_elf_generic_reloc
,
1312 HOWTO (R_NIOS2_CALL26_NOAT
, /* type */
1314 2, /* size (0 = byte, 1 = short, 2 = long) */
1316 FALSE
, /* pc_relative */
1318 complain_overflow_dont
, /* complain on overflow */
1319 nios2_elf32_call26_relocate
, /* special function */
1320 "R_NIOS2_CALL26_NOAT", /* name */
1321 FALSE
, /* partial_inplace */
1322 0xffffffc0, /* src_mask */
1323 0xffffffc0, /* dst_mask */
1324 FALSE
), /* pcrel_offset */
1326 HOWTO (R_NIOS2_GOT_LO
,
1332 complain_overflow_dont
,
1333 bfd_elf_generic_reloc
,
1340 HOWTO (R_NIOS2_GOT_HA
,
1346 complain_overflow_dont
,
1347 bfd_elf_generic_reloc
,
1354 HOWTO (R_NIOS2_CALL_LO
,
1360 complain_overflow_dont
,
1361 bfd_elf_generic_reloc
,
1368 HOWTO (R_NIOS2_CALL_HA
,
1374 complain_overflow_dont
,
1375 bfd_elf_generic_reloc
,
1382 HOWTO (R_NIOS2_R2_S12
,
1388 complain_overflow_signed
,
1389 bfd_elf_generic_reloc
,
1396 HOWTO (R_NIOS2_R2_I10_1_PCREL
,
1402 complain_overflow_signed
,
1403 bfd_elf_generic_reloc
, /* FIXME? */
1404 "R_NIOS2_R2_I10_1_PCREL",
1410 HOWTO (R_NIOS2_R2_T1I7_1_PCREL
,
1416 complain_overflow_signed
,
1417 bfd_elf_generic_reloc
, /* FIXME? */
1418 "R_NIOS2_R2_T1I7_1_PCREL",
1424 HOWTO (R_NIOS2_R2_T1I7_2
,
1430 complain_overflow_unsigned
,
1431 bfd_elf_generic_reloc
,
1432 "R_NIOS2_R2_T1I7_2",
1438 HOWTO (R_NIOS2_R2_T2I4
,
1444 complain_overflow_unsigned
,
1445 bfd_elf_generic_reloc
,
1452 HOWTO (R_NIOS2_R2_T2I4_1
,
1458 complain_overflow_unsigned
,
1459 bfd_elf_generic_reloc
,
1460 "R_NIOS2_R2_T2I4_1",
1466 HOWTO (R_NIOS2_R2_T2I4_2
,
1472 complain_overflow_unsigned
,
1473 bfd_elf_generic_reloc
,
1474 "R_NIOS2_R2_T2I4_2",
1480 HOWTO (R_NIOS2_R2_X1I7_2
,
1486 complain_overflow_unsigned
,
1487 bfd_elf_generic_reloc
,
1488 "R_NIOS2_R2_X1I7_2",
1494 HOWTO (R_NIOS2_R2_X2L5
,
1500 complain_overflow_unsigned
,
1501 bfd_elf_generic_reloc
,
1508 HOWTO (R_NIOS2_R2_F1I5_2
,
1514 complain_overflow_unsigned
,
1515 bfd_elf_generic_reloc
,
1516 "R_NIOS2_R2_F1L5_2",
1522 HOWTO (R_NIOS2_R2_L5I4X1
,
1528 complain_overflow_unsigned
,
1529 bfd_elf_generic_reloc
,
1530 "R_NIOS2_R2_L5I4X1",
1536 HOWTO (R_NIOS2_R2_T1X1I6
,
1542 complain_overflow_unsigned
,
1543 bfd_elf_generic_reloc
,
1544 "R_NIOS2_R2_T1X1I6",
1550 HOWTO (R_NIOS2_R2_T1X1I6_2
,
1556 complain_overflow_unsigned
,
1557 bfd_elf_generic_reloc
,
1558 "R_NIOS2_R2_T1I1X6_2",
1564 /* Add other relocations here. */
1567 static unsigned char elf_code_to_howto_index
[R_NIOS2_ILLEGAL
+ 1];
1570 /* Return true if producing output for a R2 BFD. */
1571 #define BFD_IS_R2(abfd) (bfd_get_mach (abfd) == bfd_mach_nios2r2)
1573 /* Return the howto for relocation RTYPE. */
1574 static reloc_howto_type
*
1575 lookup_howto (unsigned int rtype
, bfd
*abfd
)
1577 static int initialized
= 0;
1579 /* R2 relocations are a superset of R1, so use that for the lookup
1581 int r1_howto_tbl_size
= (int) (sizeof (elf_nios2_r1_howto_table_rel
)
1582 / sizeof (elf_nios2_r1_howto_table_rel
[0]));
1583 int r2_howto_tbl_size
= (int) (sizeof (elf_nios2_r2_howto_table_rel
)
1584 / sizeof (elf_nios2_r2_howto_table_rel
[0]));
1589 memset (elf_code_to_howto_index
, 0xff,
1590 sizeof (elf_code_to_howto_index
));
1591 for (i
= 0; i
< r2_howto_tbl_size
; i
++)
1593 elf_code_to_howto_index
[elf_nios2_r2_howto_table_rel
[i
].type
] = i
;
1594 if (i
< r1_howto_tbl_size
)
1595 BFD_ASSERT (elf_nios2_r2_howto_table_rel
[i
].type
1596 == elf_nios2_r1_howto_table_rel
[i
].type
);
1600 BFD_ASSERT (rtype
<= R_NIOS2_ILLEGAL
);
1601 i
= elf_code_to_howto_index
[rtype
];
1602 if (BFD_IS_R2 (abfd
))
1604 if (i
>= r2_howto_tbl_size
)
1606 return elf_nios2_r2_howto_table_rel
+ i
;
1610 if (i
>= r1_howto_tbl_size
)
1612 return elf_nios2_r1_howto_table_rel
+ i
;
1616 /* Map for converting BFD reloc types to Nios II reloc types. */
1617 struct elf_reloc_map
1619 bfd_reloc_code_real_type bfd_val
;
1620 enum elf_nios2_reloc_type elf_val
;
1623 static const struct elf_reloc_map nios2_reloc_map
[] = {
1624 {BFD_RELOC_NONE
, R_NIOS2_NONE
},
1625 {BFD_RELOC_NIOS2_S16
, R_NIOS2_S16
},
1626 {BFD_RELOC_NIOS2_U16
, R_NIOS2_U16
},
1627 {BFD_RELOC_16_PCREL
, R_NIOS2_PCREL16
},
1628 {BFD_RELOC_NIOS2_CALL26
, R_NIOS2_CALL26
},
1629 {BFD_RELOC_NIOS2_IMM5
, R_NIOS2_IMM5
},
1630 {BFD_RELOC_NIOS2_CACHE_OPX
, R_NIOS2_CACHE_OPX
},
1631 {BFD_RELOC_NIOS2_IMM6
, R_NIOS2_IMM6
},
1632 {BFD_RELOC_NIOS2_IMM8
, R_NIOS2_IMM8
},
1633 {BFD_RELOC_NIOS2_HI16
, R_NIOS2_HI16
},
1634 {BFD_RELOC_NIOS2_LO16
, R_NIOS2_LO16
},
1635 {BFD_RELOC_NIOS2_HIADJ16
, R_NIOS2_HIADJ16
},
1636 {BFD_RELOC_32
, R_NIOS2_BFD_RELOC_32
},
1637 {BFD_RELOC_16
, R_NIOS2_BFD_RELOC_16
},
1638 {BFD_RELOC_8
, R_NIOS2_BFD_RELOC_8
},
1639 {BFD_RELOC_NIOS2_GPREL
, R_NIOS2_GPREL
},
1640 {BFD_RELOC_VTABLE_INHERIT
, R_NIOS2_GNU_VTINHERIT
},
1641 {BFD_RELOC_VTABLE_ENTRY
, R_NIOS2_GNU_VTENTRY
},
1642 {BFD_RELOC_NIOS2_UJMP
, R_NIOS2_UJMP
},
1643 {BFD_RELOC_NIOS2_CJMP
, R_NIOS2_CJMP
},
1644 {BFD_RELOC_NIOS2_CALLR
, R_NIOS2_CALLR
},
1645 {BFD_RELOC_NIOS2_ALIGN
, R_NIOS2_ALIGN
},
1646 {BFD_RELOC_NIOS2_GOT16
, R_NIOS2_GOT16
},
1647 {BFD_RELOC_NIOS2_CALL16
, R_NIOS2_CALL16
},
1648 {BFD_RELOC_NIOS2_GOTOFF_LO
, R_NIOS2_GOTOFF_LO
},
1649 {BFD_RELOC_NIOS2_GOTOFF_HA
, R_NIOS2_GOTOFF_HA
},
1650 {BFD_RELOC_NIOS2_PCREL_LO
, R_NIOS2_PCREL_LO
},
1651 {BFD_RELOC_NIOS2_PCREL_HA
, R_NIOS2_PCREL_HA
},
1652 {BFD_RELOC_NIOS2_TLS_GD16
, R_NIOS2_TLS_GD16
},
1653 {BFD_RELOC_NIOS2_TLS_LDM16
, R_NIOS2_TLS_LDM16
},
1654 {BFD_RELOC_NIOS2_TLS_LDO16
, R_NIOS2_TLS_LDO16
},
1655 {BFD_RELOC_NIOS2_TLS_IE16
, R_NIOS2_TLS_IE16
},
1656 {BFD_RELOC_NIOS2_TLS_LE16
, R_NIOS2_TLS_LE16
},
1657 {BFD_RELOC_NIOS2_TLS_DTPMOD
, R_NIOS2_TLS_DTPMOD
},
1658 {BFD_RELOC_NIOS2_TLS_DTPREL
, R_NIOS2_TLS_DTPREL
},
1659 {BFD_RELOC_NIOS2_TLS_TPREL
, R_NIOS2_TLS_TPREL
},
1660 {BFD_RELOC_NIOS2_COPY
, R_NIOS2_COPY
},
1661 {BFD_RELOC_NIOS2_GLOB_DAT
, R_NIOS2_GLOB_DAT
},
1662 {BFD_RELOC_NIOS2_JUMP_SLOT
, R_NIOS2_JUMP_SLOT
},
1663 {BFD_RELOC_NIOS2_RELATIVE
, R_NIOS2_RELATIVE
},
1664 {BFD_RELOC_NIOS2_GOTOFF
, R_NIOS2_GOTOFF
},
1665 {BFD_RELOC_NIOS2_CALL26_NOAT
, R_NIOS2_CALL26_NOAT
},
1666 {BFD_RELOC_NIOS2_GOT_LO
, R_NIOS2_GOT_LO
},
1667 {BFD_RELOC_NIOS2_GOT_HA
, R_NIOS2_GOT_HA
},
1668 {BFD_RELOC_NIOS2_CALL_LO
, R_NIOS2_CALL_LO
},
1669 {BFD_RELOC_NIOS2_CALL_HA
, R_NIOS2_CALL_HA
},
1670 {BFD_RELOC_NIOS2_R2_S12
, R_NIOS2_R2_S12
},
1671 {BFD_RELOC_NIOS2_R2_I10_1_PCREL
, R_NIOS2_R2_I10_1_PCREL
},
1672 {BFD_RELOC_NIOS2_R2_T1I7_1_PCREL
, R_NIOS2_R2_T1I7_1_PCREL
},
1673 {BFD_RELOC_NIOS2_R2_T1I7_2
, R_NIOS2_R2_T1I7_2
},
1674 {BFD_RELOC_NIOS2_R2_T2I4
, R_NIOS2_R2_T2I4
},
1675 {BFD_RELOC_NIOS2_R2_T2I4_1
, R_NIOS2_R2_T2I4_1
},
1676 {BFD_RELOC_NIOS2_R2_T2I4_2
, R_NIOS2_R2_T2I4_2
},
1677 {BFD_RELOC_NIOS2_R2_X1I7_2
, R_NIOS2_R2_X1I7_2
},
1678 {BFD_RELOC_NIOS2_R2_X2L5
, R_NIOS2_R2_X2L5
},
1679 {BFD_RELOC_NIOS2_R2_F1I5_2
, R_NIOS2_R2_F1I5_2
},
1680 {BFD_RELOC_NIOS2_R2_L5I4X1
, R_NIOS2_R2_L5I4X1
},
1681 {BFD_RELOC_NIOS2_R2_T1X1I6
, R_NIOS2_R2_T1X1I6
},
1682 {BFD_RELOC_NIOS2_R2_T1X1I6_2
, R_NIOS2_R2_T1X1I6_2
},
1685 enum elf32_nios2_stub_type
1687 nios2_stub_call26_before
,
1688 nios2_stub_call26_after
,
1692 struct elf32_nios2_stub_hash_entry
1694 /* Base hash table entry structure. */
1695 struct bfd_hash_entry bh_root
;
1697 /* The stub section. */
1700 /* Offset within stub_sec of the beginning of this stub. */
1701 bfd_vma stub_offset
;
1703 /* Given the symbol's value and its section we can determine its final
1704 value when building the stubs (so the stub knows where to jump. */
1705 bfd_vma target_value
;
1706 asection
*target_section
;
1708 enum elf32_nios2_stub_type stub_type
;
1710 /* The symbol table entry, if any, that this was derived from. */
1711 struct elf32_nios2_link_hash_entry
*hh
;
1713 /* And the reloc addend that this was derived from. */
1716 /* Where this stub is being called from, or, in the case of combined
1717 stub sections, the first input section in the group. */
1721 #define nios2_stub_hash_entry(ent) \
1722 ((struct elf32_nios2_stub_hash_entry *)(ent))
1724 #define nios2_stub_hash_lookup(table, string, create, copy) \
1725 ((struct elf32_nios2_stub_hash_entry *) \
1726 bfd_hash_lookup ((table), (string), (create), (copy)))
1729 /* Nios II ELF linker hash entry. */
1731 struct elf32_nios2_link_hash_entry
1733 struct elf_link_hash_entry root
;
1735 /* A pointer to the most recently used stub hash entry against this
1737 struct elf32_nios2_stub_hash_entry
*hsh_cache
;
1739 /* Track dynamic relocs copied for this symbol. */
1740 struct elf_dyn_relocs
*dyn_relocs
;
1742 #define GOT_UNKNOWN 0
1743 #define GOT_NORMAL 1
1744 #define GOT_TLS_GD 2
1745 #define GOT_TLS_IE 4
1746 unsigned char tls_type
;
1748 /* We need to detect and take special action for symbols which are only
1749 referenced with %call() and not with %got(). Such symbols do not need
1750 a dynamic GOT reloc in shared objects, only a dynamic PLT reloc. Lazy
1751 linking will not work if the dynamic GOT reloc exists.
1752 To check for this condition efficiently, we compare got_types_used against
1754 (got_types_used & (GOT_USED | CALL_USED)) == CALL_USED.
1758 unsigned char got_types_used
;
1761 #define elf32_nios2_hash_entry(ent) \
1762 ((struct elf32_nios2_link_hash_entry *) (ent))
1764 /* Get the Nios II elf linker hash table from a link_info structure. */
1765 #define elf32_nios2_hash_table(info) \
1766 ((struct elf32_nios2_link_hash_table *) ((info)->hash))
1768 /* Nios II ELF linker hash table. */
1769 struct elf32_nios2_link_hash_table
1771 /* The main hash table. */
1772 struct elf_link_hash_table root
;
1774 /* The stub hash table. */
1775 struct bfd_hash_table bstab
;
1777 /* Linker stub bfd. */
1780 /* Linker call-backs. */
1781 asection
* (*add_stub_section
) (const char *, asection
*, bfd_boolean
);
1782 void (*layout_sections_again
) (void);
1784 /* Array to keep track of which stub sections have been created, and
1785 information on stub grouping. */
1788 /* These are the section to which stubs in the group will be
1790 asection
*first_sec
, *last_sec
;
1791 /* The stub sections. There might be stubs inserted either before
1792 or after the real section.*/
1793 asection
*first_stub_sec
, *last_stub_sec
;
1796 /* Assorted information used by nios2_elf32_size_stubs. */
1797 unsigned int bfd_count
;
1798 unsigned int top_index
;
1799 asection
**input_list
;
1800 Elf_Internal_Sym
**all_local_syms
;
1802 /* Short-cuts to get to dynamic linker sections. */
1805 /* GOT pointer symbol _gp_got. */
1806 struct elf_link_hash_entry
*h_gp_got
;
1809 bfd_signed_vma refcount
;
1813 /* Small local sym cache. */
1814 struct sym_cache sym_cache
;
1819 struct nios2_elf32_obj_tdata
1821 struct elf_obj_tdata root
;
1823 /* tls_type for each local got entry. */
1824 char *local_got_tls_type
;
1826 /* TRUE if TLS GD relocs have been seen for this object. */
1827 bfd_boolean has_tlsgd
;
1830 #define elf32_nios2_tdata(abfd) \
1831 ((struct nios2_elf32_obj_tdata *) (abfd)->tdata.any)
1833 #define elf32_nios2_local_got_tls_type(abfd) \
1834 (elf32_nios2_tdata (abfd)->local_got_tls_type)
1836 /* The name of the dynamic interpreter. This is put in the .interp
1838 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
1840 /* PLT implementation for position-dependent code. */
1841 static const bfd_vma nios2_plt_entry
[] = { /* .PLTn: */
1842 0x03c00034, /* movhi r15, %hiadj(plt_got_slot_address) */
1843 0x7bc00017, /* ldw r15, %lo(plt_got_slot_address)(r15) */
1844 0x7800683a /* jmp r15 */
1847 static const bfd_vma nios2_plt0_entry
[] = { /* .PLTresolve */
1848 0x03800034, /* movhi r14, %hiadj(res_0) */
1849 0x73800004, /* addi r14, r14, %lo(res_0) */
1850 0x7b9fc83a, /* sub r15, r15, r14 */
1851 0x03400034, /* movhi r13, %hiadj(_GLOBAL_OFFSET_TABLE_) */
1852 0x6b800017, /* ldw r14, %lo(_GLOBAL_OFFSET_TABLE_+4)(r13) */
1853 0x6b400017, /* ldw r13, %lo(_GLOBAL_OFFSET_TABLE_+8)(r13) */
1854 0x6800683a /* jmp r13 */
1857 /* PLT implementation for position-independent code. */
1858 static const bfd_vma nios2_so_plt_entry
[] = { /* .PLTn */
1859 0x03c00034, /* movhi r15, %hiadj(index * 4) */
1860 0x7bc00004, /* addi r15, r15, %lo(index * 4) */
1861 0x00000006 /* br .PLTresolve */
1864 static const bfd_vma nios2_so_plt0_entry
[] = { /* .PLTresolve */
1865 0x001ce03a, /* nextpc r14 */
1866 0x03400034, /* movhi r13, %hiadj(_GLOBAL_OFFSET_TABLE_) */
1867 0x6b9b883a, /* add r13, r13, r14 */
1868 0x6b800017, /* ldw r14, %lo(_GLOBAL_OFFSET_TABLE_+4)(r13) */
1869 0x6b400017, /* ldw r13, %lo(_GLOBAL_OFFSET_TABLE_+8)(r13) */
1870 0x6800683a /* jmp r13 */
1874 static const bfd_vma nios2_call26_stub_entry
[] = {
1875 0x00400034, /* orhi at, r0, %hiadj(dest) */
1876 0x08400004, /* addi at, at, %lo(dest) */
1877 0x0800683a /* jmp at */
1880 /* Install 16-bit immediate value VALUE at offset OFFSET into section SEC. */
1882 nios2_elf32_install_imm16 (asection
*sec
, bfd_vma offset
, bfd_vma value
)
1884 bfd_vma word
= bfd_get_32 (sec
->owner
, sec
->contents
+ offset
);
1886 BFD_ASSERT (value
<= 0xffff || ((bfd_signed_vma
) value
) >= -0xffff);
1888 bfd_put_32 (sec
->owner
, word
| ((value
& 0xffff) << 6),
1889 sec
->contents
+ offset
);
1892 /* Install COUNT 32-bit values DATA starting at offset OFFSET into
1895 nios2_elf32_install_data (asection
*sec
, const bfd_vma
*data
, bfd_vma offset
,
1900 bfd_put_32 (sec
->owner
, *data
, sec
->contents
+ offset
);
1906 /* The usual way of loading a 32-bit constant into a Nios II register is to
1907 load the high 16 bits in one instruction and then add the low 16 bits with
1908 a signed add. This means that the high halfword needs to be adjusted to
1909 compensate for the sign bit of the low halfword. This function returns the
1910 adjusted high halfword for a given 32-bit constant. */
1912 bfd_vma
hiadj (bfd_vma symbol_value
)
1914 return ((symbol_value
+ 0x8000) >> 16) & 0xffff;
1917 /* Implement elf_backend_grok_prstatus:
1918 Support for core dump NOTE sections. */
1920 nios2_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
1925 switch (note
->descsz
)
1930 case 212: /* Linux/Nios II */
1932 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
1935 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
1944 /* Make a ".reg/999" section. */
1945 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
1946 size
, note
->descpos
+ offset
);
1949 /* Implement elf_backend_grok_psinfo. */
1951 nios2_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
1953 switch (note
->descsz
)
1958 case 124: /* Linux/Nios II elf_prpsinfo */
1959 elf_tdata (abfd
)->core
->program
1960 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
1961 elf_tdata (abfd
)->core
->command
1962 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
1965 /* Note that for some reason, a spurious space is tacked
1966 onto the end of the args in some (at least one anyway)
1967 implementations, so strip it off if it exists. */
1970 char *command
= elf_tdata (abfd
)->core
->command
;
1971 int n
= strlen (command
);
1973 if (0 < n
&& command
[n
- 1] == ' ')
1974 command
[n
- 1] = '\0';
1980 /* Assorted hash table functions. */
1982 /* Initialize an entry in the stub hash table. */
1983 static struct bfd_hash_entry
*
1984 stub_hash_newfunc (struct bfd_hash_entry
*entry
,
1985 struct bfd_hash_table
*table
,
1988 /* Allocate the structure if it has not already been allocated by a
1992 entry
= bfd_hash_allocate (table
,
1993 sizeof (struct elf32_nios2_stub_hash_entry
));
1998 /* Call the allocation method of the superclass. */
1999 entry
= bfd_hash_newfunc (entry
, table
, string
);
2002 struct elf32_nios2_stub_hash_entry
*hsh
;
2004 /* Initialize the local fields. */
2005 hsh
= (struct elf32_nios2_stub_hash_entry
*) entry
;
2006 hsh
->stub_sec
= NULL
;
2007 hsh
->stub_offset
= 0;
2008 hsh
->target_value
= 0;
2009 hsh
->target_section
= NULL
;
2010 hsh
->stub_type
= nios2_stub_none
;
2018 /* Create an entry in a Nios II ELF linker hash table. */
2019 static struct bfd_hash_entry
*
2020 link_hash_newfunc (struct bfd_hash_entry
*entry
,
2021 struct bfd_hash_table
*table
, const char *string
)
2023 /* Allocate the structure if it has not already been allocated by a
2027 entry
= bfd_hash_allocate (table
,
2028 sizeof (struct elf32_nios2_link_hash_entry
));
2033 /* Call the allocation method of the superclass. */
2034 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
2037 struct elf32_nios2_link_hash_entry
*eh
;
2039 eh
= (struct elf32_nios2_link_hash_entry
*) entry
;
2040 eh
->hsh_cache
= NULL
;
2041 eh
->dyn_relocs
= NULL
;
2042 eh
->tls_type
= GOT_UNKNOWN
;
2043 eh
->got_types_used
= 0;
2049 /* Section name for stubs is the associated section name plus this
2051 #define STUB_SUFFIX ".stub"
2053 /* Build a name for an entry in the stub hash table. */
2055 nios2_stub_name (const asection
*input_section
,
2056 const asection
*sym_sec
,
2057 const struct elf32_nios2_link_hash_entry
*hh
,
2058 const Elf_Internal_Rela
*rel
,
2059 enum elf32_nios2_stub_type stub_type
)
2063 char stubpos
= (stub_type
== nios2_stub_call26_before
) ? 'b' : 'a';
2067 len
= 8 + 1 + 1 + 1+ strlen (hh
->root
.root
.root
.string
) + 1 + 8 + 1;
2068 stub_name
= bfd_malloc (len
);
2069 if (stub_name
!= NULL
)
2071 sprintf (stub_name
, "%08x_%c_%s+%x",
2072 input_section
->id
& 0xffffffff,
2074 hh
->root
.root
.root
.string
,
2075 (int) rel
->r_addend
& 0xffffffff);
2080 len
= 8 + 1 + 1 + 1+ 8 + 1 + 8 + 1 + 8 + 1;
2081 stub_name
= bfd_malloc (len
);
2082 if (stub_name
!= NULL
)
2084 sprintf (stub_name
, "%08x_%c_%x:%x+%x",
2085 input_section
->id
& 0xffffffff,
2087 sym_sec
->id
& 0xffffffff,
2088 (int) ELF32_R_SYM (rel
->r_info
) & 0xffffffff,
2089 (int) rel
->r_addend
& 0xffffffff);
2095 /* Look up an entry in the stub hash. Stub entries are cached because
2096 creating the stub name takes a bit of time. */
2097 static struct elf32_nios2_stub_hash_entry
*
2098 nios2_get_stub_entry (const asection
*input_section
,
2099 const asection
*sym_sec
,
2100 struct elf32_nios2_link_hash_entry
*hh
,
2101 const Elf_Internal_Rela
*rel
,
2102 struct elf32_nios2_link_hash_table
*htab
,
2103 enum elf32_nios2_stub_type stub_type
)
2105 struct elf32_nios2_stub_hash_entry
*hsh
;
2106 const asection
*id_sec
;
2108 /* If this input section is part of a group of sections sharing one
2109 stub section, then use the id of the first/last section in the group,
2110 depending on the stub section placement relative to the group.
2111 Stub names need to include a section id, as there may well be
2112 more than one stub used to reach say, printf, and we need to
2113 distinguish between them. */
2114 if (stub_type
== nios2_stub_call26_before
)
2115 id_sec
= htab
->stub_group
[input_section
->id
].first_sec
;
2117 id_sec
= htab
->stub_group
[input_section
->id
].last_sec
;
2119 if (hh
!= NULL
&& hh
->hsh_cache
!= NULL
2120 && hh
->hsh_cache
->hh
== hh
2121 && hh
->hsh_cache
->id_sec
== id_sec
2122 && hh
->hsh_cache
->stub_type
== stub_type
)
2124 hsh
= hh
->hsh_cache
;
2130 stub_name
= nios2_stub_name (id_sec
, sym_sec
, hh
, rel
, stub_type
);
2131 if (stub_name
== NULL
)
2134 hsh
= nios2_stub_hash_lookup (&htab
->bstab
,
2135 stub_name
, FALSE
, FALSE
);
2138 hh
->hsh_cache
= hsh
;
2146 /* Add a new stub entry to the stub hash. Not all fields of the new
2147 stub entry are initialised. */
2148 static struct elf32_nios2_stub_hash_entry
*
2149 nios2_add_stub (const char *stub_name
,
2151 struct elf32_nios2_link_hash_table
*htab
,
2152 enum elf32_nios2_stub_type stub_type
)
2156 asection
**secptr
, **linkptr
;
2157 struct elf32_nios2_stub_hash_entry
*hsh
;
2160 if (stub_type
== nios2_stub_call26_before
)
2162 link_sec
= htab
->stub_group
[section
->id
].first_sec
;
2163 secptr
= &(htab
->stub_group
[section
->id
].first_stub_sec
);
2164 linkptr
= &(htab
->stub_group
[link_sec
->id
].first_stub_sec
);
2169 link_sec
= htab
->stub_group
[section
->id
].last_sec
;
2170 secptr
= &(htab
->stub_group
[section
->id
].last_stub_sec
);
2171 linkptr
= &(htab
->stub_group
[link_sec
->id
].last_stub_sec
);
2175 if (stub_sec
== NULL
)
2177 stub_sec
= *linkptr
;
2178 if (stub_sec
== NULL
)
2184 namelen
= strlen (link_sec
->name
);
2185 len
= namelen
+ sizeof (STUB_SUFFIX
);
2186 s_name
= bfd_alloc (htab
->stub_bfd
, len
);
2190 memcpy (s_name
, link_sec
->name
, namelen
);
2191 memcpy (s_name
+ namelen
, STUB_SUFFIX
, sizeof (STUB_SUFFIX
));
2193 stub_sec
= (*htab
->add_stub_section
) (s_name
, link_sec
, afterp
);
2194 if (stub_sec
== NULL
)
2196 *linkptr
= stub_sec
;
2201 /* Enter this entry into the linker stub hash table. */
2202 hsh
= nios2_stub_hash_lookup (&htab
->bstab
, stub_name
,
2206 /* xgettext:c-format */
2207 _bfd_error_handler (_("%pB: cannot create stub entry %s"),
2213 hsh
->stub_sec
= stub_sec
;
2214 hsh
->stub_offset
= 0;
2215 hsh
->id_sec
= link_sec
;
2219 /* Set up various things so that we can make a list of input sections
2220 for each output section included in the link. Returns -1 on error,
2221 0 when no stubs will be needed, and 1 on success. */
2223 nios2_elf32_setup_section_lists (bfd
*output_bfd
, struct bfd_link_info
*info
)
2226 unsigned int bfd_count
;
2227 unsigned int top_id
, top_index
;
2229 asection
**input_list
, **list
;
2231 struct elf32_nios2_link_hash_table
*htab
= elf32_nios2_hash_table (info
);
2233 /* Count the number of input BFDs and find the top input section id. */
2234 for (input_bfd
= info
->input_bfds
, bfd_count
= 0, top_id
= 0;
2236 input_bfd
= input_bfd
->link
.next
)
2239 for (section
= input_bfd
->sections
;
2241 section
= section
->next
)
2243 if (top_id
< section
->id
)
2244 top_id
= section
->id
;
2248 htab
->bfd_count
= bfd_count
;
2250 amt
= sizeof (struct map_stub
) * (top_id
+ 1);
2251 htab
->stub_group
= bfd_zmalloc (amt
);
2252 if (htab
->stub_group
== NULL
)
2255 /* We can't use output_bfd->section_count here to find the top output
2256 section index as some sections may have been removed, and
2257 strip_excluded_output_sections doesn't renumber the indices. */
2258 for (section
= output_bfd
->sections
, top_index
= 0;
2260 section
= section
->next
)
2262 if (top_index
< section
->index
)
2263 top_index
= section
->index
;
2266 htab
->top_index
= top_index
;
2267 amt
= sizeof (asection
*) * (top_index
+ 1);
2268 input_list
= bfd_malloc (amt
);
2269 htab
->input_list
= input_list
;
2270 if (input_list
== NULL
)
2273 /* For sections we aren't interested in, mark their entries with a
2274 value we can check later. */
2275 list
= input_list
+ top_index
;
2277 *list
= bfd_abs_section_ptr
;
2278 while (list
-- != input_list
);
2280 for (section
= output_bfd
->sections
;
2282 section
= section
->next
)
2284 /* FIXME: This is a bit of hack. Currently our .ctors and .dtors
2285 * have PC relative relocs in them but no code flag set. */
2286 if (((section
->flags
& SEC_CODE
) != 0) ||
2287 strcmp(".ctors", section
->name
) ||
2288 strcmp(".dtors", section
->name
))
2289 input_list
[section
->index
] = NULL
;
2295 /* The linker repeatedly calls this function for each input section,
2296 in the order that input sections are linked into output sections.
2297 Build lists of input sections to determine groupings between which
2298 we may insert linker stubs. */
2300 nios2_elf32_next_input_section (struct bfd_link_info
*info
, asection
*isec
)
2302 struct elf32_nios2_link_hash_table
*htab
= elf32_nios2_hash_table (info
);
2304 if (isec
->output_section
->index
<= htab
->top_index
)
2306 asection
**list
= htab
->input_list
+ isec
->output_section
->index
;
2307 if (*list
!= bfd_abs_section_ptr
)
2309 /* Steal the last_sec pointer for our list.
2310 This happens to make the list in reverse order,
2311 which is what we want. */
2312 htab
->stub_group
[isec
->id
].last_sec
= *list
;
2318 /* Segment mask for CALL26 relocation relaxation. */
2319 #define CALL26_SEGMENT(x) ((x) & 0xf0000000)
2321 /* Fudge factor for approximate maximum size of all stubs that might
2322 be inserted by the linker. This does not actually limit the number
2323 of stubs that might be inserted, and only affects strategy for grouping
2324 and placement of stubs. Perhaps this should be computed based on number
2325 of relocations seen, or be specifiable on the command line. */
2326 #define MAX_STUB_SECTION_SIZE 0xffff
2328 /* See whether we can group stub sections together. Grouping stub
2329 sections may result in fewer stubs. More importantly, we need to
2330 put all .init* and .fini* stubs at the end of the .init or
2331 .fini output sections respectively, because glibc splits the
2332 _init and _fini functions into multiple parts. Putting a stub in
2333 the middle of a function is not a good idea.
2334 Rather than computing groups of a maximum fixed size, for Nios II
2335 CALL26 relaxation it makes more sense to compute the groups based on
2336 sections that fit within a 256MB address segment. Also do not allow
2337 a group to span more than one output section, since different output
2338 sections might correspond to different memory banks on a bare-metal
2341 group_sections (struct elf32_nios2_link_hash_table
*htab
)
2343 asection
**list
= htab
->input_list
+ htab
->top_index
;
2346 /* The list is in reverse order so we'll search backwards looking
2347 for the first section that begins in the same memory segment,
2348 marking sections along the way to point at the tail for this
2350 asection
*tail
= *list
;
2351 if (tail
== bfd_abs_section_ptr
)
2353 while (tail
!= NULL
)
2355 bfd_vma start
= tail
->output_section
->vma
+ tail
->output_offset
;
2356 bfd_vma end
= start
+ tail
->size
;
2357 bfd_vma segment
= CALL26_SEGMENT (end
);
2360 if (segment
!= CALL26_SEGMENT (start
)
2361 || segment
!= CALL26_SEGMENT (end
+ MAX_STUB_SECTION_SIZE
))
2362 /* This section spans more than one memory segment, or is
2363 close enough to the end of the segment that adding stub
2364 sections before it might cause it to move so that it
2365 spans memory segments, or that stubs added at the end of
2366 this group might overflow into the next memory segment.
2367 Put it in a group by itself to localize the effects. */
2369 prev
= htab
->stub_group
[tail
->id
].last_sec
;
2370 htab
->stub_group
[tail
->id
].last_sec
= tail
;
2371 htab
->stub_group
[tail
->id
].first_sec
= tail
;
2374 /* Collect more sections for this group. */
2376 asection
*curr
, *first
;
2377 for (curr
= tail
; ; curr
= prev
)
2379 prev
= htab
->stub_group
[curr
->id
].last_sec
;
2381 || tail
->output_section
!= prev
->output_section
2382 || (CALL26_SEGMENT (prev
->output_section
->vma
2383 + prev
->output_offset
)
2388 for (curr
= tail
; ; curr
= prev
)
2390 prev
= htab
->stub_group
[curr
->id
].last_sec
;
2391 htab
->stub_group
[curr
->id
].last_sec
= tail
;
2392 htab
->stub_group
[curr
->id
].first_sec
= first
;
2398 /* Reset tail for the next group. */
2402 while (list
-- != htab
->input_list
);
2403 free (htab
->input_list
);
2406 /* Determine the type of stub needed, if any, for a call. */
2407 static enum elf32_nios2_stub_type
2408 nios2_type_of_stub (asection
*input_sec
,
2409 const Elf_Internal_Rela
*rel
,
2410 struct elf32_nios2_link_hash_entry
*hh
,
2411 struct elf32_nios2_link_hash_table
*htab
,
2412 bfd_vma destination
,
2413 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2415 bfd_vma location
, segment
, start
, end
;
2416 asection
*s0
, *s1
, *s
;
2419 !(hh
->root
.root
.type
== bfd_link_hash_defined
2420 || hh
->root
.root
.type
== bfd_link_hash_defweak
))
2421 return nios2_stub_none
;
2423 /* Determine where the call point is. */
2424 location
= (input_sec
->output_section
->vma
2425 + input_sec
->output_offset
+ rel
->r_offset
);
2426 segment
= CALL26_SEGMENT (location
);
2428 /* Nios II CALL and JMPI instructions can transfer control to addresses
2429 within the same 256MB segment as the PC. */
2430 if (segment
== CALL26_SEGMENT (destination
))
2431 return nios2_stub_none
;
2433 /* Find the start and end addresses of the stub group. Also account for
2434 any already-created stub sections for this group. Note that for stubs
2435 in the end section, only the first instruction of the last stub
2436 (12 bytes long) needs to be within range. */
2437 s0
= htab
->stub_group
[input_sec
->id
].first_sec
;
2438 s
= htab
->stub_group
[s0
->id
].first_stub_sec
;
2439 if (s
!= NULL
&& s
->size
> 0)
2440 start
= s
->output_section
->vma
+ s
->output_offset
;
2442 start
= s0
->output_section
->vma
+ s0
->output_offset
;
2444 s1
= htab
->stub_group
[input_sec
->id
].last_sec
;
2445 s
= htab
->stub_group
[s1
->id
].last_stub_sec
;
2446 if (s
!= NULL
&& s
->size
> 0)
2447 end
= s
->output_section
->vma
+ s
->output_offset
+ s
->size
- 8;
2449 end
= s1
->output_section
->vma
+ s1
->output_offset
+ s1
->size
;
2451 BFD_ASSERT (start
< end
);
2452 BFD_ASSERT (start
<= location
);
2453 BFD_ASSERT (location
< end
);
2455 /* Put stubs at the end of the group unless that is not a valid
2456 location and the beginning of the group is. It might be that
2457 neither the beginning nor end works if we have an input section
2458 so large that it spans multiple segment boundaries. In that
2459 case, punt; the end result will be a relocation overflow error no
2460 matter what we do here.
2462 Note that adding stubs pushes up the addresses of all subsequent
2463 sections, so that stubs allocated on one pass through the
2464 relaxation loop may not be valid on the next pass. (E.g., we may
2465 allocate a stub at the beginning of the section on one pass and
2466 find that the call site has been bumped into the next memory
2467 segment on the next pass.) The important thing to note is that
2468 we never try to reclaim the space allocated to such unused stubs,
2469 so code size and section addresses can only increase with each
2470 iteration. Accounting for the start and end addresses of the
2471 already-created stub sections ensures that when the algorithm
2472 converges, it converges accurately, with the entire appropriate
2473 stub section accessible from the call site and not just the
2474 address at the start or end of the stub group proper. */
2476 if (segment
== CALL26_SEGMENT (end
))
2477 return nios2_stub_call26_after
;
2478 else if (segment
== CALL26_SEGMENT (start
))
2479 return nios2_stub_call26_before
;
2481 /* Perhaps this should be a dedicated error code. */
2482 return nios2_stub_none
;
2486 nios2_build_one_stub (struct bfd_hash_entry
*gen_entry
, void *in_arg ATTRIBUTE_UNUSED
)
2488 struct elf32_nios2_stub_hash_entry
*hsh
2489 = (struct elf32_nios2_stub_hash_entry
*) gen_entry
;
2490 asection
*stub_sec
= hsh
->stub_sec
;
2493 /* Make a note of the offset within the stubs for this entry. */
2494 hsh
->stub_offset
= stub_sec
->size
;
2496 switch (hsh
->stub_type
)
2498 case nios2_stub_call26_before
:
2499 case nios2_stub_call26_after
:
2500 /* A call26 stub looks like:
2501 orhi at, %hiadj(dest)
2502 addi at, at, %lo(dest)
2504 Note that call/jmpi instructions can't be used in PIC code
2505 so there is no reason for the stub to be PIC, either. */
2506 sym_value
= (hsh
->target_value
2507 + hsh
->target_section
->output_offset
2508 + hsh
->target_section
->output_section
->vma
2511 nios2_elf32_install_data (stub_sec
, nios2_call26_stub_entry
,
2512 hsh
->stub_offset
, 3);
2513 nios2_elf32_install_imm16 (stub_sec
, hsh
->stub_offset
,
2515 nios2_elf32_install_imm16 (stub_sec
, hsh
->stub_offset
+ 4,
2516 (sym_value
& 0xffff));
2517 stub_sec
->size
+= 12;
2527 /* As above, but don't actually build the stub. Just bump offset so
2528 we know stub section sizes. */
2530 nios2_size_one_stub (struct bfd_hash_entry
*gen_entry
, void *in_arg ATTRIBUTE_UNUSED
)
2532 struct elf32_nios2_stub_hash_entry
*hsh
2533 = (struct elf32_nios2_stub_hash_entry
*) gen_entry
;
2535 switch (hsh
->stub_type
)
2537 case nios2_stub_call26_before
:
2538 case nios2_stub_call26_after
:
2539 hsh
->stub_sec
->size
+= 12;
2548 /* Read in all local syms for all input bfds.
2549 Returns -1 on error, 0 otherwise. */
2552 get_local_syms (bfd
*output_bfd ATTRIBUTE_UNUSED
, bfd
*input_bfd
,
2553 struct bfd_link_info
*info
)
2555 unsigned int bfd_indx
;
2556 Elf_Internal_Sym
*local_syms
, **all_local_syms
;
2557 struct elf32_nios2_link_hash_table
*htab
= elf32_nios2_hash_table (info
);
2559 /* We want to read in symbol extension records only once. To do this
2560 we need to read in the local symbols in parallel and save them for
2561 later use; so hold pointers to the local symbols in an array. */
2562 bfd_size_type amt
= sizeof (Elf_Internal_Sym
*) * htab
->bfd_count
;
2563 all_local_syms
= bfd_zmalloc (amt
);
2564 htab
->all_local_syms
= all_local_syms
;
2565 if (all_local_syms
== NULL
)
2568 /* Walk over all the input BFDs, swapping in local symbols. */
2571 input_bfd
= input_bfd
->link
.next
, bfd_indx
++)
2573 Elf_Internal_Shdr
*symtab_hdr
;
2575 /* We'll need the symbol table in a second. */
2576 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2577 if (symtab_hdr
->sh_info
== 0)
2580 /* We need an array of the local symbols attached to the input bfd. */
2581 local_syms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2582 if (local_syms
== NULL
)
2584 local_syms
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
,
2585 symtab_hdr
->sh_info
, 0,
2587 /* Cache them for elf_link_input_bfd. */
2588 symtab_hdr
->contents
= (unsigned char *) local_syms
;
2590 if (local_syms
== NULL
)
2593 all_local_syms
[bfd_indx
] = local_syms
;
2599 /* Determine and set the size of the stub section for a final link. */
2601 nios2_elf32_size_stubs (bfd
*output_bfd
, bfd
*stub_bfd
,
2602 struct bfd_link_info
*info
,
2603 asection
*(*add_stub_section
) (const char *,
2604 asection
*, bfd_boolean
),
2605 void (*layout_sections_again
) (void))
2607 bfd_boolean stub_changed
= FALSE
;
2608 struct elf32_nios2_link_hash_table
*htab
= elf32_nios2_hash_table (info
);
2610 /* Stash our params away. */
2611 htab
->stub_bfd
= stub_bfd
;
2612 htab
->add_stub_section
= add_stub_section
;
2613 htab
->layout_sections_again
= layout_sections_again
;
2615 /* FIXME: We only compute the section groups once. This could cause
2616 problems if adding a large stub section causes following sections,
2617 or parts of them, to move into another segment. However, this seems
2618 to be consistent with the way other back ends handle this.... */
2619 group_sections (htab
);
2621 if (get_local_syms (output_bfd
, info
->input_bfds
, info
))
2623 if (htab
->all_local_syms
)
2624 goto error_ret_free_local
;
2631 unsigned int bfd_indx
;
2634 for (input_bfd
= info
->input_bfds
, bfd_indx
= 0;
2636 input_bfd
= input_bfd
->link
.next
, bfd_indx
++)
2638 Elf_Internal_Shdr
*symtab_hdr
;
2640 Elf_Internal_Sym
*local_syms
;
2642 /* We'll need the symbol table in a second. */
2643 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2644 if (symtab_hdr
->sh_info
== 0)
2647 local_syms
= htab
->all_local_syms
[bfd_indx
];
2649 /* Walk over each section attached to the input bfd. */
2650 for (section
= input_bfd
->sections
;
2652 section
= section
->next
)
2654 Elf_Internal_Rela
*internal_relocs
, *irelaend
, *irela
;
2656 /* If there aren't any relocs, then there's nothing more
2658 if ((section
->flags
& SEC_RELOC
) == 0
2659 || section
->reloc_count
== 0)
2662 /* If this section is a link-once section that will be
2663 discarded, then don't create any stubs. */
2664 if (section
->output_section
== NULL
2665 || section
->output_section
->owner
!= output_bfd
)
2668 /* Get the relocs. */
2670 = _bfd_elf_link_read_relocs (input_bfd
, section
, NULL
, NULL
,
2672 if (internal_relocs
== NULL
)
2673 goto error_ret_free_local
;
2675 /* Now examine each relocation. */
2676 irela
= internal_relocs
;
2677 irelaend
= irela
+ section
->reloc_count
;
2678 for (; irela
< irelaend
; irela
++)
2680 unsigned int r_type
, r_indx
;
2681 enum elf32_nios2_stub_type stub_type
;
2682 struct elf32_nios2_stub_hash_entry
*hsh
;
2685 bfd_vma destination
;
2686 struct elf32_nios2_link_hash_entry
*hh
;
2688 const asection
*id_sec
;
2690 r_type
= ELF32_R_TYPE (irela
->r_info
);
2691 r_indx
= ELF32_R_SYM (irela
->r_info
);
2693 if (r_type
>= (unsigned int) R_NIOS2_ILLEGAL
)
2695 bfd_set_error (bfd_error_bad_value
);
2696 error_ret_free_internal
:
2697 if (elf_section_data (section
)->relocs
== NULL
)
2698 free (internal_relocs
);
2699 goto error_ret_free_local
;
2702 /* Only look for stubs on CALL and JMPI instructions. */
2703 if (r_type
!= (unsigned int) R_NIOS2_CALL26
)
2706 /* Now determine the call target, its name, value,
2712 if (r_indx
< symtab_hdr
->sh_info
)
2714 /* It's a local symbol. */
2715 Elf_Internal_Sym
*sym
;
2716 Elf_Internal_Shdr
*hdr
;
2719 sym
= local_syms
+ r_indx
;
2720 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
2721 sym_value
= sym
->st_value
;
2722 shndx
= sym
->st_shndx
;
2723 if (shndx
< elf_numsections (input_bfd
))
2725 hdr
= elf_elfsections (input_bfd
)[shndx
];
2726 sym_sec
= hdr
->bfd_section
;
2727 destination
= (sym_value
+ irela
->r_addend
2728 + sym_sec
->output_offset
2729 + sym_sec
->output_section
->vma
);
2734 /* It's an external symbol. */
2737 e_indx
= r_indx
- symtab_hdr
->sh_info
;
2738 hh
= ((struct elf32_nios2_link_hash_entry
*)
2739 elf_sym_hashes (input_bfd
)[e_indx
]);
2741 while (hh
->root
.root
.type
== bfd_link_hash_indirect
2742 || hh
->root
.root
.type
== bfd_link_hash_warning
)
2743 hh
= ((struct elf32_nios2_link_hash_entry
*)
2744 hh
->root
.root
.u
.i
.link
);
2746 if (hh
->root
.root
.type
== bfd_link_hash_defined
2747 || hh
->root
.root
.type
== bfd_link_hash_defweak
)
2749 sym_sec
= hh
->root
.root
.u
.def
.section
;
2750 sym_value
= hh
->root
.root
.u
.def
.value
;
2752 if (sym_sec
->output_section
!= NULL
)
2753 destination
= (sym_value
+ irela
->r_addend
2754 + sym_sec
->output_offset
2755 + sym_sec
->output_section
->vma
);
2759 else if (hh
->root
.root
.type
== bfd_link_hash_undefweak
)
2761 if (! bfd_link_pic (info
))
2764 else if (hh
->root
.root
.type
== bfd_link_hash_undefined
)
2766 if (! (info
->unresolved_syms_in_objects
== RM_IGNORE
2767 && (ELF_ST_VISIBILITY (hh
->root
.other
)
2773 bfd_set_error (bfd_error_bad_value
);
2774 goto error_ret_free_internal
;
2778 /* Determine what (if any) linker stub is needed. */
2779 stub_type
= nios2_type_of_stub (section
, irela
, hh
, htab
,
2781 if (stub_type
== nios2_stub_none
)
2784 /* Support for grouping stub sections. */
2785 if (stub_type
== nios2_stub_call26_before
)
2786 id_sec
= htab
->stub_group
[section
->id
].first_sec
;
2788 id_sec
= htab
->stub_group
[section
->id
].last_sec
;
2790 /* Get the name of this stub. */
2791 stub_name
= nios2_stub_name (id_sec
, sym_sec
, hh
, irela
,
2794 goto error_ret_free_internal
;
2796 hsh
= nios2_stub_hash_lookup (&htab
->bstab
,
2801 /* The proper stub has already been created. */
2806 hsh
= nios2_add_stub (stub_name
, section
, htab
, stub_type
);
2810 goto error_ret_free_internal
;
2812 hsh
->target_value
= sym_value
;
2813 hsh
->target_section
= sym_sec
;
2814 hsh
->stub_type
= stub_type
;
2816 hsh
->addend
= irela
->r_addend
;
2817 stub_changed
= TRUE
;
2820 /* We're done with the internal relocs, free them. */
2821 if (elf_section_data (section
)->relocs
== NULL
)
2822 free (internal_relocs
);
2829 /* OK, we've added some stubs. Find out the new size of the
2831 for (stub_sec
= htab
->stub_bfd
->sections
;
2833 stub_sec
= stub_sec
->next
)
2836 bfd_hash_traverse (&htab
->bstab
, nios2_size_one_stub
, htab
);
2838 /* Ask the linker to do its stuff. */
2839 (*htab
->layout_sections_again
) ();
2840 stub_changed
= FALSE
;
2843 free (htab
->all_local_syms
);
2846 error_ret_free_local
:
2847 free (htab
->all_local_syms
);
2851 /* Build all the stubs associated with the current output file. The
2852 stubs are kept in a hash table attached to the main linker hash
2853 table. This function is called via nios2elf_finish in the linker. */
2855 nios2_elf32_build_stubs (struct bfd_link_info
*info
)
2858 struct bfd_hash_table
*table
;
2859 struct elf32_nios2_link_hash_table
*htab
;
2861 htab
= elf32_nios2_hash_table (info
);
2863 for (stub_sec
= htab
->stub_bfd
->sections
;
2865 stub_sec
= stub_sec
->next
)
2866 /* The stub_bfd may contain non-stub sections if it is also the
2867 dynobj. Any such non-stub sections are created with the
2868 SEC_LINKER_CREATED flag set, while stub sections do not
2869 have that flag. Ignore any non-stub sections here. */
2870 if ((stub_sec
->flags
& SEC_LINKER_CREATED
) == 0)
2874 /* Allocate memory to hold the linker stubs. */
2875 size
= stub_sec
->size
;
2876 stub_sec
->contents
= bfd_zalloc (htab
->stub_bfd
, size
);
2877 if (stub_sec
->contents
== NULL
&& size
!= 0)
2882 /* Build the stubs as directed by the stub hash table. */
2883 table
= &htab
->bstab
;
2884 bfd_hash_traverse (table
, nios2_build_one_stub
, info
);
2890 #define is_nios2_elf(bfd) \
2891 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2892 && elf_object_id (bfd) == NIOS2_ELF_DATA)
2894 /* Merge backend specific data from an object file to the output
2895 object file when linking. */
2898 nios2_elf32_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
2900 bfd
*obfd
= info
->output_bfd
;
2904 if (!is_nios2_elf (ibfd
) || !is_nios2_elf (obfd
))
2907 /* Check if we have the same endianness. */
2908 if (! _bfd_generic_verify_endian_match (ibfd
, info
))
2911 new_flags
= elf_elfheader (ibfd
)->e_flags
;
2912 old_flags
= elf_elfheader (obfd
)->e_flags
;
2913 if (!elf_flags_init (obfd
))
2915 /* First call, no flags set. */
2916 elf_flags_init (obfd
) = TRUE
;
2917 elf_elfheader (obfd
)->e_flags
= new_flags
;
2922 case EF_NIOS2_ARCH_R1
:
2923 bfd_default_set_arch_mach (obfd
, bfd_arch_nios2
, bfd_mach_nios2r1
);
2925 case EF_NIOS2_ARCH_R2
:
2926 if (bfd_big_endian (ibfd
))
2929 (_("error: %pB: Big-endian R2 is not supported."), ibfd
);
2930 bfd_set_error (bfd_error_bad_value
);
2933 bfd_default_set_arch_mach (obfd
, bfd_arch_nios2
, bfd_mach_nios2r2
);
2938 /* Incompatible flags. */
2939 else if (new_flags
!= old_flags
)
2941 /* So far, the only incompatible flags denote incompatible
2944 /* xgettext:c-format */
2945 (_("error: %pB: Conflicting CPU architectures %d/%d"),
2946 ibfd
, new_flags
, old_flags
);
2947 bfd_set_error (bfd_error_bad_value
);
2951 /* Merge Tag_compatibility attributes and any common GNU ones. */
2952 _bfd_elf_merge_object_attributes (ibfd
, info
);
2958 /* Implement bfd_elf32_bfd_reloc_type_lookup:
2959 Given a BFD reloc type, return a howto structure. */
2960 static reloc_howto_type
*
2961 nios2_elf32_bfd_reloc_type_lookup (bfd
*abfd
,
2962 bfd_reloc_code_real_type code
)
2967 i
< (int) (sizeof (nios2_reloc_map
) / sizeof (struct elf_reloc_map
));
2969 if (nios2_reloc_map
[i
].bfd_val
== code
)
2970 return lookup_howto (nios2_reloc_map
[i
].elf_val
, abfd
);
2974 /* Implement bfd_elf32_bfd_reloc_name_lookup:
2975 Given a reloc name, return a howto structure. */
2976 static reloc_howto_type
*
2977 nios2_elf32_bfd_reloc_name_lookup (bfd
*abfd
,
2981 reloc_howto_type
*howto_tbl
;
2984 if (BFD_IS_R2 (abfd
))
2986 howto_tbl
= elf_nios2_r2_howto_table_rel
;
2987 howto_tbl_size
= (int) (sizeof (elf_nios2_r2_howto_table_rel
)
2988 / sizeof (elf_nios2_r2_howto_table_rel
[0]));
2992 howto_tbl
= elf_nios2_r1_howto_table_rel
;
2993 howto_tbl_size
= (int) (sizeof (elf_nios2_r1_howto_table_rel
)
2994 / sizeof (elf_nios2_r1_howto_table_rel
[0]));
2997 for (i
= 0; i
< howto_tbl_size
; i
++)
2998 if (howto_tbl
[i
].name
&& strcasecmp (howto_tbl
[i
].name
, r_name
) == 0)
2999 return howto_tbl
+ i
;
3003 /* Implement elf_info_to_howto:
3004 Given a ELF32 relocation, fill in a arelent structure. */
3006 nios2_elf32_info_to_howto (bfd
*abfd
, arelent
*cache_ptr
,
3007 Elf_Internal_Rela
*dst
)
3009 unsigned int r_type
;
3011 r_type
= ELF32_R_TYPE (dst
->r_info
);
3012 cache_ptr
->howto
= lookup_howto (r_type
, abfd
);
3015 /* Return the base VMA address which should be subtracted from real addresses
3016 when resolving @dtpoff relocation.
3017 This is PT_TLS segment p_vaddr. */
3019 dtpoff_base (struct bfd_link_info
*info
)
3021 /* If tls_sec is NULL, we should have signalled an error already. */
3022 if (elf_hash_table (info
)->tls_sec
== NULL
)
3024 return elf_hash_table (info
)->tls_sec
->vma
;
3027 /* Return the relocation value for @tpoff relocation
3028 if STT_TLS virtual address is ADDRESS. */
3030 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3032 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3034 /* If tls_sec is NULL, we should have signalled an error already. */
3035 if (htab
->tls_sec
== NULL
)
3037 return address
- htab
->tls_sec
->vma
;
3040 /* Set the GP value for OUTPUT_BFD. Returns FALSE if this is a
3041 dangerous relocation. */
3043 nios2_elf_assign_gp (bfd
*output_bfd
, bfd_vma
*pgp
, struct bfd_link_info
*info
)
3046 bfd_boolean gp_found
;
3047 struct bfd_hash_entry
*h
;
3048 struct bfd_link_hash_entry
*lh
;
3050 /* If we've already figured out what GP will be, just return it. */
3051 *pgp
= _bfd_get_gp_value (output_bfd
);
3055 h
= bfd_hash_lookup (&info
->hash
->table
, "_gp", FALSE
, FALSE
);
3056 lh
= (struct bfd_link_hash_entry
*) h
;
3062 case bfd_link_hash_undefined
:
3063 case bfd_link_hash_undefweak
:
3064 case bfd_link_hash_common
:
3067 case bfd_link_hash_defined
:
3068 case bfd_link_hash_defweak
:
3071 asection
*sym_sec
= lh
->u
.def
.section
;
3072 bfd_vma sym_value
= lh
->u
.def
.value
;
3074 if (sym_sec
->output_section
)
3075 sym_value
= (sym_value
+ sym_sec
->output_offset
3076 + sym_sec
->output_section
->vma
);
3080 case bfd_link_hash_indirect
:
3081 case bfd_link_hash_warning
:
3083 /* @@FIXME ignoring warning for now */
3085 case bfd_link_hash_new
:
3095 /* Only get the error once. */
3097 _bfd_set_gp_value (output_bfd
, *pgp
);
3101 _bfd_set_gp_value (output_bfd
, *pgp
);
3106 /* Retrieve the previously cached _gp pointer, returning bfd_reloc_dangerous
3107 if it's not available as we don't have a link_info pointer available here
3108 to look it up in the output symbol table. We don't need to adjust the
3109 symbol value for an external symbol if we are producing relocatable
3111 static bfd_reloc_status_type
3112 nios2_elf_final_gp (bfd
*output_bfd
, asymbol
*symbol
, bfd_boolean relocatable
,
3113 char **error_message
, bfd_vma
*pgp
)
3115 if (bfd_is_und_section (symbol
->section
) && !relocatable
)
3118 return bfd_reloc_undefined
;
3121 *pgp
= _bfd_get_gp_value (output_bfd
);
3122 if (*pgp
== 0 && (!relocatable
|| (symbol
->flags
& BSF_SECTION_SYM
) != 0))
3126 /* Make up a value. */
3127 *pgp
= symbol
->section
->output_section
->vma
+ 0x4000;
3128 _bfd_set_gp_value (output_bfd
, *pgp
);
3133 = (char *) _("global pointer relative relocation when _gp not defined");
3134 return bfd_reloc_dangerous
;
3138 return bfd_reloc_ok
;
3141 /* Do the relocations that require special handling. */
3142 static bfd_reloc_status_type
3143 nios2_elf32_do_hi16_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3144 asection
*input_section
,
3145 bfd_byte
*data
, bfd_vma offset
,
3146 bfd_vma symbol_value
, bfd_vma addend
)
3148 symbol_value
= symbol_value
+ addend
;
3150 symbol_value
= (symbol_value
>> 16) & 0xffff;
3151 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
3152 data
, offset
, symbol_value
, addend
);
3155 static bfd_reloc_status_type
3156 nios2_elf32_do_lo16_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3157 asection
*input_section
,
3158 bfd_byte
*data
, bfd_vma offset
,
3159 bfd_vma symbol_value
, bfd_vma addend
)
3161 symbol_value
= symbol_value
+ addend
;
3163 symbol_value
= symbol_value
& 0xffff;
3164 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
3165 data
, offset
, symbol_value
, addend
);
3168 static bfd_reloc_status_type
3169 nios2_elf32_do_hiadj16_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3170 asection
*input_section
,
3171 bfd_byte
*data
, bfd_vma offset
,
3172 bfd_vma symbol_value
, bfd_vma addend
)
3174 symbol_value
= symbol_value
+ addend
;
3176 symbol_value
= hiadj(symbol_value
);
3177 return _bfd_final_link_relocate (howto
, abfd
, input_section
, data
, offset
,
3178 symbol_value
, addend
);
3181 static bfd_reloc_status_type
3182 nios2_elf32_do_pcrel_lo16_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3183 asection
*input_section
,
3184 bfd_byte
*data
, bfd_vma offset
,
3185 bfd_vma symbol_value
, bfd_vma addend
)
3187 symbol_value
= symbol_value
+ addend
;
3189 symbol_value
= symbol_value
& 0xffff;
3190 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
3191 data
, offset
, symbol_value
, addend
);
3194 static bfd_reloc_status_type
3195 nios2_elf32_do_pcrel_hiadj16_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3196 asection
*input_section
,
3197 bfd_byte
*data
, bfd_vma offset
,
3198 bfd_vma symbol_value
, bfd_vma addend
)
3200 symbol_value
= symbol_value
+ addend
;
3201 symbol_value
-= (input_section
->output_section
->vma
3202 + input_section
->output_offset
);
3203 symbol_value
-= offset
;
3205 symbol_value
= hiadj(symbol_value
);
3206 return _bfd_final_link_relocate (howto
, abfd
, input_section
, data
, offset
,
3207 symbol_value
, addend
);
3210 static bfd_reloc_status_type
3211 nios2_elf32_do_pcrel16_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3212 asection
*input_section
,
3213 bfd_byte
*data
, bfd_vma offset
,
3214 bfd_vma symbol_value
, bfd_vma addend
)
3216 /* NIOS2 pc relative relocations are relative to the next 32-bit instruction
3217 so we need to subtract 4 before doing a final_link_relocate. */
3218 symbol_value
= symbol_value
+ addend
- 4;
3220 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
3221 data
, offset
, symbol_value
, addend
);
3224 static bfd_reloc_status_type
3225 nios2_elf32_do_call26_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3226 asection
*input_section
,
3227 bfd_byte
*data
, bfd_vma offset
,
3228 bfd_vma symbol_value
, bfd_vma addend
)
3230 /* Check that the relocation is in the same page as the current address. */
3231 if (CALL26_SEGMENT (symbol_value
+ addend
)
3232 != CALL26_SEGMENT (input_section
->output_section
->vma
3233 + input_section
->output_offset
3235 return bfd_reloc_overflow
;
3237 /* Check that the target address is correctly aligned on a 4-byte
3239 if ((symbol_value
+ addend
) & 0x3)
3240 return bfd_reloc_overflow
;
3242 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
3243 data
, offset
, symbol_value
, addend
);
3246 static bfd_reloc_status_type
3247 nios2_elf32_do_gprel_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3248 asection
*input_section
,
3249 bfd_byte
*data
, bfd_vma offset
,
3250 bfd_vma symbol_value
, bfd_vma addend
)
3252 /* Because we need the output_bfd, the special handling is done
3253 in nios2_elf32_relocate_section or in nios2_elf32_gprel_relocate. */
3254 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
3255 data
, offset
, symbol_value
, addend
);
3258 static bfd_reloc_status_type
3259 nios2_elf32_do_ujmp_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3260 asection
*input_section
,
3261 bfd_byte
*data
, bfd_vma offset
,
3262 bfd_vma symbol_value
, bfd_vma addend
)
3264 bfd_vma symbol_lo16
, symbol_hi16
;
3265 bfd_reloc_status_type r
;
3266 symbol_value
= symbol_value
+ addend
;
3268 symbol_hi16
= (symbol_value
>> 16) & 0xffff;
3269 symbol_lo16
= symbol_value
& 0xffff;
3271 r
= _bfd_final_link_relocate (howto
, abfd
, input_section
,
3272 data
, offset
, symbol_hi16
, addend
);
3274 if (r
== bfd_reloc_ok
)
3275 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
3276 data
, offset
+ 4, symbol_lo16
, addend
);
3281 static bfd_reloc_status_type
3282 nios2_elf32_do_cjmp_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3283 asection
*input_section
,
3284 bfd_byte
*data
, bfd_vma offset
,
3285 bfd_vma symbol_value
, bfd_vma addend
)
3287 bfd_vma symbol_lo16
, symbol_hi16
;
3288 bfd_reloc_status_type r
;
3289 symbol_value
= symbol_value
+ addend
;
3291 symbol_hi16
= (symbol_value
>> 16) & 0xffff;
3292 symbol_lo16
= symbol_value
& 0xffff;
3294 r
= _bfd_final_link_relocate (howto
, abfd
, input_section
,
3295 data
, offset
, symbol_hi16
, addend
);
3297 if (r
== bfd_reloc_ok
)
3298 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
3299 data
, offset
+ 4, symbol_lo16
, addend
);
3304 static bfd_reloc_status_type
3305 nios2_elf32_do_callr_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3306 asection
*input_section
,
3307 bfd_byte
*data
, bfd_vma offset
,
3308 bfd_vma symbol_value
, bfd_vma addend
)
3310 bfd_vma symbol_lo16
, symbol_hi16
;
3311 bfd_reloc_status_type r
;
3312 symbol_value
= symbol_value
+ addend
;
3314 symbol_hi16
= (symbol_value
>> 16) & 0xffff;
3315 symbol_lo16
= symbol_value
& 0xffff;
3317 r
= _bfd_final_link_relocate (howto
, abfd
, input_section
,
3318 data
, offset
, symbol_hi16
, addend
);
3320 if (r
== bfd_reloc_ok
)
3321 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
3322 data
, offset
+ 4, symbol_lo16
, addend
);
3327 /* HOWTO handlers for relocations that require special handling. */
3329 /* This is for relocations used only when relaxing to ensure
3330 changes in size of section don't screw up .align. */
3331 static bfd_reloc_status_type
3332 nios2_elf32_ignore_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
3333 asymbol
*symbol ATTRIBUTE_UNUSED
,
3334 void *data ATTRIBUTE_UNUSED
, asection
*input_section
,
3336 char **error_message ATTRIBUTE_UNUSED
)
3338 if (output_bfd
!= NULL
)
3339 reloc_entry
->address
+= input_section
->output_offset
;
3340 return bfd_reloc_ok
;
3343 static bfd_reloc_status_type
3344 nios2_elf32_hi16_relocate (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
3345 void *data
, asection
*input_section
,
3347 char **error_message ATTRIBUTE_UNUSED
)
3349 /* This part is from bfd_elf_generic_reloc. */
3350 if (output_bfd
!= NULL
3351 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3352 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3354 reloc_entry
->address
+= input_section
->output_offset
;
3355 return bfd_reloc_ok
;
3358 if (output_bfd
!= NULL
)
3359 /* FIXME: See bfd_perform_relocation. Is this right? */
3360 return bfd_reloc_continue
;
3362 return nios2_elf32_do_hi16_relocate (abfd
, reloc_entry
->howto
,
3364 data
, reloc_entry
->address
,
3366 + symbol
->section
->output_section
->vma
3367 + symbol
->section
->output_offset
),
3368 reloc_entry
->addend
);
3371 static bfd_reloc_status_type
3372 nios2_elf32_lo16_relocate (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
3373 void *data
, asection
*input_section
,
3375 char **error_message ATTRIBUTE_UNUSED
)
3377 /* This part is from bfd_elf_generic_reloc. */
3378 if (output_bfd
!= NULL
3379 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3380 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3382 reloc_entry
->address
+= input_section
->output_offset
;
3383 return bfd_reloc_ok
;
3386 if (output_bfd
!= NULL
)
3387 /* FIXME: See bfd_perform_relocation. Is this right? */
3388 return bfd_reloc_continue
;
3390 return nios2_elf32_do_lo16_relocate (abfd
, reloc_entry
->howto
,
3392 data
, reloc_entry
->address
,
3394 + symbol
->section
->output_section
->vma
3395 + symbol
->section
->output_offset
),
3396 reloc_entry
->addend
);
3399 static bfd_reloc_status_type
3400 nios2_elf32_hiadj16_relocate (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
3401 void *data
, asection
*input_section
,
3403 char **error_message ATTRIBUTE_UNUSED
)
3405 /* This part is from bfd_elf_generic_reloc. */
3406 if (output_bfd
!= NULL
3407 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3408 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3410 reloc_entry
->address
+= input_section
->output_offset
;
3411 return bfd_reloc_ok
;
3414 if (output_bfd
!= NULL
)
3415 /* FIXME: See bfd_perform_relocation. Is this right? */
3416 return bfd_reloc_continue
;
3418 return nios2_elf32_do_hiadj16_relocate (abfd
, reloc_entry
->howto
,
3420 data
, reloc_entry
->address
,
3422 + symbol
->section
->output_section
->vma
3423 + symbol
->section
->output_offset
),
3424 reloc_entry
->addend
);
3427 static bfd_reloc_status_type
3428 nios2_elf32_pcrel_lo16_relocate (bfd
*abfd
, arelent
*reloc_entry
,
3429 asymbol
*symbol
, void *data
,
3430 asection
*input_section
, bfd
*output_bfd
,
3431 char **error_message ATTRIBUTE_UNUSED
)
3433 /* This part is from bfd_elf_generic_reloc. */
3434 if (output_bfd
!= NULL
3435 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3436 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3438 reloc_entry
->address
+= input_section
->output_offset
;
3439 return bfd_reloc_ok
;
3442 if (output_bfd
!= NULL
)
3443 /* FIXME: See bfd_perform_relocation. Is this right? */
3444 return bfd_reloc_continue
;
3446 return nios2_elf32_do_pcrel_lo16_relocate (
3447 abfd
, reloc_entry
->howto
, input_section
, data
, reloc_entry
->address
,
3448 (symbol
->value
+ symbol
->section
->output_section
->vma
3449 + symbol
->section
->output_offset
),
3450 reloc_entry
->addend
);
3453 static bfd_reloc_status_type
3454 nios2_elf32_pcrel_hiadj16_relocate (bfd
*abfd
, arelent
*reloc_entry
,
3455 asymbol
*symbol
, void *data
,
3456 asection
*input_section
, bfd
*output_bfd
,
3457 char **error_message ATTRIBUTE_UNUSED
)
3459 /* This part is from bfd_elf_generic_reloc. */
3460 if (output_bfd
!= NULL
3461 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3462 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3464 reloc_entry
->address
+= input_section
->output_offset
;
3465 return bfd_reloc_ok
;
3468 if (output_bfd
!= NULL
)
3469 /* FIXME: See bfd_perform_relocation. Is this right? */
3470 return bfd_reloc_continue
;
3472 return nios2_elf32_do_pcrel_hiadj16_relocate (
3473 abfd
, reloc_entry
->howto
, input_section
, data
, reloc_entry
->address
,
3474 (symbol
->value
+ symbol
->section
->output_section
->vma
3475 + symbol
->section
->output_offset
),
3476 reloc_entry
->addend
);
3479 static bfd_reloc_status_type
3480 nios2_elf32_pcrel16_relocate (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
3481 void *data
, asection
*input_section
,
3483 char **error_message ATTRIBUTE_UNUSED
)
3485 /* This part is from bfd_elf_generic_reloc. */
3486 if (output_bfd
!= NULL
3487 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3488 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3490 reloc_entry
->address
+= input_section
->output_offset
;
3491 return bfd_reloc_ok
;
3494 if (output_bfd
!= NULL
)
3495 /* FIXME: See bfd_perform_relocation. Is this right? */
3496 return bfd_reloc_continue
;
3498 return nios2_elf32_do_pcrel16_relocate (abfd
, reloc_entry
->howto
,
3500 data
, reloc_entry
->address
,
3502 + symbol
->section
->output_section
->vma
3503 + symbol
->section
->output_offset
),
3504 reloc_entry
->addend
);
3507 static bfd_reloc_status_type
3508 nios2_elf32_call26_relocate (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
3509 void *data
, asection
*input_section
,
3511 char **error_message ATTRIBUTE_UNUSED
)
3513 /* This part is from bfd_elf_generic_reloc. */
3514 if (output_bfd
!= NULL
3515 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3516 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3518 reloc_entry
->address
+= input_section
->output_offset
;
3519 return bfd_reloc_ok
;
3522 if (output_bfd
!= NULL
)
3523 /* FIXME: See bfd_perform_relocation. Is this right? */
3524 return bfd_reloc_continue
;
3526 return nios2_elf32_do_call26_relocate (abfd
, reloc_entry
->howto
,
3528 data
, reloc_entry
->address
,
3530 + symbol
->section
->output_section
->vma
3531 + symbol
->section
->output_offset
),
3532 reloc_entry
->addend
);
3535 static bfd_reloc_status_type
3536 nios2_elf32_gprel_relocate (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
3537 void *data
, asection
*input_section
,
3538 bfd
*output_bfd
, char **msg
)
3542 bfd_reloc_status_type r
;
3545 /* This part is from bfd_elf_generic_reloc. */
3546 if (output_bfd
!= NULL
3547 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3548 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3550 reloc_entry
->address
+= input_section
->output_offset
;
3551 return bfd_reloc_ok
;
3554 if (output_bfd
!= NULL
)
3555 /* FIXME: See bfd_perform_relocation. Is this right? */
3556 return bfd_reloc_continue
;
3558 relocation
= (symbol
->value
3559 + symbol
->section
->output_section
->vma
3560 + symbol
->section
->output_offset
);
3562 /* This assumes we've already cached the _gp symbol. */
3563 r
= nios2_elf_final_gp (abfd
, symbol
, FALSE
, msg
, &gp
);
3564 if (r
== bfd_reloc_ok
)
3566 relocation
= relocation
+ reloc_entry
->addend
- gp
;
3567 reloc_entry
->addend
= 0;
3568 if ((signed) relocation
< -32768 || (signed) relocation
> 32767)
3570 *msg
= _("global pointer relative address out of range");
3571 r
= bfd_reloc_outofrange
;
3574 r
= nios2_elf32_do_gprel_relocate (abfd
, reloc_entry
->howto
,
3576 data
, reloc_entry
->address
,
3577 relocation
, reloc_entry
->addend
);
3583 static bfd_reloc_status_type
3584 nios2_elf32_ujmp_relocate (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
3585 void *data
, asection
*input_section
,
3586 bfd
*output_bfd
, char **msg ATTRIBUTE_UNUSED
)
3588 /* This part is from bfd_elf_generic_reloc. */
3589 if (output_bfd
!= NULL
3590 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3591 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3593 reloc_entry
->address
+= input_section
->output_offset
;
3594 return bfd_reloc_ok
;
3597 if (output_bfd
!= NULL
)
3598 /* FIXME: See bfd_perform_relocation. Is this right? */
3599 return bfd_reloc_continue
;
3601 return nios2_elf32_do_ujmp_relocate (abfd
, reloc_entry
->howto
,
3603 data
, reloc_entry
->address
,
3605 + symbol
->section
->output_section
->vma
3606 + symbol
->section
->output_offset
),
3607 reloc_entry
->addend
);
3610 static bfd_reloc_status_type
3611 nios2_elf32_cjmp_relocate (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
3612 void *data
, asection
*input_section
,
3613 bfd
*output_bfd
, char **msg ATTRIBUTE_UNUSED
)
3615 /* This part is from bfd_elf_generic_reloc. */
3616 if (output_bfd
!= NULL
3617 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3618 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3620 reloc_entry
->address
+= input_section
->output_offset
;
3621 return bfd_reloc_ok
;
3624 if (output_bfd
!= NULL
)
3625 /* FIXME: See bfd_perform_relocation. Is this right? */
3626 return bfd_reloc_continue
;
3628 return nios2_elf32_do_cjmp_relocate (abfd
, reloc_entry
->howto
,
3630 data
, reloc_entry
->address
,
3632 + symbol
->section
->output_section
->vma
3633 + symbol
->section
->output_offset
),
3634 reloc_entry
->addend
);
3637 static bfd_reloc_status_type
3638 nios2_elf32_callr_relocate (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
3639 void *data
, asection
*input_section
,
3640 bfd
*output_bfd
, char **msg ATTRIBUTE_UNUSED
)
3642 /* This part is from bfd_elf_generic_reloc. */
3643 if (output_bfd
!= NULL
3644 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3645 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3647 reloc_entry
->address
+= input_section
->output_offset
;
3648 return bfd_reloc_ok
;
3651 if (output_bfd
!= NULL
)
3652 /* FIXME: See bfd_perform_relocation. Is this right? */
3653 return bfd_reloc_continue
;
3655 return nios2_elf32_do_callr_relocate (abfd
, reloc_entry
->howto
,
3657 data
, reloc_entry
->address
,
3659 + symbol
->section
->output_section
->vma
3660 + symbol
->section
->output_offset
),
3661 reloc_entry
->addend
);
3665 /* Implement elf_backend_relocate_section. */
3667 nios2_elf32_relocate_section (bfd
*output_bfd
,
3668 struct bfd_link_info
*info
,
3670 asection
*input_section
,
3672 Elf_Internal_Rela
*relocs
,
3673 Elf_Internal_Sym
*local_syms
,
3674 asection
**local_sections
)
3676 Elf_Internal_Shdr
*symtab_hdr
;
3677 struct elf_link_hash_entry
**sym_hashes
;
3678 Elf_Internal_Rela
*rel
;
3679 Elf_Internal_Rela
*relend
;
3680 struct elf32_nios2_link_hash_table
*htab
;
3683 asection
*sreloc
= NULL
;
3684 bfd_vma
*local_got_offsets
;
3687 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3688 sym_hashes
= elf_sym_hashes (input_bfd
);
3689 relend
= relocs
+ input_section
->reloc_count
;
3691 htab
= elf32_nios2_hash_table (info
);
3692 sgot
= htab
->root
.sgot
;
3693 splt
= htab
->root
.splt
;
3694 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3696 if (htab
->h_gp_got
== NULL
)
3699 got_base
= htab
->h_gp_got
->root
.u
.def
.value
;
3701 for (rel
= relocs
; rel
< relend
; rel
++)
3703 reloc_howto_type
*howto
;
3704 unsigned long r_symndx
;
3705 Elf_Internal_Sym
*sym
;
3707 struct elf_link_hash_entry
*h
;
3708 struct elf32_nios2_link_hash_entry
*eh
;
3711 bfd_reloc_status_type r
= bfd_reloc_ok
;
3712 const char *name
= NULL
;
3716 const char* msg
= (const char*) NULL
;
3717 bfd_boolean unresolved_reloc
;
3721 r_type
= ELF32_R_TYPE (rel
->r_info
);
3722 r_symndx
= ELF32_R_SYM (rel
->r_info
);
3724 howto
= lookup_howto ((unsigned) ELF32_R_TYPE (rel
->r_info
), output_bfd
);
3729 if (r_symndx
< symtab_hdr
->sh_info
)
3731 sym
= local_syms
+ r_symndx
;
3732 sec
= local_sections
[r_symndx
];
3733 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
3737 bfd_boolean warned
, ignored
;
3739 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3740 r_symndx
, symtab_hdr
, sym_hashes
,
3742 unresolved_reloc
, warned
, ignored
);
3745 if (sec
&& discarded_section (sec
))
3746 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3747 rel
, 1, relend
, howto
, 0, contents
);
3749 /* Nothing more to do unless this is a final link. */
3750 if (bfd_link_relocatable (info
))
3755 bfd_boolean resolved_to_zero
;
3757 resolved_to_zero
= (h
!= NULL
3758 && UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
));
3759 switch (howto
->type
)
3762 r
= nios2_elf32_do_hi16_relocate (input_bfd
, howto
,
3764 contents
, rel
->r_offset
,
3765 relocation
, rel
->r_addend
);
3768 r
= nios2_elf32_do_lo16_relocate (input_bfd
, howto
,
3770 contents
, rel
->r_offset
,
3771 relocation
, rel
->r_addend
);
3773 case R_NIOS2_PCREL_LO
:
3774 r
= nios2_elf32_do_pcrel_lo16_relocate (input_bfd
, howto
,
3781 case R_NIOS2_HIADJ16
:
3782 r
= nios2_elf32_do_hiadj16_relocate (input_bfd
, howto
,
3783 input_section
, contents
,
3784 rel
->r_offset
, relocation
,
3787 case R_NIOS2_PCREL_HA
:
3788 r
= nios2_elf32_do_pcrel_hiadj16_relocate (input_bfd
, howto
,
3795 case R_NIOS2_PCREL16
:
3796 r
= nios2_elf32_do_pcrel16_relocate (input_bfd
, howto
,
3797 input_section
, contents
,
3798 rel
->r_offset
, relocation
,
3802 /* Turns an absolute address into a gp-relative address. */
3803 if (!nios2_elf_assign_gp (output_bfd
, &gp
, info
))
3805 bfd_vma reloc_address
;
3807 if (sec
&& sec
->output_section
)
3808 reloc_address
= (sec
->output_section
->vma
3809 + sec
->output_offset
3814 format
= _("global pointer relative relocation at address "
3815 "0x%08x when _gp not defined\n");
3816 sprintf (msgbuf
, format
, reloc_address
);
3818 r
= bfd_reloc_dangerous
;
3822 bfd_vma symbol_address
= rel
->r_addend
+ relocation
;
3823 relocation
= symbol_address
- gp
;
3825 if (((signed) relocation
< -32768
3826 || (signed) relocation
> 32767)
3828 || h
->root
.type
== bfd_link_hash_defined
3829 || h
->root
.type
== bfd_link_hash_defweak
))
3832 name
= h
->root
.root
.string
;
3833 /* xgettext:c-format */
3834 format
= _("Unable to reach %s (at 0x%08x) from the "
3835 "global pointer (at 0x%08x) because the "
3836 "offset (%d) is out of the allowed range, "
3837 "-32678 to 32767.\n" );
3838 sprintf (msgbuf
, format
, name
, symbol_address
, gp
,
3839 (signed)relocation
);
3841 r
= bfd_reloc_outofrange
;
3844 r
= _bfd_final_link_relocate (howto
, input_bfd
,
3845 input_section
, contents
,
3846 rel
->r_offset
, relocation
,
3851 r
= nios2_elf32_do_ujmp_relocate (input_bfd
, howto
,
3853 contents
, rel
->r_offset
,
3854 relocation
, rel
->r_addend
);
3857 r
= nios2_elf32_do_cjmp_relocate (input_bfd
, howto
,
3859 contents
, rel
->r_offset
,
3860 relocation
, rel
->r_addend
);
3863 r
= nios2_elf32_do_callr_relocate (input_bfd
, howto
,
3864 input_section
, contents
,
3865 rel
->r_offset
, relocation
,
3868 case R_NIOS2_CALL26
:
3869 case R_NIOS2_CALL26_NOAT
:
3870 /* If we have a call to an undefined weak symbol, we just want
3871 to stuff a zero in the bits of the call instruction and
3872 bypass the normal call26 relocation handling, because it'll
3873 diagnose an overflow error if address 0 isn't in the same
3874 256MB segment as the call site. Presumably the call
3875 should be guarded by a null check anyway. */
3876 if (h
!= NULL
&& h
->root
.type
== bfd_link_hash_undefweak
)
3878 BFD_ASSERT (relocation
== 0 && rel
->r_addend
== 0);
3879 r
= _bfd_final_link_relocate (howto
, input_bfd
,
3880 input_section
, contents
,
3881 rel
->r_offset
, relocation
,
3885 /* Handle relocations which should use the PLT entry.
3886 NIOS2_BFD_RELOC_32 relocations will use the symbol's value,
3887 which may point to a PLT entry, but we don't need to handle
3888 that here. If we created a PLT entry, all branches in this
3889 object should go to it. */
3890 if (h
!= NULL
&& splt
!= NULL
&& h
->plt
.offset
!= (bfd_vma
) -1)
3892 /* If we've created a .plt section, and assigned a PLT entry
3893 to this function, it should not be known to bind locally.
3894 If it were, we would have cleared the PLT entry. */
3895 BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info
, h
));
3897 relocation
= (splt
->output_section
->vma
3898 + splt
->output_offset
3901 unresolved_reloc
= FALSE
;
3903 /* Detect R_NIOS2_CALL26 relocations that would overflow the
3904 256MB segment. Replace the target with a reference to a
3906 Note that htab->stub_group is null if relaxation has been
3907 disabled by the --no-relax linker command-line option, so
3908 we can use that to skip this processing entirely. */
3909 if (howto
->type
== R_NIOS2_CALL26
&& htab
->stub_group
)
3911 bfd_vma dest
= relocation
+ rel
->r_addend
;
3912 enum elf32_nios2_stub_type stub_type
;
3914 eh
= (struct elf32_nios2_link_hash_entry
*)h
;
3915 stub_type
= nios2_type_of_stub (input_section
, rel
, eh
,
3918 if (stub_type
!= nios2_stub_none
)
3920 struct elf32_nios2_stub_hash_entry
*hsh
;
3922 hsh
= nios2_get_stub_entry (input_section
, sec
,
3923 eh
, rel
, htab
, stub_type
);
3926 r
= bfd_reloc_undefined
;
3930 dest
= (hsh
->stub_offset
3931 + hsh
->stub_sec
->output_offset
3932 + hsh
->stub_sec
->output_section
->vma
);
3933 r
= nios2_elf32_do_call26_relocate (input_bfd
, howto
,
3943 r
= nios2_elf32_do_call26_relocate (input_bfd
, howto
,
3944 input_section
, contents
,
3945 rel
->r_offset
, relocation
,
3950 /* For symmetry this would be
3951 r = nios2_elf32_do_ignore_reloc (input_bfd, howto,
3952 input_section, contents,
3953 rel->r_offset, relocation,
3955 but do_ignore_reloc would do no more than return
3960 case R_NIOS2_CALL16
:
3961 case R_NIOS2_GOT_LO
:
3962 case R_NIOS2_GOT_HA
:
3963 case R_NIOS2_CALL_LO
:
3964 case R_NIOS2_CALL_HA
:
3965 /* Relocation is to the entry for this symbol in the
3966 global offset table. */
3969 r
= bfd_reloc_notsupported
;
3979 eh
= (struct elf32_nios2_link_hash_entry
*)h
;
3980 use_plt
= (eh
->got_types_used
== CALL_USED
3981 && h
->plt
.offset
!= (bfd_vma
) -1);
3983 off
= h
->got
.offset
;
3984 BFD_ASSERT (off
!= (bfd_vma
) -1);
3985 dyn
= htab
->root
.dynamic_sections_created
;
3986 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
3987 bfd_link_pic (info
),
3989 || (bfd_link_pic (info
)
3990 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3991 || ((ELF_ST_VISIBILITY (h
->other
)
3992 || resolved_to_zero
)
3993 && h
->root
.type
== bfd_link_hash_undefweak
))
3995 /* This is actually a static link, or it is a -Bsymbolic
3996 link and the symbol is defined locally. We must
3997 initialize this entry in the global offset table.
3998 Since the offset must always be a multiple of 4, we
3999 use the least significant bit to record whether we
4000 have initialized it already.
4002 When doing a dynamic link, we create a .rela.got
4003 relocation entry to initialize the value. This is
4004 done in the finish_dynamic_symbol routine. */
4009 bfd_put_32 (output_bfd
, relocation
,
4010 sgot
->contents
+ off
);
4015 unresolved_reloc
= FALSE
;
4019 BFD_ASSERT (local_got_offsets
!= NULL
4020 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
4022 off
= local_got_offsets
[r_symndx
];
4024 /* The offset must always be a multiple of 4. We use the
4025 least significant bit to record whether we have already
4026 generated the necessary reloc. */
4031 bfd_put_32 (output_bfd
, relocation
,
4032 sgot
->contents
+ off
);
4034 if (bfd_link_pic (info
))
4037 Elf_Internal_Rela outrel
;
4040 srelgot
= htab
->root
.srelgot
;
4041 BFD_ASSERT (srelgot
!= NULL
);
4043 outrel
.r_addend
= relocation
;
4044 outrel
.r_offset
= (sgot
->output_section
->vma
4045 + sgot
->output_offset
4047 outrel
.r_info
= ELF32_R_INFO (0, R_NIOS2_RELATIVE
);
4048 loc
= srelgot
->contents
;
4049 loc
+= (srelgot
->reloc_count
++ *
4050 sizeof (Elf32_External_Rela
));
4051 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4054 local_got_offsets
[r_symndx
] |= 1;
4058 if (use_plt
&& bfd_link_pic (info
))
4060 off
= ((h
->plt
.offset
- 24) / 12 + 3) * 4;
4061 relocation
= (htab
->root
.sgotplt
->output_offset
+ off
4065 relocation
= sgot
->output_offset
+ off
- got_base
;
4067 /* This relocation does not use the addend. */
4070 switch (howto
->type
)
4072 case R_NIOS2_GOT_LO
:
4073 case R_NIOS2_CALL_LO
:
4074 r
= nios2_elf32_do_lo16_relocate (input_bfd
, howto
,
4075 input_section
, contents
,
4076 rel
->r_offset
, relocation
,
4079 case R_NIOS2_GOT_HA
:
4080 case R_NIOS2_CALL_HA
:
4081 r
= nios2_elf32_do_hiadj16_relocate (input_bfd
, howto
,
4082 input_section
, contents
,
4088 r
= _bfd_final_link_relocate (howto
, input_bfd
,
4089 input_section
, contents
,
4090 rel
->r_offset
, relocation
,
4096 case R_NIOS2_GOTOFF_LO
:
4097 case R_NIOS2_GOTOFF_HA
:
4098 case R_NIOS2_GOTOFF
:
4099 /* Relocation is relative to the global offset table pointer. */
4101 BFD_ASSERT (sgot
!= NULL
);
4104 r
= bfd_reloc_notsupported
;
4108 /* Note that sgot->output_offset is not involved in this
4109 calculation. We always want the start of .got. */
4110 relocation
-= sgot
->output_section
->vma
;
4112 /* Now we adjust the relocation to be relative to the GOT pointer
4113 (the _gp_got symbol), which possibly contains the 0x8000 bias. */
4114 relocation
-= got_base
;
4116 switch (howto
->type
)
4118 case R_NIOS2_GOTOFF_LO
:
4119 r
= nios2_elf32_do_lo16_relocate (input_bfd
, howto
,
4120 input_section
, contents
,
4121 rel
->r_offset
, relocation
,
4124 case R_NIOS2_GOTOFF_HA
:
4125 r
= nios2_elf32_do_hiadj16_relocate (input_bfd
, howto
,
4126 input_section
, contents
,
4132 r
= _bfd_final_link_relocate (howto
, input_bfd
,
4133 input_section
, contents
,
4134 rel
->r_offset
, relocation
,
4140 case R_NIOS2_TLS_LDO16
:
4141 relocation
-= dtpoff_base (info
) + DTP_OFFSET
;
4143 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4144 contents
, rel
->r_offset
,
4145 relocation
, rel
->r_addend
);
4147 case R_NIOS2_TLS_LDM16
:
4148 if (htab
->root
.sgot
== NULL
)
4151 off
= htab
->tls_ldm_got
.offset
;
4157 /* If we don't know the module number, create a relocation
4159 if (bfd_link_pic (info
))
4161 Elf_Internal_Rela outrel
;
4164 if (htab
->root
.srelgot
== NULL
)
4167 outrel
.r_addend
= 0;
4168 outrel
.r_offset
= (htab
->root
.sgot
->output_section
->vma
4169 + htab
->root
.sgot
->output_offset
4171 outrel
.r_info
= ELF32_R_INFO (0, R_NIOS2_TLS_DTPMOD
);
4173 loc
= htab
->root
.srelgot
->contents
;
4174 loc
+= (htab
->root
.srelgot
->reloc_count
++
4175 * sizeof (Elf32_External_Rela
));
4176 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4179 bfd_put_32 (output_bfd
, 1,
4180 htab
->root
.sgot
->contents
+ off
);
4182 htab
->tls_ldm_got
.offset
|= 1;
4185 relocation
= htab
->root
.sgot
->output_offset
+ off
- got_base
;
4187 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4188 contents
, rel
->r_offset
,
4189 relocation
, rel
->r_addend
);
4192 case R_NIOS2_TLS_GD16
:
4193 case R_NIOS2_TLS_IE16
:
4198 if (htab
->root
.sgot
== NULL
)
4205 dyn
= htab
->root
.dynamic_sections_created
;
4206 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
4207 bfd_link_pic (info
),
4209 && (!bfd_link_pic (info
)
4210 || !SYMBOL_REFERENCES_LOCAL (info
, h
)))
4212 unresolved_reloc
= FALSE
;
4215 off
= h
->got
.offset
;
4216 tls_type
= (((struct elf32_nios2_link_hash_entry
*) h
)
4221 if (local_got_offsets
== NULL
)
4223 off
= local_got_offsets
[r_symndx
];
4224 tls_type
= (elf32_nios2_local_got_tls_type (input_bfd
)
4228 if (tls_type
== GOT_UNKNOWN
)
4235 bfd_boolean need_relocs
= FALSE
;
4236 Elf_Internal_Rela outrel
;
4237 bfd_byte
*loc
= NULL
;
4240 /* The GOT entries have not been initialized yet. Do it
4241 now, and emit any relocations. If both an IE GOT and a
4242 GD GOT are necessary, we emit the GD first. */
4244 if ((bfd_link_pic (info
) || indx
!= 0)
4246 || (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4247 && !resolved_to_zero
)
4248 || h
->root
.type
!= bfd_link_hash_undefweak
))
4251 if (htab
->root
.srelgot
== NULL
)
4253 loc
= htab
->root
.srelgot
->contents
;
4254 loc
+= (htab
->root
.srelgot
->reloc_count
*
4255 sizeof (Elf32_External_Rela
));
4258 if (tls_type
& GOT_TLS_GD
)
4262 outrel
.r_addend
= 0;
4263 outrel
.r_offset
= (htab
->root
.sgot
->output_section
->vma
4264 + htab
->root
.sgot
->output_offset
4266 outrel
.r_info
= ELF32_R_INFO (indx
,
4267 R_NIOS2_TLS_DTPMOD
);
4269 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
4271 htab
->root
.srelgot
->reloc_count
++;
4272 loc
+= sizeof (Elf32_External_Rela
);
4275 bfd_put_32 (output_bfd
,
4276 (relocation
- dtpoff_base (info
) -
4278 htab
->root
.sgot
->contents
+ cur_off
+ 4);
4281 outrel
.r_addend
= 0;
4282 outrel
.r_info
= ELF32_R_INFO (indx
,
4283 R_NIOS2_TLS_DTPREL
);
4284 outrel
.r_offset
+= 4;
4286 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
4288 htab
->root
.srelgot
->reloc_count
++;
4289 loc
+= sizeof (Elf32_External_Rela
);
4294 /* If we are not emitting relocations for a
4295 general dynamic reference, then we must be in a
4296 static link or an executable link with the
4297 symbol binding locally. Mark it as belonging
4298 to module 1, the executable. */
4299 bfd_put_32 (output_bfd
, 1,
4300 htab
->root
.sgot
->contents
+ cur_off
);
4301 bfd_put_32 (output_bfd
, (relocation
-
4302 dtpoff_base (info
) -
4304 htab
->root
.sgot
->contents
+ cur_off
+ 4);
4310 if (tls_type
& GOT_TLS_IE
)
4315 outrel
.r_addend
= (relocation
-
4316 dtpoff_base (info
));
4318 outrel
.r_addend
= 0;
4319 outrel
.r_offset
= (htab
->root
.sgot
->output_section
->vma
4320 + htab
->root
.sgot
->output_offset
4322 outrel
.r_info
= ELF32_R_INFO (indx
,
4325 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
4327 htab
->root
.srelgot
->reloc_count
++;
4328 loc
+= sizeof (Elf32_External_Rela
);
4331 bfd_put_32 (output_bfd
, (tpoff (info
, relocation
)
4333 htab
->root
.sgot
->contents
+ cur_off
);
4340 local_got_offsets
[r_symndx
] |= 1;
4343 if ((tls_type
& GOT_TLS_GD
) && r_type
!= R_NIOS2_TLS_GD16
)
4345 relocation
= htab
->root
.sgot
->output_offset
+ off
- got_base
;
4347 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4348 contents
, rel
->r_offset
,
4349 relocation
, rel
->r_addend
);
4353 case R_NIOS2_TLS_LE16
:
4354 if (bfd_link_dll (info
))
4357 /* xgettext:c-format */
4358 (_("%pB(%pA+%#Lx): %s relocation not "
4359 "permitted in shared object"),
4360 input_bfd
, input_section
,
4361 rel
->r_offset
, howto
->name
);
4365 relocation
= tpoff (info
, relocation
) - TP_OFFSET
;
4367 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4368 contents
, rel
->r_offset
,
4369 relocation
, rel
->r_addend
);
4372 case R_NIOS2_BFD_RELOC_32
:
4373 if (bfd_link_pic (info
)
4374 && (input_section
->flags
& SEC_ALLOC
) != 0
4376 || (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4377 && !resolved_to_zero
)
4378 || h
->root
.type
!= bfd_link_hash_undefweak
))
4380 Elf_Internal_Rela outrel
;
4382 bfd_boolean skip
, relocate
;
4384 /* When generating a shared object, these relocations
4385 are copied into the output file to be resolved at run
4392 = _bfd_elf_section_offset (output_bfd
, info
,
4393 input_section
, rel
->r_offset
);
4394 if (outrel
.r_offset
== (bfd_vma
) -1)
4396 else if (outrel
.r_offset
== (bfd_vma
) -2)
4397 skip
= TRUE
, relocate
= TRUE
;
4398 outrel
.r_offset
+= (input_section
->output_section
->vma
4399 + input_section
->output_offset
);
4402 memset (&outrel
, 0, sizeof outrel
);
4405 && (!bfd_link_pic (info
)
4406 || !SYMBOLIC_BIND (info
, h
)
4407 || !h
->def_regular
))
4409 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
4410 outrel
.r_addend
= rel
->r_addend
;
4414 /* This symbol is local, or marked to become local. */
4415 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4417 outrel
.r_info
= ELF32_R_INFO (0, R_NIOS2_RELATIVE
);
4420 sreloc
= elf_section_data (input_section
)->sreloc
;
4424 loc
= sreloc
->contents
;
4425 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4426 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4428 /* This reloc will be computed at runtime, so there's no
4429 need to do anything now, except for R_NIOS2_BFD_RELOC_32
4430 relocations that have been turned into
4431 R_NIOS2_RELATIVE. */
4436 r
= _bfd_final_link_relocate (howto
, input_bfd
,
4437 input_section
, contents
,
4438 rel
->r_offset
, relocation
,
4442 case R_NIOS2_TLS_DTPREL
:
4443 relocation
-= dtpoff_base (info
);
4447 r
= _bfd_final_link_relocate (howto
, input_bfd
,
4448 input_section
, contents
,
4449 rel
->r_offset
, relocation
,
4455 r
= bfd_reloc_notsupported
;
4457 if (r
!= bfd_reloc_ok
)
4460 name
= h
->root
.root
.string
;
4463 name
= bfd_elf_string_from_elf_section (input_bfd
,
4464 symtab_hdr
->sh_link
,
4466 if (name
== NULL
|| *name
== '\0')
4467 name
= bfd_section_name (input_bfd
, sec
);
4472 case bfd_reloc_overflow
:
4473 (*info
->callbacks
->reloc_overflow
) (info
, NULL
, name
,
4474 howto
->name
, (bfd_vma
) 0,
4475 input_bfd
, input_section
,
4479 case bfd_reloc_undefined
:
4480 (*info
->callbacks
->undefined_symbol
) (info
, name
, input_bfd
,
4482 rel
->r_offset
, TRUE
);
4485 case bfd_reloc_outofrange
:
4487 msg
= _("relocation out of range");
4490 case bfd_reloc_notsupported
:
4492 msg
= _("unsupported relocation");
4495 case bfd_reloc_dangerous
:
4497 msg
= _("dangerous relocation");
4502 msg
= _("unknown error");
4508 (*info
->callbacks
->warning
) (info
, msg
, name
, input_bfd
,
4509 input_section
, rel
->r_offset
);
4517 /* Implement elf-backend_section_flags:
4518 Convert NIOS2 specific section flags to bfd internal section flags. */
4520 nios2_elf32_section_flags (flagword
*flags
, const Elf_Internal_Shdr
*hdr
)
4522 if (hdr
->sh_flags
& SHF_NIOS2_GPREL
)
4523 *flags
|= SEC_SMALL_DATA
;
4528 /* Implement elf_backend_fake_sections:
4529 Set the correct type for an NIOS2 ELF section. We do this by the
4530 section name, which is a hack, but ought to work. */
4532 nios2_elf32_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
4533 Elf_Internal_Shdr
*hdr
, asection
*sec
)
4535 register const char *name
= bfd_get_section_name (abfd
, sec
);
4537 if ((sec
->flags
& SEC_SMALL_DATA
)
4538 || strcmp (name
, ".sdata") == 0
4539 || strcmp (name
, ".sbss") == 0
4540 || strcmp (name
, ".lit4") == 0 || strcmp (name
, ".lit8") == 0)
4541 hdr
->sh_flags
|= SHF_NIOS2_GPREL
;
4546 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
4547 shortcuts to them in our hash table. */
4549 create_got_section (bfd
*dynobj
, struct bfd_link_info
*info
)
4551 struct elf32_nios2_link_hash_table
*htab
;
4552 struct elf_link_hash_entry
*h
;
4554 htab
= elf32_nios2_hash_table (info
);
4556 if (! _bfd_elf_create_got_section (dynobj
, info
))
4559 /* In order for the two loads in .PLTresolve to share the same %hiadj,
4560 _GLOBAL_OFFSET_TABLE_ must be aligned to a 16-byte boundary. */
4561 if (!bfd_set_section_alignment (dynobj
, htab
->root
.sgotplt
, 4))
4564 /* The Nios II ABI specifies that GOT-relative relocations are relative
4565 to the linker-created symbol _gp_got, rather than using
4566 _GLOBAL_OFFSET_TABLE_ directly. In particular, the latter always
4567 points to the base of the GOT while _gp_got may include a bias. */
4568 h
= _bfd_elf_define_linkage_sym (dynobj
, info
, htab
->root
.sgotplt
,
4577 /* Implement elf_backend_create_dynamic_sections:
4578 Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
4579 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
4582 nios2_elf32_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
4584 struct elf32_nios2_link_hash_table
*htab
;
4586 htab
= elf32_nios2_hash_table (info
);
4587 if (!htab
->root
.sgot
&& !create_got_section (dynobj
, info
))
4590 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
4593 /* In order for the two loads in a shared object .PLTresolve to share the
4594 same %hiadj, the start of the PLT (as well as the GOT) must be aligned
4595 to a 16-byte boundary. This is because the addresses for these loads
4596 include the -(.plt+4) PIC correction. */
4597 return bfd_set_section_alignment (dynobj
, htab
->root
.splt
, 4);
4600 /* Implement elf_backend_copy_indirect_symbol:
4601 Copy the extra info we tack onto an elf_link_hash_entry. */
4603 nios2_elf32_copy_indirect_symbol (struct bfd_link_info
*info
,
4604 struct elf_link_hash_entry
*dir
,
4605 struct elf_link_hash_entry
*ind
)
4607 struct elf32_nios2_link_hash_entry
*edir
, *eind
;
4609 edir
= (struct elf32_nios2_link_hash_entry
*) dir
;
4610 eind
= (struct elf32_nios2_link_hash_entry
*) ind
;
4612 if (eind
->dyn_relocs
!= NULL
)
4614 if (edir
->dyn_relocs
!= NULL
)
4616 struct elf_dyn_relocs
**pp
;
4617 struct elf_dyn_relocs
*p
;
4619 /* Add reloc counts against the indirect sym to the direct sym
4620 list. Merge any entries against the same section. */
4621 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
4623 struct elf_dyn_relocs
*q
;
4625 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
4626 if (q
->sec
== p
->sec
)
4628 q
->pc_count
+= p
->pc_count
;
4629 q
->count
+= p
->count
;
4636 *pp
= edir
->dyn_relocs
;
4639 edir
->dyn_relocs
= eind
->dyn_relocs
;
4640 eind
->dyn_relocs
= NULL
;
4643 if (ind
->root
.type
== bfd_link_hash_indirect
4644 && dir
->got
.refcount
<= 0)
4646 edir
->tls_type
= eind
->tls_type
;
4647 eind
->tls_type
= GOT_UNKNOWN
;
4650 edir
->got_types_used
|= eind
->got_types_used
;
4652 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
4655 /* Set the right machine number for a NIOS2 ELF file. */
4658 nios2_elf32_object_p (bfd
*abfd
)
4662 mach
= elf_elfheader (abfd
)->e_flags
;
4667 case EF_NIOS2_ARCH_R1
:
4668 bfd_default_set_arch_mach (abfd
, bfd_arch_nios2
, bfd_mach_nios2r1
);
4670 case EF_NIOS2_ARCH_R2
:
4671 bfd_default_set_arch_mach (abfd
, bfd_arch_nios2
, bfd_mach_nios2r2
);
4678 /* Implement elf_backend_check_relocs:
4679 Look through the relocs for a section during the first phase. */
4681 nios2_elf32_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
4682 asection
*sec
, const Elf_Internal_Rela
*relocs
)
4684 Elf_Internal_Shdr
*symtab_hdr
;
4685 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
4686 const Elf_Internal_Rela
*rel
;
4687 const Elf_Internal_Rela
*rel_end
;
4688 struct elf32_nios2_link_hash_table
*htab
;
4689 asection
*sreloc
= NULL
;
4690 bfd_signed_vma
*local_got_refcounts
;
4692 if (bfd_link_relocatable (info
))
4695 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4696 sym_hashes
= elf_sym_hashes (abfd
);
4697 sym_hashes_end
= (sym_hashes
4698 + symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
));
4699 if (!elf_bad_symtab (abfd
))
4700 sym_hashes_end
-= symtab_hdr
->sh_info
;
4701 local_got_refcounts
= elf_local_got_refcounts (abfd
);
4703 htab
= elf32_nios2_hash_table (info
);
4705 rel_end
= relocs
+ sec
->reloc_count
;
4706 for (rel
= relocs
; rel
< rel_end
; rel
++)
4708 unsigned int r_type
;
4709 struct elf_link_hash_entry
*h
;
4710 unsigned long r_symndx
;
4712 r_symndx
= ELF32_R_SYM (rel
->r_info
);
4713 if (r_symndx
< symtab_hdr
->sh_info
)
4717 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
4718 while (h
->root
.type
== bfd_link_hash_indirect
4719 || h
->root
.type
== bfd_link_hash_warning
)
4720 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4723 r_type
= ELF32_R_TYPE (rel
->r_info
);
4728 case R_NIOS2_GOT_LO
:
4729 case R_NIOS2_GOT_HA
:
4730 case R_NIOS2_CALL16
:
4731 case R_NIOS2_CALL_LO
:
4732 case R_NIOS2_CALL_HA
:
4733 case R_NIOS2_TLS_GD16
:
4734 case R_NIOS2_TLS_IE16
:
4735 /* This symbol requires a global offset table entry. */
4737 int tls_type
, old_tls_type
;
4743 case R_NIOS2_GOT_LO
:
4744 case R_NIOS2_GOT_HA
:
4745 case R_NIOS2_CALL16
:
4746 case R_NIOS2_CALL_LO
:
4747 case R_NIOS2_CALL_HA
:
4748 tls_type
= GOT_NORMAL
;
4750 case R_NIOS2_TLS_GD16
:
4751 tls_type
= GOT_TLS_GD
;
4753 case R_NIOS2_TLS_IE16
:
4754 tls_type
= GOT_TLS_IE
;
4760 struct elf32_nios2_link_hash_entry
*eh
4761 = (struct elf32_nios2_link_hash_entry
*)h
;
4763 old_tls_type
= elf32_nios2_hash_entry(h
)->tls_type
;
4764 if (r_type
== R_NIOS2_CALL16
4765 || r_type
== R_NIOS2_CALL_LO
4766 || r_type
== R_NIOS2_CALL_HA
)
4768 /* Make sure a plt entry is created for this symbol if
4769 it turns out to be a function defined by a dynamic
4774 eh
->got_types_used
|= CALL_USED
;
4777 eh
->got_types_used
|= GOT_USED
;
4781 /* This is a global offset table entry for a local symbol. */
4782 if (local_got_refcounts
== NULL
)
4786 size
= symtab_hdr
->sh_info
;
4787 size
*= (sizeof (bfd_signed_vma
) + sizeof (char));
4789 = ((bfd_signed_vma
*) bfd_zalloc (abfd
, size
));
4790 if (local_got_refcounts
== NULL
)
4792 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
4793 elf32_nios2_local_got_tls_type (abfd
)
4794 = (char *) (local_got_refcounts
+ symtab_hdr
->sh_info
);
4796 local_got_refcounts
[r_symndx
]++;
4797 old_tls_type
= elf32_nios2_local_got_tls_type (abfd
) [r_symndx
];
4800 /* We will already have issued an error message if there is a
4801 TLS / non-TLS mismatch, based on the symbol type. We don't
4802 support any linker relaxations. So just combine any TLS
4804 if (old_tls_type
!= GOT_UNKNOWN
&& old_tls_type
!= GOT_NORMAL
4805 && tls_type
!= GOT_NORMAL
)
4806 tls_type
|= old_tls_type
;
4808 if (old_tls_type
!= tls_type
)
4811 elf32_nios2_hash_entry (h
)->tls_type
= tls_type
;
4813 elf32_nios2_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
4817 if (htab
->root
.sgot
== NULL
)
4819 if (htab
->root
.dynobj
== NULL
)
4820 htab
->root
.dynobj
= abfd
;
4821 if (!create_got_section (htab
->root
.dynobj
, info
))
4826 case R_NIOS2_TLS_LDM16
:
4827 htab
->tls_ldm_got
.refcount
++;
4830 /* This relocation describes the C++ object vtable hierarchy.
4831 Reconstruct it for later use during GC. */
4832 case R_NIOS2_GNU_VTINHERIT
:
4833 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
4837 /* This relocation describes which C++ vtable entries are actually
4838 used. Record for later use during GC. */
4839 case R_NIOS2_GNU_VTENTRY
:
4840 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
4844 case R_NIOS2_BFD_RELOC_32
:
4845 case R_NIOS2_CALL26
:
4846 case R_NIOS2_CALL26_NOAT
:
4847 case R_NIOS2_HIADJ16
:
4852 /* If this reloc is in a read-only section, we might
4853 need a copy reloc. We can't check reliably at this
4854 stage whether the section is read-only, as input
4855 sections have not yet been mapped to output sections.
4856 Tentatively set the flag for now, and correct in
4857 adjust_dynamic_symbol. */
4858 if (!bfd_link_pic (info
))
4861 /* Make sure a plt entry is created for this symbol if it
4862 turns out to be a function defined by a dynamic object. */
4865 if (r_type
== R_NIOS2_CALL26
|| r_type
== R_NIOS2_CALL26_NOAT
)
4869 /* If we are creating a shared library, we need to copy the
4870 reloc into the shared library. */
4871 if (bfd_link_pic (info
)
4872 && (sec
->flags
& SEC_ALLOC
) != 0
4873 && (r_type
== R_NIOS2_BFD_RELOC_32
4874 || (h
!= NULL
&& ! h
->needs_plt
4875 && (! SYMBOLIC_BIND (info
, h
) || ! h
->def_regular
))))
4877 struct elf_dyn_relocs
*p
;
4878 struct elf_dyn_relocs
**head
;
4880 /* When creating a shared object, we must copy these
4881 reloc types into the output file. We create a reloc
4882 section in dynobj and make room for this reloc. */
4885 if (htab
->root
.dynobj
== NULL
)
4886 htab
->root
.dynobj
= abfd
;
4888 sreloc
= _bfd_elf_make_dynamic_reloc_section
4889 (sec
, htab
->root
.dynobj
, 2, abfd
, TRUE
);
4894 /* If this is a global symbol, we count the number of
4895 relocations we need for this symbol. */
4897 head
= &((struct elf32_nios2_link_hash_entry
*) h
)->dyn_relocs
;
4900 /* Track dynamic relocs needed for local syms too.
4901 We really need local syms available to do this
4906 Elf_Internal_Sym
*isym
;
4908 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
4913 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
4917 vpp
= &elf_section_data (s
)->local_dynrel
;
4918 head
= (struct elf_dyn_relocs
**) vpp
;
4922 if (p
== NULL
|| p
->sec
!= sec
)
4924 bfd_size_type amt
= sizeof *p
;
4925 p
= ((struct elf_dyn_relocs
*)
4926 bfd_alloc (htab
->root
.dynobj
, amt
));
4947 /* Implement elf_backend_gc_mark_hook:
4948 Return the section that should be marked against GC for a given
4951 nios2_elf32_gc_mark_hook (asection
*sec
,
4952 struct bfd_link_info
*info
,
4953 Elf_Internal_Rela
*rel
,
4954 struct elf_link_hash_entry
*h
,
4955 Elf_Internal_Sym
*sym
)
4958 switch (ELF32_R_TYPE (rel
->r_info
))
4960 case R_NIOS2_GNU_VTINHERIT
:
4961 case R_NIOS2_GNU_VTENTRY
:
4964 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
4967 /* Implement elf_backend_finish_dynamic_symbols:
4968 Finish up dynamic symbol handling. We set the contents of various
4969 dynamic sections here. */
4971 nios2_elf32_finish_dynamic_symbol (bfd
*output_bfd
,
4972 struct bfd_link_info
*info
,
4973 struct elf_link_hash_entry
*h
,
4974 Elf_Internal_Sym
*sym
)
4976 struct elf32_nios2_link_hash_table
*htab
;
4977 struct elf32_nios2_link_hash_entry
*eh
4978 = (struct elf32_nios2_link_hash_entry
*)h
;
4981 htab
= elf32_nios2_hash_table (info
);
4983 if (h
->plt
.offset
!= (bfd_vma
) -1)
4990 Elf_Internal_Rela rela
;
4992 bfd_vma got_address
;
4994 /* This symbol has an entry in the procedure linkage table. Set
4996 BFD_ASSERT (h
->dynindx
!= -1);
4997 splt
= htab
->root
.splt
;
4998 sgotplt
= htab
->root
.sgotplt
;
4999 srela
= htab
->root
.srelplt
;
5000 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
&& srela
!= NULL
);
5002 /* Emit the PLT entry. */
5003 if (bfd_link_pic (info
))
5005 nios2_elf32_install_data (splt
, nios2_so_plt_entry
, h
->plt
.offset
,
5007 plt_index
= (h
->plt
.offset
- 24) / 12;
5008 got_offset
= (plt_index
+ 3) * 4;
5009 nios2_elf32_install_imm16 (splt
, h
->plt
.offset
,
5010 hiadj(plt_index
* 4));
5011 nios2_elf32_install_imm16 (splt
, h
->plt
.offset
+ 4,
5012 (plt_index
* 4) & 0xffff);
5013 nios2_elf32_install_imm16 (splt
, h
->plt
.offset
+ 8,
5014 0xfff4 - h
->plt
.offset
);
5015 got_address
= (sgotplt
->output_section
->vma
+ sgotplt
->output_offset
5018 /* Fill in the entry in the global offset table. There are no
5019 res_n slots for a shared object PLT, instead the .got.plt entries
5020 point to the PLT entries. */
5021 bfd_put_32 (output_bfd
,
5022 splt
->output_section
->vma
+ splt
->output_offset
5023 + h
->plt
.offset
, sgotplt
->contents
+ got_offset
);
5027 plt_index
= (h
->plt
.offset
- 28 - htab
->res_n_size
) / 12;
5028 got_offset
= (plt_index
+ 3) * 4;
5030 nios2_elf32_install_data (splt
, nios2_plt_entry
, h
->plt
.offset
, 3);
5031 got_address
= (sgotplt
->output_section
->vma
+ sgotplt
->output_offset
5033 nios2_elf32_install_imm16 (splt
, h
->plt
.offset
, hiadj(got_address
));
5034 nios2_elf32_install_imm16 (splt
, h
->plt
.offset
+ 4,
5035 got_address
& 0xffff);
5037 /* Fill in the entry in the global offset table. */
5038 bfd_put_32 (output_bfd
,
5039 splt
->output_section
->vma
+ splt
->output_offset
5040 + plt_index
* 4, sgotplt
->contents
+ got_offset
);
5043 /* Fill in the entry in the .rela.plt section. */
5044 rela
.r_offset
= got_address
;
5045 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_NIOS2_JUMP_SLOT
);
5047 loc
= srela
->contents
+ plt_index
* sizeof (Elf32_External_Rela
);
5048 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
5050 if (!h
->def_regular
)
5052 /* Mark the symbol as undefined, rather than as defined in
5053 the .plt section. Leave the value alone. */
5054 sym
->st_shndx
= SHN_UNDEF
;
5055 /* If the symbol is weak, we do need to clear the value.
5056 Otherwise, the PLT entry would provide a definition for
5057 the symbol even if the symbol wasn't defined anywhere,
5058 and so the symbol would never be NULL. */
5059 if (!h
->ref_regular_nonweak
)
5064 use_plt
= (eh
->got_types_used
== CALL_USED
5065 && h
->plt
.offset
!= (bfd_vma
) -1);
5067 if (!use_plt
&& h
->got
.offset
!= (bfd_vma
) -1
5068 && (elf32_nios2_hash_entry (h
)->tls_type
& GOT_TLS_GD
) == 0
5069 && (elf32_nios2_hash_entry (h
)->tls_type
& GOT_TLS_IE
) == 0)
5073 Elf_Internal_Rela rela
;
5077 /* This symbol has an entry in the global offset table. Set it
5079 sgot
= htab
->root
.sgot
;
5080 srela
= htab
->root
.srelgot
;
5081 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
5083 offset
= (h
->got
.offset
& ~(bfd_vma
) 1);
5084 rela
.r_offset
= (sgot
->output_section
->vma
5085 + sgot
->output_offset
+ offset
);
5087 /* If this is a -Bsymbolic link, and the symbol is defined
5088 locally, we just want to emit a RELATIVE reloc. Likewise if
5089 the symbol was forced to be local because of a version file.
5090 The entry in the global offset table will already have been
5091 initialized in the relocate_section function. */
5093 if (bfd_link_pic (info
) && SYMBOL_REFERENCES_LOCAL (info
, h
))
5095 rela
.r_info
= ELF32_R_INFO (0, R_NIOS2_RELATIVE
);
5096 rela
.r_addend
= bfd_get_signed_32 (output_bfd
,
5097 (sgot
->contents
+ offset
));
5098 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ offset
);
5102 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
5103 sgot
->contents
+ offset
);
5104 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_NIOS2_GLOB_DAT
);
5108 loc
= srela
->contents
;
5109 loc
+= srela
->reloc_count
++ * sizeof (Elf32_External_Rela
);
5110 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
5113 if (use_plt
&& h
->got
.offset
!= (bfd_vma
) -1)
5115 bfd_vma offset
= (h
->got
.offset
& ~(bfd_vma
) 1);
5116 asection
*sgot
= htab
->root
.sgot
;
5117 asection
*splt
= htab
->root
.splt
;
5118 bfd_put_32 (output_bfd
, (splt
->output_section
->vma
+ splt
->output_offset
5120 sgot
->contents
+ offset
);
5126 Elf_Internal_Rela rela
;
5129 /* This symbol needs a copy reloc. Set it up. */
5130 BFD_ASSERT (h
->dynindx
!= -1
5131 && (h
->root
.type
== bfd_link_hash_defined
5132 || h
->root
.type
== bfd_link_hash_defweak
));
5134 rela
.r_offset
= (h
->root
.u
.def
.value
5135 + h
->root
.u
.def
.section
->output_section
->vma
5136 + h
->root
.u
.def
.section
->output_offset
);
5137 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_NIOS2_COPY
);
5139 if (h
->root
.u
.def
.section
== htab
->root
.sdynrelro
)
5140 s
= htab
->root
.sreldynrelro
;
5142 s
= htab
->root
.srelbss
;
5143 BFD_ASSERT (s
!= NULL
);
5144 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
5145 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
5148 /* Mark _DYNAMIC, _GLOBAL_OFFSET_TABLE_, and _gp_got as absolute. */
5149 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
5150 || h
== htab
->root
.hgot
5151 || h
== htab
->h_gp_got
)
5152 sym
->st_shndx
= SHN_ABS
;
5157 /* Implement elf_backend_finish_dynamic_sections. */
5159 nios2_elf32_finish_dynamic_sections (bfd
*output_bfd
,
5160 struct bfd_link_info
*info
)
5164 struct elf32_nios2_link_hash_table
*htab
;
5166 htab
= elf32_nios2_hash_table (info
);
5167 sgotplt
= htab
->root
.sgotplt
;
5170 if (htab
->root
.dynamic_sections_created
)
5173 Elf32_External_Dyn
*dyncon
, *dynconend
;
5175 splt
= htab
->root
.splt
;
5176 sdyn
= bfd_get_linker_section (htab
->root
.dynobj
, ".dynamic");
5177 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
&& sgotplt
!= NULL
);
5179 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
5180 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
5181 for (; dyncon
< dynconend
; dyncon
++)
5183 Elf_Internal_Dyn dyn
;
5186 bfd_elf32_swap_dyn_in (htab
->root
.dynobj
, dyncon
, &dyn
);
5194 s
= htab
->root
.sgotplt
;
5195 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5196 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5200 s
= htab
->root
.srelplt
;
5201 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5202 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5206 s
= htab
->root
.srelplt
;
5207 dyn
.d_un
.d_val
= s
->size
;
5208 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5212 s
= htab
->root
.sgotplt
;
5214 = s
->output_section
->vma
+ s
->output_offset
+ 0x7ff0;
5215 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5220 /* Fill in the first entry in the procedure linkage table. */
5223 bfd_vma got_address
= (sgotplt
->output_section
->vma
5224 + sgotplt
->output_offset
);
5225 if (bfd_link_pic (info
))
5227 bfd_vma got_pcrel
= got_address
- (splt
->output_section
->vma
5228 + splt
->output_offset
);
5229 /* Both GOT and PLT must be aligned to a 16-byte boundary
5230 for the two loads to share the %hiadj part. The 4-byte
5231 offset for nextpc is accounted for in the %lo offsets
5233 BFD_ASSERT ((got_pcrel
& 0xf) == 0);
5234 nios2_elf32_install_data (splt
, nios2_so_plt0_entry
, 0, 6);
5235 nios2_elf32_install_imm16 (splt
, 4, hiadj (got_pcrel
));
5236 nios2_elf32_install_imm16 (splt
, 12, got_pcrel
& 0xffff);
5237 nios2_elf32_install_imm16 (splt
, 16, (got_pcrel
+ 4) & 0xffff);
5241 /* Divide by 4 here, not 3 because we already corrected for the
5243 bfd_vma res_size
= (splt
->size
- 28) / 4;
5244 bfd_vma res_start
= (splt
->output_section
->vma
5245 + splt
->output_offset
);
5248 for (res_offset
= 0; res_offset
< res_size
; res_offset
+= 4)
5249 bfd_put_32 (output_bfd
,
5250 6 | ((res_size
- (res_offset
+ 4)) << 6),
5251 splt
->contents
+ res_offset
);
5253 /* The GOT must be aligned to a 16-byte boundary for the
5254 two loads to share the same %hiadj part. */
5255 BFD_ASSERT ((got_address
& 0xf) == 0);
5257 nios2_elf32_install_data (splt
, nios2_plt0_entry
, res_size
, 7);
5258 nios2_elf32_install_imm16 (splt
, res_size
, hiadj (res_start
));
5259 nios2_elf32_install_imm16 (splt
, res_size
+ 4,
5260 res_start
& 0xffff);
5261 nios2_elf32_install_imm16 (splt
, res_size
+ 12,
5262 hiadj (got_address
));
5263 nios2_elf32_install_imm16 (splt
, res_size
+ 16,
5264 (got_address
+ 4) & 0xffff);
5265 nios2_elf32_install_imm16 (splt
, res_size
+ 20,
5266 (got_address
+ 8) & 0xffff);
5271 /* Fill in the first three entries in the global offset table. */
5272 if (sgotplt
!= NULL
&& sgotplt
->size
> 0)
5275 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgotplt
->contents
);
5277 bfd_put_32 (output_bfd
,
5278 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
5280 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgotplt
->contents
+ 4);
5281 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgotplt
->contents
+ 8);
5283 if (sgotplt
->output_section
!= bfd_abs_section_ptr
)
5284 elf_section_data (sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
5290 /* Implement elf_backend_adjust_dynamic_symbol:
5291 Adjust a symbol defined by a dynamic object and referenced by a
5292 regular object. The current definition is in some section of the
5293 dynamic object, but we're not including those sections. We have to
5294 change the definition to something the rest of the link can
5297 nios2_elf32_adjust_dynamic_symbol (struct bfd_link_info
*info
,
5298 struct elf_link_hash_entry
*h
)
5300 struct elf32_nios2_link_hash_table
*htab
;
5305 htab
= elf32_nios2_hash_table (info
);
5306 dynobj
= htab
->root
.dynobj
;
5308 /* Make sure we know what is going on here. */
5309 BFD_ASSERT (dynobj
!= NULL
5314 && !h
->def_regular
)));
5316 /* If this is a function, put it in the procedure linkage table. We
5317 will fill in the contents of the procedure linkage table later,
5318 when we know the address of the .got section. */
5319 if (h
->type
== STT_FUNC
|| h
->needs_plt
)
5321 if (h
->plt
.refcount
<= 0
5322 || SYMBOL_CALLS_LOCAL (info
, h
)
5323 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
5324 && h
->root
.type
== bfd_link_hash_undefweak
))
5326 /* This case can occur if we saw a PLT reloc in an input
5327 file, but the symbol was never referred to by a dynamic
5328 object, or if all references were garbage collected. In
5329 such a case, we don't actually need to build a procedure
5330 linkage table, and we can just do a PCREL reloc instead. */
5331 h
->plt
.offset
= (bfd_vma
) -1;
5338 /* Reinitialize the plt offset now that it is not used as a reference
5340 h
->plt
.offset
= (bfd_vma
) -1;
5342 /* If this is a weak symbol, and there is a real definition, the
5343 processor independent code will have arranged for us to see the
5344 real definition first, and we can just use the same value. */
5345 if (h
->is_weakalias
)
5347 struct elf_link_hash_entry
*def
= weakdef (h
);
5348 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
5349 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
5350 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
5354 /* If there are no non-GOT references, we do not need a copy
5356 if (!h
->non_got_ref
)
5359 /* This is a reference to a symbol defined by a dynamic object which
5361 If we are creating a shared library, we must presume that the
5362 only references to the symbol are via the global offset table.
5363 For such cases we need not do anything here; the relocations will
5364 be handled correctly by relocate_section. */
5365 if (bfd_link_pic (info
))
5370 _bfd_error_handler (_("dynamic variable `%s' is zero size"),
5371 h
->root
.root
.string
);
5375 /* We must allocate the symbol in our .dynbss section, which will
5376 become part of the .bss section of the executable. There will be
5377 an entry for this symbol in the .dynsym section. The dynamic
5378 object will contain position independent code, so all references
5379 from the dynamic object to this symbol will go through the global
5380 offset table. The dynamic linker will use the .dynsym entry to
5381 determine the address it must put in the global offset table, so
5382 both the dynamic object and the regular object will refer to the
5383 same memory location for the variable. */
5384 /* We must generate a R_NIOS2_COPY reloc to tell the dynamic linker to
5385 copy the initial value out of the dynamic object and into the
5386 runtime process image. We need to remember the offset into the
5387 .rela.bss section we are going to use. */
5388 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
5390 s
= htab
->root
.sdynrelro
;
5391 srel
= htab
->root
.sreldynrelro
;
5395 s
= htab
->root
.sdynbss
;
5396 srel
= htab
->root
.srelbss
;
5398 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
5400 srel
->size
+= sizeof (Elf32_External_Rela
);
5404 align2
= bfd_log2 (h
->size
);
5405 if (align2
> h
->root
.u
.def
.section
->alignment_power
)
5406 align2
= h
->root
.u
.def
.section
->alignment_power
;
5409 s
->size
= BFD_ALIGN (s
->size
, (bfd_size_type
)1 << align2
);
5410 if (align2
> bfd_get_section_alignment (dynobj
, s
)
5411 && !bfd_set_section_alignment (dynobj
, s
, align2
))
5414 /* Define the symbol as being at this point in the section. */
5415 h
->root
.u
.def
.section
= s
;
5416 h
->root
.u
.def
.value
= s
->size
;
5418 /* Increment the section size to make room for the symbol. */
5424 /* Worker function for nios2_elf32_size_dynamic_sections. */
5426 adjust_dynrelocs (struct elf_link_hash_entry
*h
, PTR inf
)
5428 struct bfd_link_info
*info
;
5429 struct elf32_nios2_link_hash_table
*htab
;
5431 if (h
->root
.type
== bfd_link_hash_indirect
)
5434 if (h
->root
.type
== bfd_link_hash_warning
)
5435 /* When warning symbols are created, they **replace** the "real"
5436 entry in the hash table, thus we never get to see the real
5437 symbol in a hash traversal. So look at it now. */
5438 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5440 info
= (struct bfd_link_info
*) inf
;
5441 htab
= elf32_nios2_hash_table (info
);
5443 if (h
->plt
.offset
!= (bfd_vma
)-1)
5444 h
->plt
.offset
+= htab
->res_n_size
;
5445 if (htab
->root
.splt
== h
->root
.u
.def
.section
)
5446 h
->root
.u
.def
.value
+= htab
->res_n_size
;
5451 /* Another worker function for nios2_elf32_size_dynamic_sections.
5452 Allocate space in .plt, .got and associated reloc sections for
5455 allocate_dynrelocs (struct elf_link_hash_entry
*h
, PTR inf
)
5457 struct bfd_link_info
*info
;
5458 struct elf32_nios2_link_hash_table
*htab
;
5459 struct elf32_nios2_link_hash_entry
*eh
;
5460 struct elf_dyn_relocs
*p
;
5463 if (h
->root
.type
== bfd_link_hash_indirect
)
5466 if (h
->root
.type
== bfd_link_hash_warning
)
5467 /* When warning symbols are created, they **replace** the "real"
5468 entry in the hash table, thus we never get to see the real
5469 symbol in a hash traversal. So look at it now. */
5470 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5472 info
= (struct bfd_link_info
*) inf
;
5473 htab
= elf32_nios2_hash_table (info
);
5475 if (htab
->root
.dynamic_sections_created
5476 && h
->plt
.refcount
> 0)
5478 /* Make sure this symbol is output as a dynamic symbol.
5479 Undefined weak syms won't yet be marked as dynamic. */
5480 if (h
->dynindx
== -1
5482 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
5485 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info
), h
))
5487 asection
*s
= htab
->root
.splt
;
5489 /* Allocate room for the header. */
5492 if (bfd_link_pic (info
))
5498 h
->plt
.offset
= s
->size
;
5500 /* If this symbol is not defined in a regular file, and we are
5501 not generating a shared library, then set the symbol to this
5502 location in the .plt. This is required to make function
5503 pointers compare as equal between the normal executable and
5504 the shared library. */
5505 if (! bfd_link_pic (info
)
5508 h
->root
.u
.def
.section
= s
;
5509 h
->root
.u
.def
.value
= h
->plt
.offset
;
5512 /* Make room for this entry. */
5515 /* We also need to make an entry in the .rela.plt section. */
5516 htab
->root
.srelplt
->size
+= sizeof (Elf32_External_Rela
);
5518 /* And the .got.plt section. */
5519 htab
->root
.sgotplt
->size
+= 4;
5523 h
->plt
.offset
= (bfd_vma
) -1;
5529 h
->plt
.offset
= (bfd_vma
) -1;
5533 eh
= (struct elf32_nios2_link_hash_entry
*) h
;
5534 use_plt
= (eh
->got_types_used
== CALL_USED
5535 && h
->plt
.offset
!= (bfd_vma
) -1);
5537 if (h
->got
.refcount
> 0)
5541 int tls_type
= eh
->tls_type
;
5544 /* Make sure this symbol is output as a dynamic symbol.
5545 Undefined weak syms won't yet be marked as dynamic. */
5546 if (h
->dynindx
== -1
5548 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
5551 s
= htab
->root
.sgot
;
5552 h
->got
.offset
= s
->size
;
5554 if (tls_type
== GOT_UNKNOWN
)
5557 if (tls_type
== GOT_NORMAL
)
5558 /* Non-TLS symbols need one GOT slot. */
5562 if (tls_type
& GOT_TLS_GD
)
5563 /* R_NIOS2_TLS_GD16 needs 2 consecutive GOT slots. */
5565 if (tls_type
& GOT_TLS_IE
)
5566 /* R_NIOS2_TLS_IE16 needs one GOT slot. */
5570 dyn
= htab
->root
.dynamic_sections_created
;
5573 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
5574 && (!bfd_link_pic (info
)
5575 || !SYMBOL_REFERENCES_LOCAL (info
, h
)))
5578 if (tls_type
!= GOT_NORMAL
5579 && (bfd_link_pic (info
) || indx
!= 0)
5580 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
5581 || h
->root
.type
!= bfd_link_hash_undefweak
))
5583 if (tls_type
& GOT_TLS_IE
)
5584 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
5586 if (tls_type
& GOT_TLS_GD
)
5587 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
5589 if ((tls_type
& GOT_TLS_GD
) && indx
!= 0)
5590 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
5592 else if ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
5593 || h
->root
.type
!= bfd_link_hash_undefweak
)
5595 && (bfd_link_pic (info
)
5596 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
5597 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
5600 h
->got
.offset
= (bfd_vma
) -1;
5602 if (eh
->dyn_relocs
== NULL
)
5605 /* In the shared -Bsymbolic case, discard space allocated for
5606 dynamic pc-relative relocs against symbols which turn out to be
5607 defined in regular objects. For the normal shared case, discard
5608 space for pc-relative relocs that have become local due to symbol
5609 visibility changes. */
5611 if (bfd_link_pic (info
))
5614 && (h
->forced_local
|| SYMBOLIC_BIND (info
, h
)))
5616 struct elf_dyn_relocs
**pp
;
5618 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
5620 p
->count
-= p
->pc_count
;
5629 /* Also discard relocs on undefined weak syms with non-default
5631 if (eh
->dyn_relocs
!= NULL
5632 && h
->root
.type
== bfd_link_hash_undefweak
)
5634 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
5635 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
5636 eh
->dyn_relocs
= NULL
;
5638 /* Make sure undefined weak symbols are output as a dynamic
5640 else if (h
->dynindx
== -1
5642 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
5648 /* For the non-shared case, discard space for relocs against
5649 symbols which turn out to need copy relocs or are not
5653 && ((h
->def_dynamic
&& !h
->def_regular
)
5654 || (htab
->root
.dynamic_sections_created
5655 && (h
->root
.type
== bfd_link_hash_undefweak
5656 || h
->root
.type
== bfd_link_hash_undefined
))))
5658 /* Make sure this symbol is output as a dynamic symbol.
5659 Undefined weak syms won't yet be marked as dynamic. */
5660 if (h
->dynindx
== -1
5662 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
5665 /* If that succeeded, we know we'll be keeping all the
5667 if (h
->dynindx
!= -1)
5671 eh
->dyn_relocs
= NULL
;
5676 /* Finally, allocate space. */
5677 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
5679 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
5680 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
5686 /* Implement elf_backend_size_dynamic_sections:
5687 Set the sizes of the dynamic sections. */
5689 nios2_elf32_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
5690 struct bfd_link_info
*info
)
5696 struct elf32_nios2_link_hash_table
*htab
;
5698 htab
= elf32_nios2_hash_table (info
);
5699 dynobj
= htab
->root
.dynobj
;
5700 BFD_ASSERT (dynobj
!= NULL
);
5702 htab
->res_n_size
= 0;
5703 if (htab
->root
.dynamic_sections_created
)
5705 /* Set the contents of the .interp section to the interpreter. */
5706 if (bfd_link_executable (info
) && !info
->nointerp
)
5708 s
= bfd_get_linker_section (dynobj
, ".interp");
5709 BFD_ASSERT (s
!= NULL
);
5710 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
5711 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
5716 /* We may have created entries in the .rela.got section.
5717 However, if we are not creating the dynamic sections, we will
5718 not actually use these entries. Reset the size of .rela.got,
5719 which will cause it to get stripped from the output file
5721 s
= htab
->root
.srelgot
;
5726 /* Set up .got offsets for local syms, and space for local dynamic
5728 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
5730 bfd_signed_vma
*local_got
;
5731 bfd_signed_vma
*end_local_got
;
5732 char *local_tls_type
;
5733 bfd_size_type locsymcount
;
5734 Elf_Internal_Shdr
*symtab_hdr
;
5737 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
5740 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
5742 struct elf_dyn_relocs
*p
;
5744 for (p
= elf_section_data (s
)->local_dynrel
; p
!= NULL
; p
= p
->next
)
5746 if (!bfd_is_abs_section (p
->sec
)
5747 && bfd_is_abs_section (p
->sec
->output_section
))
5749 /* Input section has been discarded, either because
5750 it is a copy of a linkonce section or due to
5751 linker script /DISCARD/, so we'll be discarding
5754 else if (p
->count
!= 0)
5756 srel
= elf_section_data (p
->sec
)->sreloc
;
5757 srel
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
5758 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
5759 info
->flags
|= DF_TEXTREL
;
5764 local_got
= elf_local_got_refcounts (ibfd
);
5768 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
5769 locsymcount
= symtab_hdr
->sh_info
;
5770 end_local_got
= local_got
+ locsymcount
;
5771 local_tls_type
= elf32_nios2_local_got_tls_type (ibfd
);
5772 s
= htab
->root
.sgot
;
5773 srel
= htab
->root
.srelgot
;
5774 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
5778 *local_got
= s
->size
;
5779 if (*local_tls_type
& GOT_TLS_GD
)
5780 /* TLS_GD relocs need an 8-byte structure in the GOT. */
5782 if (*local_tls_type
& GOT_TLS_IE
)
5784 if (*local_tls_type
== GOT_NORMAL
)
5787 if (bfd_link_pic (info
) || *local_tls_type
== GOT_TLS_GD
)
5788 srel
->size
+= sizeof (Elf32_External_Rela
);
5791 *local_got
= (bfd_vma
) -1;
5795 if (htab
->tls_ldm_got
.refcount
> 0)
5797 /* Allocate two GOT entries and one dynamic relocation (if necessary)
5798 for R_NIOS2_TLS_LDM16 relocations. */
5799 htab
->tls_ldm_got
.offset
= htab
->root
.sgot
->size
;
5800 htab
->root
.sgot
->size
+= 8;
5801 if (bfd_link_pic (info
))
5802 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
5805 htab
->tls_ldm_got
.offset
= -1;
5807 /* Allocate global sym .plt and .got entries, and space for global
5808 sym dynamic relocs. */
5809 elf_link_hash_traverse (& htab
->root
, allocate_dynrelocs
, info
);
5811 if (htab
->root
.dynamic_sections_created
)
5813 /* If the .got section is more than 0x8000 bytes, we add
5814 0x8000 to the value of _gp_got, so that 16-bit relocations
5815 have a greater chance of working. */
5816 if (htab
->root
.sgot
->size
>= 0x8000
5817 && htab
->h_gp_got
->root
.u
.def
.value
== 0)
5818 htab
->h_gp_got
->root
.u
.def
.value
= 0x8000;
5821 /* The check_relocs and adjust_dynamic_symbol entry points have
5822 determined the sizes of the various dynamic sections. Allocate
5825 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
5829 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
5832 /* It's OK to base decisions on the section name, because none
5833 of the dynobj section names depend upon the input files. */
5834 name
= bfd_get_section_name (dynobj
, s
);
5836 if (CONST_STRNEQ (name
, ".rela"))
5840 if (s
!= htab
->root
.srelplt
)
5843 /* We use the reloc_count field as a counter if we need
5844 to copy relocs into the output file. */
5848 else if (s
== htab
->root
.splt
)
5850 /* Correct for the number of res_N branches. */
5851 if (s
->size
!= 0 && !bfd_link_pic (info
))
5853 htab
->res_n_size
= (s
->size
- 28) / 3;
5854 s
->size
+= htab
->res_n_size
;
5857 else if (s
!= htab
->sbss
5858 && s
!= htab
->root
.sgot
5859 && s
!= htab
->root
.sgotplt
5860 && s
!= htab
->root
.sdynbss
5861 && s
!= htab
->root
.sdynrelro
)
5862 /* It's not one of our sections, so don't allocate space. */
5867 s
->flags
|= SEC_EXCLUDE
;
5871 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
5874 /* Allocate memory for the section contents. */
5875 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
5876 if (s
->contents
== NULL
)
5880 /* Adjust dynamic symbols that point to the plt to account for the
5881 now-known number of resN slots. */
5882 if (htab
->res_n_size
)
5883 elf_link_hash_traverse (& htab
->root
, adjust_dynrelocs
, info
);
5885 if (htab
->root
.dynamic_sections_created
)
5887 /* Add some entries to the .dynamic section. We fill in the
5888 values later, in elf_nios2_finish_dynamic_sections, but we
5889 must add the entries now so that we get the correct size for
5890 the .dynamic section. The DT_DEBUG entry is filled in by the
5891 dynamic linker and used by the debugger. */
5892 #define add_dynamic_entry(TAG, VAL) \
5893 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
5895 if (!bfd_link_pic (info
) && !add_dynamic_entry (DT_DEBUG
, 0))
5898 if (htab
->root
.sgotplt
->size
!= 0
5899 && !add_dynamic_entry (DT_PLTGOT
, 0))
5902 if (htab
->root
.splt
->size
!= 0
5903 && (!add_dynamic_entry (DT_PLTRELSZ
, 0)
5904 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
5905 || !add_dynamic_entry (DT_JMPREL
, 0)))
5909 && (!add_dynamic_entry (DT_RELA
, 0)
5910 || !add_dynamic_entry (DT_RELASZ
, 0)
5911 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
))))
5914 if (!bfd_link_pic (info
) && !add_dynamic_entry (DT_NIOS2_GP
, 0))
5917 if ((info
->flags
& DF_TEXTREL
) != 0
5918 && !add_dynamic_entry (DT_TEXTREL
, 0))
5921 #undef add_dynamic_entry
5926 /* Free the derived linker hash table. */
5928 nios2_elf32_link_hash_table_free (bfd
*obfd
)
5930 struct elf32_nios2_link_hash_table
*htab
5931 = (struct elf32_nios2_link_hash_table
*) obfd
->link
.hash
;
5933 bfd_hash_table_free (&htab
->bstab
);
5934 _bfd_elf_link_hash_table_free (obfd
);
5937 /* Implement bfd_elf32_bfd_link_hash_table_create. */
5938 static struct bfd_link_hash_table
*
5939 nios2_elf32_link_hash_table_create (bfd
*abfd
)
5941 struct elf32_nios2_link_hash_table
*ret
;
5942 bfd_size_type amt
= sizeof (struct elf32_nios2_link_hash_table
);
5944 ret
= bfd_zmalloc (amt
);
5948 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
5951 elf32_nios2_link_hash_entry
),
5958 /* Init the stub hash table too. */
5959 if (!bfd_hash_table_init (&ret
->bstab
, stub_hash_newfunc
,
5960 sizeof (struct elf32_nios2_stub_hash_entry
)))
5962 _bfd_elf_link_hash_table_free (abfd
);
5965 ret
->root
.root
.hash_table_free
= nios2_elf32_link_hash_table_free
;
5967 return &ret
->root
.root
;
5970 /* Implement elf_backend_reloc_type_class. */
5971 static enum elf_reloc_type_class
5972 nios2_elf32_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5973 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5974 const Elf_Internal_Rela
*rela
)
5976 switch ((int) ELF32_R_TYPE (rela
->r_info
))
5978 case R_NIOS2_RELATIVE
:
5979 return reloc_class_relative
;
5980 case R_NIOS2_JUMP_SLOT
:
5981 return reloc_class_plt
;
5983 return reloc_class_copy
;
5985 return reloc_class_normal
;
5989 /* Return 1 if target is one of ours. */
5991 is_nios2_elf_target (const struct bfd_target
*targ
)
5993 return (targ
== &nios2_elf32_le_vec
5994 || targ
== &nios2_elf32_be_vec
);
5997 /* Implement elf_backend_add_symbol_hook.
5998 This hook is called by the linker when adding symbols from an object
5999 file. We use it to put .comm items in .sbss, and not .bss. */
6001 nios2_elf_add_symbol_hook (bfd
*abfd
,
6002 struct bfd_link_info
*info
,
6003 Elf_Internal_Sym
*sym
,
6004 const char **namep ATTRIBUTE_UNUSED
,
6005 flagword
*flagsp ATTRIBUTE_UNUSED
,
6009 if (sym
->st_shndx
== SHN_COMMON
6010 && !bfd_link_relocatable (info
)
6011 && sym
->st_size
<= elf_gp_size (abfd
)
6012 && is_nios2_elf_target (info
->output_bfd
->xvec
))
6014 /* Common symbols less than or equal to -G nn bytes are automatically
6016 struct elf32_nios2_link_hash_table
*htab
;
6018 htab
= elf32_nios2_hash_table (info
);
6019 if (htab
->sbss
== NULL
)
6021 flagword flags
= SEC_IS_COMMON
| SEC_LINKER_CREATED
;
6023 if (htab
->root
.dynobj
== NULL
)
6024 htab
->root
.dynobj
= abfd
;
6026 htab
->sbss
= bfd_make_section_anyway_with_flags (htab
->root
.dynobj
,
6028 if (htab
->sbss
== NULL
)
6033 *valp
= sym
->st_size
;
6039 /* Implement elf_backend_can_make_relative_eh_frame:
6040 Decide whether to attempt to turn absptr or lsda encodings in
6041 shared libraries into pcrel within the given input section. */
6043 nios2_elf32_can_make_relative_eh_frame (bfd
*input_bfd ATTRIBUTE_UNUSED
,
6044 struct bfd_link_info
*info
6046 asection
*eh_frame_section
6049 /* We can't use PC-relative encodings in the .eh_frame section. */
6053 /* Implement elf_backend_special_sections. */
6054 const struct bfd_elf_special_section elf32_nios2_special_sections
[] =
6056 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS
,
6057 SHF_ALLOC
+ SHF_WRITE
+ SHF_NIOS2_GPREL
},
6058 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS
,
6059 SHF_ALLOC
+ SHF_WRITE
+ SHF_NIOS2_GPREL
},
6060 { NULL
, 0, 0, 0, 0 }
6063 #define ELF_ARCH bfd_arch_nios2
6064 #define ELF_TARGET_ID NIOS2_ELF_DATA
6065 #define ELF_MACHINE_CODE EM_ALTERA_NIOS2
6067 /* The Nios II MMU uses a 4K page size. */
6069 #define ELF_MAXPAGESIZE 0x1000
6071 #define bfd_elf32_bfd_link_hash_table_create \
6072 nios2_elf32_link_hash_table_create
6074 #define bfd_elf32_bfd_merge_private_bfd_data \
6075 nios2_elf32_merge_private_bfd_data
6077 /* Relocation table lookup macros. */
6079 #define bfd_elf32_bfd_reloc_type_lookup nios2_elf32_bfd_reloc_type_lookup
6080 #define bfd_elf32_bfd_reloc_name_lookup nios2_elf32_bfd_reloc_name_lookup
6082 /* JUMP_TABLE_LINK macros. */
6084 /* elf_info_to_howto (using RELA relocations). */
6086 #define elf_info_to_howto nios2_elf32_info_to_howto
6088 /* elf backend functions. */
6090 #define elf_backend_can_gc_sections 1
6091 #define elf_backend_can_refcount 1
6092 #define elf_backend_plt_readonly 1
6093 #define elf_backend_want_got_plt 1
6094 #define elf_backend_want_dynrelro 1
6095 #define elf_backend_rela_normal 1
6096 #define elf_backend_dtrel_excludes_plt 1
6098 #define elf_backend_relocate_section nios2_elf32_relocate_section
6099 #define elf_backend_section_flags nios2_elf32_section_flags
6100 #define elf_backend_fake_sections nios2_elf32_fake_sections
6101 #define elf_backend_check_relocs nios2_elf32_check_relocs
6103 #define elf_backend_gc_mark_hook nios2_elf32_gc_mark_hook
6104 #define elf_backend_create_dynamic_sections \
6105 nios2_elf32_create_dynamic_sections
6106 #define elf_backend_finish_dynamic_symbol nios2_elf32_finish_dynamic_symbol
6107 #define elf_backend_finish_dynamic_sections \
6108 nios2_elf32_finish_dynamic_sections
6109 #define elf_backend_adjust_dynamic_symbol nios2_elf32_adjust_dynamic_symbol
6110 #define elf_backend_reloc_type_class nios2_elf32_reloc_type_class
6111 #define elf_backend_size_dynamic_sections nios2_elf32_size_dynamic_sections
6112 #define elf_backend_add_symbol_hook nios2_elf_add_symbol_hook
6113 #define elf_backend_copy_indirect_symbol nios2_elf32_copy_indirect_symbol
6114 #define elf_backend_object_p nios2_elf32_object_p
6116 #define elf_backend_grok_prstatus nios2_grok_prstatus
6117 #define elf_backend_grok_psinfo nios2_grok_psinfo
6119 #undef elf_backend_can_make_relative_eh_frame
6120 #define elf_backend_can_make_relative_eh_frame \
6121 nios2_elf32_can_make_relative_eh_frame
6123 #define elf_backend_special_sections elf32_nios2_special_sections
6125 #define TARGET_LITTLE_SYM nios2_elf32_le_vec
6126 #define TARGET_LITTLE_NAME "elf32-littlenios2"
6127 #define TARGET_BIG_SYM nios2_elf32_be_vec
6128 #define TARGET_BIG_NAME "elf32-bignios2"
6130 #define elf_backend_got_header_size 12
6131 #define elf_backend_default_execstack 0
6133 #include "elf32-target.h"