| blob | 023ed7ede7b475e87baf64a24cd8769a44c10079 |
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 }
4249 {
4250 /* For relocs against symbols from removed linkonce sections,
4251 or sections discarded by a linker script, we just want the
4252 section contents zeroed. Avoid any special processing. */
4257 }
4262 /* Check for inter-segment relocations in FDPIC files. Most
4263 relocations connect the relocation site to the location of
4264 the target symbol, but there are some exceptions below. */
4269 else
4273 {
4274 final_link_relocate:
4275 /* COFF relocs don't use the addend. The addend is used for
4276 R_SH_DIR32 to be compatible with other compilers. */
4288 /* If the reloc is against the start of this section, then
4289 the assembler has already taken care of it and the reloc
4290 is here only to assist in relaxing. If the reloc is not
4291 against the start of this section, then it's against an
4292 external symbol and we must deal with it ourselves. */
4295 {
4302 {
4307 }
4309 {
4316 }
4319 }
4324 #ifdef INCLUDE_SHMEDIA
4328 #endif
4342 {
4350 }
4357 {
4365 }
4371 {
4379 }
4385 {
4393 }
4398 #ifdef INCLUDE_SHMEDIA
4403 #endif
4410 && !is_vxworks_tls
4413 {
4414 Elf_Internal_Rela outrel;
4418 /* When generating a shared object, these relocations
4419 are copied into the output file to be resolved at run
4420 time. */
4423 {
4424 sreloc = _bfd_elf_get_dynamic_reloc_section
4428 }
4446 {
4449 outrel.r_addend
4453 }
4454 #ifdef INCLUDE_SHMEDIA
4459 {
4463 }
4464 #endif
4469 {
4477 outrel.r_addend
4482 }
4483 else
4484 {
4485 /* h->dynindx may be -1 if this symbol was marked to
4486 become local. */
4490 {
4493 }
4494 else
4495 {
4498 }
4500 outrel.r_addend
4504 }
4512 /* If this reloc is against an external symbol, we do
4513 not want to fiddle with the addend. Otherwise, we
4514 need to include the symbol value so that it becomes
4515 an addend for the dynamic reloc. */
4518 }
4522 {
4523 bfd_vma offset;
4529 {
4532 input_bfd,
4533 input_section,
4535 symname);
4537 }
4548 }
4552 #ifdef INCLUDE_SHMEDIA
4559 #endif
4560 /* Relocation is to the entry for this symbol in the
4561 procedure linkage table. */
4572 /* Relocation is to the entry for this symbol in the global
4573 offset table extension for the procedure linkage table. */
4581 #ifdef GOT_BIAS
4583 #endif
4587 force_got:
4590 #ifdef INCLUDE_SHMEDIA
4597 #endif
4598 /* Relocation is to the entry for this symbol in the global
4599 offset table. */
4606 {
4607 bfd_boolean dyn;
4610 #ifdef INCLUDE_SHMEDIA
4612 {
4617 }
4618 #endif
4627 {
4628 /* This is actually a static link, or it is a
4629 -Bsymbolic link and the symbol is defined
4630 locally, or the symbol was forced to be local
4631 because of a version file. We must initialize
4632 this entry in the global offset table. Since the
4633 offset must always be a multiple of 4, we use the
4634 least significant bit to record whether we have
4635 initialized it already.
4637 When doing a dynamic link, we create a .rela.got
4638 relocation entry to initialize the value. This
4639 is done in the finish_dynamic_symbol routine. */
4642 else
4643 {
4646 #ifdef INCLUDE_SHMEDIA
4648 {
4653 }
4654 else
4655 #endif
4658 /* If we initialize the GOT entry here with a valid
4659 symbol address, also add a fixup. */
4668 }
4669 }
4672 }
4673 else
4674 {
4675 #ifdef INCLUDE_SHMEDIA
4677 {
4685 }
4686 else
4687 {
4688 #endif
4693 #ifdef INCLUDE_SHMEDIA
4694 }
4695 #endif
4697 /* The offset must always be a multiple of 4. We use
4698 the least significant bit to record whether we have
4699 already generated the necessary reloc. */
4702 else
4703 {
4707 {
4708 Elf_Internal_Rela outrel;
4712 {
4716 }
4722 {
4723 int dynindx
4728 }
4729 else
4730 {
4733 }
4737 }
4746 #ifdef INCLUDE_SHMEDIA
4749 else
4750 #endif
4752 }
4755 }
4757 #ifdef GOT_BIAS
4759 #endif
4762 {
4767 }
4768 else
4773 #ifdef INCLUDE_SHMEDIA
4778 #endif
4779 /* GOTOFF relocations are relative to _GLOBAL_OFFSET_TABLE_, which
4780 we place at the start of the .got.plt section. This is the same
4781 as the start of the output .got section, unless there are function
4782 descriptors in front of it. */
4789 #ifdef GOT_BIAS
4791 #endif
4796 {
4801 }
4802 else
4806 #ifdef INCLUDE_SHMEDIA
4811 #endif
4812 /* Use global offset table as symbol value. */
4817 #ifdef GOT_BIAS
4819 #endif
4826 #ifdef INCLUDE_SHMEDIA
4831 #endif
4832 /* Relocation is to the entry for this symbol in the
4833 procedure linkage table. */
4835 /* Resolve a PLT reloc against a local symbol directly,
4836 without using the procedure linkage table. */
4840 /* We don't want to warn on calls to undefined weak symbols,
4841 as calls to them must be protected by non-NULL tests
4842 anyway, and unprotected calls would invoke undefined
4843 behavior. */
4851 {
4852 /* We didn't make a PLT entry for this symbol. This
4853 happens when statically linking PIC code, or when
4854 using -Bsymbolic. */
4856 }
4864 #ifdef INCLUDE_SHMEDIA
4865 relocation++;
4866 #endif
4872 /* Relocation is to the canonical function descriptor for this
4873 symbol, possibly via the GOT. Initialize the GOT
4874 entry and function descriptor if necessary. */
4878 {
4881 bfd_vma reloc_offset;
4888 /* FIXME: See what FRV does for global symbols in the
4889 executable, with --export-dynamic. Do they need ld.so
4890 to allocate official descriptors? See what this code
4891 does. */
4897 {
4900 }
4901 else
4902 {
4907 else
4908 {
4911 }
4915 {
4918 }
4919 }
4924 /* Undefined weak symbol which will not be dynamically
4925 resolved later; leave it at zero. */
4929 {
4930 /* If the symbol needs a non-local function descriptor
4931 but binds locally (i.e., its visibility is
4932 protected), emit a dynamic relocation decayed to
4933 section+offset. This is an optimization; the dynamic
4934 linker would resolve our function descriptor request
4935 to our copy of the function anyway. */
4940 }
4942 {
4943 /* If the symbol is dynamic and there will be dynamic
4944 symbol resolution because we are or are linked with a
4945 shared library, emit a FUNCDESC relocation such that
4946 the dynamic linker will allocate the function
4947 descriptor. */
4950 }
4951 else
4952 {
4953 bfd_vma offset;
4955 /* Otherwise, we know we have a private function
4956 descriptor, so reference it directly. */
4962 {
4966 {
4971 }
4972 }
4973 else
4974 {
4981 {
4987 }
4988 }
4991 }
4994 {
4995 bfd_vma offset;
4999 {
5002 input_bfd,
5003 input_section,
5005 symname);
5007 }
5014 offset
5017 }
5020 {
5021 bfd_vma offset;
5025 {
5031 }
5034 {
5037 }
5044 offset
5050 {
5053 }
5054 else
5055 {
5058 }
5059 }
5063 funcdesc_leave_zero:
5065 {
5070 else
5073 funcdesc_done_got:
5076 #ifdef GOT_BIAS
5078 #endif
5079 }
5081 {
5086 }
5087 else
5089 }
5094 /* FIXME: See R_SH_FUNCDESC comment about global symbols in the
5095 executable and --export-dynamic. If such symbols get
5096 ld.so-allocated descriptors we can not use R_SH_GOTOFFFUNCDESC
5097 for them. */
5106 {
5107 _bfd_error_handler
5112 }
5113 else
5114 {
5115 bfd_vma offset;
5117 /* Otherwise, we know we have a private function
5118 descriptor, so reference it directly. */
5120 {
5124 {
5129 }
5130 }
5131 else
5132 {
5139 {
5145 }
5146 }
5149 }
5153 #ifdef GOT_BIAS
5155 #endif
5158 {
5163 }
5164 else
5168 {
5183 }
5194 {
5200 }
5206 {
5207 bfd_vma offset;
5211 {
5212 /* GD->LE transition:
5213 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5214 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5215 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5216 We change it into:
5217 mov.l 1f,r4; stc gbr,r0; add r4,r0; nop;
5218 nop; nop; ...
5219 1: .long x@TPOFF; 2: .long __tls_get_addr@PLT; 3:. */
5223 /* Size of GD instructions is 16 or 18. */
5227 {
5231 }
5250 }
5251 else
5252 {
5255 /* IE->LE transition:
5256 mov.l 1f,r0; stc gbr,rN; mov.l @(r0,r12),rM;
5257 bra 2f; add ...; .align 2; 1: x@GOTTPOFF; 2:
5258 We change it into:
5259 mov.l .Ln,rM; stc gbr,rN; nop; ...;
5260 1: x@TPOFF; 2:. */
5264 /* Size of IE instructions is 10 or 12. */
5268 {
5272 }
5283 }
5288 }
5295 else
5296 {
5301 }
5303 /* Relocate R_SH_TLS_IE_32 directly when statically linking. */
5306 {
5313 }
5317 else
5318 {
5319 Elf_Internal_Rela outrel;
5324 {
5327 }
5334 else
5338 R_SH_TLS_TPOFF32);
5341 else
5349 {
5351 {
5355 }
5356 else
5357 {
5359 R_SH_TLS_DTPOFF32);
5365 }
5366 }
5370 else
5372 }
5379 else
5380 {
5381 bfd_vma offset;
5384 /* GD->IE transition:
5385 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5386 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5387 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5388 We change it into:
5389 mov.l 1f,r0; stc gbr,r4; mov.l @(r0,r12),r0; add r4,r0;
5390 nop; nop; bra 3f; nop; .align 2;
5391 1: .long x@TPOFF; 2:...; 3:. */
5395 /* Size of GD instructions is 16 or 18. */
5399 {
5403 }
5407 /* Replace mov.l 1f,R4 with mov.l 1f,r0. */
5431 }
5441 {
5442 bfd_vma offset;
5445 /* LD->LE transition:
5446 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5447 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5448 1: .long x$TLSLD; 2: .long __tls_get_addr@PLT; 3:
5449 We change it into:
5450 stc gbr,r0; nop; nop; nop;
5451 nop; nop; bra 3f; ...; 3:. */
5455 /* Size of LD instructions is 16 or 18. */
5459 {
5463 }
5485 }
5493 else
5494 {
5495 Elf_Internal_Rela outrel;
5510 }
5521 else
5528 {
5530 Elf_Internal_Rela outrel;
5536 {
5540 }
5543 {
5544 sreloc = _bfd_elf_get_dynamic_reloc_section
5548 }
5552 else
5561 else
5568 }
5569 }
5571 relocation_done:
5574 {
5575 /* We don't want duplicate errors for undefined symbols. */
5577 {
5579 {
5584 }
5585 else
5589 }
5592 }
5595 {
5597 {
5602 {
5607 else
5608 {
5609 name = (bfd_elf_string_from_elf_section
5615 }
5621 }
5623 }
5624 }
5625 }
5628 }
5630 /* This is a version of bfd_generic_get_relocated_section_contents
5631 which uses sh_elf_relocate_section. */
5638 bfd_boolean relocatable,
5640 {
5648 /* We only need to handle the case of relaxing, or of having a
5649 particular set of section contents, specially. */
5654 relocatable,
5655 symbols);
5664 {
5667 bfd_size_type amt;
5669 internal_relocs = (_bfd_elf_link_read_relocs
5676 {
5684 }
5694 {
5703 else
5707 }
5721 }
5725 error_return:
5735 }
5737 /* Return the base VMA address which should be subtracted from real addresses
5738 when resolving @dtpoff relocation.
5739 This is PT_TLS segment p_vaddr. */
5741 static bfd_vma
5743 {
5744 /* If tls_sec is NULL, we should have signalled an error already. */
5748 }
5750 /* Return the relocation value for R_SH_TLS_TPOFF32.. */
5752 static bfd_vma
5754 {
5755 /* If tls_sec is NULL, we should have signalled an error already. */
5758 /* SH TLS ABI is variant I and static TLS block start just after tcbhead
5759 structure which has 2 pointer fields. */
5763 }
5771 {
5774 {
5778 }
5781 }
5783 /* Update the got entry reference counts for the section being removed. */
5785 static bfd_boolean
5788 {
5807 {
5811 #ifdef INCLUDE_SHMEDIA
5813 #endif
5817 {
5825 {
5826 #ifdef INCLUDE_SHMEDIA
5828 #endif
5830 }
5834 {
5835 /* Everything must go for SEC. */
5838 }
5839 }
5843 {
5854 #ifdef INCLUDE_SHMEDIA
5869 #endif
5875 {
5876 #ifdef INCLUDE_SHMEDIA
5878 {
5883 }
5884 else
5885 #endif
5888 }
5890 {
5891 #ifdef INCLUDE_SHMEDIA
5893 {
5896 }
5897 else
5898 #endif
5901 }
5910 /* Fall through. */
5916 else
5924 /* Fall thru */
5929 /* Fall thru */
5932 #ifdef INCLUDE_SHMEDIA
5937 #endif
5939 {
5942 }
5946 #ifdef INCLUDE_SHMEDIA
5953 #endif
5955 {
5959 {
5963 }
5964 #ifdef INCLUDE_SHMEDIA
5966 {
5969 }
5970 #endif
5973 }
5975 {
5976 #ifdef INCLUDE_SHMEDIA
5978 {
5981 }
5982 else
5983 #endif
5986 }
5991 }
5992 }
5995 }
5997 /* Copy the extra info we tack onto an elf_link_hash_entry. */
5999 static void
6003 {
6010 {
6012 {
6016 /* Add reloc counts against the indirect sym to the direct sym
6017 list. Merge any entries against the same section. */
6019 {
6024 {
6029 }
6032 }
6034 }
6038 }
6041 #ifdef INCLUDE_SHMEDIA
6044 #endif
6052 {
6055 }
6059 {
6060 /* If called to transfer flags for a weakdef during processing
6061 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
6062 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
6067 }
6068 else
6070 }
6072 static int
6075 {
6080 {
6088 }
6091 }
6093 /* Look through the relocs for a section during the first phase.
6094 Since we don't do .gots or .plts, we just need to consider the
6095 virtual table relocs for gc. */
6097 static bfd_boolean
6100 {
6126 {
6129 #ifdef INCLUDE_SHMEDIA
6131 #endif
6138 else
6139 {
6143 {
6144 #ifdef INCLUDE_SHMEDIA
6146 #endif
6148 }
6149 }
6163 {
6170 {
6173 {
6180 }
6181 }
6183 }
6185 /* Some relocs require a global offset table. */
6187 {
6189 {
6191 /* This may require an rofixup. */
6205 #ifdef INCLUDE_SHMEDIA
6226 #endif
6238 }
6239 }
6242 {
6243 /* This relocation describes the C++ object vtable hierarchy.
6244 Reconstruct it for later use during GC. */
6250 /* This relocation describes which C++ vtable entries are actually
6251 used. Record for later use during GC. */
6263 /* FALLTHROUGH */
6264 force_got:
6268 #ifdef INCLUDE_SHMEDIA
6275 #endif
6279 {
6293 }
6296 {
6297 #ifdef INCLUDE_SHMEDIA
6299 {
6304 }
6305 else
6306 #endif
6309 }
6310 else
6311 {
6314 /* This is a global offset table entry for a local
6315 symbol. */
6318 {
6319 bfd_size_type size;
6323 #ifdef INCLUDE_SHMEDIA
6324 /* Reserve space for both the datalabel and
6325 codelabel local GOT offsets. */
6327 #endif
6334 #ifdef INCLUDE_SHMEDIA
6335 /* Take care of both the datalabel and codelabel local
6336 GOT offsets. */
6339 #else
6342 #endif
6343 }
6344 #ifdef INCLUDE_SHMEDIA
6347 else
6348 #endif
6351 }
6353 /* If a TLS symbol is accessed using IE at least once,
6354 there is no point to use dynamic model for it. */
6357 {
6360 else
6361 {
6372 else
6377 }
6378 }
6381 {
6384 else
6386 }
6398 {
6401 abfd);
6403 }
6406 {
6409 /* We need a function descriptor for a local symbol. */
6412 {
6413 bfd_size_type size;
6416 #ifdef INCLUDE_SHMEDIA
6417 /* Count datalabel local GOT. */
6419 #endif
6424 }
6428 {
6431 else
6433 }
6434 }
6435 else
6436 {
6441 /* If there is a function descriptor reference, then
6442 there should not be any non-FDPIC references. */
6445 {
6450 else
6454 }
6455 }
6459 #ifdef INCLUDE_SHMEDIA
6466 #endif
6467 /* If this is a local symbol, we resolve it directly without
6468 creating a procedure linkage table entry. */
6484 #ifdef INCLUDE_SHMEDIA
6489 #endif
6490 /* This symbol requires a procedure linkage table entry. We
6491 actually build the entry in adjust_dynamic_symbol,
6492 because this might be a case of linking PIC code which is
6493 never referenced by a dynamic object, in which case we
6494 don't need to generate a procedure linkage table entry
6495 after all. */
6497 /* If this is a local symbol, we resolve it directly without
6498 creating a procedure linkage table entry. */
6511 #ifdef INCLUDE_SHMEDIA
6516 #endif
6518 {
6521 }
6523 /* If we are creating a shared library, and this is a reloc
6524 against a global symbol, or a non PC relative reloc
6525 against a local symbol, then we need to copy the reloc
6526 into the shared library. However, if we are linking with
6527 -Bsymbolic, we do not need to copy a reloc against a
6528 global symbol which is defined in an object we are
6529 including in the link (i.e., DEF_REGULAR is set). At
6530 this point we have not seen all the input files, so it is
6531 possible that DEF_REGULAR is not set now but will be set
6532 later (it is never cleared). We account for that
6533 possibility below by storing information in the
6534 dyn_relocs field of the hash table entry. A similar
6535 situation occurs when creating shared libraries and symbol
6536 visibility changes render the symbol local.
6538 If on the other hand, we are creating an executable, we
6539 may need to keep relocations for symbols satisfied by a
6540 dynamic library if we manage to avoid copy relocs for the
6541 symbol. */
6554 {
6561 /* When creating a shared object, we must copy these
6562 reloc types into the output file. We create a reloc
6563 section in dynobj and make room for this reloc. */
6565 {
6566 sreloc = _bfd_elf_make_dynamic_reloc_section
6571 }
6573 /* If this is a global symbol, we count the number of
6574 relocations we need for this symbol. */
6577 else
6578 {
6579 /* Track dynamic relocs needed for local syms too. */
6595 }
6599 {
6609 }
6613 #ifdef INCLUDE_SHMEDIA
6618 #endif
6619 )
6621 }
6623 /* Allocate the fixup regardless of whether we need a relocation.
6624 If we end up generating the relocation, we'll unallocate the
6625 fixup. */
6634 {
6637 abfd);
6639 }
6644 /* Nothing to do. */
6649 }
6650 }
6653 }
6655 #ifndef sh_elf_set_mach_from_flags
6658 static bfd_boolean
6660 {
6672 }
6675 /* Reverse table lookup for sh_ef_bfd_table[].
6676 Given a bfd MACH value from archures.c
6677 return the equivalent ELF flags from the table.
6678 Return -1 if no match is found. */
6680 int
6682 {
6689 /* shouldn't get here */
6693 }
6696 #ifndef sh_elf_set_private_flags
6697 /* Function to keep SH specific file flags. */
6699 static bfd_boolean
6701 {
6708 }
6711 #ifndef sh_elf_copy_private_data
6712 /* Copy backend specific data from one object module to another */
6714 static bfd_boolean
6716 {
6717 /* Copy object attributes. */
6723 /* Copy the stack size. */
6726 {
6731 {
6736 {
6739 /* Rewrite the phdrs, since we're only called after they
6740 were first written. */
6749 }
6752 }
6753 }
6756 }
6759 #ifndef sh_elf_merge_private_data
6761 /* This function returns the ELF architecture number that
6762 corresponds to the given arch_sh* flags. */
6764 int
6766 {
6771 }
6773 /* This routine initialises the elf flags when required and
6774 calls sh_merge_bfd_arch() to check dsp/fpu compatibility. */
6776 static bfd_boolean
6778 {
6785 {
6786 /* This happens when ld starts out with a 'blank' output file. */
6792 }
6795 {
6798 ibfd);
6801 }
6808 {
6810 ibfd);
6813 }
6816 }
6819 /* Override the generic function because we need to store sh_elf_obj_tdata
6820 as the specific tdata. We set also the machine architecture from flags
6821 here. */
6823 static bfd_boolean
6825 {
6831 }
6833 /* Finish up dynamic symbol handling. We set the contents of various
6834 dynamic sections here. */
6836 static bfd_boolean
6840 {
6848 {
6853 bfd_vma plt_index;
6854 bfd_vma got_offset;
6855 Elf_Internal_Rela rel;
6859 /* This symbol has an entry in the procedure linkage table. Set
6860 it up. */
6869 /* Get the index in the procedure linkage table which
6870 corresponds to this symbol. This is the index of this symbol
6871 in all the symbols for which we are making plt entries. The
6872 first entry in the procedure linkage table is reserved. */
6879 /* Get the offset into the .got table of the entry that
6880 corresponds to this function. */
6882 /* The offset must be relative to the GOT symbol, twelve bytes
6883 before the end of .got.plt. Each descriptor is eight
6884 bytes. */
6886 else
6887 /* Each .got entry is 4 bytes. The first three are
6888 reserved. */
6891 #ifdef GOT_BIAS
6894 #endif
6896 /* Fill in the entry in the procedure linkage table. */
6902 {
6904 {
6905 bfd_reloc_status_type r;
6911 }
6912 else
6917 }
6918 else
6919 {
6930 {
6934 /* Divide the PLT into groups. The first group contains
6935 REACHABLE_PLTS entries and the other groups contain
6936 PLTS_PER_4K entries. Entries in the first group can
6937 branch directly to .plt; those in later groups branch
6938 to the last element of the previous group. */
6939 /* ??? It would be better to create multiple copies of
6940 the common resolver stub. */
6949 else
6953 /* Install the 'bra' with this offset. */
6959 }
6960 else
6966 }
6968 /* Make got_offset relative to the start of .got.plt. */
6969 #ifdef GOT_BIAS
6972 #endif
6983 /* Fill in the entry in the global offset table. */
6996 /* Fill in the entry in the .rela.plt section. */
7002 else
7005 #ifdef GOT_BIAS
7007 #endif
7012 {
7013 /* Create the .rela.plt.unloaded relocations for this PLT entry.
7014 Begin by pointing LOC to the first such relocation. */
7018 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation
7019 for the PLT entry's pointer to the .got.plt entry. */
7029 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for
7030 the .got.plt entry, which initially points to .plt. */
7037 }
7040 {
7041 /* Mark the symbol as undefined, rather than as defined in
7042 the .plt section. Leave the value alone. */
7044 }
7045 }
7051 {
7054 Elf_Internal_Rela rel;
7057 /* This symbol has an entry in the global offset table. Set it
7058 up. */
7068 /* If this is a static link, or it is a -Bsymbolic link and the
7069 symbol is defined locally or was forced to be local because
7070 of a version file, we just want to emit a RELATIVE reloc.
7071 The entry in the global offset table will already have been
7072 initialized in the relocate_section function. */
7075 {
7077 {
7079 int dynindx
7085 }
7086 else
7087 {
7092 }
7093 }
7094 else
7095 {
7099 }
7104 }
7106 #ifdef INCLUDE_SHMEDIA
7107 {
7112 {
7115 Elf_Internal_Rela rel;
7118 /* This symbol has a datalabel entry in the global offset table.
7119 Set it up. */
7129 /* If this is a static link, or it is a -Bsymbolic link and the
7130 symbol is defined locally or was forced to be local because
7131 of a version file, we just want to emit a RELATIVE reloc.
7132 The entry in the global offset table will already have been
7133 initialized in the relocate_section function. */
7136 {
7138 {
7140 int dynindx
7146 }
7147 else
7148 {
7153 }
7154 }
7155 else
7156 {
7161 }
7166 }
7167 }
7168 #endif
7171 {
7173 Elf_Internal_Rela rel;
7176 /* This symbol needs a copy reloc. Set it up. */
7193 }
7195 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. On VxWorks,
7196 _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
7197 ".got" section. */
7203 }
7205 /* Finish up the dynamic sections. */
7207 static bfd_boolean
7209 {
7222 {
7231 {
7232 Elf_Internal_Dyn dyn;
7234 #ifdef INCLUDE_SHMEDIA
7236 #endif
7241 {
7248 #ifdef INCLUDE_SHMEDIA
7255 get_sym:
7257 {
7263 {
7266 }
7267 }
7269 #endif
7294 /* My reading of the SVR4 ABI indicates that the
7295 procedure linkage table relocs (DT_JMPREL) should be
7296 included in the overall relocs (DT_RELA). This is
7297 what Solaris does. However, UnixWare can not handle
7298 that case. Therefore, we override the DT_RELASZ entry
7299 here to make it not include the JMPREL relocs. Since
7300 the linker script arranges for .rela.plt to follow all
7301 other relocation sections, we don't have to worry
7302 about changing the DT_RELA entry. */
7304 {
7307 }
7310 }
7311 }
7313 /* Fill in the first entry in the procedure linkage table. */
7316 {
7332 {
7333 /* Finalize the .rela.plt.unloaded contents. */
7334 Elf_Internal_Rela rel;
7337 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for the
7338 first PLT entry's pointer to _GLOBAL_OFFSET_TABLE_ + 8. */
7348 /* Fix up the remaining .rela.plt.unloaded relocations.
7349 They may have the wrong symbol index for _G_O_T_ or
7350 _P_L_T_ depending on the order in which symbols were
7351 output. */
7353 {
7354 /* The PLT entry's pointer to the .got.plt slot. */
7357 R_SH_DIR32);
7361 /* The .got.plt slot's pointer to .plt. */
7364 R_SH_DIR32);
7367 }
7368 }
7370 /* UnixWare sets the entsize of .plt to 4, although that doesn't
7371 really seem like the right value. */
7373 }
7374 }
7376 /* Fill in the first three entries in the global offset table. */
7378 {
7381 else
7387 }
7392 /* At the very end of the .rofixup section is a pointer to the GOT. */
7394 {
7402 /* Make sure we allocated and generated the same number of fixups. */
7404 }
7415 }
7417 static enum elf_reloc_type_class
7419 {
7421 {
7430 }
7431 }
7433 #if !defined SH_TARGET_ALREADY_DEFINED
7434 /* Support for Linux core dump NOTE sections. */
7436 static bfd_boolean
7438 {
7443 {
7448 /* pr_cursig */
7451 /* pr_pid */
7454 /* pr_reg */
7459 }
7461 /* Make a ".reg/999" section. */
7464 }
7466 static bfd_boolean
7468 {
7470 {
7479 }
7481 /* Note that for some reason, a spurious space is tacked
7482 onto the end of the args in some (at least one anyway)
7483 implementations, so strip it off if it exists. */
7485 {
7491 }
7494 }
7498 /* Return address for Ith PLT stub in section PLT, for relocation REL
7499 or (bfd_vma) -1 if it should not be included. */
7501 static bfd_vma
7504 {
7509 }
7511 /* Decide whether to attempt to turn absptr or lsda encodings in
7512 shared libraries into pcrel within the given input section. */
7514 static bfd_boolean
7518 {
7521 /* We can't use PC-relative encodings in FDPIC binaries, in general. */
7526 }
7528 /* Adjust the contents of an eh_frame_hdr section before they're output. */
7530 static bfd_byte
7536 {
7553 == (sh_elf_osec_to_segment
7562 }
7564 #if !defined SH_TARGET_ALREADY_DEFINED
7565 #define TARGET_BIG_SYM bfd_elf32_sh_vec
7567 #define TARGET_LITTLE_SYM bfd_elf32_shl_vec
7569 #endif
7571 #define ELF_ARCH bfd_arch_sh
7572 #define ELF_TARGET_ID SH_ELF_DATA
7573 #define ELF_MACHINE_CODE EM_SH
7574 #ifdef __QNXTARGET__
7575 #define ELF_MAXPAGESIZE 0x1000
7576 #else
7577 #define ELF_MAXPAGESIZE 0x80
7578 #endif
7582 #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup
7583 #define bfd_elf32_bfd_reloc_name_lookup \
7584 sh_elf_reloc_name_lookup
7585 #define elf_info_to_howto sh_elf_info_to_howto
7586 #define bfd_elf32_bfd_relax_section sh_elf_relax_section
7587 #define elf_backend_relocate_section sh_elf_relocate_section
7588 #define bfd_elf32_bfd_get_relocated_section_contents \
7589 sh_elf_get_relocated_section_contents
7590 #define bfd_elf32_mkobject sh_elf_mkobject
7591 #define elf_backend_object_p sh_elf_object_p
7592 #define bfd_elf32_bfd_set_private_bfd_flags \
7593 sh_elf_set_private_flags
7594 #define bfd_elf32_bfd_copy_private_bfd_data \
7595 sh_elf_copy_private_data
7596 #define bfd_elf32_bfd_merge_private_bfd_data \
7597 sh_elf_merge_private_data
7599 #define elf_backend_gc_mark_hook sh_elf_gc_mark_hook
7600 #define elf_backend_gc_sweep_hook sh_elf_gc_sweep_hook
7601 #define elf_backend_check_relocs sh_elf_check_relocs
7602 #define elf_backend_copy_indirect_symbol \
7603 sh_elf_copy_indirect_symbol
7604 #define elf_backend_create_dynamic_sections \
7605 sh_elf_create_dynamic_sections
7606 #define bfd_elf32_bfd_link_hash_table_create \
7607 sh_elf_link_hash_table_create
7608 #define elf_backend_adjust_dynamic_symbol \
7609 sh_elf_adjust_dynamic_symbol
7610 #define elf_backend_always_size_sections \
7611 sh_elf_always_size_sections
7612 #define elf_backend_size_dynamic_sections \
7613 sh_elf_size_dynamic_sections
7614 #define elf_backend_omit_section_dynsym sh_elf_omit_section_dynsym
7615 #define elf_backend_finish_dynamic_symbol \
7616 sh_elf_finish_dynamic_symbol
7617 #define elf_backend_finish_dynamic_sections \
7618 sh_elf_finish_dynamic_sections
7619 #define elf_backend_reloc_type_class sh_elf_reloc_type_class
7620 #define elf_backend_plt_sym_val sh_elf_plt_sym_val
7621 #define elf_backend_can_make_relative_eh_frame \
7622 sh_elf_use_relative_eh_frame
7623 #define elf_backend_can_make_lsda_relative_eh_frame \
7624 sh_elf_use_relative_eh_frame
7625 #define elf_backend_encode_eh_address \
7626 sh_elf_encode_eh_address
7628 #define elf_backend_can_gc_sections 1
7629 #define elf_backend_can_refcount 1
7630 #define elf_backend_want_got_plt 1
7631 #define elf_backend_plt_readonly 1
7632 #define elf_backend_want_plt_sym 0
7633 #define elf_backend_got_header_size 12
7635 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED
7639 /* NetBSD support. */
7640 #undef TARGET_BIG_SYM
7641 #define TARGET_BIG_SYM bfd_elf32_shnbsd_vec
7642 #undef TARGET_BIG_NAME
7644 #undef TARGET_LITTLE_SYM
7645 #define TARGET_LITTLE_SYM bfd_elf32_shlnbsd_vec
7646 #undef TARGET_LITTLE_NAME
7648 #undef ELF_MAXPAGESIZE
7649 #define ELF_MAXPAGESIZE 0x10000
7650 #undef ELF_COMMONPAGESIZE
7651 #undef elf_symbol_leading_char
7652 #define elf_symbol_leading_char 0
7653 #undef elf32_bed
7654 #define elf32_bed elf32_sh_nbsd_bed
7659 /* Linux support. */
7660 #undef TARGET_BIG_SYM
7661 #define TARGET_BIG_SYM bfd_elf32_shblin_vec
7662 #undef TARGET_BIG_NAME
7664 #undef TARGET_LITTLE_SYM
7665 #define TARGET_LITTLE_SYM bfd_elf32_shlin_vec
7666 #undef TARGET_LITTLE_NAME
7668 #undef ELF_COMMONPAGESIZE
7669 #define ELF_COMMONPAGESIZE 0x1000
7671 #undef elf_backend_grok_prstatus
7672 #define elf_backend_grok_prstatus elf32_shlin_grok_prstatus
7673 #undef elf_backend_grok_psinfo
7674 #define elf_backend_grok_psinfo elf32_shlin_grok_psinfo
7675 #undef elf32_bed
7676 #define elf32_bed elf32_sh_lin_bed
7681 /* FDPIC support. */
7682 #undef TARGET_BIG_SYM
7683 #define TARGET_BIG_SYM bfd_elf32_shbfd_vec
7684 #undef TARGET_BIG_NAME
7686 #undef TARGET_LITTLE_SYM
7687 #define TARGET_LITTLE_SYM bfd_elf32_shfd_vec
7688 #undef TARGET_LITTLE_NAME
7690 #undef elf_backend_modify_program_headers
7691 #define elf_backend_modify_program_headers \
7692 sh_elf_modify_program_headers
7694 #undef elf32_bed
7695 #define elf32_bed elf32_sh_fd_bed
7699 #undef elf_backend_modify_program_headers
7701 /* VxWorks support. */
7702 #undef TARGET_BIG_SYM
7703 #define TARGET_BIG_SYM bfd_elf32_shvxworks_vec
7704 #undef TARGET_BIG_NAME
7706 #undef TARGET_LITTLE_SYM
7707 #define TARGET_LITTLE_SYM bfd_elf32_shlvxworks_vec
7708 #undef TARGET_LITTLE_NAME
7710 #undef elf32_bed
7711 #define elf32_bed elf32_sh_vxworks_bed
7713 #undef elf_backend_want_plt_sym
7714 #define elf_backend_want_plt_sym 1
7715 #undef elf_symbol_leading_char
7717 #define elf_backend_want_got_underscore 1
7718 #undef elf_backend_grok_prstatus
7719 #undef elf_backend_grok_psinfo
7720 #undef elf_backend_add_symbol_hook
7721 #define elf_backend_add_symbol_hook elf_vxworks_add_symbol_hook
7722 #undef elf_backend_link_output_symbol_hook
7723 #define elf_backend_link_output_symbol_hook \
7724 elf_vxworks_link_output_symbol_hook
7725 #undef elf_backend_emit_relocs
7726 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
7727 #undef elf_backend_final_write_processing
7728 #define elf_backend_final_write_processing \
7729 elf_vxworks_final_write_processing
7730 #undef ELF_MAXPAGESIZE
7731 #define ELF_MAXPAGESIZE 0x1000
7732 #undef ELF_COMMONPAGESIZE