| blob | e15f51c20f4dc72e2b37f99317ef9543df2eab2c |
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;
3947 {
3953 }
3963 else
3968 else
3971 /* We have to handle relocations in vxworks .tls_vars sections
3972 specially, because the dynamic loader is 'weird'. */
3980 {
3987 bfd_vma relocation;
3989 bfd_reloc_status_type r;
3991 bfd_vma off;
3999 /* Many of the relocs are only used for relaxing, and are
4000 handled entirely by the relaxation code. */
4021 {
4024 }
4028 /* For relocs that aren't partial_inplace, we get the addend from
4029 the relocation. */
4039 {
4043 symname = bfd_elf_string_from_elf_section
4051 /* A local symbol never has STO_SH5_ISA32, so we don't need
4052 datalabel processing here. Make sure this does not change
4053 without notice. */
4061 /* Handled below. */
4062 ;
4064 {
4065 /* This is a relocatable link. We don't have to change
4066 anything, unless the reloc is against a section symbol,
4067 in which case we have to adjust according to where the
4068 section symbol winds up in the output section. */
4070 {
4072 {
4073 /* For relocations with the addend in the
4074 relocation, we need just to update the addend.
4075 All real relocs are of type partial_inplace; this
4076 code is mostly for completeness. */
4080 }
4082 /* Relocs of type partial_inplace need to pick up the
4083 contents in the contents and add the offset resulting
4084 from the changed location of the section symbol.
4085 Using _bfd_final_link_relocate (e.g. goto
4086 final_link_relocate) here would be wrong, because
4087 relocations marked pc_relative would get the current
4088 location subtracted, and we must only do that at the
4089 final link. */
4091 sec->output_offset
4095 }
4098 }
4100 {
4103 }
4106 {
4110 {
4116 }
4120 addend =
4126 }
4127 }
4128 else
4129 {
4130 /* FIXME: Ought to make use of the RELOC_FOR_GLOBAL_SYMBOL macro. */
4137 {
4138 #ifdef INCLUDE_SHMEDIA
4139 /* If the reference passes a symbol marked with
4140 STT_DATALABEL, then any STO_SH5_ISA32 on the final value
4141 doesn't count. */
4143 #endif
4145 }
4148 {
4149 bfd_boolean dyn;
4153 /* In these cases, we don't need the relocation value.
4154 We check specially because in some obscure cases
4155 sec->output_section will be NULL. */
4182 /* The cases above are those in which relocation is
4183 overwritten in the switch block below. The cases
4184 below are those in which we must defer relocation
4185 to run-time, because we can't resolve absolute
4186 addresses when creating a shared library. */
4195 /* DWARF will emit R_SH_DIR32 relocations in its
4196 sections against symbols defined externally
4197 in shared libraries. We can't do anything
4198 with them here. */
4201 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4202 sections because such sections are not SEC_ALLOC and
4203 thus ld.so will not process them. */
4210 ;
4215 /* A STO_SH5_ISA32 causes a "bitor 1" to the
4216 symbol value, unless we've seen
4217 STT_DATALABEL on the way to it. */
4221 {
4224 input_bfd,
4225 input_section,
4230 }
4231 }
4233 ;
4236 ;
4238 {
4245 }
4246 }
4255 /* Check for inter-segment relocations in FDPIC files. Most
4256 relocations connect the relocation site to the location of
4257 the target symbol, but there are some exceptions below. */
4262 else
4266 {
4267 final_link_relocate:
4268 /* COFF relocs don't use the addend. The addend is used for
4269 R_SH_DIR32 to be compatible with other compilers. */
4281 /* If the reloc is against the start of this section, then
4282 the assembler has already taken care of it and the reloc
4283 is here only to assist in relaxing. If the reloc is not
4284 against the start of this section, then it's against an
4285 external symbol and we must deal with it ourselves. */
4288 {
4295 {
4300 }
4302 {
4309 }
4312 }
4317 #ifdef INCLUDE_SHMEDIA
4321 #endif
4335 {
4343 }
4350 {
4358 }
4364 {
4372 }
4378 {
4386 }
4391 #ifdef INCLUDE_SHMEDIA
4396 #endif
4403 && !is_vxworks_tls
4406 {
4407 Elf_Internal_Rela outrel;
4411 /* When generating a shared object, these relocations
4412 are copied into the output file to be resolved at run
4413 time. */
4416 {
4417 sreloc = _bfd_elf_get_dynamic_reloc_section
4421 }
4439 {
4442 outrel.r_addend
4446 }
4447 #ifdef INCLUDE_SHMEDIA
4452 {
4456 }
4457 #endif
4462 {
4470 outrel.r_addend
4475 }
4476 else
4477 {
4478 /* h->dynindx may be -1 if this symbol was marked to
4479 become local. */
4483 {
4486 }
4487 else
4488 {
4491 }
4493 outrel.r_addend
4497 }
4505 /* If this reloc is against an external symbol, we do
4506 not want to fiddle with the addend. Otherwise, we
4507 need to include the symbol value so that it becomes
4508 an addend for the dynamic reloc. */
4511 }
4515 {
4516 bfd_vma offset;
4522 {
4525 input_bfd,
4526 input_section,
4528 symname);
4530 }
4541 }
4545 #ifdef INCLUDE_SHMEDIA
4552 #endif
4553 /* Relocation is to the entry for this symbol in the
4554 procedure linkage table. */
4565 /* Relocation is to the entry for this symbol in the global
4566 offset table extension for the procedure linkage table. */
4574 #ifdef GOT_BIAS
4576 #endif
4580 force_got:
4583 #ifdef INCLUDE_SHMEDIA
4590 #endif
4591 /* Relocation is to the entry for this symbol in the global
4592 offset table. */
4599 {
4600 bfd_boolean dyn;
4603 #ifdef INCLUDE_SHMEDIA
4605 {
4610 }
4611 #endif
4620 {
4621 /* This is actually a static link, or it is a
4622 -Bsymbolic link and the symbol is defined
4623 locally, or the symbol was forced to be local
4624 because of a version file. We must initialize
4625 this entry in the global offset table. Since the
4626 offset must always be a multiple of 4, we use the
4627 least significant bit to record whether we have
4628 initialized it already.
4630 When doing a dynamic link, we create a .rela.got
4631 relocation entry to initialize the value. This
4632 is done in the finish_dynamic_symbol routine. */
4635 else
4636 {
4639 #ifdef INCLUDE_SHMEDIA
4641 {
4646 }
4647 else
4648 #endif
4651 /* If we initialize the GOT entry here with a valid
4652 symbol address, also add a fixup. */
4661 }
4662 }
4665 }
4666 else
4667 {
4668 #ifdef INCLUDE_SHMEDIA
4670 {
4678 }
4679 else
4680 {
4681 #endif
4686 #ifdef INCLUDE_SHMEDIA
4687 }
4688 #endif
4690 /* The offset must always be a multiple of 4. We use
4691 the least significant bit to record whether we have
4692 already generated the necessary reloc. */
4695 else
4696 {
4700 {
4701 Elf_Internal_Rela outrel;
4705 {
4709 }
4715 {
4716 int dynindx
4721 }
4722 else
4723 {
4726 }
4730 }
4739 #ifdef INCLUDE_SHMEDIA
4742 else
4743 #endif
4745 }
4748 }
4750 #ifdef GOT_BIAS
4752 #endif
4755 {
4760 }
4761 else
4766 #ifdef INCLUDE_SHMEDIA
4771 #endif
4772 /* GOTOFF relocations are relative to _GLOBAL_OFFSET_TABLE_, which
4773 we place at the start of the .got.plt section. This is the same
4774 as the start of the output .got section, unless there are function
4775 descriptors in front of it. */
4782 #ifdef GOT_BIAS
4784 #endif
4789 {
4794 }
4795 else
4799 #ifdef INCLUDE_SHMEDIA
4804 #endif
4805 /* Use global offset table as symbol value. */
4810 #ifdef GOT_BIAS
4812 #endif
4819 #ifdef INCLUDE_SHMEDIA
4824 #endif
4825 /* Relocation is to the entry for this symbol in the
4826 procedure linkage table. */
4828 /* Resolve a PLT reloc against a local symbol directly,
4829 without using the procedure linkage table. */
4833 /* We don't want to warn on calls to undefined weak symbols,
4834 as calls to them must be protected by non-NULL tests
4835 anyway, and unprotected calls would invoke undefined
4836 behavior. */
4844 {
4845 /* We didn't make a PLT entry for this symbol. This
4846 happens when statically linking PIC code, or when
4847 using -Bsymbolic. */
4849 }
4857 #ifdef INCLUDE_SHMEDIA
4858 relocation++;
4859 #endif
4865 /* Relocation is to the canonical function descriptor for this
4866 symbol, possibly via the GOT. Initialize the GOT
4867 entry and function descriptor if necessary. */
4871 {
4874 bfd_vma reloc_offset;
4881 /* FIXME: See what FRV does for global symbols in the
4882 executable, with --export-dynamic. Do they need ld.so
4883 to allocate official descriptors? See what this code
4884 does. */
4890 {
4893 }
4894 else
4895 {
4900 else
4901 {
4904 }
4908 {
4911 }
4912 }
4917 /* Undefined weak symbol which will not be dynamically
4918 resolved later; leave it at zero. */
4922 {
4923 /* If the symbol needs a non-local function descriptor
4924 but binds locally (i.e., its visibility is
4925 protected), emit a dynamic relocation decayed to
4926 section+offset. This is an optimization; the dynamic
4927 linker would resolve our function descriptor request
4928 to our copy of the function anyway. */
4933 }
4935 {
4936 /* If the symbol is dynamic and there will be dynamic
4937 symbol resolution because we are or are linked with a
4938 shared library, emit a FUNCDESC relocation such that
4939 the dynamic linker will allocate the function
4940 descriptor. */
4943 }
4944 else
4945 {
4946 bfd_vma offset;
4948 /* Otherwise, we know we have a private function
4949 descriptor, so reference it directly. */
4955 {
4959 {
4964 }
4965 }
4966 else
4967 {
4974 {
4980 }
4981 }
4984 }
4987 {
4988 bfd_vma offset;
4992 {
4995 input_bfd,
4996 input_section,
4998 symname);
5000 }
5007 offset
5010 }
5013 {
5014 bfd_vma offset;
5018 {
5024 }
5027 {
5030 }
5037 offset
5043 {
5046 }
5047 else
5048 {
5051 }
5052 }
5056 funcdesc_leave_zero:
5058 {
5063 else
5066 funcdesc_done_got:
5069 #ifdef GOT_BIAS
5071 #endif
5072 }
5074 {
5079 }
5080 else
5082 }
5087 /* FIXME: See R_SH_FUNCDESC comment about global symbols in the
5088 executable and --export-dynamic. If such symbols get
5089 ld.so-allocated descriptors we can not use R_SH_GOTOFFFUNCDESC
5090 for them. */
5099 {
5100 _bfd_error_handler
5105 }
5106 else
5107 {
5108 bfd_vma offset;
5110 /* Otherwise, we know we have a private function
5111 descriptor, so reference it directly. */
5113 {
5117 {
5122 }
5123 }
5124 else
5125 {
5132 {
5138 }
5139 }
5142 }
5146 #ifdef GOT_BIAS
5148 #endif
5151 {
5156 }
5157 else
5161 {
5176 }
5187 {
5193 }
5199 {
5200 bfd_vma offset;
5204 {
5205 /* GD->LE transition:
5206 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5207 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5208 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5209 We change it into:
5210 mov.l 1f,r4; stc gbr,r0; add r4,r0; nop;
5211 nop; nop; ...
5212 1: .long x@TPOFF; 2: .long __tls_get_addr@PLT; 3:. */
5216 /* Size of GD instructions is 16 or 18. */
5220 {
5224 }
5243 }
5244 else
5245 {
5248 /* IE->LE transition:
5249 mov.l 1f,r0; stc gbr,rN; mov.l @(r0,r12),rM;
5250 bra 2f; add ...; .align 2; 1: x@GOTTPOFF; 2:
5251 We change it into:
5252 mov.l .Ln,rM; stc gbr,rN; nop; ...;
5253 1: x@TPOFF; 2:. */
5257 /* Size of IE instructions is 10 or 12. */
5261 {
5265 }
5276 }
5281 }
5288 else
5289 {
5294 }
5296 /* Relocate R_SH_TLS_IE_32 directly when statically linking. */
5299 {
5306 }
5310 else
5311 {
5312 Elf_Internal_Rela outrel;
5317 {
5320 }
5327 else
5331 R_SH_TLS_TPOFF32);
5334 else
5342 {
5344 {
5348 }
5349 else
5350 {
5352 R_SH_TLS_DTPOFF32);
5358 }
5359 }
5363 else
5365 }
5372 else
5373 {
5374 bfd_vma offset;
5377 /* GD->IE transition:
5378 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5379 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5380 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5381 We change it into:
5382 mov.l 1f,r0; stc gbr,r4; mov.l @(r0,r12),r0; add r4,r0;
5383 nop; nop; bra 3f; nop; .align 2;
5384 1: .long x@TPOFF; 2:...; 3:. */
5388 /* Size of GD instructions is 16 or 18. */
5392 {
5396 }
5400 /* Replace mov.l 1f,R4 with mov.l 1f,r0. */
5424 }
5434 {
5435 bfd_vma offset;
5438 /* LD->LE transition:
5439 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5440 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5441 1: .long x$TLSLD; 2: .long __tls_get_addr@PLT; 3:
5442 We change it into:
5443 stc gbr,r0; nop; nop; nop;
5444 nop; nop; bra 3f; ...; 3:. */
5448 /* Size of LD instructions is 16 or 18. */
5452 {
5456 }
5478 }
5486 else
5487 {
5488 Elf_Internal_Rela outrel;
5503 }
5514 else
5521 {
5523 Elf_Internal_Rela outrel;
5529 {
5533 }
5536 {
5537 sreloc = _bfd_elf_get_dynamic_reloc_section
5541 }
5545 else
5554 else
5561 }
5562 }
5564 relocation_done:
5567 {
5568 /* We don't want duplicate errors for undefined symbols. */
5570 {
5572 {
5577 }
5578 else
5582 }
5585 }
5588 {
5590 {
5595 {
5600 else
5601 {
5602 name = (bfd_elf_string_from_elf_section
5608 }
5614 }
5616 }
5617 }
5618 }
5621 }
5623 /* This is a version of bfd_generic_get_relocated_section_contents
5624 which uses sh_elf_relocate_section. */
5631 bfd_boolean relocatable,
5633 {
5641 /* We only need to handle the case of relaxing, or of having a
5642 particular set of section contents, specially. */
5647 relocatable,
5648 symbols);
5657 {
5660 bfd_size_type amt;
5662 internal_relocs = (_bfd_elf_link_read_relocs
5669 {
5677 }
5687 {
5696 else
5700 }
5714 }
5718 error_return:
5728 }
5730 /* Return the base VMA address which should be subtracted from real addresses
5731 when resolving @dtpoff relocation.
5732 This is PT_TLS segment p_vaddr. */
5734 static bfd_vma
5736 {
5737 /* If tls_sec is NULL, we should have signalled an error already. */
5741 }
5743 /* Return the relocation value for R_SH_TLS_TPOFF32.. */
5745 static bfd_vma
5747 {
5748 /* If tls_sec is NULL, we should have signalled an error already. */
5751 /* SH TLS ABI is variant I and static TLS block start just after tcbhead
5752 structure which has 2 pointer fields. */
5756 }
5764 {
5767 {
5771 }
5774 }
5776 /* Update the got entry reference counts for the section being removed. */
5778 static bfd_boolean
5781 {
5800 {
5804 #ifdef INCLUDE_SHMEDIA
5806 #endif
5810 {
5818 {
5819 #ifdef INCLUDE_SHMEDIA
5821 #endif
5823 }
5827 {
5828 /* Everything must go for SEC. */
5831 }
5832 }
5836 {
5847 #ifdef INCLUDE_SHMEDIA
5862 #endif
5868 {
5869 #ifdef INCLUDE_SHMEDIA
5871 {
5876 }
5877 else
5878 #endif
5881 }
5883 {
5884 #ifdef INCLUDE_SHMEDIA
5886 {
5889 }
5890 else
5891 #endif
5894 }
5903 /* Fall through. */
5909 else
5917 /* Fall thru */
5922 /* Fall thru */
5925 #ifdef INCLUDE_SHMEDIA
5930 #endif
5932 {
5935 }
5939 #ifdef INCLUDE_SHMEDIA
5946 #endif
5948 {
5952 {
5956 }
5957 #ifdef INCLUDE_SHMEDIA
5959 {
5962 }
5963 #endif
5966 }
5968 {
5969 #ifdef INCLUDE_SHMEDIA
5971 {
5974 }
5975 else
5976 #endif
5979 }
5984 }
5985 }
5988 }
5990 /* Copy the extra info we tack onto an elf_link_hash_entry. */
5992 static void
5996 {
6003 {
6005 {
6009 /* Add reloc counts against the indirect sym to the direct sym
6010 list. Merge any entries against the same section. */
6012 {
6017 {
6022 }
6025 }
6027 }
6031 }
6034 #ifdef INCLUDE_SHMEDIA
6037 #endif
6045 {
6048 }
6052 {
6053 /* If called to transfer flags for a weakdef during processing
6054 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
6055 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
6060 }
6061 else
6063 }
6065 static int
6068 {
6073 {
6081 }
6084 }
6086 /* Look through the relocs for a section during the first phase.
6087 Since we don't do .gots or .plts, we just need to consider the
6088 virtual table relocs for gc. */
6090 static bfd_boolean
6093 {
6119 {
6122 #ifdef INCLUDE_SHMEDIA
6124 #endif
6131 else
6132 {
6136 {
6137 #ifdef INCLUDE_SHMEDIA
6139 #endif
6141 }
6142 }
6156 {
6163 {
6166 {
6173 }
6174 }
6176 }
6178 /* Some relocs require a global offset table. */
6180 {
6182 {
6184 /* This may require an rofixup. */
6198 #ifdef INCLUDE_SHMEDIA
6219 #endif
6231 }
6232 }
6235 {
6236 /* This relocation describes the C++ object vtable hierarchy.
6237 Reconstruct it for later use during GC. */
6243 /* This relocation describes which C++ vtable entries are actually
6244 used. Record for later use during GC. */
6256 /* FALLTHROUGH */
6257 force_got:
6261 #ifdef INCLUDE_SHMEDIA
6268 #endif
6272 {
6286 }
6289 {
6290 #ifdef INCLUDE_SHMEDIA
6292 {
6297 }
6298 else
6299 #endif
6302 }
6303 else
6304 {
6307 /* This is a global offset table entry for a local
6308 symbol. */
6311 {
6312 bfd_size_type size;
6316 #ifdef INCLUDE_SHMEDIA
6317 /* Reserve space for both the datalabel and
6318 codelabel local GOT offsets. */
6320 #endif
6327 #ifdef INCLUDE_SHMEDIA
6328 /* Take care of both the datalabel and codelabel local
6329 GOT offsets. */
6332 #else
6335 #endif
6336 }
6337 #ifdef INCLUDE_SHMEDIA
6340 else
6341 #endif
6344 }
6346 /* If a TLS symbol is accessed using IE at least once,
6347 there is no point to use dynamic model for it. */
6350 {
6353 else
6354 {
6365 else
6370 }
6371 }
6374 {
6377 else
6379 }
6391 {
6394 abfd);
6396 }
6399 {
6402 /* We need a function descriptor for a local symbol. */
6405 {
6406 bfd_size_type size;
6409 #ifdef INCLUDE_SHMEDIA
6410 /* Count datalabel local GOT. */
6412 #endif
6417 }
6421 {
6424 else
6426 }
6427 }
6428 else
6429 {
6434 /* If there is a function descriptor reference, then
6435 there should not be any non-FDPIC references. */
6438 {
6443 else
6447 }
6448 }
6452 #ifdef INCLUDE_SHMEDIA
6459 #endif
6460 /* If this is a local symbol, we resolve it directly without
6461 creating a procedure linkage table entry. */
6477 #ifdef INCLUDE_SHMEDIA
6482 #endif
6483 /* This symbol requires a procedure linkage table entry. We
6484 actually build the entry in adjust_dynamic_symbol,
6485 because this might be a case of linking PIC code which is
6486 never referenced by a dynamic object, in which case we
6487 don't need to generate a procedure linkage table entry
6488 after all. */
6490 /* If this is a local symbol, we resolve it directly without
6491 creating a procedure linkage table entry. */
6504 #ifdef INCLUDE_SHMEDIA
6509 #endif
6511 {
6514 }
6516 /* If we are creating a shared library, and this is a reloc
6517 against a global symbol, or a non PC relative reloc
6518 against a local symbol, then we need to copy the reloc
6519 into the shared library. However, if we are linking with
6520 -Bsymbolic, we do not need to copy a reloc against a
6521 global symbol which is defined in an object we are
6522 including in the link (i.e., DEF_REGULAR is set). At
6523 this point we have not seen all the input files, so it is
6524 possible that DEF_REGULAR is not set now but will be set
6525 later (it is never cleared). We account for that
6526 possibility below by storing information in the
6527 dyn_relocs field of the hash table entry. A similar
6528 situation occurs when creating shared libraries and symbol
6529 visibility changes render the symbol local.
6531 If on the other hand, we are creating an executable, we
6532 may need to keep relocations for symbols satisfied by a
6533 dynamic library if we manage to avoid copy relocs for the
6534 symbol. */
6547 {
6554 /* When creating a shared object, we must copy these
6555 reloc types into the output file. We create a reloc
6556 section in dynobj and make room for this reloc. */
6558 {
6559 sreloc = _bfd_elf_make_dynamic_reloc_section
6564 }
6566 /* If this is a global symbol, we count the number of
6567 relocations we need for this symbol. */
6570 else
6571 {
6572 /* Track dynamic relocs needed for local syms too. */
6588 }
6592 {
6602 }
6606 #ifdef INCLUDE_SHMEDIA
6611 #endif
6612 )
6614 }
6616 /* Allocate the fixup regardless of whether we need a relocation.
6617 If we end up generating the relocation, we'll unallocate the
6618 fixup. */
6627 {
6630 abfd);
6632 }
6637 /* Nothing to do. */
6642 }
6643 }
6646 }
6648 #ifndef sh_elf_set_mach_from_flags
6651 static bfd_boolean
6653 {
6665 }
6668 /* Reverse table lookup for sh_ef_bfd_table[].
6669 Given a bfd MACH value from archures.c
6670 return the equivalent ELF flags from the table.
6671 Return -1 if no match is found. */
6673 int
6675 {
6682 /* shouldn't get here */
6686 }
6689 #ifndef sh_elf_set_private_flags
6690 /* Function to keep SH specific file flags. */
6692 static bfd_boolean
6694 {
6701 }
6704 #ifndef sh_elf_copy_private_data
6705 /* Copy backend specific data from one object module to another */
6707 static bfd_boolean
6709 {
6710 /* Copy object attributes. */
6716 /* Copy the stack size. */
6719 {
6724 {
6729 {
6732 /* Rewrite the phdrs, since we're only called after they
6733 were first written. */
6742 }
6745 }
6746 }
6749 }
6752 #ifndef sh_elf_merge_private_data
6754 /* This function returns the ELF architecture number that
6755 corresponds to the given arch_sh* flags. */
6757 int
6759 {
6764 }
6766 /* This routine initialises the elf flags when required and
6767 calls sh_merge_bfd_arch() to check dsp/fpu compatibility. */
6769 static bfd_boolean
6771 {
6778 {
6779 /* This happens when ld starts out with a 'blank' output file. */
6785 }
6788 {
6791 ibfd);
6794 }
6801 {
6803 ibfd);
6806 }
6809 }
6812 /* Override the generic function because we need to store sh_elf_obj_tdata
6813 as the specific tdata. We set also the machine architecture from flags
6814 here. */
6816 static bfd_boolean
6818 {
6824 }
6826 /* Finish up dynamic symbol handling. We set the contents of various
6827 dynamic sections here. */
6829 static bfd_boolean
6833 {
6841 {
6846 bfd_vma plt_index;
6847 bfd_vma got_offset;
6848 Elf_Internal_Rela rel;
6852 /* This symbol has an entry in the procedure linkage table. Set
6853 it up. */
6862 /* Get the index in the procedure linkage table which
6863 corresponds to this symbol. This is the index of this symbol
6864 in all the symbols for which we are making plt entries. The
6865 first entry in the procedure linkage table is reserved. */
6872 /* Get the offset into the .got table of the entry that
6873 corresponds to this function. */
6875 /* The offset must be relative to the GOT symbol, twelve bytes
6876 before the end of .got.plt. Each descriptor is eight
6877 bytes. */
6879 else
6880 /* Each .got entry is 4 bytes. The first three are
6881 reserved. */
6884 #ifdef GOT_BIAS
6887 #endif
6889 /* Fill in the entry in the procedure linkage table. */
6895 {
6897 {
6898 bfd_reloc_status_type r;
6904 }
6905 else
6910 }
6911 else
6912 {
6923 {
6927 /* Divide the PLT into groups. The first group contains
6928 REACHABLE_PLTS entries and the other groups contain
6929 PLTS_PER_4K entries. Entries in the first group can
6930 branch directly to .plt; those in later groups branch
6931 to the last element of the previous group. */
6932 /* ??? It would be better to create multiple copies of
6933 the common resolver stub. */
6942 else
6946 /* Install the 'bra' with this offset. */
6952 }
6953 else
6959 }
6961 /* Make got_offset relative to the start of .got.plt. */
6962 #ifdef GOT_BIAS
6965 #endif
6976 /* Fill in the entry in the global offset table. */
6989 /* Fill in the entry in the .rela.plt section. */
6995 else
6998 #ifdef GOT_BIAS
7000 #endif
7005 {
7006 /* Create the .rela.plt.unloaded relocations for this PLT entry.
7007 Begin by pointing LOC to the first such relocation. */
7011 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation
7012 for the PLT entry's pointer to the .got.plt entry. */
7022 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for
7023 the .got.plt entry, which initially points to .plt. */
7030 }
7033 {
7034 /* Mark the symbol as undefined, rather than as defined in
7035 the .plt section. Leave the value alone. */
7037 }
7038 }
7044 {
7047 Elf_Internal_Rela rel;
7050 /* This symbol has an entry in the global offset table. Set it
7051 up. */
7061 /* If this is a static link, or it is a -Bsymbolic link and the
7062 symbol is defined locally or was forced to be local because
7063 of a version file, we just want to emit a RELATIVE reloc.
7064 The entry in the global offset table will already have been
7065 initialized in the relocate_section function. */
7068 {
7070 {
7072 int dynindx
7078 }
7079 else
7080 {
7085 }
7086 }
7087 else
7088 {
7092 }
7097 }
7099 #ifdef INCLUDE_SHMEDIA
7100 {
7105 {
7108 Elf_Internal_Rela rel;
7111 /* This symbol has a datalabel entry in the global offset table.
7112 Set it up. */
7122 /* If this is a static link, or it is a -Bsymbolic link and the
7123 symbol is defined locally or was forced to be local because
7124 of a version file, we just want to emit a RELATIVE reloc.
7125 The entry in the global offset table will already have been
7126 initialized in the relocate_section function. */
7129 {
7131 {
7133 int dynindx
7139 }
7140 else
7141 {
7146 }
7147 }
7148 else
7149 {
7154 }
7159 }
7160 }
7161 #endif
7164 {
7166 Elf_Internal_Rela rel;
7169 /* This symbol needs a copy reloc. Set it up. */
7186 }
7188 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. On VxWorks,
7189 _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
7190 ".got" section. */
7196 }
7198 /* Finish up the dynamic sections. */
7200 static bfd_boolean
7202 {
7215 {
7224 {
7225 Elf_Internal_Dyn dyn;
7227 #ifdef INCLUDE_SHMEDIA
7229 #endif
7234 {
7241 #ifdef INCLUDE_SHMEDIA
7248 get_sym:
7250 {
7256 {
7259 }
7260 }
7262 #endif
7287 /* My reading of the SVR4 ABI indicates that the
7288 procedure linkage table relocs (DT_JMPREL) should be
7289 included in the overall relocs (DT_RELA). This is
7290 what Solaris does. However, UnixWare can not handle
7291 that case. Therefore, we override the DT_RELASZ entry
7292 here to make it not include the JMPREL relocs. Since
7293 the linker script arranges for .rela.plt to follow all
7294 other relocation sections, we don't have to worry
7295 about changing the DT_RELA entry. */
7297 {
7300 }
7303 }
7304 }
7306 /* Fill in the first entry in the procedure linkage table. */
7309 {
7325 {
7326 /* Finalize the .rela.plt.unloaded contents. */
7327 Elf_Internal_Rela rel;
7330 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for the
7331 first PLT entry's pointer to _GLOBAL_OFFSET_TABLE_ + 8. */
7341 /* Fix up the remaining .rela.plt.unloaded relocations.
7342 They may have the wrong symbol index for _G_O_T_ or
7343 _P_L_T_ depending on the order in which symbols were
7344 output. */
7346 {
7347 /* The PLT entry's pointer to the .got.plt slot. */
7350 R_SH_DIR32);
7354 /* The .got.plt slot's pointer to .plt. */
7357 R_SH_DIR32);
7360 }
7361 }
7363 /* UnixWare sets the entsize of .plt to 4, although that doesn't
7364 really seem like the right value. */
7366 }
7367 }
7369 /* Fill in the first three entries in the global offset table. */
7371 {
7374 else
7380 }
7385 /* At the very end of the .rofixup section is a pointer to the GOT. */
7387 {
7395 /* Make sure we allocated and generated the same number of fixups. */
7397 }
7408 }
7410 static enum elf_reloc_type_class
7412 {
7414 {
7423 }
7424 }
7426 #if !defined SH_TARGET_ALREADY_DEFINED
7427 /* Support for Linux core dump NOTE sections. */
7429 static bfd_boolean
7431 {
7436 {
7441 /* pr_cursig */
7444 /* pr_pid */
7447 /* pr_reg */
7452 }
7454 /* Make a ".reg/999" section. */
7457 }
7459 static bfd_boolean
7461 {
7463 {
7472 }
7474 /* Note that for some reason, a spurious space is tacked
7475 onto the end of the args in some (at least one anyway)
7476 implementations, so strip it off if it exists. */
7478 {
7484 }
7487 }
7491 /* Return address for Ith PLT stub in section PLT, for relocation REL
7492 or (bfd_vma) -1 if it should not be included. */
7494 static bfd_vma
7497 {
7502 }
7504 /* Decide whether to attempt to turn absptr or lsda encodings in
7505 shared libraries into pcrel within the given input section. */
7507 static bfd_boolean
7511 {
7514 /* We can't use PC-relative encodings in FDPIC binaries, in general. */
7519 }
7521 /* Adjust the contents of an eh_frame_hdr section before they're output. */
7523 static bfd_byte
7529 {
7546 == (sh_elf_osec_to_segment
7555 }
7557 #if !defined SH_TARGET_ALREADY_DEFINED
7558 #define TARGET_BIG_SYM bfd_elf32_sh_vec
7560 #define TARGET_LITTLE_SYM bfd_elf32_shl_vec
7562 #endif
7564 #define ELF_ARCH bfd_arch_sh
7565 #define ELF_TARGET_ID SH_ELF_DATA
7566 #define ELF_MACHINE_CODE EM_SH
7567 #ifdef __QNXTARGET__
7568 #define ELF_MAXPAGESIZE 0x1000
7569 #else
7570 #define ELF_MAXPAGESIZE 0x80
7571 #endif
7575 #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup
7576 #define bfd_elf32_bfd_reloc_name_lookup \
7577 sh_elf_reloc_name_lookup
7578 #define elf_info_to_howto sh_elf_info_to_howto
7579 #define bfd_elf32_bfd_relax_section sh_elf_relax_section
7580 #define elf_backend_relocate_section sh_elf_relocate_section
7581 #define bfd_elf32_bfd_get_relocated_section_contents \
7582 sh_elf_get_relocated_section_contents
7583 #define bfd_elf32_mkobject sh_elf_mkobject
7584 #define elf_backend_object_p sh_elf_object_p
7585 #define bfd_elf32_bfd_set_private_bfd_flags \
7586 sh_elf_set_private_flags
7587 #define bfd_elf32_bfd_copy_private_bfd_data \
7588 sh_elf_copy_private_data
7589 #define bfd_elf32_bfd_merge_private_bfd_data \
7590 sh_elf_merge_private_data
7592 #define elf_backend_gc_mark_hook sh_elf_gc_mark_hook
7593 #define elf_backend_gc_sweep_hook sh_elf_gc_sweep_hook
7594 #define elf_backend_check_relocs sh_elf_check_relocs
7595 #define elf_backend_copy_indirect_symbol \
7596 sh_elf_copy_indirect_symbol
7597 #define elf_backend_create_dynamic_sections \
7598 sh_elf_create_dynamic_sections
7599 #define bfd_elf32_bfd_link_hash_table_create \
7600 sh_elf_link_hash_table_create
7601 #define elf_backend_adjust_dynamic_symbol \
7602 sh_elf_adjust_dynamic_symbol
7603 #define elf_backend_always_size_sections \
7604 sh_elf_always_size_sections
7605 #define elf_backend_size_dynamic_sections \
7606 sh_elf_size_dynamic_sections
7607 #define elf_backend_omit_section_dynsym sh_elf_omit_section_dynsym
7608 #define elf_backend_finish_dynamic_symbol \
7609 sh_elf_finish_dynamic_symbol
7610 #define elf_backend_finish_dynamic_sections \
7611 sh_elf_finish_dynamic_sections
7612 #define elf_backend_reloc_type_class sh_elf_reloc_type_class
7613 #define elf_backend_plt_sym_val sh_elf_plt_sym_val
7614 #define elf_backend_can_make_relative_eh_frame \
7615 sh_elf_use_relative_eh_frame
7616 #define elf_backend_can_make_lsda_relative_eh_frame \
7617 sh_elf_use_relative_eh_frame
7618 #define elf_backend_encode_eh_address \
7619 sh_elf_encode_eh_address
7621 #define elf_backend_can_gc_sections 1
7622 #define elf_backend_can_refcount 1
7623 #define elf_backend_want_got_plt 1
7624 #define elf_backend_plt_readonly 1
7625 #define elf_backend_want_plt_sym 0
7626 #define elf_backend_got_header_size 12
7628 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
7632 /* NetBSD support. */
7633 #undef TARGET_BIG_SYM
7634 #define TARGET_BIG_SYM bfd_elf32_shnbsd_vec
7635 #undef TARGET_BIG_NAME
7637 #undef TARGET_LITTLE_SYM
7638 #define TARGET_LITTLE_SYM bfd_elf32_shlnbsd_vec
7639 #undef TARGET_LITTLE_NAME
7641 #undef ELF_MAXPAGESIZE
7642 #define ELF_MAXPAGESIZE 0x10000
7643 #undef ELF_COMMONPAGESIZE
7644 #undef elf_symbol_leading_char
7645 #define elf_symbol_leading_char 0
7646 #undef elf32_bed
7647 #define elf32_bed elf32_sh_nbsd_bed
7652 /* Linux support. */
7653 #undef TARGET_BIG_SYM
7654 #define TARGET_BIG_SYM bfd_elf32_shblin_vec
7655 #undef TARGET_BIG_NAME
7657 #undef TARGET_LITTLE_SYM
7658 #define TARGET_LITTLE_SYM bfd_elf32_shlin_vec
7659 #undef TARGET_LITTLE_NAME
7661 #undef ELF_COMMONPAGESIZE
7662 #define ELF_COMMONPAGESIZE 0x1000
7664 #undef elf_backend_grok_prstatus
7665 #define elf_backend_grok_prstatus elf32_shlin_grok_prstatus
7666 #undef elf_backend_grok_psinfo
7667 #define elf_backend_grok_psinfo elf32_shlin_grok_psinfo
7668 #undef elf32_bed
7669 #define elf32_bed elf32_sh_lin_bed
7674 /* FDPIC support. */
7675 #undef TARGET_BIG_SYM
7676 #define TARGET_BIG_SYM bfd_elf32_shbfd_vec
7677 #undef TARGET_BIG_NAME
7679 #undef TARGET_LITTLE_SYM
7680 #define TARGET_LITTLE_SYM bfd_elf32_shfd_vec
7681 #undef TARGET_LITTLE_NAME
7683 #undef elf_backend_modify_program_headers
7684 #define elf_backend_modify_program_headers \
7685 sh_elf_modify_program_headers
7687 #undef elf32_bed
7688 #define elf32_bed elf32_sh_fd_bed
7692 #undef elf_backend_modify_program_headers
7694 /* VxWorks support. */
7695 #undef TARGET_BIG_SYM
7696 #define TARGET_BIG_SYM bfd_elf32_shvxworks_vec
7697 #undef TARGET_BIG_NAME
7699 #undef TARGET_LITTLE_SYM
7700 #define TARGET_LITTLE_SYM bfd_elf32_shlvxworks_vec
7701 #undef TARGET_LITTLE_NAME
7703 #undef elf32_bed
7704 #define elf32_bed elf32_sh_vxworks_bed
7706 #undef elf_backend_want_plt_sym
7707 #define elf_backend_want_plt_sym 1
7708 #undef elf_symbol_leading_char
7710 #define elf_backend_want_got_underscore 1
7711 #undef elf_backend_grok_prstatus
7712 #undef elf_backend_grok_psinfo
7713 #undef elf_backend_add_symbol_hook
7714 #define elf_backend_add_symbol_hook elf_vxworks_add_symbol_hook
7715 #undef elf_backend_link_output_symbol_hook
7716 #define elf_backend_link_output_symbol_hook \
7717 elf_vxworks_link_output_symbol_hook
7718 #undef elf_backend_emit_relocs
7719 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
7720 #undef elf_backend_final_write_processing
7721 #define elf_backend_final_write_processing \
7722 elf_vxworks_final_write_processing
7723 #undef ELF_MAXPAGESIZE
7724 #define ELF_MAXPAGESIZE 0x1000
7725 #undef ELF_COMMONPAGESIZE