1 /* 32-bit ELF support for Nios II.
2 Copyright (C) 2012-2019 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"
34 #include "libiberty.h"
36 /* Use RELA relocations. */
45 /* Forward declarations. */
46 static bfd_reloc_status_type nios2_elf32_ignore_reloc
47 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
48 static bfd_reloc_status_type nios2_elf32_hi16_relocate
49 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
50 static bfd_reloc_status_type nios2_elf32_lo16_relocate
51 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
52 static bfd_reloc_status_type nios2_elf32_hiadj16_relocate
53 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
54 static bfd_reloc_status_type nios2_elf32_pcrel_lo16_relocate
55 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
56 static bfd_reloc_status_type nios2_elf32_pcrel_hiadj16_relocate
57 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
58 static bfd_reloc_status_type nios2_elf32_pcrel16_relocate
59 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
60 static bfd_reloc_status_type nios2_elf32_call26_relocate
61 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
62 static bfd_reloc_status_type nios2_elf32_gprel_relocate
63 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
64 static bfd_reloc_status_type nios2_elf32_ujmp_relocate
65 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
66 static bfd_reloc_status_type nios2_elf32_cjmp_relocate
67 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
68 static bfd_reloc_status_type nios2_elf32_callr_relocate
69 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
72 extern const bfd_target nios2_elf32_le_vec
;
73 extern const bfd_target nios2_elf32_be_vec
;
75 /* Offset of tp and dtp pointers from start of TLS block. */
76 #define TP_OFFSET 0x7000
77 #define DTP_OFFSET 0x8000
79 /* The relocation tables used for SHT_REL sections. There are separate
80 tables for R1 and R2 encodings. */
81 static reloc_howto_type elf_nios2_r1_howto_table_rel
[] = {
83 HOWTO (R_NIOS2_NONE
, /* type */
85 3, /* size (0 = byte, 1 = short, 2 = long) */
87 FALSE
, /* pc_relative */
89 complain_overflow_dont
, /* complain_on_overflow */
90 bfd_elf_generic_reloc
, /* special_function */
91 "R_NIOS2_NONE", /* name */
92 FALSE
, /* partial_inplace */
95 FALSE
), /* pcrel_offset */
97 /* 16-bit signed immediate relocation. */
98 HOWTO (R_NIOS2_S16
, /* type */
100 2, /* size (0 = byte, 1 = short, 2 = long) */
102 FALSE
, /* pc_relative */
104 complain_overflow_signed
, /* complain on overflow */
105 bfd_elf_generic_reloc
, /* special function */
106 "R_NIOS2_S16", /* name */
107 FALSE
, /* partial_inplace */
108 0x003fffc0, /* src_mask */
109 0x003fffc0, /* dest_mask */
110 FALSE
), /* pcrel_offset */
112 /* 16-bit unsigned immediate relocation. */
113 HOWTO (R_NIOS2_U16
, /* type */
115 2, /* size (0 = byte, 1 = short, 2 = long) */
117 FALSE
, /* pc_relative */
119 complain_overflow_unsigned
, /* complain on overflow */
120 bfd_elf_generic_reloc
, /* special function */
121 "R_NIOS2_U16", /* name */
122 FALSE
, /* partial_inplace */
123 0x003fffc0, /* src_mask */
124 0x003fffc0, /* dest_mask */
125 FALSE
), /* pcrel_offset */
127 HOWTO (R_NIOS2_PCREL16
, /* type */
129 2, /* size (0 = byte, 1 = short, 2 = long) */
131 TRUE
, /* pc_relative */
133 complain_overflow_signed
, /* complain on overflow */
134 nios2_elf32_pcrel16_relocate
, /* special function */
135 "R_NIOS2_PCREL16", /* name */
136 FALSE
, /* partial_inplace */
137 0x003fffc0, /* src_mask */
138 0x003fffc0, /* dest_mask */
139 TRUE
), /* pcrel_offset */
141 HOWTO (R_NIOS2_CALL26
, /* type */
143 2, /* size (0 = byte, 1 = short, 2 = long) */
145 FALSE
, /* pc_relative */
147 complain_overflow_dont
, /* complain on overflow */
148 nios2_elf32_call26_relocate
, /* special function */
149 "R_NIOS2_CALL26", /* name */
150 FALSE
, /* partial_inplace */
151 0xffffffc0, /* src_mask */
152 0xffffffc0, /* dst_mask */
153 FALSE
), /* pcrel_offset */
161 complain_overflow_bitfield
,
162 bfd_elf_generic_reloc
,
169 HOWTO (R_NIOS2_CACHE_OPX
,
175 complain_overflow_bitfield
,
176 bfd_elf_generic_reloc
,
189 complain_overflow_bitfield
,
190 bfd_elf_generic_reloc
,
203 complain_overflow_bitfield
,
204 bfd_elf_generic_reloc
,
217 complain_overflow_dont
,
218 nios2_elf32_hi16_relocate
,
231 complain_overflow_dont
,
232 nios2_elf32_lo16_relocate
,
239 HOWTO (R_NIOS2_HIADJ16
,
245 complain_overflow_dont
,
246 nios2_elf32_hiadj16_relocate
,
253 HOWTO (R_NIOS2_BFD_RELOC_32
,
259 complain_overflow_dont
,
260 bfd_elf_generic_reloc
,
261 "R_NIOS2_BFD_RELOC32",
267 HOWTO (R_NIOS2_BFD_RELOC_16
,
273 complain_overflow_bitfield
,
274 bfd_elf_generic_reloc
,
275 "R_NIOS2_BFD_RELOC16",
281 HOWTO (R_NIOS2_BFD_RELOC_8
,
287 complain_overflow_bitfield
,
288 bfd_elf_generic_reloc
,
289 "R_NIOS2_BFD_RELOC8",
295 HOWTO (R_NIOS2_GPREL
,
301 complain_overflow_dont
,
302 nios2_elf32_gprel_relocate
,
309 HOWTO (R_NIOS2_GNU_VTINHERIT
,
315 complain_overflow_dont
,
317 "R_NIOS2_GNU_VTINHERIT",
323 HOWTO (R_NIOS2_GNU_VTENTRY
,
329 complain_overflow_dont
,
330 _bfd_elf_rel_vtable_reloc_fn
,
331 "R_NIOS2_GNU_VTENTRY",
343 complain_overflow_dont
,
344 nios2_elf32_ujmp_relocate
,
357 complain_overflow_dont
,
358 nios2_elf32_cjmp_relocate
,
365 HOWTO (R_NIOS2_CALLR
,
371 complain_overflow_dont
,
372 nios2_elf32_callr_relocate
,
379 HOWTO (R_NIOS2_ALIGN
,
385 complain_overflow_dont
,
386 nios2_elf32_ignore_reloc
,
394 HOWTO (R_NIOS2_GOT16
,
400 complain_overflow_bitfield
,
401 bfd_elf_generic_reloc
,
408 HOWTO (R_NIOS2_CALL16
,
414 complain_overflow_bitfield
,
415 bfd_elf_generic_reloc
,
422 HOWTO (R_NIOS2_GOTOFF_LO
,
428 complain_overflow_dont
,
429 bfd_elf_generic_reloc
,
436 HOWTO (R_NIOS2_GOTOFF_HA
,
442 complain_overflow_dont
,
443 bfd_elf_generic_reloc
,
450 HOWTO (R_NIOS2_PCREL_LO
,
456 complain_overflow_dont
,
457 nios2_elf32_pcrel_lo16_relocate
,
464 HOWTO (R_NIOS2_PCREL_HA
,
468 FALSE
, /* This is a PC-relative relocation, but we need to subtract
469 PC ourselves before the HIADJ. */
471 complain_overflow_dont
,
472 nios2_elf32_pcrel_hiadj16_relocate
,
479 HOWTO (R_NIOS2_TLS_GD16
,
485 complain_overflow_bitfield
,
486 bfd_elf_generic_reloc
,
493 HOWTO (R_NIOS2_TLS_LDM16
,
499 complain_overflow_bitfield
,
500 bfd_elf_generic_reloc
,
507 HOWTO (R_NIOS2_TLS_LDO16
,
513 complain_overflow_bitfield
,
514 bfd_elf_generic_reloc
,
521 HOWTO (R_NIOS2_TLS_IE16
,
527 complain_overflow_bitfield
,
528 bfd_elf_generic_reloc
,
535 HOWTO (R_NIOS2_TLS_LE16
,
541 complain_overflow_bitfield
,
542 bfd_elf_generic_reloc
,
549 HOWTO (R_NIOS2_TLS_DTPMOD
,
555 complain_overflow_dont
,
556 bfd_elf_generic_reloc
,
557 "R_NIOS2_TLS_DTPMOD",
563 HOWTO (R_NIOS2_TLS_DTPREL
,
569 complain_overflow_dont
,
570 bfd_elf_generic_reloc
,
571 "R_NIOS2_TLS_DTPREL",
577 HOWTO (R_NIOS2_TLS_TPREL
,
583 complain_overflow_dont
,
584 bfd_elf_generic_reloc
,
597 complain_overflow_dont
,
598 bfd_elf_generic_reloc
,
605 HOWTO (R_NIOS2_GLOB_DAT
,
611 complain_overflow_dont
,
612 bfd_elf_generic_reloc
,
619 HOWTO (R_NIOS2_JUMP_SLOT
,
625 complain_overflow_dont
,
626 bfd_elf_generic_reloc
,
633 HOWTO (R_NIOS2_RELATIVE
,
639 complain_overflow_dont
,
640 bfd_elf_generic_reloc
,
647 HOWTO (R_NIOS2_GOTOFF
,
653 complain_overflow_dont
,
654 bfd_elf_generic_reloc
,
661 HOWTO (R_NIOS2_CALL26_NOAT
, /* type */
663 2, /* size (0 = byte, 1 = short, 2 = long) */
665 FALSE
, /* pc_relative */
667 complain_overflow_dont
, /* complain on overflow */
668 nios2_elf32_call26_relocate
, /* special function */
669 "R_NIOS2_CALL26_NOAT", /* name */
670 FALSE
, /* partial_inplace */
671 0xffffffc0, /* src_mask */
672 0xffffffc0, /* dst_mask */
673 FALSE
), /* pcrel_offset */
675 HOWTO (R_NIOS2_GOT_LO
,
681 complain_overflow_dont
,
682 bfd_elf_generic_reloc
,
689 HOWTO (R_NIOS2_GOT_HA
,
695 complain_overflow_dont
,
696 bfd_elf_generic_reloc
,
703 HOWTO (R_NIOS2_CALL_LO
,
709 complain_overflow_dont
,
710 bfd_elf_generic_reloc
,
717 HOWTO (R_NIOS2_CALL_HA
,
723 complain_overflow_dont
,
724 bfd_elf_generic_reloc
,
731 /* Add other relocations here. */
734 static reloc_howto_type elf_nios2_r2_howto_table_rel
[] = {
736 HOWTO (R_NIOS2_NONE
, /* type */
738 0, /* size (0 = byte, 1 = short, 2 = long) */
740 FALSE
, /* pc_relative */
742 complain_overflow_dont
, /* complain_on_overflow */
743 bfd_elf_generic_reloc
, /* special_function */
744 "R_NIOS2_NONE", /* name */
745 FALSE
, /* partial_inplace */
748 FALSE
), /* pcrel_offset */
750 /* 16-bit signed immediate relocation. */
751 HOWTO (R_NIOS2_S16
, /* type */
753 2, /* size (0 = byte, 1 = short, 2 = long) */
755 FALSE
, /* pc_relative */
757 complain_overflow_signed
, /* complain on overflow */
758 bfd_elf_generic_reloc
, /* special function */
759 "R_NIOS2_S16", /* name */
760 FALSE
, /* partial_inplace */
761 0xffff0000, /* src_mask */
762 0xffff0000, /* dest_mask */
763 FALSE
), /* pcrel_offset */
765 /* 16-bit unsigned immediate relocation. */
766 HOWTO (R_NIOS2_U16
, /* type */
768 2, /* size (0 = byte, 1 = short, 2 = long) */
770 FALSE
, /* pc_relative */
772 complain_overflow_unsigned
, /* complain on overflow */
773 bfd_elf_generic_reloc
, /* special function */
774 "R_NIOS2_U16", /* name */
775 FALSE
, /* partial_inplace */
776 0xffff0000, /* src_mask */
777 0xffff0000, /* dest_mask */
778 FALSE
), /* pcrel_offset */
780 HOWTO (R_NIOS2_PCREL16
, /* type */
782 2, /* size (0 = byte, 1 = short, 2 = long) */
784 TRUE
, /* pc_relative */
786 complain_overflow_signed
, /* complain on overflow */
787 nios2_elf32_pcrel16_relocate
, /* special function */
788 "R_NIOS2_PCREL16", /* name */
789 FALSE
, /* partial_inplace */
790 0xffff0000, /* src_mask */
791 0xffff0000, /* dest_mask */
792 TRUE
), /* pcrel_offset */
794 HOWTO (R_NIOS2_CALL26
, /* type */
796 2, /* size (0 = byte, 1 = short, 2 = long) */
798 FALSE
, /* pc_relative */
800 complain_overflow_dont
, /* complain on overflow */
801 nios2_elf32_call26_relocate
, /* special function */
802 "R_NIOS2_CALL26", /* name */
803 FALSE
, /* partial_inplace */
804 0xffffffc0, /* src_mask */
805 0xffffffc0, /* dst_mask */
806 FALSE
), /* pcrel_offset */
814 complain_overflow_bitfield
,
815 bfd_elf_generic_reloc
,
822 HOWTO (R_NIOS2_CACHE_OPX
,
828 complain_overflow_bitfield
,
829 bfd_elf_generic_reloc
,
842 complain_overflow_bitfield
,
843 bfd_elf_generic_reloc
,
856 complain_overflow_bitfield
,
857 bfd_elf_generic_reloc
,
870 complain_overflow_dont
,
871 nios2_elf32_hi16_relocate
,
884 complain_overflow_dont
,
885 nios2_elf32_lo16_relocate
,
892 HOWTO (R_NIOS2_HIADJ16
,
898 complain_overflow_dont
,
899 nios2_elf32_hiadj16_relocate
,
906 HOWTO (R_NIOS2_BFD_RELOC_32
,
912 complain_overflow_dont
,
913 bfd_elf_generic_reloc
,
914 "R_NIOS2_BFD_RELOC32",
920 HOWTO (R_NIOS2_BFD_RELOC_16
,
926 complain_overflow_bitfield
,
927 bfd_elf_generic_reloc
,
928 "R_NIOS2_BFD_RELOC16",
934 HOWTO (R_NIOS2_BFD_RELOC_8
,
940 complain_overflow_bitfield
,
941 bfd_elf_generic_reloc
,
942 "R_NIOS2_BFD_RELOC8",
948 HOWTO (R_NIOS2_GPREL
,
954 complain_overflow_dont
,
955 nios2_elf32_gprel_relocate
,
962 HOWTO (R_NIOS2_GNU_VTINHERIT
,
968 complain_overflow_dont
,
970 "R_NIOS2_GNU_VTINHERIT",
976 HOWTO (R_NIOS2_GNU_VTENTRY
,
982 complain_overflow_dont
,
983 _bfd_elf_rel_vtable_reloc_fn
,
984 "R_NIOS2_GNU_VTENTRY",
996 complain_overflow_dont
,
997 nios2_elf32_ujmp_relocate
,
1004 HOWTO (R_NIOS2_CJMP
,
1010 complain_overflow_dont
,
1011 nios2_elf32_cjmp_relocate
,
1018 HOWTO (R_NIOS2_CALLR
,
1024 complain_overflow_dont
,
1025 nios2_elf32_callr_relocate
,
1032 HOWTO (R_NIOS2_ALIGN
,
1038 complain_overflow_dont
,
1039 nios2_elf32_ignore_reloc
,
1046 HOWTO (R_NIOS2_GOT16
,
1052 complain_overflow_bitfield
,
1053 bfd_elf_generic_reloc
,
1060 HOWTO (R_NIOS2_CALL16
,
1066 complain_overflow_bitfield
,
1067 bfd_elf_generic_reloc
,
1074 HOWTO (R_NIOS2_GOTOFF_LO
,
1080 complain_overflow_dont
,
1081 bfd_elf_generic_reloc
,
1082 "R_NIOS2_GOTOFF_LO",
1088 HOWTO (R_NIOS2_GOTOFF_HA
,
1094 complain_overflow_dont
,
1095 bfd_elf_generic_reloc
,
1096 "R_NIOS2_GOTOFF_HA",
1102 HOWTO (R_NIOS2_PCREL_LO
,
1108 complain_overflow_dont
,
1109 nios2_elf32_pcrel_lo16_relocate
,
1116 HOWTO (R_NIOS2_PCREL_HA
,
1120 FALSE
, /* This is a PC-relative relocation, but we need to subtract
1121 PC ourselves before the HIADJ. */
1123 complain_overflow_dont
,
1124 nios2_elf32_pcrel_hiadj16_relocate
,
1131 HOWTO (R_NIOS2_TLS_GD16
,
1137 complain_overflow_bitfield
,
1138 bfd_elf_generic_reloc
,
1145 HOWTO (R_NIOS2_TLS_LDM16
,
1151 complain_overflow_bitfield
,
1152 bfd_elf_generic_reloc
,
1153 "R_NIOS2_TLS_LDM16",
1159 HOWTO (R_NIOS2_TLS_LDO16
,
1165 complain_overflow_bitfield
,
1166 bfd_elf_generic_reloc
,
1167 "R_NIOS2_TLS_LDO16",
1173 HOWTO (R_NIOS2_TLS_IE16
,
1179 complain_overflow_bitfield
,
1180 bfd_elf_generic_reloc
,
1187 HOWTO (R_NIOS2_TLS_LE16
,
1193 complain_overflow_bitfield
,
1194 bfd_elf_generic_reloc
,
1201 HOWTO (R_NIOS2_TLS_DTPMOD
,
1207 complain_overflow_dont
,
1208 bfd_elf_generic_reloc
,
1209 "R_NIOS2_TLS_DTPMOD",
1215 HOWTO (R_NIOS2_TLS_DTPREL
,
1221 complain_overflow_dont
,
1222 bfd_elf_generic_reloc
,
1223 "R_NIOS2_TLS_DTPREL",
1229 HOWTO (R_NIOS2_TLS_TPREL
,
1235 complain_overflow_dont
,
1236 bfd_elf_generic_reloc
,
1237 "R_NIOS2_TLS_TPREL",
1243 HOWTO (R_NIOS2_COPY
,
1249 complain_overflow_dont
,
1250 bfd_elf_generic_reloc
,
1257 HOWTO (R_NIOS2_GLOB_DAT
,
1263 complain_overflow_dont
,
1264 bfd_elf_generic_reloc
,
1271 HOWTO (R_NIOS2_JUMP_SLOT
,
1277 complain_overflow_dont
,
1278 bfd_elf_generic_reloc
,
1279 "R_NIOS2_JUMP_SLOT",
1285 HOWTO (R_NIOS2_RELATIVE
,
1291 complain_overflow_dont
,
1292 bfd_elf_generic_reloc
,
1299 HOWTO (R_NIOS2_GOTOFF
,
1305 complain_overflow_dont
,
1306 bfd_elf_generic_reloc
,
1313 HOWTO (R_NIOS2_CALL26_NOAT
, /* type */
1315 2, /* size (0 = byte, 1 = short, 2 = long) */
1317 FALSE
, /* pc_relative */
1319 complain_overflow_dont
, /* complain on overflow */
1320 nios2_elf32_call26_relocate
, /* special function */
1321 "R_NIOS2_CALL26_NOAT", /* name */
1322 FALSE
, /* partial_inplace */
1323 0xffffffc0, /* src_mask */
1324 0xffffffc0, /* dst_mask */
1325 FALSE
), /* pcrel_offset */
1327 HOWTO (R_NIOS2_GOT_LO
,
1333 complain_overflow_dont
,
1334 bfd_elf_generic_reloc
,
1341 HOWTO (R_NIOS2_GOT_HA
,
1347 complain_overflow_dont
,
1348 bfd_elf_generic_reloc
,
1355 HOWTO (R_NIOS2_CALL_LO
,
1361 complain_overflow_dont
,
1362 bfd_elf_generic_reloc
,
1369 HOWTO (R_NIOS2_CALL_HA
,
1375 complain_overflow_dont
,
1376 bfd_elf_generic_reloc
,
1383 HOWTO (R_NIOS2_R2_S12
,
1389 complain_overflow_signed
,
1390 bfd_elf_generic_reloc
,
1397 HOWTO (R_NIOS2_R2_I10_1_PCREL
,
1403 complain_overflow_signed
,
1404 bfd_elf_generic_reloc
, /* FIXME? */
1405 "R_NIOS2_R2_I10_1_PCREL",
1411 HOWTO (R_NIOS2_R2_T1I7_1_PCREL
,
1417 complain_overflow_signed
,
1418 bfd_elf_generic_reloc
, /* FIXME? */
1419 "R_NIOS2_R2_T1I7_1_PCREL",
1425 HOWTO (R_NIOS2_R2_T1I7_2
,
1431 complain_overflow_unsigned
,
1432 bfd_elf_generic_reloc
,
1433 "R_NIOS2_R2_T1I7_2",
1439 HOWTO (R_NIOS2_R2_T2I4
,
1445 complain_overflow_unsigned
,
1446 bfd_elf_generic_reloc
,
1453 HOWTO (R_NIOS2_R2_T2I4_1
,
1459 complain_overflow_unsigned
,
1460 bfd_elf_generic_reloc
,
1461 "R_NIOS2_R2_T2I4_1",
1467 HOWTO (R_NIOS2_R2_T2I4_2
,
1473 complain_overflow_unsigned
,
1474 bfd_elf_generic_reloc
,
1475 "R_NIOS2_R2_T2I4_2",
1481 HOWTO (R_NIOS2_R2_X1I7_2
,
1487 complain_overflow_unsigned
,
1488 bfd_elf_generic_reloc
,
1489 "R_NIOS2_R2_X1I7_2",
1495 HOWTO (R_NIOS2_R2_X2L5
,
1501 complain_overflow_unsigned
,
1502 bfd_elf_generic_reloc
,
1509 HOWTO (R_NIOS2_R2_F1I5_2
,
1515 complain_overflow_unsigned
,
1516 bfd_elf_generic_reloc
,
1517 "R_NIOS2_R2_F1L5_2",
1523 HOWTO (R_NIOS2_R2_L5I4X1
,
1529 complain_overflow_unsigned
,
1530 bfd_elf_generic_reloc
,
1531 "R_NIOS2_R2_L5I4X1",
1537 HOWTO (R_NIOS2_R2_T1X1I6
,
1543 complain_overflow_unsigned
,
1544 bfd_elf_generic_reloc
,
1545 "R_NIOS2_R2_T1X1I6",
1551 HOWTO (R_NIOS2_R2_T1X1I6_2
,
1557 complain_overflow_unsigned
,
1558 bfd_elf_generic_reloc
,
1559 "R_NIOS2_R2_T1I1X6_2",
1565 /* Add other relocations here. */
1568 static unsigned char elf_code_to_howto_index
[R_NIOS2_ILLEGAL
+ 1];
1571 /* Return true if producing output for a R2 BFD. */
1572 #define BFD_IS_R2(abfd) (bfd_get_mach (abfd) == bfd_mach_nios2r2)
1574 /* Return the howto for relocation RTYPE. */
1575 static reloc_howto_type
*
1576 lookup_howto (unsigned int rtype
, bfd
*abfd
)
1578 static int initialized
= 0;
1580 /* R2 relocations are a superset of R1, so use that for the lookup
1582 int r1_howto_tbl_size
= (int) ARRAY_SIZE (elf_nios2_r1_howto_table_rel
);
1583 int r2_howto_tbl_size
= (int) ARRAY_SIZE (elf_nios2_r2_howto_table_rel
);
1588 memset (elf_code_to_howto_index
, 0xff,
1589 sizeof (elf_code_to_howto_index
));
1590 for (i
= 0; i
< r2_howto_tbl_size
; i
++)
1592 elf_code_to_howto_index
[elf_nios2_r2_howto_table_rel
[i
].type
] = i
;
1593 if (i
< r1_howto_tbl_size
)
1594 BFD_ASSERT (elf_nios2_r2_howto_table_rel
[i
].type
1595 == elf_nios2_r1_howto_table_rel
[i
].type
);
1599 if (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
[] =
1625 {BFD_RELOC_NONE
, R_NIOS2_NONE
},
1626 {BFD_RELOC_NIOS2_S16
, R_NIOS2_S16
},
1627 {BFD_RELOC_NIOS2_U16
, R_NIOS2_U16
},
1628 {BFD_RELOC_16_PCREL
, R_NIOS2_PCREL16
},
1629 {BFD_RELOC_NIOS2_CALL26
, R_NIOS2_CALL26
},
1630 {BFD_RELOC_NIOS2_IMM5
, R_NIOS2_IMM5
},
1631 {BFD_RELOC_NIOS2_CACHE_OPX
, R_NIOS2_CACHE_OPX
},
1632 {BFD_RELOC_NIOS2_IMM6
, R_NIOS2_IMM6
},
1633 {BFD_RELOC_NIOS2_IMM8
, R_NIOS2_IMM8
},
1634 {BFD_RELOC_NIOS2_HI16
, R_NIOS2_HI16
},
1635 {BFD_RELOC_NIOS2_LO16
, R_NIOS2_LO16
},
1636 {BFD_RELOC_NIOS2_HIADJ16
, R_NIOS2_HIADJ16
},
1637 {BFD_RELOC_32
, R_NIOS2_BFD_RELOC_32
},
1638 {BFD_RELOC_16
, R_NIOS2_BFD_RELOC_16
},
1639 {BFD_RELOC_8
, R_NIOS2_BFD_RELOC_8
},
1640 {BFD_RELOC_NIOS2_GPREL
, R_NIOS2_GPREL
},
1641 {BFD_RELOC_VTABLE_INHERIT
, R_NIOS2_GNU_VTINHERIT
},
1642 {BFD_RELOC_VTABLE_ENTRY
, R_NIOS2_GNU_VTENTRY
},
1643 {BFD_RELOC_NIOS2_UJMP
, R_NIOS2_UJMP
},
1644 {BFD_RELOC_NIOS2_CJMP
, R_NIOS2_CJMP
},
1645 {BFD_RELOC_NIOS2_CALLR
, R_NIOS2_CALLR
},
1646 {BFD_RELOC_NIOS2_ALIGN
, R_NIOS2_ALIGN
},
1647 {BFD_RELOC_NIOS2_GOT16
, R_NIOS2_GOT16
},
1648 {BFD_RELOC_NIOS2_CALL16
, R_NIOS2_CALL16
},
1649 {BFD_RELOC_NIOS2_GOTOFF_LO
, R_NIOS2_GOTOFF_LO
},
1650 {BFD_RELOC_NIOS2_GOTOFF_HA
, R_NIOS2_GOTOFF_HA
},
1651 {BFD_RELOC_NIOS2_PCREL_LO
, R_NIOS2_PCREL_LO
},
1652 {BFD_RELOC_NIOS2_PCREL_HA
, R_NIOS2_PCREL_HA
},
1653 {BFD_RELOC_NIOS2_TLS_GD16
, R_NIOS2_TLS_GD16
},
1654 {BFD_RELOC_NIOS2_TLS_LDM16
, R_NIOS2_TLS_LDM16
},
1655 {BFD_RELOC_NIOS2_TLS_LDO16
, R_NIOS2_TLS_LDO16
},
1656 {BFD_RELOC_NIOS2_TLS_IE16
, R_NIOS2_TLS_IE16
},
1657 {BFD_RELOC_NIOS2_TLS_LE16
, R_NIOS2_TLS_LE16
},
1658 {BFD_RELOC_NIOS2_TLS_DTPMOD
, R_NIOS2_TLS_DTPMOD
},
1659 {BFD_RELOC_NIOS2_TLS_DTPREL
, R_NIOS2_TLS_DTPREL
},
1660 {BFD_RELOC_NIOS2_TLS_TPREL
, R_NIOS2_TLS_TPREL
},
1661 {BFD_RELOC_NIOS2_COPY
, R_NIOS2_COPY
},
1662 {BFD_RELOC_NIOS2_GLOB_DAT
, R_NIOS2_GLOB_DAT
},
1663 {BFD_RELOC_NIOS2_JUMP_SLOT
, R_NIOS2_JUMP_SLOT
},
1664 {BFD_RELOC_NIOS2_RELATIVE
, R_NIOS2_RELATIVE
},
1665 {BFD_RELOC_NIOS2_GOTOFF
, R_NIOS2_GOTOFF
},
1666 {BFD_RELOC_NIOS2_CALL26_NOAT
, R_NIOS2_CALL26_NOAT
},
1667 {BFD_RELOC_NIOS2_GOT_LO
, R_NIOS2_GOT_LO
},
1668 {BFD_RELOC_NIOS2_GOT_HA
, R_NIOS2_GOT_HA
},
1669 {BFD_RELOC_NIOS2_CALL_LO
, R_NIOS2_CALL_LO
},
1670 {BFD_RELOC_NIOS2_CALL_HA
, R_NIOS2_CALL_HA
},
1671 {BFD_RELOC_NIOS2_R2_S12
, R_NIOS2_R2_S12
},
1672 {BFD_RELOC_NIOS2_R2_I10_1_PCREL
, R_NIOS2_R2_I10_1_PCREL
},
1673 {BFD_RELOC_NIOS2_R2_T1I7_1_PCREL
, R_NIOS2_R2_T1I7_1_PCREL
},
1674 {BFD_RELOC_NIOS2_R2_T1I7_2
, R_NIOS2_R2_T1I7_2
},
1675 {BFD_RELOC_NIOS2_R2_T2I4
, R_NIOS2_R2_T2I4
},
1676 {BFD_RELOC_NIOS2_R2_T2I4_1
, R_NIOS2_R2_T2I4_1
},
1677 {BFD_RELOC_NIOS2_R2_T2I4_2
, R_NIOS2_R2_T2I4_2
},
1678 {BFD_RELOC_NIOS2_R2_X1I7_2
, R_NIOS2_R2_X1I7_2
},
1679 {BFD_RELOC_NIOS2_R2_X2L5
, R_NIOS2_R2_X2L5
},
1680 {BFD_RELOC_NIOS2_R2_F1I5_2
, R_NIOS2_R2_F1I5_2
},
1681 {BFD_RELOC_NIOS2_R2_L5I4X1
, R_NIOS2_R2_L5I4X1
},
1682 {BFD_RELOC_NIOS2_R2_T1X1I6
, R_NIOS2_R2_T1X1I6
},
1683 {BFD_RELOC_NIOS2_R2_T1X1I6_2
, R_NIOS2_R2_T1X1I6_2
},
1686 enum elf32_nios2_stub_type
1688 nios2_stub_call26_before
,
1689 nios2_stub_call26_after
,
1693 struct elf32_nios2_stub_hash_entry
1695 /* Base hash table entry structure. */
1696 struct bfd_hash_entry bh_root
;
1698 /* The stub section. */
1701 /* Offset within stub_sec of the beginning of this stub. */
1702 bfd_vma stub_offset
;
1704 /* Given the symbol's value and its section we can determine its final
1705 value when building the stubs (so the stub knows where to jump. */
1706 bfd_vma target_value
;
1707 asection
*target_section
;
1709 enum elf32_nios2_stub_type stub_type
;
1711 /* The symbol table entry, if any, that this was derived from. */
1712 struct elf32_nios2_link_hash_entry
*hh
;
1714 /* And the reloc addend that this was derived from. */
1717 /* Where this stub is being called from, or, in the case of combined
1718 stub sections, the first input section in the group. */
1722 #define nios2_stub_hash_entry(ent) \
1723 ((struct elf32_nios2_stub_hash_entry *)(ent))
1725 #define nios2_stub_hash_lookup(table, string, create, copy) \
1726 ((struct elf32_nios2_stub_hash_entry *) \
1727 bfd_hash_lookup ((table), (string), (create), (copy)))
1730 /* Nios II ELF linker hash entry. */
1732 struct elf32_nios2_link_hash_entry
1734 struct elf_link_hash_entry root
;
1736 /* A pointer to the most recently used stub hash entry against this
1738 struct elf32_nios2_stub_hash_entry
*hsh_cache
;
1740 /* Track dynamic relocs copied for this symbol. */
1741 struct elf_dyn_relocs
*dyn_relocs
;
1743 #define GOT_UNKNOWN 0
1744 #define GOT_NORMAL 1
1745 #define GOT_TLS_GD 2
1746 #define GOT_TLS_IE 4
1747 unsigned char tls_type
;
1749 /* We need to detect and take special action for symbols which are only
1750 referenced with %call() and not with %got(). Such symbols do not need
1751 a dynamic GOT reloc in shared objects, only a dynamic PLT reloc. Lazy
1752 linking will not work if the dynamic GOT reloc exists.
1753 To check for this condition efficiently, we compare got_types_used against
1755 (got_types_used & (GOT_USED | CALL_USED)) == CALL_USED.
1759 unsigned char got_types_used
;
1762 #define elf32_nios2_hash_entry(ent) \
1763 ((struct elf32_nios2_link_hash_entry *) (ent))
1765 /* Get the Nios II elf linker hash table from a link_info structure. */
1766 #define elf32_nios2_hash_table(info) \
1767 ((struct elf32_nios2_link_hash_table *) ((info)->hash))
1769 /* Nios II ELF linker hash table. */
1770 struct elf32_nios2_link_hash_table
1772 /* The main hash table. */
1773 struct elf_link_hash_table root
;
1775 /* The stub hash table. */
1776 struct bfd_hash_table bstab
;
1778 /* Linker stub bfd. */
1781 /* Linker call-backs. */
1782 asection
* (*add_stub_section
) (const char *, asection
*, bfd_boolean
);
1783 void (*layout_sections_again
) (void);
1785 /* Array to keep track of which stub sections have been created, and
1786 information on stub grouping. */
1789 /* These are the section to which stubs in the group will be
1791 asection
*first_sec
, *last_sec
;
1792 /* The stub sections. There might be stubs inserted either before
1793 or after the real section.*/
1794 asection
*first_stub_sec
, *last_stub_sec
;
1797 /* Assorted information used by nios2_elf32_size_stubs. */
1798 unsigned int bfd_count
;
1799 unsigned int top_index
;
1800 asection
**input_list
;
1801 Elf_Internal_Sym
**all_local_syms
;
1803 /* Short-cuts to get to dynamic linker sections. */
1806 /* GOT pointer symbol _gp_got. */
1807 struct elf_link_hash_entry
*h_gp_got
;
1810 bfd_signed_vma refcount
;
1814 /* Small local sym cache. */
1815 struct sym_cache sym_cache
;
1820 struct nios2_elf32_obj_tdata
1822 struct elf_obj_tdata root
;
1824 /* tls_type for each local got entry. */
1825 char *local_got_tls_type
;
1827 /* TRUE if TLS GD relocs have been seen for this object. */
1828 bfd_boolean has_tlsgd
;
1831 #define elf32_nios2_tdata(abfd) \
1832 ((struct nios2_elf32_obj_tdata *) (abfd)->tdata.any)
1834 #define elf32_nios2_local_got_tls_type(abfd) \
1835 (elf32_nios2_tdata (abfd)->local_got_tls_type)
1837 /* The name of the dynamic interpreter. This is put in the .interp
1839 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
1841 /* PLT implementation for position-dependent code. */
1842 static const bfd_vma nios2_plt_entry
[] = { /* .PLTn: */
1843 0x03c00034, /* movhi r15, %hiadj(plt_got_slot_address) */
1844 0x7bc00017, /* ldw r15, %lo(plt_got_slot_address)(r15) */
1845 0x7800683a /* jmp r15 */
1848 static const bfd_vma nios2_plt0_entry
[] = { /* .PLTresolve */
1849 0x03800034, /* movhi r14, %hiadj(res_0) */
1850 0x73800004, /* addi r14, r14, %lo(res_0) */
1851 0x7b9fc83a, /* sub r15, r15, r14 */
1852 0x03400034, /* movhi r13, %hiadj(_GLOBAL_OFFSET_TABLE_) */
1853 0x6b800017, /* ldw r14, %lo(_GLOBAL_OFFSET_TABLE_+4)(r13) */
1854 0x6b400017, /* ldw r13, %lo(_GLOBAL_OFFSET_TABLE_+8)(r13) */
1855 0x6800683a /* jmp r13 */
1858 /* PLT implementation for position-independent code. */
1859 static const bfd_vma nios2_so_plt_entry
[] = { /* .PLTn */
1860 0x03c00034, /* movhi r15, %hiadj(index * 4) */
1861 0x7bc00004, /* addi r15, r15, %lo(index * 4) */
1862 0x00000006 /* br .PLTresolve */
1865 static const bfd_vma nios2_so_plt0_entry
[] = { /* .PLTresolve */
1866 0x001ce03a, /* nextpc r14 */
1867 0x03400034, /* movhi r13, %hiadj(_GLOBAL_OFFSET_TABLE_) */
1868 0x6b9b883a, /* add r13, r13, r14 */
1869 0x6b800017, /* ldw r14, %lo(_GLOBAL_OFFSET_TABLE_+4)(r13) */
1870 0x6b400017, /* ldw r13, %lo(_GLOBAL_OFFSET_TABLE_+8)(r13) */
1871 0x6800683a /* jmp r13 */
1875 static const bfd_vma nios2_call26_stub_entry
[] = {
1876 0x00400034, /* orhi at, r0, %hiadj(dest) */
1877 0x08400004, /* addi at, at, %lo(dest) */
1878 0x0800683a /* jmp at */
1881 /* Install 16-bit immediate value VALUE at offset OFFSET into section SEC. */
1883 nios2_elf32_install_imm16 (asection
*sec
, bfd_vma offset
, bfd_vma value
)
1885 bfd_vma word
= bfd_get_32 (sec
->owner
, sec
->contents
+ offset
);
1887 BFD_ASSERT (value
<= 0xffff || ((bfd_signed_vma
) value
) >= -0xffff);
1889 bfd_put_32 (sec
->owner
, word
| ((value
& 0xffff) << 6),
1890 sec
->contents
+ offset
);
1893 /* Install COUNT 32-bit values DATA starting at offset OFFSET into
1896 nios2_elf32_install_data (asection
*sec
, const bfd_vma
*data
, bfd_vma offset
,
1901 bfd_put_32 (sec
->owner
, *data
, sec
->contents
+ offset
);
1907 /* The usual way of loading a 32-bit constant into a Nios II register is to
1908 load the high 16 bits in one instruction and then add the low 16 bits with
1909 a signed add. This means that the high halfword needs to be adjusted to
1910 compensate for the sign bit of the low halfword. This function returns the
1911 adjusted high halfword for a given 32-bit constant. */
1913 bfd_vma
hiadj (bfd_vma symbol_value
)
1915 return ((symbol_value
+ 0x8000) >> 16) & 0xffff;
1918 /* Implement elf_backend_grok_prstatus:
1919 Support for core dump NOTE sections. */
1921 nios2_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
1926 switch (note
->descsz
)
1931 case 212: /* Linux/Nios II */
1933 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
1936 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
1945 /* Make a ".reg/999" section. */
1946 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
1947 size
, note
->descpos
+ offset
);
1950 /* Implement elf_backend_grok_psinfo. */
1952 nios2_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
1954 switch (note
->descsz
)
1959 case 124: /* Linux/Nios II elf_prpsinfo */
1960 elf_tdata (abfd
)->core
->program
1961 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
1962 elf_tdata (abfd
)->core
->command
1963 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
1966 /* Note that for some reason, a spurious space is tacked
1967 onto the end of the args in some (at least one anyway)
1968 implementations, so strip it off if it exists. */
1971 char *command
= elf_tdata (abfd
)->core
->command
;
1972 int n
= strlen (command
);
1974 if (0 < n
&& command
[n
- 1] == ' ')
1975 command
[n
- 1] = '\0';
1981 /* Assorted hash table functions. */
1983 /* Initialize an entry in the stub hash table. */
1984 static struct bfd_hash_entry
*
1985 stub_hash_newfunc (struct bfd_hash_entry
*entry
,
1986 struct bfd_hash_table
*table
,
1989 /* Allocate the structure if it has not already been allocated by a
1993 entry
= bfd_hash_allocate (table
,
1994 sizeof (struct elf32_nios2_stub_hash_entry
));
1999 /* Call the allocation method of the superclass. */
2000 entry
= bfd_hash_newfunc (entry
, table
, string
);
2003 struct elf32_nios2_stub_hash_entry
*hsh
;
2005 /* Initialize the local fields. */
2006 hsh
= (struct elf32_nios2_stub_hash_entry
*) entry
;
2007 hsh
->stub_sec
= NULL
;
2008 hsh
->stub_offset
= 0;
2009 hsh
->target_value
= 0;
2010 hsh
->target_section
= NULL
;
2011 hsh
->stub_type
= nios2_stub_none
;
2019 /* Create an entry in a Nios II ELF linker hash table. */
2020 static struct bfd_hash_entry
*
2021 link_hash_newfunc (struct bfd_hash_entry
*entry
,
2022 struct bfd_hash_table
*table
, const char *string
)
2024 /* Allocate the structure if it has not already been allocated by a
2028 entry
= bfd_hash_allocate (table
,
2029 sizeof (struct elf32_nios2_link_hash_entry
));
2034 /* Call the allocation method of the superclass. */
2035 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
2038 struct elf32_nios2_link_hash_entry
*eh
;
2040 eh
= (struct elf32_nios2_link_hash_entry
*) entry
;
2041 eh
->hsh_cache
= NULL
;
2042 eh
->dyn_relocs
= NULL
;
2043 eh
->tls_type
= GOT_UNKNOWN
;
2044 eh
->got_types_used
= 0;
2050 /* Section name for stubs is the associated section name plus this
2052 #define STUB_SUFFIX ".stub"
2054 /* Build a name for an entry in the stub hash table. */
2056 nios2_stub_name (const asection
*input_section
,
2057 const asection
*sym_sec
,
2058 const struct elf32_nios2_link_hash_entry
*hh
,
2059 const Elf_Internal_Rela
*rel
,
2060 enum elf32_nios2_stub_type stub_type
)
2064 char stubpos
= (stub_type
== nios2_stub_call26_before
) ? 'b' : 'a';
2068 len
= 8 + 1 + 1 + 1+ strlen (hh
->root
.root
.root
.string
) + 1 + 8 + 1;
2069 stub_name
= bfd_malloc (len
);
2070 if (stub_name
!= NULL
)
2072 sprintf (stub_name
, "%08x_%c_%s+%x",
2073 input_section
->id
& 0xffffffff,
2075 hh
->root
.root
.root
.string
,
2076 (int) rel
->r_addend
& 0xffffffff);
2081 len
= 8 + 1 + 1 + 1+ 8 + 1 + 8 + 1 + 8 + 1;
2082 stub_name
= bfd_malloc (len
);
2083 if (stub_name
!= NULL
)
2085 sprintf (stub_name
, "%08x_%c_%x:%x+%x",
2086 input_section
->id
& 0xffffffff,
2088 sym_sec
->id
& 0xffffffff,
2089 (int) ELF32_R_SYM (rel
->r_info
) & 0xffffffff,
2090 (int) rel
->r_addend
& 0xffffffff);
2096 /* Look up an entry in the stub hash. Stub entries are cached because
2097 creating the stub name takes a bit of time. */
2098 static struct elf32_nios2_stub_hash_entry
*
2099 nios2_get_stub_entry (const asection
*input_section
,
2100 const asection
*sym_sec
,
2101 struct elf32_nios2_link_hash_entry
*hh
,
2102 const Elf_Internal_Rela
*rel
,
2103 struct elf32_nios2_link_hash_table
*htab
,
2104 enum elf32_nios2_stub_type stub_type
)
2106 struct elf32_nios2_stub_hash_entry
*hsh
;
2107 const asection
*id_sec
;
2109 /* If this input section is part of a group of sections sharing one
2110 stub section, then use the id of the first/last section in the group,
2111 depending on the stub section placement relative to the group.
2112 Stub names need to include a section id, as there may well be
2113 more than one stub used to reach say, printf, and we need to
2114 distinguish between them. */
2115 if (stub_type
== nios2_stub_call26_before
)
2116 id_sec
= htab
->stub_group
[input_section
->id
].first_sec
;
2118 id_sec
= htab
->stub_group
[input_section
->id
].last_sec
;
2120 if (hh
!= NULL
&& hh
->hsh_cache
!= NULL
2121 && hh
->hsh_cache
->hh
== hh
2122 && hh
->hsh_cache
->id_sec
== id_sec
2123 && hh
->hsh_cache
->stub_type
== stub_type
)
2125 hsh
= hh
->hsh_cache
;
2131 stub_name
= nios2_stub_name (id_sec
, sym_sec
, hh
, rel
, stub_type
);
2132 if (stub_name
== NULL
)
2135 hsh
= nios2_stub_hash_lookup (&htab
->bstab
,
2136 stub_name
, FALSE
, FALSE
);
2139 hh
->hsh_cache
= hsh
;
2147 /* Add a new stub entry to the stub hash. Not all fields of the new
2148 stub entry are initialised. */
2149 static struct elf32_nios2_stub_hash_entry
*
2150 nios2_add_stub (const char *stub_name
,
2152 struct elf32_nios2_link_hash_table
*htab
,
2153 enum elf32_nios2_stub_type stub_type
)
2157 asection
**secptr
, **linkptr
;
2158 struct elf32_nios2_stub_hash_entry
*hsh
;
2161 if (stub_type
== nios2_stub_call26_before
)
2163 link_sec
= htab
->stub_group
[section
->id
].first_sec
;
2164 secptr
= &(htab
->stub_group
[section
->id
].first_stub_sec
);
2165 linkptr
= &(htab
->stub_group
[link_sec
->id
].first_stub_sec
);
2170 link_sec
= htab
->stub_group
[section
->id
].last_sec
;
2171 secptr
= &(htab
->stub_group
[section
->id
].last_stub_sec
);
2172 linkptr
= &(htab
->stub_group
[link_sec
->id
].last_stub_sec
);
2176 if (stub_sec
== NULL
)
2178 stub_sec
= *linkptr
;
2179 if (stub_sec
== NULL
)
2185 namelen
= strlen (link_sec
->name
);
2186 len
= namelen
+ sizeof (STUB_SUFFIX
);
2187 s_name
= bfd_alloc (htab
->stub_bfd
, len
);
2191 memcpy (s_name
, link_sec
->name
, namelen
);
2192 memcpy (s_name
+ namelen
, STUB_SUFFIX
, sizeof (STUB_SUFFIX
));
2194 stub_sec
= (*htab
->add_stub_section
) (s_name
, link_sec
, afterp
);
2195 if (stub_sec
== NULL
)
2197 *linkptr
= stub_sec
;
2202 /* Enter this entry into the linker stub hash table. */
2203 hsh
= nios2_stub_hash_lookup (&htab
->bstab
, stub_name
,
2207 /* xgettext:c-format */
2208 _bfd_error_handler (_("%pB: cannot create stub entry %s"),
2214 hsh
->stub_sec
= stub_sec
;
2215 hsh
->stub_offset
= 0;
2216 hsh
->id_sec
= link_sec
;
2220 /* Set up various things so that we can make a list of input sections
2221 for each output section included in the link. Returns -1 on error,
2222 0 when no stubs will be needed, and 1 on success. */
2224 nios2_elf32_setup_section_lists (bfd
*output_bfd
, struct bfd_link_info
*info
)
2227 unsigned int bfd_count
;
2228 unsigned int top_id
, top_index
;
2230 asection
**input_list
, **list
;
2232 struct elf32_nios2_link_hash_table
*htab
= elf32_nios2_hash_table (info
);
2234 /* Count the number of input BFDs and find the top input section id. */
2235 for (input_bfd
= info
->input_bfds
, bfd_count
= 0, top_id
= 0;
2237 input_bfd
= input_bfd
->link
.next
)
2240 for (section
= input_bfd
->sections
;
2242 section
= section
->next
)
2244 if (top_id
< section
->id
)
2245 top_id
= section
->id
;
2249 htab
->bfd_count
= bfd_count
;
2251 amt
= sizeof (struct map_stub
) * (top_id
+ 1);
2252 htab
->stub_group
= bfd_zmalloc (amt
);
2253 if (htab
->stub_group
== NULL
)
2256 /* We can't use output_bfd->section_count here to find the top output
2257 section index as some sections may have been removed, and
2258 strip_excluded_output_sections doesn't renumber the indices. */
2259 for (section
= output_bfd
->sections
, top_index
= 0;
2261 section
= section
->next
)
2263 if (top_index
< section
->index
)
2264 top_index
= section
->index
;
2267 htab
->top_index
= top_index
;
2268 amt
= sizeof (asection
*) * (top_index
+ 1);
2269 input_list
= bfd_malloc (amt
);
2270 htab
->input_list
= input_list
;
2271 if (input_list
== NULL
)
2274 /* For sections we aren't interested in, mark their entries with a
2275 value we can check later. */
2276 list
= input_list
+ top_index
;
2278 *list
= bfd_abs_section_ptr
;
2279 while (list
-- != input_list
);
2281 for (section
= output_bfd
->sections
;
2283 section
= section
->next
)
2285 /* FIXME: This is a bit of hack. Currently our .ctors and .dtors
2286 * have PC relative relocs in them but no code flag set. */
2287 if (((section
->flags
& SEC_CODE
) != 0) ||
2288 strcmp(".ctors", section
->name
) ||
2289 strcmp(".dtors", section
->name
))
2290 input_list
[section
->index
] = NULL
;
2296 /* The linker repeatedly calls this function for each input section,
2297 in the order that input sections are linked into output sections.
2298 Build lists of input sections to determine groupings between which
2299 we may insert linker stubs. */
2301 nios2_elf32_next_input_section (struct bfd_link_info
*info
, asection
*isec
)
2303 struct elf32_nios2_link_hash_table
*htab
= elf32_nios2_hash_table (info
);
2305 if (isec
->output_section
->index
<= htab
->top_index
)
2307 asection
**list
= htab
->input_list
+ isec
->output_section
->index
;
2308 if (*list
!= bfd_abs_section_ptr
)
2310 /* Steal the last_sec pointer for our list.
2311 This happens to make the list in reverse order,
2312 which is what we want. */
2313 htab
->stub_group
[isec
->id
].last_sec
= *list
;
2319 /* Segment mask for CALL26 relocation relaxation. */
2320 #define CALL26_SEGMENT(x) ((x) & 0xf0000000)
2322 /* Fudge factor for approximate maximum size of all stubs that might
2323 be inserted by the linker. This does not actually limit the number
2324 of stubs that might be inserted, and only affects strategy for grouping
2325 and placement of stubs. Perhaps this should be computed based on number
2326 of relocations seen, or be specifiable on the command line. */
2327 #define MAX_STUB_SECTION_SIZE 0xffff
2329 /* See whether we can group stub sections together. Grouping stub
2330 sections may result in fewer stubs. More importantly, we need to
2331 put all .init* and .fini* stubs at the end of the .init or
2332 .fini output sections respectively, because glibc splits the
2333 _init and _fini functions into multiple parts. Putting a stub in
2334 the middle of a function is not a good idea.
2335 Rather than computing groups of a maximum fixed size, for Nios II
2336 CALL26 relaxation it makes more sense to compute the groups based on
2337 sections that fit within a 256MB address segment. Also do not allow
2338 a group to span more than one output section, since different output
2339 sections might correspond to different memory banks on a bare-metal
2342 group_sections (struct elf32_nios2_link_hash_table
*htab
)
2344 asection
**list
= htab
->input_list
+ htab
->top_index
;
2347 /* The list is in reverse order so we'll search backwards looking
2348 for the first section that begins in the same memory segment,
2349 marking sections along the way to point at the tail for this
2351 asection
*tail
= *list
;
2352 if (tail
== bfd_abs_section_ptr
)
2354 while (tail
!= NULL
)
2356 bfd_vma start
= tail
->output_section
->vma
+ tail
->output_offset
;
2357 bfd_vma end
= start
+ tail
->size
;
2358 bfd_vma segment
= CALL26_SEGMENT (end
);
2361 if (segment
!= CALL26_SEGMENT (start
)
2362 || segment
!= CALL26_SEGMENT (end
+ MAX_STUB_SECTION_SIZE
))
2363 /* This section spans more than one memory segment, or is
2364 close enough to the end of the segment that adding stub
2365 sections before it might cause it to move so that it
2366 spans memory segments, or that stubs added at the end of
2367 this group might overflow into the next memory segment.
2368 Put it in a group by itself to localize the effects. */
2370 prev
= htab
->stub_group
[tail
->id
].last_sec
;
2371 htab
->stub_group
[tail
->id
].last_sec
= tail
;
2372 htab
->stub_group
[tail
->id
].first_sec
= tail
;
2375 /* Collect more sections for this group. */
2377 asection
*curr
, *first
;
2378 for (curr
= tail
; ; curr
= prev
)
2380 prev
= htab
->stub_group
[curr
->id
].last_sec
;
2382 || tail
->output_section
!= prev
->output_section
2383 || (CALL26_SEGMENT (prev
->output_section
->vma
2384 + prev
->output_offset
)
2389 for (curr
= tail
; ; curr
= prev
)
2391 prev
= htab
->stub_group
[curr
->id
].last_sec
;
2392 htab
->stub_group
[curr
->id
].last_sec
= tail
;
2393 htab
->stub_group
[curr
->id
].first_sec
= first
;
2399 /* Reset tail for the next group. */
2403 while (list
-- != htab
->input_list
);
2404 free (htab
->input_list
);
2407 /* Determine the type of stub needed, if any, for a call. */
2408 static enum elf32_nios2_stub_type
2409 nios2_type_of_stub (asection
*input_sec
,
2410 const Elf_Internal_Rela
*rel
,
2411 struct elf32_nios2_link_hash_entry
*hh
,
2412 struct elf32_nios2_link_hash_table
*htab
,
2413 bfd_vma destination
,
2414 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2416 bfd_vma location
, segment
, start
, end
;
2417 asection
*s0
, *s1
, *s
;
2420 !(hh
->root
.root
.type
== bfd_link_hash_defined
2421 || hh
->root
.root
.type
== bfd_link_hash_defweak
))
2422 return nios2_stub_none
;
2424 /* Determine where the call point is. */
2425 location
= (input_sec
->output_section
->vma
2426 + input_sec
->output_offset
+ rel
->r_offset
);
2427 segment
= CALL26_SEGMENT (location
);
2429 /* Nios II CALL and JMPI instructions can transfer control to addresses
2430 within the same 256MB segment as the PC. */
2431 if (segment
== CALL26_SEGMENT (destination
))
2432 return nios2_stub_none
;
2434 /* Find the start and end addresses of the stub group. Also account for
2435 any already-created stub sections for this group. Note that for stubs
2436 in the end section, only the first instruction of the last stub
2437 (12 bytes long) needs to be within range. */
2438 s0
= htab
->stub_group
[input_sec
->id
].first_sec
;
2439 s
= htab
->stub_group
[s0
->id
].first_stub_sec
;
2440 if (s
!= NULL
&& s
->size
> 0)
2441 start
= s
->output_section
->vma
+ s
->output_offset
;
2443 start
= s0
->output_section
->vma
+ s0
->output_offset
;
2445 s1
= htab
->stub_group
[input_sec
->id
].last_sec
;
2446 s
= htab
->stub_group
[s1
->id
].last_stub_sec
;
2447 if (s
!= NULL
&& s
->size
> 0)
2448 end
= s
->output_section
->vma
+ s
->output_offset
+ s
->size
- 8;
2450 end
= s1
->output_section
->vma
+ s1
->output_offset
+ s1
->size
;
2452 BFD_ASSERT (start
< end
);
2453 BFD_ASSERT (start
<= location
);
2454 BFD_ASSERT (location
< end
);
2456 /* Put stubs at the end of the group unless that is not a valid
2457 location and the beginning of the group is. It might be that
2458 neither the beginning nor end works if we have an input section
2459 so large that it spans multiple segment boundaries. In that
2460 case, punt; the end result will be a relocation overflow error no
2461 matter what we do here.
2463 Note that adding stubs pushes up the addresses of all subsequent
2464 sections, so that stubs allocated on one pass through the
2465 relaxation loop may not be valid on the next pass. (E.g., we may
2466 allocate a stub at the beginning of the section on one pass and
2467 find that the call site has been bumped into the next memory
2468 segment on the next pass.) The important thing to note is that
2469 we never try to reclaim the space allocated to such unused stubs,
2470 so code size and section addresses can only increase with each
2471 iteration. Accounting for the start and end addresses of the
2472 already-created stub sections ensures that when the algorithm
2473 converges, it converges accurately, with the entire appropriate
2474 stub section accessible from the call site and not just the
2475 address at the start or end of the stub group proper. */
2477 if (segment
== CALL26_SEGMENT (end
))
2478 return nios2_stub_call26_after
;
2479 else if (segment
== CALL26_SEGMENT (start
))
2480 return nios2_stub_call26_before
;
2482 /* Perhaps this should be a dedicated error code. */
2483 return nios2_stub_none
;
2487 nios2_build_one_stub (struct bfd_hash_entry
*gen_entry
, void *in_arg ATTRIBUTE_UNUSED
)
2489 struct elf32_nios2_stub_hash_entry
*hsh
2490 = (struct elf32_nios2_stub_hash_entry
*) gen_entry
;
2491 asection
*stub_sec
= hsh
->stub_sec
;
2494 /* Make a note of the offset within the stubs for this entry. */
2495 hsh
->stub_offset
= stub_sec
->size
;
2497 switch (hsh
->stub_type
)
2499 case nios2_stub_call26_before
:
2500 case nios2_stub_call26_after
:
2501 /* A call26 stub looks like:
2502 orhi at, %hiadj(dest)
2503 addi at, at, %lo(dest)
2505 Note that call/jmpi instructions can't be used in PIC code
2506 so there is no reason for the stub to be PIC, either. */
2507 sym_value
= (hsh
->target_value
2508 + hsh
->target_section
->output_offset
2509 + hsh
->target_section
->output_section
->vma
2512 nios2_elf32_install_data (stub_sec
, nios2_call26_stub_entry
,
2513 hsh
->stub_offset
, 3);
2514 nios2_elf32_install_imm16 (stub_sec
, hsh
->stub_offset
,
2516 nios2_elf32_install_imm16 (stub_sec
, hsh
->stub_offset
+ 4,
2517 (sym_value
& 0xffff));
2518 stub_sec
->size
+= 12;
2528 /* As above, but don't actually build the stub. Just bump offset so
2529 we know stub section sizes. */
2531 nios2_size_one_stub (struct bfd_hash_entry
*gen_entry
, void *in_arg ATTRIBUTE_UNUSED
)
2533 struct elf32_nios2_stub_hash_entry
*hsh
2534 = (struct elf32_nios2_stub_hash_entry
*) gen_entry
;
2536 switch (hsh
->stub_type
)
2538 case nios2_stub_call26_before
:
2539 case nios2_stub_call26_after
:
2540 hsh
->stub_sec
->size
+= 12;
2549 /* Read in all local syms for all input bfds.
2550 Returns -1 on error, 0 otherwise. */
2553 get_local_syms (bfd
*output_bfd ATTRIBUTE_UNUSED
, bfd
*input_bfd
,
2554 struct bfd_link_info
*info
)
2556 unsigned int bfd_indx
;
2557 Elf_Internal_Sym
*local_syms
, **all_local_syms
;
2558 struct elf32_nios2_link_hash_table
*htab
= elf32_nios2_hash_table (info
);
2560 /* We want to read in symbol extension records only once. To do this
2561 we need to read in the local symbols in parallel and save them for
2562 later use; so hold pointers to the local symbols in an array. */
2563 bfd_size_type amt
= sizeof (Elf_Internal_Sym
*) * htab
->bfd_count
;
2564 all_local_syms
= bfd_zmalloc (amt
);
2565 htab
->all_local_syms
= all_local_syms
;
2566 if (all_local_syms
== NULL
)
2569 /* Walk over all the input BFDs, swapping in local symbols. */
2572 input_bfd
= input_bfd
->link
.next
, bfd_indx
++)
2574 Elf_Internal_Shdr
*symtab_hdr
;
2576 /* We'll need the symbol table in a second. */
2577 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2578 if (symtab_hdr
->sh_info
== 0)
2581 /* We need an array of the local symbols attached to the input bfd. */
2582 local_syms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2583 if (local_syms
== NULL
)
2585 local_syms
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
,
2586 symtab_hdr
->sh_info
, 0,
2588 /* Cache them for elf_link_input_bfd. */
2589 symtab_hdr
->contents
= (unsigned char *) local_syms
;
2591 if (local_syms
== NULL
)
2594 all_local_syms
[bfd_indx
] = local_syms
;
2600 /* Determine and set the size of the stub section for a final link. */
2602 nios2_elf32_size_stubs (bfd
*output_bfd
, bfd
*stub_bfd
,
2603 struct bfd_link_info
*info
,
2604 asection
*(*add_stub_section
) (const char *,
2605 asection
*, bfd_boolean
),
2606 void (*layout_sections_again
) (void))
2608 bfd_boolean stub_changed
= FALSE
;
2609 struct elf32_nios2_link_hash_table
*htab
= elf32_nios2_hash_table (info
);
2611 /* Stash our params away. */
2612 htab
->stub_bfd
= stub_bfd
;
2613 htab
->add_stub_section
= add_stub_section
;
2614 htab
->layout_sections_again
= layout_sections_again
;
2616 /* FIXME: We only compute the section groups once. This could cause
2617 problems if adding a large stub section causes following sections,
2618 or parts of them, to move into another segment. However, this seems
2619 to be consistent with the way other back ends handle this.... */
2620 group_sections (htab
);
2622 if (get_local_syms (output_bfd
, info
->input_bfds
, info
))
2624 if (htab
->all_local_syms
)
2625 goto error_ret_free_local
;
2632 unsigned int bfd_indx
;
2635 for (input_bfd
= info
->input_bfds
, bfd_indx
= 0;
2637 input_bfd
= input_bfd
->link
.next
, bfd_indx
++)
2639 Elf_Internal_Shdr
*symtab_hdr
;
2641 Elf_Internal_Sym
*local_syms
;
2643 /* We'll need the symbol table in a second. */
2644 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2645 if (symtab_hdr
->sh_info
== 0)
2648 local_syms
= htab
->all_local_syms
[bfd_indx
];
2650 /* Walk over each section attached to the input bfd. */
2651 for (section
= input_bfd
->sections
;
2653 section
= section
->next
)
2655 Elf_Internal_Rela
*internal_relocs
, *irelaend
, *irela
;
2657 /* If there aren't any relocs, then there's nothing more
2659 if ((section
->flags
& SEC_RELOC
) == 0
2660 || section
->reloc_count
== 0)
2663 /* If this section is a link-once section that will be
2664 discarded, then don't create any stubs. */
2665 if (section
->output_section
== NULL
2666 || section
->output_section
->owner
!= output_bfd
)
2669 /* Get the relocs. */
2671 = _bfd_elf_link_read_relocs (input_bfd
, section
, NULL
, NULL
,
2673 if (internal_relocs
== NULL
)
2674 goto error_ret_free_local
;
2676 /* Now examine each relocation. */
2677 irela
= internal_relocs
;
2678 irelaend
= irela
+ section
->reloc_count
;
2679 for (; irela
< irelaend
; irela
++)
2681 unsigned int r_type
, r_indx
;
2682 enum elf32_nios2_stub_type stub_type
;
2683 struct elf32_nios2_stub_hash_entry
*hsh
;
2686 bfd_vma destination
;
2687 struct elf32_nios2_link_hash_entry
*hh
;
2689 const asection
*id_sec
;
2691 r_type
= ELF32_R_TYPE (irela
->r_info
);
2692 r_indx
= ELF32_R_SYM (irela
->r_info
);
2694 if (r_type
>= (unsigned int) R_NIOS2_ILLEGAL
)
2696 bfd_set_error (bfd_error_bad_value
);
2697 error_ret_free_internal
:
2698 if (elf_section_data (section
)->relocs
== NULL
)
2699 free (internal_relocs
);
2700 goto error_ret_free_local
;
2703 /* Only look for stubs on CALL and JMPI instructions. */
2704 if (r_type
!= (unsigned int) R_NIOS2_CALL26
)
2707 /* Now determine the call target, its name, value,
2713 if (r_indx
< symtab_hdr
->sh_info
)
2715 /* It's a local symbol. */
2716 Elf_Internal_Sym
*sym
;
2717 Elf_Internal_Shdr
*hdr
;
2720 sym
= local_syms
+ r_indx
;
2721 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
2722 sym_value
= sym
->st_value
;
2723 shndx
= sym
->st_shndx
;
2724 if (shndx
< elf_numsections (input_bfd
))
2726 hdr
= elf_elfsections (input_bfd
)[shndx
];
2727 sym_sec
= hdr
->bfd_section
;
2728 destination
= (sym_value
+ irela
->r_addend
2729 + sym_sec
->output_offset
2730 + sym_sec
->output_section
->vma
);
2735 /* It's an external symbol. */
2738 e_indx
= r_indx
- symtab_hdr
->sh_info
;
2739 hh
= ((struct elf32_nios2_link_hash_entry
*)
2740 elf_sym_hashes (input_bfd
)[e_indx
]);
2742 while (hh
->root
.root
.type
== bfd_link_hash_indirect
2743 || hh
->root
.root
.type
== bfd_link_hash_warning
)
2744 hh
= ((struct elf32_nios2_link_hash_entry
*)
2745 hh
->root
.root
.u
.i
.link
);
2747 if (hh
->root
.root
.type
== bfd_link_hash_defined
2748 || hh
->root
.root
.type
== bfd_link_hash_defweak
)
2750 sym_sec
= hh
->root
.root
.u
.def
.section
;
2751 sym_value
= hh
->root
.root
.u
.def
.value
;
2753 if (sym_sec
->output_section
!= NULL
)
2754 destination
= (sym_value
+ irela
->r_addend
2755 + sym_sec
->output_offset
2756 + sym_sec
->output_section
->vma
);
2760 else if (hh
->root
.root
.type
== bfd_link_hash_undefweak
)
2762 if (! bfd_link_pic (info
))
2765 else if (hh
->root
.root
.type
== bfd_link_hash_undefined
)
2767 if (! (info
->unresolved_syms_in_objects
== RM_IGNORE
2768 && (ELF_ST_VISIBILITY (hh
->root
.other
)
2774 bfd_set_error (bfd_error_bad_value
);
2775 goto error_ret_free_internal
;
2779 /* Determine what (if any) linker stub is needed. */
2780 stub_type
= nios2_type_of_stub (section
, irela
, hh
, htab
,
2782 if (stub_type
== nios2_stub_none
)
2785 /* Support for grouping stub sections. */
2786 if (stub_type
== nios2_stub_call26_before
)
2787 id_sec
= htab
->stub_group
[section
->id
].first_sec
;
2789 id_sec
= htab
->stub_group
[section
->id
].last_sec
;
2791 /* Get the name of this stub. */
2792 stub_name
= nios2_stub_name (id_sec
, sym_sec
, hh
, irela
,
2795 goto error_ret_free_internal
;
2797 hsh
= nios2_stub_hash_lookup (&htab
->bstab
,
2802 /* The proper stub has already been created. */
2807 hsh
= nios2_add_stub (stub_name
, section
, htab
, stub_type
);
2811 goto error_ret_free_internal
;
2813 hsh
->target_value
= sym_value
;
2814 hsh
->target_section
= sym_sec
;
2815 hsh
->stub_type
= stub_type
;
2817 hsh
->addend
= irela
->r_addend
;
2818 stub_changed
= TRUE
;
2821 /* We're done with the internal relocs, free them. */
2822 if (elf_section_data (section
)->relocs
== NULL
)
2823 free (internal_relocs
);
2830 /* OK, we've added some stubs. Find out the new size of the
2832 for (stub_sec
= htab
->stub_bfd
->sections
;
2834 stub_sec
= stub_sec
->next
)
2837 bfd_hash_traverse (&htab
->bstab
, nios2_size_one_stub
, htab
);
2839 /* Ask the linker to do its stuff. */
2840 (*htab
->layout_sections_again
) ();
2841 stub_changed
= FALSE
;
2844 free (htab
->all_local_syms
);
2847 error_ret_free_local
:
2848 free (htab
->all_local_syms
);
2852 /* Build all the stubs associated with the current output file. The
2853 stubs are kept in a hash table attached to the main linker hash
2854 table. This function is called via nios2elf_finish in the linker. */
2856 nios2_elf32_build_stubs (struct bfd_link_info
*info
)
2859 struct bfd_hash_table
*table
;
2860 struct elf32_nios2_link_hash_table
*htab
;
2862 htab
= elf32_nios2_hash_table (info
);
2864 for (stub_sec
= htab
->stub_bfd
->sections
;
2866 stub_sec
= stub_sec
->next
)
2867 /* The stub_bfd may contain non-stub sections if it is also the
2868 dynobj. Any such non-stub sections are created with the
2869 SEC_LINKER_CREATED flag set, while stub sections do not
2870 have that flag. Ignore any non-stub sections here. */
2871 if ((stub_sec
->flags
& SEC_LINKER_CREATED
) == 0)
2875 /* Allocate memory to hold the linker stubs. */
2876 size
= stub_sec
->size
;
2877 stub_sec
->contents
= bfd_zalloc (htab
->stub_bfd
, size
);
2878 if (stub_sec
->contents
== NULL
&& size
!= 0)
2883 /* Build the stubs as directed by the stub hash table. */
2884 table
= &htab
->bstab
;
2885 bfd_hash_traverse (table
, nios2_build_one_stub
, info
);
2891 #define is_nios2_elf(bfd) \
2892 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2893 && elf_object_id (bfd) == NIOS2_ELF_DATA)
2895 /* Merge backend specific data from an object file to the output
2896 object file when linking. */
2899 nios2_elf32_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
2901 bfd
*obfd
= info
->output_bfd
;
2905 if (!is_nios2_elf (ibfd
) || !is_nios2_elf (obfd
))
2908 /* Check if we have the same endianness. */
2909 if (! _bfd_generic_verify_endian_match (ibfd
, info
))
2912 new_flags
= elf_elfheader (ibfd
)->e_flags
;
2913 old_flags
= elf_elfheader (obfd
)->e_flags
;
2914 if (!elf_flags_init (obfd
))
2916 /* First call, no flags set. */
2917 elf_flags_init (obfd
) = TRUE
;
2918 elf_elfheader (obfd
)->e_flags
= new_flags
;
2923 case EF_NIOS2_ARCH_R1
:
2924 bfd_default_set_arch_mach (obfd
, bfd_arch_nios2
, bfd_mach_nios2r1
);
2926 case EF_NIOS2_ARCH_R2
:
2927 if (bfd_big_endian (ibfd
))
2930 (_("error: %pB: big-endian R2 is not supported"), ibfd
);
2931 bfd_set_error (bfd_error_bad_value
);
2934 bfd_default_set_arch_mach (obfd
, bfd_arch_nios2
, bfd_mach_nios2r2
);
2939 /* Incompatible flags. */
2940 else if (new_flags
!= old_flags
)
2942 /* So far, the only incompatible flags denote incompatible
2945 /* xgettext:c-format */
2946 (_("error: %pB: conflicting CPU architectures %d/%d"),
2947 ibfd
, new_flags
, old_flags
);
2948 bfd_set_error (bfd_error_bad_value
);
2952 /* Merge Tag_compatibility attributes and any common GNU ones. */
2953 _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. */
2961 static reloc_howto_type
*
2962 nios2_elf32_bfd_reloc_type_lookup (bfd
*abfd
,
2963 bfd_reloc_code_real_type code
)
2967 for (i
= 0; i
< (int) ARRAY_SIZE (nios2_reloc_map
); ++i
)
2968 if (nios2_reloc_map
[i
].bfd_val
== code
)
2969 return lookup_howto (nios2_reloc_map
[i
].elf_val
, abfd
);
2973 /* Implement bfd_elf32_bfd_reloc_name_lookup:
2974 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) ARRAY_SIZE (elf_nios2_r2_howto_table_rel
);
2991 howto_tbl
= elf_nios2_r1_howto_table_rel
;
2992 howto_tbl_size
= (int) ARRAY_SIZE (elf_nios2_r1_howto_table_rel
);
2995 for (i
= 0; i
< howto_tbl_size
; i
++)
2996 if (howto_tbl
[i
].name
&& strcasecmp (howto_tbl
[i
].name
, r_name
) == 0)
2997 return howto_tbl
+ i
;
3002 /* Implement elf_info_to_howto:
3003 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 if ((cache_ptr
->howto
= lookup_howto (r_type
, abfd
)) == NULL
)
3014 /* xgettext:c-format */
3015 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
3017 bfd_set_error (bfd_error_bad_value
);
3023 /* Return the base VMA address which should be subtracted from real addresses
3024 when resolving @dtpoff relocation.
3025 This is PT_TLS segment p_vaddr. */
3027 dtpoff_base (struct bfd_link_info
*info
)
3029 /* If tls_sec is NULL, we should have signalled an error already. */
3030 if (elf_hash_table (info
)->tls_sec
== NULL
)
3032 return elf_hash_table (info
)->tls_sec
->vma
;
3035 /* Return the relocation value for @tpoff relocation
3036 if STT_TLS virtual address is ADDRESS. */
3038 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3040 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3042 /* If tls_sec is NULL, we should have signalled an error already. */
3043 if (htab
->tls_sec
== NULL
)
3045 return address
- htab
->tls_sec
->vma
;
3048 /* Set the GP value for OUTPUT_BFD. Returns FALSE if this is a
3049 dangerous relocation. */
3051 nios2_elf_assign_gp (bfd
*output_bfd
, bfd_vma
*pgp
, struct bfd_link_info
*info
)
3054 bfd_boolean gp_found
;
3055 struct bfd_hash_entry
*h
;
3056 struct bfd_link_hash_entry
*lh
;
3058 /* If we've already figured out what GP will be, just return it. */
3059 *pgp
= _bfd_get_gp_value (output_bfd
);
3063 h
= bfd_hash_lookup (&info
->hash
->table
, "_gp", FALSE
, FALSE
);
3064 lh
= (struct bfd_link_hash_entry
*) h
;
3070 case bfd_link_hash_undefined
:
3071 case bfd_link_hash_undefweak
:
3072 case bfd_link_hash_common
:
3075 case bfd_link_hash_defined
:
3076 case bfd_link_hash_defweak
:
3079 asection
*sym_sec
= lh
->u
.def
.section
;
3080 bfd_vma sym_value
= lh
->u
.def
.value
;
3082 if (sym_sec
->output_section
)
3083 sym_value
= (sym_value
+ sym_sec
->output_offset
3084 + sym_sec
->output_section
->vma
);
3088 case bfd_link_hash_indirect
:
3089 case bfd_link_hash_warning
:
3091 /* @@FIXME ignoring warning for now */
3093 case bfd_link_hash_new
:
3103 /* Only get the error once. */
3105 _bfd_set_gp_value (output_bfd
, *pgp
);
3109 _bfd_set_gp_value (output_bfd
, *pgp
);
3114 /* Retrieve the previously cached _gp pointer, returning bfd_reloc_dangerous
3115 if it's not available as we don't have a link_info pointer available here
3116 to look it up in the output symbol table. We don't need to adjust the
3117 symbol value for an external symbol if we are producing relocatable
3119 static bfd_reloc_status_type
3120 nios2_elf_final_gp (bfd
*output_bfd
, asymbol
*symbol
, bfd_boolean relocatable
,
3121 char **error_message
, bfd_vma
*pgp
)
3123 if (bfd_is_und_section (symbol
->section
) && !relocatable
)
3126 return bfd_reloc_undefined
;
3129 *pgp
= _bfd_get_gp_value (output_bfd
);
3130 if (*pgp
== 0 && (!relocatable
|| (symbol
->flags
& BSF_SECTION_SYM
) != 0))
3134 /* Make up a value. */
3135 *pgp
= symbol
->section
->output_section
->vma
+ 0x4000;
3136 _bfd_set_gp_value (output_bfd
, *pgp
);
3141 = (char *) _("global pointer relative relocation when _gp not defined");
3142 return bfd_reloc_dangerous
;
3146 return bfd_reloc_ok
;
3149 /* Do the relocations that require special handling. */
3150 static bfd_reloc_status_type
3151 nios2_elf32_do_hi16_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3152 asection
*input_section
,
3153 bfd_byte
*data
, bfd_vma offset
,
3154 bfd_vma symbol_value
, bfd_vma addend
)
3156 symbol_value
= symbol_value
+ addend
;
3158 symbol_value
= (symbol_value
>> 16) & 0xffff;
3159 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
3160 data
, offset
, symbol_value
, addend
);
3163 static bfd_reloc_status_type
3164 nios2_elf32_do_lo16_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3165 asection
*input_section
,
3166 bfd_byte
*data
, bfd_vma offset
,
3167 bfd_vma symbol_value
, bfd_vma addend
)
3169 symbol_value
= symbol_value
+ addend
;
3171 symbol_value
= symbol_value
& 0xffff;
3172 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
3173 data
, offset
, symbol_value
, addend
);
3176 static bfd_reloc_status_type
3177 nios2_elf32_do_hiadj16_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3178 asection
*input_section
,
3179 bfd_byte
*data
, bfd_vma offset
,
3180 bfd_vma symbol_value
, bfd_vma addend
)
3182 symbol_value
= symbol_value
+ addend
;
3184 symbol_value
= hiadj(symbol_value
);
3185 return _bfd_final_link_relocate (howto
, abfd
, input_section
, data
, offset
,
3186 symbol_value
, addend
);
3189 static bfd_reloc_status_type
3190 nios2_elf32_do_pcrel_lo16_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3191 asection
*input_section
,
3192 bfd_byte
*data
, bfd_vma offset
,
3193 bfd_vma symbol_value
, bfd_vma addend
)
3195 symbol_value
= symbol_value
+ addend
;
3197 symbol_value
= symbol_value
& 0xffff;
3198 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
3199 data
, offset
, symbol_value
, addend
);
3202 static bfd_reloc_status_type
3203 nios2_elf32_do_pcrel_hiadj16_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3204 asection
*input_section
,
3205 bfd_byte
*data
, bfd_vma offset
,
3206 bfd_vma symbol_value
, bfd_vma addend
)
3208 symbol_value
= symbol_value
+ addend
;
3209 symbol_value
-= (input_section
->output_section
->vma
3210 + input_section
->output_offset
);
3211 symbol_value
-= offset
;
3213 symbol_value
= hiadj(symbol_value
);
3214 return _bfd_final_link_relocate (howto
, abfd
, input_section
, data
, offset
,
3215 symbol_value
, addend
);
3218 static bfd_reloc_status_type
3219 nios2_elf32_do_pcrel16_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3220 asection
*input_section
,
3221 bfd_byte
*data
, bfd_vma offset
,
3222 bfd_vma symbol_value
, bfd_vma addend
)
3224 /* NIOS2 pc relative relocations are relative to the next 32-bit instruction
3225 so we need to subtract 4 before doing a final_link_relocate. */
3226 symbol_value
= symbol_value
+ addend
- 4;
3228 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
3229 data
, offset
, symbol_value
, addend
);
3232 static bfd_reloc_status_type
3233 nios2_elf32_do_call26_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3234 asection
*input_section
,
3235 bfd_byte
*data
, bfd_vma offset
,
3236 bfd_vma symbol_value
, bfd_vma addend
)
3238 /* Check that the relocation is in the same page as the current address. */
3239 if (CALL26_SEGMENT (symbol_value
+ addend
)
3240 != CALL26_SEGMENT (input_section
->output_section
->vma
3241 + input_section
->output_offset
3243 return bfd_reloc_overflow
;
3245 /* Check that the target address is correctly aligned on a 4-byte
3247 if ((symbol_value
+ addend
) & 0x3)
3248 return bfd_reloc_overflow
;
3250 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
3251 data
, offset
, symbol_value
, addend
);
3254 static bfd_reloc_status_type
3255 nios2_elf32_do_gprel_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3256 asection
*input_section
,
3257 bfd_byte
*data
, bfd_vma offset
,
3258 bfd_vma symbol_value
, bfd_vma addend
)
3260 /* Because we need the output_bfd, the special handling is done
3261 in nios2_elf32_relocate_section or in nios2_elf32_gprel_relocate. */
3262 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
3263 data
, offset
, symbol_value
, addend
);
3266 static bfd_reloc_status_type
3267 nios2_elf32_do_ujmp_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3268 asection
*input_section
,
3269 bfd_byte
*data
, bfd_vma offset
,
3270 bfd_vma symbol_value
, bfd_vma addend
)
3272 bfd_vma symbol_lo16
, symbol_hi16
;
3273 bfd_reloc_status_type r
;
3274 symbol_value
= symbol_value
+ addend
;
3276 symbol_hi16
= (symbol_value
>> 16) & 0xffff;
3277 symbol_lo16
= symbol_value
& 0xffff;
3279 r
= _bfd_final_link_relocate (howto
, abfd
, input_section
,
3280 data
, offset
, symbol_hi16
, addend
);
3282 if (r
== bfd_reloc_ok
)
3283 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
3284 data
, offset
+ 4, symbol_lo16
, addend
);
3289 static bfd_reloc_status_type
3290 nios2_elf32_do_cjmp_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3291 asection
*input_section
,
3292 bfd_byte
*data
, bfd_vma offset
,
3293 bfd_vma symbol_value
, bfd_vma addend
)
3295 bfd_vma symbol_lo16
, symbol_hi16
;
3296 bfd_reloc_status_type r
;
3297 symbol_value
= symbol_value
+ addend
;
3299 symbol_hi16
= (symbol_value
>> 16) & 0xffff;
3300 symbol_lo16
= symbol_value
& 0xffff;
3302 r
= _bfd_final_link_relocate (howto
, abfd
, input_section
,
3303 data
, offset
, symbol_hi16
, addend
);
3305 if (r
== bfd_reloc_ok
)
3306 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
3307 data
, offset
+ 4, symbol_lo16
, addend
);
3312 static bfd_reloc_status_type
3313 nios2_elf32_do_callr_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3314 asection
*input_section
,
3315 bfd_byte
*data
, bfd_vma offset
,
3316 bfd_vma symbol_value
, bfd_vma addend
)
3318 bfd_vma symbol_lo16
, symbol_hi16
;
3319 bfd_reloc_status_type r
;
3320 symbol_value
= symbol_value
+ addend
;
3322 symbol_hi16
= (symbol_value
>> 16) & 0xffff;
3323 symbol_lo16
= symbol_value
& 0xffff;
3325 r
= _bfd_final_link_relocate (howto
, abfd
, input_section
,
3326 data
, offset
, symbol_hi16
, addend
);
3328 if (r
== bfd_reloc_ok
)
3329 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
3330 data
, offset
+ 4, symbol_lo16
, addend
);
3335 /* HOWTO handlers for relocations that require special handling. */
3337 /* This is for relocations used only when relaxing to ensure
3338 changes in size of section don't screw up .align. */
3339 static bfd_reloc_status_type
3340 nios2_elf32_ignore_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
3341 asymbol
*symbol ATTRIBUTE_UNUSED
,
3342 void *data ATTRIBUTE_UNUSED
, asection
*input_section
,
3344 char **error_message ATTRIBUTE_UNUSED
)
3346 if (output_bfd
!= NULL
)
3347 reloc_entry
->address
+= input_section
->output_offset
;
3348 return bfd_reloc_ok
;
3351 static bfd_reloc_status_type
3352 nios2_elf32_hi16_relocate (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
3353 void *data
, asection
*input_section
,
3355 char **error_message ATTRIBUTE_UNUSED
)
3357 /* This part is from bfd_elf_generic_reloc. */
3358 if (output_bfd
!= NULL
3359 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3360 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3362 reloc_entry
->address
+= input_section
->output_offset
;
3363 return bfd_reloc_ok
;
3366 if (output_bfd
!= NULL
)
3367 /* FIXME: See bfd_perform_relocation. Is this right? */
3368 return bfd_reloc_continue
;
3370 return nios2_elf32_do_hi16_relocate (abfd
, reloc_entry
->howto
,
3372 data
, reloc_entry
->address
,
3374 + symbol
->section
->output_section
->vma
3375 + symbol
->section
->output_offset
),
3376 reloc_entry
->addend
);
3379 static bfd_reloc_status_type
3380 nios2_elf32_lo16_relocate (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
3381 void *data
, asection
*input_section
,
3383 char **error_message ATTRIBUTE_UNUSED
)
3385 /* This part is from bfd_elf_generic_reloc. */
3386 if (output_bfd
!= NULL
3387 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3388 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3390 reloc_entry
->address
+= input_section
->output_offset
;
3391 return bfd_reloc_ok
;
3394 if (output_bfd
!= NULL
)
3395 /* FIXME: See bfd_perform_relocation. Is this right? */
3396 return bfd_reloc_continue
;
3398 return nios2_elf32_do_lo16_relocate (abfd
, reloc_entry
->howto
,
3400 data
, reloc_entry
->address
,
3402 + symbol
->section
->output_section
->vma
3403 + symbol
->section
->output_offset
),
3404 reloc_entry
->addend
);
3407 static bfd_reloc_status_type
3408 nios2_elf32_hiadj16_relocate (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
3409 void *data
, asection
*input_section
,
3411 char **error_message ATTRIBUTE_UNUSED
)
3413 /* This part is from bfd_elf_generic_reloc. */
3414 if (output_bfd
!= NULL
3415 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3416 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3418 reloc_entry
->address
+= input_section
->output_offset
;
3419 return bfd_reloc_ok
;
3422 if (output_bfd
!= NULL
)
3423 /* FIXME: See bfd_perform_relocation. Is this right? */
3424 return bfd_reloc_continue
;
3426 return nios2_elf32_do_hiadj16_relocate (abfd
, reloc_entry
->howto
,
3428 data
, reloc_entry
->address
,
3430 + symbol
->section
->output_section
->vma
3431 + symbol
->section
->output_offset
),
3432 reloc_entry
->addend
);
3435 static bfd_reloc_status_type
3436 nios2_elf32_pcrel_lo16_relocate (bfd
*abfd
, arelent
*reloc_entry
,
3437 asymbol
*symbol
, void *data
,
3438 asection
*input_section
, bfd
*output_bfd
,
3439 char **error_message ATTRIBUTE_UNUSED
)
3441 /* This part is from bfd_elf_generic_reloc. */
3442 if (output_bfd
!= NULL
3443 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3444 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3446 reloc_entry
->address
+= input_section
->output_offset
;
3447 return bfd_reloc_ok
;
3450 if (output_bfd
!= NULL
)
3451 /* FIXME: See bfd_perform_relocation. Is this right? */
3452 return bfd_reloc_continue
;
3454 return nios2_elf32_do_pcrel_lo16_relocate (
3455 abfd
, reloc_entry
->howto
, input_section
, data
, reloc_entry
->address
,
3456 (symbol
->value
+ symbol
->section
->output_section
->vma
3457 + symbol
->section
->output_offset
),
3458 reloc_entry
->addend
);
3461 static bfd_reloc_status_type
3462 nios2_elf32_pcrel_hiadj16_relocate (bfd
*abfd
, arelent
*reloc_entry
,
3463 asymbol
*symbol
, void *data
,
3464 asection
*input_section
, bfd
*output_bfd
,
3465 char **error_message ATTRIBUTE_UNUSED
)
3467 /* This part is from bfd_elf_generic_reloc. */
3468 if (output_bfd
!= NULL
3469 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3470 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3472 reloc_entry
->address
+= input_section
->output_offset
;
3473 return bfd_reloc_ok
;
3476 if (output_bfd
!= NULL
)
3477 /* FIXME: See bfd_perform_relocation. Is this right? */
3478 return bfd_reloc_continue
;
3480 return nios2_elf32_do_pcrel_hiadj16_relocate (
3481 abfd
, reloc_entry
->howto
, input_section
, data
, reloc_entry
->address
,
3482 (symbol
->value
+ symbol
->section
->output_section
->vma
3483 + symbol
->section
->output_offset
),
3484 reloc_entry
->addend
);
3487 static bfd_reloc_status_type
3488 nios2_elf32_pcrel16_relocate (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
3489 void *data
, asection
*input_section
,
3491 char **error_message ATTRIBUTE_UNUSED
)
3493 /* This part is from bfd_elf_generic_reloc. */
3494 if (output_bfd
!= NULL
3495 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3496 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3498 reloc_entry
->address
+= input_section
->output_offset
;
3499 return bfd_reloc_ok
;
3502 if (output_bfd
!= NULL
)
3503 /* FIXME: See bfd_perform_relocation. Is this right? */
3504 return bfd_reloc_continue
;
3506 return nios2_elf32_do_pcrel16_relocate (abfd
, reloc_entry
->howto
,
3508 data
, reloc_entry
->address
,
3510 + symbol
->section
->output_section
->vma
3511 + symbol
->section
->output_offset
),
3512 reloc_entry
->addend
);
3515 static bfd_reloc_status_type
3516 nios2_elf32_call26_relocate (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
3517 void *data
, asection
*input_section
,
3519 char **error_message ATTRIBUTE_UNUSED
)
3521 /* This part is from bfd_elf_generic_reloc. */
3522 if (output_bfd
!= NULL
3523 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3524 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3526 reloc_entry
->address
+= input_section
->output_offset
;
3527 return bfd_reloc_ok
;
3530 if (output_bfd
!= NULL
)
3531 /* FIXME: See bfd_perform_relocation. Is this right? */
3532 return bfd_reloc_continue
;
3534 return nios2_elf32_do_call26_relocate (abfd
, reloc_entry
->howto
,
3536 data
, reloc_entry
->address
,
3538 + symbol
->section
->output_section
->vma
3539 + symbol
->section
->output_offset
),
3540 reloc_entry
->addend
);
3543 static bfd_reloc_status_type
3544 nios2_elf32_gprel_relocate (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
3545 void *data
, asection
*input_section
,
3546 bfd
*output_bfd
, char **msg
)
3550 bfd_reloc_status_type r
;
3553 /* This part is from bfd_elf_generic_reloc. */
3554 if (output_bfd
!= NULL
3555 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3556 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3558 reloc_entry
->address
+= input_section
->output_offset
;
3559 return bfd_reloc_ok
;
3562 if (output_bfd
!= NULL
)
3563 /* FIXME: See bfd_perform_relocation. Is this right? */
3564 return bfd_reloc_continue
;
3566 relocation
= (symbol
->value
3567 + symbol
->section
->output_section
->vma
3568 + symbol
->section
->output_offset
);
3570 /* This assumes we've already cached the _gp symbol. */
3571 r
= nios2_elf_final_gp (abfd
, symbol
, FALSE
, msg
, &gp
);
3572 if (r
== bfd_reloc_ok
)
3574 relocation
= relocation
+ reloc_entry
->addend
- gp
;
3575 reloc_entry
->addend
= 0;
3576 if ((signed) relocation
< -32768 || (signed) relocation
> 32767)
3578 *msg
= _("global pointer relative address out of range");
3579 r
= bfd_reloc_outofrange
;
3582 r
= nios2_elf32_do_gprel_relocate (abfd
, reloc_entry
->howto
,
3584 data
, reloc_entry
->address
,
3585 relocation
, reloc_entry
->addend
);
3591 static bfd_reloc_status_type
3592 nios2_elf32_ujmp_relocate (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
3593 void *data
, asection
*input_section
,
3594 bfd
*output_bfd
, char **msg ATTRIBUTE_UNUSED
)
3596 /* This part is from bfd_elf_generic_reloc. */
3597 if (output_bfd
!= NULL
3598 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3599 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3601 reloc_entry
->address
+= input_section
->output_offset
;
3602 return bfd_reloc_ok
;
3605 if (output_bfd
!= NULL
)
3606 /* FIXME: See bfd_perform_relocation. Is this right? */
3607 return bfd_reloc_continue
;
3609 return nios2_elf32_do_ujmp_relocate (abfd
, reloc_entry
->howto
,
3611 data
, reloc_entry
->address
,
3613 + symbol
->section
->output_section
->vma
3614 + symbol
->section
->output_offset
),
3615 reloc_entry
->addend
);
3618 static bfd_reloc_status_type
3619 nios2_elf32_cjmp_relocate (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
3620 void *data
, asection
*input_section
,
3621 bfd
*output_bfd
, char **msg ATTRIBUTE_UNUSED
)
3623 /* This part is from bfd_elf_generic_reloc. */
3624 if (output_bfd
!= NULL
3625 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3626 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3628 reloc_entry
->address
+= input_section
->output_offset
;
3629 return bfd_reloc_ok
;
3632 if (output_bfd
!= NULL
)
3633 /* FIXME: See bfd_perform_relocation. Is this right? */
3634 return bfd_reloc_continue
;
3636 return nios2_elf32_do_cjmp_relocate (abfd
, reloc_entry
->howto
,
3638 data
, reloc_entry
->address
,
3640 + symbol
->section
->output_section
->vma
3641 + symbol
->section
->output_offset
),
3642 reloc_entry
->addend
);
3645 static bfd_reloc_status_type
3646 nios2_elf32_callr_relocate (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
3647 void *data
, asection
*input_section
,
3648 bfd
*output_bfd
, char **msg ATTRIBUTE_UNUSED
)
3650 /* This part is from bfd_elf_generic_reloc. */
3651 if (output_bfd
!= NULL
3652 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3653 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3655 reloc_entry
->address
+= input_section
->output_offset
;
3656 return bfd_reloc_ok
;
3659 if (output_bfd
!= NULL
)
3660 /* FIXME: See bfd_perform_relocation. Is this right? */
3661 return bfd_reloc_continue
;
3663 return nios2_elf32_do_callr_relocate (abfd
, reloc_entry
->howto
,
3665 data
, reloc_entry
->address
,
3667 + symbol
->section
->output_section
->vma
3668 + symbol
->section
->output_offset
),
3669 reloc_entry
->addend
);
3673 /* Implement elf_backend_relocate_section. */
3675 nios2_elf32_relocate_section (bfd
*output_bfd
,
3676 struct bfd_link_info
*info
,
3678 asection
*input_section
,
3680 Elf_Internal_Rela
*relocs
,
3681 Elf_Internal_Sym
*local_syms
,
3682 asection
**local_sections
)
3684 Elf_Internal_Shdr
*symtab_hdr
;
3685 struct elf_link_hash_entry
**sym_hashes
;
3686 Elf_Internal_Rela
*rel
;
3687 Elf_Internal_Rela
*relend
;
3688 struct elf32_nios2_link_hash_table
*htab
;
3691 asection
*sreloc
= NULL
;
3692 bfd_vma
*local_got_offsets
;
3695 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3696 sym_hashes
= elf_sym_hashes (input_bfd
);
3697 relend
= relocs
+ input_section
->reloc_count
;
3699 htab
= elf32_nios2_hash_table (info
);
3700 sgot
= htab
->root
.sgot
;
3701 splt
= htab
->root
.splt
;
3702 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3704 if (htab
->h_gp_got
== NULL
)
3707 got_base
= htab
->h_gp_got
->root
.u
.def
.value
;
3709 for (rel
= relocs
; rel
< relend
; rel
++)
3711 reloc_howto_type
*howto
;
3712 unsigned long r_symndx
;
3713 Elf_Internal_Sym
*sym
;
3715 struct elf_link_hash_entry
*h
;
3716 struct elf32_nios2_link_hash_entry
*eh
;
3719 bfd_reloc_status_type r
= bfd_reloc_ok
;
3720 const char *name
= NULL
;
3723 char *msgbuf
= NULL
;
3725 bfd_boolean unresolved_reloc
;
3729 r_type
= ELF32_R_TYPE (rel
->r_info
);
3730 r_symndx
= ELF32_R_SYM (rel
->r_info
);
3732 howto
= lookup_howto ((unsigned) ELF32_R_TYPE (rel
->r_info
), output_bfd
);
3737 if (r_symndx
< symtab_hdr
->sh_info
)
3739 sym
= local_syms
+ r_symndx
;
3740 sec
= local_sections
[r_symndx
];
3741 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
3745 bfd_boolean warned
, ignored
;
3747 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3748 r_symndx
, symtab_hdr
, sym_hashes
,
3750 unresolved_reloc
, warned
, ignored
);
3753 if (sec
&& discarded_section (sec
))
3754 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3755 rel
, 1, relend
, howto
, 0, contents
);
3757 /* Nothing more to do unless this is a final link. */
3758 if (bfd_link_relocatable (info
))
3763 bfd_boolean resolved_to_zero
;
3765 resolved_to_zero
= (h
!= NULL
3766 && UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
));
3767 switch (howto
->type
)
3770 r
= nios2_elf32_do_hi16_relocate (input_bfd
, howto
,
3772 contents
, rel
->r_offset
,
3773 relocation
, rel
->r_addend
);
3776 r
= nios2_elf32_do_lo16_relocate (input_bfd
, howto
,
3778 contents
, rel
->r_offset
,
3779 relocation
, rel
->r_addend
);
3781 case R_NIOS2_PCREL_LO
:
3782 r
= nios2_elf32_do_pcrel_lo16_relocate (input_bfd
, howto
,
3789 case R_NIOS2_HIADJ16
:
3790 r
= nios2_elf32_do_hiadj16_relocate (input_bfd
, howto
,
3791 input_section
, contents
,
3792 rel
->r_offset
, relocation
,
3795 case R_NIOS2_PCREL_HA
:
3796 r
= nios2_elf32_do_pcrel_hiadj16_relocate (input_bfd
, howto
,
3803 case R_NIOS2_PCREL16
:
3804 r
= nios2_elf32_do_pcrel16_relocate (input_bfd
, howto
,
3805 input_section
, contents
,
3806 rel
->r_offset
, relocation
,
3810 /* Turns an absolute address into a gp-relative address. */
3811 if (!nios2_elf_assign_gp (output_bfd
, &gp
, info
))
3813 bfd_vma reloc_address
;
3815 if (sec
&& sec
->output_section
)
3816 reloc_address
= (sec
->output_section
->vma
3817 + sec
->output_offset
3822 format
= _("global pointer relative relocation at address "
3823 "%#" PRIx64
" when _gp not defined\n");
3824 asprintf (&msgbuf
, format
, (uint64_t) reloc_address
);
3826 r
= bfd_reloc_dangerous
;
3830 bfd_vma symbol_address
= rel
->r_addend
+ relocation
;
3831 relocation
= symbol_address
- gp
;
3833 if (((signed) relocation
< -32768
3834 || (signed) relocation
> 32767)
3836 || h
->root
.type
== bfd_link_hash_defined
3837 || h
->root
.type
== bfd_link_hash_defweak
))
3840 name
= h
->root
.root
.string
;
3843 name
= (bfd_elf_string_from_elf_section
3844 (input_bfd
, symtab_hdr
->sh_link
,
3846 if (name
== NULL
|| *name
== '\0')
3847 name
= bfd_section_name (input_bfd
, sec
);
3849 /* xgettext:c-format */
3850 format
= _("unable to reach %s (at %#" PRIx64
") from "
3851 "the global pointer (at %#" PRIx64
") "
3852 "because the offset (%" PRId64
") is out of "
3853 "the allowed range, -32678 to 32767\n" );
3854 asprintf (&msgbuf
, format
, name
,
3855 (uint64_t) symbol_address
, (uint64_t) gp
,
3856 (int64_t) relocation
);
3858 r
= bfd_reloc_outofrange
;
3861 r
= _bfd_final_link_relocate (howto
, input_bfd
,
3862 input_section
, contents
,
3863 rel
->r_offset
, relocation
,
3868 r
= nios2_elf32_do_ujmp_relocate (input_bfd
, howto
,
3870 contents
, rel
->r_offset
,
3871 relocation
, rel
->r_addend
);
3874 r
= nios2_elf32_do_cjmp_relocate (input_bfd
, howto
,
3876 contents
, rel
->r_offset
,
3877 relocation
, rel
->r_addend
);
3880 r
= nios2_elf32_do_callr_relocate (input_bfd
, howto
,
3881 input_section
, contents
,
3882 rel
->r_offset
, relocation
,
3885 case R_NIOS2_CALL26
:
3886 case R_NIOS2_CALL26_NOAT
:
3887 /* If we have a call to an undefined weak symbol, we just want
3888 to stuff a zero in the bits of the call instruction and
3889 bypass the normal call26 relocation handling, because it'll
3890 diagnose an overflow error if address 0 isn't in the same
3891 256MB segment as the call site. Presumably the call
3892 should be guarded by a null check anyway. */
3893 if (h
!= NULL
&& h
->root
.type
== bfd_link_hash_undefweak
)
3895 BFD_ASSERT (relocation
== 0 && rel
->r_addend
== 0);
3896 r
= _bfd_final_link_relocate (howto
, input_bfd
,
3897 input_section
, contents
,
3898 rel
->r_offset
, relocation
,
3902 /* Handle relocations which should use the PLT entry.
3903 NIOS2_BFD_RELOC_32 relocations will use the symbol's value,
3904 which may point to a PLT entry, but we don't need to handle
3905 that here. If we created a PLT entry, all branches in this
3906 object should go to it. */
3907 if (h
!= NULL
&& splt
!= NULL
&& h
->plt
.offset
!= (bfd_vma
) -1)
3909 /* If we've created a .plt section, and assigned a PLT entry
3910 to this function, it should not be known to bind locally.
3911 If it were, we would have cleared the PLT entry. */
3912 BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info
, h
));
3914 relocation
= (splt
->output_section
->vma
3915 + splt
->output_offset
3918 unresolved_reloc
= FALSE
;
3920 /* Detect R_NIOS2_CALL26 relocations that would overflow the
3921 256MB segment. Replace the target with a reference to a
3923 Note that htab->stub_group is null if relaxation has been
3924 disabled by the --no-relax linker command-line option, so
3925 we can use that to skip this processing entirely. */
3926 if (howto
->type
== R_NIOS2_CALL26
&& htab
->stub_group
)
3928 bfd_vma dest
= relocation
+ rel
->r_addend
;
3929 enum elf32_nios2_stub_type stub_type
;
3931 eh
= (struct elf32_nios2_link_hash_entry
*)h
;
3932 stub_type
= nios2_type_of_stub (input_section
, rel
, eh
,
3935 if (stub_type
!= nios2_stub_none
)
3937 struct elf32_nios2_stub_hash_entry
*hsh
;
3939 hsh
= nios2_get_stub_entry (input_section
, sec
,
3940 eh
, rel
, htab
, stub_type
);
3943 r
= bfd_reloc_undefined
;
3947 dest
= (hsh
->stub_offset
3948 + hsh
->stub_sec
->output_offset
3949 + hsh
->stub_sec
->output_section
->vma
);
3950 r
= nios2_elf32_do_call26_relocate (input_bfd
, howto
,
3960 r
= nios2_elf32_do_call26_relocate (input_bfd
, howto
,
3961 input_section
, contents
,
3962 rel
->r_offset
, relocation
,
3967 /* For symmetry this would be
3968 r = nios2_elf32_do_ignore_reloc (input_bfd, howto,
3969 input_section, contents,
3970 rel->r_offset, relocation,
3972 but do_ignore_reloc would do no more than return
3977 case R_NIOS2_CALL16
:
3978 case R_NIOS2_GOT_LO
:
3979 case R_NIOS2_GOT_HA
:
3980 case R_NIOS2_CALL_LO
:
3981 case R_NIOS2_CALL_HA
:
3982 /* Relocation is to the entry for this symbol in the
3983 global offset table. */
3986 r
= bfd_reloc_notsupported
;
3996 eh
= (struct elf32_nios2_link_hash_entry
*)h
;
3997 use_plt
= (eh
->got_types_used
== CALL_USED
3998 && h
->plt
.offset
!= (bfd_vma
) -1);
4000 off
= h
->got
.offset
;
4001 BFD_ASSERT (off
!= (bfd_vma
) -1);
4002 dyn
= htab
->root
.dynamic_sections_created
;
4003 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
4004 bfd_link_pic (info
),
4006 || (bfd_link_pic (info
)
4007 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4008 || ((ELF_ST_VISIBILITY (h
->other
)
4009 || resolved_to_zero
)
4010 && h
->root
.type
== bfd_link_hash_undefweak
))
4012 /* This is actually a static link, or it is a -Bsymbolic
4013 link and the symbol is defined locally. We must
4014 initialize this entry in the global offset table.
4015 Since the offset must always be a multiple of 4, we
4016 use the least significant bit to record whether we
4017 have initialized it already.
4019 When doing a dynamic link, we create a .rela.got
4020 relocation entry to initialize the value. This is
4021 done in the finish_dynamic_symbol routine. */
4026 bfd_put_32 (output_bfd
, relocation
,
4027 sgot
->contents
+ off
);
4032 unresolved_reloc
= FALSE
;
4036 BFD_ASSERT (local_got_offsets
!= NULL
4037 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
4039 off
= local_got_offsets
[r_symndx
];
4041 /* The offset must always be a multiple of 4. We use the
4042 least significant bit to record whether we have already
4043 generated the necessary reloc. */
4048 bfd_put_32 (output_bfd
, relocation
,
4049 sgot
->contents
+ off
);
4051 if (bfd_link_pic (info
))
4054 Elf_Internal_Rela outrel
;
4057 srelgot
= htab
->root
.srelgot
;
4058 BFD_ASSERT (srelgot
!= NULL
);
4060 outrel
.r_addend
= relocation
;
4061 outrel
.r_offset
= (sgot
->output_section
->vma
4062 + sgot
->output_offset
4064 outrel
.r_info
= ELF32_R_INFO (0, R_NIOS2_RELATIVE
);
4065 loc
= srelgot
->contents
;
4066 loc
+= (srelgot
->reloc_count
++ *
4067 sizeof (Elf32_External_Rela
));
4068 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4071 local_got_offsets
[r_symndx
] |= 1;
4075 if (use_plt
&& bfd_link_pic (info
))
4077 off
= ((h
->plt
.offset
- 24) / 12 + 3) * 4;
4078 relocation
= (htab
->root
.sgotplt
->output_offset
+ off
4082 relocation
= sgot
->output_offset
+ off
- got_base
;
4084 /* This relocation does not use the addend. */
4087 switch (howto
->type
)
4089 case R_NIOS2_GOT_LO
:
4090 case R_NIOS2_CALL_LO
:
4091 r
= nios2_elf32_do_lo16_relocate (input_bfd
, howto
,
4092 input_section
, contents
,
4093 rel
->r_offset
, relocation
,
4096 case R_NIOS2_GOT_HA
:
4097 case R_NIOS2_CALL_HA
:
4098 r
= nios2_elf32_do_hiadj16_relocate (input_bfd
, howto
,
4099 input_section
, contents
,
4105 r
= _bfd_final_link_relocate (howto
, input_bfd
,
4106 input_section
, contents
,
4107 rel
->r_offset
, relocation
,
4113 case R_NIOS2_GOTOFF_LO
:
4114 case R_NIOS2_GOTOFF_HA
:
4115 case R_NIOS2_GOTOFF
:
4116 /* Relocation is relative to the global offset table pointer. */
4118 BFD_ASSERT (sgot
!= NULL
);
4121 r
= bfd_reloc_notsupported
;
4125 /* Note that sgot->output_offset is not involved in this
4126 calculation. We always want the start of .got. */
4127 relocation
-= sgot
->output_section
->vma
;
4129 /* Now we adjust the relocation to be relative to the GOT pointer
4130 (the _gp_got symbol), which possibly contains the 0x8000 bias. */
4131 relocation
-= got_base
;
4133 switch (howto
->type
)
4135 case R_NIOS2_GOTOFF_LO
:
4136 r
= nios2_elf32_do_lo16_relocate (input_bfd
, howto
,
4137 input_section
, contents
,
4138 rel
->r_offset
, relocation
,
4141 case R_NIOS2_GOTOFF_HA
:
4142 r
= nios2_elf32_do_hiadj16_relocate (input_bfd
, howto
,
4143 input_section
, contents
,
4149 r
= _bfd_final_link_relocate (howto
, input_bfd
,
4150 input_section
, contents
,
4151 rel
->r_offset
, relocation
,
4157 case R_NIOS2_TLS_LDO16
:
4158 relocation
-= dtpoff_base (info
) + DTP_OFFSET
;
4160 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4161 contents
, rel
->r_offset
,
4162 relocation
, rel
->r_addend
);
4164 case R_NIOS2_TLS_LDM16
:
4165 if (htab
->root
.sgot
== NULL
)
4168 off
= htab
->tls_ldm_got
.offset
;
4174 /* If we don't know the module number, create a relocation
4176 if (bfd_link_pic (info
))
4178 Elf_Internal_Rela outrel
;
4181 if (htab
->root
.srelgot
== NULL
)
4184 outrel
.r_addend
= 0;
4185 outrel
.r_offset
= (htab
->root
.sgot
->output_section
->vma
4186 + htab
->root
.sgot
->output_offset
4188 outrel
.r_info
= ELF32_R_INFO (0, R_NIOS2_TLS_DTPMOD
);
4190 loc
= htab
->root
.srelgot
->contents
;
4191 loc
+= (htab
->root
.srelgot
->reloc_count
++
4192 * sizeof (Elf32_External_Rela
));
4193 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4196 bfd_put_32 (output_bfd
, 1,
4197 htab
->root
.sgot
->contents
+ off
);
4199 htab
->tls_ldm_got
.offset
|= 1;
4202 relocation
= htab
->root
.sgot
->output_offset
+ off
- got_base
;
4204 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4205 contents
, rel
->r_offset
,
4206 relocation
, rel
->r_addend
);
4209 case R_NIOS2_TLS_GD16
:
4210 case R_NIOS2_TLS_IE16
:
4215 if (htab
->root
.sgot
== NULL
)
4222 dyn
= htab
->root
.dynamic_sections_created
;
4223 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
4224 bfd_link_pic (info
),
4226 && (!bfd_link_pic (info
)
4227 || !SYMBOL_REFERENCES_LOCAL (info
, h
)))
4229 unresolved_reloc
= FALSE
;
4232 off
= h
->got
.offset
;
4233 tls_type
= (((struct elf32_nios2_link_hash_entry
*) h
)
4238 if (local_got_offsets
== NULL
)
4240 off
= local_got_offsets
[r_symndx
];
4241 tls_type
= (elf32_nios2_local_got_tls_type (input_bfd
)
4245 if (tls_type
== GOT_UNKNOWN
)
4252 bfd_boolean need_relocs
= FALSE
;
4253 Elf_Internal_Rela outrel
;
4254 bfd_byte
*loc
= NULL
;
4257 /* The GOT entries have not been initialized yet. Do it
4258 now, and emit any relocations. If both an IE GOT and a
4259 GD GOT are necessary, we emit the GD first. */
4261 if ((bfd_link_pic (info
) || indx
!= 0)
4263 || (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4264 && !resolved_to_zero
)
4265 || h
->root
.type
!= bfd_link_hash_undefweak
))
4268 if (htab
->root
.srelgot
== NULL
)
4270 loc
= htab
->root
.srelgot
->contents
;
4271 loc
+= (htab
->root
.srelgot
->reloc_count
*
4272 sizeof (Elf32_External_Rela
));
4275 if (tls_type
& GOT_TLS_GD
)
4279 outrel
.r_addend
= 0;
4280 outrel
.r_offset
= (htab
->root
.sgot
->output_section
->vma
4281 + htab
->root
.sgot
->output_offset
4283 outrel
.r_info
= ELF32_R_INFO (indx
,
4284 R_NIOS2_TLS_DTPMOD
);
4286 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
4288 htab
->root
.srelgot
->reloc_count
++;
4289 loc
+= sizeof (Elf32_External_Rela
);
4292 bfd_put_32 (output_bfd
,
4293 (relocation
- dtpoff_base (info
) -
4295 htab
->root
.sgot
->contents
+ cur_off
+ 4);
4298 outrel
.r_addend
= 0;
4299 outrel
.r_info
= ELF32_R_INFO (indx
,
4300 R_NIOS2_TLS_DTPREL
);
4301 outrel
.r_offset
+= 4;
4303 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
4305 htab
->root
.srelgot
->reloc_count
++;
4306 loc
+= sizeof (Elf32_External_Rela
);
4311 /* If we are not emitting relocations for a
4312 general dynamic reference, then we must be in a
4313 static link or an executable link with the
4314 symbol binding locally. Mark it as belonging
4315 to module 1, the executable. */
4316 bfd_put_32 (output_bfd
, 1,
4317 htab
->root
.sgot
->contents
+ cur_off
);
4318 bfd_put_32 (output_bfd
, (relocation
-
4319 dtpoff_base (info
) -
4321 htab
->root
.sgot
->contents
+ cur_off
+ 4);
4327 if (tls_type
& GOT_TLS_IE
)
4332 outrel
.r_addend
= (relocation
-
4333 dtpoff_base (info
));
4335 outrel
.r_addend
= 0;
4336 outrel
.r_offset
= (htab
->root
.sgot
->output_section
->vma
4337 + htab
->root
.sgot
->output_offset
4339 outrel
.r_info
= ELF32_R_INFO (indx
,
4342 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
4344 htab
->root
.srelgot
->reloc_count
++;
4345 loc
+= sizeof (Elf32_External_Rela
);
4348 bfd_put_32 (output_bfd
, (tpoff (info
, relocation
)
4350 htab
->root
.sgot
->contents
+ cur_off
);
4357 local_got_offsets
[r_symndx
] |= 1;
4360 if ((tls_type
& GOT_TLS_GD
) && r_type
!= R_NIOS2_TLS_GD16
)
4362 relocation
= htab
->root
.sgot
->output_offset
+ off
- got_base
;
4364 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4365 contents
, rel
->r_offset
,
4366 relocation
, rel
->r_addend
);
4370 case R_NIOS2_TLS_LE16
:
4371 if (bfd_link_dll (info
))
4374 /* xgettext:c-format */
4375 (_("%pB(%pA+%#" PRIx64
"): %s relocation not "
4376 "permitted in shared object"),
4377 input_bfd
, input_section
,
4378 (uint64_t) rel
->r_offset
, howto
->name
);
4382 relocation
= tpoff (info
, relocation
) - TP_OFFSET
;
4384 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4385 contents
, rel
->r_offset
,
4386 relocation
, rel
->r_addend
);
4389 case R_NIOS2_BFD_RELOC_32
:
4390 if (bfd_link_pic (info
)
4391 && (input_section
->flags
& SEC_ALLOC
) != 0
4393 || (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4394 && !resolved_to_zero
)
4395 || h
->root
.type
!= bfd_link_hash_undefweak
))
4397 Elf_Internal_Rela outrel
;
4399 bfd_boolean skip
, relocate
;
4401 /* When generating a shared object, these relocations
4402 are copied into the output file to be resolved at run
4409 = _bfd_elf_section_offset (output_bfd
, info
,
4410 input_section
, rel
->r_offset
);
4411 if (outrel
.r_offset
== (bfd_vma
) -1)
4413 else if (outrel
.r_offset
== (bfd_vma
) -2)
4414 skip
= TRUE
, relocate
= TRUE
;
4415 outrel
.r_offset
+= (input_section
->output_section
->vma
4416 + input_section
->output_offset
);
4419 memset (&outrel
, 0, sizeof outrel
);
4422 && (!bfd_link_pic (info
)
4423 || !SYMBOLIC_BIND (info
, h
)
4424 || !h
->def_regular
))
4426 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
4427 outrel
.r_addend
= rel
->r_addend
;
4431 /* This symbol is local, or marked to become local. */
4432 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4434 outrel
.r_info
= ELF32_R_INFO (0, R_NIOS2_RELATIVE
);
4437 sreloc
= elf_section_data (input_section
)->sreloc
;
4441 loc
= sreloc
->contents
;
4442 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4443 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4445 /* This reloc will be computed at runtime, so there's no
4446 need to do anything now, except for R_NIOS2_BFD_RELOC_32
4447 relocations that have been turned into
4448 R_NIOS2_RELATIVE. */
4453 r
= _bfd_final_link_relocate (howto
, input_bfd
,
4454 input_section
, contents
,
4455 rel
->r_offset
, relocation
,
4459 case R_NIOS2_TLS_DTPREL
:
4460 relocation
-= dtpoff_base (info
);
4464 r
= _bfd_final_link_relocate (howto
, input_bfd
,
4465 input_section
, contents
,
4466 rel
->r_offset
, relocation
,
4472 r
= bfd_reloc_notsupported
;
4474 if (r
!= bfd_reloc_ok
)
4477 name
= h
->root
.root
.string
;
4480 name
= bfd_elf_string_from_elf_section (input_bfd
,
4481 symtab_hdr
->sh_link
,
4483 if (name
== NULL
|| *name
== '\0')
4484 name
= bfd_section_name (input_bfd
, sec
);
4489 case bfd_reloc_overflow
:
4490 (*info
->callbacks
->reloc_overflow
) (info
, NULL
, name
,
4491 howto
->name
, (bfd_vma
) 0,
4492 input_bfd
, input_section
,
4496 case bfd_reloc_undefined
:
4497 (*info
->callbacks
->undefined_symbol
) (info
, name
, input_bfd
,
4499 rel
->r_offset
, TRUE
);
4502 case bfd_reloc_outofrange
:
4504 msg
= _("relocation out of range");
4507 case bfd_reloc_notsupported
:
4509 msg
= _("unsupported relocation");
4512 case bfd_reloc_dangerous
:
4514 msg
= _("dangerous relocation");
4519 msg
= _("unknown error");
4525 (*info
->callbacks
->warning
) (info
, msg
, name
, input_bfd
,
4526 input_section
, rel
->r_offset
);
4536 /* Implement elf-backend_section_flags:
4537 Convert NIOS2 specific section flags to bfd internal section flags. */
4539 nios2_elf32_section_flags (flagword
*flags
, const Elf_Internal_Shdr
*hdr
)
4541 if (hdr
->sh_flags
& SHF_NIOS2_GPREL
)
4542 *flags
|= SEC_SMALL_DATA
;
4547 /* Implement elf_backend_fake_sections:
4548 Set the correct type for an NIOS2 ELF section. We do this by the
4549 section name, which is a hack, but ought to work. */
4551 nios2_elf32_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
4552 Elf_Internal_Shdr
*hdr
, asection
*sec
)
4554 register const char *name
= bfd_get_section_name (abfd
, sec
);
4556 if ((sec
->flags
& SEC_SMALL_DATA
)
4557 || strcmp (name
, ".sdata") == 0
4558 || strcmp (name
, ".sbss") == 0
4559 || strcmp (name
, ".lit4") == 0 || strcmp (name
, ".lit8") == 0)
4560 hdr
->sh_flags
|= SHF_NIOS2_GPREL
;
4565 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
4566 shortcuts to them in our hash table. */
4568 create_got_section (bfd
*dynobj
, struct bfd_link_info
*info
)
4570 struct elf32_nios2_link_hash_table
*htab
;
4571 struct elf_link_hash_entry
*h
;
4573 htab
= elf32_nios2_hash_table (info
);
4575 if (! _bfd_elf_create_got_section (dynobj
, info
))
4578 /* In order for the two loads in .PLTresolve to share the same %hiadj,
4579 _GLOBAL_OFFSET_TABLE_ must be aligned to a 16-byte boundary. */
4580 if (!bfd_set_section_alignment (dynobj
, htab
->root
.sgotplt
, 4))
4583 /* The Nios II ABI specifies that GOT-relative relocations are relative
4584 to the linker-created symbol _gp_got, rather than using
4585 _GLOBAL_OFFSET_TABLE_ directly. In particular, the latter always
4586 points to the base of the GOT while _gp_got may include a bias. */
4587 h
= _bfd_elf_define_linkage_sym (dynobj
, info
, htab
->root
.sgotplt
,
4596 /* Implement elf_backend_create_dynamic_sections:
4597 Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
4598 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
4601 nios2_elf32_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
4603 struct elf32_nios2_link_hash_table
*htab
;
4605 htab
= elf32_nios2_hash_table (info
);
4606 if (!htab
->root
.sgot
&& !create_got_section (dynobj
, info
))
4609 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
4612 /* In order for the two loads in a shared object .PLTresolve to share the
4613 same %hiadj, the start of the PLT (as well as the GOT) must be aligned
4614 to a 16-byte boundary. This is because the addresses for these loads
4615 include the -(.plt+4) PIC correction. */
4616 return bfd_set_section_alignment (dynobj
, htab
->root
.splt
, 4);
4619 /* Implement elf_backend_copy_indirect_symbol:
4620 Copy the extra info we tack onto an elf_link_hash_entry. */
4622 nios2_elf32_copy_indirect_symbol (struct bfd_link_info
*info
,
4623 struct elf_link_hash_entry
*dir
,
4624 struct elf_link_hash_entry
*ind
)
4626 struct elf32_nios2_link_hash_entry
*edir
, *eind
;
4628 edir
= (struct elf32_nios2_link_hash_entry
*) dir
;
4629 eind
= (struct elf32_nios2_link_hash_entry
*) ind
;
4631 if (eind
->dyn_relocs
!= NULL
)
4633 if (edir
->dyn_relocs
!= NULL
)
4635 struct elf_dyn_relocs
**pp
;
4636 struct elf_dyn_relocs
*p
;
4638 /* Add reloc counts against the indirect sym to the direct sym
4639 list. Merge any entries against the same section. */
4640 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
4642 struct elf_dyn_relocs
*q
;
4644 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
4645 if (q
->sec
== p
->sec
)
4647 q
->pc_count
+= p
->pc_count
;
4648 q
->count
+= p
->count
;
4655 *pp
= edir
->dyn_relocs
;
4658 edir
->dyn_relocs
= eind
->dyn_relocs
;
4659 eind
->dyn_relocs
= NULL
;
4662 if (ind
->root
.type
== bfd_link_hash_indirect
4663 && dir
->got
.refcount
<= 0)
4665 edir
->tls_type
= eind
->tls_type
;
4666 eind
->tls_type
= GOT_UNKNOWN
;
4669 edir
->got_types_used
|= eind
->got_types_used
;
4671 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
4674 /* Set the right machine number for a NIOS2 ELF file. */
4677 nios2_elf32_object_p (bfd
*abfd
)
4681 mach
= elf_elfheader (abfd
)->e_flags
;
4686 case EF_NIOS2_ARCH_R1
:
4687 bfd_default_set_arch_mach (abfd
, bfd_arch_nios2
, bfd_mach_nios2r1
);
4689 case EF_NIOS2_ARCH_R2
:
4690 bfd_default_set_arch_mach (abfd
, bfd_arch_nios2
, bfd_mach_nios2r2
);
4697 /* Implement elf_backend_check_relocs:
4698 Look through the relocs for a section during the first phase. */
4700 nios2_elf32_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
4701 asection
*sec
, const Elf_Internal_Rela
*relocs
)
4703 Elf_Internal_Shdr
*symtab_hdr
;
4704 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
4705 const Elf_Internal_Rela
*rel
;
4706 const Elf_Internal_Rela
*rel_end
;
4707 struct elf32_nios2_link_hash_table
*htab
;
4708 asection
*sreloc
= NULL
;
4709 bfd_signed_vma
*local_got_refcounts
;
4711 if (bfd_link_relocatable (info
))
4714 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4715 sym_hashes
= elf_sym_hashes (abfd
);
4716 sym_hashes_end
= (sym_hashes
4717 + symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
));
4718 if (!elf_bad_symtab (abfd
))
4719 sym_hashes_end
-= symtab_hdr
->sh_info
;
4720 local_got_refcounts
= elf_local_got_refcounts (abfd
);
4722 htab
= elf32_nios2_hash_table (info
);
4724 rel_end
= relocs
+ sec
->reloc_count
;
4725 for (rel
= relocs
; rel
< rel_end
; rel
++)
4727 unsigned int r_type
;
4728 struct elf_link_hash_entry
*h
;
4729 unsigned long r_symndx
;
4731 r_symndx
= ELF32_R_SYM (rel
->r_info
);
4732 if (r_symndx
< symtab_hdr
->sh_info
)
4736 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
4737 while (h
->root
.type
== bfd_link_hash_indirect
4738 || h
->root
.type
== bfd_link_hash_warning
)
4739 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4742 r_type
= ELF32_R_TYPE (rel
->r_info
);
4747 case R_NIOS2_GOT_LO
:
4748 case R_NIOS2_GOT_HA
:
4749 case R_NIOS2_CALL16
:
4750 case R_NIOS2_CALL_LO
:
4751 case R_NIOS2_CALL_HA
:
4752 case R_NIOS2_TLS_GD16
:
4753 case R_NIOS2_TLS_IE16
:
4754 /* This symbol requires a global offset table entry. */
4756 int tls_type
, old_tls_type
;
4762 case R_NIOS2_GOT_LO
:
4763 case R_NIOS2_GOT_HA
:
4764 case R_NIOS2_CALL16
:
4765 case R_NIOS2_CALL_LO
:
4766 case R_NIOS2_CALL_HA
:
4767 tls_type
= GOT_NORMAL
;
4769 case R_NIOS2_TLS_GD16
:
4770 tls_type
= GOT_TLS_GD
;
4772 case R_NIOS2_TLS_IE16
:
4773 tls_type
= GOT_TLS_IE
;
4779 struct elf32_nios2_link_hash_entry
*eh
4780 = (struct elf32_nios2_link_hash_entry
*)h
;
4782 old_tls_type
= elf32_nios2_hash_entry(h
)->tls_type
;
4783 if (r_type
== R_NIOS2_CALL16
4784 || r_type
== R_NIOS2_CALL_LO
4785 || r_type
== R_NIOS2_CALL_HA
)
4787 /* Make sure a plt entry is created for this symbol if
4788 it turns out to be a function defined by a dynamic
4793 eh
->got_types_used
|= CALL_USED
;
4796 eh
->got_types_used
|= GOT_USED
;
4800 /* This is a global offset table entry for a local symbol. */
4801 if (local_got_refcounts
== NULL
)
4805 size
= symtab_hdr
->sh_info
;
4806 size
*= (sizeof (bfd_signed_vma
) + sizeof (char));
4808 = ((bfd_signed_vma
*) bfd_zalloc (abfd
, size
));
4809 if (local_got_refcounts
== NULL
)
4811 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
4812 elf32_nios2_local_got_tls_type (abfd
)
4813 = (char *) (local_got_refcounts
+ symtab_hdr
->sh_info
);
4815 local_got_refcounts
[r_symndx
]++;
4816 old_tls_type
= elf32_nios2_local_got_tls_type (abfd
) [r_symndx
];
4819 /* We will already have issued an error message if there is a
4820 TLS / non-TLS mismatch, based on the symbol type. We don't
4821 support any linker relaxations. So just combine any TLS
4823 if (old_tls_type
!= GOT_UNKNOWN
&& old_tls_type
!= GOT_NORMAL
4824 && tls_type
!= GOT_NORMAL
)
4825 tls_type
|= old_tls_type
;
4827 if (old_tls_type
!= tls_type
)
4830 elf32_nios2_hash_entry (h
)->tls_type
= tls_type
;
4832 elf32_nios2_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
4836 if (htab
->root
.sgot
== NULL
)
4838 if (htab
->root
.dynobj
== NULL
)
4839 htab
->root
.dynobj
= abfd
;
4840 if (!create_got_section (htab
->root
.dynobj
, info
))
4845 case R_NIOS2_TLS_LDM16
:
4846 htab
->tls_ldm_got
.refcount
++;
4849 /* This relocation describes the C++ object vtable hierarchy.
4850 Reconstruct it for later use during GC. */
4851 case R_NIOS2_GNU_VTINHERIT
:
4852 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
4856 /* This relocation describes which C++ vtable entries are actually
4857 used. Record for later use during GC. */
4858 case R_NIOS2_GNU_VTENTRY
:
4859 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
4863 case R_NIOS2_BFD_RELOC_32
:
4864 case R_NIOS2_CALL26
:
4865 case R_NIOS2_CALL26_NOAT
:
4866 case R_NIOS2_HIADJ16
:
4871 /* If this reloc is in a read-only section, we might
4872 need a copy reloc. We can't check reliably at this
4873 stage whether the section is read-only, as input
4874 sections have not yet been mapped to output sections.
4875 Tentatively set the flag for now, and correct in
4876 adjust_dynamic_symbol. */
4877 if (!bfd_link_pic (info
))
4880 /* Make sure a plt entry is created for this symbol if it
4881 turns out to be a function defined by a dynamic object. */
4884 if (r_type
== R_NIOS2_CALL26
|| r_type
== R_NIOS2_CALL26_NOAT
)
4888 /* If we are creating a shared library, we need to copy the
4889 reloc into the shared library. */
4890 if (bfd_link_pic (info
)
4891 && (sec
->flags
& SEC_ALLOC
) != 0
4892 && (r_type
== R_NIOS2_BFD_RELOC_32
4893 || (h
!= NULL
&& ! h
->needs_plt
4894 && (! SYMBOLIC_BIND (info
, h
) || ! h
->def_regular
))))
4896 struct elf_dyn_relocs
*p
;
4897 struct elf_dyn_relocs
**head
;
4899 /* When creating a shared object, we must copy these
4900 reloc types into the output file. We create a reloc
4901 section in dynobj and make room for this reloc. */
4904 if (htab
->root
.dynobj
== NULL
)
4905 htab
->root
.dynobj
= abfd
;
4907 sreloc
= _bfd_elf_make_dynamic_reloc_section
4908 (sec
, htab
->root
.dynobj
, 2, abfd
, TRUE
);
4913 /* If this is a global symbol, we count the number of
4914 relocations we need for this symbol. */
4916 head
= &((struct elf32_nios2_link_hash_entry
*) h
)->dyn_relocs
;
4919 /* Track dynamic relocs needed for local syms too.
4920 We really need local syms available to do this
4925 Elf_Internal_Sym
*isym
;
4927 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
4932 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
4936 vpp
= &elf_section_data (s
)->local_dynrel
;
4937 head
= (struct elf_dyn_relocs
**) vpp
;
4941 if (p
== NULL
|| p
->sec
!= sec
)
4943 bfd_size_type amt
= sizeof *p
;
4944 p
= ((struct elf_dyn_relocs
*)
4945 bfd_alloc (htab
->root
.dynobj
, amt
));
4966 /* Implement elf_backend_gc_mark_hook:
4967 Return the section that should be marked against GC for a given
4970 nios2_elf32_gc_mark_hook (asection
*sec
,
4971 struct bfd_link_info
*info
,
4972 Elf_Internal_Rela
*rel
,
4973 struct elf_link_hash_entry
*h
,
4974 Elf_Internal_Sym
*sym
)
4977 switch (ELF32_R_TYPE (rel
->r_info
))
4979 case R_NIOS2_GNU_VTINHERIT
:
4980 case R_NIOS2_GNU_VTENTRY
:
4983 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
4986 /* Implement elf_backend_finish_dynamic_symbols:
4987 Finish up dynamic symbol handling. We set the contents of various
4988 dynamic sections here. */
4990 nios2_elf32_finish_dynamic_symbol (bfd
*output_bfd
,
4991 struct bfd_link_info
*info
,
4992 struct elf_link_hash_entry
*h
,
4993 Elf_Internal_Sym
*sym
)
4995 struct elf32_nios2_link_hash_table
*htab
;
4996 struct elf32_nios2_link_hash_entry
*eh
4997 = (struct elf32_nios2_link_hash_entry
*)h
;
5000 htab
= elf32_nios2_hash_table (info
);
5002 if (h
->plt
.offset
!= (bfd_vma
) -1)
5009 Elf_Internal_Rela rela
;
5011 bfd_vma got_address
;
5013 /* This symbol has an entry in the procedure linkage table. Set
5015 BFD_ASSERT (h
->dynindx
!= -1);
5016 splt
= htab
->root
.splt
;
5017 sgotplt
= htab
->root
.sgotplt
;
5018 srela
= htab
->root
.srelplt
;
5019 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
&& srela
!= NULL
);
5021 /* Emit the PLT entry. */
5022 if (bfd_link_pic (info
))
5024 nios2_elf32_install_data (splt
, nios2_so_plt_entry
, h
->plt
.offset
,
5026 plt_index
= (h
->plt
.offset
- 24) / 12;
5027 got_offset
= (plt_index
+ 3) * 4;
5028 nios2_elf32_install_imm16 (splt
, h
->plt
.offset
,
5029 hiadj(plt_index
* 4));
5030 nios2_elf32_install_imm16 (splt
, h
->plt
.offset
+ 4,
5031 (plt_index
* 4) & 0xffff);
5032 nios2_elf32_install_imm16 (splt
, h
->plt
.offset
+ 8,
5033 0xfff4 - h
->plt
.offset
);
5034 got_address
= (sgotplt
->output_section
->vma
+ sgotplt
->output_offset
5037 /* Fill in the entry in the global offset table. There are no
5038 res_n slots for a shared object PLT, instead the .got.plt entries
5039 point to the PLT entries. */
5040 bfd_put_32 (output_bfd
,
5041 splt
->output_section
->vma
+ splt
->output_offset
5042 + h
->plt
.offset
, sgotplt
->contents
+ got_offset
);
5046 plt_index
= (h
->plt
.offset
- 28 - htab
->res_n_size
) / 12;
5047 got_offset
= (plt_index
+ 3) * 4;
5049 nios2_elf32_install_data (splt
, nios2_plt_entry
, h
->plt
.offset
, 3);
5050 got_address
= (sgotplt
->output_section
->vma
+ sgotplt
->output_offset
5052 nios2_elf32_install_imm16 (splt
, h
->plt
.offset
, hiadj(got_address
));
5053 nios2_elf32_install_imm16 (splt
, h
->plt
.offset
+ 4,
5054 got_address
& 0xffff);
5056 /* Fill in the entry in the global offset table. */
5057 bfd_put_32 (output_bfd
,
5058 splt
->output_section
->vma
+ splt
->output_offset
5059 + plt_index
* 4, sgotplt
->contents
+ got_offset
);
5062 /* Fill in the entry in the .rela.plt section. */
5063 rela
.r_offset
= got_address
;
5064 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_NIOS2_JUMP_SLOT
);
5066 loc
= srela
->contents
+ plt_index
* sizeof (Elf32_External_Rela
);
5067 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
5069 if (!h
->def_regular
)
5071 /* Mark the symbol as undefined, rather than as defined in
5072 the .plt section. Leave the value alone. */
5073 sym
->st_shndx
= SHN_UNDEF
;
5074 /* If the symbol is weak, we do need to clear the value.
5075 Otherwise, the PLT entry would provide a definition for
5076 the symbol even if the symbol wasn't defined anywhere,
5077 and so the symbol would never be NULL. */
5078 if (!h
->ref_regular_nonweak
)
5083 use_plt
= (eh
->got_types_used
== CALL_USED
5084 && h
->plt
.offset
!= (bfd_vma
) -1);
5086 if (!use_plt
&& h
->got
.offset
!= (bfd_vma
) -1
5087 && (elf32_nios2_hash_entry (h
)->tls_type
& GOT_TLS_GD
) == 0
5088 && (elf32_nios2_hash_entry (h
)->tls_type
& GOT_TLS_IE
) == 0)
5092 Elf_Internal_Rela rela
;
5096 /* This symbol has an entry in the global offset table. Set it
5098 sgot
= htab
->root
.sgot
;
5099 srela
= htab
->root
.srelgot
;
5100 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
5102 offset
= (h
->got
.offset
& ~(bfd_vma
) 1);
5103 rela
.r_offset
= (sgot
->output_section
->vma
5104 + sgot
->output_offset
+ offset
);
5106 /* If this is a -Bsymbolic link, and the symbol is defined
5107 locally, we just want to emit a RELATIVE reloc. Likewise if
5108 the symbol was forced to be local because of a version file.
5109 The entry in the global offset table will already have been
5110 initialized in the relocate_section function. */
5112 if (bfd_link_pic (info
) && SYMBOL_REFERENCES_LOCAL (info
, h
))
5114 rela
.r_info
= ELF32_R_INFO (0, R_NIOS2_RELATIVE
);
5115 rela
.r_addend
= bfd_get_signed_32 (output_bfd
,
5116 (sgot
->contents
+ offset
));
5117 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ offset
);
5121 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
5122 sgot
->contents
+ offset
);
5123 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_NIOS2_GLOB_DAT
);
5127 loc
= srela
->contents
;
5128 loc
+= srela
->reloc_count
++ * sizeof (Elf32_External_Rela
);
5129 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
5132 if (use_plt
&& h
->got
.offset
!= (bfd_vma
) -1)
5134 bfd_vma offset
= (h
->got
.offset
& ~(bfd_vma
) 1);
5135 asection
*sgot
= htab
->root
.sgot
;
5136 asection
*splt
= htab
->root
.splt
;
5137 bfd_put_32 (output_bfd
, (splt
->output_section
->vma
+ splt
->output_offset
5139 sgot
->contents
+ offset
);
5145 Elf_Internal_Rela rela
;
5148 /* This symbol needs a copy reloc. Set it up. */
5149 BFD_ASSERT (h
->dynindx
!= -1
5150 && (h
->root
.type
== bfd_link_hash_defined
5151 || h
->root
.type
== bfd_link_hash_defweak
));
5153 rela
.r_offset
= (h
->root
.u
.def
.value
5154 + h
->root
.u
.def
.section
->output_section
->vma
5155 + h
->root
.u
.def
.section
->output_offset
);
5156 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_NIOS2_COPY
);
5158 if (h
->root
.u
.def
.section
== htab
->root
.sdynrelro
)
5159 s
= htab
->root
.sreldynrelro
;
5161 s
= htab
->root
.srelbss
;
5162 BFD_ASSERT (s
!= NULL
);
5163 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
5164 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
5167 /* Mark _DYNAMIC, _GLOBAL_OFFSET_TABLE_, and _gp_got as absolute. */
5168 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
5169 || h
== htab
->root
.hgot
5170 || h
== htab
->h_gp_got
)
5171 sym
->st_shndx
= SHN_ABS
;
5176 /* Implement elf_backend_finish_dynamic_sections. */
5178 nios2_elf32_finish_dynamic_sections (bfd
*output_bfd
,
5179 struct bfd_link_info
*info
)
5183 struct elf32_nios2_link_hash_table
*htab
;
5185 htab
= elf32_nios2_hash_table (info
);
5186 sgotplt
= htab
->root
.sgotplt
;
5189 if (htab
->root
.dynamic_sections_created
)
5192 Elf32_External_Dyn
*dyncon
, *dynconend
;
5194 splt
= htab
->root
.splt
;
5195 sdyn
= bfd_get_linker_section (htab
->root
.dynobj
, ".dynamic");
5196 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
&& sgotplt
!= NULL
);
5198 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
5199 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
5200 for (; dyncon
< dynconend
; dyncon
++)
5202 Elf_Internal_Dyn dyn
;
5205 bfd_elf32_swap_dyn_in (htab
->root
.dynobj
, dyncon
, &dyn
);
5213 s
= htab
->root
.sgotplt
;
5214 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5215 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5219 s
= htab
->root
.srelplt
;
5220 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5221 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5225 s
= htab
->root
.srelplt
;
5226 dyn
.d_un
.d_val
= s
->size
;
5227 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5231 s
= htab
->root
.sgotplt
;
5233 = s
->output_section
->vma
+ s
->output_offset
+ 0x7ff0;
5234 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5239 /* Fill in the first entry in the procedure linkage table. */
5242 bfd_vma got_address
= (sgotplt
->output_section
->vma
5243 + sgotplt
->output_offset
);
5244 if (bfd_link_pic (info
))
5246 bfd_vma got_pcrel
= got_address
- (splt
->output_section
->vma
5247 + splt
->output_offset
);
5248 /* Both GOT and PLT must be aligned to a 16-byte boundary
5249 for the two loads to share the %hiadj part. The 4-byte
5250 offset for nextpc is accounted for in the %lo offsets
5252 BFD_ASSERT ((got_pcrel
& 0xf) == 0);
5253 nios2_elf32_install_data (splt
, nios2_so_plt0_entry
, 0, 6);
5254 nios2_elf32_install_imm16 (splt
, 4, hiadj (got_pcrel
));
5255 nios2_elf32_install_imm16 (splt
, 12, got_pcrel
& 0xffff);
5256 nios2_elf32_install_imm16 (splt
, 16, (got_pcrel
+ 4) & 0xffff);
5260 /* Divide by 4 here, not 3 because we already corrected for the
5262 bfd_vma res_size
= (splt
->size
- 28) / 4;
5263 bfd_vma res_start
= (splt
->output_section
->vma
5264 + splt
->output_offset
);
5267 for (res_offset
= 0; res_offset
< res_size
; res_offset
+= 4)
5268 bfd_put_32 (output_bfd
,
5269 6 | ((res_size
- (res_offset
+ 4)) << 6),
5270 splt
->contents
+ res_offset
);
5272 /* The GOT must be aligned to a 16-byte boundary for the
5273 two loads to share the same %hiadj part. */
5274 BFD_ASSERT ((got_address
& 0xf) == 0);
5276 nios2_elf32_install_data (splt
, nios2_plt0_entry
, res_size
, 7);
5277 nios2_elf32_install_imm16 (splt
, res_size
, hiadj (res_start
));
5278 nios2_elf32_install_imm16 (splt
, res_size
+ 4,
5279 res_start
& 0xffff);
5280 nios2_elf32_install_imm16 (splt
, res_size
+ 12,
5281 hiadj (got_address
));
5282 nios2_elf32_install_imm16 (splt
, res_size
+ 16,
5283 (got_address
+ 4) & 0xffff);
5284 nios2_elf32_install_imm16 (splt
, res_size
+ 20,
5285 (got_address
+ 8) & 0xffff);
5290 /* Fill in the first three entries in the global offset table. */
5291 if (sgotplt
!= NULL
&& sgotplt
->size
> 0)
5294 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgotplt
->contents
);
5296 bfd_put_32 (output_bfd
,
5297 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
5299 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgotplt
->contents
+ 4);
5300 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgotplt
->contents
+ 8);
5302 if (sgotplt
->output_section
!= bfd_abs_section_ptr
)
5303 elf_section_data (sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
5309 /* Implement elf_backend_adjust_dynamic_symbol:
5310 Adjust a symbol defined by a dynamic object and referenced by a
5311 regular object. The current definition is in some section of the
5312 dynamic object, but we're not including those sections. We have to
5313 change the definition to something the rest of the link can
5316 nios2_elf32_adjust_dynamic_symbol (struct bfd_link_info
*info
,
5317 struct elf_link_hash_entry
*h
)
5319 struct elf32_nios2_link_hash_table
*htab
;
5324 htab
= elf32_nios2_hash_table (info
);
5325 dynobj
= htab
->root
.dynobj
;
5327 /* Make sure we know what is going on here. */
5328 BFD_ASSERT (dynobj
!= NULL
5333 && !h
->def_regular
)));
5335 /* If this is a function, put it in the procedure linkage table. We
5336 will fill in the contents of the procedure linkage table later,
5337 when we know the address of the .got section. */
5338 if (h
->type
== STT_FUNC
|| h
->needs_plt
)
5340 if (h
->plt
.refcount
<= 0
5341 || SYMBOL_CALLS_LOCAL (info
, h
)
5342 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
5343 && h
->root
.type
== bfd_link_hash_undefweak
))
5345 /* This case can occur if we saw a PLT reloc in an input
5346 file, but the symbol was never referred to by a dynamic
5347 object, or if all references were garbage collected. In
5348 such a case, we don't actually need to build a procedure
5349 linkage table, and we can just do a PCREL reloc instead. */
5350 h
->plt
.offset
= (bfd_vma
) -1;
5357 /* Reinitialize the plt offset now that it is not used as a reference
5359 h
->plt
.offset
= (bfd_vma
) -1;
5361 /* If this is a weak symbol, and there is a real definition, the
5362 processor independent code will have arranged for us to see the
5363 real definition first, and we can just use the same value. */
5364 if (h
->is_weakalias
)
5366 struct elf_link_hash_entry
*def
= weakdef (h
);
5367 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
5368 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
5369 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
5373 /* If there are no non-GOT references, we do not need a copy
5375 if (!h
->non_got_ref
)
5378 /* This is a reference to a symbol defined by a dynamic object which
5380 If we are creating a shared library, we must presume that the
5381 only references to the symbol are via the global offset table.
5382 For such cases we need not do anything here; the relocations will
5383 be handled correctly by relocate_section. */
5384 if (bfd_link_pic (info
))
5389 _bfd_error_handler (_("dynamic variable `%s' is zero size"),
5390 h
->root
.root
.string
);
5394 /* We must allocate the symbol in our .dynbss section, which will
5395 become part of the .bss section of the executable. There will be
5396 an entry for this symbol in the .dynsym section. The dynamic
5397 object will contain position independent code, so all references
5398 from the dynamic object to this symbol will go through the global
5399 offset table. The dynamic linker will use the .dynsym entry to
5400 determine the address it must put in the global offset table, so
5401 both the dynamic object and the regular object will refer to the
5402 same memory location for the variable. */
5403 /* We must generate a R_NIOS2_COPY reloc to tell the dynamic linker to
5404 copy the initial value out of the dynamic object and into the
5405 runtime process image. We need to remember the offset into the
5406 .rela.bss section we are going to use. */
5407 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
5409 s
= htab
->root
.sdynrelro
;
5410 srel
= htab
->root
.sreldynrelro
;
5414 s
= htab
->root
.sdynbss
;
5415 srel
= htab
->root
.srelbss
;
5417 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
5419 srel
->size
+= sizeof (Elf32_External_Rela
);
5423 align2
= bfd_log2 (h
->size
);
5424 if (align2
> h
->root
.u
.def
.section
->alignment_power
)
5425 align2
= h
->root
.u
.def
.section
->alignment_power
;
5428 s
->size
= BFD_ALIGN (s
->size
, (bfd_size_type
)1 << align2
);
5429 if (align2
> bfd_get_section_alignment (dynobj
, s
)
5430 && !bfd_set_section_alignment (dynobj
, s
, align2
))
5433 /* Define the symbol as being at this point in the section. */
5434 h
->root
.u
.def
.section
= s
;
5435 h
->root
.u
.def
.value
= s
->size
;
5437 /* Increment the section size to make room for the symbol. */
5443 /* Worker function for nios2_elf32_size_dynamic_sections. */
5445 adjust_dynrelocs (struct elf_link_hash_entry
*h
, PTR inf
)
5447 struct bfd_link_info
*info
;
5448 struct elf32_nios2_link_hash_table
*htab
;
5450 if (h
->root
.type
== bfd_link_hash_indirect
)
5453 if (h
->root
.type
== bfd_link_hash_warning
)
5454 /* When warning symbols are created, they **replace** the "real"
5455 entry in the hash table, thus we never get to see the real
5456 symbol in a hash traversal. So look at it now. */
5457 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5459 info
= (struct bfd_link_info
*) inf
;
5460 htab
= elf32_nios2_hash_table (info
);
5462 if (h
->plt
.offset
!= (bfd_vma
)-1)
5463 h
->plt
.offset
+= htab
->res_n_size
;
5464 if (htab
->root
.splt
== h
->root
.u
.def
.section
)
5465 h
->root
.u
.def
.value
+= htab
->res_n_size
;
5470 /* Another worker function for nios2_elf32_size_dynamic_sections.
5471 Allocate space in .plt, .got and associated reloc sections for
5474 allocate_dynrelocs (struct elf_link_hash_entry
*h
, PTR inf
)
5476 struct bfd_link_info
*info
;
5477 struct elf32_nios2_link_hash_table
*htab
;
5478 struct elf32_nios2_link_hash_entry
*eh
;
5479 struct elf_dyn_relocs
*p
;
5482 if (h
->root
.type
== bfd_link_hash_indirect
)
5485 if (h
->root
.type
== bfd_link_hash_warning
)
5486 /* When warning symbols are created, they **replace** the "real"
5487 entry in the hash table, thus we never get to see the real
5488 symbol in a hash traversal. So look at it now. */
5489 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5491 info
= (struct bfd_link_info
*) inf
;
5492 htab
= elf32_nios2_hash_table (info
);
5494 if (htab
->root
.dynamic_sections_created
5495 && h
->plt
.refcount
> 0)
5497 /* Make sure this symbol is output as a dynamic symbol.
5498 Undefined weak syms won't yet be marked as dynamic. */
5499 if (h
->dynindx
== -1
5501 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
5504 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info
), h
))
5506 asection
*s
= htab
->root
.splt
;
5508 /* Allocate room for the header. */
5511 if (bfd_link_pic (info
))
5517 h
->plt
.offset
= s
->size
;
5519 /* If this symbol is not defined in a regular file, and we are
5520 not generating a shared library, then set the symbol to this
5521 location in the .plt. This is required to make function
5522 pointers compare as equal between the normal executable and
5523 the shared library. */
5524 if (! bfd_link_pic (info
)
5527 h
->root
.u
.def
.section
= s
;
5528 h
->root
.u
.def
.value
= h
->plt
.offset
;
5531 /* Make room for this entry. */
5534 /* We also need to make an entry in the .rela.plt section. */
5535 htab
->root
.srelplt
->size
+= sizeof (Elf32_External_Rela
);
5537 /* And the .got.plt section. */
5538 htab
->root
.sgotplt
->size
+= 4;
5542 h
->plt
.offset
= (bfd_vma
) -1;
5548 h
->plt
.offset
= (bfd_vma
) -1;
5552 eh
= (struct elf32_nios2_link_hash_entry
*) h
;
5553 use_plt
= (eh
->got_types_used
== CALL_USED
5554 && h
->plt
.offset
!= (bfd_vma
) -1);
5556 if (h
->got
.refcount
> 0)
5560 int tls_type
= eh
->tls_type
;
5563 /* Make sure this symbol is output as a dynamic symbol.
5564 Undefined weak syms won't yet be marked as dynamic. */
5565 if (h
->dynindx
== -1
5567 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
5570 s
= htab
->root
.sgot
;
5571 h
->got
.offset
= s
->size
;
5573 if (tls_type
== GOT_UNKNOWN
)
5576 if (tls_type
== GOT_NORMAL
)
5577 /* Non-TLS symbols need one GOT slot. */
5581 if (tls_type
& GOT_TLS_GD
)
5582 /* R_NIOS2_TLS_GD16 needs 2 consecutive GOT slots. */
5584 if (tls_type
& GOT_TLS_IE
)
5585 /* R_NIOS2_TLS_IE16 needs one GOT slot. */
5589 dyn
= htab
->root
.dynamic_sections_created
;
5592 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
5593 && (!bfd_link_pic (info
)
5594 || !SYMBOL_REFERENCES_LOCAL (info
, h
)))
5597 if (tls_type
!= GOT_NORMAL
5598 && (bfd_link_pic (info
) || indx
!= 0)
5599 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
5600 || h
->root
.type
!= bfd_link_hash_undefweak
))
5602 if (tls_type
& GOT_TLS_IE
)
5603 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
5605 if (tls_type
& GOT_TLS_GD
)
5606 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
5608 if ((tls_type
& GOT_TLS_GD
) && indx
!= 0)
5609 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
5611 else if ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
5612 || h
->root
.type
!= bfd_link_hash_undefweak
)
5614 && (bfd_link_pic (info
)
5615 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
5616 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
5619 h
->got
.offset
= (bfd_vma
) -1;
5621 if (eh
->dyn_relocs
== NULL
)
5624 /* In the shared -Bsymbolic case, discard space allocated for
5625 dynamic pc-relative relocs against symbols which turn out to be
5626 defined in regular objects. For the normal shared case, discard
5627 space for pc-relative relocs that have become local due to symbol
5628 visibility changes. */
5630 if (bfd_link_pic (info
))
5633 && (h
->forced_local
|| SYMBOLIC_BIND (info
, h
)))
5635 struct elf_dyn_relocs
**pp
;
5637 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
5639 p
->count
-= p
->pc_count
;
5648 /* Also discard relocs on undefined weak syms with non-default
5650 if (eh
->dyn_relocs
!= NULL
5651 && h
->root
.type
== bfd_link_hash_undefweak
)
5653 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
5654 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
5655 eh
->dyn_relocs
= NULL
;
5657 /* Make sure undefined weak symbols are output as a dynamic
5659 else if (h
->dynindx
== -1
5661 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
5667 /* For the non-shared case, discard space for relocs against
5668 symbols which turn out to need copy relocs or are not
5672 && ((h
->def_dynamic
&& !h
->def_regular
)
5673 || (htab
->root
.dynamic_sections_created
5674 && (h
->root
.type
== bfd_link_hash_undefweak
5675 || h
->root
.type
== bfd_link_hash_undefined
))))
5677 /* Make sure this symbol is output as a dynamic symbol.
5678 Undefined weak syms won't yet be marked as dynamic. */
5679 if (h
->dynindx
== -1
5681 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
5684 /* If that succeeded, we know we'll be keeping all the
5686 if (h
->dynindx
!= -1)
5690 eh
->dyn_relocs
= NULL
;
5695 /* Finally, allocate space. */
5696 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
5698 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
5699 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
5705 /* Implement elf_backend_size_dynamic_sections:
5706 Set the sizes of the dynamic sections. */
5708 nios2_elf32_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
5709 struct bfd_link_info
*info
)
5715 struct elf32_nios2_link_hash_table
*htab
;
5717 htab
= elf32_nios2_hash_table (info
);
5718 dynobj
= htab
->root
.dynobj
;
5719 BFD_ASSERT (dynobj
!= NULL
);
5721 htab
->res_n_size
= 0;
5722 if (htab
->root
.dynamic_sections_created
)
5724 /* Set the contents of the .interp section to the interpreter. */
5725 if (bfd_link_executable (info
) && !info
->nointerp
)
5727 s
= bfd_get_linker_section (dynobj
, ".interp");
5728 BFD_ASSERT (s
!= NULL
);
5729 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
5730 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
5735 /* We may have created entries in the .rela.got section.
5736 However, if we are not creating the dynamic sections, we will
5737 not actually use these entries. Reset the size of .rela.got,
5738 which will cause it to get stripped from the output file
5740 s
= htab
->root
.srelgot
;
5745 /* Set up .got offsets for local syms, and space for local dynamic
5747 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
5749 bfd_signed_vma
*local_got
;
5750 bfd_signed_vma
*end_local_got
;
5751 char *local_tls_type
;
5752 bfd_size_type locsymcount
;
5753 Elf_Internal_Shdr
*symtab_hdr
;
5756 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
5759 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
5761 struct elf_dyn_relocs
*p
;
5763 for (p
= elf_section_data (s
)->local_dynrel
; p
!= NULL
; p
= p
->next
)
5765 if (!bfd_is_abs_section (p
->sec
)
5766 && bfd_is_abs_section (p
->sec
->output_section
))
5768 /* Input section has been discarded, either because
5769 it is a copy of a linkonce section or due to
5770 linker script /DISCARD/, so we'll be discarding
5773 else if (p
->count
!= 0)
5775 srel
= elf_section_data (p
->sec
)->sreloc
;
5776 srel
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
5777 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
5778 info
->flags
|= DF_TEXTREL
;
5783 local_got
= elf_local_got_refcounts (ibfd
);
5787 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
5788 locsymcount
= symtab_hdr
->sh_info
;
5789 end_local_got
= local_got
+ locsymcount
;
5790 local_tls_type
= elf32_nios2_local_got_tls_type (ibfd
);
5791 s
= htab
->root
.sgot
;
5792 srel
= htab
->root
.srelgot
;
5793 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
5797 *local_got
= s
->size
;
5798 if (*local_tls_type
& GOT_TLS_GD
)
5799 /* TLS_GD relocs need an 8-byte structure in the GOT. */
5801 if (*local_tls_type
& GOT_TLS_IE
)
5803 if (*local_tls_type
== GOT_NORMAL
)
5806 if (bfd_link_pic (info
) || *local_tls_type
== GOT_TLS_GD
)
5807 srel
->size
+= sizeof (Elf32_External_Rela
);
5810 *local_got
= (bfd_vma
) -1;
5814 if (htab
->tls_ldm_got
.refcount
> 0)
5816 /* Allocate two GOT entries and one dynamic relocation (if necessary)
5817 for R_NIOS2_TLS_LDM16 relocations. */
5818 htab
->tls_ldm_got
.offset
= htab
->root
.sgot
->size
;
5819 htab
->root
.sgot
->size
+= 8;
5820 if (bfd_link_pic (info
))
5821 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
5824 htab
->tls_ldm_got
.offset
= -1;
5826 /* Allocate global sym .plt and .got entries, and space for global
5827 sym dynamic relocs. */
5828 elf_link_hash_traverse (& htab
->root
, allocate_dynrelocs
, info
);
5830 if (htab
->root
.dynamic_sections_created
)
5832 /* If the .got section is more than 0x8000 bytes, we add
5833 0x8000 to the value of _gp_got, so that 16-bit relocations
5834 have a greater chance of working. */
5835 if (htab
->root
.sgot
->size
>= 0x8000
5836 && htab
->h_gp_got
->root
.u
.def
.value
== 0)
5837 htab
->h_gp_got
->root
.u
.def
.value
= 0x8000;
5840 /* The check_relocs and adjust_dynamic_symbol entry points have
5841 determined the sizes of the various dynamic sections. Allocate
5844 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
5848 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
5851 /* It's OK to base decisions on the section name, because none
5852 of the dynobj section names depend upon the input files. */
5853 name
= bfd_get_section_name (dynobj
, s
);
5855 if (CONST_STRNEQ (name
, ".rela"))
5859 if (s
!= htab
->root
.srelplt
)
5862 /* We use the reloc_count field as a counter if we need
5863 to copy relocs into the output file. */
5867 else if (s
== htab
->root
.splt
)
5869 /* Correct for the number of res_N branches. */
5870 if (s
->size
!= 0 && !bfd_link_pic (info
))
5872 htab
->res_n_size
= (s
->size
- 28) / 3;
5873 s
->size
+= htab
->res_n_size
;
5876 else if (s
!= htab
->sbss
5877 && s
!= htab
->root
.sgot
5878 && s
!= htab
->root
.sgotplt
5879 && s
!= htab
->root
.sdynbss
5880 && s
!= htab
->root
.sdynrelro
)
5881 /* It's not one of our sections, so don't allocate space. */
5886 s
->flags
|= SEC_EXCLUDE
;
5890 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
5893 /* Allocate memory for the section contents. */
5894 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
5895 if (s
->contents
== NULL
)
5899 /* Adjust dynamic symbols that point to the plt to account for the
5900 now-known number of resN slots. */
5901 if (htab
->res_n_size
)
5902 elf_link_hash_traverse (& htab
->root
, adjust_dynrelocs
, info
);
5904 if (htab
->root
.dynamic_sections_created
)
5906 /* Add some entries to the .dynamic section. We fill in the
5907 values later, in elf_nios2_finish_dynamic_sections, but we
5908 must add the entries now so that we get the correct size for
5909 the .dynamic section. The DT_DEBUG entry is filled in by the
5910 dynamic linker and used by the debugger. */
5911 #define add_dynamic_entry(TAG, VAL) \
5912 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
5914 if (!bfd_link_pic (info
) && !add_dynamic_entry (DT_DEBUG
, 0))
5917 if (htab
->root
.sgotplt
->size
!= 0
5918 && !add_dynamic_entry (DT_PLTGOT
, 0))
5921 if (htab
->root
.splt
->size
!= 0
5922 && (!add_dynamic_entry (DT_PLTRELSZ
, 0)
5923 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
5924 || !add_dynamic_entry (DT_JMPREL
, 0)))
5928 && (!add_dynamic_entry (DT_RELA
, 0)
5929 || !add_dynamic_entry (DT_RELASZ
, 0)
5930 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
))))
5933 if (!bfd_link_pic (info
) && !add_dynamic_entry (DT_NIOS2_GP
, 0))
5936 if ((info
->flags
& DF_TEXTREL
) != 0
5937 && !add_dynamic_entry (DT_TEXTREL
, 0))
5940 #undef add_dynamic_entry
5945 /* Free the derived linker hash table. */
5947 nios2_elf32_link_hash_table_free (bfd
*obfd
)
5949 struct elf32_nios2_link_hash_table
*htab
5950 = (struct elf32_nios2_link_hash_table
*) obfd
->link
.hash
;
5952 bfd_hash_table_free (&htab
->bstab
);
5953 _bfd_elf_link_hash_table_free (obfd
);
5956 /* Implement bfd_elf32_bfd_link_hash_table_create. */
5957 static struct bfd_link_hash_table
*
5958 nios2_elf32_link_hash_table_create (bfd
*abfd
)
5960 struct elf32_nios2_link_hash_table
*ret
;
5961 bfd_size_type amt
= sizeof (struct elf32_nios2_link_hash_table
);
5963 ret
= bfd_zmalloc (amt
);
5967 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
5970 elf32_nios2_link_hash_entry
),
5977 /* Init the stub hash table too. */
5978 if (!bfd_hash_table_init (&ret
->bstab
, stub_hash_newfunc
,
5979 sizeof (struct elf32_nios2_stub_hash_entry
)))
5981 _bfd_elf_link_hash_table_free (abfd
);
5984 ret
->root
.root
.hash_table_free
= nios2_elf32_link_hash_table_free
;
5986 return &ret
->root
.root
;
5989 /* Implement elf_backend_reloc_type_class. */
5990 static enum elf_reloc_type_class
5991 nios2_elf32_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5992 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5993 const Elf_Internal_Rela
*rela
)
5995 switch ((int) ELF32_R_TYPE (rela
->r_info
))
5997 case R_NIOS2_RELATIVE
:
5998 return reloc_class_relative
;
5999 case R_NIOS2_JUMP_SLOT
:
6000 return reloc_class_plt
;
6002 return reloc_class_copy
;
6004 return reloc_class_normal
;
6008 /* Return 1 if target is one of ours. */
6010 is_nios2_elf_target (const struct bfd_target
*targ
)
6012 return (targ
== &nios2_elf32_le_vec
6013 || targ
== &nios2_elf32_be_vec
);
6016 /* Implement elf_backend_add_symbol_hook.
6017 This hook is called by the linker when adding symbols from an object
6018 file. We use it to put .comm items in .sbss, and not .bss. */
6020 nios2_elf_add_symbol_hook (bfd
*abfd
,
6021 struct bfd_link_info
*info
,
6022 Elf_Internal_Sym
*sym
,
6023 const char **namep ATTRIBUTE_UNUSED
,
6024 flagword
*flagsp ATTRIBUTE_UNUSED
,
6028 if (sym
->st_shndx
== SHN_COMMON
6029 && !bfd_link_relocatable (info
)
6030 && sym
->st_size
<= elf_gp_size (abfd
)
6031 && is_nios2_elf_target (info
->output_bfd
->xvec
))
6033 /* Common symbols less than or equal to -G nn bytes are automatically
6035 struct elf32_nios2_link_hash_table
*htab
;
6037 htab
= elf32_nios2_hash_table (info
);
6038 if (htab
->sbss
== NULL
)
6040 flagword flags
= SEC_IS_COMMON
| SEC_LINKER_CREATED
;
6042 if (htab
->root
.dynobj
== NULL
)
6043 htab
->root
.dynobj
= abfd
;
6045 htab
->sbss
= bfd_make_section_anyway_with_flags (htab
->root
.dynobj
,
6047 if (htab
->sbss
== NULL
)
6052 *valp
= sym
->st_size
;
6058 /* Implement elf_backend_can_make_relative_eh_frame:
6059 Decide whether to attempt to turn absptr or lsda encodings in
6060 shared libraries into pcrel within the given input section. */
6062 nios2_elf32_can_make_relative_eh_frame (bfd
*input_bfd ATTRIBUTE_UNUSED
,
6063 struct bfd_link_info
*info
6065 asection
*eh_frame_section
6068 /* We can't use PC-relative encodings in the .eh_frame section. */
6072 /* Implement elf_backend_special_sections. */
6073 const struct bfd_elf_special_section elf32_nios2_special_sections
[] =
6075 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS
,
6076 SHF_ALLOC
+ SHF_WRITE
+ SHF_NIOS2_GPREL
},
6077 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS
,
6078 SHF_ALLOC
+ SHF_WRITE
+ SHF_NIOS2_GPREL
},
6079 { NULL
, 0, 0, 0, 0 }
6082 #define ELF_ARCH bfd_arch_nios2
6083 #define ELF_TARGET_ID NIOS2_ELF_DATA
6084 #define ELF_MACHINE_CODE EM_ALTERA_NIOS2
6086 /* The Nios II MMU uses a 4K page size. */
6088 #define ELF_MAXPAGESIZE 0x1000
6090 #define bfd_elf32_bfd_link_hash_table_create \
6091 nios2_elf32_link_hash_table_create
6093 #define bfd_elf32_bfd_merge_private_bfd_data \
6094 nios2_elf32_merge_private_bfd_data
6096 /* Relocation table lookup macros. */
6098 #define bfd_elf32_bfd_reloc_type_lookup nios2_elf32_bfd_reloc_type_lookup
6099 #define bfd_elf32_bfd_reloc_name_lookup nios2_elf32_bfd_reloc_name_lookup
6101 /* JUMP_TABLE_LINK macros. */
6103 /* elf_info_to_howto (using RELA relocations). */
6105 #define elf_info_to_howto nios2_elf32_info_to_howto
6107 /* elf backend functions. */
6109 #define elf_backend_can_gc_sections 1
6110 #define elf_backend_can_refcount 1
6111 #define elf_backend_plt_readonly 1
6112 #define elf_backend_want_got_plt 1
6113 #define elf_backend_want_dynrelro 1
6114 #define elf_backend_rela_normal 1
6115 #define elf_backend_dtrel_excludes_plt 1
6117 #define elf_backend_relocate_section nios2_elf32_relocate_section
6118 #define elf_backend_section_flags nios2_elf32_section_flags
6119 #define elf_backend_fake_sections nios2_elf32_fake_sections
6120 #define elf_backend_check_relocs nios2_elf32_check_relocs
6122 #define elf_backend_gc_mark_hook nios2_elf32_gc_mark_hook
6123 #define elf_backend_create_dynamic_sections \
6124 nios2_elf32_create_dynamic_sections
6125 #define elf_backend_finish_dynamic_symbol nios2_elf32_finish_dynamic_symbol
6126 #define elf_backend_finish_dynamic_sections \
6127 nios2_elf32_finish_dynamic_sections
6128 #define elf_backend_adjust_dynamic_symbol nios2_elf32_adjust_dynamic_symbol
6129 #define elf_backend_reloc_type_class nios2_elf32_reloc_type_class
6130 #define elf_backend_size_dynamic_sections nios2_elf32_size_dynamic_sections
6131 #define elf_backend_add_symbol_hook nios2_elf_add_symbol_hook
6132 #define elf_backend_copy_indirect_symbol nios2_elf32_copy_indirect_symbol
6133 #define elf_backend_object_p nios2_elf32_object_p
6135 #define elf_backend_grok_prstatus nios2_grok_prstatus
6136 #define elf_backend_grok_psinfo nios2_grok_psinfo
6138 #undef elf_backend_can_make_relative_eh_frame
6139 #define elf_backend_can_make_relative_eh_frame \
6140 nios2_elf32_can_make_relative_eh_frame
6142 #define elf_backend_special_sections elf32_nios2_special_sections
6144 #define TARGET_LITTLE_SYM nios2_elf32_le_vec
6145 #define TARGET_LITTLE_NAME "elf32-littlenios2"
6146 #define TARGET_BIG_SYM nios2_elf32_be_vec
6147 #define TARGET_BIG_NAME "elf32-bignios2"
6149 #define elf_backend_got_header_size 12
6150 #define elf_backend_default_execstack 0
6152 #include "elf32-target.h"