| blob | 780a3bf6b0fd898b52b0a04dfa0631633db848c5 |
1 /* Renesas / SuperH SH specific support for 32-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3 2006, 2007, 2008, 2009, 2010, 2011 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 {
2989 {
2990 /* The symbol has been forced local, or we have some direct got refs,
2991 so treat all the gotplt refs as got refs. */
2995 }
3001 {
3002 /* Make sure this symbol is output as a dynamic symbol.
3003 Undefined weak syms won't yet be marked as dynamic. */
3006 {
3009 }
3013 {
3017 /* If this is the first .plt entry, make room for the special
3018 first entry. */
3024 /* If this symbol is not defined in a regular file, and we are
3025 not generating a shared library, then set the symbol to this
3026 location in the .plt. This is required to make function
3027 pointers compare as equal between the normal executable and
3028 the shared library. Skip this for FDPIC, since the
3029 function's address will be the address of the canonical
3030 function descriptor. */
3032 {
3035 }
3037 /* Make room for this entry. */
3044 /* We also need to make an entry in the .got.plt section, which
3045 will be placed in the .got section by the linker script. */
3048 else
3051 /* We also need to make an entry in the .rel.plt section. */
3055 {
3056 /* VxWorks executables have a second set of relocations
3057 for each PLT entry. They go in a separate relocation
3058 section, which is processed by the kernel loader. */
3060 /* There is a relocation for the initial PLT entry:
3061 an R_SH_DIR32 relocation for _GLOBAL_OFFSET_TABLE_. */
3065 /* There are two extra relocations for each subsequent
3066 PLT entry: an R_SH_DIR32 relocation for the GOT entry,
3067 and an R_SH_DIR32 relocation for the PLT entry. */
3069 }
3070 }
3071 else
3072 {
3075 }
3076 }
3077 else
3078 {
3081 }
3084 {
3086 bfd_boolean dyn;
3089 /* Make sure this symbol is output as a dynamic symbol.
3090 Undefined weak syms won't yet be marked as dynamic. */
3093 {
3096 }
3101 /* R_SH_TLS_GD needs 2 consecutive GOT slots. */
3106 {
3107 /* No dynamic relocations required. */
3112 }
3113 /* R_SH_TLS_IE_32 needs one dynamic relocation if dynamic,
3114 R_SH_TLS_GD needs one if local symbol and two if global. */
3121 {
3124 else
3126 }
3136 }
3137 else
3140 #ifdef INCLUDE_SHMEDIA
3142 {
3144 bfd_boolean dyn;
3146 /* Make sure this symbol is output as a dynamic symbol.
3147 Undefined weak syms won't yet be marked as dynamic. */
3150 {
3153 }
3161 }
3162 else
3164 #endif
3166 /* Allocate space for any dynamic relocations to function
3167 descriptors, canonical or otherwise. We need to relocate the
3168 reference unless it resolves to zero, which only happens for
3169 undefined weak symbols (either non-default visibility, or when
3170 static linking). Any GOT slot is accounted for elsewhere. */
3175 {
3178 else
3181 }
3183 /* We must allocate a function descriptor if there are references to
3184 a canonical descriptor (R_SH_GOTFUNCDESC or R_SH_FUNCDESC) and
3185 the dynamic linker isn't going to allocate it. None of this
3186 applies if we already created one in .got.plt, but if the
3187 canonical function descriptor can be in this object, there
3188 won't be a PLT entry at all. */
3193 {
3194 /* Make room for this function descriptor. */
3198 /* We will need a relocation or two fixups to initialize the
3199 function descriptor, so allocate those too. */
3202 else
3204 }
3209 /* In the shared -Bsymbolic case, discard space allocated for
3210 dynamic pc-relative relocs against symbols which turn out to be
3211 defined in regular objects. For the normal shared case, discard
3212 space for pc-relative relocs that have become local due to symbol
3213 visibility changes. */
3216 {
3218 {
3222 {
3227 else
3229 }
3230 }
3233 {
3237 {
3240 else
3242 }
3243 }
3245 /* Also discard relocs on undefined weak syms with non-default
3246 visibility. */
3249 {
3253 /* Make sure undefined weak symbols are output as a dynamic
3254 symbol in PIEs. */
3257 {
3260 }
3261 }
3262 }
3263 else
3264 {
3265 /* For the non-shared case, discard space for relocs against
3266 symbols which turn out to need copy relocs or are not
3267 dynamic. */
3275 {
3276 /* Make sure this symbol is output as a dynamic symbol.
3277 Undefined weak syms won't yet be marked as dynamic. */
3280 {
3283 }
3285 /* If that succeeded, we know we'll be keeping all the
3286 relocs. */
3289 }
3293 keep: ;
3294 }
3296 /* Finally, allocate space. */
3298 {
3302 /* If we need relocations, we do not need fixups. */
3305 }
3308 }
3310 /* Find any dynamic relocs that apply to read-only sections. */
3312 static bfd_boolean
3314 {
3320 {
3324 {
3329 /* Not an error, just cut short the traversal. */
3331 }
3332 }
3334 }
3336 /* This function is called after all the input files have been read,
3337 and the input sections have been assigned to output sections.
3338 It's a convenient place to determine the PLT style. */
3340 static bfd_boolean
3342 {
3346 {
3349 /* Force a PT_GNU_STACK segment to be created. */
3353 /* Define __stacksize if it's not defined yet. */
3359 {
3372 }
3373 }
3375 }
3377 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
3379 static bfd_boolean
3381 {
3386 /* objcopy and strip preserve what's already there using
3387 sh_elf_copy_private_bfd_data (). */
3396 {
3399 /* Obtain the pointer to the __stacksize symbol. */
3403 {
3408 }
3410 /* Set the header p_memsz from the symbol value. We
3411 intentionally ignore the symbol section. */
3414 else
3418 }
3421 }
3423 #endif
3425 /* Set the sizes of the dynamic sections. */
3427 static bfd_boolean
3430 {
3434 bfd_boolean relocs;
3445 {
3446 /* Set the contents of the .interp section to the interpreter. */
3448 {
3453 }
3454 }
3456 /* Set up .got offsets for local syms, and space for local dynamic
3457 relocs. */
3459 {
3464 bfd_size_type locsymcount;
3472 {
3479 {
3482 {
3483 /* Input section has been discarded, either because
3484 it is a copy of a linkonce section or due to
3485 linker script /DISCARD/, so we'll be discarding
3486 the relocs too. */
3487 }
3491 {
3492 /* Relocations in vxworks .tls_vars sections are
3493 handled specially by the loader. */
3494 }
3496 {
3502 /* If we need relocations, we do not need fixups. */
3505 }
3506 }
3507 }
3511 #ifdef INCLUDE_SHMEDIA
3512 /* Count datalabel local GOT. */
3514 #endif
3520 {
3525 {
3527 {
3534 else
3538 {
3540 {
3541 bfd_size_type size;
3545 size);
3549 local_funcdesc += (local_got
3551 }
3554 }
3555 }
3556 else
3559 }
3560 }
3564 {
3568 {
3570 {
3575 else
3577 }
3578 else
3580 }
3581 }
3583 }
3586 {
3587 /* Allocate 2 got entries and 1 dynamic reloc for R_SH_TLS_LD_32
3588 relocs. */
3592 }
3593 else
3596 /* Only the reserved entries should be present. For FDPIC, they go at
3597 the end of .got.plt. */
3599 {
3602 }
3604 /* Allocate global sym .plt and .got entries, and space for global
3605 sym dynamic relocs. */
3608 /* Move the reserved entries and the _GLOBAL_OFFSET_TABLE_ symbol to the
3609 end of the FDPIC .got.plt. */
3611 {
3614 }
3616 /* At the very end of the .rofixup section is a pointer to the GOT. */
3620 /* We now have determined the sizes of the various dynamic sections.
3621 Allocate memory for them. */
3624 {
3634 {
3635 /* Strip this section if we don't need it; see the
3636 comment below. */
3637 }
3639 {
3643 /* We use the reloc_count field as a counter if we need
3644 to copy relocs into the output file. */
3646 }
3647 else
3648 {
3649 /* It's not one of our sections, so don't allocate space. */
3651 }
3654 {
3655 /* If we don't need this section, strip it from the
3656 output file. This is mostly to handle .rela.bss and
3657 .rela.plt. We must create both sections in
3658 create_dynamic_sections, because they must be created
3659 before the linker maps input sections to output
3660 sections. The linker does that before
3661 adjust_dynamic_symbol is called, and it is that
3662 function which decides whether anything needs to go
3663 into these sections. */
3667 }
3672 /* Allocate memory for the section contents. We use bfd_zalloc
3673 here in case unused entries are not reclaimed before the
3674 section's contents are written out. This should not happen,
3675 but this way if it does, we get a R_SH_NONE reloc instead
3676 of garbage. */
3680 }
3683 {
3684 /* Add some entries to the .dynamic section. We fill in the
3685 values later, in sh_elf_finish_dynamic_sections, but we
3686 must add the entries now so that we get the correct size for
3687 the .dynamic section. The DT_DEBUG entry is filled in by the
3688 dynamic linker and used by the debugger. */
3689 #define add_dynamic_entry(TAG, VAL) \
3690 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3693 {
3696 }
3699 {
3705 }
3708 {
3711 }
3714 {
3721 /* If any dynamic relocs apply to a read-only section,
3722 then we need a DT_TEXTREL entry. */
3727 {
3730 }
3731 }
3735 }
3736 #undef add_dynamic_entry
3739 }
3740 \f
3741 /* Add a dynamic relocation to the SRELOC section. */
3746 {
3747 Elf_Internal_Rela outrel;
3748 bfd_vma reloc_offset;
3761 }
3763 /* Add an FDPIC read-only fixup. */
3767 {
3768 bfd_vma fixup_offset;
3773 }
3775 /* Return the offset of the generated .got section from the
3776 _GLOBAL_OFFSET_TABLE_ symbol. */
3778 static bfd_signed_vma
3780 {
3783 }
3785 /* Find the segment number in which OSEC, and output section, is
3786 located. */
3788 static unsigned
3790 {
3792 osec);
3794 /* FIXME: Nothing ever says what this index is relative to. The kernel
3795 supplies data in terms of the number of load segments but this is
3796 a phdr index and the first phdr may not be a load segment. */
3798 }
3800 static bfd_boolean
3802 {
3806 }
3808 /* Generate the initial contents of a local function descriptor, along
3809 with any relocations or fixups required. */
3810 static bfd_boolean
3814 bfd_vma offset,
3816 bfd_vma value)
3817 {
3824 /* FIXME: The ABI says that the offset to the function goes in the
3825 descriptor, along with the segment index. We're RELA, so it could
3826 go in the reloc instead... */
3829 {
3832 }
3835 {
3839 }
3840 else
3841 {
3845 }
3848 {
3850 {
3852 offset
3859 }
3861 /* There are no dynamic relocations so fill in the final
3862 address and gp value (barring fixups). */
3867 }
3868 else
3870 offset
3879 }
3881 /* Install a 20-bit movi20 field starting at ADDR, which occurs in OUTPUT_BFD.
3882 VALUE is the field's value. Return bfd_reloc_ok if successful or an error
3883 otherwise. */
3885 static bfd_reloc_status_type
3889 {
3892 bfd_reloc_status_type r;
3908 }
3910 /* Relocate an SH ELF section. */
3912 static bfd_boolean
3918 {
3930 bfd_boolean is_vxworks_tls;
3938 {
3944 }
3954 else
3959 else
3962 /* We have to handle relocations in vxworks .tls_vars sections
3963 specially, because the dynamic loader is 'weird'. */
3971 {
3978 bfd_vma relocation;
3980 bfd_reloc_status_type r;
3982 bfd_vma off;
3990 /* Many of the relocs are only used for relaxing, and are
3991 handled entirely by the relaxation code. */
4012 {
4015 }
4019 /* For relocs that aren't partial_inplace, we get the addend from
4020 the relocation. */
4030 {
4034 symname = bfd_elf_string_from_elf_section
4042 /* A local symbol never has STO_SH5_ISA32, so we don't need
4043 datalabel processing here. Make sure this does not change
4044 without notice. */
4052 /* Handled below. */
4053 ;
4055 {
4056 /* This is a relocatable link. We don't have to change
4057 anything, unless the reloc is against a section symbol,
4058 in which case we have to adjust according to where the
4059 section symbol winds up in the output section. */
4061 {
4063 {
4064 /* For relocations with the addend in the
4065 relocation, we need just to update the addend.
4066 All real relocs are of type partial_inplace; this
4067 code is mostly for completeness. */
4071 }
4073 /* Relocs of type partial_inplace need to pick up the
4074 contents in the contents and add the offset resulting
4075 from the changed location of the section symbol.
4076 Using _bfd_final_link_relocate (e.g. goto
4077 final_link_relocate) here would be wrong, because
4078 relocations marked pc_relative would get the current
4079 location subtracted, and we must only do that at the
4080 final link. */
4082 sec->output_offset
4086 }
4089 }
4091 {
4094 }
4097 {
4101 {
4107 }
4111 addend =
4117 }
4118 }
4119 else
4120 {
4121 /* FIXME: Ought to make use of the RELOC_FOR_GLOBAL_SYMBOL macro. */
4128 {
4129 #ifdef INCLUDE_SHMEDIA
4130 /* If the reference passes a symbol marked with
4131 STT_DATALABEL, then any STO_SH5_ISA32 on the final value
4132 doesn't count. */
4134 #endif
4136 }
4139 {
4140 bfd_boolean dyn;
4144 /* In these cases, we don't need the relocation value.
4145 We check specially because in some obscure cases
4146 sec->output_section will be NULL. */
4173 /* The cases above are those in which relocation is
4174 overwritten in the switch block below. The cases
4175 below are those in which we must defer relocation
4176 to run-time, because we can't resolve absolute
4177 addresses when creating a shared library. */
4186 /* DWARF will emit R_SH_DIR32 relocations in its
4187 sections against symbols defined externally
4188 in shared libraries. We can't do anything
4189 with them here. */
4192 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4193 sections because such sections are not SEC_ALLOC and
4194 thus ld.so will not process them. */
4201 ;
4206 /* A STO_SH5_ISA32 causes a "bitor 1" to the
4207 symbol value, unless we've seen
4208 STT_DATALABEL on the way to it. */
4213 input_section,
4216 {
4219 input_bfd,
4220 input_section,
4225 }
4226 }
4228 ;
4231 ;
4233 {
4240 }
4241 }
4250 /* Check for inter-segment relocations in FDPIC files. Most
4251 relocations connect the relocation site to the location of
4252 the target symbol, but there are some exceptions below. */
4257 else
4261 {
4262 final_link_relocate:
4263 /* COFF relocs don't use the addend. The addend is used for
4264 R_SH_DIR32 to be compatible with other compilers. */
4276 /* If the reloc is against the start of this section, then
4277 the assembler has already taken care of it and the reloc
4278 is here only to assist in relaxing. If the reloc is not
4279 against the start of this section, then it's against an
4280 external symbol and we must deal with it ourselves. */
4283 {
4290 {
4295 }
4297 {
4304 }
4307 }
4312 #ifdef INCLUDE_SHMEDIA
4316 #endif
4330 {
4338 }
4345 {
4353 }
4359 {
4367 }
4373 {
4381 }
4386 #ifdef INCLUDE_SHMEDIA
4391 #endif
4398 && !is_vxworks_tls
4401 {
4402 Elf_Internal_Rela outrel;
4406 /* When generating a shared object, these relocations
4407 are copied into the output file to be resolved at run
4408 time. */
4411 {
4412 sreloc = _bfd_elf_get_dynamic_reloc_section
4416 }
4434 {
4437 outrel.r_addend
4441 }
4442 #ifdef INCLUDE_SHMEDIA
4447 {
4451 }
4452 #endif
4457 {
4465 outrel.r_addend
4470 }
4471 else
4472 {
4473 /* h->dynindx may be -1 if this symbol was marked to
4474 become local. */
4478 {
4481 }
4482 else
4483 {
4486 }
4488 outrel.r_addend
4492 }
4500 /* If this reloc is against an external symbol, we do
4501 not want to fiddle with the addend. Otherwise, we
4502 need to include the symbol value so that it becomes
4503 an addend for the dynamic reloc. */
4506 }
4510 {
4511 bfd_vma offset;
4517 {
4520 input_bfd,
4521 input_section,
4523 symname);
4525 }
4536 }
4540 #ifdef INCLUDE_SHMEDIA
4547 #endif
4548 /* Relocation is to the entry for this symbol in the
4549 procedure linkage table. */
4560 /* Relocation is to the entry for this symbol in the global
4561 offset table extension for the procedure linkage table. */
4569 #ifdef GOT_BIAS
4571 #endif
4575 force_got:
4578 #ifdef INCLUDE_SHMEDIA
4585 #endif
4586 /* Relocation is to the entry for this symbol in the global
4587 offset table. */
4594 {
4595 bfd_boolean dyn;
4598 #ifdef INCLUDE_SHMEDIA
4600 {
4605 }
4606 #endif
4615 {
4616 /* This is actually a static link, or it is a
4617 -Bsymbolic link and the symbol is defined
4618 locally, or the symbol was forced to be local
4619 because of a version file. We must initialize
4620 this entry in the global offset table. Since the
4621 offset must always be a multiple of 4, we use the
4622 least significant bit to record whether we have
4623 initialized it already.
4625 When doing a dynamic link, we create a .rela.got
4626 relocation entry to initialize the value. This
4627 is done in the finish_dynamic_symbol routine. */
4630 else
4631 {
4634 #ifdef INCLUDE_SHMEDIA
4636 {
4641 }
4642 else
4643 #endif
4646 /* If we initialize the GOT entry here with a valid
4647 symbol address, also add a fixup. */
4656 }
4657 }
4660 }
4661 else
4662 {
4663 #ifdef INCLUDE_SHMEDIA
4665 {
4673 }
4674 else
4675 {
4676 #endif
4681 #ifdef INCLUDE_SHMEDIA
4682 }
4683 #endif
4685 /* The offset must always be a multiple of 4. We use
4686 the least significant bit to record whether we have
4687 already generated the necessary reloc. */
4690 else
4691 {
4695 {
4696 Elf_Internal_Rela outrel;
4700 {
4704 }
4710 {
4711 int dynindx
4716 }
4717 else
4718 {
4721 }
4725 }
4734 #ifdef INCLUDE_SHMEDIA
4737 else
4738 #endif
4740 }
4743 }
4745 #ifdef GOT_BIAS
4747 #endif
4750 {
4755 }
4756 else
4761 #ifdef INCLUDE_SHMEDIA
4766 #endif
4767 /* GOTOFF relocations are relative to _GLOBAL_OFFSET_TABLE_, which
4768 we place at the start of the .got.plt section. This is the same
4769 as the start of the output .got section, unless there are function
4770 descriptors in front of it. */
4777 #ifdef GOT_BIAS
4779 #endif
4784 {
4789 }
4790 else
4794 #ifdef INCLUDE_SHMEDIA
4799 #endif
4800 /* Use global offset table as symbol value. */
4805 #ifdef GOT_BIAS
4807 #endif
4814 #ifdef INCLUDE_SHMEDIA
4819 #endif
4820 /* Relocation is to the entry for this symbol in the
4821 procedure linkage table. */
4823 /* Resolve a PLT reloc against a local symbol directly,
4824 without using the procedure linkage table. */
4828 /* We don't want to warn on calls to undefined weak symbols,
4829 as calls to them must be protected by non-NULL tests
4830 anyway, and unprotected calls would invoke undefined
4831 behavior. */
4839 {
4840 /* We didn't make a PLT entry for this symbol. This
4841 happens when statically linking PIC code, or when
4842 using -Bsymbolic. */
4844 }
4852 #ifdef INCLUDE_SHMEDIA
4853 relocation++;
4854 #endif
4860 /* Relocation is to the canonical function descriptor for this
4861 symbol, possibly via the GOT. Initialize the GOT
4862 entry and function descriptor if necessary. */
4866 {
4869 bfd_vma reloc_offset;
4876 /* FIXME: See what FRV does for global symbols in the
4877 executable, with --export-dynamic. Do they need ld.so
4878 to allocate official descriptors? See what this code
4879 does. */
4885 {
4888 }
4889 else
4890 {
4895 else
4896 {
4899 }
4903 {
4906 }
4907 }
4912 /* Undefined weak symbol which will not be dynamically
4913 resolved later; leave it at zero. */
4917 {
4918 /* If the symbol needs a non-local function descriptor
4919 but binds locally (i.e., its visibility is
4920 protected), emit a dynamic relocation decayed to
4921 section+offset. This is an optimization; the dynamic
4922 linker would resolve our function descriptor request
4923 to our copy of the function anyway. */
4928 }
4930 {
4931 /* If the symbol is dynamic and there will be dynamic
4932 symbol resolution because we are or are linked with a
4933 shared library, emit a FUNCDESC relocation such that
4934 the dynamic linker will allocate the function
4935 descriptor. */
4938 }
4939 else
4940 {
4941 bfd_vma offset;
4943 /* Otherwise, we know we have a private function
4944 descriptor, so reference it directly. */
4950 {
4954 {
4959 }
4960 }
4961 else
4962 {
4969 {
4975 }
4976 }
4979 }
4982 {
4983 bfd_vma offset;
4987 {
4990 input_bfd,
4991 input_section,
4993 symname);
4995 }
5002 offset
5005 }
5008 {
5009 bfd_vma offset;
5013 {
5019 }
5022 {
5025 }
5032 offset
5038 {
5041 }
5042 else
5043 {
5046 }
5047 }
5051 funcdesc_leave_zero:
5053 {
5058 else
5061 funcdesc_done_got:
5064 #ifdef GOT_BIAS
5066 #endif
5067 }
5069 {
5074 }
5075 else
5077 }
5082 /* FIXME: See R_SH_FUNCDESC comment about global symbols in the
5083 executable and --export-dynamic. If such symbols get
5084 ld.so-allocated descriptors we can not use R_SH_GOTOFFFUNCDESC
5085 for them. */
5094 {
5095 _bfd_error_handler
5100 }
5101 else
5102 {
5103 bfd_vma offset;
5105 /* Otherwise, we know we have a private function
5106 descriptor, so reference it directly. */
5108 {
5112 {
5117 }
5118 }
5119 else
5120 {
5127 {
5133 }
5134 }
5137 }
5141 #ifdef GOT_BIAS
5143 #endif
5146 {
5151 }
5152 else
5156 {
5171 }
5182 {
5188 }
5194 {
5195 bfd_vma offset;
5199 {
5200 /* GD->LE transition:
5201 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5202 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5203 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5204 We change it into:
5205 mov.l 1f,r4; stc gbr,r0; add r4,r0; nop;
5206 nop; nop; ...
5207 1: .long x@TPOFF; 2: .long __tls_get_addr@PLT; 3:. */
5211 /* Size of GD instructions is 16 or 18. */
5215 {
5219 }
5238 }
5239 else
5240 {
5243 /* IE->LE transition:
5244 mov.l 1f,r0; stc gbr,rN; mov.l @(r0,r12),rM;
5245 bra 2f; add ...; .align 2; 1: x@GOTTPOFF; 2:
5246 We change it into:
5247 mov.l .Ln,rM; stc gbr,rN; nop; ...;
5248 1: x@TPOFF; 2:. */
5252 /* Size of IE instructions is 10 or 12. */
5256 {
5260 }
5271 }
5276 }
5283 else
5284 {
5289 }
5291 /* Relocate R_SH_TLS_IE_32 directly when statically linking. */
5294 {
5301 }
5305 else
5306 {
5307 Elf_Internal_Rela outrel;
5312 {
5315 }
5322 else
5326 R_SH_TLS_TPOFF32);
5329 else
5337 {
5339 {
5343 }
5344 else
5345 {
5347 R_SH_TLS_DTPOFF32);
5353 }
5354 }
5358 else
5360 }
5367 else
5368 {
5369 bfd_vma offset;
5372 /* GD->IE transition:
5373 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5374 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5375 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5376 We change it into:
5377 mov.l 1f,r0; stc gbr,r4; mov.l @(r0,r12),r0; add r4,r0;
5378 nop; nop; bra 3f; nop; .align 2;
5379 1: .long x@TPOFF; 2:...; 3:. */
5383 /* Size of GD instructions is 16 or 18. */
5387 {
5391 }
5395 /* Replace mov.l 1f,R4 with mov.l 1f,r0. */
5419 }
5429 {
5430 bfd_vma offset;
5433 /* LD->LE transition:
5434 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5435 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5436 1: .long x$TLSLD; 2: .long __tls_get_addr@PLT; 3:
5437 We change it into:
5438 stc gbr,r0; nop; nop; nop;
5439 nop; nop; bra 3f; ...; 3:. */
5443 /* Size of LD instructions is 16 or 18. */
5447 {
5451 }
5473 }
5481 else
5482 {
5483 Elf_Internal_Rela outrel;
5498 }
5509 else
5516 {
5518 Elf_Internal_Rela outrel;
5524 {
5528 }
5531 {
5532 sreloc = _bfd_elf_get_dynamic_reloc_section
5536 }
5540 else
5549 else
5556 }
5557 }
5559 relocation_done:
5562 {
5563 /* We don't want duplicate errors for undefined symbols. */
5565 {
5567 {
5572 }
5573 else
5577 }
5580 }
5583 {
5585 {
5590 {
5595 else
5596 {
5597 name = (bfd_elf_string_from_elf_section
5603 }
5609 }
5611 }
5612 }
5613 }
5616 }
5618 /* This is a version of bfd_generic_get_relocated_section_contents
5619 which uses sh_elf_relocate_section. */
5626 bfd_boolean relocatable,
5628 {
5636 /* We only need to handle the case of relaxing, or of having a
5637 particular set of section contents, specially. */
5642 relocatable,
5643 symbols);
5652 {
5655 bfd_size_type amt;
5657 internal_relocs = (_bfd_elf_link_read_relocs
5664 {
5672 }
5682 {
5691 else
5695 }
5709 }
5713 error_return:
5723 }
5725 /* Return the base VMA address which should be subtracted from real addresses
5726 when resolving @dtpoff relocation.
5727 This is PT_TLS segment p_vaddr. */
5729 static bfd_vma
5731 {
5732 /* If tls_sec is NULL, we should have signalled an error already. */
5736 }
5738 /* Return the relocation value for R_SH_TLS_TPOFF32.. */
5740 static bfd_vma
5742 {
5743 /* If tls_sec is NULL, we should have signalled an error already. */
5746 /* SH TLS ABI is variant I and static TLS block start just after tcbhead
5747 structure which has 2 pointer fields. */
5751 }
5759 {
5762 {
5766 }
5769 }
5771 /* Update the got entry reference counts for the section being removed. */
5773 static bfd_boolean
5776 {
5795 {
5799 #ifdef INCLUDE_SHMEDIA
5801 #endif
5805 {
5813 {
5814 #ifdef INCLUDE_SHMEDIA
5816 #endif
5818 }
5822 {
5823 /* Everything must go for SEC. */
5826 }
5827 }
5831 {
5842 #ifdef INCLUDE_SHMEDIA
5857 #endif
5863 {
5864 #ifdef INCLUDE_SHMEDIA
5866 {
5871 }
5872 else
5873 #endif
5876 }
5878 {
5879 #ifdef INCLUDE_SHMEDIA
5881 {
5884 }
5885 else
5886 #endif
5889 }
5898 /* Fall through. */
5904 else
5912 /* Fall thru */
5917 /* Fall thru */
5920 #ifdef INCLUDE_SHMEDIA
5925 #endif
5927 {
5930 }
5934 #ifdef INCLUDE_SHMEDIA
5941 #endif
5943 {
5947 {
5951 }
5952 #ifdef INCLUDE_SHMEDIA
5954 {
5957 }
5958 #endif
5961 }
5963 {
5964 #ifdef INCLUDE_SHMEDIA
5966 {
5969 }
5970 else
5971 #endif
5974 }
5979 }
5980 }
5983 }
5985 /* Copy the extra info we tack onto an elf_link_hash_entry. */
5987 static void
5991 {
5998 {
6000 {
6004 /* Add reloc counts against the indirect sym to the direct sym
6005 list. Merge any entries against the same section. */
6007 {
6012 {
6017 }
6020 }
6022 }
6026 }
6029 #ifdef INCLUDE_SHMEDIA
6032 #endif
6040 {
6043 }
6047 {
6048 /* If called to transfer flags for a weakdef during processing
6049 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
6050 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
6055 }
6056 else
6058 }
6060 static int
6063 {
6068 {
6076 }
6079 }
6081 /* Look through the relocs for a section during the first phase.
6082 Since we don't do .gots or .plts, we just need to consider the
6083 virtual table relocs for gc. */
6085 static bfd_boolean
6088 {
6114 {
6117 #ifdef INCLUDE_SHMEDIA
6119 #endif
6126 else
6127 {
6131 {
6132 #ifdef INCLUDE_SHMEDIA
6134 #endif
6136 }
6137 }
6151 {
6158 {
6161 {
6168 }
6169 }
6171 }
6173 /* Some relocs require a global offset table. */
6175 {
6177 {
6179 /* This may require an rofixup. */
6193 #ifdef INCLUDE_SHMEDIA
6214 #endif
6226 }
6227 }
6230 {
6231 /* This relocation describes the C++ object vtable hierarchy.
6232 Reconstruct it for later use during GC. */
6238 /* This relocation describes which C++ vtable entries are actually
6239 used. Record for later use during GC. */
6251 /* FALLTHROUGH */
6252 force_got:
6256 #ifdef INCLUDE_SHMEDIA
6263 #endif
6267 {
6281 }
6284 {
6285 #ifdef INCLUDE_SHMEDIA
6287 {
6292 }
6293 else
6294 #endif
6297 }
6298 else
6299 {
6302 /* This is a global offset table entry for a local
6303 symbol. */
6306 {
6307 bfd_size_type size;
6311 #ifdef INCLUDE_SHMEDIA
6312 /* Reserve space for both the datalabel and
6313 codelabel local GOT offsets. */
6315 #endif
6322 #ifdef INCLUDE_SHMEDIA
6323 /* Take care of both the datalabel and codelabel local
6324 GOT offsets. */
6327 #else
6330 #endif
6331 }
6332 #ifdef INCLUDE_SHMEDIA
6335 else
6336 #endif
6339 }
6341 /* If a TLS symbol is accessed using IE at least once,
6342 there is no point to use dynamic model for it. */
6345 {
6348 else
6349 {
6360 else
6365 }
6366 }
6369 {
6372 else
6374 }
6386 {
6389 abfd);
6391 }
6394 {
6397 /* We need a function descriptor for a local symbol. */
6400 {
6401 bfd_size_type size;
6404 #ifdef INCLUDE_SHMEDIA
6405 /* Count datalabel local GOT. */
6407 #endif
6412 }
6416 {
6419 else
6421 }
6422 }
6423 else
6424 {
6429 /* If there is a function descriptor reference, then
6430 there should not be any non-FDPIC references. */
6433 {
6438 else
6442 }
6443 }
6447 #ifdef INCLUDE_SHMEDIA
6454 #endif
6455 /* If this is a local symbol, we resolve it directly without
6456 creating a procedure linkage table entry. */
6472 #ifdef INCLUDE_SHMEDIA
6477 #endif
6478 /* This symbol requires a procedure linkage table entry. We
6479 actually build the entry in adjust_dynamic_symbol,
6480 because this might be a case of linking PIC code which is
6481 never referenced by a dynamic object, in which case we
6482 don't need to generate a procedure linkage table entry
6483 after all. */
6485 /* If this is a local symbol, we resolve it directly without
6486 creating a procedure linkage table entry. */
6499 #ifdef INCLUDE_SHMEDIA
6504 #endif
6506 {
6509 }
6511 /* If we are creating a shared library, and this is a reloc
6512 against a global symbol, or a non PC relative reloc
6513 against a local symbol, then we need to copy the reloc
6514 into the shared library. However, if we are linking with
6515 -Bsymbolic, we do not need to copy a reloc against a
6516 global symbol which is defined in an object we are
6517 including in the link (i.e., DEF_REGULAR is set). At
6518 this point we have not seen all the input files, so it is
6519 possible that DEF_REGULAR is not set now but will be set
6520 later (it is never cleared). We account for that
6521 possibility below by storing information in the
6522 dyn_relocs field of the hash table entry. A similar
6523 situation occurs when creating shared libraries and symbol
6524 visibility changes render the symbol local.
6526 If on the other hand, we are creating an executable, we
6527 may need to keep relocations for symbols satisfied by a
6528 dynamic library if we manage to avoid copy relocs for the
6529 symbol. */
6542 {
6549 /* When creating a shared object, we must copy these
6550 reloc types into the output file. We create a reloc
6551 section in dynobj and make room for this reloc. */
6553 {
6554 sreloc = _bfd_elf_make_dynamic_reloc_section
6559 }
6561 /* If this is a global symbol, we count the number of
6562 relocations we need for this symbol. */
6565 else
6566 {
6567 /* Track dynamic relocs needed for local syms too. */
6583 }
6587 {
6597 }
6601 #ifdef INCLUDE_SHMEDIA
6606 #endif
6607 )
6609 }
6611 /* Allocate the fixup regardless of whether we need a relocation.
6612 If we end up generating the relocation, we'll unallocate the
6613 fixup. */
6622 {
6625 abfd);
6627 }
6632 /* Nothing to do. */
6637 }
6638 }
6641 }
6643 #ifndef sh_elf_set_mach_from_flags
6646 static bfd_boolean
6648 {
6660 }
6663 /* Reverse table lookup for sh_ef_bfd_table[].
6664 Given a bfd MACH value from archures.c
6665 return the equivalent ELF flags from the table.
6666 Return -1 if no match is found. */
6668 int
6670 {
6677 /* shouldn't get here */
6681 }
6684 #ifndef sh_elf_set_private_flags
6685 /* Function to keep SH specific file flags. */
6687 static bfd_boolean
6689 {
6696 }
6699 #ifndef sh_elf_copy_private_data
6700 /* Copy backend specific data from one object module to another */
6702 static bfd_boolean
6704 {
6705 /* Copy object attributes. */
6711 /* Copy the stack size. */
6714 {
6719 {
6724 {
6727 /* Rewrite the phdrs, since we're only called after they
6728 were first written. */
6737 }
6740 }
6741 }
6744 }
6747 #ifndef sh_elf_merge_private_data
6749 /* This function returns the ELF architecture number that
6750 corresponds to the given arch_sh* flags. */
6752 int
6754 {
6759 }
6761 /* This routine initialises the elf flags when required and
6762 calls sh_merge_bfd_arch() to check dsp/fpu compatibility. */
6764 static bfd_boolean
6766 {
6773 {
6774 /* This happens when ld starts out with a 'blank' output file. */
6780 }
6783 {
6786 ibfd);
6789 }
6796 {
6798 ibfd);
6801 }
6804 }
6807 /* Override the generic function because we need to store sh_elf_obj_tdata
6808 as the specific tdata. We set also the machine architecture from flags
6809 here. */
6811 static bfd_boolean
6813 {
6819 }
6821 /* Finish up dynamic symbol handling. We set the contents of various
6822 dynamic sections here. */
6824 static bfd_boolean
6828 {
6836 {
6841 bfd_vma plt_index;
6842 bfd_vma got_offset;
6843 Elf_Internal_Rela rel;
6847 /* This symbol has an entry in the procedure linkage table. Set
6848 it up. */
6857 /* Get the index in the procedure linkage table which
6858 corresponds to this symbol. This is the index of this symbol
6859 in all the symbols for which we are making plt entries. The
6860 first entry in the procedure linkage table is reserved. */
6867 /* Get the offset into the .got table of the entry that
6868 corresponds to this function. */
6870 /* The offset must be relative to the GOT symbol, twelve bytes
6871 before the end of .got.plt. Each descriptor is eight
6872 bytes. */
6874 else
6875 /* Each .got entry is 4 bytes. The first three are
6876 reserved. */
6879 #ifdef GOT_BIAS
6882 #endif
6884 /* Fill in the entry in the procedure linkage table. */
6890 {
6892 {
6893 bfd_reloc_status_type r;
6899 }
6900 else
6905 }
6906 else
6907 {
6918 {
6922 /* Divide the PLT into groups. The first group contains
6923 REACHABLE_PLTS entries and the other groups contain
6924 PLTS_PER_4K entries. Entries in the first group can
6925 branch directly to .plt; those in later groups branch
6926 to the last element of the previous group. */
6927 /* ??? It would be better to create multiple copies of
6928 the common resolver stub. */
6937 else
6941 /* Install the 'bra' with this offset. */
6947 }
6948 else
6954 }
6956 /* Make got_offset relative to the start of .got.plt. */
6957 #ifdef GOT_BIAS
6960 #endif
6971 /* Fill in the entry in the global offset table. */
6984 /* Fill in the entry in the .rela.plt section. */
6990 else
6993 #ifdef GOT_BIAS
6995 #endif
7000 {
7001 /* Create the .rela.plt.unloaded relocations for this PLT entry.
7002 Begin by pointing LOC to the first such relocation. */
7006 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation
7007 for the PLT entry's pointer to the .got.plt entry. */
7017 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for
7018 the .got.plt entry, which initially points to .plt. */
7025 }
7028 {
7029 /* Mark the symbol as undefined, rather than as defined in
7030 the .plt section. Leave the value alone. */
7032 }
7033 }
7039 {
7042 Elf_Internal_Rela rel;
7045 /* This symbol has an entry in the global offset table. Set it
7046 up. */
7056 /* If this is a static link, or it is a -Bsymbolic link and the
7057 symbol is defined locally or was forced to be local because
7058 of a version file, we just want to emit a RELATIVE reloc.
7059 The entry in the global offset table will already have been
7060 initialized in the relocate_section function. */
7063 {
7065 {
7067 int dynindx
7073 }
7074 else
7075 {
7080 }
7081 }
7082 else
7083 {
7087 }
7092 }
7094 #ifdef INCLUDE_SHMEDIA
7095 {
7100 {
7103 Elf_Internal_Rela rel;
7106 /* This symbol has a datalabel entry in the global offset table.
7107 Set it up. */
7117 /* If this is a static link, or it is a -Bsymbolic link and the
7118 symbol is defined locally or was forced to be local because
7119 of a version file, we just want to emit a RELATIVE reloc.
7120 The entry in the global offset table will already have been
7121 initialized in the relocate_section function. */
7124 {
7126 {
7128 int dynindx
7134 }
7135 else
7136 {
7141 }
7142 }
7143 else
7144 {
7149 }
7154 }
7155 }
7156 #endif
7159 {
7161 Elf_Internal_Rela rel;
7164 /* This symbol needs a copy reloc. Set it up. */
7181 }
7183 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. On VxWorks,
7184 _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
7185 ".got" section. */
7191 }
7193 /* Finish up the dynamic sections. */
7195 static bfd_boolean
7197 {
7210 {
7219 {
7220 Elf_Internal_Dyn dyn;
7222 #ifdef INCLUDE_SHMEDIA
7224 #endif
7229 {
7236 #ifdef INCLUDE_SHMEDIA
7243 get_sym:
7245 {
7251 {
7254 }
7255 }
7257 #endif
7282 /* My reading of the SVR4 ABI indicates that the
7283 procedure linkage table relocs (DT_JMPREL) should be
7284 included in the overall relocs (DT_RELA). This is
7285 what Solaris does. However, UnixWare can not handle
7286 that case. Therefore, we override the DT_RELASZ entry
7287 here to make it not include the JMPREL relocs. Since
7288 the linker script arranges for .rela.plt to follow all
7289 other relocation sections, we don't have to worry
7290 about changing the DT_RELA entry. */
7292 {
7295 }
7298 }
7299 }
7301 /* Fill in the first entry in the procedure linkage table. */
7304 {
7320 {
7321 /* Finalize the .rela.plt.unloaded contents. */
7322 Elf_Internal_Rela rel;
7325 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for the
7326 first PLT entry's pointer to _GLOBAL_OFFSET_TABLE_ + 8. */
7336 /* Fix up the remaining .rela.plt.unloaded relocations.
7337 They may have the wrong symbol index for _G_O_T_ or
7338 _P_L_T_ depending on the order in which symbols were
7339 output. */
7341 {
7342 /* The PLT entry's pointer to the .got.plt slot. */
7345 R_SH_DIR32);
7349 /* The .got.plt slot's pointer to .plt. */
7352 R_SH_DIR32);
7355 }
7356 }
7358 /* UnixWare sets the entsize of .plt to 4, although that doesn't
7359 really seem like the right value. */
7361 }
7362 }
7364 /* Fill in the first three entries in the global offset table. */
7366 {
7369 else
7375 }
7380 /* At the very end of the .rofixup section is a pointer to the GOT. */
7382 {
7390 /* Make sure we allocated and generated the same number of fixups. */
7392 }
7403 }
7405 static enum elf_reloc_type_class
7407 {
7409 {
7418 }
7419 }
7421 #if !defined SH_TARGET_ALREADY_DEFINED
7422 /* Support for Linux core dump NOTE sections. */
7424 static bfd_boolean
7426 {
7431 {
7436 /* pr_cursig */
7439 /* pr_pid */
7442 /* pr_reg */
7447 }
7449 /* Make a ".reg/999" section. */
7452 }
7454 static bfd_boolean
7456 {
7458 {
7467 }
7469 /* Note that for some reason, a spurious space is tacked
7470 onto the end of the args in some (at least one anyway)
7471 implementations, so strip it off if it exists. */
7473 {
7479 }
7482 }
7486 /* Return address for Ith PLT stub in section PLT, for relocation REL
7487 or (bfd_vma) -1 if it should not be included. */
7489 static bfd_vma
7492 {
7497 }
7499 /* Decide whether to attempt to turn absptr or lsda encodings in
7500 shared libraries into pcrel within the given input section. */
7502 static bfd_boolean
7506 {
7509 /* We can't use PC-relative encodings in FDPIC binaries, in general. */
7514 }
7516 /* Adjust the contents of an eh_frame_hdr section before they're output. */
7518 static bfd_byte
7524 {
7541 == (sh_elf_osec_to_segment
7550 }
7552 #if !defined SH_TARGET_ALREADY_DEFINED
7553 #define TARGET_BIG_SYM bfd_elf32_sh_vec
7555 #define TARGET_LITTLE_SYM bfd_elf32_shl_vec
7557 #endif
7559 #define ELF_ARCH bfd_arch_sh
7560 #define ELF_TARGET_ID SH_ELF_DATA
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