| blob | bde565ee4694a28805db66997fd33c4c58807c78 |
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 Free Software Foundation, Inc.
4 Contributed by Ian Lance Taylor, Cygnus Support.
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. */
34 static bfd_reloc_status_type sh_elf_reloc
36 static bfd_reloc_status_type sh_elf_ignore_reloc
38 static bfd_boolean sh_elf_relax_delete_bytes
40 static bfd_boolean sh_elf_align_loads
42 #ifndef SH64_ELF
43 static bfd_boolean sh_elf_swap_insns
45 #endif
46 static int sh_elf_optimized_tls_reloc
48 static bfd_vma dtpoff_base
50 static bfd_vma tpoff
53 /* The name of the dynamic interpreter. This is put in the .interp
54 section. */
58 /* FDPIC binaries have a default 128K stack. */
59 #define DEFAULT_STACK_SIZE 0x20000
61 #define MINUS_ONE ((bfd_vma) 0 - 1)
63 /* Decide whether a reference to a symbol can be resolved locally or
64 not. If the symbol is protected, we want the local address, but
65 its function descriptor must be assigned by the dynamic linker. */
66 #define SYMBOL_FUNCDESC_LOCAL(INFO, H) \
67 (SYMBOL_REFERENCES_LOCAL (INFO, H) \
68 || ! elf_hash_table (INFO)->dynamic_sections_created)
69 \f
70 #define SH_PARTIAL32 TRUE
71 #define SH_SRC_MASK32 0xffffffff
72 #define SH_ELF_RELOC sh_elf_reloc
74 {
76 };
78 #define SH_PARTIAL32 FALSE
79 #define SH_SRC_MASK32 0
80 #define SH_ELF_RELOC bfd_elf_generic_reloc
82 {
84 };
85 \f
86 /* Return true if OUTPUT_BFD is a VxWorks object. */
88 static bfd_boolean
90 {
91 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
97 #else
99 #endif
100 }
102 /* Return true if OUTPUT_BFD is an FDPIC object. */
104 static bfd_boolean
106 {
107 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
113 #else
115 #endif
116 }
118 /* Return the howto table for ABFD. */
122 {
126 }
128 static bfd_reloc_status_type
133 {
138 bfd_signed_vma x;
141 /* Sanity check the address. */
145 /* We require the start and end relocations to be processed consecutively -
146 although we allow then to be processed forwards or backwards. */
148 {
152 }
160 /* Get the symbol_section contents. */
162 {
165 else
166 {
169 {
173 }
174 }
175 }
176 #define IS_PPI(PTR) ((bfd_get_16 (input_bfd, (PTR)) & 0xfc00) == 0xf800)
179 {
186 }
187 /* Calculate the start / end values to load into rs / re minus four -
188 so that will cancel out the four we would otherwise have to add to
189 addr to get the value to subtract in order to get relative addressing. */
191 {
194 }
195 else
196 {
204 }
225 }
227 /* This function is used for normal relocs. This used to be like the COFF
228 function, and is almost certainly incorrect for other ELF targets. */
230 static bfd_reloc_status_type
234 {
236 bfd_vma sym_value;
244 {
245 /* Partial linking--do nothing. */
248 }
250 /* Almost all relocs have to do with relaxing. If any work must be
251 done for them, it has been done in sh_relax_section. */
261 else
267 {
278 + addr
291 }
294 }
296 /* This function is used for relocs which are only used for relaxing,
297 which the linker should otherwise ignore. */
299 static bfd_reloc_status_type
305 {
309 }
311 /* This structure is used to map BFD reloc codes to SH ELF relocs. */
313 struct elf_reloc_map
314 {
315 bfd_reloc_code_real_type bfd_reloc_val;
317 };
319 /* An array mapping BFD reloc codes to SH ELF relocs. */
322 {
370 #ifdef INCLUDE_SHMEDIA
421 };
423 /* Given a BFD reloc code, return the howto structure for the
424 corresponding SH ELF reloc. */
428 {
432 {
435 }
438 }
442 {
446 {
450 i++)
454 }
455 else
456 {
460 i++)
464 }
467 }
469 /* Given an ELF reloc, fill in the howto field of a relent. */
471 static void
473 {
487 }
488 \f
489 /* This function handles relaxing for SH ELF. See the corresponding
490 function in coff-sh.c for a description of what this does. FIXME:
491 There is a lot of duplication here between this code and the COFF
492 specific code. The format of relocs and symbols is wound deeply
493 into this code, but it would still be better if the duplication
494 could be eliminated somehow. Note in particular that although both
495 functions use symbols like R_SH_CODE, those symbols have different
496 values; in coff-sh.c they come from include/coff/sh.h, whereas here
497 they come from enum elf_sh_reloc_type in include/elf/sh.h. */
499 static bfd_boolean
502 {
505 bfd_boolean have_code;
517 #ifdef INCLUDE_SHMEDIA
520 {
522 }
523 #endif
527 internal_relocs = (_bfd_elf_link_read_relocs
537 {
541 bfd_signed_vma foff;
549 /* Get the section contents. */
551 {
554 else
555 {
558 }
559 }
561 /* The r_addend field of the R_SH_USES reloc will point us to
562 the register load. The 4 is because the r_addend field is
563 computed as though it were a jump offset, which are based
564 from 4 bytes after the jump instruction. */
567 {
569 abfd,
572 }
575 /* If the instruction is not mov.l NN,rN, we don't know what to
576 do. */
578 {
583 }
585 /* Get the address from which the register is being loaded. The
586 displacement in the mov.l instruction is quadrupled. It is a
587 displacement from four bytes after the movl instruction, but,
588 before adding in the PC address, two least significant bits
589 of the PC are cleared. We assume that the section is aligned
590 on a four byte boundary. */
595 {
600 }
602 /* Get the reloc for the address from which the register is
603 being loaded. This reloc will tell us which function is
604 actually being called. */
610 {
615 }
617 /* Read this BFD's symbols if we haven't done so already. */
619 {
627 }
629 /* Get the value of the symbol referred to by the reloc. */
631 {
632 /* A local symbol. */
638 {
643 }
648 }
649 else
650 {
659 {
660 /* This appears to be a reference to an undefined
661 symbol. Just ignore it--it will be caught by the
662 regular reloc processing. */
664 }
669 }
673 else
676 /* See if this function call can be shortened. */
677 foff = (symval
682 /* A branch to an address beyond ours might be increased by an
683 .align that doesn't move when bytes behind us are deleted.
684 So, we add some slop in this calculation to allow for
685 that. */
687 {
688 /* After all that work, we can't shorten this function call. */
690 }
692 /* Shorten the function call. */
694 /* For simplicity of coding, we are going to modify the section
695 contents, the section relocs, and the BFD symbol table. We
696 must tell the rest of the code not to free up this
697 information. It would be possible to instead create a table
698 of changes which have to be made, as is done in coff-mips.c;
699 that would be more work, but would require less memory when
700 the linker is run. */
706 /* Replace the jsr with a bsr. */
708 /* Change the R_SH_USES reloc into an R_SH_IND12W reloc, and
709 replace the jsr with a bsr. */
711 /* We used to test (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
712 here, but that only checks if the symbol is an external symbol,
713 not if the symbol is in a different section. Besides, we need
714 a consistent meaning for the relocation, so we just assume here that
715 the value of the symbol is not available. */
717 /* We can't fully resolve this yet, because the external
718 symbol value may be changed by future relaxing. We let
719 the final link phase handle it. */
724 /* When we calculated the symbol "value" we had an offset in the
725 DIR32's word in memory (we read and add it above). However,
726 the jsr we create does NOT have this offset encoded, so we
727 have to add it to the addend to preserve it. */
730 /* See if there is another R_SH_USES reloc referring to the same
731 register load. */
737 {
738 /* Some other function call depends upon this register load,
739 and we have not yet converted that function call.
740 Indeed, we may never be able to convert it. There is
741 nothing else we can do at this point. */
743 }
745 /* Look for a R_SH_COUNT reloc on the location where the
746 function address is stored. Do this before deleting any
747 bytes, to avoid confusion about the address. */
753 /* Delete the register load. */
757 /* That will change things, so, just in case it permits some
758 other function call to come within range, we should relax
759 again. Note that this is not required, and it may be slow. */
762 /* Now check whether we got a COUNT reloc. */
764 {
769 }
771 /* The number of uses is stored in the r_addend field. We've
772 just deleted one. */
774 {
776 abfd,
779 }
783 /* If there are no more uses, we can delete the address. Reload
784 the address from irelfn, in case it was changed by the
785 previous call to sh_elf_relax_delete_bytes. */
787 {
790 }
792 /* We've done all we can with that function call. */
793 }
795 /* Look for load and store instructions that we can align on four
796 byte boundaries. */
799 {
800 bfd_boolean swapped;
802 /* Get the section contents. */
804 {
807 else
808 {
811 }
812 }
819 {
823 }
824 }
828 {
831 else
832 {
833 /* Cache the symbols for elf_link_input_bfd. */
835 }
836 }
840 {
843 else
844 {
845 /* Cache the section contents for elf_link_input_bfd. */
847 }
848 }
856 error_return:
868 }
870 /* Delete some bytes from a section while relaxing. FIXME: There is a
871 lot of duplication between this function and sh_relax_delete_bytes
872 in coff-sh.c. */
874 static bfd_boolean
877 {
883 bfd_vma toaddr;
897 /* The deletion must stop at the next ALIGN reloc for an aligment
898 power larger than the number of bytes we are deleting. */
906 {
910 {
914 }
915 }
917 /* Actually delete the bytes. */
922 else
923 {
926 #define NOP_OPCODE (0x0009)
931 }
933 /* Adjust all the relocs. */
935 {
941 bfd_boolean overflow;
943 /* Get the new reloc address. */
951 /* See if this reloc was for the bytes we have deleted, in which
952 case we no longer care about it. Don't delete relocs which
953 represent addresses, though. */
963 /* If this is a PC relative reloc, see if the range it covers
964 includes the bytes we have deleted. */
966 {
977 }
980 {
986 /* If this reloc is against a symbol defined in this
987 section, and the symbol will not be adjusted below, we
988 must check the addend to see it will put the value in
989 range to be adjusted, and hence must be changed. */
991 {
996 {
997 bfd_vma val;
1000 {
1005 }
1006 else
1007 {
1011 }
1012 }
1013 }
1027 {
1028 /* This has been made by previous relaxation. Since the
1029 relocation will be against an external symbol, the
1030 final relocation will just do the right thing. */
1032 }
1033 else
1034 {
1039 /* The addend will be against the section symbol, thus
1040 for adjusting the addend, the relevant start is the
1041 start of the section.
1042 N.B. If we want to abandon in-place changes here and
1043 test directly using symbol + addend, we have to take into
1044 account that the addend has already been adjusted by -4. */
1047 }
1063 /* These relocs types represent
1064 .word L2-L1
1065 The r_addend field holds the difference between the reloc
1066 address and L1. That is the start of the reloc, and
1067 adding in the contents gives us the top. We must adjust
1068 both the r_offset field and the section contents.
1069 N.B. in gas / coff bfd, the elf bfd r_addend is called r_offset,
1070 and the elf bfd r_offset is called r_vaddr. */
1088 else
1100 }
1110 else
1114 {
1118 {
1142 else
1143 {
1146 }
1174 }
1177 {
1183 }
1184 }
1187 }
1189 /* Look through all the other sections. If there contain any IMM32
1190 relocs against internal symbols which we are not going to adjust
1191 below, we may need to adjust the addends. */
1193 {
1203 /* We always cache the relocs. Perhaps, if info->keep_memory is
1204 FALSE, we should free them, if we are permitted to, when we
1205 leave sh_coff_relax_section. */
1206 internal_relocs = (_bfd_elf_link_read_relocs
1214 {
1215 /* Dwarf line numbers use R_SH_SWITCH32 relocs. */
1217 {
1219 bfd_signed_vma voff;
1222 {
1225 else
1226 {
1227 /* We always cache the section contents.
1228 Perhaps, if info->keep_memory is FALSE, we
1229 should free them, if we are permitted to,
1230 when we leave sh_coff_relax_section. */
1232 {
1236 }
1239 }
1240 }
1243 start
1246 /* STOP is in a different section, so it won't change. */
1263 }
1276 {
1277 bfd_vma val;
1280 {
1283 else
1284 {
1285 /* We always cache the section contents.
1286 Perhaps, if info->keep_memory is FALSE, we
1287 should free them, if we are permitted to,
1288 when we leave sh_coff_relax_section. */
1290 {
1294 }
1297 }
1298 }
1305 }
1306 }
1307 }
1309 /* Adjust the local symbols defined in this section. */
1312 {
1317 }
1319 /* Now adjust the global symbols defined in this section. */
1325 {
1332 {
1334 }
1335 }
1337 /* See if we can move the ALIGN reloc forward. We have adjusted
1338 r_offset for it already. */
1340 {
1347 {
1348 /* Tail recursion. */
1351 }
1352 }
1355 }
1357 /* Look for loads and stores which we can align to four byte
1358 boundaries. This is like sh_align_loads in coff-sh.c. */
1360 static bfd_boolean
1365 {
1369 bfd_size_type amt;
1375 /* Get all the addresses with labels on them. */
1383 {
1385 {
1388 }
1389 }
1391 /* Note that the assembler currently always outputs relocs in
1392 address order. If that ever changes, this code will need to sort
1393 the label values and the relocs. */
1398 {
1411 else
1418 }
1424 error_return:
1428 }
1430 #ifndef SH64_ELF
1431 /* Swap two SH instructions. This is like sh_swap_insns in coff-sh.c. */
1433 static bfd_boolean
1436 {
1441 /* Swap the instructions themselves. */
1447 /* Adjust all reloc addresses. */
1450 {
1454 /* There are a few special types of relocs that we don't want to
1455 adjust. These relocs do not apply to the instruction itself,
1456 but are only associated with the address. */
1464 /* If an R_SH_USES reloc points to one of the addresses being
1465 swapped, we must adjust it. It would be incorrect to do this
1466 for a jump, though, since we want to execute both
1467 instructions after the jump. (We have avoided swapping
1468 around a label, so the jump will not wind up executing an
1469 instruction it shouldn't). */
1471 {
1472 bfd_vma off;
1479 }
1482 {
1485 }
1487 {
1490 }
1491 else
1495 {
1498 bfd_boolean overflow;
1503 {
1527 /* This reloc ignores the least significant 3 bits of
1528 the program counter before adding in the offset.
1529 This means that if ADDR is at an even address, the
1530 swap will not affect the offset. If ADDR is an at an
1531 odd address, then the instruction will be crossing a
1532 four byte boundary, and must be adjusted. */
1534 {
1541 }
1544 }
1547 {
1553 }
1554 }
1555 }
1558 }
1560 \f
1561 /* Describes one of the various PLT styles. */
1563 struct elf_sh_plt_info
1564 {
1565 /* The template for the first PLT entry, or NULL if there is no special
1566 first entry. */
1569 /* The size of PLT0_ENTRY in bytes, or 0 if PLT0_ENTRY is NULL. */
1570 bfd_vma plt0_entry_size;
1572 /* Index I is the offset into PLT0_ENTRY of a pointer to
1573 _GLOBAL_OFFSET_TABLE_ + I * 4. The value is MINUS_ONE
1574 if there is no such pointer. */
1577 /* The template for a symbol's PLT entry. */
1580 /* The size of SYMBOL_ENTRY in bytes. */
1581 bfd_vma symbol_entry_size;
1583 /* Byte offsets of fields in SYMBOL_ENTRY. Not all fields are used
1584 on all targets. The comments by each member indicate the value
1585 that the field must hold. */
1591 instruction (instead of a constant pool
1592 entry). */
1595 /* The offset of the resolver stub from the start of SYMBOL_ENTRY. */
1596 bfd_vma symbol_resolve_offset;
1598 /* A different PLT layout which can be used for the first
1599 MAX_SHORT_PLT entries. It must share the same plt0. NULL in
1600 other cases. */
1602 };
1604 #ifdef INCLUDE_SHMEDIA
1606 /* The size in bytes of an entry in the procedure linkage table. */
1608 #define ELF_PLT_ENTRY_SIZE 64
1610 /* First entry in an absolute procedure linkage table look like this. */
1613 {
1630 };
1633 {
1650 };
1652 /* Sebsequent entries in an absolute procedure linkage table look like
1653 this. */
1656 {
1673 };
1676 {
1693 };
1695 /* Entries in a PIC procedure linkage table look like this. */
1698 {
1715 };
1718 {
1735 };
1738 {
1739 {
1740 /* Big-endian non-PIC. */
1741 elf_sh_plt0_entry_be,
1742 ELF_PLT_ENTRY_SIZE,
1744 elf_sh_plt_entry_be,
1745 ELF_PLT_ENTRY_SIZE,
1748 NULL
1749 },
1750 {
1751 /* Little-endian non-PIC. */
1752 elf_sh_plt0_entry_le,
1753 ELF_PLT_ENTRY_SIZE,
1755 elf_sh_plt_entry_le,
1756 ELF_PLT_ENTRY_SIZE,
1759 NULL
1760 },
1761 },
1762 {
1763 {
1764 /* Big-endian PIC. */
1765 elf_sh_plt0_entry_be,
1766 ELF_PLT_ENTRY_SIZE,
1768 elf_sh_pic_plt_entry_be,
1769 ELF_PLT_ENTRY_SIZE,
1772 NULL
1773 },
1774 {
1775 /* Little-endian PIC. */
1776 elf_sh_plt0_entry_le,
1777 ELF_PLT_ENTRY_SIZE,
1779 elf_sh_pic_plt_entry_le,
1780 ELF_PLT_ENTRY_SIZE,
1783 NULL
1784 },
1785 }
1786 };
1788 /* Return offset of the linker in PLT0 entry. */
1789 #define elf_sh_plt0_gotplt_offset(info) 0
1791 /* Install a 32-bit PLT field starting at ADDR, which occurs in OUTPUT_BFD.
1792 VALUE is the field's value and CODE_P is true if VALUE refers to code,
1793 not data.
1795 On SH64, each 32-bit field is loaded by a movi/shori pair. */
1800 {
1805 addr);
1810 }
1812 /* Return the type of PLT associated with ABFD. PIC_P is true if
1813 the object is position-independent. */
1817 {
1819 }
1820 #else
1821 /* The size in bytes of an entry in the procedure linkage table. */
1823 #define ELF_PLT_ENTRY_SIZE 28
1825 /* First entry in an absolute procedure linkage table look like this. */
1827 /* Note - this code has been "optimised" not to use r2. r2 is used by
1828 GCC to return the address of large structures, so it should not be
1829 corrupted here. This does mean however, that this PLT does not conform
1830 to the SH PIC ABI. That spec says that r0 contains the type of the PLT
1831 and r2 contains the GOT id. This version stores the GOT id in r0 and
1832 ignores the type. Loaders can easily detect this difference however,
1833 since the type will always be 0 or 8, and the GOT ids will always be
1834 greater than or equal to 12. */
1836 {
1849 };
1852 {
1865 };
1867 /* Sebsequent entries in an absolute procedure linkage table look like
1868 this. */
1871 {
1883 };
1886 {
1898 };
1900 /* Entries in a PIC procedure linkage table look like this. */
1903 {
1916 };
1919 {
1932 };
1935 {
1936 {
1937 /* Big-endian non-PIC. */
1938 elf_sh_plt0_entry_be,
1939 ELF_PLT_ENTRY_SIZE,
1941 elf_sh_plt_entry_be,
1942 ELF_PLT_ENTRY_SIZE,
1945 NULL
1946 },
1947 {
1948 /* Little-endian non-PIC. */
1949 elf_sh_plt0_entry_le,
1950 ELF_PLT_ENTRY_SIZE,
1952 elf_sh_plt_entry_le,
1953 ELF_PLT_ENTRY_SIZE,
1956 NULL
1957 },
1958 },
1959 {
1960 {
1961 /* Big-endian PIC. */
1962 elf_sh_plt0_entry_be,
1963 ELF_PLT_ENTRY_SIZE,
1965 elf_sh_pic_plt_entry_be,
1966 ELF_PLT_ENTRY_SIZE,
1969 NULL
1970 },
1971 {
1972 /* Little-endian PIC. */
1973 elf_sh_plt0_entry_le,
1974 ELF_PLT_ENTRY_SIZE,
1976 elf_sh_pic_plt_entry_le,
1977 ELF_PLT_ENTRY_SIZE,
1980 NULL
1981 },
1982 }
1983 };
1985 #define VXWORKS_PLT_HEADER_SIZE 12
1986 #define VXWORKS_PLT_ENTRY_SIZE 24
1989 {
1995 };
1998 {
2004 };
2007 {
2018 };
2021 {
2032 };
2035 {
2046 };
2049 {
2060 };
2063 {
2064 {
2065 /* Big-endian non-PIC. */
2066 vxworks_sh_plt0_entry_be,
2067 VXWORKS_PLT_HEADER_SIZE,
2069 vxworks_sh_plt_entry_be,
2070 VXWORKS_PLT_ENTRY_SIZE,
2073 NULL
2074 },
2075 {
2076 /* Little-endian non-PIC. */
2077 vxworks_sh_plt0_entry_le,
2078 VXWORKS_PLT_HEADER_SIZE,
2080 vxworks_sh_plt_entry_le,
2081 VXWORKS_PLT_ENTRY_SIZE,
2084 NULL
2085 },
2086 },
2087 {
2088 {
2089 /* Big-endian PIC. */
2090 NULL,
2093 vxworks_sh_pic_plt_entry_be,
2094 VXWORKS_PLT_ENTRY_SIZE,
2097 NULL
2098 },
2099 {
2100 /* Little-endian PIC. */
2101 NULL,
2104 vxworks_sh_pic_plt_entry_le,
2105 VXWORKS_PLT_ENTRY_SIZE,
2108 NULL
2109 },
2110 }
2111 };
2113 /* FDPIC PLT entries. Two unimplemented optimizations for lazy
2114 binding are to omit the lazy binding stub when linking with -z now
2115 and to move lazy binding stubs into a separate region for better
2116 cache behavior. */
2118 #define FDPIC_PLT_ENTRY_SIZE 28
2119 #define FDPIC_PLT_LAZY_OFFSET 20
2121 /* FIXME: The lazy binding stub requires a plt0 - which may need to be
2122 duplicated if it is out of range, or which can be inlined. So
2123 right now it is always inlined, which wastes a word per stub. It
2124 might be easier to handle the duplication if we put the lazy
2125 stubs separately. */
2128 {
2141 };
2144 {
2157 };
2160 {
2161 /* Big-endian PIC. */
2162 NULL,
2165 fdpic_sh_plt_entry_be,
2166 FDPIC_PLT_ENTRY_SIZE,
2168 FDPIC_PLT_LAZY_OFFSET,
2169 NULL
2170 },
2171 {
2172 /* Little-endian PIC. */
2173 NULL,
2176 fdpic_sh_plt_entry_le,
2177 FDPIC_PLT_ENTRY_SIZE,
2179 FDPIC_PLT_LAZY_OFFSET,
2180 NULL
2181 },
2182 };
2184 /* On SH2A, we can use the movi20 instruction to generate shorter PLT
2185 entries for the first 64K slots. We use the normal FDPIC PLT entry
2186 past that point; we could also use movi20s, which might be faster,
2187 but would not be any smaller. */
2189 #define FDPIC_SH2A_PLT_ENTRY_SIZE 24
2190 #define FDPIC_SH2A_PLT_LAZY_OFFSET 16
2193 {
2204 };
2207 {
2218 };
2221 /* Big-endian FDPIC, max index 64K. */
2222 NULL,
2225 fdpic_sh2a_plt_entry_be,
2226 FDPIC_SH2A_PLT_ENTRY_SIZE,
2228 FDPIC_SH2A_PLT_LAZY_OFFSET,
2229 NULL
2230 };
2233 /* Little-endian FDPIC, max index 64K. */
2234 NULL,
2237 fdpic_sh2a_plt_entry_le,
2238 FDPIC_SH2A_PLT_ENTRY_SIZE,
2240 FDPIC_SH2A_PLT_LAZY_OFFSET,
2241 NULL
2242 };
2245 {
2246 /* Big-endian PIC. */
2247 NULL,
2250 fdpic_sh_plt_entry_be,
2251 FDPIC_PLT_ENTRY_SIZE,
2253 FDPIC_PLT_LAZY_OFFSET,
2254 &fdpic_sh2a_short_plt_be
2255 },
2256 {
2257 /* Little-endian PIC. */
2258 NULL,
2261 fdpic_sh_plt_entry_le,
2262 FDPIC_PLT_ENTRY_SIZE,
2264 FDPIC_PLT_LAZY_OFFSET,
2265 &fdpic_sh2a_short_plt_le
2266 },
2267 };
2269 /* Return the type of PLT associated with ABFD. PIC_P is true if
2270 the object is position-independent. */
2274 {
2276 {
2277 /* If any input file requires SH2A we can use a shorter PLT
2278 sequence. */
2281 else
2283 }
2287 }
2289 /* Install a 32-bit PLT field starting at ADDR, which occurs in OUTPUT_BFD.
2290 VALUE is the field's value and CODE_P is true if VALUE refers to code,
2291 not data. */
2296 {
2298 }
2299 #endif
2301 /* The number of PLT entries which can use a shorter PLT, if any.
2302 Currently always 64K, since only SH-2A FDPIC uses this; a
2303 20-bit movi20 can address that many function descriptors below
2304 _GLOBAL_OFFSET_TABLE_. */
2305 #define MAX_SHORT_PLT 65536
2307 /* Return the index of the PLT entry at byte offset OFFSET. */
2309 static bfd_vma
2311 {
2316 {
2318 {
2321 }
2322 else
2324 }
2326 }
2328 /* Do the inverse operation. */
2330 static bfd_vma
2332 {
2336 {
2338 {
2341 }
2342 else
2344 }
2347 }
2349 /* The sh linker needs to keep track of the number of relocs that it
2350 decides to copy as dynamic relocs in check_relocs for each symbol.
2351 This is so that it can later discard them if they are found to be
2352 unnecessary. We store the information in a field extending the
2353 regular ELF linker hash table. */
2355 struct elf_sh_dyn_relocs
2356 {
2359 /* The input section of the reloc. */
2362 /* Total number of relocs copied for the input section. */
2363 bfd_size_type count;
2365 /* Number of pc-relative relocs copied for the input section. */
2366 bfd_size_type pc_count;
2367 };
2369 union gotref
2370 {
2371 bfd_signed_vma refcount;
2372 bfd_vma offset;
2373 };
2375 /* sh ELF linker hash entry. */
2377 struct elf_sh_link_hash_entry
2378 {
2381 #ifdef INCLUDE_SHMEDIA
2382 union
2383 {
2384 bfd_signed_vma refcount;
2385 bfd_vma offset;
2387 #endif
2389 /* Track dynamic relocs copied for this symbol. */
2392 bfd_signed_vma gotplt_refcount;
2394 /* A local function descriptor, for FDPIC. The refcount counts
2395 R_SH_FUNCDESC, R_SH_GOTOFFFUNCDESC, and R_SH_GOTOFFFUNCDESC20
2396 relocations; the PLT and GOT entry are accounted
2397 for separately. After adjust_dynamic_symbol, the offset is
2398 MINUS_ONE if there is no local descriptor (dynamic linker
2399 managed and no PLT entry, or undefined weak non-dynamic).
2400 During check_relocs we do not yet know whether the local
2401 descriptor will be canonical. */
2404 /* How many of the above refcounted relocations were R_SH_FUNCDESC,
2405 and thus require fixups or relocations. */
2406 bfd_signed_vma abs_funcdesc_refcount;
2411 };
2413 #define sh_elf_hash_entry(ent) ((struct elf_sh_link_hash_entry *)(ent))
2415 struct sh_elf_obj_tdata
2416 {
2419 /* got_type for each local got entry. */
2422 /* Function descriptor refcount and offset for each local symbol. */
2424 };
2426 #define sh_elf_tdata(abfd) \
2427 ((struct sh_elf_obj_tdata *) (abfd)->tdata.any)
2429 #define sh_elf_local_got_type(abfd) \
2430 (sh_elf_tdata (abfd)->local_got_type)
2432 #define sh_elf_local_funcdesc(abfd) \
2433 (sh_elf_tdata (abfd)->local_funcdesc)
2435 #define is_sh_elf(bfd) \
2436 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2437 && elf_tdata (bfd) != NULL \
2438 && elf_object_id (bfd) == SH_ELF_DATA)
2440 /* Override the generic function because we need to store sh_elf_obj_tdata
2441 as the specific tdata. */
2443 static bfd_boolean
2445 {
2447 SH_ELF_DATA);
2448 }
2450 /* sh ELF linker hash table. */
2452 struct elf_sh_link_hash_table
2453 {
2456 /* Short-cuts to get to dynamic linker sections. */
2468 /* The (unloaded but important) VxWorks .rela.plt.unloaded section. */
2471 /* Small local sym cache. */
2474 /* A counter or offset to track a TLS got entry. */
2475 union
2476 {
2477 bfd_signed_vma refcount;
2478 bfd_vma offset;
2481 /* The type of PLT to use. */
2484 /* True if the target system is VxWorks. */
2485 bfd_boolean vxworks_p;
2487 /* True if the target system uses FDPIC. */
2488 bfd_boolean fdpic_p;
2489 };
2491 /* Traverse an sh ELF linker hash table. */
2493 #define sh_elf_link_hash_traverse(table, func, info) \
2494 (elf_link_hash_traverse \
2495 (&(table)->root, \
2496 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
2497 (info)))
2499 /* Get the sh ELF linker hash table from a link_info structure. */
2501 #define sh_elf_hash_table(p) \
2502 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
2503 == SH_ELF_DATA ? ((struct elf_sh_link_hash_table *) ((p)->hash)) : NULL)
2505 /* Create an entry in an sh ELF linker hash table. */
2511 {
2515 /* Allocate the structure if it has not already been allocated by a
2516 subclass. */
2524 /* Call the allocation method of the superclass. */
2529 {
2532 #ifdef INCLUDE_SHMEDIA
2534 #endif
2538 }
2541 }
2543 /* Create an sh ELF linker hash table. */
2547 {
2556 sh_elf_link_hash_newfunc,
2558 SH_ELF_DATA))
2559 {
2562 }
2579 }
2581 static bfd_boolean
2584 {
2587 /* Non-FDPIC binaries do not need dynamic symbols for sections. */
2591 /* We need dynamic symbols for every section, since segments can
2592 relocate independently. */
2594 {
2597 /* If sh_type is yet undecided, assume it could be
2598 SHT_PROGBITS/SHT_NOBITS. */
2602 /* There shouldn't be section relative relocations
2603 against any other section. */
2606 }
2607 }
2609 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
2610 shortcuts to them in our hash table. */
2612 static bfd_boolean
2614 {
2632 | SEC_HAS_CONTENTS
2633 | SEC_IN_MEMORY
2642 | SEC_HAS_CONTENTS
2643 | SEC_IN_MEMORY
2644 | SEC_LINKER_CREATED
2650 /* Also create .rofixup. */
2653 | SEC_HAS_CONTENTS
2654 | SEC_IN_MEMORY
2655 | SEC_LINKER_CREATED
2662 }
2664 /* Create dynamic sections when linking against a dynamic object. */
2666 static bfd_boolean
2668 {
2676 {
2688 }
2697 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2698 .rel[a].bss sections. */
2717 {
2718 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2719 .plt section. */
2737 }
2751 {
2754 flagword secflags;
2758 {
2774 }
2775 }
2778 {
2779 /* The .dynbss section is a place to put symbols which are defined
2780 by dynamic objects, are referenced by regular objects, and are
2781 not functions. We must allocate space for them in the process
2782 image and use a R_*_COPY reloc to tell the dynamic linker to
2783 initialize them at run time. The linker script puts the .dynbss
2784 section into the .bss section of the final image. */
2791 /* The .rel[a].bss section holds copy relocs. This section is not
2792 normally needed. We need to create it here, though, so that the
2793 linker will map it to an output section. We can't just create it
2794 only if we need it, because we will not know whether we need it
2795 until we have seen all the input files, and the first time the
2796 main linker code calls BFD after examining all the input files
2797 (size_dynamic_sections) the input sections have already been
2798 mapped to the output sections. If the section turns out not to
2799 be needed, we can discard it later. We will never need this
2800 section when generating a shared object, since they do not use
2801 copy relocs. */
2803 {
2812 }
2813 }
2816 {
2819 }
2822 }
2823 \f
2824 /* Adjust a symbol defined by a dynamic object and referenced by a
2825 regular object. The current definition is in some section of the
2826 dynamic object, but we're not including those sections. We have to
2827 change the definition to something the rest of the link can
2828 understand. */
2830 static bfd_boolean
2833 {
2843 /* Make sure we know what is going on here. */
2851 /* If this is a function, put it in the procedure linkage table. We
2852 will fill in the contents of the procedure linkage table later,
2853 when we know the address of the .got section. */
2856 {
2861 {
2862 /* This case can occur if we saw a PLT reloc in an input
2863 file, but the symbol was never referred to by a dynamic
2864 object. In such a case, we don't actually need to build
2865 a procedure linkage table, and we can just do a REL32
2866 reloc instead. */
2869 }
2872 }
2873 else
2876 /* If this is a weak symbol, and there is a real definition, the
2877 processor independent code will have arranged for us to see the
2878 real definition first, and we can just use the same value. */
2880 {
2888 }
2890 /* This is a reference to a symbol defined by a dynamic object which
2891 is not a function. */
2893 /* If we are creating a shared library, we must presume that the
2894 only references to the symbol are via the global offset table.
2895 For such cases we need not do anything here; the relocations will
2896 be handled correctly by relocate_section. */
2900 /* If there are no references to this symbol that do not use the
2901 GOT, we don't need to generate a copy reloc. */
2905 /* If -z nocopyreloc was given, we won't generate them either. */
2907 {
2910 }
2914 {
2918 }
2920 /* If we didn't find any dynamic relocs in sections which needs the
2921 copy reloc, then we'll be keeping the dynamic relocs and avoiding
2922 the copy reloc. */
2924 {
2927 }
2930 {
2934 }
2936 /* We must allocate the symbol in our .dynbss section, which will
2937 become part of the .bss section of the executable. There will be
2938 an entry for this symbol in the .dynsym section. The dynamic
2939 object will contain position independent code, so all references
2940 from the dynamic object to this symbol will go through the global
2941 offset table. The dynamic linker will use the .dynsym entry to
2942 determine the address it must put in the global offset table, so
2943 both the dynamic object and the regular object will refer to the
2944 same memory location for the variable. */
2949 /* We must generate a R_SH_COPY reloc to tell the dynamic linker to
2950 copy the initial value out of the dynamic object and into the
2951 runtime process image. We need to remember the offset into the
2952 .rela.bss section we are going to use. */
2954 {
2961 }
2964 }
2966 /* Allocate space in .plt, .got and associated reloc sections for
2967 dynamic relocs. */
2969 static bfd_boolean
2971 {
2981 /* When warning symbols are created, they **replace** the "real"
2982 entry in the hash table, thus we never get to see the real
2983 symbol in a hash traversal. So look at it now. */
2995 {
2996 /* The symbol has been forced local, or we have some direct got refs,
2997 so treat all the gotplt refs as got refs. */
3001 }
3007 {
3008 /* Make sure this symbol is output as a dynamic symbol.
3009 Undefined weak syms won't yet be marked as dynamic. */
3012 {
3015 }
3019 {
3023 /* If this is the first .plt entry, make room for the special
3024 first entry. */
3030 /* If this symbol is not defined in a regular file, and we are
3031 not generating a shared library, then set the symbol to this
3032 location in the .plt. This is required to make function
3033 pointers compare as equal between the normal executable and
3034 the shared library. Skip this for FDPIC, since the
3035 function's address will be the address of the canonical
3036 function descriptor. */
3038 {
3041 }
3043 /* Make room for this entry. */
3050 /* We also need to make an entry in the .got.plt section, which
3051 will be placed in the .got section by the linker script. */
3054 else
3057 /* We also need to make an entry in the .rel.plt section. */
3061 {
3062 /* VxWorks executables have a second set of relocations
3063 for each PLT entry. They go in a separate relocation
3064 section, which is processed by the kernel loader. */
3066 /* There is a relocation for the initial PLT entry:
3067 an R_SH_DIR32 relocation for _GLOBAL_OFFSET_TABLE_. */
3071 /* There are two extra relocations for each subsequent
3072 PLT entry: an R_SH_DIR32 relocation for the GOT entry,
3073 and an R_SH_DIR32 relocation for the PLT entry. */
3075 }
3076 }
3077 else
3078 {
3081 }
3082 }
3083 else
3084 {
3087 }
3090 {
3092 bfd_boolean dyn;
3095 /* Make sure this symbol is output as a dynamic symbol.
3096 Undefined weak syms won't yet be marked as dynamic. */
3099 {
3102 }
3107 /* R_SH_TLS_GD needs 2 consecutive GOT slots. */
3112 {
3113 /* No dynamic relocations required. */
3118 }
3119 /* R_SH_TLS_IE_32 needs one dynamic relocation if dynamic,
3120 R_SH_TLS_GD needs one if local symbol and two if global. */
3127 {
3130 else
3132 }
3142 }
3143 else
3146 #ifdef INCLUDE_SHMEDIA
3148 {
3150 bfd_boolean dyn;
3152 /* Make sure this symbol is output as a dynamic symbol.
3153 Undefined weak syms won't yet be marked as dynamic. */
3156 {
3159 }
3167 }
3168 else
3170 #endif
3172 /* Allocate space for any dynamic relocations to function
3173 descriptors, canonical or otherwise. We need to relocate the
3174 reference unless it resolves to zero, which only happens for
3175 undefined weak symbols (either non-default visibility, or when
3176 static linking). Any GOT slot is accounted for elsewhere. */
3181 {
3184 else
3187 }
3189 /* We must allocate a function descriptor if there are references to
3190 a canonical descriptor (R_SH_GOTFUNCDESC or R_SH_FUNCDESC) and
3191 the dynamic linker isn't going to allocate it. None of this
3192 applies if we already created one in .got.plt, but if the
3193 canonical function descriptor can be in this object, there
3194 won't be a PLT entry at all. */
3199 {
3200 /* Make room for this function descriptor. */
3204 /* We will need a relocation or two fixups to initialize the
3205 function descriptor, so allocate those too. */
3208 else
3210 }
3215 /* In the shared -Bsymbolic case, discard space allocated for
3216 dynamic pc-relative relocs against symbols which turn out to be
3217 defined in regular objects. For the normal shared case, discard
3218 space for pc-relative relocs that have become local due to symbol
3219 visibility changes. */
3222 {
3224 {
3228 {
3233 else
3235 }
3236 }
3239 {
3243 {
3246 else
3248 }
3249 }
3251 /* Also discard relocs on undefined weak syms with non-default
3252 visibility. */
3255 {
3259 /* Make sure undefined weak symbols are output as a dynamic
3260 symbol in PIEs. */
3263 {
3266 }
3267 }
3268 }
3269 else
3270 {
3271 /* For the non-shared case, discard space for relocs against
3272 symbols which turn out to need copy relocs or are not
3273 dynamic. */
3281 {
3282 /* Make sure this symbol is output as a dynamic symbol.
3283 Undefined weak syms won't yet be marked as dynamic. */
3286 {
3289 }
3291 /* If that succeeded, we know we'll be keeping all the
3292 relocs. */
3295 }
3299 keep: ;
3300 }
3302 /* Finally, allocate space. */
3304 {
3308 /* If we need relocations, we do not need fixups. */
3311 }
3314 }
3316 /* Find any dynamic relocs that apply to read-only sections. */
3318 static bfd_boolean
3320 {
3329 {
3333 {
3338 /* Not an error, just cut short the traversal. */
3340 }
3341 }
3343 }
3345 /* This function is called after all the input files have been read,
3346 and the input sections have been assigned to output sections.
3347 It's a convenient place to determine the PLT style. */
3349 static bfd_boolean
3351 {
3355 {
3358 /* Force a PT_GNU_STACK segment to be created. */
3362 /* Define __stacksize if it's not defined yet. */
3368 {
3381 }
3382 }
3384 }
3386 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
3388 static bfd_boolean
3390 {
3395 /* objcopy and strip preserve what's already there using
3396 sh_elf_copy_private_bfd_data (). */
3405 {
3408 /* Obtain the pointer to the __stacksize symbol. */
3412 {
3417 }
3419 /* Set the header p_memsz from the symbol value. We
3420 intentionally ignore the symbol section. */
3423 else
3427 }
3430 }
3432 #endif
3434 /* Set the sizes of the dynamic sections. */
3436 static bfd_boolean
3439 {
3443 bfd_boolean relocs;
3454 {
3455 /* Set the contents of the .interp section to the interpreter. */
3457 {
3462 }
3463 }
3465 /* Set up .got offsets for local syms, and space for local dynamic
3466 relocs. */
3468 {
3473 bfd_size_type locsymcount;
3481 {
3488 {
3491 {
3492 /* Input section has been discarded, either because
3493 it is a copy of a linkonce section or due to
3494 linker script /DISCARD/, so we'll be discarding
3495 the relocs too. */
3496 }
3500 {
3501 /* Relocations in vxworks .tls_vars sections are
3502 handled specially by the loader. */
3503 }
3505 {
3511 /* If we need relocations, we do not need fixups. */
3514 }
3515 }
3516 }
3520 #ifdef INCLUDE_SHMEDIA
3521 /* Count datalabel local GOT. */
3523 #endif
3529 {
3534 {
3536 {
3543 else
3547 {
3549 {
3550 bfd_size_type size;
3554 size);
3558 local_funcdesc += (local_got
3560 }
3563 }
3564 }
3565 else
3568 }
3569 }
3573 {
3577 {
3579 {
3584 else
3586 }
3587 else
3589 }
3590 }
3592 }
3595 {
3596 /* Allocate 2 got entries and 1 dynamic reloc for R_SH_TLS_LD_32
3597 relocs. */
3601 }
3602 else
3605 /* Only the reserved entries should be present. For FDPIC, they go at
3606 the end of .got.plt. */
3608 {
3611 }
3613 /* Allocate global sym .plt and .got entries, and space for global
3614 sym dynamic relocs. */
3617 /* Move the reserved entries and the _GLOBAL_OFFSET_TABLE_ symbol to the
3618 end of the FDPIC .got.plt. */
3620 {
3623 }
3625 /* At the very end of the .rofixup section is a pointer to the GOT. */
3629 /* We now have determined the sizes of the various dynamic sections.
3630 Allocate memory for them. */
3633 {
3643 {
3644 /* Strip this section if we don't need it; see the
3645 comment below. */
3646 }
3648 {
3652 /* We use the reloc_count field as a counter if we need
3653 to copy relocs into the output file. */
3655 }
3656 else
3657 {
3658 /* It's not one of our sections, so don't allocate space. */
3660 }
3663 {
3664 /* If we don't need this section, strip it from the
3665 output file. This is mostly to handle .rela.bss and
3666 .rela.plt. We must create both sections in
3667 create_dynamic_sections, because they must be created
3668 before the linker maps input sections to output
3669 sections. The linker does that before
3670 adjust_dynamic_symbol is called, and it is that
3671 function which decides whether anything needs to go
3672 into these sections. */
3676 }
3681 /* Allocate memory for the section contents. We use bfd_zalloc
3682 here in case unused entries are not reclaimed before the
3683 section's contents are written out. This should not happen,
3684 but this way if it does, we get a R_SH_NONE reloc instead
3685 of garbage. */
3689 }
3692 {
3693 /* Add some entries to the .dynamic section. We fill in the
3694 values later, in sh_elf_finish_dynamic_sections, but we
3695 must add the entries now so that we get the correct size for
3696 the .dynamic section. The DT_DEBUG entry is filled in by the
3697 dynamic linker and used by the debugger. */
3698 #define add_dynamic_entry(TAG, VAL) \
3699 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3702 {
3705 }
3708 {
3714 }
3717 {
3720 }
3723 {
3730 /* If any dynamic relocs apply to a read-only section,
3731 then we need a DT_TEXTREL entry. */
3736 {
3739 }
3740 }
3744 }
3745 #undef add_dynamic_entry
3748 }
3749 \f
3750 /* Add a dynamic relocation to the SRELOC section. */
3755 {
3756 Elf_Internal_Rela outrel;
3757 bfd_vma reloc_offset;
3770 }
3772 /* Add an FDPIC read-only fixup. */
3776 {
3777 bfd_vma fixup_offset;
3782 }
3784 /* Return the offset of the generated .got section from the
3785 _GLOBAL_OFFSET_TABLE_ symbol. */
3787 static bfd_signed_vma
3789 {
3792 }
3794 /* Find the segment number in which OSEC, and output section, is
3795 located. */
3797 static unsigned
3799 {
3801 osec);
3803 /* FIXME: Nothing ever says what this index is relative to. The kernel
3804 supplies data in terms of the number of load segments but this is
3805 a phdr index and the first phdr may not be a load segment. */
3807 }
3809 static bfd_boolean
3811 {
3815 }
3817 /* Generate the initial contents of a local function descriptor, along
3818 with any relocations or fixups required. */
3819 static bfd_boolean
3823 bfd_vma offset,
3825 bfd_vma value)
3826 {
3833 /* FIXME: The ABI says that the offset to the function goes in the
3834 descriptor, along with the segment index. We're RELA, so it could
3835 go in the reloc instead... */
3838 {
3841 }
3844 {
3848 }
3849 else
3850 {
3854 }
3857 {
3859 {
3861 offset
3868 }
3870 /* There are no dynamic relocations so fill in the final
3871 address and gp value (barring fixups). */
3876 }
3877 else
3879 offset
3888 }
3890 /* Install a 20-bit movi20 field starting at ADDR, which occurs in OUTPUT_BFD.
3891 VALUE is the field's value. Return bfd_reloc_ok if successful or an error
3892 otherwise. */
3894 static bfd_reloc_status_type
3898 {
3901 bfd_reloc_status_type r;
3917 }
3919 /* Relocate an SH ELF section. */
3921 static bfd_boolean
3927 {
3939 bfd_boolean is_vxworks_tls;
3957 else
3962 else
3970 /* We have to handle relocations in vxworks .tls_vars sections
3971 specially, because the dynamic loader is 'weird'. */
3979 {
3986 bfd_vma relocation;
3988 bfd_reloc_status_type r;
3990 bfd_vma off;
3998 /* Many of the relocs are only used for relaxing, and are
3999 handled entirely by the relaxation code. */
4020 {
4023 }
4027 /* For relocs that aren't partial_inplace, we get the addend from
4028 the relocation. */
4038 {
4042 symname = bfd_elf_string_from_elf_section
4050 /* A local symbol never has STO_SH5_ISA32, so we don't need
4051 datalabel processing here. Make sure this does not change
4052 without notice. */
4060 /* Handled below. */
4061 ;
4063 {
4064 /* This is a relocatable link. We don't have to change
4065 anything, unless the reloc is against a section symbol,
4066 in which case we have to adjust according to where the
4067 section symbol winds up in the output section. */
4069 {
4071 {
4072 /* For relocations with the addend in the
4073 relocation, we need just to update the addend.
4074 All real relocs are of type partial_inplace; this
4075 code is mostly for completeness. */
4079 }
4081 /* Relocs of type partial_inplace need to pick up the
4082 contents in the contents and add the offset resulting
4083 from the changed location of the section symbol.
4084 Using _bfd_final_link_relocate (e.g. goto
4085 final_link_relocate) here would be wrong, because
4086 relocations marked pc_relative would get the current
4087 location subtracted, and we must only do that at the
4088 final link. */
4090 sec->output_offset
4094 }
4097 }
4099 {
4102 }
4105 {
4109 {
4115 }
4119 addend =
4125 }
4126 }
4127 else
4128 {
4129 /* FIXME: Ought to make use of the RELOC_FOR_GLOBAL_SYMBOL macro. */
4136 {
4137 #ifdef INCLUDE_SHMEDIA
4138 /* If the reference passes a symbol marked with
4139 STT_DATALABEL, then any STO_SH5_ISA32 on the final value
4140 doesn't count. */
4142 #endif
4144 }
4147 {
4148 bfd_boolean dyn;
4152 /* In these cases, we don't need the relocation value.
4153 We check specially because in some obscure cases
4154 sec->output_section will be NULL. */
4181 /* The cases above are those in which relocation is
4182 overwritten in the switch block below. The cases
4183 below are those in which we must defer relocation
4184 to run-time, because we can't resolve absolute
4185 addresses when creating a shared library. */
4194 /* DWARF will emit R_SH_DIR32 relocations in its
4195 sections against symbols defined externally
4196 in shared libraries. We can't do anything
4197 with them here. */
4200 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4201 sections because such sections are not SEC_ALLOC and
4202 thus ld.so will not process them. */
4209 ;
4214 /* A STO_SH5_ISA32 causes a "bitor 1" to the
4215 symbol value, unless we've seen
4216 STT_DATALABEL on the way to it. */
4220 {
4223 input_bfd,
4224 input_section,
4229 }
4230 }
4232 ;
4235 ;
4237 {
4244 }
4245 }
4248 {
4249 /* For relocs against symbols from removed linkonce sections,
4250 or sections discarded by a linker script, we just want the
4251 section contents zeroed. Avoid any special processing. */
4256 }
4261 /* Check for inter-segment relocations in FDPIC files. Most
4262 relocations connect the relocation site to the location of
4263 the target symbol, but there are some exceptions below. */
4268 else
4272 {
4273 final_link_relocate:
4274 /* COFF relocs don't use the addend. The addend is used for
4275 R_SH_DIR32 to be compatible with other compilers. */
4287 /* If the reloc is against the start of this section, then
4288 the assembler has already taken care of it and the reloc
4289 is here only to assist in relaxing. If the reloc is not
4290 against the start of this section, then it's against an
4291 external symbol and we must deal with it ourselves. */
4294 {
4301 {
4306 }
4308 {
4315 }
4318 }
4323 #ifdef INCLUDE_SHMEDIA
4327 #endif
4341 {
4349 }
4356 {
4364 }
4370 {
4378 }
4384 {
4392 }
4397 #ifdef INCLUDE_SHMEDIA
4402 #endif
4409 && !is_vxworks_tls
4412 {
4413 Elf_Internal_Rela outrel;
4417 /* When generating a shared object, these relocations
4418 are copied into the output file to be resolved at run
4419 time. */
4422 {
4423 sreloc = _bfd_elf_get_dynamic_reloc_section
4427 }
4445 {
4448 outrel.r_addend
4452 }
4453 #ifdef INCLUDE_SHMEDIA
4458 {
4462 }
4463 #endif
4468 {
4476 outrel.r_addend
4481 }
4482 else
4483 {
4484 /* h->dynindx may be -1 if this symbol was marked to
4485 become local. */
4489 {
4492 }
4493 else
4494 {
4497 }
4499 outrel.r_addend
4503 }
4511 /* If this reloc is against an external symbol, we do
4512 not want to fiddle with the addend. Otherwise, we
4513 need to include the symbol value so that it becomes
4514 an addend for the dynamic reloc. */
4517 }
4521 {
4522 bfd_vma offset;
4526 {
4529 input_bfd,
4530 input_section,
4532 symname);
4534 }
4545 }
4549 #ifdef INCLUDE_SHMEDIA
4556 #endif
4557 /* Relocation is to the entry for this symbol in the
4558 procedure linkage table. */
4569 /* Relocation is to the entry for this symbol in the global
4570 offset table extension for the procedure linkage table. */
4577 #ifdef GOT_BIAS
4579 #endif
4583 force_got:
4586 #ifdef INCLUDE_SHMEDIA
4593 #endif
4594 /* Relocation is to the entry for this symbol in the global
4595 offset table. */
4601 {
4602 bfd_boolean dyn;
4605 #ifdef INCLUDE_SHMEDIA
4607 {
4612 }
4613 #endif
4622 {
4623 /* This is actually a static link, or it is a
4624 -Bsymbolic link and the symbol is defined
4625 locally, or the symbol was forced to be local
4626 because of a version file. We must initialize
4627 this entry in the global offset table. Since the
4628 offset must always be a multiple of 4, we use the
4629 least significant bit to record whether we have
4630 initialized it already.
4632 When doing a dynamic link, we create a .rela.got
4633 relocation entry to initialize the value. This
4634 is done in the finish_dynamic_symbol routine. */
4637 else
4638 {
4641 #ifdef INCLUDE_SHMEDIA
4643 {
4648 }
4649 else
4650 #endif
4653 /* If we initialize the GOT entry here with a valid
4654 symbol address, also add a fixup. */
4663 }
4664 }
4667 }
4668 else
4669 {
4670 #ifdef INCLUDE_SHMEDIA
4672 {
4680 }
4681 else
4682 {
4683 #endif
4688 #ifdef INCLUDE_SHMEDIA
4689 }
4690 #endif
4692 /* The offset must always be a multiple of 4. We use
4693 the least significant bit to record whether we have
4694 already generated the necessary reloc. */
4697 else
4698 {
4702 {
4703 Elf_Internal_Rela outrel;
4707 {
4711 }
4717 {
4718 int dynindx
4723 }
4724 else
4725 {
4728 }
4732 }
4741 #ifdef INCLUDE_SHMEDIA
4744 else
4745 #endif
4747 }
4750 }
4752 #ifdef GOT_BIAS
4754 #endif
4757 {
4762 }
4763 else
4768 #ifdef INCLUDE_SHMEDIA
4773 #endif
4774 /* GOTOFF relocations are relative to _GLOBAL_OFFSET_TABLE_, which
4775 we place at the start of the .got.plt section. This is the same
4776 as the start of the output .got section, unless there are function
4777 descriptors in front of it. */
4783 #ifdef GOT_BIAS
4785 #endif
4790 {
4795 }
4796 else
4800 #ifdef INCLUDE_SHMEDIA
4805 #endif
4806 /* Use global offset table as symbol value. */
4811 #ifdef GOT_BIAS
4813 #endif
4820 #ifdef INCLUDE_SHMEDIA
4825 #endif
4826 /* Relocation is to the entry for this symbol in the
4827 procedure linkage table. */
4829 /* Resolve a PLT reloc against a local symbol directly,
4830 without using the procedure linkage table. */
4834 /* We don't want to warn on calls to undefined weak symbols,
4835 as calls to them must be protected by non-NULL tests
4836 anyway, and unprotected calls would invoke undefined
4837 behavior. */
4845 {
4846 /* We didn't make a PLT entry for this symbol. This
4847 happens when statically linking PIC code, or when
4848 using -Bsymbolic. */
4850 }
4858 #ifdef INCLUDE_SHMEDIA
4859 relocation++;
4860 #endif
4866 /* Relocation is to the canonical function descriptor for this
4867 symbol, possibly via the GOT. Initialize the GOT
4868 entry and function descriptor if necessary. */
4872 {
4875 bfd_vma reloc_offset;
4880 /* FIXME: See what FRV does for global symbols in the
4881 executable, with --export-dynamic. Do they need ld.so
4882 to allocate official descriptors? See what this code
4883 does. */
4889 {
4892 }
4893 else
4894 {
4899 else
4900 {
4903 }
4907 {
4910 }
4911 }
4916 /* Undefined weak symbol which will not be dynamically
4917 resolved later; leave it at zero. */
4921 {
4922 /* If the symbol needs a non-local function descriptor
4923 but binds locally (i.e., its visibility is
4924 protected), emit a dynamic relocation decayed to
4925 section+offset. This is an optimization; the dynamic
4926 linker would resolve our function descriptor request
4927 to our copy of the function anyway. */
4932 }
4934 {
4935 /* If the symbol is dynamic and there will be dynamic
4936 symbol resolution because we are or are linked with a
4937 shared library, emit a FUNCDESC relocation such that
4938 the dynamic linker will allocate the function
4939 descriptor. */
4942 }
4943 else
4944 {
4945 bfd_vma offset;
4947 /* Otherwise, we know we have a private function
4948 descriptor, so reference it directly. */
4954 {
4958 {
4963 }
4964 }
4965 else
4966 {
4973 {
4979 }
4980 }
4983 }
4986 {
4987 bfd_vma offset;
4991 {
4994 input_bfd,
4995 input_section,
4997 symname);
4999 }
5006 offset
5009 }
5012 {
5013 bfd_vma offset;
5017 {
5023 }
5026 {
5029 }
5036 offset
5042 {
5045 }
5046 else
5047 {
5050 }
5051 }
5055 funcdesc_leave_zero:
5057 {
5062 else
5065 funcdesc_done_got:
5068 #ifdef GOT_BIAS
5070 #endif
5071 }
5073 {
5078 }
5079 else
5081 }
5086 /* FIXME: See R_SH_FUNCDESC comment about global symbols in the
5087 executable and --export-dynamic. If such symbols get
5088 ld.so-allocated descriptors we can not use R_SH_GOTOFFFUNCDESC
5089 for them. */
5097 {
5098 _bfd_error_handler
5103 }
5104 else
5105 {
5106 bfd_vma offset;
5108 /* Otherwise, we know we have a private function
5109 descriptor, so reference it directly. */
5111 {
5115 {
5120 }
5121 }
5122 else
5123 {
5130 {
5136 }
5137 }
5140 }
5144 #ifdef GOT_BIAS
5146 #endif
5149 {
5154 }
5155 else
5159 {
5174 }
5184 {
5190 }
5196 {
5197 bfd_vma offset;
5201 {
5202 /* GD->LE transition:
5203 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5204 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5205 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5206 We change it into:
5207 mov.l 1f,r4; stc gbr,r0; add r4,r0; nop;
5208 nop; nop; ...
5209 1: .long x@TPOFF; 2: .long __tls_get_addr@PLT; 3:. */
5213 /* Size of GD instructions is 16 or 18. */
5217 {
5221 }
5240 }
5241 else
5242 {
5245 /* IE->LE transition:
5246 mov.l 1f,r0; stc gbr,rN; mov.l @(r0,r12),rM;
5247 bra 2f; add ...; .align 2; 1: x@GOTTPOFF; 2:
5248 We change it into:
5249 mov.l .Ln,rM; stc gbr,rN; nop; ...;
5250 1: x@TPOFF; 2:. */
5254 /* Size of IE instructions is 10 or 12. */
5258 {
5262 }
5273 }
5278 }
5285 else
5286 {
5291 }
5293 /* Relocate R_SH_TLS_IE_32 directly when statically linking. */
5296 {
5303 }
5307 else
5308 {
5309 Elf_Internal_Rela outrel;
5314 {
5317 }
5324 else
5328 R_SH_TLS_TPOFF32);
5331 else
5339 {
5341 {
5345 }
5346 else
5347 {
5349 R_SH_TLS_DTPOFF32);
5355 }
5356 }
5360 else
5362 }
5369 else
5370 {
5371 bfd_vma offset;
5374 /* GD->IE transition:
5375 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5376 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5377 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5378 We change it into:
5379 mov.l 1f,r0; stc gbr,r4; mov.l @(r0,r12),r0; add r4,r0;
5380 nop; nop; bra 3f; nop; .align 2;
5381 1: .long x@TPOFF; 2:...; 3:. */
5385 /* Size of GD instructions is 16 or 18. */
5389 {
5393 }
5397 /* Replace mov.l 1f,R4 with mov.l 1f,r0. */
5421 }
5430 {
5431 bfd_vma offset;
5434 /* LD->LE transition:
5435 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5436 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5437 1: .long x$TLSLD; 2: .long __tls_get_addr@PLT; 3:
5438 We change it into:
5439 stc gbr,r0; nop; nop; nop;
5440 nop; nop; bra 3f; ...; 3:. */
5444 /* Size of LD instructions is 16 or 18. */
5448 {
5452 }
5474 }
5482 else
5483 {
5484 Elf_Internal_Rela outrel;
5499 }
5510 else
5517 {
5519 Elf_Internal_Rela outrel;
5525 {
5529 }
5532 {
5533 sreloc = _bfd_elf_get_dynamic_reloc_section
5537 }
5541 else
5550 else
5557 }
5558 }
5560 relocation_done:
5563 {
5564 /* We don't want duplicate errors for undefined symbols. */
5566 {
5568 {
5573 }
5574 else
5578 }
5581 }
5584 {
5586 {
5591 {
5596 else
5597 {
5598 name = (bfd_elf_string_from_elf_section
5604 }
5610 }
5612 }
5613 }
5614 }
5617 }
5619 /* This is a version of bfd_generic_get_relocated_section_contents
5620 which uses sh_elf_relocate_section. */
5627 bfd_boolean relocatable,
5629 {
5637 /* We only need to handle the case of relaxing, or of having a
5638 particular set of section contents, specially. */
5643 relocatable,
5644 symbols);
5653 {
5656 bfd_size_type amt;
5658 internal_relocs = (_bfd_elf_link_read_relocs
5665 {
5673 }
5683 {
5692 else
5696 }
5710 }
5714 error_return:
5724 }
5726 /* Return the base VMA address which should be subtracted from real addresses
5727 when resolving @dtpoff relocation.
5728 This is PT_TLS segment p_vaddr. */
5730 static bfd_vma
5732 {
5733 /* If tls_sec is NULL, we should have signalled an error already. */
5737 }
5739 /* Return the relocation value for R_SH_TLS_TPOFF32.. */
5741 static bfd_vma
5743 {
5744 /* If tls_sec is NULL, we should have signalled an error already. */
5747 /* SH TLS ABI is variant I and static TLS block start just after tcbhead
5748 structure which has 2 pointer fields. */
5752 }
5760 {
5763 {
5767 }
5770 }
5772 /* Update the got entry reference counts for the section being removed. */
5774 static bfd_boolean
5777 {
5796 {
5800 #ifdef INCLUDE_SHMEDIA
5802 #endif
5806 {
5814 {
5815 #ifdef INCLUDE_SHMEDIA
5817 #endif
5819 }
5823 {
5824 /* Everything must go for SEC. */
5827 }
5828 }
5832 {
5843 #ifdef INCLUDE_SHMEDIA
5858 #endif
5864 {
5865 #ifdef INCLUDE_SHMEDIA
5867 {
5872 }
5873 else
5874 #endif
5877 }
5879 {
5880 #ifdef INCLUDE_SHMEDIA
5882 {
5885 }
5886 else
5887 #endif
5890 }
5899 /* Fall through. */
5905 else
5913 /* Fall thru */
5918 /* Fall thru */
5921 #ifdef INCLUDE_SHMEDIA
5926 #endif
5928 {
5931 }
5935 #ifdef INCLUDE_SHMEDIA
5942 #endif
5944 {
5948 {
5952 }
5953 #ifdef INCLUDE_SHMEDIA
5955 {
5958 }
5959 #endif
5962 }
5964 {
5965 #ifdef INCLUDE_SHMEDIA
5967 {
5970 }
5971 else
5972 #endif
5975 }
5980 }
5981 }
5984 }
5986 /* Copy the extra info we tack onto an elf_link_hash_entry. */
5988 static void
5992 {
5999 {
6001 {
6005 /* Add reloc counts against the indirect sym to the direct sym
6006 list. Merge any entries against the same section. */
6008 {
6013 {
6018 }
6021 }
6023 }
6027 }
6030 #ifdef INCLUDE_SHMEDIA
6033 #endif
6041 {
6044 }
6048 {
6049 /* If called to transfer flags for a weakdef during processing
6050 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
6051 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
6056 }
6057 else
6059 }
6061 static int
6064 {
6069 {
6077 }
6080 }
6082 /* Look through the relocs for a section during the first phase.
6083 Since we don't do .gots or .plts, we just need to consider the
6084 virtual table relocs for gc. */
6086 static bfd_boolean
6089 {
6115 {
6118 #ifdef INCLUDE_SHMEDIA
6120 #endif
6127 else
6128 {
6132 {
6133 #ifdef INCLUDE_SHMEDIA
6135 #endif
6137 }
6138 }
6152 {
6159 {
6162 {
6169 }
6170 }
6172 }
6174 /* Some relocs require a global offset table. */
6176 {
6178 {
6180 /* This may require an rofixup. */
6194 #ifdef INCLUDE_SHMEDIA
6215 #endif
6227 }
6228 }
6231 {
6232 /* This relocation describes the C++ object vtable hierarchy.
6233 Reconstruct it for later use during GC. */
6239 /* This relocation describes which C++ vtable entries are actually
6240 used. Record for later use during GC. */
6252 /* FALLTHROUGH */
6253 force_got:
6257 #ifdef INCLUDE_SHMEDIA
6264 #endif
6268 {
6282 }
6285 {
6286 #ifdef INCLUDE_SHMEDIA
6288 {
6293 }
6294 else
6295 #endif
6298 }
6299 else
6300 {
6303 /* This is a global offset table entry for a local
6304 symbol. */
6307 {
6308 bfd_size_type size;
6312 #ifdef INCLUDE_SHMEDIA
6313 /* Reserve space for both the datalabel and
6314 codelabel local GOT offsets. */
6316 #endif
6323 #ifdef INCLUDE_SHMEDIA
6324 /* Take care of both the datalabel and codelabel local
6325 GOT offsets. */
6328 #else
6331 #endif
6332 }
6333 #ifdef INCLUDE_SHMEDIA
6336 else
6337 #endif
6340 }
6342 /* If a TLS symbol is accessed using IE at least once,
6343 there is no point to use dynamic model for it. */
6346 {
6349 else
6350 {
6361 else
6366 }
6367 }
6370 {
6373 else
6375 }
6387 {
6390 abfd);
6392 }
6395 {
6398 /* We need a function descriptor for a local symbol. */
6401 {
6402 bfd_size_type size;
6405 #ifdef INCLUDE_SHMEDIA
6406 /* Count datalabel local GOT. */
6408 #endif
6413 }
6417 {
6420 else
6422 }
6423 }
6424 else
6425 {
6430 /* If there is a function descriptor reference, then
6431 there should not be any non-FDPIC references. */
6434 {
6439 else
6443 }
6444 }
6448 #ifdef INCLUDE_SHMEDIA
6455 #endif
6456 /* If this is a local symbol, we resolve it directly without
6457 creating a procedure linkage table entry. */
6473 #ifdef INCLUDE_SHMEDIA
6478 #endif
6479 /* This symbol requires a procedure linkage table entry. We
6480 actually build the entry in adjust_dynamic_symbol,
6481 because this might be a case of linking PIC code which is
6482 never referenced by a dynamic object, in which case we
6483 don't need to generate a procedure linkage table entry
6484 after all. */
6486 /* If this is a local symbol, we resolve it directly without
6487 creating a procedure linkage table entry. */
6500 #ifdef INCLUDE_SHMEDIA
6505 #endif
6507 {
6510 }
6512 /* If we are creating a shared library, and this is a reloc
6513 against a global symbol, or a non PC relative reloc
6514 against a local symbol, then we need to copy the reloc
6515 into the shared library. However, if we are linking with
6516 -Bsymbolic, we do not need to copy a reloc against a
6517 global symbol which is defined in an object we are
6518 including in the link (i.e., DEF_REGULAR is set). At
6519 this point we have not seen all the input files, so it is
6520 possible that DEF_REGULAR is not set now but will be set
6521 later (it is never cleared). We account for that
6522 possibility below by storing information in the
6523 dyn_relocs field of the hash table entry. A similar
6524 situation occurs when creating shared libraries and symbol
6525 visibility changes render the symbol local.
6527 If on the other hand, we are creating an executable, we
6528 may need to keep relocations for symbols satisfied by a
6529 dynamic library if we manage to avoid copy relocs for the
6530 symbol. */
6543 {
6550 /* When creating a shared object, we must copy these
6551 reloc types into the output file. We create a reloc
6552 section in dynobj and make room for this reloc. */
6554 {
6555 sreloc = _bfd_elf_make_dynamic_reloc_section
6560 }
6562 /* If this is a global symbol, we count the number of
6563 relocations we need for this symbol. */
6566 else
6567 {
6568 /* Track dynamic relocs needed for local syms too. */
6584 }
6588 {
6598 }
6602 #ifdef INCLUDE_SHMEDIA
6607 #endif
6608 )
6610 }
6612 /* Allocate the fixup regardless of whether we need a relocation.
6613 If we end up generating the relocation, we'll unallocate the
6614 fixup. */
6623 {
6626 abfd);
6628 }
6633 /* Nothing to do. */
6638 }
6639 }
6642 }
6644 #ifndef sh_elf_set_mach_from_flags
6647 static bfd_boolean
6649 {
6661 }
6664 /* Reverse table lookup for sh_ef_bfd_table[].
6665 Given a bfd MACH value from archures.c
6666 return the equivalent ELF flags from the table.
6667 Return -1 if no match is found. */
6669 int
6671 {
6678 /* shouldn't get here */
6682 }
6685 #ifndef sh_elf_set_private_flags
6686 /* Function to keep SH specific file flags. */
6688 static bfd_boolean
6690 {
6697 }
6700 #ifndef sh_elf_copy_private_data
6701 /* Copy backend specific data from one object module to another */
6703 static bfd_boolean
6705 {
6706 /* Copy object attributes. */
6712 /* Copy the stack size. */
6715 {
6720 {
6725 {
6728 /* Rewrite the phdrs, since we're only called after they
6729 were first written. */
6738 }
6741 }
6742 }
6745 }
6748 #ifndef sh_elf_merge_private_data
6750 /* This function returns the ELF architecture number that
6751 corresponds to the given arch_sh* flags. */
6753 int
6755 {
6760 }
6762 /* This routine initialises the elf flags when required and
6763 calls sh_merge_bfd_arch() to check dsp/fpu compatibility. */
6765 static bfd_boolean
6767 {
6774 {
6775 /* This happens when ld starts out with a 'blank' output file. */
6781 }
6784 {
6787 ibfd);
6790 }
6797 {
6799 ibfd);
6802 }
6805 }
6808 /* Override the generic function because we need to store sh_elf_obj_tdata
6809 as the specific tdata. We set also the machine architecture from flags
6810 here. */
6812 static bfd_boolean
6814 {
6820 }
6822 /* Finish up dynamic symbol handling. We set the contents of various
6823 dynamic sections here. */
6825 static bfd_boolean
6829 {
6837 {
6842 bfd_vma plt_index;
6843 bfd_vma got_offset;
6844 Elf_Internal_Rela rel;
6848 /* This symbol has an entry in the procedure linkage table. Set
6849 it up. */
6858 /* Get the index in the procedure linkage table which
6859 corresponds to this symbol. This is the index of this symbol
6860 in all the symbols for which we are making plt entries. The
6861 first entry in the procedure linkage table is reserved. */
6868 /* Get the offset into the .got table of the entry that
6869 corresponds to this function. */
6871 /* The offset must be relative to the GOT symbol, twelve bytes
6872 before the end of .got.plt. Each descriptor is eight
6873 bytes. */
6875 else
6876 /* Each .got entry is 4 bytes. The first three are
6877 reserved. */
6880 #ifdef GOT_BIAS
6883 #endif
6885 /* Fill in the entry in the procedure linkage table. */
6891 {
6893 {
6894 bfd_reloc_status_type r;
6900 }
6901 else
6906 }
6907 else
6908 {
6919 {
6923 /* Divide the PLT into groups. The first group contains
6924 REACHABLE_PLTS entries and the other groups contain
6925 PLTS_PER_4K entries. Entries in the first group can
6926 branch directly to .plt; those in later groups branch
6927 to the last element of the previous group. */
6928 /* ??? It would be better to create multiple copies of
6929 the common resolver stub. */
6938 else
6942 /* Install the 'bra' with this offset. */
6948 }
6949 else
6955 }
6957 /* Make got_offset relative to the start of .got.plt. */
6958 #ifdef GOT_BIAS
6961 #endif
6972 /* Fill in the entry in the global offset table. */
6985 /* Fill in the entry in the .rela.plt section. */
6991 else
6994 #ifdef GOT_BIAS
6996 #endif
7001 {
7002 /* Create the .rela.plt.unloaded relocations for this PLT entry.
7003 Begin by pointing LOC to the first such relocation. */
7007 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation
7008 for the PLT entry's pointer to the .got.plt entry. */
7018 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for
7019 the .got.plt entry, which initially points to .plt. */
7026 }
7029 {
7030 /* Mark the symbol as undefined, rather than as defined in
7031 the .plt section. Leave the value alone. */
7033 }
7034 }
7040 {
7043 Elf_Internal_Rela rel;
7046 /* This symbol has an entry in the global offset table. Set it
7047 up. */
7057 /* If this is a static link, or it is a -Bsymbolic link and the
7058 symbol is defined locally or was forced to be local because
7059 of a version file, we just want to emit a RELATIVE reloc.
7060 The entry in the global offset table will already have been
7061 initialized in the relocate_section function. */
7064 {
7066 {
7068 int dynindx
7074 }
7075 else
7076 {
7081 }
7082 }
7083 else
7084 {
7088 }
7093 }
7095 #ifdef INCLUDE_SHMEDIA
7096 {
7101 {
7104 Elf_Internal_Rela rel;
7107 /* This symbol has a datalabel entry in the global offset table.
7108 Set it up. */
7118 /* If this is a static link, or it is a -Bsymbolic link and the
7119 symbol is defined locally or was forced to be local because
7120 of a version file, we just want to emit a RELATIVE reloc.
7121 The entry in the global offset table will already have been
7122 initialized in the relocate_section function. */
7125 {
7127 {
7129 int dynindx
7135 }
7136 else
7137 {
7142 }
7143 }
7144 else
7145 {
7150 }
7155 }
7156 }
7157 #endif
7160 {
7162 Elf_Internal_Rela rel;
7165 /* This symbol needs a copy reloc. Set it up. */
7182 }
7184 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. On VxWorks,
7185 _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
7186 ".got" section. */
7192 }
7194 /* Finish up the dynamic sections. */
7196 static bfd_boolean
7198 {
7211 {
7220 {
7221 Elf_Internal_Dyn dyn;
7223 #ifdef INCLUDE_SHMEDIA
7225 #endif
7230 {
7237 #ifdef INCLUDE_SHMEDIA
7244 get_sym:
7246 {
7252 {
7255 }
7256 }
7258 #endif
7283 /* My reading of the SVR4 ABI indicates that the
7284 procedure linkage table relocs (DT_JMPREL) should be
7285 included in the overall relocs (DT_RELA). This is
7286 what Solaris does. However, UnixWare can not handle
7287 that case. Therefore, we override the DT_RELASZ entry
7288 here to make it not include the JMPREL relocs. Since
7289 the linker script arranges for .rela.plt to follow all
7290 other relocation sections, we don't have to worry
7291 about changing the DT_RELA entry. */
7293 {
7296 }
7299 }
7300 }
7302 /* Fill in the first entry in the procedure linkage table. */
7305 {
7321 {
7322 /* Finalize the .rela.plt.unloaded contents. */
7323 Elf_Internal_Rela rel;
7326 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for the
7327 first PLT entry's pointer to _GLOBAL_OFFSET_TABLE_ + 8. */
7337 /* Fix up the remaining .rela.plt.unloaded relocations.
7338 They may have the wrong symbol index for _G_O_T_ or
7339 _P_L_T_ depending on the order in which symbols were
7340 output. */
7342 {
7343 /* The PLT entry's pointer to the .got.plt slot. */
7346 R_SH_DIR32);
7350 /* The .got.plt slot's pointer to .plt. */
7353 R_SH_DIR32);
7356 }
7357 }
7359 /* UnixWare sets the entsize of .plt to 4, although that doesn't
7360 really seem like the right value. */
7362 }
7363 }
7365 /* Fill in the first three entries in the global offset table. */
7367 {
7370 else
7376 }
7381 /* At the very end of the .rofixup section is a pointer to the GOT. */
7383 {
7391 /* Make sure we allocated and generated the same number of fixups. */
7393 }
7404 }
7406 static enum elf_reloc_type_class
7408 {
7410 {
7419 }
7420 }
7422 #if !defined SH_TARGET_ALREADY_DEFINED
7423 /* Support for Linux core dump NOTE sections. */
7425 static bfd_boolean
7427 {
7432 {
7437 /* pr_cursig */
7440 /* pr_pid */
7443 /* pr_reg */
7448 }
7450 /* Make a ".reg/999" section. */
7453 }
7455 static bfd_boolean
7457 {
7459 {
7468 }
7470 /* Note that for some reason, a spurious space is tacked
7471 onto the end of the args in some (at least one anyway)
7472 implementations, so strip it off if it exists. */
7474 {
7480 }
7483 }
7487 /* Return address for Ith PLT stub in section PLT, for relocation REL
7488 or (bfd_vma) -1 if it should not be included. */
7490 static bfd_vma
7493 {
7498 }
7500 /* Decide whether to attempt to turn absptr or lsda encodings in
7501 shared libraries into pcrel within the given input section. */
7503 static bfd_boolean
7507 {
7510 /* We can't use PC-relative encodings in FDPIC binaries, in general. */
7515 }
7517 /* Adjust the contents of an eh_frame_hdr section before they're output. */
7519 static bfd_byte
7525 {
7542 == (sh_elf_osec_to_segment
7551 }
7553 #if !defined SH_TARGET_ALREADY_DEFINED
7554 #define TARGET_BIG_SYM bfd_elf32_sh_vec
7556 #define TARGET_LITTLE_SYM bfd_elf32_shl_vec
7558 #endif
7560 #define ELF_ARCH bfd_arch_sh
7561 #define ELF_MACHINE_CODE EM_SH
7562 #ifdef __QNXTARGET__
7563 #define ELF_MAXPAGESIZE 0x1000
7564 #else
7565 #define ELF_MAXPAGESIZE 0x80
7566 #endif
7570 #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup
7571 #define bfd_elf32_bfd_reloc_name_lookup \
7572 sh_elf_reloc_name_lookup
7573 #define elf_info_to_howto sh_elf_info_to_howto
7574 #define bfd_elf32_bfd_relax_section sh_elf_relax_section
7575 #define elf_backend_relocate_section sh_elf_relocate_section
7576 #define bfd_elf32_bfd_get_relocated_section_contents \
7577 sh_elf_get_relocated_section_contents
7578 #define bfd_elf32_mkobject sh_elf_mkobject
7579 #define elf_backend_object_p sh_elf_object_p
7580 #define bfd_elf32_bfd_set_private_bfd_flags \
7581 sh_elf_set_private_flags
7582 #define bfd_elf32_bfd_copy_private_bfd_data \
7583 sh_elf_copy_private_data
7584 #define bfd_elf32_bfd_merge_private_bfd_data \
7585 sh_elf_merge_private_data
7587 #define elf_backend_gc_mark_hook sh_elf_gc_mark_hook
7588 #define elf_backend_gc_sweep_hook sh_elf_gc_sweep_hook
7589 #define elf_backend_check_relocs sh_elf_check_relocs
7590 #define elf_backend_copy_indirect_symbol \
7591 sh_elf_copy_indirect_symbol
7592 #define elf_backend_create_dynamic_sections \
7593 sh_elf_create_dynamic_sections
7594 #define bfd_elf32_bfd_link_hash_table_create \
7595 sh_elf_link_hash_table_create
7596 #define elf_backend_adjust_dynamic_symbol \
7597 sh_elf_adjust_dynamic_symbol
7598 #define elf_backend_always_size_sections \
7599 sh_elf_always_size_sections
7600 #define elf_backend_size_dynamic_sections \
7601 sh_elf_size_dynamic_sections
7602 #define elf_backend_omit_section_dynsym sh_elf_omit_section_dynsym
7603 #define elf_backend_finish_dynamic_symbol \
7604 sh_elf_finish_dynamic_symbol
7605 #define elf_backend_finish_dynamic_sections \
7606 sh_elf_finish_dynamic_sections
7607 #define elf_backend_reloc_type_class sh_elf_reloc_type_class
7608 #define elf_backend_plt_sym_val sh_elf_plt_sym_val
7609 #define elf_backend_can_make_relative_eh_frame \
7610 sh_elf_use_relative_eh_frame
7611 #define elf_backend_can_make_lsda_relative_eh_frame \
7612 sh_elf_use_relative_eh_frame
7613 #define elf_backend_encode_eh_address \
7614 sh_elf_encode_eh_address
7616 #define elf_backend_can_gc_sections 1
7617 #define elf_backend_can_refcount 1
7618 #define elf_backend_want_got_plt 1
7619 #define elf_backend_plt_readonly 1
7620 #define elf_backend_want_plt_sym 0
7621 #define elf_backend_got_header_size 12
7623 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
7627 /* NetBSD support. */
7628 #undef TARGET_BIG_SYM
7629 #define TARGET_BIG_SYM bfd_elf32_shnbsd_vec
7630 #undef TARGET_BIG_NAME
7632 #undef TARGET_LITTLE_SYM
7633 #define TARGET_LITTLE_SYM bfd_elf32_shlnbsd_vec
7634 #undef TARGET_LITTLE_NAME
7636 #undef ELF_MAXPAGESIZE
7637 #define ELF_MAXPAGESIZE 0x10000
7638 #undef ELF_COMMONPAGESIZE
7639 #undef elf_symbol_leading_char
7640 #define elf_symbol_leading_char 0
7641 #undef elf32_bed
7642 #define elf32_bed elf32_sh_nbsd_bed
7647 /* Linux support. */
7648 #undef TARGET_BIG_SYM
7649 #define TARGET_BIG_SYM bfd_elf32_shblin_vec
7650 #undef TARGET_BIG_NAME
7652 #undef TARGET_LITTLE_SYM
7653 #define TARGET_LITTLE_SYM bfd_elf32_shlin_vec
7654 #undef TARGET_LITTLE_NAME
7656 #undef ELF_COMMONPAGESIZE
7657 #define ELF_COMMONPAGESIZE 0x1000
7659 #undef elf_backend_grok_prstatus
7660 #define elf_backend_grok_prstatus elf32_shlin_grok_prstatus
7661 #undef elf_backend_grok_psinfo
7662 #define elf_backend_grok_psinfo elf32_shlin_grok_psinfo
7663 #undef elf32_bed
7664 #define elf32_bed elf32_sh_lin_bed
7669 /* FDPIC support. */
7670 #undef TARGET_BIG_SYM
7671 #define TARGET_BIG_SYM bfd_elf32_shbfd_vec
7672 #undef TARGET_BIG_NAME
7674 #undef TARGET_LITTLE_SYM
7675 #define TARGET_LITTLE_SYM bfd_elf32_shfd_vec
7676 #undef TARGET_LITTLE_NAME
7678 #undef elf_backend_modify_program_headers
7679 #define elf_backend_modify_program_headers \
7680 sh_elf_modify_program_headers
7682 #undef elf32_bed
7683 #define elf32_bed elf32_sh_fd_bed
7687 #undef elf_backend_modify_program_headers
7689 /* VxWorks support. */
7690 #undef TARGET_BIG_SYM
7691 #define TARGET_BIG_SYM bfd_elf32_shvxworks_vec
7692 #undef TARGET_BIG_NAME
7694 #undef TARGET_LITTLE_SYM
7695 #define TARGET_LITTLE_SYM bfd_elf32_shlvxworks_vec
7696 #undef TARGET_LITTLE_NAME
7698 #undef elf32_bed
7699 #define elf32_bed elf32_sh_vxworks_bed
7701 #undef elf_backend_want_plt_sym
7702 #define elf_backend_want_plt_sym 1
7703 #undef elf_symbol_leading_char
7705 #define elf_backend_want_got_underscore 1
7706 #undef elf_backend_grok_prstatus
7707 #undef elf_backend_grok_psinfo
7708 #undef elf_backend_add_symbol_hook
7709 #define elf_backend_add_symbol_hook elf_vxworks_add_symbol_hook
7710 #undef elf_backend_link_output_symbol_hook
7711 #define elf_backend_link_output_symbol_hook \
7712 elf_vxworks_link_output_symbol_hook
7713 #undef elf_backend_emit_relocs
7714 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
7715 #undef elf_backend_final_write_processing
7716 #define elf_backend_final_write_processing \
7717 elf_vxworks_final_write_processing
7718 #undef ELF_MAXPAGESIZE
7719 #define ELF_MAXPAGESIZE 0x1000
7720 #undef ELF_COMMONPAGESIZE