| blob | 86fe1b3377e8e1bb9c85e8c5d9ea1fd9a665cdc5 |
1 /* Renesas / SuperH SH specific support for 32-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013
4 Free Software Foundation, Inc.
5 Contributed by Ian Lance Taylor, Cygnus Support.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
35 static bfd_reloc_status_type sh_elf_reloc
37 static bfd_reloc_status_type sh_elf_ignore_reloc
39 static bfd_boolean sh_elf_relax_delete_bytes
41 static bfd_boolean sh_elf_align_loads
43 #ifndef SH64_ELF
44 static bfd_boolean sh_elf_swap_insns
46 #endif
47 static int sh_elf_optimized_tls_reloc
49 static bfd_vma dtpoff_base
51 static bfd_vma tpoff
54 /* The name of the dynamic interpreter. This is put in the .interp
55 section. */
59 /* FDPIC binaries have a default 128K stack. */
60 #define DEFAULT_STACK_SIZE 0x20000
62 #define MINUS_ONE ((bfd_vma) 0 - 1)
64 /* Decide whether a reference to a symbol can be resolved locally or
65 not. If the symbol is protected, we want the local address, but
66 its function descriptor must be assigned by the dynamic linker. */
67 #define SYMBOL_FUNCDESC_LOCAL(INFO, H) \
68 (SYMBOL_REFERENCES_LOCAL (INFO, H) \
69 || ! elf_hash_table (INFO)->dynamic_sections_created)
70 \f
71 #define SH_PARTIAL32 TRUE
72 #define SH_SRC_MASK32 0xffffffff
73 #define SH_ELF_RELOC sh_elf_reloc
75 {
77 };
79 #define SH_PARTIAL32 FALSE
80 #define SH_SRC_MASK32 0
81 #define SH_ELF_RELOC bfd_elf_generic_reloc
83 {
85 };
86 \f
87 /* Return true if OUTPUT_BFD is a VxWorks object. */
89 static bfd_boolean
91 {
92 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
98 #else
100 #endif
101 }
103 /* Return true if OUTPUT_BFD is an FDPIC object. */
105 static bfd_boolean
107 {
108 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
114 #else
116 #endif
117 }
119 /* Return the howto table for ABFD. */
123 {
127 }
129 static bfd_reloc_status_type
134 {
139 bfd_signed_vma x;
142 /* Sanity check the address. */
146 /* We require the start and end relocations to be processed consecutively -
147 although we allow then to be processed forwards or backwards. */
149 {
153 }
161 /* Get the symbol_section contents. */
163 {
166 else
167 {
170 {
174 }
175 }
176 }
177 #define IS_PPI(PTR) ((bfd_get_16 (input_bfd, (PTR)) & 0xfc00) == 0xf800)
180 {
187 }
188 /* Calculate the start / end values to load into rs / re minus four -
189 so that will cancel out the four we would otherwise have to add to
190 addr to get the value to subtract in order to get relative addressing. */
192 {
195 }
196 else
197 {
205 }
226 }
228 /* This function is used for normal relocs. This used to be like the COFF
229 function, and is almost certainly incorrect for other ELF targets. */
231 static bfd_reloc_status_type
235 {
237 bfd_vma sym_value;
245 {
246 /* Partial linking--do nothing. */
249 }
251 /* Almost all relocs have to do with relaxing. If any work must be
252 done for them, it has been done in sh_relax_section. */
262 else
268 {
279 + addr
292 }
295 }
297 /* This function is used for relocs which are only used for relaxing,
298 which the linker should otherwise ignore. */
300 static bfd_reloc_status_type
306 {
310 }
312 /* This structure is used to map BFD reloc codes to SH ELF relocs. */
314 struct elf_reloc_map
315 {
316 bfd_reloc_code_real_type bfd_reloc_val;
318 };
320 /* An array mapping BFD reloc codes to SH ELF relocs. */
323 {
371 #ifdef INCLUDE_SHMEDIA
422 };
424 /* Given a BFD reloc code, return the howto structure for the
425 corresponding SH ELF reloc. */
429 {
433 {
436 }
439 }
443 {
447 {
451 i++)
455 }
456 else
457 {
461 i++)
465 }
468 }
470 /* Given an ELF reloc, fill in the howto field of a relent. */
472 static void
474 {
488 }
489 \f
490 /* This function handles relaxing for SH ELF. See the corresponding
491 function in coff-sh.c for a description of what this does. FIXME:
492 There is a lot of duplication here between this code and the COFF
493 specific code. The format of relocs and symbols is wound deeply
494 into this code, but it would still be better if the duplication
495 could be eliminated somehow. Note in particular that although both
496 functions use symbols like R_SH_CODE, those symbols have different
497 values; in coff-sh.c they come from include/coff/sh.h, whereas here
498 they come from enum elf_sh_reloc_type in include/elf/sh.h. */
500 static bfd_boolean
503 {
506 bfd_boolean have_code;
518 #ifdef INCLUDE_SHMEDIA
521 {
523 }
524 #endif
528 internal_relocs = (_bfd_elf_link_read_relocs
538 {
542 bfd_signed_vma foff;
550 /* Get the section contents. */
552 {
555 else
556 {
559 }
560 }
562 /* The r_addend field of the R_SH_USES reloc will point us to
563 the register load. The 4 is because the r_addend field is
564 computed as though it were a jump offset, which are based
565 from 4 bytes after the jump instruction. */
568 {
570 abfd,
573 }
576 /* If the instruction is not mov.l NN,rN, we don't know what to
577 do. */
579 {
584 }
586 /* Get the address from which the register is being loaded. The
587 displacement in the mov.l instruction is quadrupled. It is a
588 displacement from four bytes after the movl instruction, but,
589 before adding in the PC address, two least significant bits
590 of the PC are cleared. We assume that the section is aligned
591 on a four byte boundary. */
596 {
601 }
603 /* Get the reloc for the address from which the register is
604 being loaded. This reloc will tell us which function is
605 actually being called. */
611 {
616 }
618 /* Read this BFD's symbols if we haven't done so already. */
620 {
628 }
630 /* Get the value of the symbol referred to by the reloc. */
632 {
633 /* A local symbol. */
639 {
644 }
649 }
650 else
651 {
660 {
661 /* This appears to be a reference to an undefined
662 symbol. Just ignore it--it will be caught by the
663 regular reloc processing. */
665 }
670 }
674 else
677 /* See if this function call can be shortened. */
678 foff = (symval
683 /* A branch to an address beyond ours might be increased by an
684 .align that doesn't move when bytes behind us are deleted.
685 So, we add some slop in this calculation to allow for
686 that. */
688 {
689 /* After all that work, we can't shorten this function call. */
691 }
693 /* Shorten the function call. */
695 /* For simplicity of coding, we are going to modify the section
696 contents, the section relocs, and the BFD symbol table. We
697 must tell the rest of the code not to free up this
698 information. It would be possible to instead create a table
699 of changes which have to be made, as is done in coff-mips.c;
700 that would be more work, but would require less memory when
701 the linker is run. */
707 /* Replace the jsr with a bsr. */
709 /* Change the R_SH_USES reloc into an R_SH_IND12W reloc, and
710 replace the jsr with a bsr. */
712 /* We used to test (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
713 here, but that only checks if the symbol is an external symbol,
714 not if the symbol is in a different section. Besides, we need
715 a consistent meaning for the relocation, so we just assume here that
716 the value of the symbol is not available. */
718 /* We can't fully resolve this yet, because the external
719 symbol value may be changed by future relaxing. We let
720 the final link phase handle it. */
725 /* When we calculated the symbol "value" we had an offset in the
726 DIR32's word in memory (we read and add it above). However,
727 the jsr we create does NOT have this offset encoded, so we
728 have to add it to the addend to preserve it. */
731 /* See if there is another R_SH_USES reloc referring to the same
732 register load. */
738 {
739 /* Some other function call depends upon this register load,
740 and we have not yet converted that function call.
741 Indeed, we may never be able to convert it. There is
742 nothing else we can do at this point. */
744 }
746 /* Look for a R_SH_COUNT reloc on the location where the
747 function address is stored. Do this before deleting any
748 bytes, to avoid confusion about the address. */
754 /* Delete the register load. */
758 /* That will change things, so, just in case it permits some
759 other function call to come within range, we should relax
760 again. Note that this is not required, and it may be slow. */
763 /* Now check whether we got a COUNT reloc. */
765 {
770 }
772 /* The number of uses is stored in the r_addend field. We've
773 just deleted one. */
775 {
777 abfd,
780 }
784 /* If there are no more uses, we can delete the address. Reload
785 the address from irelfn, in case it was changed by the
786 previous call to sh_elf_relax_delete_bytes. */
788 {
791 }
793 /* We've done all we can with that function call. */
794 }
796 /* Look for load and store instructions that we can align on four
797 byte boundaries. */
800 {
801 bfd_boolean swapped;
803 /* Get the section contents. */
805 {
808 else
809 {
812 }
813 }
820 {
824 }
825 }
829 {
832 else
833 {
834 /* Cache the symbols for elf_link_input_bfd. */
836 }
837 }
841 {
844 else
845 {
846 /* Cache the section contents for elf_link_input_bfd. */
848 }
849 }
857 error_return:
869 }
871 /* Delete some bytes from a section while relaxing. FIXME: There is a
872 lot of duplication between this function and sh_relax_delete_bytes
873 in coff-sh.c. */
875 static bfd_boolean
878 {
884 bfd_vma toaddr;
898 /* The deletion must stop at the next ALIGN reloc for an aligment
899 power larger than the number of bytes we are deleting. */
907 {
911 {
915 }
916 }
918 /* Actually delete the bytes. */
923 else
924 {
927 #define NOP_OPCODE (0x0009)
932 }
934 /* Adjust all the relocs. */
936 {
942 bfd_boolean overflow;
944 /* Get the new reloc address. */
952 /* See if this reloc was for the bytes we have deleted, in which
953 case we no longer care about it. Don't delete relocs which
954 represent addresses, though. */
964 /* If this is a PC relative reloc, see if the range it covers
965 includes the bytes we have deleted. */
967 {
978 }
981 {
987 /* If this reloc is against a symbol defined in this
988 section, and the symbol will not be adjusted below, we
989 must check the addend to see it will put the value in
990 range to be adjusted, and hence must be changed. */
992 {
997 {
998 bfd_vma val;
1001 {
1006 }
1007 else
1008 {
1012 }
1013 }
1014 }
1028 {
1029 /* This has been made by previous relaxation. Since the
1030 relocation will be against an external symbol, the
1031 final relocation will just do the right thing. */
1033 }
1034 else
1035 {
1040 /* The addend will be against the section symbol, thus
1041 for adjusting the addend, the relevant start is the
1042 start of the section.
1043 N.B. If we want to abandon in-place changes here and
1044 test directly using symbol + addend, we have to take into
1045 account that the addend has already been adjusted by -4. */
1048 }
1064 /* These relocs types represent
1065 .word L2-L1
1066 The r_addend field holds the difference between the reloc
1067 address and L1. That is the start of the reloc, and
1068 adding in the contents gives us the top. We must adjust
1069 both the r_offset field and the section contents.
1070 N.B. in gas / coff bfd, the elf bfd r_addend is called r_offset,
1071 and the elf bfd r_offset is called r_vaddr. */
1089 else
1101 }
1111 else
1115 {
1119 {
1143 else
1144 {
1147 }
1175 }
1178 {
1184 }
1185 }
1188 }
1190 /* Look through all the other sections. If there contain any IMM32
1191 relocs against internal symbols which we are not going to adjust
1192 below, we may need to adjust the addends. */
1194 {
1204 /* We always cache the relocs. Perhaps, if info->keep_memory is
1205 FALSE, we should free them, if we are permitted to, when we
1206 leave sh_coff_relax_section. */
1207 internal_relocs = (_bfd_elf_link_read_relocs
1215 {
1216 /* Dwarf line numbers use R_SH_SWITCH32 relocs. */
1218 {
1220 bfd_signed_vma voff;
1223 {
1226 else
1227 {
1228 /* We always cache the section contents.
1229 Perhaps, if info->keep_memory is FALSE, we
1230 should free them, if we are permitted to,
1231 when we leave sh_coff_relax_section. */
1233 {
1237 }
1240 }
1241 }
1244 start
1247 /* STOP is in a different section, so it won't change. */
1264 }
1277 {
1278 bfd_vma val;
1281 {
1284 else
1285 {
1286 /* We always cache the section contents.
1287 Perhaps, if info->keep_memory is FALSE, we
1288 should free them, if we are permitted to,
1289 when we leave sh_coff_relax_section. */
1291 {
1295 }
1298 }
1299 }
1306 }
1307 }
1308 }
1310 /* Adjust the local symbols defined in this section. */
1313 {
1318 }
1320 /* Now adjust the global symbols defined in this section. */
1326 {
1333 {
1335 }
1336 }
1338 /* See if we can move the ALIGN reloc forward. We have adjusted
1339 r_offset for it already. */
1341 {
1348 {
1349 /* Tail recursion. */
1352 }
1353 }
1356 }
1358 /* Look for loads and stores which we can align to four byte
1359 boundaries. This is like sh_align_loads in coff-sh.c. */
1361 static bfd_boolean
1366 {
1370 bfd_size_type amt;
1376 /* Get all the addresses with labels on them. */
1384 {
1386 {
1389 }
1390 }
1392 /* Note that the assembler currently always outputs relocs in
1393 address order. If that ever changes, this code will need to sort
1394 the label values and the relocs. */
1399 {
1412 else
1419 }
1425 error_return:
1429 }
1431 #ifndef SH64_ELF
1432 /* Swap two SH instructions. This is like sh_swap_insns in coff-sh.c. */
1434 static bfd_boolean
1437 {
1442 /* Swap the instructions themselves. */
1448 /* Adjust all reloc addresses. */
1451 {
1455 /* There are a few special types of relocs that we don't want to
1456 adjust. These relocs do not apply to the instruction itself,
1457 but are only associated with the address. */
1465 /* If an R_SH_USES reloc points to one of the addresses being
1466 swapped, we must adjust it. It would be incorrect to do this
1467 for a jump, though, since we want to execute both
1468 instructions after the jump. (We have avoided swapping
1469 around a label, so the jump will not wind up executing an
1470 instruction it shouldn't). */
1472 {
1473 bfd_vma off;
1480 }
1483 {
1486 }
1488 {
1491 }
1492 else
1496 {
1499 bfd_boolean overflow;
1504 {
1528 /* This reloc ignores the least significant 3 bits of
1529 the program counter before adding in the offset.
1530 This means that if ADDR is at an even address, the
1531 swap will not affect the offset. If ADDR is an at an
1532 odd address, then the instruction will be crossing a
1533 four byte boundary, and must be adjusted. */
1535 {
1542 }
1545 }
1548 {
1554 }
1555 }
1556 }
1559 }
1561 \f
1562 /* Describes one of the various PLT styles. */
1564 struct elf_sh_plt_info
1565 {
1566 /* The template for the first PLT entry, or NULL if there is no special
1567 first entry. */
1570 /* The size of PLT0_ENTRY in bytes, or 0 if PLT0_ENTRY is NULL. */
1571 bfd_vma plt0_entry_size;
1573 /* Index I is the offset into PLT0_ENTRY of a pointer to
1574 _GLOBAL_OFFSET_TABLE_ + I * 4. The value is MINUS_ONE
1575 if there is no such pointer. */
1578 /* The template for a symbol's PLT entry. */
1581 /* The size of SYMBOL_ENTRY in bytes. */
1582 bfd_vma symbol_entry_size;
1584 /* Byte offsets of fields in SYMBOL_ENTRY. Not all fields are used
1585 on all targets. The comments by each member indicate the value
1586 that the field must hold. */
1592 instruction (instead of a constant pool
1593 entry). */
1596 /* The offset of the resolver stub from the start of SYMBOL_ENTRY. */
1597 bfd_vma symbol_resolve_offset;
1599 /* A different PLT layout which can be used for the first
1600 MAX_SHORT_PLT entries. It must share the same plt0. NULL in
1601 other cases. */
1603 };
1605 #ifdef INCLUDE_SHMEDIA
1607 /* The size in bytes of an entry in the procedure linkage table. */
1609 #define ELF_PLT_ENTRY_SIZE 64
1611 /* First entry in an absolute procedure linkage table look like this. */
1614 {
1631 };
1634 {
1651 };
1653 /* Sebsequent entries in an absolute procedure linkage table look like
1654 this. */
1657 {
1674 };
1677 {
1694 };
1696 /* Entries in a PIC procedure linkage table look like this. */
1699 {
1716 };
1719 {
1736 };
1739 {
1740 {
1741 /* Big-endian non-PIC. */
1742 elf_sh_plt0_entry_be,
1743 ELF_PLT_ENTRY_SIZE,
1745 elf_sh_plt_entry_be,
1746 ELF_PLT_ENTRY_SIZE,
1749 NULL
1750 },
1751 {
1752 /* Little-endian non-PIC. */
1753 elf_sh_plt0_entry_le,
1754 ELF_PLT_ENTRY_SIZE,
1756 elf_sh_plt_entry_le,
1757 ELF_PLT_ENTRY_SIZE,
1760 NULL
1761 },
1762 },
1763 {
1764 {
1765 /* Big-endian PIC. */
1766 elf_sh_plt0_entry_be,
1767 ELF_PLT_ENTRY_SIZE,
1769 elf_sh_pic_plt_entry_be,
1770 ELF_PLT_ENTRY_SIZE,
1773 NULL
1774 },
1775 {
1776 /* Little-endian PIC. */
1777 elf_sh_plt0_entry_le,
1778 ELF_PLT_ENTRY_SIZE,
1780 elf_sh_pic_plt_entry_le,
1781 ELF_PLT_ENTRY_SIZE,
1784 NULL
1785 },
1786 }
1787 };
1789 /* Return offset of the linker in PLT0 entry. */
1790 #define elf_sh_plt0_gotplt_offset(info) 0
1792 /* Install a 32-bit PLT field starting at ADDR, which occurs in OUTPUT_BFD.
1793 VALUE is the field's value and CODE_P is true if VALUE refers to code,
1794 not data.
1796 On SH64, each 32-bit field is loaded by a movi/shori pair. */
1801 {
1806 addr);
1811 }
1813 /* Return the type of PLT associated with ABFD. PIC_P is true if
1814 the object is position-independent. */
1818 {
1820 }
1821 #else
1822 /* The size in bytes of an entry in the procedure linkage table. */
1824 #define ELF_PLT_ENTRY_SIZE 28
1826 /* First entry in an absolute procedure linkage table look like this. */
1828 /* Note - this code has been "optimised" not to use r2. r2 is used by
1829 GCC to return the address of large structures, so it should not be
1830 corrupted here. This does mean however, that this PLT does not conform
1831 to the SH PIC ABI. That spec says that r0 contains the type of the PLT
1832 and r2 contains the GOT id. This version stores the GOT id in r0 and
1833 ignores the type. Loaders can easily detect this difference however,
1834 since the type will always be 0 or 8, and the GOT ids will always be
1835 greater than or equal to 12. */
1837 {
1850 };
1853 {
1866 };
1868 /* Sebsequent entries in an absolute procedure linkage table look like
1869 this. */
1872 {
1884 };
1887 {
1899 };
1901 /* Entries in a PIC procedure linkage table look like this. */
1904 {
1917 };
1920 {
1933 };
1936 {
1937 {
1938 /* Big-endian non-PIC. */
1939 elf_sh_plt0_entry_be,
1940 ELF_PLT_ENTRY_SIZE,
1942 elf_sh_plt_entry_be,
1943 ELF_PLT_ENTRY_SIZE,
1946 NULL
1947 },
1948 {
1949 /* Little-endian non-PIC. */
1950 elf_sh_plt0_entry_le,
1951 ELF_PLT_ENTRY_SIZE,
1953 elf_sh_plt_entry_le,
1954 ELF_PLT_ENTRY_SIZE,
1957 NULL
1958 },
1959 },
1960 {
1961 {
1962 /* Big-endian PIC. */
1963 elf_sh_plt0_entry_be,
1964 ELF_PLT_ENTRY_SIZE,
1966 elf_sh_pic_plt_entry_be,
1967 ELF_PLT_ENTRY_SIZE,
1970 NULL
1971 },
1972 {
1973 /* Little-endian PIC. */
1974 elf_sh_plt0_entry_le,
1975 ELF_PLT_ENTRY_SIZE,
1977 elf_sh_pic_plt_entry_le,
1978 ELF_PLT_ENTRY_SIZE,
1981 NULL
1982 },
1983 }
1984 };
1986 #define VXWORKS_PLT_HEADER_SIZE 12
1987 #define VXWORKS_PLT_ENTRY_SIZE 24
1990 {
1996 };
1999 {
2005 };
2008 {
2019 };
2022 {
2033 };
2036 {
2047 };
2050 {
2061 };
2064 {
2065 {
2066 /* Big-endian non-PIC. */
2067 vxworks_sh_plt0_entry_be,
2068 VXWORKS_PLT_HEADER_SIZE,
2070 vxworks_sh_plt_entry_be,
2071 VXWORKS_PLT_ENTRY_SIZE,
2074 NULL
2075 },
2076 {
2077 /* Little-endian non-PIC. */
2078 vxworks_sh_plt0_entry_le,
2079 VXWORKS_PLT_HEADER_SIZE,
2081 vxworks_sh_plt_entry_le,
2082 VXWORKS_PLT_ENTRY_SIZE,
2085 NULL
2086 },
2087 },
2088 {
2089 {
2090 /* Big-endian PIC. */
2091 NULL,
2094 vxworks_sh_pic_plt_entry_be,
2095 VXWORKS_PLT_ENTRY_SIZE,
2098 NULL
2099 },
2100 {
2101 /* Little-endian PIC. */
2102 NULL,
2105 vxworks_sh_pic_plt_entry_le,
2106 VXWORKS_PLT_ENTRY_SIZE,
2109 NULL
2110 },
2111 }
2112 };
2114 /* FDPIC PLT entries. Two unimplemented optimizations for lazy
2115 binding are to omit the lazy binding stub when linking with -z now
2116 and to move lazy binding stubs into a separate region for better
2117 cache behavior. */
2119 #define FDPIC_PLT_ENTRY_SIZE 28
2120 #define FDPIC_PLT_LAZY_OFFSET 20
2122 /* FIXME: The lazy binding stub requires a plt0 - which may need to be
2123 duplicated if it is out of range, or which can be inlined. So
2124 right now it is always inlined, which wastes a word per stub. It
2125 might be easier to handle the duplication if we put the lazy
2126 stubs separately. */
2129 {
2142 };
2145 {
2158 };
2161 {
2162 /* Big-endian PIC. */
2163 NULL,
2166 fdpic_sh_plt_entry_be,
2167 FDPIC_PLT_ENTRY_SIZE,
2169 FDPIC_PLT_LAZY_OFFSET,
2170 NULL
2171 },
2172 {
2173 /* Little-endian PIC. */
2174 NULL,
2177 fdpic_sh_plt_entry_le,
2178 FDPIC_PLT_ENTRY_SIZE,
2180 FDPIC_PLT_LAZY_OFFSET,
2181 NULL
2182 },
2183 };
2185 /* On SH2A, we can use the movi20 instruction to generate shorter PLT
2186 entries for the first 64K slots. We use the normal FDPIC PLT entry
2187 past that point; we could also use movi20s, which might be faster,
2188 but would not be any smaller. */
2190 #define FDPIC_SH2A_PLT_ENTRY_SIZE 24
2191 #define FDPIC_SH2A_PLT_LAZY_OFFSET 16
2194 {
2205 };
2208 {
2219 };
2222 /* Big-endian FDPIC, max index 64K. */
2223 NULL,
2226 fdpic_sh2a_plt_entry_be,
2227 FDPIC_SH2A_PLT_ENTRY_SIZE,
2229 FDPIC_SH2A_PLT_LAZY_OFFSET,
2230 NULL
2231 };
2234 /* Little-endian FDPIC, max index 64K. */
2235 NULL,
2238 fdpic_sh2a_plt_entry_le,
2239 FDPIC_SH2A_PLT_ENTRY_SIZE,
2241 FDPIC_SH2A_PLT_LAZY_OFFSET,
2242 NULL
2243 };
2246 {
2247 /* Big-endian PIC. */
2248 NULL,
2251 fdpic_sh_plt_entry_be,
2252 FDPIC_PLT_ENTRY_SIZE,
2254 FDPIC_PLT_LAZY_OFFSET,
2255 &fdpic_sh2a_short_plt_be
2256 },
2257 {
2258 /* Little-endian PIC. */
2259 NULL,
2262 fdpic_sh_plt_entry_le,
2263 FDPIC_PLT_ENTRY_SIZE,
2265 FDPIC_PLT_LAZY_OFFSET,
2266 &fdpic_sh2a_short_plt_le
2267 },
2268 };
2270 /* Return the type of PLT associated with ABFD. PIC_P is true if
2271 the object is position-independent. */
2275 {
2277 {
2278 /* If any input file requires SH2A we can use a shorter PLT
2279 sequence. */
2282 else
2284 }
2288 }
2290 /* Install a 32-bit PLT field starting at ADDR, which occurs in OUTPUT_BFD.
2291 VALUE is the field's value and CODE_P is true if VALUE refers to code,
2292 not data. */
2297 {
2299 }
2300 #endif
2302 /* The number of PLT entries which can use a shorter PLT, if any.
2303 Currently always 64K, since only SH-2A FDPIC uses this; a
2304 20-bit movi20 can address that many function descriptors below
2305 _GLOBAL_OFFSET_TABLE_. */
2306 #define MAX_SHORT_PLT 65536
2308 /* Return the index of the PLT entry at byte offset OFFSET. */
2310 static bfd_vma
2312 {
2317 {
2319 {
2322 }
2323 else
2325 }
2327 }
2329 /* Do the inverse operation. */
2331 static bfd_vma
2333 {
2337 {
2339 {
2342 }
2343 else
2345 }
2348 }
2350 /* The sh linker needs to keep track of the number of relocs that it
2351 decides to copy as dynamic relocs in check_relocs for each symbol.
2352 This is so that it can later discard them if they are found to be
2353 unnecessary. We store the information in a field extending the
2354 regular ELF linker hash table. */
2356 struct elf_sh_dyn_relocs
2357 {
2360 /* The input section of the reloc. */
2363 /* Total number of relocs copied for the input section. */
2364 bfd_size_type count;
2366 /* Number of pc-relative relocs copied for the input section. */
2367 bfd_size_type pc_count;
2368 };
2370 union gotref
2371 {
2372 bfd_signed_vma refcount;
2373 bfd_vma offset;
2374 };
2376 /* sh ELF linker hash entry. */
2378 struct elf_sh_link_hash_entry
2379 {
2382 #ifdef INCLUDE_SHMEDIA
2383 union
2384 {
2385 bfd_signed_vma refcount;
2386 bfd_vma offset;
2388 #endif
2390 /* Track dynamic relocs copied for this symbol. */
2393 bfd_signed_vma gotplt_refcount;
2395 /* A local function descriptor, for FDPIC. The refcount counts
2396 R_SH_FUNCDESC, R_SH_GOTOFFFUNCDESC, and R_SH_GOTOFFFUNCDESC20
2397 relocations; the PLT and GOT entry are accounted
2398 for separately. After adjust_dynamic_symbol, the offset is
2399 MINUS_ONE if there is no local descriptor (dynamic linker
2400 managed and no PLT entry, or undefined weak non-dynamic).
2401 During check_relocs we do not yet know whether the local
2402 descriptor will be canonical. */
2405 /* How many of the above refcounted relocations were R_SH_FUNCDESC,
2406 and thus require fixups or relocations. */
2407 bfd_signed_vma abs_funcdesc_refcount;
2412 };
2414 #define sh_elf_hash_entry(ent) ((struct elf_sh_link_hash_entry *)(ent))
2416 struct sh_elf_obj_tdata
2417 {
2420 /* got_type for each local got entry. */
2423 /* Function descriptor refcount and offset for each local symbol. */
2425 };
2427 #define sh_elf_tdata(abfd) \
2428 ((struct sh_elf_obj_tdata *) (abfd)->tdata.any)
2430 #define sh_elf_local_got_type(abfd) \
2431 (sh_elf_tdata (abfd)->local_got_type)
2433 #define sh_elf_local_funcdesc(abfd) \
2434 (sh_elf_tdata (abfd)->local_funcdesc)
2436 #define is_sh_elf(bfd) \
2437 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2438 && elf_tdata (bfd) != NULL \
2439 && elf_object_id (bfd) == SH_ELF_DATA)
2441 /* Override the generic function because we need to store sh_elf_obj_tdata
2442 as the specific tdata. */
2444 static bfd_boolean
2446 {
2448 SH_ELF_DATA);
2449 }
2451 /* sh ELF linker hash table. */
2453 struct elf_sh_link_hash_table
2454 {
2457 /* Short-cuts to get to dynamic linker sections. */
2469 /* The (unloaded but important) VxWorks .rela.plt.unloaded section. */
2472 /* Small local sym cache. */
2475 /* A counter or offset to track a TLS got entry. */
2476 union
2477 {
2478 bfd_signed_vma refcount;
2479 bfd_vma offset;
2482 /* The type of PLT to use. */
2485 /* True if the target system is VxWorks. */
2486 bfd_boolean vxworks_p;
2488 /* True if the target system uses FDPIC. */
2489 bfd_boolean fdpic_p;
2490 };
2492 /* Traverse an sh ELF linker hash table. */
2494 #define sh_elf_link_hash_traverse(table, func, info) \
2495 (elf_link_hash_traverse \
2496 (&(table)->root, \
2497 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
2498 (info)))
2500 /* Get the sh ELF linker hash table from a link_info structure. */
2502 #define sh_elf_hash_table(p) \
2503 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
2504 == SH_ELF_DATA ? ((struct elf_sh_link_hash_table *) ((p)->hash)) : NULL)
2506 /* Create an entry in an sh ELF linker hash table. */
2512 {
2516 /* Allocate the structure if it has not already been allocated by a
2517 subclass. */
2525 /* Call the allocation method of the superclass. */
2530 {
2533 #ifdef INCLUDE_SHMEDIA
2535 #endif
2539 }
2542 }
2544 /* Create an sh ELF linker hash table. */
2548 {
2557 sh_elf_link_hash_newfunc,
2559 SH_ELF_DATA))
2560 {
2563 }
2569 }
2571 static bfd_boolean
2574 {
2577 /* Non-FDPIC binaries do not need dynamic symbols for sections. */
2581 /* We need dynamic symbols for every section, since segments can
2582 relocate independently. */
2584 {
2587 /* If sh_type is yet undecided, assume it could be
2588 SHT_PROGBITS/SHT_NOBITS. */
2592 /* There shouldn't be section relative relocations
2593 against any other section. */
2596 }
2597 }
2599 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
2600 shortcuts to them in our hash table. */
2602 static bfd_boolean
2604 {
2622 | SEC_HAS_CONTENTS
2623 | SEC_IN_MEMORY
2632 | SEC_HAS_CONTENTS
2633 | SEC_IN_MEMORY
2634 | SEC_LINKER_CREATED
2640 /* Also create .rofixup. */
2643 | SEC_HAS_CONTENTS
2644 | SEC_IN_MEMORY
2645 | SEC_LINKER_CREATED
2652 }
2654 /* Create dynamic sections when linking against a dynamic object. */
2656 static bfd_boolean
2658 {
2666 {
2678 }
2687 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2688 .rel[a].bss sections. */
2707 {
2708 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2709 .plt section. */
2727 }
2730 bed->default_use_rela_p
2743 {
2744 /* The .dynbss section is a place to put symbols which are defined
2745 by dynamic objects, are referenced by regular objects, and are
2746 not functions. We must allocate space for them in the process
2747 image and use a R_*_COPY reloc to tell the dynamic linker to
2748 initialize them at run time. The linker script puts the .dynbss
2749 section into the .bss section of the final image. */
2756 /* The .rel[a].bss section holds copy relocs. This section is not
2757 normally needed. We need to create it here, though, so that the
2758 linker will map it to an output section. We can't just create it
2759 only if we need it, because we will not know whether we need it
2760 until we have seen all the input files, and the first time the
2761 main linker code calls BFD after examining all the input files
2762 (size_dynamic_sections) the input sections have already been
2763 mapped to the output sections. If the section turns out not to
2764 be needed, we can discard it later. We will never need this
2765 section when generating a shared object, since they do not use
2766 copy relocs. */
2768 {
2777 }
2778 }
2781 {
2784 }
2787 }
2788 \f
2789 /* Adjust a symbol defined by a dynamic object and referenced by a
2790 regular object. The current definition is in some section of the
2791 dynamic object, but we're not including those sections. We have to
2792 change the definition to something the rest of the link can
2793 understand. */
2795 static bfd_boolean
2798 {
2808 /* Make sure we know what is going on here. */
2816 /* If this is a function, put it in the procedure linkage table. We
2817 will fill in the contents of the procedure linkage table later,
2818 when we know the address of the .got section. */
2821 {
2826 {
2827 /* This case can occur if we saw a PLT reloc in an input
2828 file, but the symbol was never referred to by a dynamic
2829 object. In such a case, we don't actually need to build
2830 a procedure linkage table, and we can just do a REL32
2831 reloc instead. */
2834 }
2837 }
2838 else
2841 /* If this is a weak symbol, and there is a real definition, the
2842 processor independent code will have arranged for us to see the
2843 real definition first, and we can just use the same value. */
2845 {
2853 }
2855 /* This is a reference to a symbol defined by a dynamic object which
2856 is not a function. */
2858 /* If we are creating a shared library, we must presume that the
2859 only references to the symbol are via the global offset table.
2860 For such cases we need not do anything here; the relocations will
2861 be handled correctly by relocate_section. */
2865 /* If there are no references to this symbol that do not use the
2866 GOT, we don't need to generate a copy reloc. */
2870 /* If -z nocopyreloc was given, we won't generate them either. */
2872 {
2875 }
2879 {
2883 }
2885 /* If we didn't find any dynamic relocs in sections which needs the
2886 copy reloc, then we'll be keeping the dynamic relocs and avoiding
2887 the copy reloc. */
2889 {
2892 }
2894 /* We must allocate the symbol in our .dynbss section, which will
2895 become part of the .bss section of the executable. There will be
2896 an entry for this symbol in the .dynsym section. The dynamic
2897 object will contain position independent code, so all references
2898 from the dynamic object to this symbol will go through the global
2899 offset table. The dynamic linker will use the .dynsym entry to
2900 determine the address it must put in the global offset table, so
2901 both the dynamic object and the regular object will refer to the
2902 same memory location for the variable. */
2907 /* We must generate a R_SH_COPY reloc to tell the dynamic linker to
2908 copy the initial value out of the dynamic object and into the
2909 runtime process image. We need to remember the offset into the
2910 .rela.bss section we are going to use. */
2912 {
2919 }
2922 }
2924 /* Allocate space in .plt, .got and associated reloc sections for
2925 dynamic relocs. */
2927 static bfd_boolean
2929 {
2947 {
2948 /* The symbol has been forced local, or we have some direct got refs,
2949 so treat all the gotplt refs as got refs. */
2953 }
2959 {
2960 /* Make sure this symbol is output as a dynamic symbol.
2961 Undefined weak syms won't yet be marked as dynamic. */
2964 {
2967 }
2971 {
2975 /* If this is the first .plt entry, make room for the special
2976 first entry. */
2982 /* If this symbol is not defined in a regular file, and we are
2983 not generating a shared library, then set the symbol to this
2984 location in the .plt. This is required to make function
2985 pointers compare as equal between the normal executable and
2986 the shared library. Skip this for FDPIC, since the
2987 function's address will be the address of the canonical
2988 function descriptor. */
2990 {
2993 }
2995 /* Make room for this entry. */
3002 /* We also need to make an entry in the .got.plt section, which
3003 will be placed in the .got section by the linker script. */
3006 else
3009 /* We also need to make an entry in the .rel.plt section. */
3013 {
3014 /* VxWorks executables have a second set of relocations
3015 for each PLT entry. They go in a separate relocation
3016 section, which is processed by the kernel loader. */
3018 /* There is a relocation for the initial PLT entry:
3019 an R_SH_DIR32 relocation for _GLOBAL_OFFSET_TABLE_. */
3023 /* There are two extra relocations for each subsequent
3024 PLT entry: an R_SH_DIR32 relocation for the GOT entry,
3025 and an R_SH_DIR32 relocation for the PLT entry. */
3027 }
3028 }
3029 else
3030 {
3033 }
3034 }
3035 else
3036 {
3039 }
3042 {
3044 bfd_boolean dyn;
3047 /* Make sure this symbol is output as a dynamic symbol.
3048 Undefined weak syms won't yet be marked as dynamic. */
3051 {
3054 }
3059 /* R_SH_TLS_GD needs 2 consecutive GOT slots. */
3064 {
3065 /* No dynamic relocations required. */
3070 }
3071 /* No dynamic relocations required when IE->LE conversion happens. */
3073 ;
3074 /* R_SH_TLS_IE_32 needs one dynamic relocation if dynamic,
3075 R_SH_TLS_GD needs one if local symbol and two if global. */
3082 {
3085 else
3087 }
3097 }
3098 else
3101 #ifdef INCLUDE_SHMEDIA
3103 {
3105 bfd_boolean dyn;
3107 /* Make sure this symbol is output as a dynamic symbol.
3108 Undefined weak syms won't yet be marked as dynamic. */
3111 {
3114 }
3122 }
3123 else
3125 #endif
3127 /* Allocate space for any dynamic relocations to function
3128 descriptors, canonical or otherwise. We need to relocate the
3129 reference unless it resolves to zero, which only happens for
3130 undefined weak symbols (either non-default visibility, or when
3131 static linking). Any GOT slot is accounted for elsewhere. */
3136 {
3139 else
3142 }
3144 /* We must allocate a function descriptor if there are references to
3145 a canonical descriptor (R_SH_GOTFUNCDESC or R_SH_FUNCDESC) and
3146 the dynamic linker isn't going to allocate it. None of this
3147 applies if we already created one in .got.plt, but if the
3148 canonical function descriptor can be in this object, there
3149 won't be a PLT entry at all. */
3154 {
3155 /* Make room for this function descriptor. */
3159 /* We will need a relocation or two fixups to initialize the
3160 function descriptor, so allocate those too. */
3163 else
3165 }
3170 /* In the shared -Bsymbolic case, discard space allocated for
3171 dynamic pc-relative relocs against symbols which turn out to be
3172 defined in regular objects. For the normal shared case, discard
3173 space for pc-relative relocs that have become local due to symbol
3174 visibility changes. */
3177 {
3179 {
3183 {
3188 else
3190 }
3191 }
3194 {
3198 {
3201 else
3203 }
3204 }
3206 /* Also discard relocs on undefined weak syms with non-default
3207 visibility. */
3210 {
3214 /* Make sure undefined weak symbols are output as a dynamic
3215 symbol in PIEs. */
3218 {
3221 }
3222 }
3223 }
3224 else
3225 {
3226 /* For the non-shared case, discard space for relocs against
3227 symbols which turn out to need copy relocs or are not
3228 dynamic. */
3236 {
3237 /* Make sure this symbol is output as a dynamic symbol.
3238 Undefined weak syms won't yet be marked as dynamic. */
3241 {
3244 }
3246 /* If that succeeded, we know we'll be keeping all the
3247 relocs. */
3250 }
3254 keep: ;
3255 }
3257 /* Finally, allocate space. */
3259 {
3263 /* If we need relocations, we do not need fixups. */
3266 }
3269 }
3271 /* Find any dynamic relocs that apply to read-only sections. */
3273 static bfd_boolean
3275 {
3281 {
3285 {
3290 /* Not an error, just cut short the traversal. */
3292 }
3293 }
3295 }
3297 /* This function is called after all the input files have been read,
3298 and the input sections have been assigned to output sections.
3299 It's a convenient place to determine the PLT style. */
3301 static bfd_boolean
3303 {
3311 }
3313 /* Set the sizes of the dynamic sections. */
3315 static bfd_boolean
3318 {
3322 bfd_boolean relocs;
3333 {
3334 /* Set the contents of the .interp section to the interpreter. */
3336 {
3341 }
3342 }
3344 /* Set up .got offsets for local syms, and space for local dynamic
3345 relocs. */
3347 {
3352 bfd_size_type locsymcount;
3360 {
3367 {
3370 {
3371 /* Input section has been discarded, either because
3372 it is a copy of a linkonce section or due to
3373 linker script /DISCARD/, so we'll be discarding
3374 the relocs too. */
3375 }
3379 {
3380 /* Relocations in vxworks .tls_vars sections are
3381 handled specially by the loader. */
3382 }
3384 {
3390 /* If we need relocations, we do not need fixups. */
3393 }
3394 }
3395 }
3399 #ifdef INCLUDE_SHMEDIA
3400 /* Count datalabel local GOT. */
3402 #endif
3408 {
3413 {
3415 {
3422 else
3426 {
3428 {
3429 bfd_size_type size;
3433 size);
3437 local_funcdesc += (local_got
3439 }
3442 }
3443 }
3444 else
3447 }
3448 }
3452 {
3456 {
3458 {
3463 else
3465 }
3466 else
3468 }
3469 }
3471 }
3474 {
3475 /* Allocate 2 got entries and 1 dynamic reloc for R_SH_TLS_LD_32
3476 relocs. */
3480 }
3481 else
3484 /* Only the reserved entries should be present. For FDPIC, they go at
3485 the end of .got.plt. */
3487 {
3490 }
3492 /* Allocate global sym .plt and .got entries, and space for global
3493 sym dynamic relocs. */
3496 /* Move the reserved entries and the _GLOBAL_OFFSET_TABLE_ symbol to the
3497 end of the FDPIC .got.plt. */
3499 {
3502 }
3504 /* At the very end of the .rofixup section is a pointer to the GOT. */
3508 /* We now have determined the sizes of the various dynamic sections.
3509 Allocate memory for them. */
3512 {
3522 {
3523 /* Strip this section if we don't need it; see the
3524 comment below. */
3525 }
3527 {
3531 /* We use the reloc_count field as a counter if we need
3532 to copy relocs into the output file. */
3534 }
3535 else
3536 {
3537 /* It's not one of our sections, so don't allocate space. */
3539 }
3542 {
3543 /* If we don't need this section, strip it from the
3544 output file. This is mostly to handle .rela.bss and
3545 .rela.plt. We must create both sections in
3546 create_dynamic_sections, because they must be created
3547 before the linker maps input sections to output
3548 sections. The linker does that before
3549 adjust_dynamic_symbol is called, and it is that
3550 function which decides whether anything needs to go
3551 into these sections. */
3555 }
3560 /* Allocate memory for the section contents. We use bfd_zalloc
3561 here in case unused entries are not reclaimed before the
3562 section's contents are written out. This should not happen,
3563 but this way if it does, we get a R_SH_NONE reloc instead
3564 of garbage. */
3568 }
3571 {
3572 /* Add some entries to the .dynamic section. We fill in the
3573 values later, in sh_elf_finish_dynamic_sections, but we
3574 must add the entries now so that we get the correct size for
3575 the .dynamic section. The DT_DEBUG entry is filled in by the
3576 dynamic linker and used by the debugger. */
3577 #define add_dynamic_entry(TAG, VAL) \
3578 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3581 {
3584 }
3587 {
3593 }
3596 {
3599 }
3602 {
3609 /* If any dynamic relocs apply to a read-only section,
3610 then we need a DT_TEXTREL entry. */
3615 {
3618 }
3619 }
3623 }
3624 #undef add_dynamic_entry
3627 }
3628 \f
3629 /* Add a dynamic relocation to the SRELOC section. */
3634 {
3635 Elf_Internal_Rela outrel;
3636 bfd_vma reloc_offset;
3649 }
3651 /* Add an FDPIC read-only fixup. */
3655 {
3656 bfd_vma fixup_offset;
3661 }
3663 /* Return the offset of the generated .got section from the
3664 _GLOBAL_OFFSET_TABLE_ symbol. */
3666 static bfd_signed_vma
3668 {
3671 }
3673 /* Find the segment number in which OSEC, and output section, is
3674 located. */
3676 static unsigned
3678 {
3684 /* FIXME: Nothing ever says what this index is relative to. The kernel
3685 supplies data in terms of the number of load segments but this is
3686 a phdr index and the first phdr may not be a load segment. */
3688 }
3690 static bfd_boolean
3692 {
3697 }
3699 /* Generate the initial contents of a local function descriptor, along
3700 with any relocations or fixups required. */
3701 static bfd_boolean
3705 bfd_vma offset,
3707 bfd_vma value)
3708 {
3715 /* FIXME: The ABI says that the offset to the function goes in the
3716 descriptor, along with the segment index. We're RELA, so it could
3717 go in the reloc instead... */
3720 {
3723 }
3726 {
3730 }
3731 else
3732 {
3736 }
3739 {
3741 {
3743 offset
3750 }
3752 /* There are no dynamic relocations so fill in the final
3753 address and gp value (barring fixups). */
3758 }
3759 else
3761 offset
3770 }
3772 /* Install a 20-bit movi20 field starting at ADDR, which occurs in OUTPUT_BFD.
3773 VALUE is the field's value. Return bfd_reloc_ok if successful or an error
3774 otherwise. */
3776 static bfd_reloc_status_type
3780 {
3783 bfd_reloc_status_type r;
3799 }
3801 /* Relocate an SH ELF section. */
3803 static bfd_boolean
3809 {
3821 bfd_boolean is_vxworks_tls;
3829 {
3835 }
3845 else
3850 else
3853 /* We have to handle relocations in vxworks .tls_vars sections
3854 specially, because the dynamic loader is 'weird'. */
3862 {
3869 bfd_vma relocation;
3871 bfd_reloc_status_type r;
3873 bfd_vma off;
3881 /* Many of the relocs are only used for relaxing, and are
3882 handled entirely by the relaxation code. */
3903 {
3906 }
3910 /* For relocs that aren't partial_inplace, we get the addend from
3911 the relocation. */
3921 {
3925 symname = bfd_elf_string_from_elf_section
3933 /* A local symbol never has STO_SH5_ISA32, so we don't need
3934 datalabel processing here. Make sure this does not change
3935 without notice. */
3943 /* Handled below. */
3944 ;
3946 {
3947 /* This is a relocatable link. We don't have to change
3948 anything, unless the reloc is against a section symbol,
3949 in which case we have to adjust according to where the
3950 section symbol winds up in the output section. */
3952 {
3954 {
3955 /* For relocations with the addend in the
3956 relocation, we need just to update the addend.
3957 All real relocs are of type partial_inplace; this
3958 code is mostly for completeness. */
3962 }
3964 /* Relocs of type partial_inplace need to pick up the
3965 contents in the contents and add the offset resulting
3966 from the changed location of the section symbol.
3967 Using _bfd_final_link_relocate (e.g. goto
3968 final_link_relocate) here would be wrong, because
3969 relocations marked pc_relative would get the current
3970 location subtracted, and we must only do that at the
3971 final link. */
3973 sec->output_offset
3977 }
3980 }
3982 {
3985 }
3988 {
3992 {
3998 }
4002 addend =
4008 }
4009 }
4010 else
4011 {
4012 /* FIXME: Ought to make use of the RELOC_FOR_GLOBAL_SYMBOL macro. */
4019 {
4020 #ifdef INCLUDE_SHMEDIA
4021 /* If the reference passes a symbol marked with
4022 STT_DATALABEL, then any STO_SH5_ISA32 on the final value
4023 doesn't count. */
4025 #endif
4027 }
4030 {
4031 bfd_boolean dyn;
4035 /* In these cases, we don't need the relocation value.
4036 We check specially because in some obscure cases
4037 sec->output_section will be NULL. */
4064 /* The cases above are those in which relocation is
4065 overwritten in the switch block below. The cases
4066 below are those in which we must defer relocation
4067 to run-time, because we can't resolve absolute
4068 addresses when creating a shared library. */
4077 /* DWARF will emit R_SH_DIR32 relocations in its
4078 sections against symbols defined externally
4079 in shared libraries. We can't do anything
4080 with them here. */
4083 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4084 sections because such sections are not SEC_ALLOC and
4085 thus ld.so will not process them. */
4092 ;
4097 /* A STO_SH5_ISA32 causes a "bitor 1" to the
4098 symbol value, unless we've seen
4099 STT_DATALABEL on the way to it. */
4104 input_section,
4107 {
4110 input_bfd,
4111 input_section,
4116 }
4117 }
4119 ;
4122 ;
4124 {
4131 }
4132 }
4141 /* Check for inter-segment relocations in FDPIC files. Most
4142 relocations connect the relocation site to the location of
4143 the target symbol, but there are some exceptions below. */
4148 else
4152 {
4153 final_link_relocate:
4154 /* COFF relocs don't use the addend. The addend is used for
4155 R_SH_DIR32 to be compatible with other compilers. */
4167 /* If the reloc is against the start of this section, then
4168 the assembler has already taken care of it and the reloc
4169 is here only to assist in relaxing. If the reloc is not
4170 against the start of this section, then it's against an
4171 external symbol and we must deal with it ourselves. */
4174 {
4181 {
4186 }
4188 {
4195 }
4198 }
4203 #ifdef INCLUDE_SHMEDIA
4207 #endif
4221 {
4229 }
4236 {
4244 }
4250 {
4258 }
4264 {
4272 }
4277 #ifdef INCLUDE_SHMEDIA
4282 #endif
4289 && !is_vxworks_tls
4292 {
4293 Elf_Internal_Rela outrel;
4297 /* When generating a shared object, these relocations
4298 are copied into the output file to be resolved at run
4299 time. */
4302 {
4303 sreloc = _bfd_elf_get_dynamic_reloc_section
4307 }
4325 {
4328 outrel.r_addend
4332 }
4333 #ifdef INCLUDE_SHMEDIA
4338 {
4342 }
4343 #endif
4348 {
4356 outrel.r_addend
4361 }
4362 else
4363 {
4364 /* h->dynindx may be -1 if this symbol was marked to
4365 become local. */
4369 {
4372 }
4373 else
4374 {
4377 }
4379 outrel.r_addend
4383 }
4391 /* If this reloc is against an external symbol, we do
4392 not want to fiddle with the addend. Otherwise, we
4393 need to include the symbol value so that it becomes
4394 an addend for the dynamic reloc. */
4397 }
4401 {
4402 bfd_vma offset;
4408 {
4411 input_bfd,
4412 input_section,
4414 symname);
4416 }
4427 }
4428 /* We don't want warnings for non-NULL tests on undefined weak
4429 symbols. */
4431 && h
4437 #ifdef INCLUDE_SHMEDIA
4444 #endif
4445 /* Relocation is to the entry for this symbol in the
4446 procedure linkage table. */
4457 /* Relocation is to the entry for this symbol in the global
4458 offset table extension for the procedure linkage table. */
4466 #ifdef GOT_BIAS
4468 #endif
4472 force_got:
4475 #ifdef INCLUDE_SHMEDIA
4482 #endif
4483 /* Relocation is to the entry for this symbol in the global
4484 offset table. */
4491 {
4492 bfd_boolean dyn;
4495 #ifdef INCLUDE_SHMEDIA
4497 {
4502 }
4503 #endif
4512 {
4513 /* This is actually a static link, or it is a
4514 -Bsymbolic link and the symbol is defined
4515 locally, or the symbol was forced to be local
4516 because of a version file. We must initialize
4517 this entry in the global offset table. Since the
4518 offset must always be a multiple of 4, we use the
4519 least significant bit to record whether we have
4520 initialized it already.
4522 When doing a dynamic link, we create a .rela.got
4523 relocation entry to initialize the value. This
4524 is done in the finish_dynamic_symbol routine. */
4527 else
4528 {
4531 #ifdef INCLUDE_SHMEDIA
4533 {
4538 }
4539 else
4540 #endif
4543 /* If we initialize the GOT entry here with a valid
4544 symbol address, also add a fixup. */
4553 }
4554 }
4557 }
4558 else
4559 {
4560 #ifdef INCLUDE_SHMEDIA
4562 {
4570 }
4571 else
4572 {
4573 #endif
4578 #ifdef INCLUDE_SHMEDIA
4579 }
4580 #endif
4582 /* The offset must always be a multiple of 4. We use
4583 the least significant bit to record whether we have
4584 already generated the necessary reloc. */
4587 else
4588 {
4592 {
4593 Elf_Internal_Rela outrel;
4597 {
4601 }
4607 {
4608 int dynindx
4613 }
4614 else
4615 {
4618 }
4622 }
4631 #ifdef INCLUDE_SHMEDIA
4634 else
4635 #endif
4637 }
4640 }
4642 #ifdef GOT_BIAS
4644 #endif
4647 {
4652 }
4653 else
4658 #ifdef INCLUDE_SHMEDIA
4663 #endif
4664 /* GOTOFF relocations are relative to _GLOBAL_OFFSET_TABLE_, which
4665 we place at the start of the .got.plt section. This is the same
4666 as the start of the output .got section, unless there are function
4667 descriptors in front of it. */
4674 #ifdef GOT_BIAS
4676 #endif
4681 {
4686 }
4687 else
4691 #ifdef INCLUDE_SHMEDIA
4696 #endif
4697 /* Use global offset table as symbol value. */
4702 #ifdef GOT_BIAS
4704 #endif
4711 #ifdef INCLUDE_SHMEDIA
4716 #endif
4717 /* Relocation is to the entry for this symbol in the
4718 procedure linkage table. */
4720 /* Resolve a PLT reloc against a local symbol directly,
4721 without using the procedure linkage table. */
4725 /* We don't want to warn on calls to undefined weak symbols,
4726 as calls to them must be protected by non-NULL tests
4727 anyway, and unprotected calls would invoke undefined
4728 behavior. */
4736 {
4737 /* We didn't make a PLT entry for this symbol. This
4738 happens when statically linking PIC code, or when
4739 using -Bsymbolic. */
4741 }
4749 #ifdef INCLUDE_SHMEDIA
4750 relocation++;
4751 #endif
4757 /* Relocation is to the canonical function descriptor for this
4758 symbol, possibly via the GOT. Initialize the GOT
4759 entry and function descriptor if necessary. */
4763 {
4766 bfd_vma reloc_offset;
4773 /* FIXME: See what FRV does for global symbols in the
4774 executable, with --export-dynamic. Do they need ld.so
4775 to allocate official descriptors? See what this code
4776 does. */
4782 {
4785 }
4786 else
4787 {
4792 else
4793 {
4796 }
4800 {
4803 }
4804 }
4809 /* Undefined weak symbol which will not be dynamically
4810 resolved later; leave it at zero. */
4814 {
4815 /* If the symbol needs a non-local function descriptor
4816 but binds locally (i.e., its visibility is
4817 protected), emit a dynamic relocation decayed to
4818 section+offset. This is an optimization; the dynamic
4819 linker would resolve our function descriptor request
4820 to our copy of the function anyway. */
4825 }
4827 {
4828 /* If the symbol is dynamic and there will be dynamic
4829 symbol resolution because we are or are linked with a
4830 shared library, emit a FUNCDESC relocation such that
4831 the dynamic linker will allocate the function
4832 descriptor. */
4835 }
4836 else
4837 {
4838 bfd_vma offset;
4840 /* Otherwise, we know we have a private function
4841 descriptor, so reference it directly. */
4847 {
4851 {
4856 }
4857 }
4858 else
4859 {
4866 {
4872 }
4873 }
4876 }
4879 {
4880 bfd_vma offset;
4884 {
4887 input_bfd,
4888 input_section,
4890 symname);
4892 }
4899 offset
4902 }
4905 {
4906 bfd_vma offset;
4910 {
4916 }
4919 {
4922 }
4929 offset
4935 {
4938 }
4939 else
4940 {
4943 }
4944 }
4948 funcdesc_leave_zero:
4950 {
4955 else
4958 funcdesc_done_got:
4961 #ifdef GOT_BIAS
4963 #endif
4964 }
4966 {
4971 }
4972 else
4974 }
4979 /* FIXME: See R_SH_FUNCDESC comment about global symbols in the
4980 executable and --export-dynamic. If such symbols get
4981 ld.so-allocated descriptors we can not use R_SH_GOTOFFFUNCDESC
4982 for them. */
4991 {
4992 _bfd_error_handler
4997 }
4998 else
4999 {
5000 bfd_vma offset;
5002 /* Otherwise, we know we have a private function
5003 descriptor, so reference it directly. */
5005 {
5009 {
5014 }
5015 }
5016 else
5017 {
5024 {
5030 }
5031 }
5034 }
5038 #ifdef GOT_BIAS
5040 #endif
5043 {
5048 }
5049 else
5053 {
5068 }
5079 {
5085 }
5091 {
5092 bfd_vma offset;
5096 {
5097 /* GD->LE transition:
5098 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5099 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5100 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5101 We change it into:
5102 mov.l 1f,r4; stc gbr,r0; add r4,r0; nop;
5103 nop; nop; ...
5104 1: .long x@TPOFF; 2: .long __tls_get_addr@PLT; 3:. */
5108 /* Size of GD instructions is 16 or 18. */
5112 {
5116 }
5135 }
5136 else
5137 {
5140 /* IE->LE transition:
5141 mov.l 1f,r0; stc gbr,rN; mov.l @(r0,r12),rM;
5142 bra 2f; add ...; .align 2; 1: x@GOTTPOFF; 2:
5143 We change it into:
5144 mov.l .Ln,rM; stc gbr,rN; nop; ...;
5145 1: x@TPOFF; 2:. */
5149 /* Size of IE instructions is 10 or 12. */
5153 {
5157 }
5168 }
5173 }
5180 else
5181 {
5186 }
5188 /* Relocate R_SH_TLS_IE_32 directly when statically linking. */
5191 {
5198 }
5202 else
5203 {
5204 Elf_Internal_Rela outrel;
5209 {
5212 }
5219 else
5223 R_SH_TLS_TPOFF32);
5226 else
5234 {
5236 {
5240 }
5241 else
5242 {
5244 R_SH_TLS_DTPOFF32);
5250 }
5251 }
5255 else
5257 }
5264 else
5265 {
5266 bfd_vma offset;
5269 /* GD->IE transition:
5270 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5271 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5272 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5273 We change it into:
5274 mov.l 1f,r0; stc gbr,r4; mov.l @(r0,r12),r0; add r4,r0;
5275 nop; nop; bra 3f; nop; .align 2;
5276 1: .long x@TPOFF; 2:...; 3:. */
5280 /* Size of GD instructions is 16 or 18. */
5284 {
5288 }
5292 /* Replace mov.l 1f,R4 with mov.l 1f,r0. */
5316 }
5326 {
5327 bfd_vma offset;
5330 /* LD->LE transition:
5331 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5332 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5333 1: .long x$TLSLD; 2: .long __tls_get_addr@PLT; 3:
5334 We change it into:
5335 stc gbr,r0; nop; nop; nop;
5336 nop; nop; bra 3f; ...; 3:. */
5340 /* Size of LD instructions is 16 or 18. */
5344 {
5348 }
5370 }
5378 else
5379 {
5380 Elf_Internal_Rela outrel;
5395 }
5406 else
5413 {
5415 Elf_Internal_Rela outrel;
5421 {
5425 }
5428 {
5429 sreloc = _bfd_elf_get_dynamic_reloc_section
5433 }
5437 else
5446 else
5453 }
5454 }
5456 relocation_done:
5459 {
5460 /* We don't want duplicate errors for undefined symbols. */
5462 {
5464 {
5469 }
5470 else
5474 }
5477 }
5480 {
5482 {
5487 {
5492 else
5493 {
5494 name = (bfd_elf_string_from_elf_section
5500 }
5506 }
5508 }
5509 }
5510 }
5513 }
5515 /* This is a version of bfd_generic_get_relocated_section_contents
5516 which uses sh_elf_relocate_section. */
5523 bfd_boolean relocatable,
5525 {
5533 /* We only need to handle the case of relaxing, or of having a
5534 particular set of section contents, specially. */
5539 relocatable,
5540 symbols);
5549 {
5552 bfd_size_type amt;
5554 internal_relocs = (_bfd_elf_link_read_relocs
5561 {
5569 }
5579 {
5588 else
5592 }
5606 }
5610 error_return:
5620 }
5622 /* Return the base VMA address which should be subtracted from real addresses
5623 when resolving @dtpoff relocation.
5624 This is PT_TLS segment p_vaddr. */
5626 static bfd_vma
5628 {
5629 /* If tls_sec is NULL, we should have signalled an error already. */
5633 }
5635 /* Return the relocation value for R_SH_TLS_TPOFF32.. */
5637 static bfd_vma
5639 {
5640 /* If tls_sec is NULL, we should have signalled an error already. */
5643 /* SH TLS ABI is variant I and static TLS block start just after tcbhead
5644 structure which has 2 pointer fields. */
5648 }
5656 {
5659 {
5663 }
5666 }
5668 /* Update the got entry reference counts for the section being removed. */
5670 static bfd_boolean
5673 {
5692 {
5696 #ifdef INCLUDE_SHMEDIA
5698 #endif
5702 {
5710 {
5711 #ifdef INCLUDE_SHMEDIA
5713 #endif
5715 }
5719 {
5720 /* Everything must go for SEC. */
5723 }
5724 }
5728 {
5739 #ifdef INCLUDE_SHMEDIA
5754 #endif
5760 {
5761 #ifdef INCLUDE_SHMEDIA
5763 {
5768 }
5769 else
5770 #endif
5773 }
5775 {
5776 #ifdef INCLUDE_SHMEDIA
5778 {
5781 }
5782 else
5783 #endif
5786 }
5795 /* Fall through. */
5801 else
5809 /* Fall thru */
5814 /* Fall thru */
5817 #ifdef INCLUDE_SHMEDIA
5822 #endif
5824 {
5827 }
5831 #ifdef INCLUDE_SHMEDIA
5838 #endif
5840 {
5844 {
5848 }
5849 #ifdef INCLUDE_SHMEDIA
5851 {
5854 }
5855 #endif
5858 }
5860 {
5861 #ifdef INCLUDE_SHMEDIA
5863 {
5866 }
5867 else
5868 #endif
5871 }
5876 }
5877 }
5880 }
5882 /* Copy the extra info we tack onto an elf_link_hash_entry. */
5884 static void
5888 {
5895 {
5897 {
5901 /* Add reloc counts against the indirect sym to the direct sym
5902 list. Merge any entries against the same section. */
5904 {
5909 {
5914 }
5917 }
5919 }
5923 }
5926 #ifdef INCLUDE_SHMEDIA
5929 #endif
5937 {
5940 }
5944 {
5945 /* If called to transfer flags for a weakdef during processing
5946 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
5947 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
5952 }
5953 else
5955 }
5957 static int
5960 {
5965 {
5973 }
5976 }
5978 /* Look through the relocs for a section during the first phase.
5979 Since we don't do .gots or .plts, we just need to consider the
5980 virtual table relocs for gc. */
5982 static bfd_boolean
5985 {
6011 {
6014 #ifdef INCLUDE_SHMEDIA
6016 #endif
6023 else
6024 {
6028 {
6029 #ifdef INCLUDE_SHMEDIA
6031 #endif
6033 }
6035 /* PR15323, ref flags aren't set for references in the same
6036 object. */
6038 }
6052 {
6059 {
6062 {
6069 }
6070 }
6072 }
6074 /* Some relocs require a global offset table. */
6076 {
6078 {
6080 /* This may require an rofixup. */
6094 #ifdef INCLUDE_SHMEDIA
6115 #endif
6127 }
6128 }
6131 {
6132 /* This relocation describes the C++ object vtable hierarchy.
6133 Reconstruct it for later use during GC. */
6139 /* This relocation describes which C++ vtable entries are actually
6140 used. Record for later use during GC. */
6152 /* FALLTHROUGH */
6153 force_got:
6157 #ifdef INCLUDE_SHMEDIA
6164 #endif
6168 {
6182 }
6185 {
6186 #ifdef INCLUDE_SHMEDIA
6188 {
6193 }
6194 else
6195 #endif
6198 }
6199 else
6200 {
6203 /* This is a global offset table entry for a local
6204 symbol. */
6207 {
6208 bfd_size_type size;
6212 #ifdef INCLUDE_SHMEDIA
6213 /* Reserve space for both the datalabel and
6214 codelabel local GOT offsets. */
6216 #endif
6223 #ifdef INCLUDE_SHMEDIA
6224 /* Take care of both the datalabel and codelabel local
6225 GOT offsets. */
6228 #else
6231 #endif
6232 }
6233 #ifdef INCLUDE_SHMEDIA
6236 else
6237 #endif
6240 }
6242 /* If a TLS symbol is accessed using IE at least once,
6243 there is no point to use dynamic model for it. */
6246 {
6249 else
6250 {
6261 else
6266 }
6267 }
6270 {
6273 else
6275 }
6287 {
6290 abfd);
6292 }
6295 {
6298 /* We need a function descriptor for a local symbol. */
6301 {
6302 bfd_size_type size;
6305 #ifdef INCLUDE_SHMEDIA
6306 /* Count datalabel local GOT. */
6308 #endif
6313 }
6317 {
6320 else
6322 }
6323 }
6324 else
6325 {
6330 /* If there is a function descriptor reference, then
6331 there should not be any non-FDPIC references. */
6334 {
6339 else
6343 }
6344 }
6348 #ifdef INCLUDE_SHMEDIA
6355 #endif
6356 /* If this is a local symbol, we resolve it directly without
6357 creating a procedure linkage table entry. */
6373 #ifdef INCLUDE_SHMEDIA
6378 #endif
6379 /* This symbol requires a procedure linkage table entry. We
6380 actually build the entry in adjust_dynamic_symbol,
6381 because this might be a case of linking PIC code which is
6382 never referenced by a dynamic object, in which case we
6383 don't need to generate a procedure linkage table entry
6384 after all. */
6386 /* If this is a local symbol, we resolve it directly without
6387 creating a procedure linkage table entry. */
6400 #ifdef INCLUDE_SHMEDIA
6405 #endif
6407 {
6410 }
6412 /* If we are creating a shared library, and this is a reloc
6413 against a global symbol, or a non PC relative reloc
6414 against a local symbol, then we need to copy the reloc
6415 into the shared library. However, if we are linking with
6416 -Bsymbolic, we do not need to copy a reloc against a
6417 global symbol which is defined in an object we are
6418 including in the link (i.e., DEF_REGULAR is set). At
6419 this point we have not seen all the input files, so it is
6420 possible that DEF_REGULAR is not set now but will be set
6421 later (it is never cleared). We account for that
6422 possibility below by storing information in the
6423 dyn_relocs field of the hash table entry. A similar
6424 situation occurs when creating shared libraries and symbol
6425 visibility changes render the symbol local.
6427 If on the other hand, we are creating an executable, we
6428 may need to keep relocations for symbols satisfied by a
6429 dynamic library if we manage to avoid copy relocs for the
6430 symbol. */
6443 {
6450 /* When creating a shared object, we must copy these
6451 reloc types into the output file. We create a reloc
6452 section in dynobj and make room for this reloc. */
6454 {
6455 sreloc = _bfd_elf_make_dynamic_reloc_section
6460 }
6462 /* If this is a global symbol, we count the number of
6463 relocations we need for this symbol. */
6466 else
6467 {
6468 /* Track dynamic relocs needed for local syms too. */
6484 }
6488 {
6498 }
6502 #ifdef INCLUDE_SHMEDIA
6507 #endif
6508 )
6510 }
6512 /* Allocate the fixup regardless of whether we need a relocation.
6513 If we end up generating the relocation, we'll unallocate the
6514 fixup. */
6523 {
6526 abfd);
6528 }
6533 /* Nothing to do. */
6538 }
6539 }
6542 }
6544 #ifndef sh_elf_set_mach_from_flags
6547 static bfd_boolean
6549 {
6561 }
6564 /* Reverse table lookup for sh_ef_bfd_table[].
6565 Given a bfd MACH value from archures.c
6566 return the equivalent ELF flags from the table.
6567 Return -1 if no match is found. */
6569 int
6571 {
6578 /* shouldn't get here */
6582 }
6585 #ifndef sh_elf_set_private_flags
6586 /* Function to keep SH specific file flags. */
6588 static bfd_boolean
6590 {
6597 }
6600 #ifndef sh_elf_copy_private_data
6601 /* Copy backend specific data from one object module to another */
6603 static bfd_boolean
6605 {
6606 /* Copy object attributes. */
6613 }
6616 #ifndef sh_elf_merge_private_data
6618 /* This function returns the ELF architecture number that
6619 corresponds to the given arch_sh* flags. */
6621 int
6623 {
6628 }
6630 /* This routine initialises the elf flags when required and
6631 calls sh_merge_bfd_arch() to check dsp/fpu compatibility. */
6633 static bfd_boolean
6635 {
6642 {
6643 /* This happens when ld starts out with a 'blank' output file. */
6649 }
6652 {
6655 ibfd);
6658 }
6665 {
6667 ibfd);
6670 }
6673 }
6676 /* Override the generic function because we need to store sh_elf_obj_tdata
6677 as the specific tdata. We set also the machine architecture from flags
6678 here. */
6680 static bfd_boolean
6682 {
6688 }
6690 /* Finish up dynamic symbol handling. We set the contents of various
6691 dynamic sections here. */
6693 static bfd_boolean
6697 {
6705 {
6710 bfd_vma plt_index;
6711 bfd_vma got_offset;
6712 Elf_Internal_Rela rel;
6716 /* This symbol has an entry in the procedure linkage table. Set
6717 it up. */
6726 /* Get the index in the procedure linkage table which
6727 corresponds to this symbol. This is the index of this symbol
6728 in all the symbols for which we are making plt entries. The
6729 first entry in the procedure linkage table is reserved. */
6736 /* Get the offset into the .got table of the entry that
6737 corresponds to this function. */
6739 /* The offset must be relative to the GOT symbol, twelve bytes
6740 before the end of .got.plt. Each descriptor is eight
6741 bytes. */
6743 else
6744 /* Each .got entry is 4 bytes. The first three are
6745 reserved. */
6748 #ifdef GOT_BIAS
6751 #endif
6753 /* Fill in the entry in the procedure linkage table. */
6759 {
6761 {
6762 bfd_reloc_status_type r;
6768 }
6769 else
6774 }
6775 else
6776 {
6787 {
6791 /* Divide the PLT into groups. The first group contains
6792 REACHABLE_PLTS entries and the other groups contain
6793 PLTS_PER_4K entries. Entries in the first group can
6794 branch directly to .plt; those in later groups branch
6795 to the last element of the previous group. */
6796 /* ??? It would be better to create multiple copies of
6797 the common resolver stub. */
6806 else
6810 /* Install the 'bra' with this offset. */
6816 }
6817 else
6823 }
6825 /* Make got_offset relative to the start of .got.plt. */
6826 #ifdef GOT_BIAS
6829 #endif
6840 /* Fill in the entry in the global offset table. */
6853 /* Fill in the entry in the .rela.plt section. */
6859 else
6862 #ifdef GOT_BIAS
6864 #endif
6869 {
6870 /* Create the .rela.plt.unloaded relocations for this PLT entry.
6871 Begin by pointing LOC to the first such relocation. */
6875 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation
6876 for the PLT entry's pointer to the .got.plt entry. */
6886 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for
6887 the .got.plt entry, which initially points to .plt. */
6894 }
6897 {
6898 /* Mark the symbol as undefined, rather than as defined in
6899 the .plt section. Leave the value alone. */
6901 }
6902 }
6908 {
6911 Elf_Internal_Rela rel;
6914 /* This symbol has an entry in the global offset table. Set it
6915 up. */
6925 /* If this is a static link, or it is a -Bsymbolic link and the
6926 symbol is defined locally or was forced to be local because
6927 of a version file, we just want to emit a RELATIVE reloc.
6928 The entry in the global offset table will already have been
6929 initialized in the relocate_section function. */
6932 {
6934 {
6936 int dynindx
6942 }
6943 else
6944 {
6949 }
6950 }
6951 else
6952 {
6956 }
6961 }
6963 #ifdef INCLUDE_SHMEDIA
6964 {
6969 {
6972 Elf_Internal_Rela rel;
6975 /* This symbol has a datalabel entry in the global offset table.
6976 Set it up. */
6986 /* If this is a static link, or it is a -Bsymbolic link and the
6987 symbol is defined locally or was forced to be local because
6988 of a version file, we just want to emit a RELATIVE reloc.
6989 The entry in the global offset table will already have been
6990 initialized in the relocate_section function. */
6993 {
6995 {
6997 int dynindx
7003 }
7004 else
7005 {
7010 }
7011 }
7012 else
7013 {
7018 }
7023 }
7024 }
7025 #endif
7028 {
7030 Elf_Internal_Rela rel;
7033 /* This symbol needs a copy reloc. Set it up. */
7049 }
7051 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. On VxWorks,
7052 _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
7053 ".got" section. */
7059 }
7061 /* Finish up the dynamic sections. */
7063 static bfd_boolean
7065 {
7078 {
7087 {
7088 Elf_Internal_Dyn dyn;
7090 #ifdef INCLUDE_SHMEDIA
7092 #endif
7097 {
7104 #ifdef INCLUDE_SHMEDIA
7111 get_sym:
7113 {
7119 {
7122 }
7123 }
7125 #endif
7150 /* My reading of the SVR4 ABI indicates that the
7151 procedure linkage table relocs (DT_JMPREL) should be
7152 included in the overall relocs (DT_RELA). This is
7153 what Solaris does. However, UnixWare can not handle
7154 that case. Therefore, we override the DT_RELASZ entry
7155 here to make it not include the JMPREL relocs. Since
7156 the linker script arranges for .rela.plt to follow all
7157 other relocation sections, we don't have to worry
7158 about changing the DT_RELA entry. */
7160 {
7163 }
7166 }
7167 }
7169 /* Fill in the first entry in the procedure linkage table. */
7172 {
7188 {
7189 /* Finalize the .rela.plt.unloaded contents. */
7190 Elf_Internal_Rela rel;
7193 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for the
7194 first PLT entry's pointer to _GLOBAL_OFFSET_TABLE_ + 8. */
7204 /* Fix up the remaining .rela.plt.unloaded relocations.
7205 They may have the wrong symbol index for _G_O_T_ or
7206 _P_L_T_ depending on the order in which symbols were
7207 output. */
7209 {
7210 /* The PLT entry's pointer to the .got.plt slot. */
7213 R_SH_DIR32);
7217 /* The .got.plt slot's pointer to .plt. */
7220 R_SH_DIR32);
7223 }
7224 }
7226 /* UnixWare sets the entsize of .plt to 4, although that doesn't
7227 really seem like the right value. */
7229 }
7230 }
7232 /* Fill in the first three entries in the global offset table. */
7234 {
7237 else
7243 }
7248 /* At the very end of the .rofixup section is a pointer to the GOT. */
7250 {
7258 /* Make sure we allocated and generated the same number of fixups. */
7260 }
7271 }
7273 static enum elf_reloc_type_class
7277 {
7279 {
7288 }
7289 }
7291 #if !defined SH_TARGET_ALREADY_DEFINED
7292 /* Support for Linux core dump NOTE sections. */
7294 static bfd_boolean
7296 {
7301 {
7306 /* pr_cursig */
7309 /* pr_pid */
7312 /* pr_reg */
7317 }
7319 /* Make a ".reg/999" section. */
7322 }
7324 static bfd_boolean
7326 {
7328 {
7337 }
7339 /* Note that for some reason, a spurious space is tacked
7340 onto the end of the args in some (at least one anyway)
7341 implementations, so strip it off if it exists. */
7343 {
7349 }
7352 }
7356 /* Return address for Ith PLT stub in section PLT, for relocation REL
7357 or (bfd_vma) -1 if it should not be included. */
7359 static bfd_vma
7362 {
7367 }
7369 /* Decide whether to attempt to turn absptr or lsda encodings in
7370 shared libraries into pcrel within the given input section. */
7372 static bfd_boolean
7376 {
7379 /* We can't use PC-relative encodings in FDPIC binaries, in general. */
7384 }
7386 /* Adjust the contents of an eh_frame_hdr section before they're output. */
7388 static bfd_byte
7394 {
7411 == (sh_elf_osec_to_segment
7420 }
7422 #if !defined SH_TARGET_ALREADY_DEFINED
7423 #define TARGET_BIG_SYM bfd_elf32_sh_vec
7425 #define TARGET_LITTLE_SYM bfd_elf32_shl_vec
7427 #endif
7429 #define ELF_ARCH bfd_arch_sh
7430 #define ELF_TARGET_ID SH_ELF_DATA
7431 #define ELF_MACHINE_CODE EM_SH
7432 #ifdef __QNXTARGET__
7433 #define ELF_MAXPAGESIZE 0x1000
7434 #else
7435 #define ELF_MAXPAGESIZE 0x80
7436 #endif
7440 #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup
7441 #define bfd_elf32_bfd_reloc_name_lookup \
7442 sh_elf_reloc_name_lookup
7443 #define elf_info_to_howto sh_elf_info_to_howto
7444 #define bfd_elf32_bfd_relax_section sh_elf_relax_section
7445 #define elf_backend_relocate_section sh_elf_relocate_section
7446 #define bfd_elf32_bfd_get_relocated_section_contents \
7447 sh_elf_get_relocated_section_contents
7448 #define bfd_elf32_mkobject sh_elf_mkobject
7449 #define elf_backend_object_p sh_elf_object_p
7450 #define bfd_elf32_bfd_set_private_bfd_flags \
7451 sh_elf_set_private_flags
7452 #define bfd_elf32_bfd_copy_private_bfd_data \
7453 sh_elf_copy_private_data
7454 #define bfd_elf32_bfd_merge_private_bfd_data \
7455 sh_elf_merge_private_data
7457 #define elf_backend_gc_mark_hook sh_elf_gc_mark_hook
7458 #define elf_backend_gc_sweep_hook sh_elf_gc_sweep_hook
7459 #define elf_backend_check_relocs sh_elf_check_relocs
7460 #define elf_backend_copy_indirect_symbol \
7461 sh_elf_copy_indirect_symbol
7462 #define elf_backend_create_dynamic_sections \
7463 sh_elf_create_dynamic_sections
7464 #define bfd_elf32_bfd_link_hash_table_create \
7465 sh_elf_link_hash_table_create
7466 #define elf_backend_adjust_dynamic_symbol \
7467 sh_elf_adjust_dynamic_symbol
7468 #define elf_backend_always_size_sections \
7469 sh_elf_always_size_sections
7470 #define elf_backend_size_dynamic_sections \
7471 sh_elf_size_dynamic_sections
7472 #define elf_backend_omit_section_dynsym sh_elf_omit_section_dynsym
7473 #define elf_backend_finish_dynamic_symbol \
7474 sh_elf_finish_dynamic_symbol
7475 #define elf_backend_finish_dynamic_sections \
7476 sh_elf_finish_dynamic_sections
7477 #define elf_backend_reloc_type_class sh_elf_reloc_type_class
7478 #define elf_backend_plt_sym_val sh_elf_plt_sym_val
7479 #define elf_backend_can_make_relative_eh_frame \
7480 sh_elf_use_relative_eh_frame
7481 #define elf_backend_can_make_lsda_relative_eh_frame \
7482 sh_elf_use_relative_eh_frame
7483 #define elf_backend_encode_eh_address \
7484 sh_elf_encode_eh_address
7486 #define elf_backend_stack_align 8
7487 #define elf_backend_can_gc_sections 1
7488 #define elf_backend_can_refcount 1
7489 #define elf_backend_want_got_plt 1
7490 #define elf_backend_plt_readonly 1
7491 #define elf_backend_want_plt_sym 0
7492 #define elf_backend_got_header_size 12
7494 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
7498 /* NetBSD support. */
7499 #undef TARGET_BIG_SYM
7500 #define TARGET_BIG_SYM bfd_elf32_shnbsd_vec
7501 #undef TARGET_BIG_NAME
7503 #undef TARGET_LITTLE_SYM
7504 #define TARGET_LITTLE_SYM bfd_elf32_shlnbsd_vec
7505 #undef TARGET_LITTLE_NAME
7507 #undef ELF_MAXPAGESIZE
7508 #define ELF_MAXPAGESIZE 0x10000
7509 #undef ELF_COMMONPAGESIZE
7510 #undef elf_symbol_leading_char
7511 #define elf_symbol_leading_char 0
7512 #undef elf32_bed
7513 #define elf32_bed elf32_sh_nbsd_bed
7518 /* Linux support. */
7519 #undef TARGET_BIG_SYM
7520 #define TARGET_BIG_SYM bfd_elf32_shblin_vec
7521 #undef TARGET_BIG_NAME
7523 #undef TARGET_LITTLE_SYM
7524 #define TARGET_LITTLE_SYM bfd_elf32_shlin_vec
7525 #undef TARGET_LITTLE_NAME
7527 #undef ELF_COMMONPAGESIZE
7528 #define ELF_COMMONPAGESIZE 0x1000
7530 #undef elf_backend_grok_prstatus
7531 #define elf_backend_grok_prstatus elf32_shlin_grok_prstatus
7532 #undef elf_backend_grok_psinfo
7533 #define elf_backend_grok_psinfo elf32_shlin_grok_psinfo
7534 #undef elf32_bed
7535 #define elf32_bed elf32_sh_lin_bed
7540 /* FDPIC support. */
7541 #undef TARGET_BIG_SYM
7542 #define TARGET_BIG_SYM bfd_elf32_shbfd_vec
7543 #undef TARGET_BIG_NAME
7545 #undef TARGET_LITTLE_SYM
7546 #define TARGET_LITTLE_SYM bfd_elf32_shfd_vec
7547 #undef TARGET_LITTLE_NAME
7550 #undef elf32_bed
7551 #define elf32_bed elf32_sh_fd_bed
7555 #undef elf_backend_modify_program_headers
7557 /* VxWorks support. */
7558 #undef TARGET_BIG_SYM
7559 #define TARGET_BIG_SYM bfd_elf32_shvxworks_vec
7560 #undef TARGET_BIG_NAME
7562 #undef TARGET_LITTLE_SYM
7563 #define TARGET_LITTLE_SYM bfd_elf32_shlvxworks_vec
7564 #undef TARGET_LITTLE_NAME
7566 #undef elf32_bed
7567 #define elf32_bed elf32_sh_vxworks_bed
7569 #undef elf_backend_want_plt_sym
7570 #define elf_backend_want_plt_sym 1
7571 #undef elf_symbol_leading_char
7573 #define elf_backend_want_got_underscore 1
7574 #undef elf_backend_grok_prstatus
7575 #undef elf_backend_grok_psinfo
7576 #undef elf_backend_add_symbol_hook
7577 #define elf_backend_add_symbol_hook elf_vxworks_add_symbol_hook
7578 #undef elf_backend_link_output_symbol_hook
7579 #define elf_backend_link_output_symbol_hook \
7580 elf_vxworks_link_output_symbol_hook
7581 #undef elf_backend_emit_relocs
7582 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
7583 #undef elf_backend_final_write_processing
7584 #define elf_backend_final_write_processing \
7585 elf_vxworks_final_write_processing
7586 #undef ELF_MAXPAGESIZE
7587 #define ELF_MAXPAGESIZE 0x1000
7588 #undef ELF_COMMONPAGESIZE