| blob | 6b29d8b97f1bc34585c084500c592ee4f9b2b4e7 |
1 /* 32-bit ELF support for Nios II.
2 Copyright (C) 2012-2015 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. */
35 /* Use RELA relocations. */
36 #ifndef USE_RELA
37 #define USE_RELA
38 #endif
40 #ifdef USE_REL
41 #undef USE_REL
42 #endif
44 /* Forward declarations. */
45 static bfd_reloc_status_type nios2_elf32_ignore_reloc
47 static bfd_reloc_status_type nios2_elf32_hi16_relocate
49 static bfd_reloc_status_type nios2_elf32_lo16_relocate
51 static bfd_reloc_status_type nios2_elf32_hiadj16_relocate
53 static bfd_reloc_status_type nios2_elf32_pcrel_lo16_relocate
55 static bfd_reloc_status_type nios2_elf32_pcrel_hiadj16_relocate
57 static bfd_reloc_status_type nios2_elf32_pcrel16_relocate
59 static bfd_reloc_status_type nios2_elf32_call26_relocate
61 static bfd_reloc_status_type nios2_elf32_gprel_relocate
63 static bfd_reloc_status_type nios2_elf32_ujmp_relocate
65 static bfd_reloc_status_type nios2_elf32_cjmp_relocate
67 static bfd_reloc_status_type nios2_elf32_callr_relocate
70 /* Target vector. */
74 /* Offset of tp and dtp pointers from start of TLS block. */
75 #define TP_OFFSET 0x7000
76 #define DTP_OFFSET 0x8000
78 /* The relocation tables used for SHT_REL sections. There are separate
79 tables for R1 and R2 encodings. */
81 /* No relocation. */
96 /* 16-bit signed immediate relocation. */
111 /* 16-bit unsigned immediate relocation. */
158 FALSE,
160 complain_overflow_bitfield,
161 bfd_elf_generic_reloc,
163 FALSE,
166 FALSE),
172 FALSE,
174 complain_overflow_bitfield,
175 bfd_elf_generic_reloc,
177 FALSE,
180 FALSE),
186 FALSE,
188 complain_overflow_bitfield,
189 bfd_elf_generic_reloc,
191 FALSE,
194 FALSE),
200 FALSE,
202 complain_overflow_bitfield,
203 bfd_elf_generic_reloc,
205 FALSE,
208 FALSE),
214 FALSE,
216 complain_overflow_dont,
217 nios2_elf32_hi16_relocate,
219 FALSE,
222 FALSE),
228 FALSE,
230 complain_overflow_dont,
231 nios2_elf32_lo16_relocate,
233 FALSE,
236 FALSE),
242 FALSE,
244 complain_overflow_dont,
245 nios2_elf32_hiadj16_relocate,
247 FALSE,
250 FALSE),
256 FALSE,
258 complain_overflow_dont,
259 bfd_elf_generic_reloc,
261 FALSE,
264 FALSE),
270 FALSE,
272 complain_overflow_bitfield,
273 bfd_elf_generic_reloc,
275 FALSE,
278 FALSE),
284 FALSE,
286 complain_overflow_bitfield,
287 bfd_elf_generic_reloc,
289 FALSE,
292 FALSE),
298 FALSE,
300 complain_overflow_dont,
301 nios2_elf32_gprel_relocate,
303 FALSE,
306 FALSE),
312 FALSE,
314 complain_overflow_dont,
315 NULL,
317 FALSE,
320 FALSE),
326 FALSE,
328 complain_overflow_dont,
329 _bfd_elf_rel_vtable_reloc_fn,
331 FALSE,
334 FALSE),
340 FALSE,
342 complain_overflow_dont,
343 nios2_elf32_ujmp_relocate,
345 FALSE,
348 FALSE),
354 FALSE,
356 complain_overflow_dont,
357 nios2_elf32_cjmp_relocate,
359 FALSE,
362 FALSE),
368 FALSE,
370 complain_overflow_dont,
371 nios2_elf32_callr_relocate,
373 FALSE,
376 FALSE),
382 FALSE,
384 complain_overflow_dont,
385 nios2_elf32_ignore_reloc,
387 FALSE,
390 TRUE),
397 FALSE,
399 complain_overflow_bitfield,
400 bfd_elf_generic_reloc,
402 FALSE,
405 FALSE),
411 FALSE,
413 complain_overflow_bitfield,
414 bfd_elf_generic_reloc,
416 FALSE,
419 FALSE),
425 FALSE,
427 complain_overflow_dont,
428 bfd_elf_generic_reloc,
430 FALSE,
433 FALSE),
439 FALSE,
441 complain_overflow_dont,
442 bfd_elf_generic_reloc,
444 FALSE,
447 FALSE),
453 TRUE,
455 complain_overflow_dont,
456 nios2_elf32_pcrel_lo16_relocate,
458 FALSE,
461 TRUE),
468 PC ourselves before the HIADJ. */
470 complain_overflow_dont,
471 nios2_elf32_pcrel_hiadj16_relocate,
473 FALSE,
476 TRUE),
482 FALSE,
484 complain_overflow_bitfield,
485 bfd_elf_generic_reloc,
487 FALSE,
490 FALSE),
496 FALSE,
498 complain_overflow_bitfield,
499 bfd_elf_generic_reloc,
501 FALSE,
504 FALSE),
510 FALSE,
512 complain_overflow_bitfield,
513 bfd_elf_generic_reloc,
515 FALSE,
518 FALSE),
524 FALSE,
526 complain_overflow_bitfield,
527 bfd_elf_generic_reloc,
529 FALSE,
532 FALSE),
538 FALSE,
540 complain_overflow_bitfield,
541 bfd_elf_generic_reloc,
543 FALSE,
546 FALSE),
552 FALSE,
554 complain_overflow_dont,
555 bfd_elf_generic_reloc,
557 FALSE,
560 FALSE),
566 FALSE,
568 complain_overflow_dont,
569 bfd_elf_generic_reloc,
571 FALSE,
574 FALSE),
580 FALSE,
582 complain_overflow_dont,
583 bfd_elf_generic_reloc,
585 FALSE,
588 FALSE),
594 FALSE,
596 complain_overflow_dont,
597 bfd_elf_generic_reloc,
599 FALSE,
602 FALSE),
608 FALSE,
610 complain_overflow_dont,
611 bfd_elf_generic_reloc,
613 FALSE,
616 FALSE),
622 FALSE,
624 complain_overflow_dont,
625 bfd_elf_generic_reloc,
627 FALSE,
630 FALSE),
636 FALSE,
638 complain_overflow_dont,
639 bfd_elf_generic_reloc,
641 FALSE,
644 FALSE),
650 FALSE,
652 complain_overflow_dont,
653 bfd_elf_generic_reloc,
655 FALSE,
658 FALSE),
678 FALSE,
680 complain_overflow_dont,
681 bfd_elf_generic_reloc,
683 FALSE,
686 FALSE),
692 FALSE,
694 complain_overflow_dont,
695 bfd_elf_generic_reloc,
697 FALSE,
700 FALSE),
706 FALSE,
708 complain_overflow_dont,
709 bfd_elf_generic_reloc,
711 FALSE,
714 FALSE),
720 FALSE,
722 complain_overflow_dont,
723 bfd_elf_generic_reloc,
725 FALSE,
728 FALSE),
730 /* Add other relocations here. */
731 };
734 /* No relocation. */
749 /* 16-bit signed immediate relocation. */
764 /* 16-bit unsigned immediate relocation. */
811 FALSE,
813 complain_overflow_bitfield,
814 bfd_elf_generic_reloc,
816 FALSE,
819 FALSE),
825 FALSE,
827 complain_overflow_bitfield,
828 bfd_elf_generic_reloc,
830 FALSE,
833 FALSE),
839 FALSE,
841 complain_overflow_bitfield,
842 bfd_elf_generic_reloc,
844 FALSE,
847 FALSE),
853 FALSE,
855 complain_overflow_bitfield,
856 bfd_elf_generic_reloc,
858 FALSE,
861 FALSE),
867 FALSE,
869 complain_overflow_dont,
870 nios2_elf32_hi16_relocate,
872 FALSE,
875 FALSE),
881 FALSE,
883 complain_overflow_dont,
884 nios2_elf32_lo16_relocate,
886 FALSE,
889 FALSE),
895 FALSE,
897 complain_overflow_dont,
898 nios2_elf32_hiadj16_relocate,
900 FALSE,
903 FALSE),
909 FALSE,
911 complain_overflow_dont,
912 bfd_elf_generic_reloc,
914 FALSE,
917 FALSE),
923 FALSE,
925 complain_overflow_bitfield,
926 bfd_elf_generic_reloc,
928 FALSE,
931 FALSE),
937 FALSE,
939 complain_overflow_bitfield,
940 bfd_elf_generic_reloc,
942 FALSE,
945 FALSE),
951 FALSE,
953 complain_overflow_dont,
954 nios2_elf32_gprel_relocate,
956 FALSE,
959 FALSE),
965 FALSE,
967 complain_overflow_dont,
968 NULL,
970 FALSE,
973 FALSE),
979 FALSE,
981 complain_overflow_dont,
982 _bfd_elf_rel_vtable_reloc_fn,
984 FALSE,
987 FALSE),
993 FALSE,
995 complain_overflow_dont,
996 nios2_elf32_ujmp_relocate,
998 FALSE,
1001 FALSE),
1007 FALSE,
1009 complain_overflow_dont,
1010 nios2_elf32_cjmp_relocate,
1012 FALSE,
1015 FALSE),
1021 FALSE,
1023 complain_overflow_dont,
1024 nios2_elf32_callr_relocate,
1026 FALSE,
1029 FALSE),
1035 FALSE,
1037 complain_overflow_dont,
1038 nios2_elf32_ignore_reloc,
1040 FALSE,
1043 TRUE),
1049 FALSE,
1051 complain_overflow_bitfield,
1052 bfd_elf_generic_reloc,
1054 FALSE,
1057 FALSE),
1063 FALSE,
1065 complain_overflow_bitfield,
1066 bfd_elf_generic_reloc,
1068 FALSE,
1071 FALSE),
1077 FALSE,
1079 complain_overflow_dont,
1080 bfd_elf_generic_reloc,
1082 FALSE,
1085 FALSE),
1091 FALSE,
1093 complain_overflow_dont,
1094 bfd_elf_generic_reloc,
1096 FALSE,
1099 FALSE),
1105 TRUE,
1107 complain_overflow_dont,
1108 nios2_elf32_pcrel_lo16_relocate,
1110 FALSE,
1113 TRUE),
1120 PC ourselves before the HIADJ. */
1122 complain_overflow_dont,
1123 nios2_elf32_pcrel_hiadj16_relocate,
1125 FALSE,
1128 TRUE),
1134 FALSE,
1136 complain_overflow_bitfield,
1137 bfd_elf_generic_reloc,
1139 FALSE,
1142 FALSE),
1148 FALSE,
1150 complain_overflow_bitfield,
1151 bfd_elf_generic_reloc,
1153 FALSE,
1156 FALSE),
1162 FALSE,
1164 complain_overflow_bitfield,
1165 bfd_elf_generic_reloc,
1167 FALSE,
1170 FALSE),
1176 FALSE,
1178 complain_overflow_bitfield,
1179 bfd_elf_generic_reloc,
1181 FALSE,
1184 FALSE),
1190 FALSE,
1192 complain_overflow_bitfield,
1193 bfd_elf_generic_reloc,
1195 FALSE,
1198 FALSE),
1204 FALSE,
1206 complain_overflow_dont,
1207 bfd_elf_generic_reloc,
1209 FALSE,
1212 FALSE),
1218 FALSE,
1220 complain_overflow_dont,
1221 bfd_elf_generic_reloc,
1223 FALSE,
1226 FALSE),
1232 FALSE,
1234 complain_overflow_dont,
1235 bfd_elf_generic_reloc,
1237 FALSE,
1240 FALSE),
1246 FALSE,
1248 complain_overflow_dont,
1249 bfd_elf_generic_reloc,
1251 FALSE,
1254 FALSE),
1260 FALSE,
1262 complain_overflow_dont,
1263 bfd_elf_generic_reloc,
1265 FALSE,
1268 FALSE),
1274 FALSE,
1276 complain_overflow_dont,
1277 bfd_elf_generic_reloc,
1279 FALSE,
1282 FALSE),
1288 FALSE,
1290 complain_overflow_dont,
1291 bfd_elf_generic_reloc,
1293 FALSE,
1296 FALSE),
1302 FALSE,
1304 complain_overflow_dont,
1305 bfd_elf_generic_reloc,
1307 FALSE,
1310 FALSE),
1330 FALSE,
1332 complain_overflow_dont,
1333 bfd_elf_generic_reloc,
1335 FALSE,
1338 FALSE),
1344 FALSE,
1346 complain_overflow_dont,
1347 bfd_elf_generic_reloc,
1349 FALSE,
1352 FALSE),
1358 FALSE,
1360 complain_overflow_dont,
1361 bfd_elf_generic_reloc,
1363 FALSE,
1366 FALSE),
1372 FALSE,
1374 complain_overflow_dont,
1375 bfd_elf_generic_reloc,
1377 FALSE,
1380 FALSE),
1386 FALSE,
1388 complain_overflow_signed,
1389 bfd_elf_generic_reloc,
1391 FALSE,
1394 FALSE),
1400 TRUE,
1402 complain_overflow_signed,
1405 FALSE,
1408 TRUE),
1414 TRUE,
1416 complain_overflow_signed,
1419 FALSE,
1422 TRUE),
1428 FALSE,
1430 complain_overflow_unsigned,
1431 bfd_elf_generic_reloc,
1433 FALSE,
1436 FALSE),
1442 FALSE,
1444 complain_overflow_unsigned,
1445 bfd_elf_generic_reloc,
1447 FALSE,
1450 FALSE),
1456 FALSE,
1458 complain_overflow_unsigned,
1459 bfd_elf_generic_reloc,
1461 FALSE,
1464 FALSE),
1470 FALSE,
1472 complain_overflow_unsigned,
1473 bfd_elf_generic_reloc,
1475 FALSE,
1478 FALSE),
1484 FALSE,
1486 complain_overflow_unsigned,
1487 bfd_elf_generic_reloc,
1489 FALSE,
1492 FALSE),
1498 FALSE,
1500 complain_overflow_unsigned,
1501 bfd_elf_generic_reloc,
1503 FALSE,
1506 FALSE),
1512 FALSE,
1514 complain_overflow_unsigned,
1515 bfd_elf_generic_reloc,
1517 FALSE,
1520 FALSE),
1526 FALSE,
1528 complain_overflow_unsigned,
1529 bfd_elf_generic_reloc,
1531 FALSE,
1534 FALSE),
1540 FALSE,
1542 complain_overflow_unsigned,
1543 bfd_elf_generic_reloc,
1545 FALSE,
1548 FALSE),
1554 FALSE,
1556 complain_overflow_unsigned,
1557 bfd_elf_generic_reloc,
1559 FALSE,
1562 FALSE),
1564 /* Add other relocations here. */
1565 };
1570 /* Return true if producing output for a R2 BFD. */
1571 #define BFD_IS_R2(abfd) (bfd_get_mach (abfd) == bfd_mach_nios2r2)
1573 /* Return the howto for relocation RTYPE. */
1576 {
1579 /* R2 relocations are a superset of R1, so use that for the lookup
1580 table. */
1587 {
1592 {
1597 }
1598 }
1603 {
1607 }
1608 else
1609 {
1613 }
1614 }
1616 /* Map for converting BFD reloc types to Nios II reloc types. */
1617 struct elf_reloc_map
1618 {
1619 bfd_reloc_code_real_type bfd_val;
1621 };
1683 };
1685 enum elf32_nios2_stub_type
1686 {
1687 nios2_stub_call26_before,
1688 nios2_stub_call26_after,
1689 nios2_stub_none
1690 };
1692 struct elf32_nios2_stub_hash_entry
1693 {
1694 /* Base hash table entry structure. */
1697 /* The stub section. */
1700 /* Offset within stub_sec of the beginning of this stub. */
1701 bfd_vma stub_offset;
1703 /* Given the symbol's value and its section we can determine its final
1704 value when building the stubs (so the stub knows where to jump. */
1705 bfd_vma target_value;
1710 /* The symbol table entry, if any, that this was derived from. */
1713 /* And the reloc addend that this was derived from. */
1714 bfd_vma addend;
1716 /* Where this stub is being called from, or, in the case of combined
1717 stub sections, the first input section in the group. */
1719 };
1721 #define nios2_stub_hash_entry(ent) \
1722 ((struct elf32_nios2_stub_hash_entry *)(ent))
1724 #define nios2_stub_hash_lookup(table, string, create, copy) \
1725 ((struct elf32_nios2_stub_hash_entry *) \
1726 bfd_hash_lookup ((table), (string), (create), (copy)))
1729 /* The Nios II linker needs to keep track of the number of relocs that it
1730 decides to copy as dynamic relocs in check_relocs for each symbol.
1731 This is so that it can later discard them if they are found to be
1732 unnecessary. We store the information in a field extending the
1733 regular ELF linker hash table. */
1735 struct elf32_nios2_dyn_relocs
1736 {
1739 /* The input section of the reloc. */
1742 /* Total number of relocs copied for the input section. */
1743 bfd_size_type count;
1745 /* Number of pc-relative relocs copied for the input section. */
1746 bfd_size_type pc_count;
1747 };
1749 /* Nios II ELF linker hash entry. */
1751 struct elf32_nios2_link_hash_entry
1752 {
1755 /* A pointer to the most recently used stub hash entry against this
1756 symbol. */
1759 /* Track dynamic relocs copied for this symbol. */
1762 #define GOT_UNKNOWN 0
1763 #define GOT_NORMAL 1
1764 #define GOT_TLS_GD 2
1765 #define GOT_TLS_IE 4
1768 /* We need to detect and take special action for symbols which are only
1769 referenced with %call() and not with %got(). Such symbols do not need
1770 a dynamic GOT reloc in shared objects, only a dynamic PLT reloc. Lazy
1771 linking will not work if the dynamic GOT reloc exists.
1772 To check for this condition efficiently, we compare got_types_used against
1773 CALL_USED, meaning
1774 (got_types_used & (GOT_USED | CALL_USED)) == CALL_USED.
1775 */
1776 #define GOT_USED 1
1777 #define CALL_USED 2
1779 };
1781 #define elf32_nios2_hash_entry(ent) \
1782 ((struct elf32_nios2_link_hash_entry *) (ent))
1784 /* Get the Nios II elf linker hash table from a link_info structure. */
1785 #define elf32_nios2_hash_table(info) \
1786 ((struct elf32_nios2_link_hash_table *) ((info)->hash))
1788 /* Nios II ELF linker hash table. */
1789 struct elf32_nios2_link_hash_table
1790 {
1791 /* The main hash table. */
1794 /* The stub hash table. */
1797 /* Linker stub bfd. */
1800 /* Linker call-backs. */
1804 /* Array to keep track of which stub sections have been created, and
1805 information on stub grouping. */
1806 struct map_stub
1807 {
1808 /* These are the section to which stubs in the group will be
1809 attached. */
1811 /* The stub sections. There might be stubs inserted either before
1812 or after the real section.*/
1816 /* Assorted information used by nios2_elf32_size_stubs. */
1822 /* Short-cuts to get to dynamic linker sections. */
1827 /* GOT pointer symbol _gp_got. */
1831 bfd_signed_vma refcount;
1832 bfd_vma offset;
1835 /* Small local sym cache. */
1838 bfd_vma res_n_size;
1839 };
1841 struct nios2_elf32_obj_tdata
1842 {
1845 /* tls_type for each local got entry. */
1848 /* TRUE if TLS GD relocs have been seen for this object. */
1849 bfd_boolean has_tlsgd;
1850 };
1852 #define elf32_nios2_tdata(abfd) \
1853 ((struct nios2_elf32_obj_tdata *) (abfd)->tdata.any)
1855 #define elf32_nios2_local_got_tls_type(abfd) \
1856 (elf32_nios2_tdata (abfd)->local_got_tls_type)
1858 /* The name of the dynamic interpreter. This is put in the .interp
1859 section. */
1862 /* PLT implementation for position-dependent code. */
1867 };
1877 };
1879 /* PLT implementation for position-independent code. */
1884 };
1893 };
1895 /* CALL26 stub. */
1900 };
1902 /* Install 16-bit immediate value VALUE at offset OFFSET into section SEC. */
1903 static void
1905 {
1912 }
1914 /* Install COUNT 32-bit values DATA starting at offset OFFSET into
1915 section SEC. */
1916 static void
1919 {
1921 {
1925 }
1926 }
1928 /* The usual way of loading a 32-bit constant into a Nios II register is to
1929 load the high 16 bits in one instruction and then add the low 16 bits with
1930 a signed add. This means that the high halfword needs to be adjusted to
1931 compensate for the sign bit of the low halfword. This function returns the
1932 adjusted high halfword for a given 32-bit constant. */
1933 static
1935 {
1937 }
1939 /* Implement elf_backend_grok_prstatus:
1940 Support for core dump NOTE sections. */
1941 static bfd_boolean
1943 {
1948 {
1953 /* pr_cursig */
1956 /* pr_pid */
1959 /* pr_reg */
1964 }
1966 /* Make a ".reg/999" section. */
1969 }
1971 /* Implement elf_backend_grok_psinfo. */
1972 static bfd_boolean
1974 {
1976 {
1985 }
1987 /* Note that for some reason, a spurious space is tacked
1988 onto the end of the args in some (at least one anyway)
1989 implementations, so strip it off if it exists. */
1991 {
1997 }
2000 }
2002 /* Assorted hash table functions. */
2004 /* Initialize an entry in the stub hash table. */
2009 {
2010 /* Allocate the structure if it has not already been allocated by a
2011 subclass. */
2013 {
2018 }
2020 /* Call the allocation method of the superclass. */
2023 {
2026 /* Initialize the local fields. */
2035 }
2038 }
2040 /* Create an entry in a Nios II ELF linker hash table. */
2044 {
2045 /* Allocate the structure if it has not already been allocated by a
2046 subclass. */
2048 {
2053 }
2055 /* Call the allocation method of the superclass. */
2058 {
2066 }
2069 }
2071 /* Section name for stubs is the associated section name plus this
2072 string. */
2075 /* Build a name for an entry in the stub hash table. */
2082 {
2084 bfd_size_type len;
2088 {
2092 {
2095 stubpos,
2098 }
2099 }
2100 else
2101 {
2105 {
2108 stubpos,
2112 }
2113 }
2115 }
2117 /* Look up an entry in the stub hash. Stub entries are cached because
2118 creating the stub name takes a bit of time. */
2126 {
2130 /* If this input section is part of a group of sections sharing one
2131 stub section, then use the id of the first/last section in the group,
2132 depending on the stub section placement relative to the group.
2133 Stub names need to include a section id, as there may well be
2134 more than one stub used to reach say, printf, and we need to
2135 distinguish between them. */
2138 else
2145 {
2147 }
2148 else
2149 {
2163 }
2166 }
2168 /* Add a new stub entry to the stub hash. Not all fields of the new
2169 stub entry are initialised. */
2175 {
2180 bfd_boolean afterp;
2183 {
2188 }
2189 else
2190 {
2195 }
2198 {
2201 {
2203 bfd_size_type len;
2219 }
2221 }
2223 /* Enter this entry into the linker stub hash table. */
2227 {
2230 stub_name);
2232 }
2238 }
2240 /* Set up various things so that we can make a list of input sections
2241 for each output section included in the link. Returns -1 on error,
2242 0 when no stubs will be needed, and 1 on success. */
2243 int
2245 {
2251 bfd_size_type amt;
2254 /* Count the number of input BFDs and find the top input section id. */
2258 {
2263 {
2266 }
2267 }
2276 /* We can't use output_bfd->section_count here to find the top output
2277 section index as some sections may have been removed, and
2278 strip_excluded_output_sections doesn't renumber the indices. */
2282 {
2285 }
2294 /* For sections we aren't interested in, mark their entries with a
2295 value we can check later. */
2297 do
2304 {
2305 /* FIXME: This is a bit of hack. Currently our .ctors and .dtors
2306 * have PC relative relocs in them but no code flag set. */
2311 }
2314 }
2316 /* The linker repeatedly calls this function for each input section,
2317 in the order that input sections are linked into output sections.
2318 Build lists of input sections to determine groupings between which
2319 we may insert linker stubs. */
2320 void
2322 {
2326 {
2329 {
2330 /* Steal the last_sec pointer for our list.
2331 This happens to make the list in reverse order,
2332 which is what we want. */
2335 }
2336 }
2337 }
2339 /* Segment mask for CALL26 relocation relaxation. */
2340 #define CALL26_SEGMENT(x) ((x) & 0xf0000000)
2342 /* Fudge factor for approximate maximum size of all stubs that might
2343 be inserted by the linker. This does not actually limit the number
2344 of stubs that might be inserted, and only affects strategy for grouping
2345 and placement of stubs. Perhaps this should be computed based on number
2346 of relocations seen, or be specifiable on the command line. */
2347 #define MAX_STUB_SECTION_SIZE 0xffff
2349 /* See whether we can group stub sections together. Grouping stub
2350 sections may result in fewer stubs. More importantly, we need to
2351 put all .init* and .fini* stubs at the end of the .init or
2352 .fini output sections respectively, because glibc splits the
2353 _init and _fini functions into multiple parts. Putting a stub in
2354 the middle of a function is not a good idea.
2355 Rather than computing groups of a maximum fixed size, for Nios II
2356 CALL26 relaxation it makes more sense to compute the groups based on
2357 sections that fit within a 256MB address segment. Also do not allow
2358 a group to span more than one output section, since different output
2359 sections might correspond to different memory banks on a bare-metal
2360 target, etc. */
2361 static void
2363 {
2365 do
2366 {
2367 /* The list is in reverse order so we'll search backwards looking
2368 for the first section that begins in the same memory segment,
2369 marking sections along the way to point at the tail for this
2370 group. */
2375 {
2383 /* This section spans more than one memory segment, or is
2384 close enough to the end of the segment that adding stub
2385 sections before it might cause it to move so that it
2386 spans memory segments, or that stubs added at the end of
2387 this group might overflow into the next memory segment.
2388 Put it in a group by itself to localize the effects. */
2389 {
2393 }
2394 else
2395 /* Collect more sections for this group. */
2396 {
2399 {
2407 }
2410 {
2416 }
2417 }
2419 /* Reset tail for the next group. */
2421 }
2422 }
2425 }
2427 /* Determine the type of stub needed, if any, for a call. */
2428 static enum elf32_nios2_stub_type
2433 bfd_vma destination,
2435 {
2444 /* Determine where the call point is. */
2449 /* Nios II CALL and JMPI instructions can transfer control to addresses
2450 within the same 256MB segment as the PC. */
2454 /* Find the start and end addresses of the stub group. Also account for
2455 any already-created stub sections for this group. Note that for stubs
2456 in the end section, only the first instruction of the last stub
2457 (12 bytes long) needs to be within range. */
2462 else
2469 else
2476 /* Put stubs at the end of the group unless that is not a valid
2477 location and the beginning of the group is. It might be that
2478 neither the beginning nor end works if we have an input section
2479 so large that it spans multiple segment boundaries. In that
2480 case, punt; the end result will be a relocation overflow error no
2481 matter what we do here.
2483 Note that adding stubs pushes up the addresses of all subsequent
2484 sections, so that stubs allocated on one pass through the
2485 relaxation loop may not be valid on the next pass. (E.g., we may
2486 allocate a stub at the beginning of the section on one pass and
2487 find that the call site has been bumped into the next memory
2488 segment on the next pass.) The important thing to note is that
2489 we never try to reclaim the space allocated to such unused stubs,
2490 so code size and section addresses can only increase with each
2491 iteration. Accounting for the start and end addresses of the
2492 already-created stub sections ensures that when the algorithm
2493 converges, it converges accurately, with the entire appropriate
2494 stub section accessible from the call site and not just the
2495 address at the start or end of the stub group proper. */
2501 else
2502 /* Perhaps this should be a dedicated error code. */
2504 }
2506 static bfd_boolean
2508 {
2512 bfd_vma sym_value;
2514 /* Make a note of the offset within the stubs for this entry. */
2518 {
2521 /* A call26 stub looks like:
2522 orhi at, %hiadj(dest)
2523 addi at, at, %lo(dest)
2524 jmp at
2525 Note that call/jmpi instructions can't be used in PIC code
2526 so there is no reason for the stub to be PIC, either. */
2543 }
2546 }
2548 /* As above, but don't actually build the stub. Just bump offset so
2549 we know stub section sizes. */
2550 static bfd_boolean
2552 {
2557 {
2565 }
2567 }
2569 /* Read in all local syms for all input bfds.
2570 Returns -1 on error, 0 otherwise. */
2572 static int
2575 {
2580 /* We want to read in symbol extension records only once. To do this
2581 we need to read in the local symbols in parallel and save them for
2582 later use; so hold pointers to the local symbols in an array. */
2589 /* Walk over all the input BFDs, swapping in local symbols. */
2593 {
2596 /* We'll need the symbol table in a second. */
2601 /* We need an array of the local symbols attached to the input bfd. */
2604 {
2608 /* Cache them for elf_link_input_bfd. */
2610 }
2615 }
2618 }
2620 /* Determine and set the size of the stub section for a final link. */
2621 bfd_boolean
2627 {
2631 /* Stash our params away. */
2636 /* FIXME: We only compute the section groups once. This could cause
2637 problems if adding a large stub section causes following sections,
2638 or parts of them, to move into another segment. However, this seems
2639 to be consistent with the way other back ends handle this.... */
2643 {
2647 }
2650 {
2658 {
2663 /* We'll need the symbol table in a second. */
2670 /* Walk over each section attached to the input bfd. */
2674 {
2677 /* If there aren't any relocs, then there's nothing more
2678 to do. */
2683 /* If this section is a link-once section that will be
2684 discarded, then don't create any stubs. */
2689 /* Get the relocs. */
2690 internal_relocs
2696 /* Now examine each relocation. */
2700 {
2705 bfd_vma sym_value;
2706 bfd_vma destination;
2715 {
2717 error_ret_free_internal:
2721 }
2723 /* Only look for stubs on CALL and JMPI instructions. */
2727 /* Now determine the call target, its name, value,
2728 section. */
2734 {
2735 /* It's a local symbol. */
2745 {
2751 }
2752 }
2753 else
2754 {
2755 /* It's an external symbol. */
2769 {
2777 else
2779 }
2781 {
2784 }
2786 {
2791 }
2792 else
2793 {
2796 }
2797 }
2799 /* Determine what (if any) linker stub is needed. */
2805 /* Support for grouping stub sections. */
2808 else
2811 /* Get the name of this stub. */
2813 stub_type);
2818 stub_name,
2821 {
2822 /* The proper stub has already been created. */
2825 }
2829 {
2832 }
2839 }
2841 /* We're done with the internal relocs, free them. */
2844 }
2845 }
2850 /* OK, we've added some stubs. Find out the new size of the
2851 stub sections. */
2859 /* Ask the linker to do its stuff. */
2862 }
2867 error_ret_free_local:
2870 }
2872 /* Build all the stubs associated with the current output file. The
2873 stubs are kept in a hash table attached to the main linker hash
2874 table. This function is called via nios2elf_finish in the linker. */
2875 bfd_boolean
2877 {
2887 /* The stub_bfd may contain non-stub sections if it is also the
2888 dynobj. Any such non-stub sections are created with the
2889 SEC_LINKER_CREATED flag set, while stub sections do not
2890 have that flag. Ignore any non-stub sections here. */
2892 {
2893 bfd_size_type size;
2895 /* Allocate memory to hold the linker stubs. */
2901 }
2903 /* Build the stubs as directed by the stub hash table. */
2908 }
2911 #define is_nios2_elf(bfd) \
2912 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2913 && elf_object_id (bfd) == NIOS2_ELF_DATA)
2915 /* Merge backend specific data from an object file to the output
2916 object file when linking. */
2918 static bfd_boolean
2920 {
2921 flagword old_flags;
2922 flagword new_flags;
2927 /* Check if we have the same endianness. */
2934 {
2935 /* First call, no flags set. */
2940 {
2947 {
2952 }
2955 }
2956 }
2958 /* Incompatible flags. */
2960 {
2961 /* So far, the only incompatible flags denote incompatible
2962 architectures. */
2968 }
2970 /* Merge Tag_compatibility attributes and any common GNU ones. */
2974 }
2977 /* Implement bfd_elf32_bfd_reloc_type_lookup:
2978 Given a BFD reloc type, return a howto structure. */
2981 bfd_reloc_code_real_type code)
2982 {
2991 }
2993 /* Implement bfd_elf32_bfd_reloc_name_lookup:
2994 Given a reloc name, return a howto structure. */
2998 {
3004 {
3008 }
3009 else
3010 {
3014 }
3020 }
3022 /* Implement elf_info_to_howto:
3023 Given a ELF32 relocation, fill in a arelent structure. */
3024 static void
3027 {
3032 }
3034 /* Return the base VMA address which should be subtracted from real addresses
3035 when resolving @dtpoff relocation.
3036 This is PT_TLS segment p_vaddr. */
3037 static bfd_vma
3039 {
3040 /* If tls_sec is NULL, we should have signalled an error already. */
3044 }
3046 /* Return the relocation value for @tpoff relocation
3047 if STT_TLS virtual address is ADDRESS. */
3048 static bfd_vma
3050 {
3053 /* If tls_sec is NULL, we should have signalled an error already. */
3057 }
3059 /* Set the GP value for OUTPUT_BFD. Returns FALSE if this is a
3060 dangerous relocation. */
3061 static bfd_boolean
3063 {
3065 bfd_boolean gp_found;
3069 /* If we've already figured out what GP will be, just return it. */
3076 lookup:
3078 {
3080 {
3094 /* @@FIXME ignoring warning for now */
3099 }
3100 }
3101 else
3105 {
3106 /* Only get the error once. */
3110 }
3115 }
3117 /* Retrieve the previously cached _gp pointer, returning bfd_reloc_dangerous
3118 if it's not available as we don't have a link_info pointer available here
3119 to look it up in the output symbol table. We don't need to adjust the
3120 symbol value for an external symbol if we are producing relocatable
3121 output. */
3122 static bfd_reloc_status_type
3125 {
3127 {
3130 }
3134 {
3136 {
3137 /* Make up a value. */
3140 }
3141 else
3142 {
3143 *error_message
3146 }
3147 }
3150 }
3152 /* Do the relocations that require special handling. */
3153 static bfd_reloc_status_type
3158 {
3164 }
3166 static bfd_reloc_status_type
3171 {
3177 }
3179 static bfd_reloc_status_type
3184 {
3190 }
3192 static bfd_reloc_status_type
3197 {
3203 }
3205 static bfd_reloc_status_type
3210 {
3219 }
3221 static bfd_reloc_status_type
3226 {
3227 /* NIOS2 pc relative relocations are relative to the next 32-bit instruction
3228 so we need to subtract 4 before doing a final_link_relocate. */
3233 }
3235 static bfd_reloc_status_type
3240 {
3241 /* Check that the relocation is in the same page as the current address. */
3248 /* Check that the target address is correctly aligned on a 4-byte
3249 boundary. */
3255 }
3257 static bfd_reloc_status_type
3262 {
3263 /* Because we need the output_bfd, the special handling is done
3264 in nios2_elf32_relocate_section or in nios2_elf32_gprel_relocate. */
3267 }
3269 static bfd_reloc_status_type
3274 {
3276 bfd_reloc_status_type r;
3290 }
3292 static bfd_reloc_status_type
3297 {
3299 bfd_reloc_status_type r;
3313 }
3315 static bfd_reloc_status_type
3320 {
3322 bfd_reloc_status_type r;
3336 }
3338 /* HOWTO handlers for relocations that require special handling. */
3340 /* This is for relocations used only when relaxing to ensure
3341 changes in size of section don't screw up .align. */
3342 static bfd_reloc_status_type
3348 {
3352 }
3354 static bfd_reloc_status_type
3359 {
3360 /* This part is from bfd_elf_generic_reloc. */
3364 {
3367 }
3370 /* FIXME: See bfd_perform_relocation. Is this right? */
3374 input_section,
3380 }
3382 static bfd_reloc_status_type
3387 {
3388 /* This part is from bfd_elf_generic_reloc. */
3392 {
3395 }
3398 /* FIXME: See bfd_perform_relocation. Is this right? */
3402 input_section,
3408 }
3410 static bfd_reloc_status_type
3415 {
3416 /* This part is from bfd_elf_generic_reloc. */
3420 {
3423 }
3426 /* FIXME: See bfd_perform_relocation. Is this right? */
3430 input_section,
3436 }
3438 static bfd_reloc_status_type
3443 {
3444 /* This part is from bfd_elf_generic_reloc. */
3448 {
3451 }
3454 /* FIXME: See bfd_perform_relocation. Is this right? */
3462 }
3464 static bfd_reloc_status_type
3469 {
3470 /* This part is from bfd_elf_generic_reloc. */
3474 {
3477 }
3480 /* FIXME: See bfd_perform_relocation. Is this right? */
3488 }
3490 static bfd_reloc_status_type
3495 {
3496 /* This part is from bfd_elf_generic_reloc. */
3500 {
3503 }
3506 /* FIXME: See bfd_perform_relocation. Is this right? */
3510 input_section,
3516 }
3518 static bfd_reloc_status_type
3523 {
3524 /* This part is from bfd_elf_generic_reloc. */
3528 {
3531 }
3534 /* FIXME: See bfd_perform_relocation. Is this right? */
3538 input_section,
3544 }
3546 static bfd_reloc_status_type
3550 {
3551 bfd_vma relocation;
3552 bfd_vma gp;
3553 bfd_reloc_status_type r;
3556 /* This part is from bfd_elf_generic_reloc. */
3560 {
3563 }
3566 /* FIXME: See bfd_perform_relocation. Is this right? */
3573 /* This assumes we've already cached the _gp symbol. */
3576 {
3580 {
3583 }
3584 else
3586 input_section,
3589 }
3592 }
3594 static bfd_reloc_status_type
3598 {
3599 /* This part is from bfd_elf_generic_reloc. */
3603 {
3606 }
3609 /* FIXME: See bfd_perform_relocation. Is this right? */
3613 input_section,
3619 }
3621 static bfd_reloc_status_type
3625 {
3626 /* This part is from bfd_elf_generic_reloc. */
3630 {
3633 }
3636 /* FIXME: See bfd_perform_relocation. Is this right? */
3640 input_section,
3646 }
3648 static bfd_reloc_status_type
3652 {
3653 /* This part is from bfd_elf_generic_reloc. */
3657 {
3660 }
3663 /* FIXME: See bfd_perform_relocation. Is this right? */
3667 input_section,
3673 }
3676 /* Implement elf_backend_relocate_section. */
3677 static bfd_boolean
3686 {
3696 bfd_vma got_base;
3709 else
3713 {
3720 bfd_vma relocation;
3721 bfd_vma gp;
3722 bfd_vma reloc_address;
3729 bfd_boolean unresolved_reloc;
3730 bfd_vma off;
3742 {
3746 }
3747 else
3748 {
3755 }
3761 /* Nothing more to do unless this is a final link. */
3768 else
3772 {
3774 {
3777 input_section,
3783 input_section,
3789 input_section,
3790 contents,
3792 relocation,
3803 input_section,
3804 contents,
3806 relocation,
3816 /* Turns an absolute address into a gp-relative address. */
3818 {
3824 }
3825 else
3826 {
3832 && (!h
3835 {
3837 "global pointer (at 0x%08x) because the "
3838 "offset (%d) is out of the allowed range, "
3844 }
3845 else
3850 }
3855 input_section,
3861 input_section,
3873 /* If we have a call to an undefined weak symbol, we just want
3874 to stuff a zero in the bits of the call instruction and
3875 bypass the normal call26 relocation handling, because it'll
3876 diagnose an overflow error if address 0 isn't in the same
3877 256MB segment as the call site. Presumably the call
3878 should be guarded by a null check anyway. */
3880 {
3887 }
3888 /* Handle relocations which should use the PLT entry.
3889 NIOS2_BFD_RELOC_32 relocations will use the symbol's value,
3890 which may point to a PLT entry, but we don't need to handle
3891 that here. If we created a PLT entry, all branches in this
3892 object should go to it. */
3894 {
3895 /* If we've created a .plt section, and assigned a PLT entry
3896 to this function, it should not be known to bind locally.
3897 If it were, we would have cleared the PLT entry. */
3905 }
3906 /* Detect R_NIOS2_CALL26 relocations that would overflow the
3907 256MB segment. Replace the target with a reference to a
3908 trampoline instead.
3909 Note that htab->stub_group is null if relaxation has been
3910 disabled by the --no-relax linker command-line option, so
3911 we can use that to skip this processing entirely. */
3913 {
3922 {
3928 {
3931 }
3937 input_section,
3938 contents,
3942 }
3943 }
3945 /* Normal case. */
3953 /* For symmetry this would be
3954 r = nios2_elf32_do_ignore_reloc (input_bfd, howto,
3955 input_section, contents,
3956 rel->r_offset, relocation,
3957 rel->r_addend);
3958 but do_ignore_reloc would do no more than return
3959 bfd_reloc_ok. */
3968 /* Relocation is to the entry for this symbol in the
3969 global offset table. */
3971 {
3974 }
3979 {
3980 bfd_boolean dyn;
3991 h)
3996 {
3997 /* This is actually a static link, or it is a -Bsymbolic
3998 link and the symbol is defined locally. We must
3999 initialize this entry in the global offset table.
4000 Since the offset must always be a multiple of 4, we
4001 use the least significant bit to record whether we
4002 have initialized it already.
4004 When doing a dynamic link, we create a .rela.got
4005 relocation entry to initialize the value. This is
4006 done in the finish_dynamic_symbol routine. */
4009 else
4010 {
4014 }
4015 }
4016 else
4018 }
4019 else
4020 {
4026 /* The offset must always be a multiple of 4. We use the
4027 least significant bit to record whether we have already
4028 generated the necessary reloc. */
4031 else
4032 {
4037 {
4039 Elf_Internal_Rela outrel;
4054 }
4057 }
4058 }
4061 {
4065 }
4066 else
4069 /* This relocation does not use the addend. */
4073 {
4086 relocation,
4095 }
4101 /* Relocation is relative to the global offset table pointer. */
4105 {
4108 }
4110 /* Note that sgot->output_offset is not involved in this
4111 calculation. We always want the start of .got. */
4114 /* Now we adjust the relocation to be relative to the GOT pointer
4115 (the _gp_got symbol), which possibly contains the 0x8000 bias. */
4119 {
4130 relocation,
4139 }
4157 else
4158 {
4159 /* If we don't know the module number, create a relocation
4160 for it. */
4162 {
4163 Elf_Internal_Rela outrel;
4179 }
4180 else
4185 }
4196 {
4205 {
4206 bfd_boolean dyn;
4210 h)
4213 {
4216 }
4220 }
4221 else
4222 {
4228 }
4235 else
4236 {
4238 Elf_Internal_Rela outrel;
4242 /* The GOT entries have not been initialized yet. Do it
4243 now, and emit any relocations. If both an IE GOT and a
4244 GD GOT are necessary, we emit the GD first. */
4250 {
4257 }
4260 {
4262 {
4268 R_NIOS2_TLS_DTPMOD);
4271 loc);
4278 DTP_OFFSET),
4280 else
4281 {
4284 R_NIOS2_TLS_DTPREL);
4288 loc);
4291 }
4292 }
4293 else
4294 {
4295 /* If we are not emitting relocations for a
4296 general dynamic reference, then we must be in a
4297 static link or an executable link with the
4298 symbol binding locally. Mark it as belonging
4299 to module 1, the executable. */
4304 DTP_OFFSET),
4306 }
4309 }
4312 {
4314 {
4318 else
4324 R_NIOS2_TLS_TPREL);
4327 loc);
4330 }
4331 else
4336 }
4340 else
4342 }
4351 }
4356 {
4363 }
4364 else
4378 {
4379 Elf_Internal_Rela outrel;
4383 /* When generating a shared object, these relocations
4384 are copied into the output file to be resolved at run
4385 time. */
4390 outrel.r_offset
4407 {
4410 }
4411 else
4412 {
4413 /* This symbol is local, or marked to become local. */
4417 }
4427 /* This reloc will be computed at runtime, so there's no
4428 need to do anything now, except for R_NIOS2_BFD_RELOC_32
4429 relocations that have been turned into
4430 R_NIOS2_RELATIVE. */
4433 }
4443 /* Fall through. */
4451 }
4452 }
4453 else
4457 {
4460 else
4461 {
4467 }
4470 {
4480 input_section,
4503 }
4506 {
4510 }
4511 }
4512 }
4514 }
4516 /* Implement elf-backend_section_flags:
4517 Convert NIOS2 specific section flags to bfd internal section flags. */
4518 static bfd_boolean
4520 {
4525 }
4527 /* Implement elf_backend_fake_sections:
4528 Set the correct type for an NIOS2 ELF section. We do this by the
4529 section name, which is a hack, but ought to work. */
4530 static bfd_boolean
4533 {
4543 }
4545 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
4546 shortcuts to them in our hash table. */
4547 static bfd_boolean
4549 {
4558 /* In order for the two loads in .PLTresolve to share the same %hiadj,
4559 _GLOBAL_OFFSET_TABLE_ must be aligned to a 16-byte boundary. */
4563 /* The Nios II ABI specifies that GOT-relative relocations are relative
4564 to the linker-created symbol _gp_got, rather than using
4565 _GLOBAL_OFFSET_TABLE_ directly. In particular, the latter always
4566 points to the base of the GOT while _gp_got may include a bias. */
4574 }
4576 /* Implement elf_backend_create_dynamic_sections:
4577 Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
4578 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
4579 hash table. */
4580 static bfd_boolean
4582 {
4591 /* In order for the two loads in a shared object .PLTresolve to share the
4592 same %hiadj, the start of the PLT (as well as the GOT) must be aligned
4593 to a 16-byte boundary. This is because the addresses for these loads
4594 include the -(.plt+4) PIC correction. */
4602 {
4606 }
4609 }
4611 /* Implement elf_backend_copy_indirect_symbol:
4612 Copy the extra info we tack onto an elf_link_hash_entry. */
4613 static void
4617 {
4624 {
4626 {
4630 /* Add reloc counts against the indirect sym to the direct sym
4631 list. Merge any entries against the same section. */
4633 {
4638 {
4643 }
4646 }
4648 }
4652 }
4656 {
4659 }
4664 }
4666 /* Set the right machine number for a NIOS2 ELF file. */
4668 static bfd_boolean
4670 {
4676 {
4684 }
4687 }
4689 /* Implement elf_backend_check_relocs:
4690 Look through the relocs for a section during the first phase. */
4691 static bfd_boolean
4694 {
4712 sym_hashes_end = (sym_hashes
4724 {
4732 else
4733 {
4739 /* PR15323, ref flags aren't set for references in the same
4740 object. */
4742 }
4747 {
4756 /* This symbol requires a global offset table entry. */
4757 {
4761 {
4777 }
4780 {
4781 /* Create the .got section. */
4784 }
4787 {
4790 }
4794 {
4797 }
4800 {
4808 {
4809 /* Make sure a plt entry is created for this symbol if
4810 it turns out to be a function defined by a dynamic
4811 object. */
4816 }
4817 else
4819 }
4820 else
4821 {
4822 /* This is a global offset table entry for a local symbol. */
4824 {
4825 bfd_size_type size;
4829 local_got_refcounts
4836 }
4839 }
4841 /* We will already have issued an error message if there is a
4842 TLS / non-TLS mismatch, based on the symbol type. We don't
4843 support any linker relaxations. So just combine any TLS
4844 types needed. */
4850 {
4853 else
4855 }
4856 }
4857 /* Fall through */
4863 {
4868 }
4871 /* This relocation describes the C++ object vtable hierarchy.
4872 Reconstruct it for later use during GC. */
4878 /* This relocation describes which C++ vtable entries are actually
4879 used. Record for later use during GC. */
4892 {
4893 /* If this reloc is in a read-only section, we might
4894 need a copy reloc. We can't check reliably at this
4895 stage whether the section is read-only, as input
4896 sections have not yet been mapped to output sections.
4897 Tentatively set the flag for now, and correct in
4898 adjust_dynamic_symbol. */
4902 /* Make sure a plt entry is created for this symbol if it
4903 turns out to be a function defined by a dynamic object. */
4908 }
4910 /* If we are creating a shared library, we need to copy the
4911 reloc into the shared library. */
4917 {
4921 /* When creating a shared object, we must copy these
4922 reloc types into the output file. We create a reloc
4923 section in dynobj and make room for this reloc. */
4925 {
4926 sreloc = _bfd_elf_make_dynamic_reloc_section
4930 }
4932 /* If this is a global symbol, we count the number of
4933 relocations we need for this symbol. */
4936 else
4937 {
4938 /* Track dynamic relocs needed for local syms too.
4939 We really need local syms available to do this
4940 easily. Oh well. */
4957 }
4961 {
4972 }
4976 }
4978 }
4979 }
4982 }
4985 /* Implement elf_backend_gc_mark_hook:
4986 Return the section that should be marked against GC for a given
4987 relocation. */
4994 {
4997 {
5001 }
5003 }
5005 /* Implement elf_backend_gc_sweep_hook:
5006 Update the got entry reference counts for the section being removed. */
5007 static bfd_boolean
5012 {
5034 {
5041 {
5046 }
5050 {
5058 {
5061 }
5063 {
5066 }
5075 {
5087 {
5091 {
5096 }
5097 }
5098 }
5103 }
5104 }
5107 }
5109 /* Implement elf_backend_finish_dynamic_symbols:
5110 Finish up dynamic symbol handling. We set the contents of various
5111 dynamic sections here. */
5112 static bfd_boolean
5117 {
5126 {
5130 bfd_vma plt_index;
5131 bfd_vma got_offset;
5132 Elf_Internal_Rela rela;
5134 bfd_vma got_address;
5136 /* This symbol has an entry in the procedure linkage table. Set
5137 it up. */
5144 /* Emit the PLT entry. */
5146 {
5160 /* Fill in the entry in the global offset table. There are no
5161 res_n slots for a shared object PLT, instead the .got.plt entries
5162 point to the PLT entries. */
5166 }
5167 else
5168 {
5179 /* Fill in the entry in the global offset table. */
5183 }
5185 /* Fill in the entry in the .rela.plt section. */
5193 {
5194 /* Mark the symbol as undefined, rather than as defined in
5195 the .plt section. Leave the value alone. */
5197 /* If the symbol is weak, we do need to clear the value.
5198 Otherwise, the PLT entry would provide a definition for
5199 the symbol even if the symbol wasn't defined anywhere,
5200 and so the symbol would never be NULL. */
5203 }
5204 }
5212 {
5215 Elf_Internal_Rela rela;
5217 bfd_vma offset;
5219 /* This symbol has an entry in the global offset table. Set it
5220 up. */
5229 /* If this is a -Bsymbolic link, and the symbol is defined
5230 locally, we just want to emit a RELATIVE reloc. Likewise if
5231 the symbol was forced to be local because of a version file.
5232 The entry in the global offset table will already have been
5233 initialized in the relocate_section function. */
5236 {
5241 }
5242 else
5243 {
5248 }
5253 }
5256 {
5263 }
5266 {
5268 Elf_Internal_Rela rela;
5271 /* This symbol needs a copy reloc. Set it up. */
5286 }
5288 /* Mark _DYNAMIC, _GLOBAL_OFFSET_TABLE_, and _gp_got as absolute. */
5295 }
5297 /* Implement elf_backend_finish_dynamic_sections. */
5298 static bfd_boolean
5301 {
5314 {
5324 {
5325 Elf_Internal_Dyn dyn;
5331 {
5357 /* The procedure linkage table relocs (DT_JMPREL) should
5358 not be included in the overall relocs (DT_RELA).
5359 Therefore, we override the DT_RELASZ entry here to
5360 make it not include the JMPREL relocs. Since the
5361 linker script arranges for .rela.plt to follow all
5362 other relocation sections, we don't have to worry
5363 about changing the DT_RELA entry. */
5376 }
5377 }
5379 /* Fill in the first entry in the procedure linkage table. */
5381 {
5385 {
5392 }
5393 else
5394 {
5395 /* Divide by 4 here, not 3 because we already corrected for the
5396 res_N branches. */
5400 bfd_vma res_offset;
5417 }
5418 }
5419 }
5420 /* Fill in the first three entries in the global offset table. */
5422 {
5425 else
5431 }
5436 }
5438 /* Implement elf_backend_adjust_dynamic_symbol:
5439 Adjust a symbol defined by a dynamic object and referenced by a
5440 regular object. The current definition is in some section of the
5441 dynamic object, but we're not including those sections. We have to
5442 change the definition to something the rest of the link can
5443 understand. */
5444 static bfd_boolean
5447 {
5456 /* Make sure we know what is going on here. */
5464 /* If this is a function, put it in the procedure linkage table. We
5465 will fill in the contents of the procedure linkage table later,
5466 when we know the address of the .got section. */
5468 {
5473 {
5474 /* This case can occur if we saw a PLT reloc in an input
5475 file, but the symbol was never referred to by a dynamic
5476 object, or if all references were garbage collected. In
5477 such a case, we don't actually need to build a procedure
5478 linkage table, and we can just do a PCREL reloc instead. */
5481 }
5484 }
5486 /* Reinitialize the plt offset now that it is not used as a reference
5487 count any more. */
5490 /* If this is a weak symbol, and there is a real definition, the
5491 processor independent code will have arranged for us to see the
5492 real definition first, and we can just use the same value. */
5494 {
5500 }
5502 /* If there are no non-GOT references, we do not need a copy
5503 relocation. */
5507 /* This is a reference to a symbol defined by a dynamic object which
5508 is not a function.
5509 If we are creating a shared library, we must presume that the
5510 only references to the symbol are via the global offset table.
5511 For such cases we need not do anything here; the relocations will
5512 be handled correctly by relocate_section. */
5517 {
5521 }
5523 /* We must allocate the symbol in our .dynbss section, which will
5524 become part of the .bss section of the executable. There will be
5525 an entry for this symbol in the .dynsym section. The dynamic
5526 object will contain position independent code, so all references
5527 from the dynamic object to this symbol will go through the global
5528 offset table. The dynamic linker will use the .dynsym entry to
5529 determine the address it must put in the global offset table, so
5530 both the dynamic object and the regular object will refer to the
5531 same memory location for the variable. */
5535 /* We must generate a R_NIOS2_COPY reloc to tell the dynamic linker to
5536 copy the initial value out of the dynamic object and into the
5537 runtime process image. We need to remember the offset into the
5538 .rela.bss section we are going to use. */
5540 {
5547 }
5553 /* Align dynbss. */
5559 /* Define the symbol as being at this point in the section. */
5563 /* Increment the section size to make room for the symbol. */
5567 }
5569 /* Worker function for nios2_elf32_size_dynamic_sections. */
5570 static bfd_boolean
5572 {
5580 /* When warning symbols are created, they **replace** the "real"
5581 entry in the hash table, thus we never get to see the real
5582 symbol in a hash traversal. So look at it now. */
5594 }
5596 /* Another worker function for nios2_elf32_size_dynamic_sections.
5597 Allocate space in .plt, .got and associated reloc sections for
5598 dynamic relocs. */
5599 static bfd_boolean
5601 {
5612 /* When warning symbols are created, they **replace** the "real"
5613 entry in the hash table, thus we never get to see the real
5614 symbol in a hash traversal. So look at it now. */
5622 {
5623 /* Make sure this symbol is output as a dynamic symbol.
5624 Undefined weak syms won't yet be marked as dynamic. */
5631 {
5634 /* Allocate room for the header. */
5636 {
5639 else
5641 }
5645 /* If this symbol is not defined in a regular file, and we are
5646 not generating a shared library, then set the symbol to this
5647 location in the .plt. This is required to make function
5648 pointers compare as equal between the normal executable and
5649 the shared library. */
5652 {
5655 }
5657 /* Make room for this entry. */
5660 /* We also need to make an entry in the .rela.plt section. */
5663 /* And the .got.plt section. */
5665 }
5666 else
5667 {
5670 }
5671 }
5672 else
5673 {
5676 }
5683 {
5685 bfd_boolean dyn;
5689 /* Make sure this symbol is output as a dynamic symbol.
5690 Undefined weak syms won't yet be marked as dynamic. */
5703 /* Non-TLS symbols need one GOT slot. */
5705 else
5706 {
5708 /* R_NIOS2_TLS_GD16 needs 2 consecutive GOT slots. */
5711 /* R_NIOS2_TLS_IE16 needs one GOT slot. */
5713 }
5727 {
5736 }
5739 && !use_plt
5743 }
5744 else
5750 /* In the shared -Bsymbolic case, discard space allocated for
5751 dynamic pc-relative relocs against symbols which turn out to be
5752 defined in regular objects. For the normal shared case, discard
5753 space for pc-relative relocs that have become local due to symbol
5754 visibility changes. */
5757 {
5760 {
5764 {
5769 else
5771 }
5772 }
5774 /* Also discard relocs on undefined weak syms with non-default
5775 visibility. */
5778 {
5782 /* Make sure undefined weak symbols are output as a dynamic
5783 symbol in PIEs. */
5788 }
5789 }
5790 else
5791 {
5792 /* For the non-shared case, discard space for relocs against
5793 symbols which turn out to need copy relocs or are not
5794 dynamic. */
5801 {
5802 /* Make sure this symbol is output as a dynamic symbol.
5803 Undefined weak syms won't yet be marked as dynamic. */
5809 /* If that succeeded, we know we'll be keeping all the
5810 relocs. */
5813 }
5817 keep: ;
5818 }
5820 /* Finally, allocate space. */
5822 {
5825 }
5828 }
5830 /* Implement elf_backend_size_dynamic_sections:
5831 Set the sizes of the dynamic sections. */
5832 static bfd_boolean
5835 {
5838 bfd_boolean plt;
5839 bfd_boolean got;
5840 bfd_boolean relocs;
5850 {
5851 /* Set the contents of the .interp section to the interpreter. */
5853 {
5858 }
5859 }
5860 else
5861 {
5862 /* We may have created entries in the .rela.got section.
5863 However, if we are not creating the dynamic sections, we will
5864 not actually use these entries. Reset the size of .rela.got,
5865 which will cause it to get stripped from the output file
5866 below. */
5870 }
5872 /* Set up .got offsets for local syms, and space for local dynamic
5873 relocs. */
5875 {
5879 bfd_size_type locsymcount;
5887 {
5891 {
5894 {
5895 /* Input section has been discarded, either because
5896 it is a copy of a linkonce section or due to
5897 linker script /DISCARD/, so we'll be discarding
5898 the relocs too. */
5899 }
5901 {
5906 }
5907 }
5908 }
5921 {
5923 {
5926 /* TLS_GD relocs need an 8-byte structure in the GOT. */
5935 }
5936 else
5938 }
5939 }
5942 {
5943 /* Allocate two GOT entries and one dynamic relocation (if necessary)
5944 for R_NIOS2_TLS_LDM16 relocations. */
5949 }
5950 else
5953 /* Allocate global sym .plt and .got entries, and space for global
5954 sym dynamic relocs. */
5958 {
5959 /* If the .got section is more than 0x8000 bytes, we add
5960 0x8000 to the value of _gp_got, so that 16-bit relocations
5961 have a greater chance of working. */
5965 }
5967 /* The check_relocs and adjust_dynamic_symbol entry points have
5968 determined the sizes of the various dynamic sections. Allocate
5969 memory for them. */
5974 {
5980 /* It's OK to base decisions on the section name, because none
5981 of the dynobj section names depend upon the input files. */
5985 {
5986 /* Remember whether there is a PLT. */
5989 /* Correct for the number of res_N branches. */
5991 {
5994 }
5995 }
5997 {
5999 {
6002 /* We use the reloc_count field as a counter if we need
6003 to copy relocs into the output file. */
6005 }
6006 }
6010 /* It's not one of our sections, so don't allocate space. */
6014 {
6015 /* If we don't need this section, strip it from the
6016 output file. This is mostly to handle .rela.bss and
6017 .rela.plt. We must create both sections in
6018 create_dynamic_sections, because they must be created
6019 before the linker maps input sections to output
6020 sections. The linker does that before
6021 adjust_dynamic_symbol is called, and it is that
6022 function which decides whether anything needs to go
6023 into these sections. */
6026 }
6031 /* Allocate memory for the section contents. */
6032 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
6033 Unused entries should be reclaimed before the section's contents
6034 are written out, but at the moment this does not happen. Thus in
6035 order to prevent writing out garbage, we initialize the section's
6036 contents to zero. */
6040 }
6042 /* Adjust dynamic symbols that point to the plt to account for the
6043 now-known number of resN slots. */
6048 {
6049 /* Add some entries to the .dynamic section. We fill in the
6050 values later, in elf_nios2_finish_dynamic_sections, but we
6051 must add the entries now so that we get the correct size for
6052 the .dynamic section. The DT_DEBUG entry is filled in by the
6053 dynamic linker and used by the debugger. */
6054 #define add_dynamic_entry(TAG, VAL) \
6055 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
6081 }
6082 #undef add_dynamic_entry
6085 }
6087 /* Free the derived linker hash table. */
6088 static void
6090 {
6096 }
6098 /* Implement bfd_elf32_bfd_link_hash_table_create. */
6101 {
6110 link_hash_newfunc,
6112 elf32_nios2_link_hash_entry),
6113 NIOS2_ELF_DATA))
6114 {
6117 }
6119 /* Init the stub hash table too. */
6122 {
6125 }
6129 }
6131 /* Implement elf_backend_reloc_type_class. */
6132 static enum elf_reloc_type_class
6136 {
6138 {
6147 }
6148 }
6150 /* Return 1 if target is one of ours. */
6151 static bfd_boolean
6153 {
6156 }
6158 /* Implement elf_backend_add_symbol_hook.
6159 This hook is called by the linker when adding symbols from an object
6160 file. We use it to put .comm items in .sbss, and not .bss. */
6161 static bfd_boolean
6169 {
6176 {
6177 /* Common symbols less than or equal to -G nn bytes are automatically
6178 put into .sbss. */
6183 {
6191 flags);
6194 }
6198 }
6201 }
6203 /* Implement elf_backend_can_make_relative_eh_frame:
6204 Decide whether to attempt to turn absptr or lsda encodings in
6205 shared libraries into pcrel within the given input section. */
6206 static bfd_boolean
6209 ATTRIBUTE_UNUSED,
6210 asection *eh_frame_section
6211 ATTRIBUTE_UNUSED)
6212 {
6213 /* We can't use PC-relative encodings in the .eh_frame section. */
6215 }
6217 /* Implement elf_backend_special_sections. */
6219 {
6225 };
6227 #define ELF_ARCH bfd_arch_nios2
6228 #define ELF_TARGET_ID NIOS2_ELF_DATA
6229 #define ELF_MACHINE_CODE EM_ALTERA_NIOS2
6231 /* The Nios II MMU uses a 4K page size. */
6233 #define ELF_MAXPAGESIZE 0x1000
6235 #define bfd_elf32_bfd_link_hash_table_create \
6236 nios2_elf32_link_hash_table_create
6238 #define bfd_elf32_bfd_merge_private_bfd_data \
6239 nios2_elf32_merge_private_bfd_data
6241 /* Relocation table lookup macros. */
6243 #define bfd_elf32_bfd_reloc_type_lookup nios2_elf32_bfd_reloc_type_lookup
6244 #define bfd_elf32_bfd_reloc_name_lookup nios2_elf32_bfd_reloc_name_lookup
6246 /* JUMP_TABLE_LINK macros. */
6248 /* elf_info_to_howto (using RELA relocations). */
6250 #define elf_info_to_howto nios2_elf32_info_to_howto
6252 /* elf backend functions. */
6254 #define elf_backend_can_gc_sections 1
6255 #define elf_backend_can_refcount 1
6256 #define elf_backend_plt_readonly 1
6257 #define elf_backend_want_got_plt 1
6258 #define elf_backend_rela_normal 1
6260 #define elf_backend_relocate_section nios2_elf32_relocate_section
6261 #define elf_backend_section_flags nios2_elf32_section_flags
6262 #define elf_backend_fake_sections nios2_elf32_fake_sections
6263 #define elf_backend_check_relocs nios2_elf32_check_relocs
6265 #define elf_backend_gc_mark_hook nios2_elf32_gc_mark_hook
6266 #define elf_backend_gc_sweep_hook nios2_elf32_gc_sweep_hook
6267 #define elf_backend_create_dynamic_sections \
6268 nios2_elf32_create_dynamic_sections
6269 #define elf_backend_finish_dynamic_symbol nios2_elf32_finish_dynamic_symbol
6270 #define elf_backend_finish_dynamic_sections \
6271 nios2_elf32_finish_dynamic_sections
6272 #define elf_backend_adjust_dynamic_symbol nios2_elf32_adjust_dynamic_symbol
6273 #define elf_backend_reloc_type_class nios2_elf32_reloc_type_class
6274 #define elf_backend_size_dynamic_sections nios2_elf32_size_dynamic_sections
6275 #define elf_backend_add_symbol_hook nios2_elf_add_symbol_hook
6276 #define elf_backend_copy_indirect_symbol nios2_elf32_copy_indirect_symbol
6277 #define elf_backend_object_p nios2_elf32_object_p
6279 #define elf_backend_grok_prstatus nios2_grok_prstatus
6280 #define elf_backend_grok_psinfo nios2_grok_psinfo
6282 #undef elf_backend_can_make_relative_eh_frame
6283 #define elf_backend_can_make_relative_eh_frame \
6284 nios2_elf32_can_make_relative_eh_frame
6286 #define elf_backend_special_sections elf32_nios2_special_sections
6288 #define TARGET_LITTLE_SYM nios2_elf32_le_vec
6290 #define TARGET_BIG_SYM nios2_elf32_be_vec
6293 #define elf_backend_got_header_size 12
6294 #define elf_backend_default_execstack 0