1 /* 32-bit ELF support for Nios II.
2 Copyright (C) 2012-2020 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 #define GOT_UNKNOWN 0
1741 #define GOT_NORMAL 1
1742 #define GOT_TLS_GD 2
1743 #define GOT_TLS_IE 4
1744 unsigned char tls_type
;
1746 /* We need to detect and take special action for symbols which are only
1747 referenced with %call() and not with %got(). Such symbols do not need
1748 a dynamic GOT reloc in shared objects, only a dynamic PLT reloc. Lazy
1749 linking will not work if the dynamic GOT reloc exists.
1750 To check for this condition efficiently, we compare got_types_used against
1752 (got_types_used & (GOT_USED | CALL_USED)) == CALL_USED.
1756 unsigned char got_types_used
;
1759 #define elf32_nios2_hash_entry(ent) \
1760 ((struct elf32_nios2_link_hash_entry *) (ent))
1762 /* Get the Nios II elf linker hash table from a link_info structure. */
1763 #define elf32_nios2_hash_table(info) \
1764 ((struct elf32_nios2_link_hash_table *) ((info)->hash))
1766 /* Nios II ELF linker hash table. */
1767 struct elf32_nios2_link_hash_table
1769 /* The main hash table. */
1770 struct elf_link_hash_table root
;
1772 /* The stub hash table. */
1773 struct bfd_hash_table bstab
;
1775 /* Linker stub bfd. */
1778 /* Linker call-backs. */
1779 asection
* (*add_stub_section
) (const char *, asection
*, bfd_boolean
);
1780 void (*layout_sections_again
) (void);
1782 /* Array to keep track of which stub sections have been created, and
1783 information on stub grouping. */
1786 /* These are the section to which stubs in the group will be
1788 asection
*first_sec
, *last_sec
;
1789 /* The stub sections. There might be stubs inserted either before
1790 or after the real section.*/
1791 asection
*first_stub_sec
, *last_stub_sec
;
1794 /* Assorted information used by nios2_elf32_size_stubs. */
1795 unsigned int bfd_count
;
1796 unsigned int top_index
;
1797 asection
**input_list
;
1798 Elf_Internal_Sym
**all_local_syms
;
1800 /* Short-cuts to get to dynamic linker sections. */
1803 /* GOT pointer symbol _gp_got. */
1804 struct elf_link_hash_entry
*h_gp_got
;
1807 bfd_signed_vma refcount
;
1811 /* Small local sym cache. */
1812 struct sym_cache sym_cache
;
1817 struct nios2_elf32_obj_tdata
1819 struct elf_obj_tdata root
;
1821 /* tls_type for each local got entry. */
1822 char *local_got_tls_type
;
1824 /* TRUE if TLS GD relocs have been seen for this object. */
1825 bfd_boolean has_tlsgd
;
1828 #define elf32_nios2_tdata(abfd) \
1829 ((struct nios2_elf32_obj_tdata *) (abfd)->tdata.any)
1831 #define elf32_nios2_local_got_tls_type(abfd) \
1832 (elf32_nios2_tdata (abfd)->local_got_tls_type)
1834 /* The name of the dynamic interpreter. This is put in the .interp
1836 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
1838 /* PLT implementation for position-dependent code. */
1839 static const bfd_vma nios2_plt_entry
[] = { /* .PLTn: */
1840 0x03c00034, /* movhi r15, %hiadj(plt_got_slot_address) */
1841 0x7bc00017, /* ldw r15, %lo(plt_got_slot_address)(r15) */
1842 0x7800683a /* jmp r15 */
1845 static const bfd_vma nios2_plt0_entry
[] = { /* .PLTresolve */
1846 0x03800034, /* movhi r14, %hiadj(res_0) */
1847 0x73800004, /* addi r14, r14, %lo(res_0) */
1848 0x7b9fc83a, /* sub r15, r15, r14 */
1849 0x03400034, /* movhi r13, %hiadj(_GLOBAL_OFFSET_TABLE_) */
1850 0x6b800017, /* ldw r14, %lo(_GLOBAL_OFFSET_TABLE_+4)(r13) */
1851 0x6b400017, /* ldw r13, %lo(_GLOBAL_OFFSET_TABLE_+8)(r13) */
1852 0x6800683a /* jmp r13 */
1855 /* PLT implementation for position-independent code. */
1856 static const bfd_vma nios2_so_plt_entry
[] = { /* .PLTn */
1857 0x03c00034, /* movhi r15, %hiadj(index * 4) */
1858 0x7bc00004, /* addi r15, r15, %lo(index * 4) */
1859 0x00000006 /* br .PLTresolve */
1862 static const bfd_vma nios2_so_plt0_entry
[] = { /* .PLTresolve */
1863 0x001ce03a, /* nextpc r14 */
1864 0x03400034, /* movhi r13, %hiadj(_GLOBAL_OFFSET_TABLE_) */
1865 0x6b9b883a, /* add r13, r13, r14 */
1866 0x6b800017, /* ldw r14, %lo(_GLOBAL_OFFSET_TABLE_+4)(r13) */
1867 0x6b400017, /* ldw r13, %lo(_GLOBAL_OFFSET_TABLE_+8)(r13) */
1868 0x6800683a /* jmp r13 */
1872 static const bfd_vma nios2_call26_stub_entry
[] = {
1873 0x00400034, /* orhi at, r0, %hiadj(dest) */
1874 0x08400004, /* addi at, at, %lo(dest) */
1875 0x0800683a /* jmp at */
1878 /* Install 16-bit immediate value VALUE at offset OFFSET into section SEC. */
1880 nios2_elf32_install_imm16 (asection
*sec
, bfd_vma offset
, bfd_vma value
)
1882 bfd_vma word
= bfd_get_32 (sec
->owner
, sec
->contents
+ offset
);
1884 BFD_ASSERT (value
<= 0xffff || ((bfd_signed_vma
) value
) >= -0xffff);
1886 bfd_put_32 (sec
->owner
, word
| ((value
& 0xffff) << 6),
1887 sec
->contents
+ offset
);
1890 /* Install COUNT 32-bit values DATA starting at offset OFFSET into
1893 nios2_elf32_install_data (asection
*sec
, const bfd_vma
*data
, bfd_vma offset
,
1898 bfd_put_32 (sec
->owner
, *data
, sec
->contents
+ offset
);
1904 /* The usual way of loading a 32-bit constant into a Nios II register is to
1905 load the high 16 bits in one instruction and then add the low 16 bits with
1906 a signed add. This means that the high halfword needs to be adjusted to
1907 compensate for the sign bit of the low halfword. This function returns the
1908 adjusted high halfword for a given 32-bit constant. */
1910 bfd_vma
hiadj (bfd_vma symbol_value
)
1912 return ((symbol_value
+ 0x8000) >> 16) & 0xffff;
1915 /* Implement elf_backend_grok_prstatus:
1916 Support for core dump NOTE sections. */
1918 nios2_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
1923 switch (note
->descsz
)
1928 case 212: /* Linux/Nios II */
1930 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
1933 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
1942 /* Make a ".reg/999" section. */
1943 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
1944 size
, note
->descpos
+ offset
);
1947 /* Implement elf_backend_grok_psinfo. */
1949 nios2_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
1951 switch (note
->descsz
)
1956 case 124: /* Linux/Nios II elf_prpsinfo */
1957 elf_tdata (abfd
)->core
->program
1958 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
1959 elf_tdata (abfd
)->core
->command
1960 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
1963 /* Note that for some reason, a spurious space is tacked
1964 onto the end of the args in some (at least one anyway)
1965 implementations, so strip it off if it exists. */
1968 char *command
= elf_tdata (abfd
)->core
->command
;
1969 int n
= strlen (command
);
1971 if (0 < n
&& command
[n
- 1] == ' ')
1972 command
[n
- 1] = '\0';
1978 /* Assorted hash table functions. */
1980 /* Initialize an entry in the stub hash table. */
1981 static struct bfd_hash_entry
*
1982 stub_hash_newfunc (struct bfd_hash_entry
*entry
,
1983 struct bfd_hash_table
*table
,
1986 /* Allocate the structure if it has not already been allocated by a
1990 entry
= bfd_hash_allocate (table
,
1991 sizeof (struct elf32_nios2_stub_hash_entry
));
1996 /* Call the allocation method of the superclass. */
1997 entry
= bfd_hash_newfunc (entry
, table
, string
);
2000 struct elf32_nios2_stub_hash_entry
*hsh
;
2002 /* Initialize the local fields. */
2003 hsh
= (struct elf32_nios2_stub_hash_entry
*) entry
;
2004 hsh
->stub_sec
= NULL
;
2005 hsh
->stub_offset
= 0;
2006 hsh
->target_value
= 0;
2007 hsh
->target_section
= NULL
;
2008 hsh
->stub_type
= nios2_stub_none
;
2016 /* Create an entry in a Nios II ELF linker hash table. */
2017 static struct bfd_hash_entry
*
2018 link_hash_newfunc (struct bfd_hash_entry
*entry
,
2019 struct bfd_hash_table
*table
, const char *string
)
2021 /* Allocate the structure if it has not already been allocated by a
2025 entry
= bfd_hash_allocate (table
,
2026 sizeof (struct elf32_nios2_link_hash_entry
));
2031 /* Call the allocation method of the superclass. */
2032 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
2035 struct elf32_nios2_link_hash_entry
*eh
;
2037 eh
= (struct elf32_nios2_link_hash_entry
*) entry
;
2038 eh
->hsh_cache
= NULL
;
2039 eh
->tls_type
= GOT_UNKNOWN
;
2040 eh
->got_types_used
= 0;
2046 /* Section name for stubs is the associated section name plus this
2048 #define STUB_SUFFIX ".stub"
2050 /* Build a name for an entry in the stub hash table. */
2052 nios2_stub_name (const asection
*input_section
,
2053 const asection
*sym_sec
,
2054 const struct elf32_nios2_link_hash_entry
*hh
,
2055 const Elf_Internal_Rela
*rel
,
2056 enum elf32_nios2_stub_type stub_type
)
2060 char stubpos
= (stub_type
== nios2_stub_call26_before
) ? 'b' : 'a';
2064 len
= 8 + 1 + 1 + 1+ strlen (hh
->root
.root
.root
.string
) + 1 + 8 + 1;
2065 stub_name
= bfd_malloc (len
);
2066 if (stub_name
!= NULL
)
2068 sprintf (stub_name
, "%08x_%c_%s+%x",
2069 input_section
->id
& 0xffffffff,
2071 hh
->root
.root
.root
.string
,
2072 (int) rel
->r_addend
& 0xffffffff);
2077 len
= 8 + 1 + 1 + 1+ 8 + 1 + 8 + 1 + 8 + 1;
2078 stub_name
= bfd_malloc (len
);
2079 if (stub_name
!= NULL
)
2081 sprintf (stub_name
, "%08x_%c_%x:%x+%x",
2082 input_section
->id
& 0xffffffff,
2084 sym_sec
->id
& 0xffffffff,
2085 (int) ELF32_R_SYM (rel
->r_info
) & 0xffffffff,
2086 (int) rel
->r_addend
& 0xffffffff);
2092 /* Look up an entry in the stub hash. Stub entries are cached because
2093 creating the stub name takes a bit of time. */
2094 static struct elf32_nios2_stub_hash_entry
*
2095 nios2_get_stub_entry (const asection
*input_section
,
2096 const asection
*sym_sec
,
2097 struct elf32_nios2_link_hash_entry
*hh
,
2098 const Elf_Internal_Rela
*rel
,
2099 struct elf32_nios2_link_hash_table
*htab
,
2100 enum elf32_nios2_stub_type stub_type
)
2102 struct elf32_nios2_stub_hash_entry
*hsh
;
2103 const asection
*id_sec
;
2105 /* If this input section is part of a group of sections sharing one
2106 stub section, then use the id of the first/last section in the group,
2107 depending on the stub section placement relative to the group.
2108 Stub names need to include a section id, as there may well be
2109 more than one stub used to reach say, printf, and we need to
2110 distinguish between them. */
2111 if (stub_type
== nios2_stub_call26_before
)
2112 id_sec
= htab
->stub_group
[input_section
->id
].first_sec
;
2114 id_sec
= htab
->stub_group
[input_section
->id
].last_sec
;
2116 if (hh
!= NULL
&& hh
->hsh_cache
!= NULL
2117 && hh
->hsh_cache
->hh
== hh
2118 && hh
->hsh_cache
->id_sec
== id_sec
2119 && hh
->hsh_cache
->stub_type
== stub_type
)
2121 hsh
= hh
->hsh_cache
;
2127 stub_name
= nios2_stub_name (id_sec
, sym_sec
, hh
, rel
, stub_type
);
2128 if (stub_name
== NULL
)
2131 hsh
= nios2_stub_hash_lookup (&htab
->bstab
,
2132 stub_name
, FALSE
, FALSE
);
2135 hh
->hsh_cache
= hsh
;
2143 /* Add a new stub entry to the stub hash. Not all fields of the new
2144 stub entry are initialised. */
2145 static struct elf32_nios2_stub_hash_entry
*
2146 nios2_add_stub (const char *stub_name
,
2148 struct elf32_nios2_link_hash_table
*htab
,
2149 enum elf32_nios2_stub_type stub_type
)
2153 asection
**secptr
, **linkptr
;
2154 struct elf32_nios2_stub_hash_entry
*hsh
;
2157 if (stub_type
== nios2_stub_call26_before
)
2159 link_sec
= htab
->stub_group
[section
->id
].first_sec
;
2160 secptr
= &(htab
->stub_group
[section
->id
].first_stub_sec
);
2161 linkptr
= &(htab
->stub_group
[link_sec
->id
].first_stub_sec
);
2166 link_sec
= htab
->stub_group
[section
->id
].last_sec
;
2167 secptr
= &(htab
->stub_group
[section
->id
].last_stub_sec
);
2168 linkptr
= &(htab
->stub_group
[link_sec
->id
].last_stub_sec
);
2172 if (stub_sec
== NULL
)
2174 stub_sec
= *linkptr
;
2175 if (stub_sec
== NULL
)
2181 namelen
= strlen (link_sec
->name
);
2182 len
= namelen
+ sizeof (STUB_SUFFIX
);
2183 s_name
= bfd_alloc (htab
->stub_bfd
, len
);
2187 memcpy (s_name
, link_sec
->name
, namelen
);
2188 memcpy (s_name
+ namelen
, STUB_SUFFIX
, sizeof (STUB_SUFFIX
));
2190 stub_sec
= (*htab
->add_stub_section
) (s_name
, link_sec
, afterp
);
2191 if (stub_sec
== NULL
)
2193 *linkptr
= stub_sec
;
2198 /* Enter this entry into the linker stub hash table. */
2199 hsh
= nios2_stub_hash_lookup (&htab
->bstab
, stub_name
,
2203 /* xgettext:c-format */
2204 _bfd_error_handler (_("%pB: cannot create stub entry %s"),
2210 hsh
->stub_sec
= stub_sec
;
2211 hsh
->stub_offset
= 0;
2212 hsh
->id_sec
= link_sec
;
2216 /* Set up various things so that we can make a list of input sections
2217 for each output section included in the link. Returns -1 on error,
2218 0 when no stubs will be needed, and 1 on success. */
2220 nios2_elf32_setup_section_lists (bfd
*output_bfd
, struct bfd_link_info
*info
)
2223 unsigned int bfd_count
;
2224 unsigned int top_id
, top_index
;
2226 asection
**input_list
, **list
;
2228 struct elf32_nios2_link_hash_table
*htab
= elf32_nios2_hash_table (info
);
2230 /* Count the number of input BFDs and find the top input section id. */
2231 for (input_bfd
= info
->input_bfds
, bfd_count
= 0, top_id
= 0;
2233 input_bfd
= input_bfd
->link
.next
)
2236 for (section
= input_bfd
->sections
;
2238 section
= section
->next
)
2240 if (top_id
< section
->id
)
2241 top_id
= section
->id
;
2245 htab
->bfd_count
= bfd_count
;
2247 amt
= sizeof (struct map_stub
) * (top_id
+ 1);
2248 htab
->stub_group
= bfd_zmalloc (amt
);
2249 if (htab
->stub_group
== NULL
)
2252 /* We can't use output_bfd->section_count here to find the top output
2253 section index as some sections may have been removed, and
2254 strip_excluded_output_sections doesn't renumber the indices. */
2255 for (section
= output_bfd
->sections
, top_index
= 0;
2257 section
= section
->next
)
2259 if (top_index
< section
->index
)
2260 top_index
= section
->index
;
2263 htab
->top_index
= top_index
;
2264 amt
= sizeof (asection
*) * (top_index
+ 1);
2265 input_list
= bfd_malloc (amt
);
2266 htab
->input_list
= input_list
;
2267 if (input_list
== NULL
)
2270 /* For sections we aren't interested in, mark their entries with a
2271 value we can check later. */
2272 list
= input_list
+ top_index
;
2274 *list
= bfd_abs_section_ptr
;
2275 while (list
-- != input_list
);
2277 for (section
= output_bfd
->sections
;
2279 section
= section
->next
)
2281 /* FIXME: This is a bit of hack. Currently our .ctors and .dtors
2282 * have PC relative relocs in them but no code flag set. */
2283 if (((section
->flags
& SEC_CODE
) != 0) ||
2284 strcmp(".ctors", section
->name
) ||
2285 strcmp(".dtors", section
->name
))
2286 input_list
[section
->index
] = NULL
;
2292 /* The linker repeatedly calls this function for each input section,
2293 in the order that input sections are linked into output sections.
2294 Build lists of input sections to determine groupings between which
2295 we may insert linker stubs. */
2297 nios2_elf32_next_input_section (struct bfd_link_info
*info
, asection
*isec
)
2299 struct elf32_nios2_link_hash_table
*htab
= elf32_nios2_hash_table (info
);
2301 if (isec
->output_section
->index
<= htab
->top_index
)
2303 asection
**list
= htab
->input_list
+ isec
->output_section
->index
;
2304 if (*list
!= bfd_abs_section_ptr
)
2306 /* Steal the last_sec pointer for our list.
2307 This happens to make the list in reverse order,
2308 which is what we want. */
2309 htab
->stub_group
[isec
->id
].last_sec
= *list
;
2315 /* Segment mask for CALL26 relocation relaxation. */
2316 #define CALL26_SEGMENT(x) ((x) & 0xf0000000)
2318 /* Fudge factor for approximate maximum size of all stubs that might
2319 be inserted by the linker. This does not actually limit the number
2320 of stubs that might be inserted, and only affects strategy for grouping
2321 and placement of stubs. Perhaps this should be computed based on number
2322 of relocations seen, or be specifiable on the command line. */
2323 #define MAX_STUB_SECTION_SIZE 0xffff
2325 /* See whether we can group stub sections together. Grouping stub
2326 sections may result in fewer stubs. More importantly, we need to
2327 put all .init* and .fini* stubs at the end of the .init or
2328 .fini output sections respectively, because glibc splits the
2329 _init and _fini functions into multiple parts. Putting a stub in
2330 the middle of a function is not a good idea.
2331 Rather than computing groups of a maximum fixed size, for Nios II
2332 CALL26 relaxation it makes more sense to compute the groups based on
2333 sections that fit within a 256MB address segment. Also do not allow
2334 a group to span more than one output section, since different output
2335 sections might correspond to different memory banks on a bare-metal
2338 group_sections (struct elf32_nios2_link_hash_table
*htab
)
2340 asection
**list
= htab
->input_list
+ htab
->top_index
;
2343 /* The list is in reverse order so we'll search backwards looking
2344 for the first section that begins in the same memory segment,
2345 marking sections along the way to point at the tail for this
2347 asection
*tail
= *list
;
2348 if (tail
== bfd_abs_section_ptr
)
2350 while (tail
!= NULL
)
2352 bfd_vma start
= tail
->output_section
->vma
+ tail
->output_offset
;
2353 bfd_vma end
= start
+ tail
->size
;
2354 bfd_vma segment
= CALL26_SEGMENT (end
);
2357 if (segment
!= CALL26_SEGMENT (start
)
2358 || segment
!= CALL26_SEGMENT (end
+ MAX_STUB_SECTION_SIZE
))
2359 /* This section spans more than one memory segment, or is
2360 close enough to the end of the segment that adding stub
2361 sections before it might cause it to move so that it
2362 spans memory segments, or that stubs added at the end of
2363 this group might overflow into the next memory segment.
2364 Put it in a group by itself to localize the effects. */
2366 prev
= htab
->stub_group
[tail
->id
].last_sec
;
2367 htab
->stub_group
[tail
->id
].last_sec
= tail
;
2368 htab
->stub_group
[tail
->id
].first_sec
= tail
;
2371 /* Collect more sections for this group. */
2373 asection
*curr
, *first
;
2374 for (curr
= tail
; ; curr
= prev
)
2376 prev
= htab
->stub_group
[curr
->id
].last_sec
;
2378 || tail
->output_section
!= prev
->output_section
2379 || (CALL26_SEGMENT (prev
->output_section
->vma
2380 + prev
->output_offset
)
2385 for (curr
= tail
; ; curr
= prev
)
2387 prev
= htab
->stub_group
[curr
->id
].last_sec
;
2388 htab
->stub_group
[curr
->id
].last_sec
= tail
;
2389 htab
->stub_group
[curr
->id
].first_sec
= first
;
2395 /* Reset tail for the next group. */
2399 while (list
-- != htab
->input_list
);
2400 free (htab
->input_list
);
2403 /* Determine the type of stub needed, if any, for a call. */
2404 static enum elf32_nios2_stub_type
2405 nios2_type_of_stub (asection
*input_sec
,
2406 const Elf_Internal_Rela
*rel
,
2407 struct elf32_nios2_link_hash_entry
*hh
,
2408 struct elf32_nios2_link_hash_table
*htab
,
2409 bfd_vma destination
,
2410 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2412 bfd_vma location
, segment
, start
, end
;
2413 asection
*s0
, *s1
, *s
;
2416 !(hh
->root
.root
.type
== bfd_link_hash_defined
2417 || hh
->root
.root
.type
== bfd_link_hash_defweak
))
2418 return nios2_stub_none
;
2420 /* Determine where the call point is. */
2421 location
= (input_sec
->output_section
->vma
2422 + input_sec
->output_offset
+ rel
->r_offset
);
2423 segment
= CALL26_SEGMENT (location
);
2425 /* Nios II CALL and JMPI instructions can transfer control to addresses
2426 within the same 256MB segment as the PC. */
2427 if (segment
== CALL26_SEGMENT (destination
))
2428 return nios2_stub_none
;
2430 /* Find the start and end addresses of the stub group. Also account for
2431 any already-created stub sections for this group. Note that for stubs
2432 in the end section, only the first instruction of the last stub
2433 (12 bytes long) needs to be within range. */
2434 s0
= htab
->stub_group
[input_sec
->id
].first_sec
;
2435 s
= htab
->stub_group
[s0
->id
].first_stub_sec
;
2436 if (s
!= NULL
&& s
->size
> 0)
2437 start
= s
->output_section
->vma
+ s
->output_offset
;
2439 start
= s0
->output_section
->vma
+ s0
->output_offset
;
2441 s1
= htab
->stub_group
[input_sec
->id
].last_sec
;
2442 s
= htab
->stub_group
[s1
->id
].last_stub_sec
;
2443 if (s
!= NULL
&& s
->size
> 0)
2444 end
= s
->output_section
->vma
+ s
->output_offset
+ s
->size
- 8;
2446 end
= s1
->output_section
->vma
+ s1
->output_offset
+ s1
->size
;
2448 BFD_ASSERT (start
< end
);
2449 BFD_ASSERT (start
<= location
);
2450 BFD_ASSERT (location
< end
);
2452 /* Put stubs at the end of the group unless that is not a valid
2453 location and the beginning of the group is. It might be that
2454 neither the beginning nor end works if we have an input section
2455 so large that it spans multiple segment boundaries. In that
2456 case, punt; the end result will be a relocation overflow error no
2457 matter what we do here.
2459 Note that adding stubs pushes up the addresses of all subsequent
2460 sections, so that stubs allocated on one pass through the
2461 relaxation loop may not be valid on the next pass. (E.g., we may
2462 allocate a stub at the beginning of the section on one pass and
2463 find that the call site has been bumped into the next memory
2464 segment on the next pass.) The important thing to note is that
2465 we never try to reclaim the space allocated to such unused stubs,
2466 so code size and section addresses can only increase with each
2467 iteration. Accounting for the start and end addresses of the
2468 already-created stub sections ensures that when the algorithm
2469 converges, it converges accurately, with the entire appropriate
2470 stub section accessible from the call site and not just the
2471 address at the start or end of the stub group proper. */
2473 if (segment
== CALL26_SEGMENT (end
))
2474 return nios2_stub_call26_after
;
2475 else if (segment
== CALL26_SEGMENT (start
))
2476 return nios2_stub_call26_before
;
2478 /* Perhaps this should be a dedicated error code. */
2479 return nios2_stub_none
;
2483 nios2_build_one_stub (struct bfd_hash_entry
*gen_entry
, void *in_arg ATTRIBUTE_UNUSED
)
2485 struct elf32_nios2_stub_hash_entry
*hsh
2486 = (struct elf32_nios2_stub_hash_entry
*) gen_entry
;
2487 asection
*stub_sec
= hsh
->stub_sec
;
2489 struct bfd_link_info
*info
;
2491 info
= (struct bfd_link_info
*) in_arg
;
2493 /* Fail if the target section could not be assigned to an output
2494 section. The user should fix his linker script. */
2495 if (hsh
->target_section
->output_section
== NULL
2496 && info
->non_contiguous_regions
)
2497 info
->callbacks
->einfo (_("%F%P: Could not assign '%pA' to an output section. "
2498 "Retry without --enable-non-contiguous-regions.\n"),
2499 hsh
->target_section
);
2501 /* Make a note of the offset within the stubs for this entry. */
2502 hsh
->stub_offset
= stub_sec
->size
;
2504 switch (hsh
->stub_type
)
2506 case nios2_stub_call26_before
:
2507 case nios2_stub_call26_after
:
2508 /* A call26 stub looks like:
2509 orhi at, %hiadj(dest)
2510 addi at, at, %lo(dest)
2512 Note that call/jmpi instructions can't be used in PIC code
2513 so there is no reason for the stub to be PIC, either. */
2514 sym_value
= (hsh
->target_value
2515 + hsh
->target_section
->output_offset
2516 + hsh
->target_section
->output_section
->vma
2519 nios2_elf32_install_data (stub_sec
, nios2_call26_stub_entry
,
2520 hsh
->stub_offset
, 3);
2521 nios2_elf32_install_imm16 (stub_sec
, hsh
->stub_offset
,
2523 nios2_elf32_install_imm16 (stub_sec
, hsh
->stub_offset
+ 4,
2524 (sym_value
& 0xffff));
2525 stub_sec
->size
+= 12;
2535 /* As above, but don't actually build the stub. Just bump offset so
2536 we know stub section sizes. */
2538 nios2_size_one_stub (struct bfd_hash_entry
*gen_entry
, void *in_arg ATTRIBUTE_UNUSED
)
2540 struct elf32_nios2_stub_hash_entry
*hsh
2541 = (struct elf32_nios2_stub_hash_entry
*) gen_entry
;
2543 switch (hsh
->stub_type
)
2545 case nios2_stub_call26_before
:
2546 case nios2_stub_call26_after
:
2547 hsh
->stub_sec
->size
+= 12;
2556 /* Read in all local syms for all input bfds.
2557 Returns -1 on error, 0 otherwise. */
2560 get_local_syms (bfd
*output_bfd ATTRIBUTE_UNUSED
, bfd
*input_bfd
,
2561 struct bfd_link_info
*info
)
2563 unsigned int bfd_indx
;
2564 Elf_Internal_Sym
*local_syms
, **all_local_syms
;
2565 struct elf32_nios2_link_hash_table
*htab
= elf32_nios2_hash_table (info
);
2567 /* We want to read in symbol extension records only once. To do this
2568 we need to read in the local symbols in parallel and save them for
2569 later use; so hold pointers to the local symbols in an array. */
2570 size_t amt
= sizeof (Elf_Internal_Sym
*) * htab
->bfd_count
;
2571 all_local_syms
= bfd_zmalloc (amt
);
2572 htab
->all_local_syms
= all_local_syms
;
2573 if (all_local_syms
== NULL
)
2576 /* Walk over all the input BFDs, swapping in local symbols. */
2579 input_bfd
= input_bfd
->link
.next
, bfd_indx
++)
2581 Elf_Internal_Shdr
*symtab_hdr
;
2583 /* We'll need the symbol table in a second. */
2584 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2585 if (symtab_hdr
->sh_info
== 0)
2588 /* We need an array of the local symbols attached to the input bfd. */
2589 local_syms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2590 if (local_syms
== NULL
)
2592 local_syms
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
,
2593 symtab_hdr
->sh_info
, 0,
2595 /* Cache them for elf_link_input_bfd. */
2596 symtab_hdr
->contents
= (unsigned char *) local_syms
;
2598 if (local_syms
== NULL
)
2601 all_local_syms
[bfd_indx
] = local_syms
;
2607 /* Determine and set the size of the stub section for a final link. */
2609 nios2_elf32_size_stubs (bfd
*output_bfd
, bfd
*stub_bfd
,
2610 struct bfd_link_info
*info
,
2611 asection
*(*add_stub_section
) (const char *,
2612 asection
*, bfd_boolean
),
2613 void (*layout_sections_again
) (void))
2615 bfd_boolean stub_changed
= FALSE
;
2616 struct elf32_nios2_link_hash_table
*htab
= elf32_nios2_hash_table (info
);
2618 /* Stash our params away. */
2619 htab
->stub_bfd
= stub_bfd
;
2620 htab
->add_stub_section
= add_stub_section
;
2621 htab
->layout_sections_again
= layout_sections_again
;
2623 /* FIXME: We only compute the section groups once. This could cause
2624 problems if adding a large stub section causes following sections,
2625 or parts of them, to move into another segment. However, this seems
2626 to be consistent with the way other back ends handle this.... */
2627 group_sections (htab
);
2629 if (get_local_syms (output_bfd
, info
->input_bfds
, info
))
2631 if (htab
->all_local_syms
)
2632 goto error_ret_free_local
;
2639 unsigned int bfd_indx
;
2642 for (input_bfd
= info
->input_bfds
, bfd_indx
= 0;
2644 input_bfd
= input_bfd
->link
.next
, bfd_indx
++)
2646 Elf_Internal_Shdr
*symtab_hdr
;
2648 Elf_Internal_Sym
*local_syms
;
2650 /* We'll need the symbol table in a second. */
2651 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2652 if (symtab_hdr
->sh_info
== 0)
2655 local_syms
= htab
->all_local_syms
[bfd_indx
];
2657 /* Walk over each section attached to the input bfd. */
2658 for (section
= input_bfd
->sections
;
2660 section
= section
->next
)
2662 Elf_Internal_Rela
*internal_relocs
, *irelaend
, *irela
;
2664 /* If there aren't any relocs, then there's nothing more
2666 if ((section
->flags
& SEC_RELOC
) == 0
2667 || section
->reloc_count
== 0)
2670 /* If this section is a link-once section that will be
2671 discarded, then don't create any stubs. */
2672 if (section
->output_section
== NULL
2673 || section
->output_section
->owner
!= output_bfd
)
2676 /* Get the relocs. */
2678 = _bfd_elf_link_read_relocs (input_bfd
, section
, NULL
, NULL
,
2680 if (internal_relocs
== NULL
)
2681 goto error_ret_free_local
;
2683 /* Now examine each relocation. */
2684 irela
= internal_relocs
;
2685 irelaend
= irela
+ section
->reloc_count
;
2686 for (; irela
< irelaend
; irela
++)
2688 unsigned int r_type
, r_indx
;
2689 enum elf32_nios2_stub_type stub_type
;
2690 struct elf32_nios2_stub_hash_entry
*hsh
;
2693 bfd_vma destination
;
2694 struct elf32_nios2_link_hash_entry
*hh
;
2696 const asection
*id_sec
;
2698 r_type
= ELF32_R_TYPE (irela
->r_info
);
2699 r_indx
= ELF32_R_SYM (irela
->r_info
);
2701 if (r_type
>= (unsigned int) R_NIOS2_ILLEGAL
)
2703 bfd_set_error (bfd_error_bad_value
);
2704 error_ret_free_internal
:
2705 if (elf_section_data (section
)->relocs
== NULL
)
2706 free (internal_relocs
);
2707 goto error_ret_free_local
;
2710 /* Only look for stubs on CALL and JMPI instructions. */
2711 if (r_type
!= (unsigned int) R_NIOS2_CALL26
)
2714 /* Now determine the call target, its name, value,
2720 if (r_indx
< symtab_hdr
->sh_info
)
2722 /* It's a local symbol. */
2723 Elf_Internal_Sym
*sym
;
2724 Elf_Internal_Shdr
*hdr
;
2727 sym
= local_syms
+ r_indx
;
2728 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
2729 sym_value
= sym
->st_value
;
2730 shndx
= sym
->st_shndx
;
2731 if (shndx
< elf_numsections (input_bfd
))
2733 hdr
= elf_elfsections (input_bfd
)[shndx
];
2734 sym_sec
= hdr
->bfd_section
;
2735 destination
= (sym_value
+ irela
->r_addend
2736 + sym_sec
->output_offset
2737 + sym_sec
->output_section
->vma
);
2742 /* It's an external symbol. */
2745 e_indx
= r_indx
- symtab_hdr
->sh_info
;
2746 hh
= ((struct elf32_nios2_link_hash_entry
*)
2747 elf_sym_hashes (input_bfd
)[e_indx
]);
2749 while (hh
->root
.root
.type
== bfd_link_hash_indirect
2750 || hh
->root
.root
.type
== bfd_link_hash_warning
)
2751 hh
= ((struct elf32_nios2_link_hash_entry
*)
2752 hh
->root
.root
.u
.i
.link
);
2754 if (hh
->root
.root
.type
== bfd_link_hash_defined
2755 || hh
->root
.root
.type
== bfd_link_hash_defweak
)
2757 sym_sec
= hh
->root
.root
.u
.def
.section
;
2758 sym_value
= hh
->root
.root
.u
.def
.value
;
2760 if (sym_sec
->output_section
!= NULL
)
2761 destination
= (sym_value
+ irela
->r_addend
2762 + sym_sec
->output_offset
2763 + sym_sec
->output_section
->vma
);
2767 else if (hh
->root
.root
.type
== bfd_link_hash_undefweak
)
2769 if (! bfd_link_pic (info
))
2772 else if (hh
->root
.root
.type
== bfd_link_hash_undefined
)
2774 if (! (info
->unresolved_syms_in_objects
== RM_IGNORE
2775 && (ELF_ST_VISIBILITY (hh
->root
.other
)
2781 bfd_set_error (bfd_error_bad_value
);
2782 goto error_ret_free_internal
;
2786 /* Determine what (if any) linker stub is needed. */
2787 stub_type
= nios2_type_of_stub (section
, irela
, hh
, htab
,
2789 if (stub_type
== nios2_stub_none
)
2792 /* Support for grouping stub sections. */
2793 if (stub_type
== nios2_stub_call26_before
)
2794 id_sec
= htab
->stub_group
[section
->id
].first_sec
;
2796 id_sec
= htab
->stub_group
[section
->id
].last_sec
;
2798 /* Get the name of this stub. */
2799 stub_name
= nios2_stub_name (id_sec
, sym_sec
, hh
, irela
,
2802 goto error_ret_free_internal
;
2804 hsh
= nios2_stub_hash_lookup (&htab
->bstab
,
2809 /* The proper stub has already been created. */
2814 hsh
= nios2_add_stub (stub_name
, section
, htab
, stub_type
);
2818 goto error_ret_free_internal
;
2820 hsh
->target_value
= sym_value
;
2821 hsh
->target_section
= sym_sec
;
2822 hsh
->stub_type
= stub_type
;
2824 hsh
->addend
= irela
->r_addend
;
2825 stub_changed
= TRUE
;
2828 /* We're done with the internal relocs, free them. */
2829 if (elf_section_data (section
)->relocs
== NULL
)
2830 free (internal_relocs
);
2837 /* OK, we've added some stubs. Find out the new size of the
2839 for (stub_sec
= htab
->stub_bfd
->sections
;
2841 stub_sec
= stub_sec
->next
)
2844 bfd_hash_traverse (&htab
->bstab
, nios2_size_one_stub
, htab
);
2846 /* Ask the linker to do its stuff. */
2847 (*htab
->layout_sections_again
) ();
2848 stub_changed
= FALSE
;
2851 free (htab
->all_local_syms
);
2854 error_ret_free_local
:
2855 free (htab
->all_local_syms
);
2859 /* Build all the stubs associated with the current output file. The
2860 stubs are kept in a hash table attached to the main linker hash
2861 table. This function is called via nios2elf_finish in the linker. */
2863 nios2_elf32_build_stubs (struct bfd_link_info
*info
)
2866 struct bfd_hash_table
*table
;
2867 struct elf32_nios2_link_hash_table
*htab
;
2869 htab
= elf32_nios2_hash_table (info
);
2871 for (stub_sec
= htab
->stub_bfd
->sections
;
2873 stub_sec
= stub_sec
->next
)
2874 /* The stub_bfd may contain non-stub sections if it is also the
2875 dynobj. Any such non-stub sections are created with the
2876 SEC_LINKER_CREATED flag set, while stub sections do not
2877 have that flag. Ignore any non-stub sections here. */
2878 if ((stub_sec
->flags
& SEC_LINKER_CREATED
) == 0)
2882 /* Allocate memory to hold the linker stubs. */
2883 size
= stub_sec
->size
;
2884 stub_sec
->contents
= bfd_zalloc (htab
->stub_bfd
, size
);
2885 if (stub_sec
->contents
== NULL
&& size
!= 0)
2890 /* Build the stubs as directed by the stub hash table. */
2891 table
= &htab
->bstab
;
2892 bfd_hash_traverse (table
, nios2_build_one_stub
, info
);
2898 #define is_nios2_elf(bfd) \
2899 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2900 && elf_object_id (bfd) == NIOS2_ELF_DATA)
2902 /* Merge backend specific data from an object file to the output
2903 object file when linking. */
2906 nios2_elf32_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
2908 bfd
*obfd
= info
->output_bfd
;
2912 if (!is_nios2_elf (ibfd
) || !is_nios2_elf (obfd
))
2915 /* Check if we have the same endianness. */
2916 if (! _bfd_generic_verify_endian_match (ibfd
, info
))
2919 new_flags
= elf_elfheader (ibfd
)->e_flags
;
2920 old_flags
= elf_elfheader (obfd
)->e_flags
;
2921 if (!elf_flags_init (obfd
))
2923 /* First call, no flags set. */
2924 elf_flags_init (obfd
) = TRUE
;
2925 elf_elfheader (obfd
)->e_flags
= new_flags
;
2930 case EF_NIOS2_ARCH_R1
:
2931 bfd_default_set_arch_mach (obfd
, bfd_arch_nios2
, bfd_mach_nios2r1
);
2933 case EF_NIOS2_ARCH_R2
:
2934 if (bfd_big_endian (ibfd
))
2937 (_("error: %pB: big-endian R2 is not supported"), ibfd
);
2938 bfd_set_error (bfd_error_bad_value
);
2941 bfd_default_set_arch_mach (obfd
, bfd_arch_nios2
, bfd_mach_nios2r2
);
2946 /* Incompatible flags. */
2947 else if (new_flags
!= old_flags
)
2949 /* So far, the only incompatible flags denote incompatible
2952 /* xgettext:c-format */
2953 (_("error: %pB: conflicting CPU architectures %d/%d"),
2954 ibfd
, new_flags
, old_flags
);
2955 bfd_set_error (bfd_error_bad_value
);
2959 /* Merge Tag_compatibility attributes and any common GNU ones. */
2960 _bfd_elf_merge_object_attributes (ibfd
, info
);
2965 /* Implement bfd_elf32_bfd_reloc_type_lookup:
2966 Given a BFD reloc type, return a howto structure. */
2968 static reloc_howto_type
*
2969 nios2_elf32_bfd_reloc_type_lookup (bfd
*abfd
,
2970 bfd_reloc_code_real_type code
)
2974 for (i
= 0; i
< (int) ARRAY_SIZE (nios2_reloc_map
); ++i
)
2975 if (nios2_reloc_map
[i
].bfd_val
== code
)
2976 return lookup_howto (nios2_reloc_map
[i
].elf_val
, abfd
);
2980 /* Implement bfd_elf32_bfd_reloc_name_lookup:
2981 Given a reloc name, return a howto structure. */
2983 static reloc_howto_type
*
2984 nios2_elf32_bfd_reloc_name_lookup (bfd
*abfd
,
2988 reloc_howto_type
*howto_tbl
;
2991 if (BFD_IS_R2 (abfd
))
2993 howto_tbl
= elf_nios2_r2_howto_table_rel
;
2994 howto_tbl_size
= (int) ARRAY_SIZE (elf_nios2_r2_howto_table_rel
);
2998 howto_tbl
= elf_nios2_r1_howto_table_rel
;
2999 howto_tbl_size
= (int) ARRAY_SIZE (elf_nios2_r1_howto_table_rel
);
3002 for (i
= 0; i
< howto_tbl_size
; i
++)
3003 if (howto_tbl
[i
].name
&& strcasecmp (howto_tbl
[i
].name
, r_name
) == 0)
3004 return howto_tbl
+ i
;
3009 /* Implement elf_info_to_howto:
3010 Given a ELF32 relocation, fill in a arelent structure. */
3013 nios2_elf32_info_to_howto (bfd
*abfd
, arelent
*cache_ptr
,
3014 Elf_Internal_Rela
*dst
)
3016 unsigned int r_type
;
3018 r_type
= ELF32_R_TYPE (dst
->r_info
);
3019 if ((cache_ptr
->howto
= lookup_howto (r_type
, abfd
)) == NULL
)
3021 /* xgettext:c-format */
3022 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
3024 bfd_set_error (bfd_error_bad_value
);
3030 /* Return the base VMA address which should be subtracted from real addresses
3031 when resolving @dtpoff relocation.
3032 This is PT_TLS segment p_vaddr. */
3034 dtpoff_base (struct bfd_link_info
*info
)
3036 /* If tls_sec is NULL, we should have signalled an error already. */
3037 if (elf_hash_table (info
)->tls_sec
== NULL
)
3039 return elf_hash_table (info
)->tls_sec
->vma
;
3042 /* Return the relocation value for @tpoff relocation
3043 if STT_TLS virtual address is ADDRESS. */
3045 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3047 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3049 /* If tls_sec is NULL, we should have signalled an error already. */
3050 if (htab
->tls_sec
== NULL
)
3052 return address
- htab
->tls_sec
->vma
;
3055 /* Set the GP value for OUTPUT_BFD. Returns FALSE if this is a
3056 dangerous relocation. */
3058 nios2_elf_assign_gp (bfd
*output_bfd
, bfd_vma
*pgp
, struct bfd_link_info
*info
)
3061 bfd_boolean gp_found
;
3062 struct bfd_hash_entry
*h
;
3063 struct bfd_link_hash_entry
*lh
;
3065 /* If we've already figured out what GP will be, just return it. */
3066 *pgp
= _bfd_get_gp_value (output_bfd
);
3070 h
= bfd_hash_lookup (&info
->hash
->table
, "_gp", FALSE
, FALSE
);
3071 lh
= (struct bfd_link_hash_entry
*) h
;
3077 case bfd_link_hash_undefined
:
3078 case bfd_link_hash_undefweak
:
3079 case bfd_link_hash_common
:
3082 case bfd_link_hash_defined
:
3083 case bfd_link_hash_defweak
:
3086 asection
*sym_sec
= lh
->u
.def
.section
;
3087 bfd_vma sym_value
= lh
->u
.def
.value
;
3089 if (sym_sec
->output_section
)
3090 sym_value
= (sym_value
+ sym_sec
->output_offset
3091 + sym_sec
->output_section
->vma
);
3095 case bfd_link_hash_indirect
:
3096 case bfd_link_hash_warning
:
3098 /* @@FIXME ignoring warning for now */
3100 case bfd_link_hash_new
:
3110 /* Only get the error once. */
3112 _bfd_set_gp_value (output_bfd
, *pgp
);
3116 _bfd_set_gp_value (output_bfd
, *pgp
);
3121 /* Retrieve the previously cached _gp pointer, returning bfd_reloc_dangerous
3122 if it's not available as we don't have a link_info pointer available here
3123 to look it up in the output symbol table. We don't need to adjust the
3124 symbol value for an external symbol if we are producing relocatable
3126 static bfd_reloc_status_type
3127 nios2_elf_final_gp (bfd
*output_bfd
, asymbol
*symbol
, bfd_boolean relocatable
,
3128 char **error_message
, bfd_vma
*pgp
)
3130 if (bfd_is_und_section (symbol
->section
) && !relocatable
)
3133 return bfd_reloc_undefined
;
3136 *pgp
= _bfd_get_gp_value (output_bfd
);
3137 if (*pgp
== 0 && (!relocatable
|| (symbol
->flags
& BSF_SECTION_SYM
) != 0))
3141 /* Make up a value. */
3142 *pgp
= symbol
->section
->output_section
->vma
+ 0x4000;
3143 _bfd_set_gp_value (output_bfd
, *pgp
);
3148 = (char *) _("global pointer relative relocation when _gp not defined");
3149 return bfd_reloc_dangerous
;
3153 return bfd_reloc_ok
;
3156 /* Do the relocations that require special handling. */
3157 static bfd_reloc_status_type
3158 nios2_elf32_do_hi16_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3159 asection
*input_section
,
3160 bfd_byte
*data
, bfd_vma offset
,
3161 bfd_vma symbol_value
, bfd_vma addend
)
3163 symbol_value
= symbol_value
+ addend
;
3165 symbol_value
= (symbol_value
>> 16) & 0xffff;
3166 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
3167 data
, offset
, symbol_value
, addend
);
3170 static bfd_reloc_status_type
3171 nios2_elf32_do_lo16_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3172 asection
*input_section
,
3173 bfd_byte
*data
, bfd_vma offset
,
3174 bfd_vma symbol_value
, bfd_vma addend
)
3176 symbol_value
= symbol_value
+ addend
;
3178 symbol_value
= symbol_value
& 0xffff;
3179 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
3180 data
, offset
, symbol_value
, addend
);
3183 static bfd_reloc_status_type
3184 nios2_elf32_do_hiadj16_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3185 asection
*input_section
,
3186 bfd_byte
*data
, bfd_vma offset
,
3187 bfd_vma symbol_value
, bfd_vma addend
)
3189 symbol_value
= symbol_value
+ addend
;
3191 symbol_value
= hiadj(symbol_value
);
3192 return _bfd_final_link_relocate (howto
, abfd
, input_section
, data
, offset
,
3193 symbol_value
, addend
);
3196 static bfd_reloc_status_type
3197 nios2_elf32_do_pcrel_lo16_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3198 asection
*input_section
,
3199 bfd_byte
*data
, bfd_vma offset
,
3200 bfd_vma symbol_value
, bfd_vma addend
)
3202 symbol_value
= symbol_value
+ addend
;
3204 symbol_value
= symbol_value
& 0xffff;
3205 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
3206 data
, offset
, symbol_value
, addend
);
3209 static bfd_reloc_status_type
3210 nios2_elf32_do_pcrel_hiadj16_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3211 asection
*input_section
,
3212 bfd_byte
*data
, bfd_vma offset
,
3213 bfd_vma symbol_value
, bfd_vma addend
)
3215 symbol_value
= symbol_value
+ addend
;
3216 symbol_value
-= (input_section
->output_section
->vma
3217 + input_section
->output_offset
);
3218 symbol_value
-= offset
;
3220 symbol_value
= hiadj(symbol_value
);
3221 return _bfd_final_link_relocate (howto
, abfd
, input_section
, data
, offset
,
3222 symbol_value
, addend
);
3225 static bfd_reloc_status_type
3226 nios2_elf32_do_pcrel16_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3227 asection
*input_section
,
3228 bfd_byte
*data
, bfd_vma offset
,
3229 bfd_vma symbol_value
, bfd_vma addend
)
3231 /* NIOS2 pc relative relocations are relative to the next 32-bit instruction
3232 so we need to subtract 4 before doing a final_link_relocate. */
3233 symbol_value
= symbol_value
+ addend
- 4;
3235 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
3236 data
, offset
, symbol_value
, addend
);
3239 static bfd_reloc_status_type
3240 nios2_elf32_do_call26_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3241 asection
*input_section
,
3242 bfd_byte
*data
, bfd_vma offset
,
3243 bfd_vma symbol_value
, bfd_vma addend
)
3245 /* Check that the relocation is in the same page as the current address. */
3246 if (CALL26_SEGMENT (symbol_value
+ addend
)
3247 != CALL26_SEGMENT (input_section
->output_section
->vma
3248 + input_section
->output_offset
3250 return bfd_reloc_overflow
;
3252 /* Check that the target address is correctly aligned on a 4-byte
3254 if ((symbol_value
+ addend
) & 0x3)
3255 return bfd_reloc_overflow
;
3257 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
3258 data
, offset
, symbol_value
, addend
);
3261 static bfd_reloc_status_type
3262 nios2_elf32_do_gprel_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3263 asection
*input_section
,
3264 bfd_byte
*data
, bfd_vma offset
,
3265 bfd_vma symbol_value
, bfd_vma addend
)
3267 /* Because we need the output_bfd, the special handling is done
3268 in nios2_elf32_relocate_section or in nios2_elf32_gprel_relocate. */
3269 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
3270 data
, offset
, symbol_value
, addend
);
3273 static bfd_reloc_status_type
3274 nios2_elf32_do_ujmp_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3275 asection
*input_section
,
3276 bfd_byte
*data
, bfd_vma offset
,
3277 bfd_vma symbol_value
, bfd_vma addend
)
3279 bfd_vma symbol_lo16
, symbol_hi16
;
3280 bfd_reloc_status_type r
;
3281 symbol_value
= symbol_value
+ addend
;
3283 symbol_hi16
= (symbol_value
>> 16) & 0xffff;
3284 symbol_lo16
= symbol_value
& 0xffff;
3286 r
= _bfd_final_link_relocate (howto
, abfd
, input_section
,
3287 data
, offset
, symbol_hi16
, addend
);
3289 if (r
== bfd_reloc_ok
)
3290 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
3291 data
, offset
+ 4, symbol_lo16
, addend
);
3296 static bfd_reloc_status_type
3297 nios2_elf32_do_cjmp_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3298 asection
*input_section
,
3299 bfd_byte
*data
, bfd_vma offset
,
3300 bfd_vma symbol_value
, bfd_vma addend
)
3302 bfd_vma symbol_lo16
, symbol_hi16
;
3303 bfd_reloc_status_type r
;
3304 symbol_value
= symbol_value
+ addend
;
3306 symbol_hi16
= (symbol_value
>> 16) & 0xffff;
3307 symbol_lo16
= symbol_value
& 0xffff;
3309 r
= _bfd_final_link_relocate (howto
, abfd
, input_section
,
3310 data
, offset
, symbol_hi16
, addend
);
3312 if (r
== bfd_reloc_ok
)
3313 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
3314 data
, offset
+ 4, symbol_lo16
, addend
);
3319 static bfd_reloc_status_type
3320 nios2_elf32_do_callr_relocate (bfd
*abfd
, reloc_howto_type
*howto
,
3321 asection
*input_section
,
3322 bfd_byte
*data
, bfd_vma offset
,
3323 bfd_vma symbol_value
, bfd_vma addend
)
3325 bfd_vma symbol_lo16
, symbol_hi16
;
3326 bfd_reloc_status_type r
;
3327 symbol_value
= symbol_value
+ addend
;
3329 symbol_hi16
= (symbol_value
>> 16) & 0xffff;
3330 symbol_lo16
= symbol_value
& 0xffff;
3332 r
= _bfd_final_link_relocate (howto
, abfd
, input_section
,
3333 data
, offset
, symbol_hi16
, addend
);
3335 if (r
== bfd_reloc_ok
)
3336 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
3337 data
, offset
+ 4, symbol_lo16
, addend
);
3342 /* HOWTO handlers for relocations that require special handling. */
3344 /* This is for relocations used only when relaxing to ensure
3345 changes in size of section don't screw up .align. */
3346 static bfd_reloc_status_type
3347 nios2_elf32_ignore_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
3348 asymbol
*symbol ATTRIBUTE_UNUSED
,
3349 void *data ATTRIBUTE_UNUSED
, asection
*input_section
,
3351 char **error_message ATTRIBUTE_UNUSED
)
3353 if (output_bfd
!= NULL
)
3354 reloc_entry
->address
+= input_section
->output_offset
;
3355 return bfd_reloc_ok
;
3358 static bfd_reloc_status_type
3359 nios2_elf32_hi16_relocate (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
3360 void *data
, asection
*input_section
,
3362 char **error_message ATTRIBUTE_UNUSED
)
3364 /* This part is from bfd_elf_generic_reloc. */
3365 if (output_bfd
!= NULL
3366 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3367 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3369 reloc_entry
->address
+= input_section
->output_offset
;
3370 return bfd_reloc_ok
;
3373 if (output_bfd
!= NULL
)
3374 /* FIXME: See bfd_perform_relocation. Is this right? */
3375 return bfd_reloc_continue
;
3377 return nios2_elf32_do_hi16_relocate (abfd
, reloc_entry
->howto
,
3379 data
, reloc_entry
->address
,
3381 + symbol
->section
->output_section
->vma
3382 + symbol
->section
->output_offset
),
3383 reloc_entry
->addend
);
3386 static bfd_reloc_status_type
3387 nios2_elf32_lo16_relocate (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
3388 void *data
, asection
*input_section
,
3390 char **error_message ATTRIBUTE_UNUSED
)
3392 /* This part is from bfd_elf_generic_reloc. */
3393 if (output_bfd
!= NULL
3394 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3395 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3397 reloc_entry
->address
+= input_section
->output_offset
;
3398 return bfd_reloc_ok
;
3401 if (output_bfd
!= NULL
)
3402 /* FIXME: See bfd_perform_relocation. Is this right? */
3403 return bfd_reloc_continue
;
3405 return nios2_elf32_do_lo16_relocate (abfd
, reloc_entry
->howto
,
3407 data
, reloc_entry
->address
,
3409 + symbol
->section
->output_section
->vma
3410 + symbol
->section
->output_offset
),
3411 reloc_entry
->addend
);
3414 static bfd_reloc_status_type
3415 nios2_elf32_hiadj16_relocate (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
3416 void *data
, asection
*input_section
,
3418 char **error_message ATTRIBUTE_UNUSED
)
3420 /* This part is from bfd_elf_generic_reloc. */
3421 if (output_bfd
!= NULL
3422 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3423 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3425 reloc_entry
->address
+= input_section
->output_offset
;
3426 return bfd_reloc_ok
;
3429 if (output_bfd
!= NULL
)
3430 /* FIXME: See bfd_perform_relocation. Is this right? */
3431 return bfd_reloc_continue
;
3433 return nios2_elf32_do_hiadj16_relocate (abfd
, reloc_entry
->howto
,
3435 data
, reloc_entry
->address
,
3437 + symbol
->section
->output_section
->vma
3438 + symbol
->section
->output_offset
),
3439 reloc_entry
->addend
);
3442 static bfd_reloc_status_type
3443 nios2_elf32_pcrel_lo16_relocate (bfd
*abfd
, arelent
*reloc_entry
,
3444 asymbol
*symbol
, void *data
,
3445 asection
*input_section
, bfd
*output_bfd
,
3446 char **error_message ATTRIBUTE_UNUSED
)
3448 /* This part is from bfd_elf_generic_reloc. */
3449 if (output_bfd
!= NULL
3450 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3451 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3453 reloc_entry
->address
+= input_section
->output_offset
;
3454 return bfd_reloc_ok
;
3457 if (output_bfd
!= NULL
)
3458 /* FIXME: See bfd_perform_relocation. Is this right? */
3459 return bfd_reloc_continue
;
3461 return nios2_elf32_do_pcrel_lo16_relocate (
3462 abfd
, reloc_entry
->howto
, input_section
, data
, reloc_entry
->address
,
3463 (symbol
->value
+ symbol
->section
->output_section
->vma
3464 + symbol
->section
->output_offset
),
3465 reloc_entry
->addend
);
3468 static bfd_reloc_status_type
3469 nios2_elf32_pcrel_hiadj16_relocate (bfd
*abfd
, arelent
*reloc_entry
,
3470 asymbol
*symbol
, void *data
,
3471 asection
*input_section
, bfd
*output_bfd
,
3472 char **error_message ATTRIBUTE_UNUSED
)
3474 /* This part is from bfd_elf_generic_reloc. */
3475 if (output_bfd
!= NULL
3476 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3477 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3479 reloc_entry
->address
+= input_section
->output_offset
;
3480 return bfd_reloc_ok
;
3483 if (output_bfd
!= NULL
)
3484 /* FIXME: See bfd_perform_relocation. Is this right? */
3485 return bfd_reloc_continue
;
3487 return nios2_elf32_do_pcrel_hiadj16_relocate (
3488 abfd
, reloc_entry
->howto
, input_section
, data
, reloc_entry
->address
,
3489 (symbol
->value
+ symbol
->section
->output_section
->vma
3490 + symbol
->section
->output_offset
),
3491 reloc_entry
->addend
);
3494 static bfd_reloc_status_type
3495 nios2_elf32_pcrel16_relocate (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
3496 void *data
, asection
*input_section
,
3498 char **error_message ATTRIBUTE_UNUSED
)
3500 /* This part is from bfd_elf_generic_reloc. */
3501 if (output_bfd
!= NULL
3502 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3503 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3505 reloc_entry
->address
+= input_section
->output_offset
;
3506 return bfd_reloc_ok
;
3509 if (output_bfd
!= NULL
)
3510 /* FIXME: See bfd_perform_relocation. Is this right? */
3511 return bfd_reloc_continue
;
3513 return nios2_elf32_do_pcrel16_relocate (abfd
, reloc_entry
->howto
,
3515 data
, reloc_entry
->address
,
3517 + symbol
->section
->output_section
->vma
3518 + symbol
->section
->output_offset
),
3519 reloc_entry
->addend
);
3522 static bfd_reloc_status_type
3523 nios2_elf32_call26_relocate (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
3524 void *data
, asection
*input_section
,
3526 char **error_message ATTRIBUTE_UNUSED
)
3528 /* This part is from bfd_elf_generic_reloc. */
3529 if (output_bfd
!= NULL
3530 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3531 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3533 reloc_entry
->address
+= input_section
->output_offset
;
3534 return bfd_reloc_ok
;
3537 if (output_bfd
!= NULL
)
3538 /* FIXME: See bfd_perform_relocation. Is this right? */
3539 return bfd_reloc_continue
;
3541 return nios2_elf32_do_call26_relocate (abfd
, reloc_entry
->howto
,
3543 data
, reloc_entry
->address
,
3545 + symbol
->section
->output_section
->vma
3546 + symbol
->section
->output_offset
),
3547 reloc_entry
->addend
);
3550 static bfd_reloc_status_type
3551 nios2_elf32_gprel_relocate (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
3552 void *data
, asection
*input_section
,
3553 bfd
*output_bfd
, char **msg
)
3557 bfd_reloc_status_type r
;
3560 /* This part is from bfd_elf_generic_reloc. */
3561 if (output_bfd
!= NULL
3562 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3563 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3565 reloc_entry
->address
+= input_section
->output_offset
;
3566 return bfd_reloc_ok
;
3569 if (output_bfd
!= NULL
)
3570 /* FIXME: See bfd_perform_relocation. Is this right? */
3571 return bfd_reloc_continue
;
3573 relocation
= (symbol
->value
3574 + symbol
->section
->output_section
->vma
3575 + symbol
->section
->output_offset
);
3577 /* This assumes we've already cached the _gp symbol. */
3578 r
= nios2_elf_final_gp (abfd
, symbol
, FALSE
, msg
, &gp
);
3579 if (r
== bfd_reloc_ok
)
3581 relocation
= relocation
+ reloc_entry
->addend
- gp
;
3582 reloc_entry
->addend
= 0;
3583 if ((signed) relocation
< -32768 || (signed) relocation
> 32767)
3585 *msg
= _("global pointer relative address out of range");
3586 r
= bfd_reloc_outofrange
;
3589 r
= nios2_elf32_do_gprel_relocate (abfd
, reloc_entry
->howto
,
3591 data
, reloc_entry
->address
,
3592 relocation
, reloc_entry
->addend
);
3598 static bfd_reloc_status_type
3599 nios2_elf32_ujmp_relocate (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
3600 void *data
, asection
*input_section
,
3601 bfd
*output_bfd
, char **msg ATTRIBUTE_UNUSED
)
3603 /* This part is from bfd_elf_generic_reloc. */
3604 if (output_bfd
!= NULL
3605 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3606 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3608 reloc_entry
->address
+= input_section
->output_offset
;
3609 return bfd_reloc_ok
;
3612 if (output_bfd
!= NULL
)
3613 /* FIXME: See bfd_perform_relocation. Is this right? */
3614 return bfd_reloc_continue
;
3616 return nios2_elf32_do_ujmp_relocate (abfd
, reloc_entry
->howto
,
3618 data
, reloc_entry
->address
,
3620 + symbol
->section
->output_section
->vma
3621 + symbol
->section
->output_offset
),
3622 reloc_entry
->addend
);
3625 static bfd_reloc_status_type
3626 nios2_elf32_cjmp_relocate (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
3627 void *data
, asection
*input_section
,
3628 bfd
*output_bfd
, char **msg ATTRIBUTE_UNUSED
)
3630 /* This part is from bfd_elf_generic_reloc. */
3631 if (output_bfd
!= NULL
3632 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3633 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3635 reloc_entry
->address
+= input_section
->output_offset
;
3636 return bfd_reloc_ok
;
3639 if (output_bfd
!= NULL
)
3640 /* FIXME: See bfd_perform_relocation. Is this right? */
3641 return bfd_reloc_continue
;
3643 return nios2_elf32_do_cjmp_relocate (abfd
, reloc_entry
->howto
,
3645 data
, reloc_entry
->address
,
3647 + symbol
->section
->output_section
->vma
3648 + symbol
->section
->output_offset
),
3649 reloc_entry
->addend
);
3652 static bfd_reloc_status_type
3653 nios2_elf32_callr_relocate (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
3654 void *data
, asection
*input_section
,
3655 bfd
*output_bfd
, char **msg ATTRIBUTE_UNUSED
)
3657 /* This part is from bfd_elf_generic_reloc. */
3658 if (output_bfd
!= NULL
3659 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
3660 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
3662 reloc_entry
->address
+= input_section
->output_offset
;
3663 return bfd_reloc_ok
;
3666 if (output_bfd
!= NULL
)
3667 /* FIXME: See bfd_perform_relocation. Is this right? */
3668 return bfd_reloc_continue
;
3670 return nios2_elf32_do_callr_relocate (abfd
, reloc_entry
->howto
,
3672 data
, reloc_entry
->address
,
3674 + symbol
->section
->output_section
->vma
3675 + symbol
->section
->output_offset
),
3676 reloc_entry
->addend
);
3680 /* Implement elf_backend_relocate_section. */
3682 nios2_elf32_relocate_section (bfd
*output_bfd
,
3683 struct bfd_link_info
*info
,
3685 asection
*input_section
,
3687 Elf_Internal_Rela
*relocs
,
3688 Elf_Internal_Sym
*local_syms
,
3689 asection
**local_sections
)
3691 Elf_Internal_Shdr
*symtab_hdr
;
3692 struct elf_link_hash_entry
**sym_hashes
;
3693 Elf_Internal_Rela
*rel
;
3694 Elf_Internal_Rela
*relend
;
3695 struct elf32_nios2_link_hash_table
*htab
;
3698 asection
*sreloc
= NULL
;
3699 bfd_vma
*local_got_offsets
;
3702 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3703 sym_hashes
= elf_sym_hashes (input_bfd
);
3704 relend
= relocs
+ input_section
->reloc_count
;
3706 htab
= elf32_nios2_hash_table (info
);
3707 sgot
= htab
->root
.sgot
;
3708 splt
= htab
->root
.splt
;
3709 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3711 if (htab
->h_gp_got
== NULL
)
3714 got_base
= htab
->h_gp_got
->root
.u
.def
.value
;
3716 for (rel
= relocs
; rel
< relend
; rel
++)
3718 reloc_howto_type
*howto
;
3719 unsigned long r_symndx
;
3720 Elf_Internal_Sym
*sym
;
3722 struct elf_link_hash_entry
*h
;
3723 struct elf32_nios2_link_hash_entry
*eh
;
3726 bfd_reloc_status_type r
= bfd_reloc_ok
;
3727 const char *name
= NULL
;
3730 char *msgbuf
= NULL
;
3732 bfd_boolean unresolved_reloc
;
3736 r_type
= ELF32_R_TYPE (rel
->r_info
);
3737 r_symndx
= ELF32_R_SYM (rel
->r_info
);
3739 howto
= lookup_howto ((unsigned) ELF32_R_TYPE (rel
->r_info
), output_bfd
);
3744 if (r_symndx
< symtab_hdr
->sh_info
)
3746 sym
= local_syms
+ r_symndx
;
3747 sec
= local_sections
[r_symndx
];
3748 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
3752 bfd_boolean warned
, ignored
;
3754 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3755 r_symndx
, symtab_hdr
, sym_hashes
,
3757 unresolved_reloc
, warned
, ignored
);
3760 if (sec
&& discarded_section (sec
))
3761 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3762 rel
, 1, relend
, howto
, 0, contents
);
3764 /* Nothing more to do unless this is a final link. */
3765 if (bfd_link_relocatable (info
))
3770 bfd_boolean resolved_to_zero
;
3772 resolved_to_zero
= (h
!= NULL
3773 && UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
));
3774 switch (howto
->type
)
3777 r
= nios2_elf32_do_hi16_relocate (input_bfd
, howto
,
3779 contents
, rel
->r_offset
,
3780 relocation
, rel
->r_addend
);
3783 r
= nios2_elf32_do_lo16_relocate (input_bfd
, howto
,
3785 contents
, rel
->r_offset
,
3786 relocation
, rel
->r_addend
);
3788 case R_NIOS2_PCREL_LO
:
3789 r
= nios2_elf32_do_pcrel_lo16_relocate (input_bfd
, howto
,
3796 case R_NIOS2_HIADJ16
:
3797 r
= nios2_elf32_do_hiadj16_relocate (input_bfd
, howto
,
3798 input_section
, contents
,
3799 rel
->r_offset
, relocation
,
3802 case R_NIOS2_PCREL_HA
:
3803 r
= nios2_elf32_do_pcrel_hiadj16_relocate (input_bfd
, howto
,
3810 case R_NIOS2_PCREL16
:
3811 r
= nios2_elf32_do_pcrel16_relocate (input_bfd
, howto
,
3812 input_section
, contents
,
3813 rel
->r_offset
, relocation
,
3817 /* Turns an absolute address into a gp-relative address. */
3818 if (!nios2_elf_assign_gp (output_bfd
, &gp
, info
))
3820 bfd_vma reloc_address
;
3822 if (sec
&& sec
->output_section
)
3823 reloc_address
= (sec
->output_section
->vma
3824 + sec
->output_offset
3829 format
= _("global pointer relative relocation at address "
3830 "%#" PRIx64
" when _gp not defined\n");
3831 if (asprintf (&msgbuf
, format
,
3832 (uint64_t) reloc_address
) == -1)
3835 r
= bfd_reloc_dangerous
;
3839 bfd_vma symbol_address
= rel
->r_addend
+ relocation
;
3840 relocation
= symbol_address
- gp
;
3842 if (((signed) relocation
< -32768
3843 || (signed) relocation
> 32767)
3845 || h
->root
.type
== bfd_link_hash_defined
3846 || h
->root
.type
== bfd_link_hash_defweak
))
3849 name
= h
->root
.root
.string
;
3852 name
= (bfd_elf_string_from_elf_section
3853 (input_bfd
, symtab_hdr
->sh_link
,
3855 if (name
== NULL
|| *name
== '\0')
3856 name
= bfd_section_name (sec
);
3858 /* xgettext:c-format */
3859 format
= _("unable to reach %s (at %#" PRIx64
") from "
3860 "the global pointer (at %#" PRIx64
") "
3861 "because the offset (%" PRId64
") is out of "
3862 "the allowed range, -32678 to 32767\n" );
3863 if (asprintf (&msgbuf
, format
, name
,
3864 (uint64_t) symbol_address
, (uint64_t) gp
,
3865 (int64_t) relocation
) == -1)
3868 r
= bfd_reloc_outofrange
;
3871 r
= _bfd_final_link_relocate (howto
, input_bfd
,
3872 input_section
, contents
,
3873 rel
->r_offset
, relocation
,
3878 r
= nios2_elf32_do_ujmp_relocate (input_bfd
, howto
,
3880 contents
, rel
->r_offset
,
3881 relocation
, rel
->r_addend
);
3884 r
= nios2_elf32_do_cjmp_relocate (input_bfd
, howto
,
3886 contents
, rel
->r_offset
,
3887 relocation
, rel
->r_addend
);
3890 r
= nios2_elf32_do_callr_relocate (input_bfd
, howto
,
3891 input_section
, contents
,
3892 rel
->r_offset
, relocation
,
3895 case R_NIOS2_CALL26
:
3896 case R_NIOS2_CALL26_NOAT
:
3897 /* If we have a call to an undefined weak symbol, we just want
3898 to stuff a zero in the bits of the call instruction and
3899 bypass the normal call26 relocation handling, because it'll
3900 diagnose an overflow error if address 0 isn't in the same
3901 256MB segment as the call site. Presumably the call
3902 should be guarded by a null check anyway. */
3903 if (h
!= NULL
&& h
->root
.type
== bfd_link_hash_undefweak
)
3905 BFD_ASSERT (relocation
== 0 && rel
->r_addend
== 0);
3906 r
= _bfd_final_link_relocate (howto
, input_bfd
,
3907 input_section
, contents
,
3908 rel
->r_offset
, relocation
,
3912 /* Handle relocations which should use the PLT entry.
3913 NIOS2_BFD_RELOC_32 relocations will use the symbol's value,
3914 which may point to a PLT entry, but we don't need to handle
3915 that here. If we created a PLT entry, all branches in this
3916 object should go to it. */
3917 if (h
!= NULL
&& splt
!= NULL
&& h
->plt
.offset
!= (bfd_vma
) -1)
3919 /* If we've created a .plt section, and assigned a PLT entry
3920 to this function, it should not be known to bind locally.
3921 If it were, we would have cleared the PLT entry. */
3922 BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info
, h
));
3924 relocation
= (splt
->output_section
->vma
3925 + splt
->output_offset
3928 unresolved_reloc
= FALSE
;
3930 /* Detect R_NIOS2_CALL26 relocations that would overflow the
3931 256MB segment. Replace the target with a reference to a
3933 Note that htab->stub_group is null if relaxation has been
3934 disabled by the --no-relax linker command-line option, so
3935 we can use that to skip this processing entirely. */
3936 if (howto
->type
== R_NIOS2_CALL26
&& htab
->stub_group
)
3938 bfd_vma dest
= relocation
+ rel
->r_addend
;
3939 enum elf32_nios2_stub_type stub_type
;
3941 eh
= (struct elf32_nios2_link_hash_entry
*)h
;
3942 stub_type
= nios2_type_of_stub (input_section
, rel
, eh
,
3945 if (stub_type
!= nios2_stub_none
)
3947 struct elf32_nios2_stub_hash_entry
*hsh
;
3949 hsh
= nios2_get_stub_entry (input_section
, sec
,
3950 eh
, rel
, htab
, stub_type
);
3953 r
= bfd_reloc_undefined
;
3957 dest
= (hsh
->stub_offset
3958 + hsh
->stub_sec
->output_offset
3959 + hsh
->stub_sec
->output_section
->vma
);
3960 r
= nios2_elf32_do_call26_relocate (input_bfd
, howto
,
3970 r
= nios2_elf32_do_call26_relocate (input_bfd
, howto
,
3971 input_section
, contents
,
3972 rel
->r_offset
, relocation
,
3977 /* For symmetry this would be
3978 r = nios2_elf32_do_ignore_reloc (input_bfd, howto,
3979 input_section, contents,
3980 rel->r_offset, relocation,
3982 but do_ignore_reloc would do no more than return
3987 case R_NIOS2_CALL16
:
3988 case R_NIOS2_GOT_LO
:
3989 case R_NIOS2_GOT_HA
:
3990 case R_NIOS2_CALL_LO
:
3991 case R_NIOS2_CALL_HA
:
3992 /* Relocation is to the entry for this symbol in the
3993 global offset table. */
3996 r
= bfd_reloc_notsupported
;
4006 eh
= (struct elf32_nios2_link_hash_entry
*)h
;
4007 use_plt
= (eh
->got_types_used
== CALL_USED
4008 && h
->plt
.offset
!= (bfd_vma
) -1);
4010 off
= h
->got
.offset
;
4011 BFD_ASSERT (off
!= (bfd_vma
) -1);
4012 dyn
= htab
->root
.dynamic_sections_created
;
4013 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
4014 bfd_link_pic (info
),
4016 || (bfd_link_pic (info
)
4017 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4018 || ((ELF_ST_VISIBILITY (h
->other
)
4019 || resolved_to_zero
)
4020 && h
->root
.type
== bfd_link_hash_undefweak
))
4022 /* This is actually a static link, or it is a -Bsymbolic
4023 link and the symbol is defined locally. We must
4024 initialize this entry in the global offset table.
4025 Since the offset must always be a multiple of 4, we
4026 use the least significant bit to record whether we
4027 have initialized it already.
4029 When doing a dynamic link, we create a .rela.got
4030 relocation entry to initialize the value. This is
4031 done in the finish_dynamic_symbol routine. */
4036 bfd_put_32 (output_bfd
, relocation
,
4037 sgot
->contents
+ off
);
4042 unresolved_reloc
= FALSE
;
4046 BFD_ASSERT (local_got_offsets
!= NULL
4047 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
4049 off
= local_got_offsets
[r_symndx
];
4051 /* The offset must always be a multiple of 4. We use the
4052 least significant bit to record whether we have already
4053 generated the necessary reloc. */
4058 bfd_put_32 (output_bfd
, relocation
,
4059 sgot
->contents
+ off
);
4061 if (bfd_link_pic (info
))
4064 Elf_Internal_Rela outrel
;
4067 srelgot
= htab
->root
.srelgot
;
4068 BFD_ASSERT (srelgot
!= NULL
);
4070 outrel
.r_addend
= relocation
;
4071 outrel
.r_offset
= (sgot
->output_section
->vma
4072 + sgot
->output_offset
4074 outrel
.r_info
= ELF32_R_INFO (0, R_NIOS2_RELATIVE
);
4075 loc
= srelgot
->contents
;
4076 loc
+= (srelgot
->reloc_count
++ *
4077 sizeof (Elf32_External_Rela
));
4078 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4081 local_got_offsets
[r_symndx
] |= 1;
4085 if (use_plt
&& bfd_link_pic (info
))
4087 off
= ((h
->plt
.offset
- 24) / 12 + 3) * 4;
4088 relocation
= (htab
->root
.sgotplt
->output_offset
+ off
4092 relocation
= sgot
->output_offset
+ off
- got_base
;
4094 /* This relocation does not use the addend. */
4097 switch (howto
->type
)
4099 case R_NIOS2_GOT_LO
:
4100 case R_NIOS2_CALL_LO
:
4101 r
= nios2_elf32_do_lo16_relocate (input_bfd
, howto
,
4102 input_section
, contents
,
4103 rel
->r_offset
, relocation
,
4106 case R_NIOS2_GOT_HA
:
4107 case R_NIOS2_CALL_HA
:
4108 r
= nios2_elf32_do_hiadj16_relocate (input_bfd
, howto
,
4109 input_section
, contents
,
4115 r
= _bfd_final_link_relocate (howto
, input_bfd
,
4116 input_section
, contents
,
4117 rel
->r_offset
, relocation
,
4123 case R_NIOS2_GOTOFF_LO
:
4124 case R_NIOS2_GOTOFF_HA
:
4125 case R_NIOS2_GOTOFF
:
4126 /* Relocation is relative to the global offset table pointer. */
4128 BFD_ASSERT (sgot
!= NULL
);
4131 r
= bfd_reloc_notsupported
;
4135 /* Note that sgot->output_offset is not involved in this
4136 calculation. We always want the start of .got. */
4137 relocation
-= sgot
->output_section
->vma
;
4139 /* Now we adjust the relocation to be relative to the GOT pointer
4140 (the _gp_got symbol), which possibly contains the 0x8000 bias. */
4141 relocation
-= got_base
;
4143 switch (howto
->type
)
4145 case R_NIOS2_GOTOFF_LO
:
4146 r
= nios2_elf32_do_lo16_relocate (input_bfd
, howto
,
4147 input_section
, contents
,
4148 rel
->r_offset
, relocation
,
4151 case R_NIOS2_GOTOFF_HA
:
4152 r
= nios2_elf32_do_hiadj16_relocate (input_bfd
, howto
,
4153 input_section
, contents
,
4159 r
= _bfd_final_link_relocate (howto
, input_bfd
,
4160 input_section
, contents
,
4161 rel
->r_offset
, relocation
,
4167 case R_NIOS2_TLS_LDO16
:
4168 relocation
-= dtpoff_base (info
) + DTP_OFFSET
;
4170 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4171 contents
, rel
->r_offset
,
4172 relocation
, rel
->r_addend
);
4174 case R_NIOS2_TLS_LDM16
:
4175 if (htab
->root
.sgot
== NULL
)
4178 off
= htab
->tls_ldm_got
.offset
;
4184 /* If we don't know the module number, create a relocation
4186 if (bfd_link_pic (info
))
4188 Elf_Internal_Rela outrel
;
4191 if (htab
->root
.srelgot
== NULL
)
4194 outrel
.r_addend
= 0;
4195 outrel
.r_offset
= (htab
->root
.sgot
->output_section
->vma
4196 + htab
->root
.sgot
->output_offset
4198 outrel
.r_info
= ELF32_R_INFO (0, R_NIOS2_TLS_DTPMOD
);
4200 loc
= htab
->root
.srelgot
->contents
;
4201 loc
+= (htab
->root
.srelgot
->reloc_count
++
4202 * sizeof (Elf32_External_Rela
));
4203 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4206 bfd_put_32 (output_bfd
, 1,
4207 htab
->root
.sgot
->contents
+ off
);
4209 htab
->tls_ldm_got
.offset
|= 1;
4212 relocation
= htab
->root
.sgot
->output_offset
+ off
- got_base
;
4214 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4215 contents
, rel
->r_offset
,
4216 relocation
, rel
->r_addend
);
4219 case R_NIOS2_TLS_GD16
:
4220 case R_NIOS2_TLS_IE16
:
4225 if (htab
->root
.sgot
== NULL
)
4232 dyn
= htab
->root
.dynamic_sections_created
;
4233 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
4234 bfd_link_pic (info
),
4236 && (!bfd_link_pic (info
)
4237 || !SYMBOL_REFERENCES_LOCAL (info
, h
)))
4239 unresolved_reloc
= FALSE
;
4242 off
= h
->got
.offset
;
4243 tls_type
= (((struct elf32_nios2_link_hash_entry
*) h
)
4248 if (local_got_offsets
== NULL
)
4250 off
= local_got_offsets
[r_symndx
];
4251 tls_type
= (elf32_nios2_local_got_tls_type (input_bfd
)
4255 if (tls_type
== GOT_UNKNOWN
)
4262 bfd_boolean need_relocs
= FALSE
;
4263 Elf_Internal_Rela outrel
;
4264 bfd_byte
*loc
= NULL
;
4267 /* The GOT entries have not been initialized yet. Do it
4268 now, and emit any relocations. If both an IE GOT and a
4269 GD GOT are necessary, we emit the GD first. */
4271 if ((bfd_link_pic (info
) || indx
!= 0)
4273 || (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4274 && !resolved_to_zero
)
4275 || h
->root
.type
!= bfd_link_hash_undefweak
))
4278 if (htab
->root
.srelgot
== NULL
)
4280 loc
= htab
->root
.srelgot
->contents
;
4281 loc
+= (htab
->root
.srelgot
->reloc_count
*
4282 sizeof (Elf32_External_Rela
));
4285 if (tls_type
& GOT_TLS_GD
)
4289 outrel
.r_addend
= 0;
4290 outrel
.r_offset
= (htab
->root
.sgot
->output_section
->vma
4291 + htab
->root
.sgot
->output_offset
4293 outrel
.r_info
= ELF32_R_INFO (indx
,
4294 R_NIOS2_TLS_DTPMOD
);
4296 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
4298 htab
->root
.srelgot
->reloc_count
++;
4299 loc
+= sizeof (Elf32_External_Rela
);
4302 bfd_put_32 (output_bfd
,
4303 (relocation
- dtpoff_base (info
) -
4305 htab
->root
.sgot
->contents
+ cur_off
+ 4);
4308 outrel
.r_addend
= 0;
4309 outrel
.r_info
= ELF32_R_INFO (indx
,
4310 R_NIOS2_TLS_DTPREL
);
4311 outrel
.r_offset
+= 4;
4313 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
4315 htab
->root
.srelgot
->reloc_count
++;
4316 loc
+= sizeof (Elf32_External_Rela
);
4321 /* If we are not emitting relocations for a
4322 general dynamic reference, then we must be in a
4323 static link or an executable link with the
4324 symbol binding locally. Mark it as belonging
4325 to module 1, the executable. */
4326 bfd_put_32 (output_bfd
, 1,
4327 htab
->root
.sgot
->contents
+ cur_off
);
4328 bfd_put_32 (output_bfd
, (relocation
-
4329 dtpoff_base (info
) -
4331 htab
->root
.sgot
->contents
+ cur_off
+ 4);
4337 if (tls_type
& GOT_TLS_IE
)
4342 outrel
.r_addend
= (relocation
-
4343 dtpoff_base (info
));
4345 outrel
.r_addend
= 0;
4346 outrel
.r_offset
= (htab
->root
.sgot
->output_section
->vma
4347 + htab
->root
.sgot
->output_offset
4349 outrel
.r_info
= ELF32_R_INFO (indx
,
4352 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
4354 htab
->root
.srelgot
->reloc_count
++;
4355 loc
+= sizeof (Elf32_External_Rela
);
4358 bfd_put_32 (output_bfd
, (tpoff (info
, relocation
)
4360 htab
->root
.sgot
->contents
+ cur_off
);
4367 local_got_offsets
[r_symndx
] |= 1;
4370 if ((tls_type
& GOT_TLS_GD
) && r_type
!= R_NIOS2_TLS_GD16
)
4372 relocation
= htab
->root
.sgot
->output_offset
+ off
- got_base
;
4374 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4375 contents
, rel
->r_offset
,
4376 relocation
, rel
->r_addend
);
4380 case R_NIOS2_TLS_LE16
:
4381 if (bfd_link_dll (info
))
4384 /* xgettext:c-format */
4385 (_("%pB(%pA+%#" PRIx64
"): %s relocation not "
4386 "permitted in shared object"),
4387 input_bfd
, input_section
,
4388 (uint64_t) rel
->r_offset
, howto
->name
);
4392 relocation
= tpoff (info
, relocation
) - TP_OFFSET
;
4394 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4395 contents
, rel
->r_offset
,
4396 relocation
, rel
->r_addend
);
4399 case R_NIOS2_BFD_RELOC_32
:
4400 if (bfd_link_pic (info
)
4401 && (input_section
->flags
& SEC_ALLOC
) != 0
4403 || (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4404 && !resolved_to_zero
)
4405 || h
->root
.type
!= bfd_link_hash_undefweak
))
4407 Elf_Internal_Rela outrel
;
4409 bfd_boolean skip
, relocate
;
4411 /* When generating a shared object, these relocations
4412 are copied into the output file to be resolved at run
4419 = _bfd_elf_section_offset (output_bfd
, info
,
4420 input_section
, rel
->r_offset
);
4421 if (outrel
.r_offset
== (bfd_vma
) -1)
4423 else if (outrel
.r_offset
== (bfd_vma
) -2)
4424 skip
= TRUE
, relocate
= TRUE
;
4425 outrel
.r_offset
+= (input_section
->output_section
->vma
4426 + input_section
->output_offset
);
4429 memset (&outrel
, 0, sizeof outrel
);
4432 && (!bfd_link_pic (info
)
4433 || !SYMBOLIC_BIND (info
, h
)
4434 || !h
->def_regular
))
4436 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
4437 outrel
.r_addend
= rel
->r_addend
;
4441 /* This symbol is local, or marked to become local. */
4442 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4444 outrel
.r_info
= ELF32_R_INFO (0, R_NIOS2_RELATIVE
);
4447 sreloc
= elf_section_data (input_section
)->sreloc
;
4451 loc
= sreloc
->contents
;
4452 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4453 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4455 /* This reloc will be computed at runtime, so there's no
4456 need to do anything now, except for R_NIOS2_BFD_RELOC_32
4457 relocations that have been turned into
4458 R_NIOS2_RELATIVE. */
4463 r
= _bfd_final_link_relocate (howto
, input_bfd
,
4464 input_section
, contents
,
4465 rel
->r_offset
, relocation
,
4469 case R_NIOS2_TLS_DTPREL
:
4470 relocation
-= dtpoff_base (info
);
4474 r
= _bfd_final_link_relocate (howto
, input_bfd
,
4475 input_section
, contents
,
4476 rel
->r_offset
, relocation
,
4482 r
= bfd_reloc_notsupported
;
4484 if (r
!= bfd_reloc_ok
)
4487 name
= h
->root
.root
.string
;
4490 name
= bfd_elf_string_from_elf_section (input_bfd
,
4491 symtab_hdr
->sh_link
,
4493 if (name
== NULL
|| *name
== '\0')
4494 name
= bfd_section_name (sec
);
4499 case bfd_reloc_overflow
:
4500 (*info
->callbacks
->reloc_overflow
) (info
, NULL
, name
,
4501 howto
->name
, (bfd_vma
) 0,
4502 input_bfd
, input_section
,
4506 case bfd_reloc_undefined
:
4507 (*info
->callbacks
->undefined_symbol
) (info
, name
, input_bfd
,
4509 rel
->r_offset
, TRUE
);
4512 case bfd_reloc_outofrange
:
4514 msg
= _("relocation out of range");
4517 case bfd_reloc_notsupported
:
4519 msg
= _("unsupported relocation");
4522 case bfd_reloc_dangerous
:
4524 msg
= _("dangerous relocation");
4529 msg
= _("unknown error");
4535 (*info
->callbacks
->warning
) (info
, msg
, name
, input_bfd
,
4536 input_section
, rel
->r_offset
);
4545 /* Implement elf-backend_section_flags:
4546 Convert NIOS2 specific section flags to bfd internal section flags. */
4548 nios2_elf32_section_flags (const Elf_Internal_Shdr
*hdr
)
4550 if (hdr
->sh_flags
& SHF_NIOS2_GPREL
)
4551 hdr
->bfd_section
->flags
|= SEC_SMALL_DATA
;
4556 /* Implement elf_backend_fake_sections:
4557 Set the correct type for an NIOS2 ELF section. We do this by the
4558 section name, which is a hack, but ought to work. */
4560 nios2_elf32_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
4561 Elf_Internal_Shdr
*hdr
, asection
*sec
)
4563 const char *name
= bfd_section_name (sec
);
4565 if ((sec
->flags
& SEC_SMALL_DATA
)
4566 || strcmp (name
, ".sdata") == 0
4567 || strcmp (name
, ".sbss") == 0
4568 || strcmp (name
, ".lit4") == 0 || strcmp (name
, ".lit8") == 0)
4569 hdr
->sh_flags
|= SHF_NIOS2_GPREL
;
4574 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
4575 shortcuts to them in our hash table. */
4577 create_got_section (bfd
*dynobj
, struct bfd_link_info
*info
)
4579 struct elf32_nios2_link_hash_table
*htab
;
4580 struct elf_link_hash_entry
*h
;
4582 htab
= elf32_nios2_hash_table (info
);
4584 if (! _bfd_elf_create_got_section (dynobj
, info
))
4587 /* In order for the two loads in .PLTresolve to share the same %hiadj,
4588 _GLOBAL_OFFSET_TABLE_ must be aligned to a 16-byte boundary. */
4589 if (!bfd_set_section_alignment (htab
->root
.sgotplt
, 4))
4592 /* The Nios II ABI specifies that GOT-relative relocations are relative
4593 to the linker-created symbol _gp_got, rather than using
4594 _GLOBAL_OFFSET_TABLE_ directly. In particular, the latter always
4595 points to the base of the GOT while _gp_got may include a bias. */
4596 h
= _bfd_elf_define_linkage_sym (dynobj
, info
, htab
->root
.sgotplt
,
4605 /* Implement elf_backend_create_dynamic_sections:
4606 Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
4607 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
4610 nios2_elf32_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
4612 struct elf32_nios2_link_hash_table
*htab
;
4614 htab
= elf32_nios2_hash_table (info
);
4615 if (!htab
->root
.sgot
&& !create_got_section (dynobj
, info
))
4618 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
4621 /* In order for the two loads in a shared object .PLTresolve to share the
4622 same %hiadj, the start of the PLT (as well as the GOT) must be aligned
4623 to a 16-byte boundary. This is because the addresses for these loads
4624 include the -(.plt+4) PIC correction. */
4625 return bfd_set_section_alignment (htab
->root
.splt
, 4);
4628 /* Implement elf_backend_copy_indirect_symbol:
4629 Copy the extra info we tack onto an elf_link_hash_entry. */
4631 nios2_elf32_copy_indirect_symbol (struct bfd_link_info
*info
,
4632 struct elf_link_hash_entry
*dir
,
4633 struct elf_link_hash_entry
*ind
)
4635 struct elf32_nios2_link_hash_entry
*edir
, *eind
;
4637 edir
= (struct elf32_nios2_link_hash_entry
*) dir
;
4638 eind
= (struct elf32_nios2_link_hash_entry
*) ind
;
4640 if (ind
->dyn_relocs
!= NULL
)
4642 if (dir
->dyn_relocs
!= NULL
)
4644 struct elf_dyn_relocs
**pp
;
4645 struct elf_dyn_relocs
*p
;
4647 /* Add reloc counts against the indirect sym to the direct sym
4648 list. Merge any entries against the same section. */
4649 for (pp
= &ind
->dyn_relocs
; (p
= *pp
) != NULL
; )
4651 struct elf_dyn_relocs
*q
;
4653 for (q
= dir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
4654 if (q
->sec
== p
->sec
)
4656 q
->pc_count
+= p
->pc_count
;
4657 q
->count
+= p
->count
;
4664 *pp
= dir
->dyn_relocs
;
4667 dir
->dyn_relocs
= ind
->dyn_relocs
;
4668 ind
->dyn_relocs
= NULL
;
4671 if (ind
->root
.type
== bfd_link_hash_indirect
4672 && dir
->got
.refcount
<= 0)
4674 edir
->tls_type
= eind
->tls_type
;
4675 eind
->tls_type
= GOT_UNKNOWN
;
4678 edir
->got_types_used
|= eind
->got_types_used
;
4680 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
4683 /* Set the right machine number for a NIOS2 ELF file. */
4686 nios2_elf32_object_p (bfd
*abfd
)
4690 mach
= elf_elfheader (abfd
)->e_flags
;
4695 case EF_NIOS2_ARCH_R1
:
4696 bfd_default_set_arch_mach (abfd
, bfd_arch_nios2
, bfd_mach_nios2r1
);
4698 case EF_NIOS2_ARCH_R2
:
4699 bfd_default_set_arch_mach (abfd
, bfd_arch_nios2
, bfd_mach_nios2r2
);
4706 /* Implement elf_backend_check_relocs:
4707 Look through the relocs for a section during the first phase. */
4709 nios2_elf32_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
4710 asection
*sec
, const Elf_Internal_Rela
*relocs
)
4712 Elf_Internal_Shdr
*symtab_hdr
;
4713 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
4714 const Elf_Internal_Rela
*rel
;
4715 const Elf_Internal_Rela
*rel_end
;
4716 struct elf32_nios2_link_hash_table
*htab
;
4717 asection
*sreloc
= NULL
;
4718 bfd_signed_vma
*local_got_refcounts
;
4720 if (bfd_link_relocatable (info
))
4723 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4724 sym_hashes
= elf_sym_hashes (abfd
);
4725 sym_hashes_end
= (sym_hashes
4726 + symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
));
4727 if (!elf_bad_symtab (abfd
))
4728 sym_hashes_end
-= symtab_hdr
->sh_info
;
4729 local_got_refcounts
= elf_local_got_refcounts (abfd
);
4731 htab
= elf32_nios2_hash_table (info
);
4733 rel_end
= relocs
+ sec
->reloc_count
;
4734 for (rel
= relocs
; rel
< rel_end
; rel
++)
4736 unsigned int r_type
;
4737 struct elf_link_hash_entry
*h
;
4738 unsigned long r_symndx
;
4740 r_symndx
= ELF32_R_SYM (rel
->r_info
);
4741 if (r_symndx
< symtab_hdr
->sh_info
)
4745 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
4746 while (h
->root
.type
== bfd_link_hash_indirect
4747 || h
->root
.type
== bfd_link_hash_warning
)
4748 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4751 r_type
= ELF32_R_TYPE (rel
->r_info
);
4756 case R_NIOS2_GOT_LO
:
4757 case R_NIOS2_GOT_HA
:
4758 case R_NIOS2_CALL16
:
4759 case R_NIOS2_CALL_LO
:
4760 case R_NIOS2_CALL_HA
:
4761 case R_NIOS2_TLS_GD16
:
4762 case R_NIOS2_TLS_IE16
:
4763 /* This symbol requires a global offset table entry. */
4765 int tls_type
, old_tls_type
;
4771 case R_NIOS2_GOT_LO
:
4772 case R_NIOS2_GOT_HA
:
4773 case R_NIOS2_CALL16
:
4774 case R_NIOS2_CALL_LO
:
4775 case R_NIOS2_CALL_HA
:
4776 tls_type
= GOT_NORMAL
;
4778 case R_NIOS2_TLS_GD16
:
4779 tls_type
= GOT_TLS_GD
;
4781 case R_NIOS2_TLS_IE16
:
4782 tls_type
= GOT_TLS_IE
;
4788 struct elf32_nios2_link_hash_entry
*eh
4789 = (struct elf32_nios2_link_hash_entry
*)h
;
4791 old_tls_type
= elf32_nios2_hash_entry(h
)->tls_type
;
4792 if (r_type
== R_NIOS2_CALL16
4793 || r_type
== R_NIOS2_CALL_LO
4794 || r_type
== R_NIOS2_CALL_HA
)
4796 /* Make sure a plt entry is created for this symbol if
4797 it turns out to be a function defined by a dynamic
4802 eh
->got_types_used
|= CALL_USED
;
4805 eh
->got_types_used
|= GOT_USED
;
4809 /* This is a global offset table entry for a local symbol. */
4810 if (local_got_refcounts
== NULL
)
4814 size
= symtab_hdr
->sh_info
;
4815 size
*= (sizeof (bfd_signed_vma
) + sizeof (char));
4817 = ((bfd_signed_vma
*) bfd_zalloc (abfd
, size
));
4818 if (local_got_refcounts
== NULL
)
4820 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
4821 elf32_nios2_local_got_tls_type (abfd
)
4822 = (char *) (local_got_refcounts
+ symtab_hdr
->sh_info
);
4824 local_got_refcounts
[r_symndx
]++;
4825 old_tls_type
= elf32_nios2_local_got_tls_type (abfd
) [r_symndx
];
4828 /* We will already have issued an error message if there is a
4829 TLS / non-TLS mismatch, based on the symbol type. We don't
4830 support any linker relaxations. So just combine any TLS
4832 if (old_tls_type
!= GOT_UNKNOWN
&& old_tls_type
!= GOT_NORMAL
4833 && tls_type
!= GOT_NORMAL
)
4834 tls_type
|= old_tls_type
;
4836 if (old_tls_type
!= tls_type
)
4839 elf32_nios2_hash_entry (h
)->tls_type
= tls_type
;
4841 elf32_nios2_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
4845 if (htab
->root
.sgot
== NULL
)
4847 if (htab
->root
.dynobj
== NULL
)
4848 htab
->root
.dynobj
= abfd
;
4849 if (!create_got_section (htab
->root
.dynobj
, info
))
4854 case R_NIOS2_TLS_LDM16
:
4855 htab
->tls_ldm_got
.refcount
++;
4858 /* This relocation describes the C++ object vtable hierarchy.
4859 Reconstruct it for later use during GC. */
4860 case R_NIOS2_GNU_VTINHERIT
:
4861 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
4865 /* This relocation describes which C++ vtable entries are actually
4866 used. Record for later use during GC. */
4867 case R_NIOS2_GNU_VTENTRY
:
4868 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
4872 case R_NIOS2_BFD_RELOC_32
:
4873 case R_NIOS2_CALL26
:
4874 case R_NIOS2_CALL26_NOAT
:
4875 case R_NIOS2_HIADJ16
:
4880 /* If this reloc is in a read-only section, we might
4881 need a copy reloc. We can't check reliably at this
4882 stage whether the section is read-only, as input
4883 sections have not yet been mapped to output sections.
4884 Tentatively set the flag for now, and correct in
4885 adjust_dynamic_symbol. */
4886 if (!bfd_link_pic (info
))
4889 /* Make sure a plt entry is created for this symbol if it
4890 turns out to be a function defined by a dynamic object. */
4893 if (r_type
== R_NIOS2_CALL26
|| r_type
== R_NIOS2_CALL26_NOAT
)
4897 /* If we are creating a shared library, we need to copy the
4898 reloc into the shared library. */
4899 if (bfd_link_pic (info
)
4900 && (sec
->flags
& SEC_ALLOC
) != 0
4901 && (r_type
== R_NIOS2_BFD_RELOC_32
4902 || (h
!= NULL
&& ! h
->needs_plt
4903 && (! SYMBOLIC_BIND (info
, h
) || ! h
->def_regular
))))
4905 struct elf_dyn_relocs
*p
;
4906 struct elf_dyn_relocs
**head
;
4908 /* When creating a shared object, we must copy these
4909 reloc types into the output file. We create a reloc
4910 section in dynobj and make room for this reloc. */
4913 if (htab
->root
.dynobj
== NULL
)
4914 htab
->root
.dynobj
= abfd
;
4916 sreloc
= _bfd_elf_make_dynamic_reloc_section
4917 (sec
, htab
->root
.dynobj
, 2, abfd
, TRUE
);
4922 /* If this is a global symbol, we count the number of
4923 relocations we need for this symbol. */
4925 head
= &h
->dyn_relocs
;
4928 /* Track dynamic relocs needed for local syms too.
4929 We really need local syms available to do this
4934 Elf_Internal_Sym
*isym
;
4936 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
4941 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
4945 vpp
= &elf_section_data (s
)->local_dynrel
;
4946 head
= (struct elf_dyn_relocs
**) vpp
;
4950 if (p
== NULL
|| p
->sec
!= sec
)
4952 size_t amt
= sizeof *p
;
4953 p
= ((struct elf_dyn_relocs
*)
4954 bfd_alloc (htab
->root
.dynobj
, amt
));
4975 /* Implement elf_backend_gc_mark_hook:
4976 Return the section that should be marked against GC for a given
4979 nios2_elf32_gc_mark_hook (asection
*sec
,
4980 struct bfd_link_info
*info
,
4981 Elf_Internal_Rela
*rel
,
4982 struct elf_link_hash_entry
*h
,
4983 Elf_Internal_Sym
*sym
)
4986 switch (ELF32_R_TYPE (rel
->r_info
))
4988 case R_NIOS2_GNU_VTINHERIT
:
4989 case R_NIOS2_GNU_VTENTRY
:
4992 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
4995 /* Implement elf_backend_finish_dynamic_symbols:
4996 Finish up dynamic symbol handling. We set the contents of various
4997 dynamic sections here. */
4999 nios2_elf32_finish_dynamic_symbol (bfd
*output_bfd
,
5000 struct bfd_link_info
*info
,
5001 struct elf_link_hash_entry
*h
,
5002 Elf_Internal_Sym
*sym
)
5004 struct elf32_nios2_link_hash_table
*htab
;
5005 struct elf32_nios2_link_hash_entry
*eh
5006 = (struct elf32_nios2_link_hash_entry
*)h
;
5009 htab
= elf32_nios2_hash_table (info
);
5011 if (h
->plt
.offset
!= (bfd_vma
) -1)
5018 Elf_Internal_Rela rela
;
5020 bfd_vma got_address
;
5022 /* This symbol has an entry in the procedure linkage table. Set
5024 BFD_ASSERT (h
->dynindx
!= -1);
5025 splt
= htab
->root
.splt
;
5026 sgotplt
= htab
->root
.sgotplt
;
5027 srela
= htab
->root
.srelplt
;
5028 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
&& srela
!= NULL
);
5030 /* Emit the PLT entry. */
5031 if (bfd_link_pic (info
))
5033 nios2_elf32_install_data (splt
, nios2_so_plt_entry
, h
->plt
.offset
,
5035 plt_index
= (h
->plt
.offset
- 24) / 12;
5036 got_offset
= (plt_index
+ 3) * 4;
5037 nios2_elf32_install_imm16 (splt
, h
->plt
.offset
,
5038 hiadj(plt_index
* 4));
5039 nios2_elf32_install_imm16 (splt
, h
->plt
.offset
+ 4,
5040 (plt_index
* 4) & 0xffff);
5041 nios2_elf32_install_imm16 (splt
, h
->plt
.offset
+ 8,
5042 0xfff4 - h
->plt
.offset
);
5043 got_address
= (sgotplt
->output_section
->vma
+ sgotplt
->output_offset
5046 /* Fill in the entry in the global offset table. There are no
5047 res_n slots for a shared object PLT, instead the .got.plt entries
5048 point to the PLT entries. */
5049 bfd_put_32 (output_bfd
,
5050 splt
->output_section
->vma
+ splt
->output_offset
5051 + h
->plt
.offset
, sgotplt
->contents
+ got_offset
);
5055 plt_index
= (h
->plt
.offset
- 28 - htab
->res_n_size
) / 12;
5056 got_offset
= (plt_index
+ 3) * 4;
5058 nios2_elf32_install_data (splt
, nios2_plt_entry
, h
->plt
.offset
, 3);
5059 got_address
= (sgotplt
->output_section
->vma
+ sgotplt
->output_offset
5061 nios2_elf32_install_imm16 (splt
, h
->plt
.offset
, hiadj(got_address
));
5062 nios2_elf32_install_imm16 (splt
, h
->plt
.offset
+ 4,
5063 got_address
& 0xffff);
5065 /* Fill in the entry in the global offset table. */
5066 bfd_put_32 (output_bfd
,
5067 splt
->output_section
->vma
+ splt
->output_offset
5068 + plt_index
* 4, sgotplt
->contents
+ got_offset
);
5071 /* Fill in the entry in the .rela.plt section. */
5072 rela
.r_offset
= got_address
;
5073 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_NIOS2_JUMP_SLOT
);
5075 loc
= srela
->contents
+ plt_index
* sizeof (Elf32_External_Rela
);
5076 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
5078 if (!h
->def_regular
)
5080 /* Mark the symbol as undefined, rather than as defined in
5081 the .plt section. Leave the value alone. */
5082 sym
->st_shndx
= SHN_UNDEF
;
5083 /* If the symbol is weak, we do need to clear the value.
5084 Otherwise, the PLT entry would provide a definition for
5085 the symbol even if the symbol wasn't defined anywhere,
5086 and so the symbol would never be NULL. */
5087 if (!h
->ref_regular_nonweak
)
5092 use_plt
= (eh
->got_types_used
== CALL_USED
5093 && h
->plt
.offset
!= (bfd_vma
) -1);
5095 if (!use_plt
&& h
->got
.offset
!= (bfd_vma
) -1
5096 && (elf32_nios2_hash_entry (h
)->tls_type
& GOT_TLS_GD
) == 0
5097 && (elf32_nios2_hash_entry (h
)->tls_type
& GOT_TLS_IE
) == 0)
5101 Elf_Internal_Rela rela
;
5105 /* This symbol has an entry in the global offset table. Set it
5107 sgot
= htab
->root
.sgot
;
5108 srela
= htab
->root
.srelgot
;
5109 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
5111 offset
= (h
->got
.offset
& ~(bfd_vma
) 1);
5112 rela
.r_offset
= (sgot
->output_section
->vma
5113 + sgot
->output_offset
+ offset
);
5115 /* If this is a -Bsymbolic link, and the symbol is defined
5116 locally, we just want to emit a RELATIVE reloc. Likewise if
5117 the symbol was forced to be local because of a version file.
5118 The entry in the global offset table will already have been
5119 initialized in the relocate_section function. */
5121 if (bfd_link_pic (info
) && SYMBOL_REFERENCES_LOCAL (info
, h
))
5123 rela
.r_info
= ELF32_R_INFO (0, R_NIOS2_RELATIVE
);
5124 rela
.r_addend
= bfd_get_signed_32 (output_bfd
,
5125 (sgot
->contents
+ offset
));
5126 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ offset
);
5130 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
5131 sgot
->contents
+ offset
);
5132 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_NIOS2_GLOB_DAT
);
5136 loc
= srela
->contents
;
5137 loc
+= srela
->reloc_count
++ * sizeof (Elf32_External_Rela
);
5138 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
5141 if (use_plt
&& h
->got
.offset
!= (bfd_vma
) -1)
5143 bfd_vma offset
= (h
->got
.offset
& ~(bfd_vma
) 1);
5144 asection
*sgot
= htab
->root
.sgot
;
5145 asection
*splt
= htab
->root
.splt
;
5146 bfd_put_32 (output_bfd
, (splt
->output_section
->vma
+ splt
->output_offset
5148 sgot
->contents
+ offset
);
5154 Elf_Internal_Rela rela
;
5157 /* This symbol needs a copy reloc. Set it up. */
5158 BFD_ASSERT (h
->dynindx
!= -1
5159 && (h
->root
.type
== bfd_link_hash_defined
5160 || h
->root
.type
== bfd_link_hash_defweak
));
5162 rela
.r_offset
= (h
->root
.u
.def
.value
5163 + h
->root
.u
.def
.section
->output_section
->vma
5164 + h
->root
.u
.def
.section
->output_offset
);
5165 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_NIOS2_COPY
);
5167 if (h
->root
.u
.def
.section
== htab
->root
.sdynrelro
)
5168 s
= htab
->root
.sreldynrelro
;
5170 s
= htab
->root
.srelbss
;
5171 BFD_ASSERT (s
!= NULL
);
5172 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
5173 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
5176 /* Mark _DYNAMIC, _GLOBAL_OFFSET_TABLE_, and _gp_got as absolute. */
5177 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
5178 || h
== htab
->root
.hgot
5179 || h
== htab
->h_gp_got
)
5180 sym
->st_shndx
= SHN_ABS
;
5185 /* Implement elf_backend_finish_dynamic_sections. */
5187 nios2_elf32_finish_dynamic_sections (bfd
*output_bfd
,
5188 struct bfd_link_info
*info
)
5192 struct elf32_nios2_link_hash_table
*htab
;
5194 htab
= elf32_nios2_hash_table (info
);
5195 sgotplt
= htab
->root
.sgotplt
;
5198 if (htab
->root
.dynamic_sections_created
)
5201 Elf32_External_Dyn
*dyncon
, *dynconend
;
5203 splt
= htab
->root
.splt
;
5204 sdyn
= bfd_get_linker_section (htab
->root
.dynobj
, ".dynamic");
5205 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
&& sgotplt
!= NULL
);
5207 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
5208 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
5209 for (; dyncon
< dynconend
; dyncon
++)
5211 Elf_Internal_Dyn dyn
;
5214 bfd_elf32_swap_dyn_in (htab
->root
.dynobj
, dyncon
, &dyn
);
5222 s
= htab
->root
.sgotplt
;
5223 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5224 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5228 s
= htab
->root
.srelplt
;
5229 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5230 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5234 s
= htab
->root
.srelplt
;
5235 dyn
.d_un
.d_val
= s
->size
;
5236 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5240 s
= htab
->root
.sgotplt
;
5242 = s
->output_section
->vma
+ s
->output_offset
+ 0x7ff0;
5243 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5248 /* Fill in the first entry in the procedure linkage table. */
5251 bfd_vma got_address
= (sgotplt
->output_section
->vma
5252 + sgotplt
->output_offset
);
5253 if (bfd_link_pic (info
))
5255 bfd_vma got_pcrel
= got_address
- (splt
->output_section
->vma
5256 + splt
->output_offset
);
5257 /* Both GOT and PLT must be aligned to a 16-byte boundary
5258 for the two loads to share the %hiadj part. The 4-byte
5259 offset for nextpc is accounted for in the %lo offsets
5261 BFD_ASSERT ((got_pcrel
& 0xf) == 0);
5262 nios2_elf32_install_data (splt
, nios2_so_plt0_entry
, 0, 6);
5263 nios2_elf32_install_imm16 (splt
, 4, hiadj (got_pcrel
));
5264 nios2_elf32_install_imm16 (splt
, 12, got_pcrel
& 0xffff);
5265 nios2_elf32_install_imm16 (splt
, 16, (got_pcrel
+ 4) & 0xffff);
5269 /* Divide by 4 here, not 3 because we already corrected for the
5271 bfd_vma res_size
= (splt
->size
- 28) / 4;
5272 bfd_vma res_start
= (splt
->output_section
->vma
5273 + splt
->output_offset
);
5276 for (res_offset
= 0; res_offset
< res_size
; res_offset
+= 4)
5277 bfd_put_32 (output_bfd
,
5278 6 | ((res_size
- (res_offset
+ 4)) << 6),
5279 splt
->contents
+ res_offset
);
5281 /* The GOT must be aligned to a 16-byte boundary for the
5282 two loads to share the same %hiadj part. */
5283 BFD_ASSERT ((got_address
& 0xf) == 0);
5285 nios2_elf32_install_data (splt
, nios2_plt0_entry
, res_size
, 7);
5286 nios2_elf32_install_imm16 (splt
, res_size
, hiadj (res_start
));
5287 nios2_elf32_install_imm16 (splt
, res_size
+ 4,
5288 res_start
& 0xffff);
5289 nios2_elf32_install_imm16 (splt
, res_size
+ 12,
5290 hiadj (got_address
));
5291 nios2_elf32_install_imm16 (splt
, res_size
+ 16,
5292 (got_address
+ 4) & 0xffff);
5293 nios2_elf32_install_imm16 (splt
, res_size
+ 20,
5294 (got_address
+ 8) & 0xffff);
5299 /* Fill in the first three entries in the global offset table. */
5300 if (sgotplt
!= NULL
&& sgotplt
->size
> 0)
5303 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgotplt
->contents
);
5305 bfd_put_32 (output_bfd
,
5306 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
5308 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgotplt
->contents
+ 4);
5309 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgotplt
->contents
+ 8);
5311 if (sgotplt
->output_section
!= bfd_abs_section_ptr
)
5312 elf_section_data (sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
5318 /* Implement elf_backend_adjust_dynamic_symbol:
5319 Adjust a symbol defined by a dynamic object and referenced by a
5320 regular object. The current definition is in some section of the
5321 dynamic object, but we're not including those sections. We have to
5322 change the definition to something the rest of the link can
5325 nios2_elf32_adjust_dynamic_symbol (struct bfd_link_info
*info
,
5326 struct elf_link_hash_entry
*h
)
5328 struct elf32_nios2_link_hash_table
*htab
;
5333 htab
= elf32_nios2_hash_table (info
);
5334 dynobj
= htab
->root
.dynobj
;
5336 /* Make sure we know what is going on here. */
5337 BFD_ASSERT (dynobj
!= NULL
5342 && !h
->def_regular
)));
5344 /* If this is a function, put it in the procedure linkage table. We
5345 will fill in the contents of the procedure linkage table later,
5346 when we know the address of the .got section. */
5347 if (h
->type
== STT_FUNC
|| h
->needs_plt
)
5349 if (h
->plt
.refcount
<= 0
5350 || SYMBOL_CALLS_LOCAL (info
, h
)
5351 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
5352 && h
->root
.type
== bfd_link_hash_undefweak
))
5354 /* This case can occur if we saw a PLT reloc in an input
5355 file, but the symbol was never referred to by a dynamic
5356 object, or if all references were garbage collected. In
5357 such a case, we don't actually need to build a procedure
5358 linkage table, and we can just do a PCREL reloc instead. */
5359 h
->plt
.offset
= (bfd_vma
) -1;
5366 /* Reinitialize the plt offset now that it is not used as a reference
5368 h
->plt
.offset
= (bfd_vma
) -1;
5370 /* If this is a weak symbol, and there is a real definition, the
5371 processor independent code will have arranged for us to see the
5372 real definition first, and we can just use the same value. */
5373 if (h
->is_weakalias
)
5375 struct elf_link_hash_entry
*def
= weakdef (h
);
5376 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
5377 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
5378 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
5382 /* If there are no non-GOT references, we do not need a copy
5384 if (!h
->non_got_ref
)
5387 /* This is a reference to a symbol defined by a dynamic object which
5389 If we are creating a shared library, we must presume that the
5390 only references to the symbol are via the global offset table.
5391 For such cases we need not do anything here; the relocations will
5392 be handled correctly by relocate_section. */
5393 if (bfd_link_pic (info
))
5398 _bfd_error_handler (_("dynamic variable `%s' is zero size"),
5399 h
->root
.root
.string
);
5403 /* We must allocate the symbol in our .dynbss section, which will
5404 become part of the .bss section of the executable. There will be
5405 an entry for this symbol in the .dynsym section. The dynamic
5406 object will contain position independent code, so all references
5407 from the dynamic object to this symbol will go through the global
5408 offset table. The dynamic linker will use the .dynsym entry to
5409 determine the address it must put in the global offset table, so
5410 both the dynamic object and the regular object will refer to the
5411 same memory location for the variable. */
5412 /* We must generate a R_NIOS2_COPY reloc to tell the dynamic linker to
5413 copy the initial value out of the dynamic object and into the
5414 runtime process image. We need to remember the offset into the
5415 .rela.bss section we are going to use. */
5416 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
5418 s
= htab
->root
.sdynrelro
;
5419 srel
= htab
->root
.sreldynrelro
;
5423 s
= htab
->root
.sdynbss
;
5424 srel
= htab
->root
.srelbss
;
5426 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
5428 srel
->size
+= sizeof (Elf32_External_Rela
);
5432 align2
= bfd_log2 (h
->size
);
5433 if (align2
> h
->root
.u
.def
.section
->alignment_power
)
5434 align2
= h
->root
.u
.def
.section
->alignment_power
;
5437 s
->size
= BFD_ALIGN (s
->size
, (bfd_size_type
)1 << align2
);
5438 if (align2
> bfd_section_alignment (s
)
5439 && !bfd_set_section_alignment (s
, align2
))
5442 /* Define the symbol as being at this point in the section. */
5443 h
->root
.u
.def
.section
= s
;
5444 h
->root
.u
.def
.value
= s
->size
;
5446 /* Increment the section size to make room for the symbol. */
5452 /* Worker function for nios2_elf32_size_dynamic_sections. */
5454 adjust_dynrelocs (struct elf_link_hash_entry
*h
, PTR inf
)
5456 struct bfd_link_info
*info
;
5457 struct elf32_nios2_link_hash_table
*htab
;
5459 if (h
->root
.type
== bfd_link_hash_indirect
)
5462 if (h
->root
.type
== bfd_link_hash_warning
)
5463 /* When warning symbols are created, they **replace** the "real"
5464 entry in the hash table, thus we never get to see the real
5465 symbol in a hash traversal. So look at it now. */
5466 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5468 info
= (struct bfd_link_info
*) inf
;
5469 htab
= elf32_nios2_hash_table (info
);
5471 if (h
->plt
.offset
!= (bfd_vma
)-1)
5472 h
->plt
.offset
+= htab
->res_n_size
;
5473 if (htab
->root
.splt
== h
->root
.u
.def
.section
)
5474 h
->root
.u
.def
.value
+= htab
->res_n_size
;
5479 /* Another worker function for nios2_elf32_size_dynamic_sections.
5480 Allocate space in .plt, .got and associated reloc sections for
5483 allocate_dynrelocs (struct elf_link_hash_entry
*h
, PTR inf
)
5485 struct bfd_link_info
*info
;
5486 struct elf32_nios2_link_hash_table
*htab
;
5487 struct elf32_nios2_link_hash_entry
*eh
;
5488 struct elf_dyn_relocs
*p
;
5491 if (h
->root
.type
== bfd_link_hash_indirect
)
5494 if (h
->root
.type
== bfd_link_hash_warning
)
5495 /* When warning symbols are created, they **replace** the "real"
5496 entry in the hash table, thus we never get to see the real
5497 symbol in a hash traversal. So look at it now. */
5498 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5500 info
= (struct bfd_link_info
*) inf
;
5501 htab
= elf32_nios2_hash_table (info
);
5503 if (htab
->root
.dynamic_sections_created
5504 && h
->plt
.refcount
> 0)
5506 /* Make sure this symbol is output as a dynamic symbol.
5507 Undefined weak syms won't yet be marked as dynamic. */
5508 if (h
->dynindx
== -1
5510 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
5513 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info
), h
))
5515 asection
*s
= htab
->root
.splt
;
5517 /* Allocate room for the header. */
5520 if (bfd_link_pic (info
))
5526 h
->plt
.offset
= s
->size
;
5528 /* If this symbol is not defined in a regular file, and we are
5529 not generating a shared library, then set the symbol to this
5530 location in the .plt. This is required to make function
5531 pointers compare as equal between the normal executable and
5532 the shared library. */
5533 if (! bfd_link_pic (info
)
5536 h
->root
.u
.def
.section
= s
;
5537 h
->root
.u
.def
.value
= h
->plt
.offset
;
5540 /* Make room for this entry. */
5543 /* We also need to make an entry in the .rela.plt section. */
5544 htab
->root
.srelplt
->size
+= sizeof (Elf32_External_Rela
);
5546 /* And the .got.plt section. */
5547 htab
->root
.sgotplt
->size
+= 4;
5551 h
->plt
.offset
= (bfd_vma
) -1;
5557 h
->plt
.offset
= (bfd_vma
) -1;
5561 eh
= (struct elf32_nios2_link_hash_entry
*) h
;
5562 use_plt
= (eh
->got_types_used
== CALL_USED
5563 && h
->plt
.offset
!= (bfd_vma
) -1);
5565 if (h
->got
.refcount
> 0)
5569 int tls_type
= eh
->tls_type
;
5572 /* Make sure this symbol is output as a dynamic symbol.
5573 Undefined weak syms won't yet be marked as dynamic. */
5574 if (h
->dynindx
== -1
5576 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
5579 s
= htab
->root
.sgot
;
5580 h
->got
.offset
= s
->size
;
5582 if (tls_type
== GOT_UNKNOWN
)
5585 if (tls_type
== GOT_NORMAL
)
5586 /* Non-TLS symbols need one GOT slot. */
5590 if (tls_type
& GOT_TLS_GD
)
5591 /* R_NIOS2_TLS_GD16 needs 2 consecutive GOT slots. */
5593 if (tls_type
& GOT_TLS_IE
)
5594 /* R_NIOS2_TLS_IE16 needs one GOT slot. */
5598 dyn
= htab
->root
.dynamic_sections_created
;
5601 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
5602 && (!bfd_link_pic (info
)
5603 || !SYMBOL_REFERENCES_LOCAL (info
, h
)))
5606 if (tls_type
!= GOT_NORMAL
5607 && (bfd_link_pic (info
) || indx
!= 0)
5608 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
5609 || h
->root
.type
!= bfd_link_hash_undefweak
))
5611 if (tls_type
& GOT_TLS_IE
)
5612 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
5614 if (tls_type
& GOT_TLS_GD
)
5615 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
5617 if ((tls_type
& GOT_TLS_GD
) && indx
!= 0)
5618 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
5620 else if ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
5621 || h
->root
.type
!= bfd_link_hash_undefweak
)
5623 && (bfd_link_pic (info
)
5624 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
5625 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
5628 h
->got
.offset
= (bfd_vma
) -1;
5630 if (h
->dyn_relocs
== NULL
)
5633 /* In the shared -Bsymbolic case, discard space allocated for
5634 dynamic pc-relative relocs against symbols which turn out to be
5635 defined in regular objects. For the normal shared case, discard
5636 space for pc-relative relocs that have become local due to symbol
5637 visibility changes. */
5639 if (bfd_link_pic (info
))
5642 && (h
->forced_local
|| SYMBOLIC_BIND (info
, h
)))
5644 struct elf_dyn_relocs
**pp
;
5646 for (pp
= &h
->dyn_relocs
; (p
= *pp
) != NULL
; )
5648 p
->count
-= p
->pc_count
;
5657 /* Also discard relocs on undefined weak syms with non-default
5659 if (h
->dyn_relocs
!= NULL
5660 && h
->root
.type
== bfd_link_hash_undefweak
)
5662 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
5663 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
5664 h
->dyn_relocs
= NULL
;
5666 /* Make sure undefined weak symbols are output as a dynamic
5668 else if (h
->dynindx
== -1
5670 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
5676 /* For the non-shared case, discard space for relocs against
5677 symbols which turn out to need copy relocs or are not
5681 && ((h
->def_dynamic
&& !h
->def_regular
)
5682 || (htab
->root
.dynamic_sections_created
5683 && (h
->root
.type
== bfd_link_hash_undefweak
5684 || h
->root
.type
== bfd_link_hash_undefined
))))
5686 /* Make sure this symbol is output as a dynamic symbol.
5687 Undefined weak syms won't yet be marked as dynamic. */
5688 if (h
->dynindx
== -1
5690 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
5693 /* If that succeeded, we know we'll be keeping all the
5695 if (h
->dynindx
!= -1)
5699 h
->dyn_relocs
= NULL
;
5704 /* Finally, allocate space. */
5705 for (p
= h
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
5707 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
5708 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
5714 /* Implement elf_backend_size_dynamic_sections:
5715 Set the sizes of the dynamic sections. */
5717 nios2_elf32_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
5718 struct bfd_link_info
*info
)
5724 struct elf32_nios2_link_hash_table
*htab
;
5726 htab
= elf32_nios2_hash_table (info
);
5727 dynobj
= htab
->root
.dynobj
;
5728 BFD_ASSERT (dynobj
!= NULL
);
5730 htab
->res_n_size
= 0;
5731 if (htab
->root
.dynamic_sections_created
)
5733 /* Set the contents of the .interp section to the interpreter. */
5734 if (bfd_link_executable (info
) && !info
->nointerp
)
5736 s
= bfd_get_linker_section (dynobj
, ".interp");
5737 BFD_ASSERT (s
!= NULL
);
5738 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
5739 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
5744 /* We may have created entries in the .rela.got section.
5745 However, if we are not creating the dynamic sections, we will
5746 not actually use these entries. Reset the size of .rela.got,
5747 which will cause it to get stripped from the output file
5749 s
= htab
->root
.srelgot
;
5754 /* Set up .got offsets for local syms, and space for local dynamic
5756 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
5758 bfd_signed_vma
*local_got
;
5759 bfd_signed_vma
*end_local_got
;
5760 char *local_tls_type
;
5761 bfd_size_type locsymcount
;
5762 Elf_Internal_Shdr
*symtab_hdr
;
5765 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
5768 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
5770 struct elf_dyn_relocs
*p
;
5772 for (p
= elf_section_data (s
)->local_dynrel
; p
!= NULL
; p
= p
->next
)
5774 if (!bfd_is_abs_section (p
->sec
)
5775 && bfd_is_abs_section (p
->sec
->output_section
))
5777 /* Input section has been discarded, either because
5778 it is a copy of a linkonce section or due to
5779 linker script /DISCARD/, so we'll be discarding
5782 else if (p
->count
!= 0)
5784 srel
= elf_section_data (p
->sec
)->sreloc
;
5785 srel
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
5786 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
5787 info
->flags
|= DF_TEXTREL
;
5792 local_got
= elf_local_got_refcounts (ibfd
);
5796 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
5797 locsymcount
= symtab_hdr
->sh_info
;
5798 end_local_got
= local_got
+ locsymcount
;
5799 local_tls_type
= elf32_nios2_local_got_tls_type (ibfd
);
5800 s
= htab
->root
.sgot
;
5801 srel
= htab
->root
.srelgot
;
5802 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
5806 *local_got
= s
->size
;
5807 if (*local_tls_type
& GOT_TLS_GD
)
5808 /* TLS_GD relocs need an 8-byte structure in the GOT. */
5810 if (*local_tls_type
& GOT_TLS_IE
)
5812 if (*local_tls_type
== GOT_NORMAL
)
5815 if (bfd_link_pic (info
) || *local_tls_type
== GOT_TLS_GD
)
5816 srel
->size
+= sizeof (Elf32_External_Rela
);
5819 *local_got
= (bfd_vma
) -1;
5823 if (htab
->tls_ldm_got
.refcount
> 0)
5825 /* Allocate two GOT entries and one dynamic relocation (if necessary)
5826 for R_NIOS2_TLS_LDM16 relocations. */
5827 htab
->tls_ldm_got
.offset
= htab
->root
.sgot
->size
;
5828 htab
->root
.sgot
->size
+= 8;
5829 if (bfd_link_pic (info
))
5830 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
5833 htab
->tls_ldm_got
.offset
= -1;
5835 /* Allocate global sym .plt and .got entries, and space for global
5836 sym dynamic relocs. */
5837 elf_link_hash_traverse (& htab
->root
, allocate_dynrelocs
, info
);
5839 if (htab
->root
.dynamic_sections_created
)
5841 /* If the .got section is more than 0x8000 bytes, we add
5842 0x8000 to the value of _gp_got, so that 16-bit relocations
5843 have a greater chance of working. */
5844 if (htab
->root
.sgot
->size
>= 0x8000
5845 && htab
->h_gp_got
->root
.u
.def
.value
== 0)
5846 htab
->h_gp_got
->root
.u
.def
.value
= 0x8000;
5849 /* The check_relocs and adjust_dynamic_symbol entry points have
5850 determined the sizes of the various dynamic sections. Allocate
5853 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
5857 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
5860 /* It's OK to base decisions on the section name, because none
5861 of the dynobj section names depend upon the input files. */
5862 name
= bfd_section_name (s
);
5864 if (CONST_STRNEQ (name
, ".rela"))
5868 if (s
!= htab
->root
.srelplt
)
5871 /* We use the reloc_count field as a counter if we need
5872 to copy relocs into the output file. */
5876 else if (s
== htab
->root
.splt
)
5878 /* Correct for the number of res_N branches. */
5879 if (s
->size
!= 0 && !bfd_link_pic (info
))
5881 htab
->res_n_size
= (s
->size
- 28) / 3;
5882 s
->size
+= htab
->res_n_size
;
5885 else if (s
!= htab
->sbss
5886 && s
!= htab
->root
.sgot
5887 && s
!= htab
->root
.sgotplt
5888 && s
!= htab
->root
.sdynbss
5889 && s
!= htab
->root
.sdynrelro
)
5890 /* It's not one of our sections, so don't allocate space. */
5895 s
->flags
|= SEC_EXCLUDE
;
5899 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
5902 /* Allocate memory for the section contents. */
5903 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
5904 if (s
->contents
== NULL
)
5908 /* Adjust dynamic symbols that point to the plt to account for the
5909 now-known number of resN slots. */
5910 if (htab
->res_n_size
)
5911 elf_link_hash_traverse (& htab
->root
, adjust_dynrelocs
, info
);
5913 if (htab
->root
.dynamic_sections_created
)
5915 /* Add some entries to the .dynamic section. We fill in the
5916 values later, in elf_nios2_finish_dynamic_sections, but we
5917 must add the entries now so that we get the correct size for
5918 the .dynamic section. The DT_DEBUG entry is filled in by the
5919 dynamic linker and used by the debugger. */
5920 #define add_dynamic_entry(TAG, VAL) \
5921 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
5923 if (!bfd_link_pic (info
) && !add_dynamic_entry (DT_DEBUG
, 0))
5926 if (htab
->root
.sgotplt
->size
!= 0
5927 && !add_dynamic_entry (DT_PLTGOT
, 0))
5930 if (htab
->root
.splt
->size
!= 0
5931 && (!add_dynamic_entry (DT_PLTRELSZ
, 0)
5932 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
5933 || !add_dynamic_entry (DT_JMPREL
, 0)))
5937 && (!add_dynamic_entry (DT_RELA
, 0)
5938 || !add_dynamic_entry (DT_RELASZ
, 0)
5939 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
))))
5942 if (!bfd_link_pic (info
) && !add_dynamic_entry (DT_NIOS2_GP
, 0))
5945 if ((info
->flags
& DF_TEXTREL
) != 0
5946 && !add_dynamic_entry (DT_TEXTREL
, 0))
5949 #undef add_dynamic_entry
5954 /* Free the derived linker hash table. */
5956 nios2_elf32_link_hash_table_free (bfd
*obfd
)
5958 struct elf32_nios2_link_hash_table
*htab
5959 = (struct elf32_nios2_link_hash_table
*) obfd
->link
.hash
;
5961 bfd_hash_table_free (&htab
->bstab
);
5962 _bfd_elf_link_hash_table_free (obfd
);
5965 /* Implement bfd_elf32_bfd_link_hash_table_create. */
5966 static struct bfd_link_hash_table
*
5967 nios2_elf32_link_hash_table_create (bfd
*abfd
)
5969 struct elf32_nios2_link_hash_table
*ret
;
5970 size_t amt
= sizeof (struct elf32_nios2_link_hash_table
);
5972 ret
= bfd_zmalloc (amt
);
5976 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
5979 elf32_nios2_link_hash_entry
),
5986 /* Init the stub hash table too. */
5987 if (!bfd_hash_table_init (&ret
->bstab
, stub_hash_newfunc
,
5988 sizeof (struct elf32_nios2_stub_hash_entry
)))
5990 _bfd_elf_link_hash_table_free (abfd
);
5993 ret
->root
.root
.hash_table_free
= nios2_elf32_link_hash_table_free
;
5995 return &ret
->root
.root
;
5998 /* Implement elf_backend_reloc_type_class. */
5999 static enum elf_reloc_type_class
6000 nios2_elf32_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6001 const asection
*rel_sec ATTRIBUTE_UNUSED
,
6002 const Elf_Internal_Rela
*rela
)
6004 switch ((int) ELF32_R_TYPE (rela
->r_info
))
6006 case R_NIOS2_RELATIVE
:
6007 return reloc_class_relative
;
6008 case R_NIOS2_JUMP_SLOT
:
6009 return reloc_class_plt
;
6011 return reloc_class_copy
;
6013 return reloc_class_normal
;
6017 /* Return 1 if target is one of ours. */
6019 is_nios2_elf_target (const struct bfd_target
*targ
)
6021 return (targ
== &nios2_elf32_le_vec
6022 || targ
== &nios2_elf32_be_vec
);
6025 /* Implement elf_backend_add_symbol_hook.
6026 This hook is called by the linker when adding symbols from an object
6027 file. We use it to put .comm items in .sbss, and not .bss. */
6029 nios2_elf_add_symbol_hook (bfd
*abfd
,
6030 struct bfd_link_info
*info
,
6031 Elf_Internal_Sym
*sym
,
6032 const char **namep ATTRIBUTE_UNUSED
,
6033 flagword
*flagsp ATTRIBUTE_UNUSED
,
6037 if (sym
->st_shndx
== SHN_COMMON
6038 && !bfd_link_relocatable (info
)
6039 && sym
->st_size
<= elf_gp_size (abfd
)
6040 && is_nios2_elf_target (info
->output_bfd
->xvec
))
6042 /* Common symbols less than or equal to -G nn bytes are automatically
6044 struct elf32_nios2_link_hash_table
*htab
;
6046 htab
= elf32_nios2_hash_table (info
);
6047 if (htab
->sbss
== NULL
)
6049 flagword flags
= SEC_IS_COMMON
| SEC_LINKER_CREATED
;
6051 if (htab
->root
.dynobj
== NULL
)
6052 htab
->root
.dynobj
= abfd
;
6054 htab
->sbss
= bfd_make_section_anyway_with_flags (htab
->root
.dynobj
,
6056 if (htab
->sbss
== NULL
)
6061 *valp
= sym
->st_size
;
6067 /* Implement elf_backend_can_make_relative_eh_frame:
6068 Decide whether to attempt to turn absptr or lsda encodings in
6069 shared libraries into pcrel within the given input section. */
6071 nios2_elf32_can_make_relative_eh_frame (bfd
*input_bfd ATTRIBUTE_UNUSED
,
6072 struct bfd_link_info
*info
6074 asection
*eh_frame_section
6077 /* We can't use PC-relative encodings in the .eh_frame section. */
6081 /* Implement elf_backend_special_sections. */
6082 const struct bfd_elf_special_section elf32_nios2_special_sections
[] =
6084 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS
,
6085 SHF_ALLOC
+ SHF_WRITE
+ SHF_NIOS2_GPREL
},
6086 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS
,
6087 SHF_ALLOC
+ SHF_WRITE
+ SHF_NIOS2_GPREL
},
6088 { NULL
, 0, 0, 0, 0 }
6091 #define ELF_ARCH bfd_arch_nios2
6092 #define ELF_TARGET_ID NIOS2_ELF_DATA
6093 #define ELF_MACHINE_CODE EM_ALTERA_NIOS2
6095 /* The Nios II MMU uses a 4K page size. */
6097 #define ELF_MAXPAGESIZE 0x1000
6099 #define bfd_elf32_bfd_link_hash_table_create \
6100 nios2_elf32_link_hash_table_create
6102 #define bfd_elf32_bfd_merge_private_bfd_data \
6103 nios2_elf32_merge_private_bfd_data
6105 /* Relocation table lookup macros. */
6107 #define bfd_elf32_bfd_reloc_type_lookup nios2_elf32_bfd_reloc_type_lookup
6108 #define bfd_elf32_bfd_reloc_name_lookup nios2_elf32_bfd_reloc_name_lookup
6110 /* JUMP_TABLE_LINK macros. */
6112 /* elf_info_to_howto (using RELA relocations). */
6114 #define elf_info_to_howto nios2_elf32_info_to_howto
6116 /* elf backend functions. */
6118 #define elf_backend_can_gc_sections 1
6119 #define elf_backend_can_refcount 1
6120 #define elf_backend_plt_readonly 1
6121 #define elf_backend_want_got_plt 1
6122 #define elf_backend_want_dynrelro 1
6123 #define elf_backend_rela_normal 1
6124 #define elf_backend_dtrel_excludes_plt 1
6126 #define elf_backend_relocate_section nios2_elf32_relocate_section
6127 #define elf_backend_section_flags nios2_elf32_section_flags
6128 #define elf_backend_fake_sections nios2_elf32_fake_sections
6129 #define elf_backend_check_relocs nios2_elf32_check_relocs
6131 #define elf_backend_gc_mark_hook nios2_elf32_gc_mark_hook
6132 #define elf_backend_create_dynamic_sections \
6133 nios2_elf32_create_dynamic_sections
6134 #define elf_backend_finish_dynamic_symbol nios2_elf32_finish_dynamic_symbol
6135 #define elf_backend_finish_dynamic_sections \
6136 nios2_elf32_finish_dynamic_sections
6137 #define elf_backend_adjust_dynamic_symbol nios2_elf32_adjust_dynamic_symbol
6138 #define elf_backend_reloc_type_class nios2_elf32_reloc_type_class
6139 #define elf_backend_size_dynamic_sections nios2_elf32_size_dynamic_sections
6140 #define elf_backend_add_symbol_hook nios2_elf_add_symbol_hook
6141 #define elf_backend_copy_indirect_symbol nios2_elf32_copy_indirect_symbol
6142 #define elf_backend_object_p nios2_elf32_object_p
6144 #define elf_backend_grok_prstatus nios2_grok_prstatus
6145 #define elf_backend_grok_psinfo nios2_grok_psinfo
6147 #undef elf_backend_can_make_relative_eh_frame
6148 #define elf_backend_can_make_relative_eh_frame \
6149 nios2_elf32_can_make_relative_eh_frame
6151 #define elf_backend_special_sections elf32_nios2_special_sections
6153 #define TARGET_LITTLE_SYM nios2_elf32_le_vec
6154 #define TARGET_LITTLE_NAME "elf32-littlenios2"
6155 #define TARGET_BIG_SYM nios2_elf32_be_vec
6156 #define TARGET_BIG_NAME "elf32-bignios2"
6158 #define elf_backend_got_header_size 12
6159 #define elf_backend_default_execstack 0
6161 #include "elf32-target.h"