| blob | 9f03262eb38694f15550eb8bb7bc27c24f01c8c2 |
1 /* MIPS-specific support for 32-bit ELF
2 Copyright 1993, 94, 95, 96, 97, 98, 1999 Free Software Foundation, Inc.
4 Most of the information added by Ian Lance Taylor, Cygnus Support,
5 <ian@cygnus.com>.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23 /* This file handles MIPS ELF targets. SGI Irix 5 uses a slightly
24 different MIPS ELF from other targets. This matters when linking.
25 This file supports both, switching at runtime. */
35 /* Get the ECOFF swapping routines. */
41 #define ECOFF_32
44 static bfd_reloc_status_type mips32_64bit_reloc
48 static void mips_info_to_howto_rel
50 static void bfd_mips_elf32_swap_gptab_in
52 static void bfd_mips_elf32_swap_gptab_out
56 static boolean mips_elf_create_procedure_table
64 static boolean mips_elf32_section_from_shdr
66 static boolean mips_elf32_section_processing
68 static boolean mips_elf_is_local_label_name
75 static boolean mips_elf_final_link
77 static void mips_elf_relocate_hi16
79 bfd_vma));
80 static boolean mips_elf_relocate_got_local
83 static void mips_elf_relocate_global_got
85 static bfd_reloc_status_type mips16_jump_reloc
87 static bfd_reloc_status_type mips16_gprel_reloc
89 static boolean mips_elf_adjust_dynindx
91 static boolean mips_elf_relocate_section
94 static boolean mips_elf_link_output_symbol_hook
96 asection *));
97 static boolean mips_elf_create_dynamic_sections
99 static boolean mips_elf_create_compact_rel_section
101 static boolean mips_elf_create_got_section
103 static boolean mips_elf_check_relocs
106 static boolean mips_elf_adjust_dynamic_symbol
108 static boolean mips_elf_always_size_sections
110 static boolean mips_elf_size_dynamic_sections
112 static boolean mips_elf_finish_dynamic_symbol
114 Elf_Internal_Sym *));
115 static boolean mips_elf_finish_dynamic_sections
117 static boolean mips_elf_add_symbol_hook
120 static bfd_reloc_status_type mips_elf_final_gp
126 /* This is true for Irix 5 executables, false for normal MIPS ELF ABI
127 executables. FIXME: At the moment, we default to always generating
128 Irix 5 executables. */
130 #define SGI_COMPAT(abfd) (1)
132 /* This structure is used to hold .got information when linking. It
133 is stored in the tdata field of the bfd_elf_section_data structure. */
135 struct mips_got_info
136 {
137 /* The symbol index of the first global .got symbol. */
139 /* The number of local .got entries. */
141 /* The number of local .got entries we have used. */
143 };
145 /* The number of local .got entries we reserve. */
146 #define MIPS_RESERVED_GOTNO (2)
148 /* Instructions which appear in a stub. For some reason the stub is
149 slightly different on an SGI system. */
150 #define ELF_MIPS_GP_OFFSET(abfd) (SGI_COMPAT (abfd) ? 0x7ff0 : 0x8000)
151 #define STUB_LW(abfd) \
152 (SGI_COMPAT (abfd) \
158 #define MIPS_FUNCTION_STUB_SIZE (16)
160 #if 0
161 /* We no longer try to identify particular sections for the .dynsym
162 section. When we do, we wind up crashing if there are other random
163 sections with relocations. */
165 /* Names of sections which appear in the .dynsym section in an Irix 5
166 executable. */
169 {
178 NULL
179 };
181 #define SIZEOF_MIPS_DYNSYM_SECNAMES \
182 (sizeof mips_elf_dynsym_sec_names / sizeof mips_elf_dynsym_sec_names[0])
184 /* The number of entries in mips_elf_dynsym_sec_names which go in the
185 text segment. */
187 #define MIPS_TEXT_DYNSYM_SECNO (3)
191 /* The names of the runtime procedure table symbols used on Irix 5. */
194 {
198 NULL
199 };
201 /* These structures are used to generate the .compact_rel section on
202 Irix 5. */
205 {
215 {
225 {
235 {
244 {
251 {
256 /* These are the constants used to swap the bitfields in a crinfo. */
258 #define CRINFO_CTYPE (0x1)
259 #define CRINFO_CTYPE_SH (31)
260 #define CRINFO_RTYPE (0xf)
261 #define CRINFO_RTYPE_SH (27)
262 #define CRINFO_DIST2TO (0xff)
263 #define CRINFO_DIST2TO_SH (19)
264 #define CRINFO_RELVADDR (0x7ffff)
265 #define CRINFO_RELVADDR_SH (0)
267 /* A compact relocation info has long (3 words) or short (2 words)
268 formats. A short format doesn't have VADDR field and relvaddr
269 fields contains ((VADDR - vaddr of the previous entry) >> 2). */
270 #define CRF_MIPS_LONG 1
271 #define CRF_MIPS_SHORT 0
273 /* There are 4 types of compact relocation at least. The value KONST
274 has different meaning for each type:
276 (type) (konst)
277 CT_MIPS_REL32 Address in data
278 CT_MIPS_WORD Address in word (XXX)
279 CT_MIPS_GPHI_LO GP - vaddr
280 CT_MIPS_JMPAD Address to jump
281 */
283 #define CRT_MIPS_REL32 0xa
284 #define CRT_MIPS_WORD 0xb
285 #define CRT_MIPS_GPHI_LO 0xc
286 #define CRT_MIPS_JMPAD 0xd
288 #define mips_elf_set_cr_format(x,format) ((x).ctype = (format))
289 #define mips_elf_set_cr_type(x,type) ((x).rtype = (type))
290 #define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v))
291 #define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2)
293 static void bfd_elf32_swap_compact_rel_out
295 static void bfd_elf32_swap_crinfo_out
301 {
302 /* No relocation. */
317 /* 16 bit relocation. */
332 /* 32 bit relocation. */
347 /* 32 bit symbol relative relocation. */
362 /* 26 bit branch address. */
370 /* This needs complex overflow
371 detection, because the upper four
372 bits must match the PC. */
380 /* High 16 bits of symbol value. */
395 /* Low 16 bits of symbol value. */
410 /* GP relative reference. */
425 /* Reference to literal section. */
440 /* Reference to global offset table. */
455 /* 16 bit PC relative reference. */
470 /* 16 bit call through global offset table. */
471 /* FIXME: This is not handled correctly. */
486 /* 32 bit GP relative reference. */
501 /* The remaining relocs are defined on Irix 5, although they are
502 not defined by the ABI. */
507 /* A 5 bit shift field. */
522 /* A 6 bit shift field. */
523 /* FIXME: This is not handled correctly; a special function is
524 needed to put the most significant bit in the right place. */
539 /* A 64 bit relocation. This is used in 32 bit ELF when addresses
540 are 64 bits long; the upper 32 bits are simply a sign extension.
541 The fields of the howto should be the same as for R_MIPS_32,
542 other than the type, name, and special_function. */
557 /* Displacement in the global offset table. */
558 /* FIXME: Not handled correctly. */
573 /* Displacement to page pointer in the global offset table. */
574 /* FIXME: Not handled correctly. */
589 /* Offset from page pointer in the global offset table. */
590 /* FIXME: Not handled correctly. */
605 /* High 16 bits of displacement in global offset table. */
606 /* FIXME: Not handled correctly. */
621 /* Low 16 bits of displacement in global offset table. */
622 /* FIXME: Not handled correctly. */
637 /* 64 bit subtraction. Presumably not used in 32 bit ELF. */
640 /* Used to cause the linker to insert and delete instructions? */
645 /* Get the higher values of a 64 bit addend. Presumably not used in
646 32 bit ELF. */
650 /* High 16 bits of displacement in global offset table. */
651 /* FIXME: Not handled correctly. */
666 /* Low 16 bits of displacement in global offset table. */
667 /* FIXME: Not handled correctly. */
687 };
689 /* The reloc used for BFD_RELOC_CTOR when doing a 64 bit link. This
690 is a hack to make the linker think that we need 64 bit values. */
706 /* The reloc used for the mips16 jump instruction. */
715 /* This needs complex overflow
716 detection, because the upper four
717 bits must match the PC. */
725 /* The reloc used for the mips16 gprel instruction. The src_mask and
726 dsk_mask for this howto do not reflect the actual instruction, in
727 which the value is not contiguous; the masks are for the
728 convenience of the relocate_section routine. */
745 /* GNU extension to record C++ vtable hierarchy */
761 /* GNU extension to record C++ vtable member usage */
777 /* Do a R_MIPS_HI16 relocation. This has to be done in combination
778 with a R_MIPS_LO16 reloc, because there is a carry from the LO16 to
779 the HI16. Here we just save the information we need; we do the
780 actual relocation when we see the LO16. MIPS ELF requires that the
781 LO16 immediately follow the HI16. As a GNU extension, we permit an
782 arbitrary number of HI16 relocs to be associated with a single LO16
783 reloc. This extension permits gcc to output the HI and LO relocs
784 itself. */
786 struct mips_hi16
787 {
790 bfd_vma addend;
791 };
793 /* FIXME: This should not be a static variable. */
797 bfd_reloc_status_type
799 reloc_entry,
800 symbol,
801 data,
802 input_section,
803 output_bfd,
804 error_message)
808 PTR data;
812 {
813 bfd_reloc_status_type ret;
814 bfd_vma relocation;
817 /* If we're relocating, and this an external symbol, we don't want
818 to change anything. */
822 {
825 }
830 {
831 boolean relocateable;
832 bfd_vma gp;
839 else
840 {
843 }
851 }
852 else
853 {
860 else
862 }
871 /* Save the information, and let LO16 do the actual relocation. */
884 }
886 /* Do a R_MIPS_LO16 relocation. This is a straightforward 16 bit
887 inplace relocation; this function exists in order to do the
888 R_MIPS_HI16 relocation described above. */
890 bfd_reloc_status_type
892 reloc_entry,
893 symbol,
894 data,
895 input_section,
896 output_bfd,
897 error_message)
901 PTR data;
905 {
906 arelent gp_disp_relent;
909 {
914 {
920 /* Do the HI16 relocation. Note that we actually don't need
921 to know anything about the LO16 itself, except where to
922 find the low 16 bits of the addend needed by the LO16. */
929 /* The low order 16 bits are always treated as a signed
930 value. Therefore, a negative value in the low order bits
931 requires an adjustment in the high order bits. We need
932 to make this adjustment in two ways: once for the bits we
933 took from the data, and once for the bits we are putting
934 back in to the data. */
944 {
948 }
953 }
956 }
958 {
959 bfd_reloc_status_type ret;
962 /* FIXME: Does this case ever occur? */
979 }
981 /* Now do the LO16 reloc in the usual way. */
984 }
986 /* Do a R_MIPS_GOT16 reloc. This is a reloc against the global offset
987 table used for PIC code. If the symbol is an external symbol, the
988 instruction is modified to contain the offset of the appropriate
989 entry in the global offset table. If the symbol is a section
990 symbol, the next reloc is a R_MIPS_LO16 reloc. The two 16 bit
991 addends are combined to form the real addend against the section
992 symbol; the GOT16 is modified to contain the offset of an entry in
993 the global offset table, and the LO16 is modified to offset it
994 appropriately. Thus an offset larger than 16 bits requires a
995 modified value in the global offset table.
997 This implementation suffices for the assembler, but the linker does
998 not yet know how to create global offset tables. */
1000 bfd_reloc_status_type
1002 reloc_entry,
1003 symbol,
1004 data,
1005 input_section,
1006 output_bfd,
1007 error_message)
1011 PTR data;
1015 {
1016 /* If we're relocating, and this an external symbol, we don't want
1017 to change anything. */
1021 {
1024 }
1026 /* If we're relocating, and this is a local symbol, we can handle it
1027 just like HI16. */
1034 }
1036 /* We have to figure out the gp value, so that we can adjust the
1037 symbol value correctly. We look up the symbol _gp in the output
1038 BFD. If we can't find it, we're stuck. We cache it in the ELF
1039 target data. We don't need to adjust the symbol value for an
1040 external symbol if we are producing relocateable output. */
1042 static bfd_reloc_status_type
1046 boolean relocateable;
1049 {
1052 {
1055 }
1059 && (! relocateable
1061 {
1063 {
1064 /* Make up a value. */
1067 }
1068 else
1069 {
1079 else
1080 {
1082 {
1087 {
1091 }
1092 }
1093 }
1096 {
1097 /* Only get the error once. */
1103 }
1104 }
1105 }
1108 }
1110 /* Do a R_MIPS_GPREL16 relocation. This is a 16 bit value which must
1111 become the offset from the gp register. This function also handles
1112 R_MIPS_LITERAL relocations, although those can be handled more
1113 cleverly because the entries in the .lit8 and .lit4 sections can be
1114 merged. */
1120 bfd_reloc_status_type
1126 PTR data;
1130 {
1131 boolean relocateable;
1132 bfd_reloc_status_type ret;
1133 bfd_vma gp;
1135 /* If we're relocating, and this is an external symbol with no
1136 addend, we don't want to change anything. We will only have an
1137 addend if this is a newly created reloc, not read from an ELF
1138 file. */
1142 {
1145 }
1149 else
1150 {
1153 }
1162 }
1164 static bfd_reloc_status_type
1166 gp)
1171 boolean relocateable;
1172 PTR data;
1173 bfd_vma gp;
1174 {
1175 bfd_vma relocation;
1181 else
1192 /* Set val to the offset into the section or symbol. */
1194 {
1195 /* This case occurs with the 64-bit MIPS ELF ABI. */
1197 }
1198 else
1199 {
1203 }
1205 /* Adjust val for the final section location and GP value. If we
1206 are producing relocateable output, we don't want to do this for
1207 an external symbol. */
1218 /* Make sure it fit in 16 bits. */
1223 }
1225 /* Do a R_MIPS_GPREL32 relocation. Is this 32 bit value the offset
1226 from the gp register? XXX */
1232 bfd_reloc_status_type
1234 reloc_entry,
1235 symbol,
1236 data,
1237 input_section,
1238 output_bfd,
1239 error_message)
1243 PTR data;
1247 {
1248 boolean relocateable;
1249 bfd_reloc_status_type ret;
1250 bfd_vma gp;
1252 /* If we're relocating, and this is an external symbol with no
1253 addend, we don't want to change anything. We will only have an
1254 addend if this is a newly created reloc, not read from an ELF
1255 file. */
1259 {
1263 }
1266 {
1269 }
1270 else
1271 {
1279 }
1283 }
1285 static bfd_reloc_status_type
1287 gp)
1292 boolean relocateable;
1293 PTR data;
1294 bfd_vma gp;
1295 {
1296 bfd_vma relocation;
1301 else
1311 {
1312 /* This case arises with the 64-bit MIPS ELF ABI. */
1314 }
1315 else
1318 /* Set val to the offset into the section or symbol. */
1321 /* Adjust val for the final section location and GP value. If we
1322 are producing relocateable output, we don't want to do this for
1323 an external symbol. */
1334 }
1336 /* Handle a 64 bit reloc in a 32 bit MIPS ELF file. These are
1337 generated when addreses are 64 bits. The upper 32 bits are a simle
1338 sign extension. */
1340 static bfd_reloc_status_type
1346 PTR data;
1350 {
1351 bfd_reloc_status_type r;
1352 arelent reloc32;
1354 bfd_size_type addr;
1361 /* Do a normal 32 bit relocation on the lower 32 bits. */
1369 /* Sign extend into the upper 32 bits. */
1373 else
1381 }
1383 /* Handle a mips16 jump. */
1385 static bfd_reloc_status_type
1391 PTR data;
1395 {
1399 {
1402 }
1404 /* FIXME. */
1405 {
1413 }
1416 }
1418 /* Handle a mips16 GP relative reloc. */
1420 static bfd_reloc_status_type
1426 PTR data;
1430 {
1431 boolean relocateable;
1432 bfd_reloc_status_type ret;
1433 bfd_vma gp;
1437 /* If we're relocating, and this is an external symbol with no
1438 addend, we don't want to change anything. We will only have an
1439 addend if this is a newly created reloc, not read from an ELF
1440 file. */
1444 {
1447 }
1451 else
1452 {
1455 }
1465 /* Pick up the mips16 extend instruction and the real instruction. */
1469 /* Stuff the current addend back as a 32 bit value, do the usual
1470 relocation, and then clean up. */
1492 }
1494 /* Return the ISA for a MIPS e_flags value. */
1498 flagword flags;
1499 {
1501 {
1510 }
1512 }
1514 /* Return the MACH for a MIPS e_flags value. */
1518 flagword flags;
1519 {
1521 {
1539 {
1556 }
1557 }
1560 }
1562 /* Return printable name for ABI from flagword. */
1566 flagword flags;
1567 {
1569 {
1582 }
1583 }
1585 /* A mapping from BFD reloc types to MIPS ELF reloc types. */
1588 bfd_reloc_code_real_type bfd_reloc_val;
1590 };
1593 {
1611 };
1613 /* Given a BFD reloc type, return a howto structure. */
1618 bfd_reloc_code_real_type code;
1619 {
1623 {
1626 }
1629 {
1635 /* We need to handle BFD_RELOC_CTOR specially.
1636 Select the right relocation (R_MIPS_32 or R_MIPS_64) based on the
1637 size of addresses on this architecture. */
1640 else
1651 }
1652 }
1654 /* Given a MIPS reloc type, fill in an arelent structure. */
1656 static void
1661 {
1666 {
1684 }
1686 /* The addend for a GPREL16 or LITERAL relocation comes from the GP
1687 value for the object file. We get the addend now, rather than
1688 when we do the relocation, because the symbol manipulations done
1689 by the linker may cause us to lose track of the input BFD. */
1694 }
1695 \f
1696 /* A .reginfo section holds a single Elf32_RegInfo structure. These
1697 routines swap this structure in and out. They are used outside of
1698 BFD, so they are globally visible. */
1700 void
1705 {
1712 }
1714 void
1719 {
1732 }
1734 /* In the 64 bit ABI, the .MIPS.options section holds register
1735 information in an Elf64_Reginfo structure. These routines swap
1736 them in and out. They are globally visible because they are used
1737 outside of BFD. These routines are here so that gas can call them
1738 without worrying about whether the 64 bit ABI has been included. */
1740 void
1745 {
1753 }
1755 void
1760 {
1775 }
1777 /* Swap an entry in a .gptab section. Note that these routines rely
1778 on the equivalence of the two elements of the union. */
1780 static void
1785 {
1788 }
1790 static void
1795 {
1800 }
1802 static void
1807 {
1814 }
1816 static void
1821 {
1831 }
1833 /* Swap in an options header. */
1835 void
1840 {
1845 }
1847 /* Swap out an options header. */
1849 void
1854 {
1859 }
1860 \f
1861 /* Determine whether a symbol is global for the purposes of splitting
1862 the symbol table into global symbols and local symbols. At least
1863 on Irix 5, this split must be between section symbols and all other
1864 symbols. On most ELF targets the split is between static symbols
1865 and externally visible symbols. */
1867 /*ARGSUSED*/
1868 static boolean
1872 {
1874 }
1875 \f
1876 /* Set the right machine number for a MIPS ELF file. This is used for
1877 both the 32-bit and the 64-bit ABI. */
1879 boolean
1882 {
1886 }
1888 /* Set the right machine number for a 32-bit MIPS ELF file. */
1890 static boolean
1893 {
1894 /* Irix 5 is broken. Object file symbol tables are not always
1895 sorted correctly such that local symbols precede global symbols,
1896 and the sh_info field in the symbol table is not always right. */
1900 }
1902 /* The final processing done just before writing out a MIPS ELF object
1903 file. This gets the MIPS architecture right based on the machine
1904 number. This is used by both the 32-bit and the 64-bit ABI. */
1906 /*ARGSUSED*/
1907 void
1910 boolean linker;
1911 {
1919 {
1957 }
1962 /* Set the sh_info field for .gptab sections and other appropriate
1963 info for each special section. */
1967 {
1969 {
2014 else
2015 {
2019 (name
2021 }
2026 }
2027 }
2028 }
2029 \f
2030 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
2032 boolean
2035 flagword flags;
2036 {
2043 }
2045 /* Copy backend specific data from one object module to another */
2047 boolean
2051 {
2064 }
2066 /* Merge backend specific data from an object file to the output
2067 object file when linking. */
2069 boolean
2073 {
2074 flagword old_flags;
2075 flagword new_flags;
2076 boolean ok;
2078 /* Check if we have the same endianess */
2081 {
2086 else
2093 }
2104 {
2110 {
2114 }
2117 }
2119 /* Check flag compatibility. */
2130 {
2137 }
2140 {
2147 }
2149 /* Compare the ISA's. */
2152 {
2158 /* If either has no machine specified, just compare the general isa's.
2159 Some combinations of machines are ok, if the isa's match. */
2161 || ! old_mach
2163 )
2164 {
2165 /* Don't warn about mixing -mips1 and -mips2 code, or mixing -mips3
2166 and -mips4 code. They will normally use the same data sizes and
2167 calling conventions. */
2172 {
2177 }
2178 }
2180 else
2181 {
2188 }
2192 }
2194 /* Compare ABI's */
2196 {
2197 /* Only error if both are set (to different values). */
2200 {
2207 }
2210 }
2212 /* Warn about any other mismatches */
2214 {
2220 }
2223 {
2226 }
2229 }
2230 \f
2231 static boolean
2234 PTR ptr;
2235 {
2240 /* Print normal ELF private data. */
2243 /* xgettext:c-format */
2256 else
2267 else
2272 else
2278 }
2279 \f
2280 /* Handle a MIPS specific section when reading an object file. This
2281 is called when elfcode.h finds a section with an unknown type.
2282 This routine supports both the 32-bit and 64-bit ELF ABI.
2284 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
2285 how to. */
2287 boolean
2292 {
2295 /* There ought to be a place to keep ELF backend specific flags, but
2296 at the moment there isn't one. We just keep track of the
2297 sections by their name, instead. Fortunately, the ABI gives
2298 suggested names for all the MIPS specific sections, so we will
2299 probably get away with this. */
2301 {
2362 }
2368 {
2374 }
2377 }
2379 /* Handle a 32-bit MIPS ELF specific section. */
2381 static boolean
2386 {
2390 /* FIXME: We should record sh_info for a .gptab section. */
2392 /* For a .reginfo section, set the gp value in the tdata information
2393 from the contents of this section. We need the gp value while
2394 processing relocs, so we just get it now. The .reginfo section
2395 is not used in the 64-bit MIPS ELF ABI. */
2397 {
2398 Elf32_External_RegInfo ext;
2399 Elf32_RegInfo s;
2406 }
2408 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
2409 set the gp value based on what we find. We may see both
2410 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
2411 they should agree. */
2413 {
2421 {
2424 }
2428 {
2429 Elf_Internal_Options intopt;
2434 {
2435 Elf32_RegInfo intreg;
2437 bfd_mips_elf32_swap_reginfo_in
2443 }
2445 }
2447 }
2450 }
2452 /* Set the correct type for a MIPS ELF section. We do this by the
2453 section name, which is a hack, but ought to work. This routine is
2454 used by both the 32-bit and the 64-bit ABI. */
2456 boolean
2461 {
2467 {
2470 /* The sh_link field is set in final_write_processing. */
2471 }
2473 {
2476 /* FIXME: Set the sh_info field. */
2477 }
2481 {
2484 /* The sh_info field is set in final_write_processing. */
2485 }
2489 {
2491 /* In a shared object on Irix 5.3, the .mdebug section has an
2492 entsize of 0. FIXME: Does this matter? */
2495 else
2497 }
2499 {
2501 /* In a shared object on Irix 5.3, the .reginfo section has an
2502 entsize of 0x18. FIXME: Does this matter? */
2505 else
2507 }
2512 {
2514 #if 0
2515 /* This isn't how the Irix 6 linker behaves. */
2517 #endif
2518 }
2526 {
2529 }
2531 {
2533 /* The sh_info field is set in final_write_processing. */
2534 }
2537 {
2541 }
2545 {
2547 /* The sh_link and sh_info fields are set in
2548 final_write_processing. */
2549 }
2553 {
2556 /* The sh_link field is set in final_write_processing. */
2557 }
2560 }
2562 /* Given a BFD section, try to locate the corresponding ELF section
2563 index. This is used by both the 32-bit and the 64-bit ABI.
2564 Actually, it's not clear to me that the 64-bit ABI supports these,
2565 but for non-PIC objects we will certainly want support for at least
2566 the .scommon section. */
2568 boolean
2574 {
2576 {
2579 }
2581 {
2584 }
2586 }
2588 /* When are writing out the .options or .MIPS.options section,
2589 remember the bytes we are writing out, so that we can install the
2590 GP value in the section_processing routine. */
2592 boolean
2595 sec_ptr section;
2596 PTR location;
2597 file_ptr offset;
2598 bfd_size_type count;
2599 {
2602 {
2606 {
2611 }
2614 {
2615 bfd_size_type size;
2619 else
2625 }
2628 }
2631 count);
2632 }
2634 /* Work over a section just before writing it out. This routine is
2635 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
2636 sections that need the SHF_MIPS_GPREL flag by name; there has to be
2637 a better way. */
2639 boolean
2643 {
2645 {
2649 {
2652 }
2654 {
2657 }
2660 {
2663 }
2665 {
2668 }
2670 {
2672 {
2678 }
2679 }
2680 }
2683 }
2685 /* Work over a section just before writing it out. We update the GP
2686 value in the SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS sections based
2687 on the value we are using. */
2689 static boolean
2693 {
2695 {
2708 }
2714 {
2717 /* We stored the section contents in the elf_section_data tdata
2718 field in the set_section_contents routine. We save the
2719 section contents so that we don't have to read them again.
2720 At this point we know that elf_gp is set, so we can look
2721 through the section contents to see if there is an
2722 ODK_REGINFO structure. */
2728 {
2729 Elf_Internal_Options intopt;
2734 {
2747 }
2749 }
2750 }
2753 }
2754 \f
2755 /* MIPS ELF uses two common sections. One is the usual one, and the
2756 other is for small objects. All the small objects are kept
2757 together, and then referenced via the gp pointer, which yields
2758 faster assembler code. This is what we use for the small common
2759 section. This approach is copied from ecoff.c. */
2764 /* MIPS ELF also uses an acommon section, which represents an
2765 allocated common symbol which may be overridden by a
2766 definition in a shared library. */
2771 /* The Irix 5 support uses two virtual sections, which represent
2772 text/data symbols defined in dynamic objects. */
2783 /* Handle the special MIPS section numbers that a symbol may use.
2784 This is used for both the 32-bit and the 64-bit ABI. */
2786 void
2790 {
2795 {
2797 /* This section is used in a dynamically linked executable file.
2798 It is an allocated common section. The dynamic linker can
2799 either resolve these symbols to something in a shared
2800 library, or it can just leave them here. For our purposes,
2801 we can consider these symbols to be in a new section. */
2803 {
2804 /* Initialize the acommon section. */
2814 }
2819 /* Common symbols less than the GP size are automatically
2820 treated as SHN_MIPS_SCOMMON symbols. */
2823 /* Fall through. */
2826 {
2827 /* Initialize the small common section. */
2837 }
2854 #endif
2855 }
2856 }
2857 \f
2858 /* When creating an Irix 5 executable, we need REGINFO and RTPROC
2859 segments. */
2861 static int
2864 {
2875 {
2876 /* We need a PT_MIPS_REGINFO segment. */
2878 }
2882 {
2883 /* We need a PT_MIPS_RTPROC segment. */
2885 }
2888 }
2890 /* Modify the segment map for an Irix 5 executable. */
2892 static boolean
2895 {
2902 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
2903 segment. */
2906 {
2911 {
2920 /* We want to put it after the PHDR and INTERP segments. */
2929 }
2930 }
2932 /* If there are .dynamic and .mdebug sections, we make a room for
2933 the RTPROC header. FIXME: Rewrite without section names. */
2937 {
2942 {
2951 {
2955 }
2956 else
2957 {
2960 }
2962 /* We want to put it after the DYNAMIC segment. */
2971 }
2972 }
2974 /* On Irix 5, the PT_DYNAMIC segment includes the .dynamic, .dynstr,
2975 .dynsym, and .hash sections, and everything in between. */
2983 {
2993 {
2996 {
2997 bfd_size_type sz;
3006 }
3007 }
3027 {
3033 {
3036 }
3037 }
3040 }
3043 }
3044 \f
3045 /* The structure of the runtime procedure descriptor created by the
3046 loader for use by the static exception system. */
3061 #define cbRPDR sizeof(RPDR)
3062 #define rpdNil ((pRPDR) 0)
3064 /* Swap RPDR (runtime procedure table entry) for output. */
3066 static void ecoff_swap_rpdr_out
3069 static void
3074 {
3075 /* ecoff_put_off was defined in ecoffswap.h. */
3089 #endif
3090 }
3091 \f
3092 /* Read ECOFF debugging information from a .mdebug section into a
3093 ecoff_debug_info structure. */
3095 boolean
3100 {
3120 /* The symbolic header contains absolute file offsets and sizes to
3121 read. */
3122 #define READ(ptr, offset, count, size, type) \
3123 if (symhdr->count == 0) \
3124 debug->ptr = NULL; \
3125 else \
3126 { \
3127 debug->ptr = (type) bfd_malloc ((size_t) (size * symhdr->count)); \
3128 if (debug->ptr == NULL) \
3129 goto error_return; \
3130 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
3131 || (bfd_read (debug->ptr, size, symhdr->count, \
3132 abfd) != size * symhdr->count)) \
3133 goto error_return; \
3134 }
3148 #undef READ
3155 error_return:
3181 }
3182 \f
3183 /* MIPS ELF local labels start with '$', not 'L'. */
3185 /*ARGSUSED*/
3186 static boolean
3190 {
3194 /* On Irix 6, the labels go back to starting with '.', so we accept
3195 the generic ELF local label syntax as well. */
3197 }
3199 /* MIPS ELF uses a special find_nearest_line routine in order the
3200 handle the ECOFF debugging information. */
3202 struct mips_elf_find_line
3203 {
3206 };
3208 boolean
3214 bfd_vma offset;
3218 {
3223 line_ptr))
3228 line_ptr))
3233 {
3234 flagword origflags;
3239 /* If we are called during a link, mips_elf_final_link may have
3240 cleared the SEC_HAS_CONTENTS field. We force it back on here
3241 if appropriate (which it normally will be). */
3248 {
3249 bfd_size_type external_fdr_size;
3257 {
3260 }
3263 {
3266 }
3268 /* Swap in the FDR information. */
3274 {
3277 }
3281 fraw_end = (fraw_src
3288 /* Note that we don't bother to ever free this information.
3289 find_nearest_line is either called all the time, as in
3290 objdump -l, so the information should be saved, or it is
3291 rarely called, as in ld error messages, so the memory
3292 wasted is unimportant. Still, it would probably be a
3293 good idea for free_cached_info to throw it away. */
3294 }
3298 line_ptr))
3299 {
3302 }
3305 }
3307 /* Fall back on the generic ELF find_nearest_line routine. */
3311 line_ptr);
3312 }
3313 \f
3314 /* The mips16 compiler uses a couple of special sections to handle
3315 floating point arguments.
3317 Section names that look like .mips16.fn.FNNAME contain stubs that
3318 copy floating point arguments from the fp regs to the gp regs and
3319 then jump to FNNAME. If any 32 bit function calls FNNAME, the
3320 call should be redirected to the stub instead. If no 32 bit
3321 function calls FNNAME, the stub should be discarded. We need to
3322 consider any reference to the function, not just a call, because
3323 if the address of the function is taken we will need the stub,
3324 since the address might be passed to a 32 bit function.
3326 Section names that look like .mips16.call.FNNAME contain stubs
3327 that copy floating point arguments from the gp regs to the fp
3328 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
3329 then any 16 bit function that calls FNNAME should be redirected
3330 to the stub instead. If FNNAME is not a 32 bit function, the
3331 stub should be discarded.
3333 .mips16.call.fp.FNNAME sections are similar, but contain stubs
3334 which call FNNAME and then copy the return value from the fp regs
3335 to the gp regs. These stubs store the return value in $18 while
3336 calling FNNAME; any function which might call one of these stubs
3337 must arrange to save $18 around the call. (This case is not
3338 needed for 32 bit functions that call 16 bit functions, because
3339 16 bit functions always return floating point values in both
3340 $f0/$f1 and $2/$3.)
3342 Note that in all cases FNNAME might be defined statically.
3343 Therefore, FNNAME is not used literally. Instead, the relocation
3344 information will indicate which symbol the section is for.
3346 We record any stubs that we find in the symbol table. */
3352 /* The MIPS ELF linker needs additional information for each symbol in
3353 the global hash table. */
3355 struct mips_elf_link_hash_entry
3356 {
3359 /* External symbol information. */
3360 EXTR esym;
3362 /* Number of MIPS_32 or MIPS_REL32 relocs against this symbol. */
3365 /* If there is a stub that 32 bit functions should use to call this
3366 16 bit function, this points to the section containing the stub. */
3369 /* Whether we need the fn_stub; this is set if this symbol appears
3370 in any relocs other than a 16 bit call. */
3371 boolean need_fn_stub;
3373 /* If there is a stub that 16 bit functions should use to call this
3374 32 bit function, this points to the section containing the stub. */
3377 /* This is like the call_stub field, but it is used if the function
3378 being called returns a floating point value. */
3380 };
3382 /* MIPS ELF linker hash table. */
3384 struct mips_elf_link_hash_table
3385 {
3387 #if 0
3388 /* We no longer use this. */
3389 /* String section indices for the dynamic section symbols. */
3391 #endif
3392 /* The number of .rtproc entries. */
3393 bfd_size_type procedure_count;
3394 /* The size of the .compact_rel section (if SGI_COMPAT). */
3395 bfd_size_type compact_rel_size;
3396 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic
3397 entry is set to the address of __rld_obj_head as in Irix 5. */
3398 boolean use_rld_obj_head;
3399 /* This is the value of the __rld_map or __rld_obj_head symbol. */
3400 bfd_vma rld_value;
3401 /* This is set if we see any mips16 stub sections. */
3402 boolean mips16_stubs_seen;
3403 };
3405 /* Look up an entry in a MIPS ELF linker hash table. */
3407 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
3408 ((struct mips_elf_link_hash_entry *) \
3409 elf_link_hash_lookup (&(table)->root, (string), (create), \
3410 (copy), (follow)))
3412 /* Traverse a MIPS ELF linker hash table. */
3414 #define mips_elf_link_hash_traverse(table, func, info) \
3415 (elf_link_hash_traverse \
3416 (&(table)->root, \
3417 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
3418 (info)))
3420 /* Get the MIPS ELF linker hash table from a link_info structure. */
3422 #define mips_elf_hash_table(p) \
3423 ((struct mips_elf_link_hash_table *) ((p)->hash))
3425 static boolean mips_elf_output_extsym
3428 /* Create an entry in a MIPS ELF linker hash table. */
3435 {
3439 /* Allocate the structure if it has not already been allocated by a
3440 subclass. */
3448 /* Call the allocation method of the superclass. */
3453 {
3454 /* Set local fields. */
3456 /* We use -2 as a marker to indicate that the information has
3457 not been set. -1 means there is no associated ifd. */
3464 }
3467 }
3469 /* Create a MIPS ELF linker hash table. */
3474 {
3483 mips_elf_link_hash_newfunc))
3484 {
3487 }
3489 #if 0
3490 /* We no longer use this. */
3493 #endif
3501 }
3503 /* Hook called by the linker routine which adds symbols from an object
3504 file. We must handle the special MIPS section numbers here. */
3506 /*ARGSUSED*/
3507 static boolean
3516 {
3520 {
3521 /* Skip Irix 5 rld entry name. */
3524 }
3527 {
3529 /* Common symbols less than the GP size are automatically
3530 treated as SHN_MIPS_SCOMMON symbols. */
3533 /* Fall through. */
3541 /* This section is used in a shared object. */
3543 {
3544 /* Initialize the section. */
3555 }
3556 /* This code used to do *secp = bfd_und_section_ptr if
3557 info->shared. I don't know why, and that doesn't make sense,
3558 so I took it out. */
3563 /* Fall through. XXX Can we treat this as allocated data? */
3565 /* This section is used in a shared object. */
3567 {
3568 /* Initialize the section. */
3579 }
3580 /* This code used to do *secp = bfd_und_section_ptr if
3581 info->shared. I don't know why, and that doesn't make sense,
3582 so I took it out. */
3589 }
3595 {
3598 /* Mark __rld_obj_head as dynamic. */
3614 }
3616 /* If this is a mips16 text symbol, add 1 to the value to make it
3617 odd. This will cause something like .word SYM to come up with
3618 the right value when it is loaded into the PC. */
3623 }
3625 /* Structure used to pass information to mips_elf_output_extsym. */
3627 struct extsym_info
3628 {
3633 boolean failed;
3634 };
3636 /* This routine is used to write out ECOFF debugging external symbol
3637 information. It is called via mips_elf_link_hash_traverse. The
3638 ECOFF external symbol information must match the ELF external
3639 symbol information. Unfortunately, at this point we don't know
3640 whether a symbol is required by reloc information, so the two
3641 tables may wind up being different. We must sort out the external
3642 symbol information before we can set the final size of the .mdebug
3643 section, and we must set the size of the .mdebug section before we
3644 can relocate any sections, and we can't know which symbols are
3645 required by relocation until we relocate the sections.
3646 Fortunately, it is relatively unlikely that any symbol will be
3647 stripped but required by a reloc. In particular, it can not happen
3648 when generating a final executable. */
3650 static boolean
3653 PTR data;
3654 {
3656 boolean strip;
3672 else
3679 {
3691 {
3694 /* Use undefined class. Also, set class and type for some
3695 special symbols. */
3699 {
3703 }
3705 {
3710 }
3712 {
3716 }
3717 else
3719 }
3723 else
3724 {
3730 /* When making a shared library and symbol h is the one from
3731 the another shared library, OUTPUT_SECTION may be null. */
3734 else
3735 {
3755 else
3757 }
3758 }
3762 }
3768 {
3780 else
3782 }
3784 {
3785 /* Set type and value for a symbol with a function stub. */
3790 else
3791 {
3797 else
3799 }
3802 #endif
3803 }
3808 {
3811 }
3814 }
3816 /* Create a runtime procedure table from the .mdebug section. */
3818 static boolean
3820 PTR handle;
3825 {
3830 PTR rtproc;
3838 PDR pdr;
3839 SYMR sym;
3853 {
3890 {
3904 }
3905 }
3911 {
3914 }
3920 erp++;
3925 {
3929 }
3932 /* Set the size and contents of .rtproc section. */
3936 /* Skip this section later on (I don't think this currently
3937 matters, but someday it might). */
3953 error_return:
3965 }
3967 /* A comparison routine used to sort .gptab entries. */
3969 static int
3973 {
3978 }
3980 /* We need to use a special link routine to handle the .reginfo and
3981 the .mdebug sections. We need to merge all instances of these
3982 sections together, not write them all out sequentially. */
3984 static boolean
3988 {
3994 Elf32_RegInfo reginfo;
4001 /* Drop the .options section, since it has special semantics which I
4002 haven't bothered to figure out. */
4004 {
4006 {
4014 }
4015 }
4017 /* Get a value for the GP register. */
4019 {
4029 {
4030 bfd_vma lo;
4032 /* Make up a value. */
4035 {
4042 }
4044 }
4045 else
4046 {
4047 /* If the relocate_section function needs to do a reloc
4048 involving the GP value, it should make a reloc_dangerous
4049 callback to warn that GP is not defined. */
4050 }
4051 }
4053 /* Go through the sections and collect the .reginfo and .mdebug
4054 information. */
4060 {
4062 {
4065 /* We have found the .reginfo section in the output file.
4066 Look through all the link_orders comprising it and merge
4067 the information together. */
4071 {
4074 Elf32_External_RegInfo ext;
4075 Elf32_RegInfo sub;
4078 {
4082 }
4087 /* The linker emulation code has probably clobbered the
4088 size to be zero bytes. */
4106 /* ri_gp_value is set by the function
4107 mips_elf32_section_processing when the section is
4108 finally written out. */
4110 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4111 elf_link_input_bfd ignores this section. */
4113 }
4115 /* Size has been set in mips_elf_always_size_sections */
4118 /* Skip this section later on (I don't think this currently
4119 matters, but someday it might). */
4123 }
4126 {
4129 /* We have found the .mdebug section in the output file.
4130 Look through all the link_orders comprising it and merge
4131 the information together. */
4133 /* FIXME: What should the version stamp be? */
4148 /* We accumulate the debugging information itself in the
4149 debug_info structure. */
4167 {
4169 EXTR esym;
4170 bfd_vma last;
4189 {
4193 {
4196 }
4197 else
4203 }
4204 }
4209 {
4218 {
4222 }
4230 {
4231 /* I don't know what a non MIPS ELF bfd would be
4232 doing with a .mdebug section, but I don't really
4233 want to deal with it. */
4235 }
4242 /* The ECOFF linking code expects that we have already
4243 read in the debugging information and set up an
4244 ecoff_debug_info structure, so we do that now. */
4254 /* Loop through the external symbols. For each one with
4255 interesting information, try to find the symbol in
4256 the linker global hash table and save the information
4257 for the output external symbols. */
4259 eraw_end = (eraw_src
4265 {
4266 EXTR ext;
4283 {
4287 }
4290 }
4292 /* Free up the information we just read. */
4305 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4306 elf_link_input_bfd ignores this section. */
4308 }
4311 {
4312 /* Create .rtproc section. */
4315 {
4324 }
4329 }
4331 /* Build the external symbol information. */
4338 mips_elf_output_extsym,
4343 /* Set the size of the .mdebug section. */
4346 /* Skip this section later on (I don't think this currently
4347 matters, but someday it might). */
4351 }
4354 {
4361 /* The .gptab.sdata and .gptab.sbss sections hold
4362 information describing how the small data area would
4363 change depending upon the -G switch. These sections
4364 not used in executables files. */
4366 {
4372 {
4376 {
4380 }
4384 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4385 elf_link_input_bfd ignores this section. */
4387 }
4389 /* Skip this section later on (I don't think this
4390 currently matters, but someday it might). */
4393 /* Really remove the section. */
4397 ;
4402 }
4404 /* There is one gptab for initialized data, and one for
4405 uninitialized data. */
4410 else
4411 {
4417 }
4419 /* The linker script always combines .gptab.data and
4420 .gptab.sdata into .gptab.sdata, and likewise for
4421 .gptab.bss and .gptab.sbss. It is possible that there is
4422 no .sdata or .sbss section in the output file, in which
4423 case we must change the name of the output section. */
4426 {
4429 else
4433 }
4435 /* Set up the first entry. */
4443 /* Combine the input sections. */
4447 {
4450 bfd_size_type size;
4452 bfd_size_type gpentry;
4455 {
4459 }
4464 /* Combine the gptab entries for this input section one
4465 by one. We know that the input gptab entries are
4466 sorted by ascending -G value. */
4472 {
4473 Elf32_External_gptab ext_gptab;
4474 Elf32_gptab int_gptab;
4477 boolean exact;
4483 {
4486 }
4495 {
4501 }
4504 {
4508 /* We need a new table entry. */
4513 {
4516 }
4521 /* Merge in the size for the next smallest -G
4522 value, since that will be implied by this new
4523 value. */
4526 {
4532 }
4538 }
4541 }
4543 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4544 elf_link_input_bfd ignores this section. */
4546 }
4548 /* The table must be sorted by -G value. */
4552 /* Swap out the table. */
4556 {
4559 }
4568 /* Skip this section later on (I don't think this currently
4569 matters, but someday it might). */
4571 }
4572 }
4574 /* Invoke the regular ELF backend linker to do all the work. */
4578 /* Now write out the computed sections. */
4581 {
4582 Elf32_External_RegInfo ext;
4588 }
4591 {
4599 }
4602 {
4608 }
4611 {
4617 }
4620 {
4623 {
4629 }
4630 }
4633 }
4635 /* Handle a MIPS ELF HI16 reloc. */
4637 static void
4643 bfd_vma addend;
4644 {
4645 bfd_vma insn;
4646 bfd_vma addlo;
4663 }
4665 /* Handle a MIPS ELF local GOT16 reloc. */
4667 static boolean
4676 bfd_vma addend;
4677 {
4680 bfd_vma insn;
4681 bfd_vma addlo;
4682 bfd_vma address;
4683 bfd_vma hipage;
4699 /* Get a got entry representing requested hipage. */
4709 {
4713 }
4716 {
4718 {
4723 }
4727 }
4734 }
4736 /* Handle MIPS ELF CALL16 reloc and global GOT16 reloc. */
4738 static void
4743 bfd_vma offset;
4744 {
4745 bfd_vma insn;
4751 }
4753 /* Relocate a MIPS ELF section. */
4755 static boolean
4766 {
4772 bfd_vma gp;
4784 else
4789 {
4792 }
4793 else
4794 {
4797 }
4804 {
4808 bfd_vma addend;
4814 bfd_reloc_status_type r;
4823 {
4826 }
4831 else
4841 {
4842 /* We need the .got section. */
4844 {
4850 }
4851 }
4855 /* Mix in the change in GP address for a GP relative reloc. */
4861 else
4862 {
4864 {
4871 /* Only give the error once per link. */
4874 }
4879 {
4880 /* This is a relocation against a section. The current
4881 addend in the instruction is the difference between
4882 INPUT_SECTION->vma and the GP value of INPUT_BFD. We
4883 must change this to be the difference between the
4884 final definition (which will end up in RELOCATION)
4885 and the GP value of OUTPUT_BFD (which is in GP). */
4887 }
4889 {
4890 /* We are doing a final link. The current addend in the
4891 instruction is simply the desired offset into the
4892 symbol (normally zero). We want the instruction to
4893 hold the difference between the final definition of
4894 the symbol (which will end up in RELOCATION) and the
4895 GP value of OUTPUT_BFD (which is in GP). */
4897 }
4898 else
4899 {
4900 /* We are generating relocateable output, and we aren't
4901 going to define this symbol, so we just leave the
4902 instruction alone. */
4904 }
4905 }
4911 {
4912 /* This is a relocateable link. We don't have to change
4913 anything, unless the reloc is against a section symbol,
4914 in which case we have to adjust according to where the
4915 section symbol winds up in the output section. */
4920 else
4921 {
4925 else
4926 {
4929 /* It would be logical to add sym->st_value here,
4930 but Irix 5 sometimes generates a garbage symbol
4931 value. */
4934 /* If this is HI16 or GOT16 with an associated LO16,
4935 adjust the addend accordingly. Otherwise, just
4936 relocate. */
4939 addend,
4943 addend,
4945 else
4946 {
4949 /* As a GNU extension, permit an arbitrary
4950 number of R_MIPS_HI16 relocs before the
4951 R_MIPS_LO16 reloc. This permits gcc to emit
4952 the HI and LO relocs itself. */
4955 else
4956 {
4961 lorel++)
4962 ;
4963 }
4966 {
4970 }
4971 else
4973 addend,
4975 }
4976 }
4977 }
4978 }
4979 else
4980 {
4981 bfd_vma relocation;
4982 boolean local;
4983 boolean undefined_error;
4985 /* This is a final link. */
4991 {
4998 /* It would be logical to always add sym->st_value here,
4999 but Irix 5 sometimes generates a garbage symbol
5000 value. */
5004 /* mips16 text labels should be treated as odd. */
5007 }
5008 else
5009 {
5019 {
5021 {
5028 /* Only give the error once per link. */
5032 }
5033 else
5034 {
5037 relocation = (gp
5041 else
5045 }
5046 }
5049 {
5053 else
5057 }
5063 {
5064 /* If this is a dynamic link, we should have created
5065 a _DYNAMIC_LINK symbol in
5066 mips_elf_create_dynamic_sections. Otherwise, we
5067 should define the symbol with a value of 0.
5068 FIXME: It should probably get into the symbol
5069 table somehow as well. */
5074 }
5075 else
5076 {
5083 }
5084 }
5091 else
5094 /* If this function has an fn_stub, then it is a mips16
5095 function which needs a stub if it is called by a 32 bit
5096 function. If this reloc is anything other than a 16 bit
5097 call, redirect the reloc to the stub. We don't redirect
5098 relocs from other stub functions. */
5111 {
5113 {
5117 }
5118 else
5119 {
5125 }
5127 /* RELOCATION now points to 32 bit code. */
5129 }
5131 /* If this function has a call_stub, then it is called by a
5132 mips16 function; the call needs to go through a stub if
5133 this function is a 32 bit function. If this reloc is a
5134 16 bit call, and the symbol is not a 16 bit function,
5135 then redirect the reloc to the stub. Note that we don't
5136 need to worry about calling the function through a
5137 function pointer; such calls are handled by routing
5138 through a special mips16 routine. We don't have to check
5139 whether this call is from a stub; it can't be, because a
5140 stub contains 32 bit code, and hence can not have a 16
5141 bit reloc. */
5146 {
5149 /* If both call_stub and call_fp_stub are defined, we
5150 can figure out which one to use by seeing which one
5151 appears in the input file. */
5153 {
5158 {
5161 {
5164 }
5165 }
5168 }
5171 else
5176 }
5179 {
5182 /* As a GNU extension, permit an arbitrary number of
5183 R_MIPS_HI16 relocs before the R_MIPS_LO16 reloc.
5184 This permits gcc to emit the HI and LO relocs itself. */
5188 lorel++)
5189 ;
5192 {
5196 }
5197 else
5201 }
5203 {
5204 /* GOT16 must also have an associated LO16 in the local
5205 case. In this case, the addend is extracted and the
5206 section in which the referenced object is determined.
5207 Then the final address of the object is computed and
5208 the GOT entry for the hipage (an aligned 64kb chunk)
5209 is added to .got section if needed. The offset field
5210 of the GOT16-relocated instruction is replaced by the
5211 index of this GOT entry for the hipage. */
5214 {
5217 contents,
5221 }
5222 else
5224 }
5229 {
5230 bfd_vma offset;
5232 /* This symbol must be registered as a global symbol
5233 having the corresponding got entry. */
5244 offset);
5246 }
5249 {
5250 bfd_vma offset;
5252 /* This must be a global symbol with a got entry. The
5253 next reloc must be the corresponding LO16 reloc. */
5269 offset);
5271 }
5274 {
5275 Elf_Internal_Rel outrel;
5276 Elf32_crinfo cptrel;
5285 {
5286 boolean skip;
5288 /* When generating a shared object, these
5289 relocations are copied into the output file to be
5290 resolved at run time. */
5292 {
5295 }
5301 else
5302 {
5303 bfd_vma off;
5305 off = (_bfd_stab_section_offset
5307 input_section,
5313 }
5326 {
5330 }
5331 else
5332 {
5337 else
5338 {
5343 }
5347 {
5350 }
5351 else
5352 {
5359 }
5363 }
5375 {
5379 /* Make an entry of compact relocation info. */
5386 else
5397 }
5399 /* This reloc will be computed at runtime, so
5400 there's no need to do anything now. */
5402 }
5403 else
5407 }
5409 {
5410 bfd_size_type addr;
5413 /* Do a 32 bit relocation, and sign extend to 64 bits. */
5419 addend);
5423 else
5429 }
5431 {
5434 /* This is a jump to a mips16 routine from a mips32
5435 routine. We need to change jal into jalx. */
5439 {
5447 }
5453 }
5455 {
5456 /* It's easiest to do the normal relocation, and then
5457 dig out the instruction and swap the first word the
5458 way the mips16 expects it. If this is little endian,
5459 though, we need to swap the two words first, and then
5460 swap them back again later, so that the address looks
5461 right. */
5464 {
5470 }
5476 {
5480 {
5484 }
5490 /* If this is a jump to a 32 bit routine, then make
5491 it jalx. */
5495 }
5496 }
5498 {
5503 /* Extract the addend into buf, run the regular reloc,
5504 and stuff the resulting value back into the
5505 instructions. */
5508 else
5509 {
5516 buf);
5520 addend);
5531 }
5532 }
5533 else
5538 /* The jal instruction can only jump to an address which is
5539 divisible by 4, and it can only jump to an address with
5540 the same upper 4 bits as the PC. */
5543 {
5544 bfd_vma addr;
5545 bfd_vma pc;
5546 bfd_vma target;
5561 }
5563 /* Don't bother to report a relocation overflow for a call
5564 to a weak undefined symbol with a value of zero. This
5565 permits us to use
5566 if (!f) f();
5567 even if we aren't in range to call address zero. */
5575 /* If we've already issued an error for an undefined symbol,
5576 don't issue another useless error. */
5584 {
5585 Elf32_crinfo cptrel;
5588 /* Make an entry of compact relocation info. */
5595 {
5598 /* XXX How should we set dist2to in this case. */
5623 }
5624 }
5625 }
5628 {
5630 {
5635 {
5640 else
5641 {
5649 }
5654 }
5656 }
5657 }
5658 }
5661 }
5663 /* This hook function is called before the linker writes out a global
5664 symbol. We mark symbols as small common if appropriate. This is
5665 also where we undo the increment of the value for a mips16 symbol. */
5667 /*ARGSIGNORED*/
5668 static boolean
5675 {
5676 /* If we see a common symbol, which implies a relocatable link, then
5677 if a symbol was small common in an input file, mark it as small
5678 common in the output file. */
5688 }
5689 \f
5690 /* Functions for the dynamic linker. */
5692 /* The name of the dynamic interpreter. This is put in the .interp
5693 section. */
5697 /* Create dynamic sections when linking against a dynamic object. */
5699 static boolean
5703 {
5705 flagword flags;
5712 /* Mips ABI requests the .dynamic section to be read only. */
5715 {
5718 }
5720 /* We need to create .got section. */
5724 /* Create .stub section. */
5726 {
5732 }
5737 {
5743 }
5746 {
5748 {
5762 }
5764 /* We need to create a .compact_rel section. */
5768 /* Change aligments of some sections. */
5784 }
5787 {
5803 {
5804 /* __rld_map is a four byte word located in the .data section
5805 and is filled in by the rtld to contain a pointer to
5806 the _r_debug structure. Its symbol value will be set in
5807 mips_elf_finish_dynamic_symbol. */
5824 }
5825 }
5828 }
5830 /* Create the .compact_rel section. */
5832 static boolean
5836 {
5837 flagword flags;
5841 {
5852 }
5855 }
5857 /* Create the .got section to hold the global offset table. */
5859 static boolean
5863 {
5864 flagword flags;
5869 /* This function may be called more than once. */
5882 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
5883 linker script because we don't want to define the symbol if we
5884 are not creating a global offset table. */
5900 /* The first several global offset table entries are reserved. */
5911 {
5916 }
5920 }
5922 /* Look through the relocs for a section during the first phase, and
5923 allocate space in the global offset table. */
5925 static boolean
5931 {
5951 /* Check for the mips16 stub sections. */
5955 {
5958 /* Look at the relocation information to figure out which symbol
5959 this is for. */
5965 {
5968 /* This stub is for a local symbol. This stub will only be
5969 needed if there is some relocation in this BFD, other
5970 than a 16 bit function call, which refers to this symbol. */
5972 {
5976 /* We can ignore stub sections when looking for relocs. */
5987 sec_relocs = (_bfd_elf32_link_read_relocs
6005 }
6008 {
6009 /* There is no non-call reloc for this stub, so we do
6010 not need it. Since this function is called before
6011 the linker maps input sections to output sections, we
6012 can easily discard it by setting the SEC_EXCLUDE
6013 flag. */
6016 }
6018 /* Record this stub in an array of local symbol stubs for
6019 this BFD. */
6021 {
6027 else
6034 }
6038 /* We don't need to set mips16_stubs_seen in this case.
6039 That flag is used to see whether we need to look through
6040 the global symbol table for stubs. We don't need to set
6041 it here, because we just have a local stub. */
6042 }
6043 else
6044 {
6050 /* H is the symbol this stub is for. */
6054 }
6055 }
6058 {
6063 /* Look at the relocation information to figure out which symbol
6064 this is for. */
6070 {
6071 /* This stub was actually built for a static symbol defined
6072 in the same file. We assume that all static symbols in
6073 mips16 code are themselves mips16, so we can simply
6074 discard this stub. Since this function is called before
6075 the linker maps input sections to output sections, we can
6076 easily discard it by setting the SEC_EXCLUDE flag. */
6079 }
6084 /* H is the symbol this stub is for. */
6088 else
6091 /* If we already have an appropriate stub for this function, we
6092 don't need another one, so we can discard this one. Since
6093 this function is called before the linker maps input sections
6094 to output sections, we can easily discard it by setting the
6095 SEC_EXCLUDE flag. We can also discard this section if we
6096 happen to already know that this is a mips16 function; it is
6097 not necessary to check this here, as it is checked later, but
6098 it is slightly faster to check now. */
6100 {
6103 }
6107 }
6110 {
6113 }
6114 else
6115 {
6119 else
6120 {
6124 }
6125 }
6131 {
6139 else
6140 {
6143 /* This may be an indirect symbol created because of a version. */
6145 {
6148 }
6149 }
6151 /* Some relocs require a global offset table. */
6153 {
6155 {
6183 }
6184 }
6187 {
6191 /* This symbol requires a global offset table entry. */
6194 {
6200 }
6202 /* Make sure this symbol is output as a dynamic symbol. */
6204 {
6207 }
6210 {
6211 /* We have already allocated space in the .got. */
6213 }
6215 /* Note the index of the first global got symbol in .dynsym. */
6220 /* Make this symbol to have the corresponding got entry. */
6223 /* We need a stub, not a plt entry for the undefined
6224 function. But we record it as if it needs plt. See
6225 elf_adjust_dynamic_symbol in elflink.h. */
6234 /* This symbol requires a global offset table entry. */
6237 {
6238 /* Make sure this symbol is output as a dynamic symbol. */
6240 {
6243 }
6246 {
6247 /* We have already allocated space in the .got. */
6249 }
6250 /* Note the index of the first global got symbol in
6251 .dynsym. */
6256 /* Make this symbol to be the global got symbol. */
6258 }
6266 {
6268 {
6273 {
6277 (SEC_ALLOC
6278 | SEC_LOAD
6279 | SEC_HAS_CONTENTS
6280 | SEC_IN_MEMORY
6281 | SEC_LINKER_CREATED
6286 }
6287 }
6289 {
6290 /* When creating a shared object, we must copy these
6291 reloc types into the output file as R_MIPS_REL32
6292 relocs. We make room for this reloc in the
6293 .rel.dyn reloc section */
6295 {
6296 /* Add a null element. */
6299 }
6301 }
6302 else
6303 {
6306 /* We only need to copy this reloc if the symbol is
6307 defined in a dynamic object. */
6310 }
6311 }
6328 /* This relocation describes the C++ object vtable hierarchy.
6329 Reconstruct it for later use during GC. */
6335 /* This relocation describes which C++ vtable entries are actually
6336 used. Record for later use during GC. */
6344 }
6346 /* If this reloc is not a 16 bit call, and it has a global
6347 symbol, then we will need the fn_stub if there is one.
6348 References from a stub section do not count. */
6357 {
6362 }
6363 }
6366 }
6368 /* Return the section that should be marked against GC for a given
6369 relocation. */
6378 {
6379 /* ??? Do mips16 stub sections need to be handled special? */
6382 {
6384 {
6391 {
6401 }
6402 }
6403 }
6404 else
6405 {
6410 {
6412 }
6413 }
6416 }
6418 /* Update the got entry reference counts for the section being removed. */
6420 static boolean
6426 {
6427 #if 0
6442 {
6449 /* ??? It would seem that the existing MIPS code does no sort
6450 of reference counting or whatnot on its GOT and PLT entries,
6451 so it is not possible to garbage collect them at this time. */
6456 }
6457 #endif
6460 }
6463 /* Adjust a symbol defined by a dynamic object and referenced by a
6464 regular object. The current definition is in some section of the
6465 dynamic object, but we're not including those sections. We have to
6466 change the definition to something the rest of the link can
6467 understand. */
6469 static boolean
6473 {
6480 /* Make sure we know what is going on here. */
6491 /* If this symbol is defined in a dynamic object, we need to copy
6492 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
6493 file. */
6498 {
6503 {
6504 /* Make room for a null element. */
6507 }
6509 }
6511 /* For a function, create a stub, if needed. */
6514 {
6518 /* If this symbol is not defined in a regular file, then set
6519 the symbol to the stub location. This is required to make
6520 function pointers compare as equal between the normal
6521 executable and the shared library. */
6523 {
6524 /* We need .stub section. */
6531 /* XXX Write this stub address somewhere. */
6534 /* Make room for this stub code. */
6537 /* The last half word of the stub will be filled with the index
6538 of this symbol in .dynsym section. */
6540 }
6541 }
6543 /* If this is a weak symbol, and there is a real definition, the
6544 processor independent code will have arranged for us to see the
6545 real definition first, and we can just use the same value. */
6547 {
6553 }
6555 /* This is a reference to a symbol defined by a dynamic object which
6556 is not a function. */
6559 }
6561 /* This function is called after all the input files have been read,
6562 and the input sections have been assigned to output sections. We
6563 check for any mips16 stub sections that we can discard. */
6565 static boolean mips_elf_check_mips16_stubs
6568 static boolean
6572 {
6575 /* The .reginfo section has a fixed size. */
6585 mips_elf_check_mips16_stubs,
6589 }
6591 /* Check the mips16 stubs for a particular symbol, and see if we can
6592 discard them. */
6594 /*ARGSUSED*/
6595 static boolean
6598 PTR data;
6599 {
6602 {
6603 /* We don't need the fn_stub; the only references to this symbol
6604 are 16 bit calls. Clobber the size to 0 to prevent it from
6605 being included in the link. */
6611 }
6615 {
6616 /* We don't need the call_stub; this is a 16 bit function, so
6617 calls from other 16 bit functions are OK. Clobber the size
6618 to 0 to prevent it from being included in the link. */
6624 }
6628 {
6629 /* We don't need the call_stub; this is a 16 bit function, so
6630 calls from other 16 bit functions are OK. Clobber the size
6631 to 0 to prevent it from being included in the link. */
6637 }
6640 }
6642 /* Set the sizes of the dynamic sections. */
6644 static boolean
6648 {
6651 boolean reltext;
6659 {
6660 /* Set the contents of the .interp section to the interpreter. */
6662 {
6667 }
6668 }
6670 /* Recompute the size of .got for local entires (reserved and
6671 hipages) if needed. To estimate it, get the upper bound of total
6672 size of loadable sections. */
6676 {
6678 bfd_size_type local_gotno;
6687 {
6691 }
6695 /* Assume there are two loadable segments consisting of
6696 contiguous sections. Is 5 enough? */
6700 }
6702 /* The check_relocs and adjust_dynamic_symbol entry points have
6703 determined the sizes of the various dynamic sections. Allocate
6704 memory for them. */
6707 {
6709 boolean strip;
6711 /* It's OK to base decisions on the section name, because none
6712 of the dynobj section names depend upon the input files. */
6721 {
6723 {
6724 /* We only strip the section if the output section name
6725 has the same name. Otherwise, there might be several
6726 input sections for this output section. FIXME: This
6727 code is probably not needed these days anyhow, since
6728 the linker now does not create empty output sections. */
6734 }
6735 else
6736 {
6740 /* If this relocation section applies to a read only
6741 section, then we probably need a DT_TEXTREL entry.
6742 If the relocation section is .rel.dyn, we always
6743 assert a DT_TEXTREL entry rather than testing whether
6744 there exists a relocation to a read only section or
6745 not. */
6755 /* We use the reloc_count field as a counter if we need
6756 to copy relocs into the output file. */
6759 }
6760 }
6762 {
6769 /* Fix the size of .got section for the correspondence of
6770 global symbols and got entries. This adds some useless
6771 got entries. Is this required by ABI really? */
6774 }
6776 {
6777 /* Irix rld assumes that the function stub isn't at the end
6778 of .text section. So put a dummy. XXX */
6780 }
6784 {
6785 /* We add a room for __rld_map. It will be filled in by the
6786 rtld to contain a pointer to the _r_debug structure. */
6788 }
6793 {
6794 /* It's not one of our sections, so don't allocate space. */
6796 }
6799 {
6802 }
6804 /* Allocate memory for the section contents. */
6807 {
6810 }
6812 }
6815 {
6816 /* Add some entries to the .dynamic section. We fill in the
6817 values later, in elf_mips_finish_dynamic_sections, but we
6818 must add the entries now so that we get the correct size for
6819 the .dynamic section. The DT_DEBUG entry is filled in by the
6820 dynamic linker and used by the debugger. */
6822 {
6824 {
6825 /* SGI object has the equivalence of DT_DEBUG in the
6826 DT_MIPS_RLD_MAP entry. */
6829 }
6830 else
6833 }
6836 {
6839 }
6845 {
6854 }
6863 {
6872 }
6880 #if 0
6881 /* Time stamps in executable files are a bad idea. */
6884 #endif
6889 #endif
6894 #endif
6922 #endif
6923 }
6925 /* If we use dynamic linking, we generate a section symbol for each
6926 output section. These are local symbols, which means that they
6927 must come first in the dynamic symbol table.
6928 That means we must increment the dynamic symbol index of every
6929 other dynamic symbol. */
6930 {
6936 {
6937 #if 0
6938 /* We no longer try to restrict the set of sections which get
6939 dynamic symbol table entries, since it fails if we have
6940 other random sections which need dynamic relocations. */
6942 bfd_size_type strindex;
6946 {
6949 mips_elf_adjust_dynindx,
6959 {
6969 }
6970 }
6971 else
6973 {
6976 mips_elf_adjust_dynindx,
6981 {
6983 /* These symbols will have no names, so we don't need to
6984 fiddle with dynstr_index. */
6985 }
6986 }
6987 }
6990 {
6995 /* If there are no global got symbols, fake the last symbol so
6996 for safety. */
6999 else
7001 }
7002 }
7005 }
7007 /* Increment the index of a dynamic symbol by a given amount. Called
7008 via elf_link_hash_traverse. */
7010 static boolean
7013 PTR cparg;
7014 {
7020 }
7022 /* Finish up dynamic symbol handling. We set the contents of various
7023 dynamic sections here. */
7025 static boolean
7031 {
7033 bfd_vma gval;
7042 {
7047 /* This symbol has a stub. Set it up. */
7054 /* Fill the stub. */
7061 /* FIXME: Can h->dynindex be more than 64K? */
7072 /* Mark the symbol as undefined. plt.offset != -1 occurs
7073 only for the referenced symbol. */
7076 /* The run-time linker uses the st_value field of the symbol
7077 to reset the global offset table entry for this external
7078 to its stub address when unlinking a shared object. */
7081 }
7092 {
7093 bfd_size_type offset;
7095 /* This symbol has an entry in the global offset table. Set its
7096 value to the corresponding got entry, if needed. */
7098 {
7103 }
7104 }
7106 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
7112 {
7116 }
7118 {
7120 {
7124 }
7127 {
7132 }
7134 {
7139 }
7141 {
7146 }
7147 }
7151 {
7154 {
7161 }
7164 {
7168 }
7169 }
7171 /* If this is a mips16 symbol, force the value to be even. */
7177 }
7179 /* Finish up the dynamic sections. */
7181 static boolean
7185 {
7198 else
7199 {
7203 }
7206 {
7215 {
7216 Elf_Internal_Dyn dyn;
7224 {
7236 /* Rewrite DT_STRSZ. */
7250 get_vma:
7275 set_elemno:
7278 {
7281 else
7283 }
7284 else
7296 /* XXX FIXME: */
7300 /* XXX FIXME: */
7323 else
7329 #if 0
7331 #else
7333 #endif
7352 }
7353 }
7354 }
7356 /* The first entry of the global offset table will be filled at
7357 runtime. The second entry will be used by some runtime loaders.
7358 This isn't the case of Irix rld. */
7360 {
7363 }
7368 {
7371 Elf_Internal_Sym sym;
7372 Elf32_compact_rel cpt;
7374 /* Set up the section symbols for the output sections. SGI sets
7375 the STT_NOTYPE attribute for these symbols. Should we do so? */
7379 {
7380 #if 0
7384 bfd_vma last;
7387 /* We no longer try to restrict the set of sections which get
7388 dynamic symbol table entries, since it fails if we have
7389 other random sections which need dynamic relocations. */
7391 {
7401 {
7404 {
7408 }
7409 else
7410 {
7412 dindx++;
7413 }
7416 ? SHN_MIPS_TEXT
7426 }
7428 /* Set the sh_info field of the output .dynsym section to
7429 the index of the first global symbol. */
7431 SIZEOF_MIPS_DYNSYM_SECNAMES;
7432 }
7433 else
7435 {
7442 {
7455 }
7457 /* Set the sh_info field of the output .dynsym section to
7458 the index of the first global symbol. */
7461 }
7462 }
7465 {
7466 /* Write .compact_rel section out. */
7469 {
7481 /* Clean up a dummy stub function entry in .text. */
7484 {
7485 file_ptr dummy_offset;
7490 MIPS_FUNCTION_STUB_SIZE);
7491 }
7492 }
7493 }
7495 /* Clean up a first relocation in .rel.dyn. */
7499 }
7502 }
7503 \f
7504 /* This is almost identical to bfd_generic_get_... except that some
7505 MIPS relocations need to be handled specially. Sigh. */
7514 boolean relocateable;
7516 {
7517 /* Get enough memory to hold the stuff */
7532 /* read in the section */
7534 input_section,
7540 /* We're not relaxing the section, so just copy the size info */
7545 input_section,
7546 reloc_vector,
7547 symbols);
7552 {
7554 /* for mips */
7558 {
7561 /* Skip all this stuff if we aren't mixing formats. */
7565 else
7566 {
7569 }
7570 lookup:
7572 {
7574 {
7588 /* @@FIXME ignoring warning for now */
7593 }
7594 }
7595 else
7597 }
7598 /* end mips */
7600 parent++)
7601 {
7603 bfd_reloc_status_type r;
7605 /* Specific to MIPS: Deal with relocation types that require
7606 knowing the gp of the output bfd. */
7609 {
7610 /* The special_function wouldn't get called anyways. */
7611 }
7613 {
7614 /* The gp isn't there; let the special function code
7615 fall over on its own. */
7616 }
7619 {
7620 /* bypass special_function call */
7624 }
7625 /* end mips specific stuff */
7630 input_section,
7633 skip_bfd_perform_relocation:
7636 {
7639 /* A partial link, so keep the relocs */
7642 }
7645 {
7647 {
7672 }
7674 }
7675 }
7676 }
7681 error_return:
7685 }
7686 #define bfd_elf32_bfd_get_relocated_section_contents \
7687 elf32_mips_get_relocated_section_contents
7688 \f
7689 /* ECOFF swapping routines. These are used when dealing with the
7690 .mdebug section, which is in the ECOFF debugging format. */
7692 {
7693 /* Symbol table magic number. */
7694 magicSym,
7695 /* Alignment of debugging information. E.g., 4. */
7697 /* Sizes of external symbolic information. */
7706 /* Functions to swap in external symbolic data. */
7707 ecoff_swap_hdr_in,
7708 ecoff_swap_dnr_in,
7709 ecoff_swap_pdr_in,
7710 ecoff_swap_sym_in,
7711 ecoff_swap_opt_in,
7712 ecoff_swap_fdr_in,
7713 ecoff_swap_rfd_in,
7714 ecoff_swap_ext_in,
7715 _bfd_ecoff_swap_tir_in,
7716 _bfd_ecoff_swap_rndx_in,
7717 /* Functions to swap out external symbolic data. */
7718 ecoff_swap_hdr_out,
7719 ecoff_swap_dnr_out,
7720 ecoff_swap_pdr_out,
7721 ecoff_swap_sym_out,
7722 ecoff_swap_opt_out,
7723 ecoff_swap_fdr_out,
7724 ecoff_swap_rfd_out,
7725 ecoff_swap_ext_out,
7726 _bfd_ecoff_swap_tir_out,
7727 _bfd_ecoff_swap_rndx_out,
7728 /* Function to read in symbolic data. */
7729 _bfd_mips_elf_read_ecoff_info
7730 };
7731 \f
7732 #define TARGET_LITTLE_SYM bfd_elf32_littlemips_vec
7734 #define TARGET_BIG_SYM bfd_elf32_bigmips_vec
7736 #define ELF_ARCH bfd_arch_mips
7737 #define ELF_MACHINE_CODE EM_MIPS
7739 /* The SVR4 MIPS ABI says that this should be 0x10000, but Irix 5 uses
7740 a value of 0x1000, and we are compatible. */
7741 #define ELF_MAXPAGESIZE 0x1000
7743 #define elf_backend_collect true
7744 #define elf_backend_type_change_ok true
7745 #define elf_backend_can_gc_sections true
7746 #define elf_info_to_howto 0
7747 #define elf_info_to_howto_rel mips_info_to_howto_rel
7748 #define elf_backend_sym_is_global mips_elf_sym_is_global
7749 #define elf_backend_object_p mips_elf32_object_p
7750 #define elf_backend_section_from_shdr mips_elf32_section_from_shdr
7751 #define elf_backend_fake_sections _bfd_mips_elf_fake_sections
7752 #define elf_backend_section_from_bfd_section \
7753 _bfd_mips_elf_section_from_bfd_section
7754 #define elf_backend_section_processing mips_elf32_section_processing
7755 #define elf_backend_symbol_processing _bfd_mips_elf_symbol_processing
7756 #define elf_backend_additional_program_headers \
7757 mips_elf_additional_program_headers
7758 #define elf_backend_modify_segment_map mips_elf_modify_segment_map
7759 #define elf_backend_final_write_processing \
7760 _bfd_mips_elf_final_write_processing
7761 #define elf_backend_ecoff_debug_swap &mips_elf32_ecoff_debug_swap
7763 #define bfd_elf32_bfd_is_local_label_name \
7764 mips_elf_is_local_label_name
7765 #define bfd_elf32_find_nearest_line _bfd_mips_elf_find_nearest_line
7766 #define bfd_elf32_set_section_contents _bfd_mips_elf_set_section_contents
7767 #define bfd_elf32_bfd_link_hash_table_create \
7768 mips_elf_link_hash_table_create
7769 #define bfd_elf32_bfd_final_link mips_elf_final_link
7770 #define bfd_elf32_bfd_copy_private_bfd_data \
7771 _bfd_mips_elf_copy_private_bfd_data
7772 #define bfd_elf32_bfd_merge_private_bfd_data \
7773 _bfd_mips_elf_merge_private_bfd_data
7774 #define bfd_elf32_bfd_set_private_flags _bfd_mips_elf_set_private_flags
7775 #define bfd_elf32_bfd_print_private_bfd_data \
7776 _bfd_mips_elf_print_private_bfd_data
7777 #define elf_backend_add_symbol_hook mips_elf_add_symbol_hook
7778 #define elf_backend_create_dynamic_sections \
7779 mips_elf_create_dynamic_sections
7780 #define elf_backend_check_relocs mips_elf_check_relocs
7781 #define elf_backend_adjust_dynamic_symbol \
7782 mips_elf_adjust_dynamic_symbol
7783 #define elf_backend_always_size_sections \
7784 mips_elf_always_size_sections
7785 #define elf_backend_size_dynamic_sections \
7786 mips_elf_size_dynamic_sections
7787 #define elf_backend_relocate_section mips_elf_relocate_section
7788 #define elf_backend_link_output_symbol_hook \
7789 mips_elf_link_output_symbol_hook
7790 #define elf_backend_finish_dynamic_symbol \
7791 mips_elf_finish_dynamic_symbol
7792 #define elf_backend_finish_dynamic_sections \
7793 mips_elf_finish_dynamic_sections
7794 #define elf_backend_gc_mark_hook mips_elf_gc_mark_hook
7795 #define elf_backend_gc_sweep_hook mips_elf_gc_sweep_hook
7797 #define elf_backend_got_header_size (4*MIPS_RESERVED_GOTNO)
7798 #define elf_backend_plt_header_size 0